Add another item in array without built-in functions

Question

The following script is working fine. But need to add one more item in array without built-in function. Is it possible to do without Resize() ?

string[] data = {"item-1", "item-2"};
Array.Resize(ref data, 3);
data[2] = "item-3";
foreach(string i in data) {
  Console.WriteLine(i);
}

Answer 1

No. Arrays are fixed size, so the only way to add more stuff to them is to resize them.

If you have a scenario where you need to add a dynamic number of elements, use List<T> instead.

Answer 2

Assuming you're trying to increase the size of an array without any built-in libraries or data structures, you just need to create a new larger array, copy the old elements, then add your new element.

string[] data = {"item-1", "item-2"};
string[] newData = new string[data.Length + 1];

int i;
for (i = 0; i < data.Length; i++) {
    newData[i] = data[i];
}
newData[i] = "item-3";
Console.WriteLine(newData[2]);

Answer 3

The short answer is no. But if you want you can always implement a logic that does the resizing. You could do something like this implementation of a List:

public class List<T> : IAbstractList<T>
{
    private const int DEFAULT_CAPACITY = 4;
    private T[] _items;

    public List()
        : this(DEFAULT_CAPACITY) {
    }

    public List(int capacity)
    {
        if (capacity < 0)
        {
            throw new ArgumentOutOfRangeException(nameof(capacity));
        }

        this._items = new T[capacity];
    }

    public T this[int index]
    {
        get
        {
            this.ValidateIndex(index);
            return this._items[index];
        }
        set
        {
            this.ValidateIndex(index);
            this._items[index] = value;
        }
    }

    public int Count { get; private set; }

    public void Add(T item)
    {
        this.GrowIfNecessary();

        this._items[this.Count++] = item;
    }

    public bool Contains(T item)
    {
        for (int i = 0; i < this.Count; i++)
        {
            if (this._items[i].Equals(item))
            {
                return true;
            }
        }

        return false;
    }

    public int IndexOf(T item)
    {
        for (int i = 0; i < this.Count; i++)
        {
            if (this._items[i].Equals(item))
            {
                return i;
            }
        }

        return -1;
    }

    public void Insert(int index, T item)
    {
        this.ValidateIndex(index);
        this.GrowIfNecessary();

        for (int i = this.Count - 1; i > index; i--)
        {
            this._items[i] = this._items[i - 1];
        }

        this._items[index] = item;
        this.Count++;
    }

    public bool Remove(T item)
    {
        var index = this.IndexOf(item);
        if (index == - 1)
        {
            return false;
        }

        this.RemoveAt(index);
        return true;
    }

    public void RemoveAt(int index)
    {
        this.ValidateIndex(index);
        for(int i = index; i < this.Count - 1; i++)
        {
            this._items[i] = this._items[i + 1];
        }

        this._items[this.Count - 1] = default;
        this.Count--;
    }

    public IEnumerator<T> GetEnumerator()
    {
        for (int i = 0; i < this.Count; i++)
        {
            yield return this._items[i];
        }
    }

    IEnumerator IEnumerable.GetEnumerator()
        => this.GetEnumerator();

    private void ValidateIndex(int index)
    {
        if (index < 0 || index >= this.Count)
        {
            throw new IndexOutOfRangeException(nameof(index));
        }
    }

    private void GrowIfNecessary()
    {
        if (this.Count == this._items.Length)
        {
            var array = new T[this.Count * 2];
            Array.Copy(this._items, array, this._items.Length);

            this._items = array;
        }
    }
}

The above sample code can give you ideas about implementing other methods that need array resizing as well.