CODEWITHSUNDEEP
c#.net
PrateekSaluja
PrateekSaluja

Reputation: 14946

what is the max limit of data into list<string> in c#?

How many values I can add to List?

For example:

List<string> Item = runtime data

The data is not fixed in size. It may be 10 000 or more than 1 000 000. I have Googled but have not found an exact answer.

Upvotes: 64

Views: 84527

Answers (5)

8vtwo
8vtwo

Reputation: 66

You can get around this limit easily with a List<char[]>.

Upvotes: -3

phougatv
phougatv

Reputation: 1024

As per the implementation of List

private void EnsureCapacity(int min) {
    if (_items.Length < min) {
        int newCapacity = _items.Length == 0? _defaultCapacity : _items.Length * 2;
        // Allow the list to grow to maximum possible capacity (~2G elements) before encountering overflow.
        // Note that this check works even when _items.Length overflowed thanks to the (uint) cast
        if ((uint)newCapacity > Array.MaxArrayLength) newCapacity = Array.MaxArrayLength;
            if (newCapacity < min) newCapacity = min;
                Capacity = newCapacity;
        }
    }

Now upon navigating to this Array.MaxArrayLength:

internal const int MaxArrayLength = 2146435071;

Upvotes: 1

TalentTuner
TalentTuner

Reputation: 17566

list.Count() property is int32, so it must be the maxium limit of int32 but how your list performs over this limit is a nice observation.

if you do some list manupulation operations, it would be linier in theory.

i would say if your are having very large number of items thnink about the Parallel Collections in .net 4.0 this would make your list operations more responsive.

Upvotes: 4

LukeH
LukeH

Reputation: 269668

The maximum number of elements that can be stored in the current implementation of List<T> is, theoretically, Int32.MaxValue - just over 2 billion.

In the current Microsoft implementation of the CLR there's a 2GB maximum object size limit. (It's possible that other implementations, for example Mono, don't have this restriction.)

Your particular list contains strings, which are reference types. The size of a reference will be 4 or 8 bytes, depending on whether you're running on a 32-bit or 64-bit system. This means that the practical limit to the number of strings you could store will be roughly 536 million on 32-bit or 268 million on 64-bit.

In practice, you'll most likely run out of allocable memory before you reach those limits, especially if you're running on a 32-bit system.

Upvotes: 94

Floyd
Floyd

Reputation: 1918

2147483647 because all functions off List are using int.

Source from mscorlib:

private T[] _items;
private int _size;

public T this[int index]
{
  get
    {
      //...
    }
}

Upvotes: 13

Related Questions