There are numerous new features coming with .NET 4.5 and here, on this blog, you can find several posts about it. But the feature we are goint to talk about today is very exciting, because we were waiting for it more than 10 years. Since .NET 1.0 the memory limit of .NET object is 2GB. This means you cannot for example create array which contains elements with more than 2GB in total. If try to create such array, you will get the OutOfMemoryException.
Let’s see an example how to produce OutOfMemoryException.
Before that Open Visual Studio 2012, and create C# Console Application, like picture below.
First lets create simple struct with two double members like example below:
public struct ComplexNumber
{
public double Re;
public double Im;
public ComplexNumber(double re,double im)
{
Re=re;
Im=im;
}
}
As we know this structure consumes about 16 bytes of memory. So if we want to create array of this type which consume more than 2GB we need to create array at least with 134217728 instances. So this sample program below creates 130000000 (about 1,97 GB) of array.
int maxCount = 130000000;
ComplexNumber[] arr=null;
try
{
arr = new ComplexNumber[maxCount];
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
So if we run this sample program the output will be like picture below:
Let’s try to create 140000000 instances. This is about 2.08 GB. The output produces exception:
The new feature of .NET 4.5 allows to create object beyond this magical number. To enable creation of object more than 2 GB, you only need to set proper variable in configuration file. The new gcAllowVeryLargeObjects
Element enables creation of array that are greater than 2 gigabytes (GB) in total size on 64 bit platform. So the following configuration file allows us to create more that 140000000 instances of our sample.
Now,If we run our sample the output is:
Ok how about to create more than 3GB of instances. For that propose, we need to create at least 201326592 instances. If we include this number in our sample the output is:
Be careful with this feature, because it will suck all your computer memory.
This feature works only with 64bit OS, it will not work with 32 bit.
Before you use this feature please see official description, because it contains some limitation which you must know before you use.
Complete source code for this blog post can be downloaded from here.
Happy coding with .NET4.5
Pingback: With .NET 4.5, 10 years memory limit of 2 GB is over - C# & .NET technologies - developers.de
in framework 4.5 which is the maximum limit of memory? I downloaded your example and made the following modification.
//int maxCount = 201326592;
long maxCount = 999999999;
long[] arr=null;
try
{
arr = new long[maxCount];
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
Result :14,9 GB
But but when I write
long maxCount = 1999999999;
An unhandled exception of type ‘System.NullReferenceException’ occurred in LargeArrays.exe.
depends on the memory RAM in my computer?
I think so.
Can you link the source code again? It has been removed from your onedrive account.
Pingback: Handling large objects in .net ( C# ) | Justin
Very useful post. Have you tested this on PC with at least 64 GB of RAM?
Where is sample code…
Please try again. I have fixed the broken link.
hi.
I have a question.
The Setting is for C#,
Do you know how to set visual studio C++?
Pretty part of content. I simply stumbled upon your web site and in accession capital to say that I acquire in fact enjoyed account your weblog posts. Any way I’ll be subscribing for your feeds or even I success you get entry to persistently fast.
// copy paste the following in to a console project and execute.
using System;
namespace TomHumphrey.MemoryCheck
{
public class MemoryLimit
{
public static void Main(string[] args)
{
Console.WriteLine(“THIS PROGRAM TESTS CREATION OF ARRAYS THAT EXCEED 2GB LIMIT”);
Console.WriteLine(“Each item in array is 16 bytes.”);
int maxCount = 130000000;
Console.WriteLine(“First we test ” + maxCount + ” instances with total memory 1.94GB – it should succeed.”);
InstanceBigArray(maxCount);
maxCount = 140000000;
Console.WriteLine();
Console.WriteLine(“Second we test ” + maxCount + ” instances with total memory 2.08GB – it should fail.”);
InstanceBigArray(maxCount);
for (int i = 1; i < 100; i++)
{
maxCount += 10000000;
Console.WriteLine();
Console.WriteLine("Test " + maxCount + " is it failing?");
InstanceBigArray(maxCount);
}
Console.ReadKey();
}
private static void InstanceBigArray(int maxCount)
{
ComplexNumber[] arr = null;
try
{
arr = new ComplexNumber[maxCount];
Console.WriteLine("SUCCESS.");
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
Console.ReadKey();
}
}
}
// This structure consumes 16 bytes of memory.
// So if we want to create array of this type which consume more than 2GB we
// need to create array at least with 134217728 instances.
public struct ComplexNumber
{
public int Re;
public int Im;
public ComplexNumber(int re, int im)
{
Re = re;
Im = im;
}
}
}
About Latest Posts TRS StaffThe sports you love, the teams you follow, we’ve got it covered.
He looked lost and had trouble scoring offensively.
147) with one RBI against left-handers through Thursday’s (May 26) game.
The Bears are devoid of playmakers on offense and Jeffery has been hurt by inept quarterback play.
However, the player I’m thinking of neither of these two, despite how important they are to the Patriots.
Hi, I found that
Using editbin.exe /largeaddressaware can regard application as LARGE_ADDRESS_AWARE, which enables 32bit application in x64 OS access memory > 2GB.
So, with largeaddressaware, gcAllowVeryLargeObjects can also be enabled.
Hi thank you for sharing! I came across this blog post as well, system.outofmemoryexception if anyone else is still struggling.