Quene — From Old English cwen "woman, wife, queen," or cwene "woman, wife, prostitute".

А>        static void TestLinkedList()
А>        {
А>            var queue = new LinkedList<object>();
А>            int cnt = 0;

А>            var sw = new System.Diagnostics.Stopwatch();
А>            sw.Start();
А>            for (int i = 0; i < 30000; i++)
А>            {
А>                queue.AddFirst(new object());
А>                if (queue.Count > 10000)
А>                    queue.RemoveLast();

А>                cnt += queue.ToArray().Count();
А>            }

А>            sw.Stop();

А>            Console.WriteLine(cnt);
А>            Console.WriteLine("LinkedList Time:" + sw.Elapsed);

А>        }
А>    }

cnt += queue.ToArray().Count();

А>                cnt += quene.ToArray().Reverse().Count();
А>

var array = quene.ToArray();
Array.Reverse(array);
cnt += array.Count();

250005000
Quene Time:00:00:00.6969832
250005000
List Time:00:00:00.7490250

    /// <summary>
    /// Очередь с ограничением по кол-ву элементов
    /// </summary>
    /// <typeparam name="T"></typeparam>
    internal sealed class LimitedQueue<T> : Queue<T>
    {
        /// <summary>
        /// Максимальная емкость очереди
        /// </summary>
        private int MaxCapacity;

        /// <summary>
        /// Конструктор только такой
        /// </summary>
        /// <param name="_MaxCapacity">максимальное кол-во элементов в очереди</param>
        public LimitedQueue(int _MaxCapacity)
            : base(_MaxCapacity)
        {
            this.MaxCapacity = _MaxCapacity;
        }

        /// <summary>
        /// Заменяем базовую реализацию. Если очередь заполнена, то удаляем первый в ней элемент
        /// </summary>
        /// <param name="_item"></param>
        public new void Enqueue(T _item)
        {
            if( base.Count == this.MaxCapacity )
                base.Dequeue();

            base.Enqueue(_item);
        }
    }

   class Program
    {
        static Queue<int> q;
        static object syncObj = new object();

        static void ShowLast5()
        {

                while (true)
                {
                    // это блокирока чтоб 2 потока по очереди показывали результат 5 сек кажды
                    lock( syncObj )
                    {
                        Console.Clear();
                        Console.WriteLine(string.Format("Last 5 Records from Thread {0}: ", System.Threading.Thread.CurrentThread.ManagedThreadId));
                        foreach (var i in q)
                            Console.WriteLine(i);

                        System.Threading.Thread.Sleep(5000);
                    }                
                }
        }

        static int newitem;
        static void Generate()
        {
            while (true)
            {
                q.Enqueue(newitem);
                newitem++;
                System.Threading.Thread.Sleep(15000);
            }

        }


        static void Main(string[] args)
        {
            
            q = new Queue<int>(5);
            q.Enqueue(1);
            q.Enqueue(2);
            q.Enqueue(3);
            q.Enqueue(4);
            q.Enqueue(5);

            newitem = 6;

            var t1 = new System.Threading.Thread(Generate);
            t1.Start();

            var t2 = new System.Threading.Thread(ShowLast5);
            t2.Start();
            var t3 = new System.Threading.Thread(ShowLast5);
            t3.Start();

            Console.ReadKey();
        }
    }

А>>   class Program
А>>    {
А>>    }
А>>

public class MyQuene
{

    private Dictionary<int, MeasureData> quene;
    private int currentItem = 0;
    private int queneCapacity = 10000;

    public PushNewMeasure( p1, p2, p3 )
    {
        if ( currentItem >= queneCapacity )
        {
           currentItem=0;
        }

        quene[ currentItem ] = new MeasureData( p1, p2, p3 );
        currentItem++;
    }

    public MeasureData[] GetMeasures()
    {       
        return
        quene.Skip( currentItem ).Take( queneCapacity - currentItem).
          Union( quene.Take( currentItem ) )
          .Select ( i => i.Value).Reverse().ToArray();
    }
}

        if ( currentItem >= queneCapacity )
        {
           currentItem=0;
        }

        quene[ currentItem ] = new MeasureData( p1, p2, p3 );
        currentItem++;

А>>Вот блин. Оказывается он ничуть не тормозной

list.Insert(0, .. );
if ( list.Count > Capacity )
   list.Remove( Capacity );

/// чтоб копию создать
return list.ToArray();

    class Program
    {


        static void TestQuene()
        {
            var quene = new Queue<int>();
            int cnt = 0;

            var sw = new System.Diagnostics.Stopwatch();
            sw.Start();
            for (int i = 0; i < 30000; i++)
            {
                quene.Enqueue(i);
                if (quene.Count > 10000)
                    quene.Dequeue();

                cnt += quene.ToArray().Reverse().Count();
            }

            sw.Stop();

            Console.WriteLine(cnt);
            Console.WriteLine("Quene Time:" + sw.Elapsed);

        }

        static void TestList()
        {
            var quene = new List<int>();
            int cnt = 0;

            var sw = new System.Diagnostics.Stopwatch();
            sw.Start();
            for (int i = 0; i < 30000; i++)
            {
                quene.Insert(0, 99999999);
                if (quene.Count > 10000)
                    quene.RemoveAt(10000);

                cnt += quene.ToArray().Count();
            }

            sw.Stop();

            Console.WriteLine(cnt);
            Console.WriteLine("List Time:" + sw.Elapsed);

        }


        static void Main(string[] args)
        {
            TestQuene();
            TestList();
            Console.ReadKey();
        }
    }

   class Program
    {


        static void Testqueue()
        {
            var queue = new Queue<object>();
            int cnt = 0;

            var sw = new System.Diagnostics.Stopwatch();
            sw.Start();
            for (int i = 0; i < 30000; i++)
            {
                queue.Enqueue(new object());
                if (queue.Count > 10000)
                    queue.Dequeue();

                var array = queue.ToArray();
                Array.Reverse(array);
                cnt += array.Length;
            }

            sw.Stop();

            Console.WriteLine(cnt);
            Console.WriteLine("Queue Time:" + sw.Elapsed);

        }

        static void TestList()
        {
            var queue = new List<object>();
            int cnt = 0;

            var sw = new System.Diagnostics.Stopwatch();
            sw.Start();
            for (int i = 0; i < 30000; i++)
            {
                queue.Insert(0, new object());
                if (queue.Count > 10000)
                    queue.RemoveAt(10000);

                cnt += queue.ToArray().Count();
            }

            sw.Stop();

            Console.WriteLine(cnt);
            Console.WriteLine("List Time:" + sw.Elapsed);

        }


        static void TestLinkedList()
        {
            var queue = new LinkedList<object>();
            int cnt = 0;

            var sw = new System.Diagnostics.Stopwatch();
            sw.Start();
            for (int i = 0; i < 30000; i++)
            {
                queue.AddFirst(new object());
                if (queue.Count > 10000)
                    queue.RemoveLast();

                cnt += queue.ToArray().Count();
            }

            sw.Stop();

            Console.WriteLine(cnt);
            Console.WriteLine("LinkedList Time:" + sw.Elapsed);

        }

        static void Main(string[] args)
        {
            Testqueue();
            TestList();
            TestLinkedList();
            Console.ReadKey();
        }
    }

    class LimitedQueue 
    {
        object[] m_elements;
        int m_indexPosition;

        public LimitedQueue(int _capacity)
        {
            Capacity = _capacity;
            m_elements = new object[Capacity];
            m_indexPosition = 0;
            Count = 0;
        }

        public void Add(object _element)
        {
            m_elements[m_indexPosition] = _element;
            m_indexPosition++;
            if (m_indexPosition == Capacity)
                m_indexPosition = 0;
            if (Count != Capacity)
                Count++;
        }

        public object this[int _index]
        {
            get
            {
                if (_index >= Count || _index < 0)
                    throw new IndexOutOfRangeException();
                int indexPositionToArray;
                indexPositionToArray = (m_indexPosition + _index) % Capacity;
                return m_elements[indexPositionToArray];
            }
        }

        public int Capacity
        {
            get;
            private set;
        }

        public int Count
        {
            get;
            private set;
        }
    }