在C＃中插入内部列表

Question

I am initializing my list as below -

 List<string> lFiles = new List<string>(12);

and now I want to add/insert my string at specific index.

like I am using below -

 lFiles.Insert(6,"File.log.6");

it it throwing excepton as - "Index must be within the bounds of the List."

While initializing I have declared capacity of List but still I am not able insert strings at random indexes.

Anybody knows what I am missing??

Answer 1

The constructor that takes an int32 as parameter doesn't add items to the list, it just pre-allocates some capacity for better performances (this is implementation details). In your case, your list is still empty.

Answer 2

You are initializing the capacity of the list (basically setting the initial size of the internal array for performance purposes), but it does not actually add any elements to the list.

The easiest way to check this is try this:

var list1 = new List<int>();
var list2 = new List<int>(12);
Console.WriteLine(list1.Count);  //output is 0
Console.WriteLine(list2.Count);  //output is 0

This shows that you still don't have any elements in your list.

In order to initialize populate the array with default or blank elements, you need to actually put something into the list.

int count = 12;
int value = 0
List<T> list = new List<T>(count);
list.AddRange(Enumerable.Repeat(value, count));

Answer 3

There is small confusion with list. When you provide some capacity for constructor, it creates internal array of provided size and fills it with default values of T :

public List(int capacity)
{
    if (capacity < 0)
       throw new ArgumentException();

    if (capacity == 0)        
        this._items = List<T>._emptyArray;        
    else        
        this._items = new T[capacity];        
}

But list does not treat that default values as items added to list. Yep, that is confusing a little. Memory is allocated for array, but count of items in list still will be zero. You can check it:

List<string> lFiles = new List<string>(12);
Console.WriteLine(lFiles.Count); // 0
Console.WriteLine(lFiles.Capacity); // 12

Count does not returns size of internal data structure, it returns 'logical' size of list (ie number of items which was added and not removed):

public int Count
{  
    get { return this._size; }
}

And size is changed only when you add or remove items to list. Eg

public void Add(T item)
{
    if (this._size == this._items.Length)    
        this.EnsureCapacity(this._size + 1); // resize items array

    this._items[this._size++] = item; // change size
    this._version++;
}

When you are inserting some item at specific index, list does not checks if enough space allocated for items array (well it checks, but just for resizing inner array if current capacity is not enough). List verifies that there is enough items already contained in list (ie added, but not removed):

public void Insert(int index, T item)
{
    if (index > this._size) // here you get an exception, because size is zero
       throw new ArgumentOutOfRangeException();

    if (this._size == this._items.Length)    
        this.EnsureCapacity(this._size + 1); // resize items

    if (index < this._size)    
        Array.Copy(_items, index, this._items, index + 1, this._size - index);

    this._items[index] = item;
    this._size++;
    this._version++;
}

Answer 4

The capacity is just a hint how many elements to expect. There are still no elements in your list.

Answer 5

I think you might want to use a new Dictionary<int, string>() , not a list.

That will let you use the int as a key to set and look up values by:

Otherwise, if you want to use position-based "list", you should just use an string-array instead (but note that that will not let you adjust the size automatically):

var arr = new string[12];
arr[6] = "string at position 6";