C# - finite list or limited list?

Question

I am wondering about a certain functionality in C#...

I would like to have a List<Object> MyList();, which I could .Add(new Object()) finite amount of times. Let's say I added 5 items, and if I would add sixth, then the last item would be destroyed, and this sixth element would be put on top of the list.

Is there any built-in mechanism in c# that does that?

Answer 1

There is no build-in collection in Framework as Servy said. However, you can make a CircularBuffer like this -

namespace DataStructures
{
    class Program
    {
        static void Main(string[] args)
        {
            var buffer = new CircularBuffer<int>(capacity: 3);

            while (true)
            {
                int value;
                var input = Console.ReadLine();

                if (int.TryParse(input, out value))
                {
                    buffer.Write(value);
                    continue;
                }
                break;
            }

            Console.WriteLine("Buffer: ");
            while (!buffer.IsEmpty)
            {
                Console.WriteLine(buffer.Read());
            }
            Console.ReadLine();
        }
    }
}

namespace DataStructures
{
    public class CircularBuffer<T>
    {
        private T[] _buffer;
        private int _start;
        private int _end;

        public CircularBuffer()
            : this(capacity: 3)
        {
        }

        public CircularBuffer(int capacity)
        {
            _buffer = new T[capacity + 1];
            _start = 0;
            _end = 0;
        }

        public void Write(T value)
        {
            _buffer[_end] = value;
            _end = (_end + 1) % _buffer.Length;
            if (_end == _start)
            {
                _start = (_start + 1) % _buffer.Length;
            }
        }

        public T Read()
        {
            T result = _buffer[_start];
            _start = (_start + 1) % _buffer.Length;
            return result;
        }

        public int Capacity
        {
            get { return _buffer.Length; }
        }

        public bool IsEmpty
        {
            get { return _end == _start; }
        }

        public bool IsFull
        {
            get { return (_end + 1) % _buffer.Length == _start; }
        }
    }
}

Above code is from PluralSight - Scott Allen's C# Generics.

Answer 2

In my core library, I have something called a LimitedQueue<T>. This is probably similar to what you're after (you could easily modify it to be a List<T> instead). (Source on GitHub)

using System.Collections.Generic;

namespace Molten.Core
{
    /// <summary>
    /// Represents a limited set of first-in, first-out objects.
    /// </summary>
    /// <typeparam name="T">The type of each object to store.</typeparam>
    public class LimitedQueue<T> : Queue<T>
    {
        /// <summary>
        /// Stores the local limit instance.
        /// </summary>
        private int limit = -1;

        /// <summary>
        /// Sets the limit of this LimitedQueue. If the new limit is greater than the count of items in the queue, the queue will be trimmed.
        /// </summary>
        public int Limit
        {
            get
            {
                return limit;
            }
            set
            {
                limit = value;
                while (Count > limit)
                {
                    Dequeue();
                }
            }
        }

        /// <summary>
        /// Initializes a new instance of the LimitedQueue class.
        /// </summary>
        /// <param name="limit">The maximum number of items to store.</param>
        public LimitedQueue(int limit)
            : base(limit)
        {
            this.Limit = limit;
        }

        /// <summary>
        /// Adds a new item to the queue. After adding the item, if the count of items is greater than the limit, the first item in the queue is removed.
        /// </summary>
        /// <param name="item">The item to add.</param>
        public new void Enqueue(T item)
        {
            while (Count >= limit)
            {
                Dequeue();
            }
            base.Enqueue(item);
        }
    }
}

---

You would use it like this:

LimitedQueue<int> numbers = new LimitedQueue<int>(5);
numbers.Enqueue(1);
numbers.Enqueue(2);
numbers.Enqueue(3);
numbers.Enqueue(4);
numbers.Enqueue(5);
numbers.Enqueue(6); // This will remove "1" from the list
// Here, "numbers" contains 2, 3, 4, 5, 6 (but not 1).

Answer 3

None of the built in collections will do this, but you can easily make your own class that has an internal list that has this behavior when adding an item. It's not particularly difficult, but writing out all of the methods that a standard list would use and implementing all of the interfaces List does could be a bit tedious.

Answer 4

You can use a Queue with a fixed size. Just call .ToList() afterwards.

Fixed size queue which automatically dequeues old values upon new enques