CODEWITHSUNDEEP
c#arrays
DNR
DNR

Reputation: 3746

What is the Maximum Size that an Array can hold?

In C# 2008, what is the Maximum Size that an Array can hold?

Upvotes: 49

Views: 139415

Answers (7)

Kuba Szostak
Kuba Szostak

Reputation: 472

By default the .NET Framework runtime (CLR) has the maximum object size allowed in the GC Heap at 2GB, even on the 64-bit version of the runtime. Since arrays are just a special kind of managed type which are created within the managed heap they also suffer from this limitation. Since .NET 4.5 you can change application configuration file to enable arrays that are greater than 2GB.

Since .NET Core 2.0 arrays greater than 2GB are enabled by default.

Note that the array has also MaxLength limit which equals to 2147483591. This means you will be able to allocate 8GB of double, but not 8GB of byte.

var arr = new double[1000000000];     // OK
var bytes = new byte[1000000000 * 8]; // Error

Upvotes: 0

Anton K
Anton K

Reputation: 4808

This answer is about .NET 4.5

According to MSDN, the index for array of bytes cannot be greater than 2147483591. For .NET prior to 4.5 it also was a memory limit for an array. In .NET 4.5 this maximum is the same, but for other types it can be up to 2146435071.

This is the code for illustration:

    static void Main(string[] args)
    {
        // -----------------------------------------------
        // Pre .NET 4.5 or gcAllowVeryLargeObjects unset
        const int twoGig = 2147483591; // magic number from .NET

        var type = typeof(int);          // type to use
        var size = Marshal.SizeOf(type); // type size
        var num = twoGig / size;         // max element count

        var arr20 = Array.CreateInstance(type, num);
        var arr21 = new byte[num];

        // -----------------------------------------------
        // .NET 4.5 with x64 and gcAllowVeryLargeObjects set
        var arr451 = new byte[2147483591];
        var arr452 = Array.CreateInstance(typeof(int), 2146435071);
        var arr453 = new byte[2146435071]; // another magic number

        return;
    }

Upvotes: 14

Sai
Sai

Reputation: 1394

Per MSDN it is

By default, the maximum size of an Array is 2 gigabytes (GB).

In a 64-bit environment, you can avoid the size restriction by setting the enabled attribute of the gcAllowVeryLargeObjects configuration element to true in the run-time environment.

However, the array will still be limited to a total of 4 billion elements.

Refer Here http://msdn.microsoft.com/en-us/library/System.Array(v=vs.110).aspx

Note: Here I am focusing on the actual length of array by assuming that we will have enough hardware RAM.

Upvotes: 23

Peter Lee
Peter Lee

Reputation: 1071

I think if you don't consider the VM, it is Integer.MaxValue

Upvotes: 0

Matthew Scharley
Matthew Scharley

Reputation: 132394

System.Int32.MaxValue

Assuming you mean System.Array, ie. any normally defined array (int[], etc). This is the maximum number of values the array can hold. The size of each value is only limited by the amount of memory or virtual memory available to hold them.

This limit is enforced because System.Array uses an Int32 as it's indexer, hence only valid values for an Int32 can be used. On top of this, only positive values (ie, >= 0) may be used. This means the absolute maximum upper bound on the size of an array is the absolute maximum upper bound on values for an Int32, which is available in Int32.MaxValue and is equivalent to 2^31, or roughly 2 billion.

On a completely different note, if you're worrying about this, it's likely you're using alot of data, either correctly or incorrectly. In this case, I'd look into using a List<T> instead of an array, so that you are only using as much memory as needed. Infact, I'd recommend using a List<T> or another of the generic collection types all the time. This means that only as much memory as you are actually using will be allocated, but you can use it like you would a normal array.

The other collection of note is Dictionary<int, T> which you can use like a normal array too, but will only be populated sparsely. For instance, in the following code, only one element will be created, instead of the 1000 that an array would create:

Dictionary<int, string> foo = new Dictionary<int, string>();
foo[1000] = "Hello world!";
Console.WriteLine(foo[1000]);

Using Dictionary also lets you control the type of the indexer, and allows you to use negative values. For the absolute maximal sized sparse array you could use a Dictionary<ulong, T>, which will provide more potential elements than you could possible think about.

Upvotes: 55

James Black
James Black

Reputation: 41858

Here is an answer to your question that goes into detail: http://www.velocityreviews.com/forums/t372598-maximum-size-of-byte-array.html

You may want to mention which version of .NET you are using and your memory size.

You will be stuck to a 2G, for your application, limit though, so it depends on what is in your array.

Upvotes: 4

waqasahmed
waqasahmed

Reputation: 3835

I think it is linked with your RAM (or probably virtual memory) space and for the absolute maximum constrained to your OS version (e.g. 32 bit or 64 bit)

Upvotes: 0

Related Questions