What is the maximum possible length of a .NET string?

Question

What is the longest string that can be created in .NET? The docs for the String class are silent on this question as far as I can see, so an authoritative answer might require some knowledge of internals. Would the maximum change on a 64-bit system?

[This is asked more for curiosity than for practical use - I don't intend to create any code that uses gigantic strings!]

HitScan · Accepted Answer · 2019-09-30T13:13:53.290

397

The theoretical limit may be 2,147,483,647, but the practical limit is nowhere near that. Since no single object in a .NET program may be over 2GB and the string type uses UTF-16 (2 bytes for each character), the best you could do is 1,073,741,823, but you're not likely to ever be able to allocate that on a 32-bit machine.

This is one of those situations where "If you have to ask, you're probably doing something wrong."

edited Sep 30 '19 at 13:13

answered Sep 26 '08 at 17:18

HitScan

8,651
3
22
17

8

This is the correct answer. You're more likely to run out of memory before being able to allocate enough to exhaust the string length. On a fresh boot you might be able to pull an allocation of 2GB (with 1M characters) as mentioned here, but that's all. – Stephen Deken Sep 26 '08 at 17:30
4

Assuming that your "no single object may be over 2Gb" assertion is accurate, this IS the theoretical limit as well as the practical one - the constraint on String length would be the total object size, not the capacity of the Length field. – McKenzieG1 Sep 26 '08 at 17:37
17

If anyone is interested in the exact value, on my 64-bit machine it's 1,073,741,791 (1024 · 1024 · 1024 - 33) characters. See also [my related question about the exact max size of `byte[]`](http://stackoverflow.com/q/6616739/41071). – svick Jan 07 '13 at 21:15
7

I go crazy about answers that contain short but in depth explanation. – Mikayil Abdullayev Dec 10 '13 at 07:00
5

There is an option to allow .NET 4.5 (and later) objects to be larger than 2GB on 64-bit machines. [Check here](http://stackoverflow.com/questions/1087982/single-objects-still-limited-to-2-gb-in-size-in-clr-4-0) – Anderson Matos Oct 05 '15 at 14:22
1

@MikayilAbdullayev - `I go crazy ...` in a good way? or in a bad way? :) :) :) – Jesse Chisholm Oct 06 '15 at 20:57
2

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. – bandybabboon Dec 27 '15 at 02:01
@bandybabboon Yes, but strings are not array objects. The documentation for gcAllowVeryLargeObjects also mentions that it does not pertain to strings. – m_a_s Mar 12 '23 at 13:26

score 77 · Answer 2 · edited Apr 10 '18 at 10:45

Based on my highly scientific and accurate experiment, it tops out on my machine well before 1,000,000,000 characters. (I'm still running the code below to get a better pinpoint).

UPDATE: After a few hours, I've given up. Final results: Can go a lot bigger than 100,000,000 characters, instantly given System.OutOfMemoryException at 1,000,000,000 characters.

using System;
using System.Collections.Generic;

public class MyClass
{
    public static void Main()
    {
        int i = 100000000;
        try
        {
            for (i = i; i <= int.MaxValue; i += 5000)
            {
                string value = new string('x', i);
                //WL(i);
            }
        }
        catch (Exception exc)
        {
            WL(i);
            WL(exc);
        }
        WL(i);
        RL();
    }

    #region Helper methods

    private static void WL(object text, params object[] args)
    {
        Console.WriteLine(text.ToString(), args);   
    }

    private static void RL()
    {
        Console.ReadLine(); 
    }

    private static void Break() 
    {
        System.Diagnostics.Debugger.Break();
    }

    #endregion
}

Applying a binary search here would probably help you find this answer a lot quicker... — Mario, Jul 12 '10 at 21:08

score 52 · Answer 3 · edited Apr 10 '18 at 09:12

52

Since the Length property of System.String is an Int32, I would guess that that the maximum length would be 2,147,483,647 chars (max Int32 size). If it allowed longer you couldn't check the Length since that would fail.

edited Apr 10 '18 at 09:12

Sae1962

1,122
15
31

answered Sep 26 '08 at 16:17

Ryan Farley

11,315
4
46
43

2

@m.edmondson: I'm not convinced actually. An [array](https://msdn.microsoft.com/en-us/library/system.array%28v=vs.110%29.aspx) for instances has a `LongLength` as well and a stream uses `long` as length. Although it is valid answer, it's nood an accurate way to measure this. – Willem Van Onsem Jan 27 '15 at 19:59
1

But the first two bits are used for ASCII/non-ASCII indication as [this article](https://www.codeproject.com/Articles/3377/Strings-UNDOCUMENTED) says, so it should be 2^30 = 1 073 741 824 – Saito Feb 10 '17 at 12:04

score 34 · Answer 4 · edited Apr 10 '18 at 12:22

34

For anyone coming to this topic late, I could see that hitscan's "you probably shouldn't do that" might cause someone to ask what they should do…

The StringBuilder class is often an easy replacement. Consider one of the stream-based classes especially, if your data is coming from a file.

The problem with s += "stuff" is that it has to allocate a completely new area to hold the data and then copy all of the old data to it plus the new stuff - EACH AND EVERY LOOP ITERATION. So, adding five bytes to 1,000,000 with s += "stuff" is extremely costly. If what you want is to just write five bytes to the end and proceed with your program, you have to pick a class that leaves some room for growth:

StringBuilder sb = new StringBuilder(5000);
for (; ; )
    {
        sb.Append("stuff");
    }

StringBuilder will auto-grow by doubling when it's limit is hit. So, you will see the growth pain once at start, once at 5,000 bytes, again at 10,000, again at 20,000. Appending strings will incur the pain every loop iteration.

edited Apr 10 '18 at 12:22

Sae1962

1,122
15
31

answered Aug 11 '14 at 15:58

user922020

712
6
12

6

It's ALSO worth noting that StringBuilder allows you to set the initial size. Useful if you know you're going to be using 10,000,000 entries ahead of time, allowing you to ignore some of the crunch. – Kyle Baran Aug 29 '14 at 15:53
4

+1 For seeing through the question and answering to good design. Comparatively, "this is how big your string can be before it blows", as opposed to, "if you REALLY need to store a lot of text, use this..." – StevoInco Feb 26 '15 at 20:37
For many corporate use cases such as exports, or logs that require processing and is above 2GB, the StringBuilder with its MaxValue that can go up to Int32 (2147483647) as per documentation, is not the solution. The same limitations remain. – Daniel ZA Aug 03 '22 at 07:24

WonderWorker · Answer 5 · 2019-05-09T13:54:43.387

The max length of a string on my machine is 1,073,741,791.

You see, Strings aren't limited by integer as is commonly believed.

Memory restrictions aside, Strings cannot have more than 2³⁰ (1,073,741,824) characters, since a 2GB limit is imposed by the Microsoft CLR (Common Language Runtime). 33 more than my computer allowed.

Now, here's something you're welcome to try yourself.

Create a new C# console app in Visual Studio and then copy/paste the main method here:

static void Main(string[] args)
{
    Console.WriteLine("String test, by Nicholas John Joseph Taylor");

    Console.WriteLine("\nTheoretically, C# should support a string of int.MaxValue, but we run out of memory before then.");

    Console.WriteLine("\nThis is a quickish test to narrow down results to find the max supported length of a string.");

    Console.WriteLine("\nThe test starts ...now:\n");

    int Length = 0;

    string s = "";

    int Increment = 1000000000; // We know that s string with the length of 1000000000 causes an out of memory exception.

    LoopPoint:

    // Make a string appendage the length of the value of Increment

    StringBuilder StringAppendage = new StringBuilder();

    for (int CharacterPosition = 0; CharacterPosition < Increment; CharacterPosition++)
    {
        StringAppendage.Append("0");

    }

    // Repeatedly append string appendage until an out of memory exception is thrown.

    try
    {
        if (Increment > 0)
            while (Length < int.MaxValue)
            {
                Length += Increment;

                s += StringAppendage.ToString(); // Append string appendage the length of the value of Increment

                Console.WriteLine("s.Length = " + s.Length + " at " + DateTime.Now.ToString("dd/MM/yyyy HH:mm"));

            }

    }
    catch (OutOfMemoryException ex) // Note: Any other exception will crash the program.
    {
        Console.WriteLine("\n" + ex.Message + " at " + DateTime.Now.ToString("dd/MM/yyyy HH:mm") + ".");

        Length -= Increment;

        Increment /= 10;

        Console.WriteLine("After decimation, the value of Increment is " + Increment + ".");

    }
    catch (Exception ex2)
    {
        Console.WriteLine("\n" + ex2.Message + " at " + DateTime.Now.ToString("dd/MM/yyyy HH:mm") + ".");

        Console.WriteLine("Press a key to continue...");

        Console.ReadKey();

    }

    if (Increment > 0)
    {
        goto LoopPoint;

    }

    Console.WriteLine("Test complete.");

    Console.WriteLine("\nThe max length of a string is " + s.Length + ".");

    Console.WriteLine("\nPress any key to continue.");

    Console.ReadKey();

}

My results were as follows:

String test, by Nicholas John Joseph Taylor

Theoretically, C# should support a string of int.MaxValue, but we run out of memory before then.

This is a quickish test to narrow down results to find the max supported length of a string.

The test starts ...now:

s.Length = 1000000000 at 08/05/2019 12:06

Exception of type 'System.OutOfMemoryException' was thrown. at 08/05/2019 12:06. After decimation, the value of Increment is 100000000.

Exception of type 'System.OutOfMemoryException' was thrown. at 08/05/2019 12:06. After decimation, the value of Increment is 10000000. s.Length = 1010000000 at 08/05/2019 12:06 s.Length = 1020000000 at 08/05/2019 12:06 s.Length = 1030000000 at 08/05/2019 12:06 s.Length = 1040000000 at 08/05/2019 12:06 s.Length = 1050000000 at 08/05/2019 12:06 s.Length = 1060000000 at 08/05/2019 12:06 s.Length = 1070000000 at 08/05/2019 12:06

Exception of type 'System.OutOfMemoryException' was thrown. at 08/05/2019 12:06. After decimation, the value of Increment is 1000000. s.Length = 1071000000 at 08/05/2019 12:06 s.Length = 1072000000 at 08/05/2019 12:06 s.Length = 1073000000 at 08/05/2019 12:06

Exception of type 'System.OutOfMemoryException' was thrown. at 08/05/2019 12:06. After decimation, the value of Increment is 100000. s.Length = 1073100000 at 08/05/2019 12:06 s.Length = 1073200000 at 08/05/2019 12:06 s.Length = 1073300000 at 08/05/2019 12:06 s.Length = 1073400000 at 08/05/2019 12:06 s.Length = 1073500000 at 08/05/2019 12:06 s.Length = 1073600000 at 08/05/2019 12:06 s.Length = 1073700000 at 08/05/2019 12:06

Exception of type 'System.OutOfMemoryException' was thrown. at 08/05/2019 12:06. After decimation, the value of Increment is 10000. s.Length = 1073710000 at 08/05/2019 12:06 s.Length = 1073720000 at 08/05/2019 12:06 s.Length = 1073730000 at 08/05/2019 12:06 s.Length = 1073740000 at 08/05/2019 12:06

Exception of type 'System.OutOfMemoryException' was thrown. at 08/05/2019 12:06. After decimation, the value of Increment is 1000. s.Length = 1073741000 at 08/05/2019 12:06

Exception of type 'System.OutOfMemoryException' was thrown. at 08/05/2019 12:06. After decimation, the value of Increment is 100. s.Length = 1073741100 at 08/05/2019 12:06 s.Length = 1073741200 at 08/05/2019 12:06 s.Length = 1073741300 at 08/05/2019 12:07 s.Length = 1073741400 at 08/05/2019 12:07 s.Length = 1073741500 at 08/05/2019 12:07 s.Length = 1073741600 at 08/05/2019 12:07 s.Length = 1073741700 at 08/05/2019 12:07

Exception of type 'System.OutOfMemoryException' was thrown. at 08/05/2019 12:07. After decimation, the value of Increment is 10. s.Length = 1073741710 at 08/05/2019 12:07 s.Length = 1073741720 at 08/05/2019 12:07 s.Length = 1073741730 at 08/05/2019 12:07 s.Length = 1073741740 at 08/05/2019 12:07 s.Length = 1073741750 at 08/05/2019 12:07 s.Length = 1073741760 at 08/05/2019 12:07 s.Length = 1073741770 at 08/05/2019 12:07 s.Length = 1073741780 at 08/05/2019 12:07 s.Length = 1073741790 at 08/05/2019 12:07

Exception of type 'System.OutOfMemoryException' was thrown. at 08/05/2019 12:07. After decimation, the value of Increment is 1. s.Length = 1073741791 at 08/05/2019 12:07

Exception of type 'System.OutOfMemoryException' was thrown. at 08/05/2019 12:07. After decimation, the value of Increment is 0. Test complete.

The max length of a string is 1073741791.

Press any key to continue.

The max length of a string on my machine is 1073741791.

I'd appreciate it very much if people could post their results as a comment below.

It will be interesting to learn if people get the same or different results.

"You see, Strings aren't limited by integer as is commonly believed." --> an integer in c# can go up to 2,147,483,647 and your result is very close (32 bytes less) to this value divided by two, which is logical as every character of a String is store as Unicode on two bytes. So even if the limit isn't imposed by the size of the integer, it's remarkably close to it. — Ben, Apr 19 '20 at 08:44
Thanks for your code. I manage to reproduce it on OSX with ARM M1, .net 3.1: The max length of a string is 1073741791. — Paulo Henrique Lellis Gonalves, May 06 '21 at 16:06

score 2 · Answer 6 · edited Apr 10 '18 at 09:09

2

Since String.Length is an integer (that is an alias for Int32), its size is limited to Int32.MaxValue unicode characters. ;-)

edited Apr 10 '18 at 09:09

Sae1962

1,122
15
31

answered Sep 26 '08 at 16:20

VVS

19,405
5
46
65

score 0 · Answer 7 · answered Sep 26 '08 at 18:06

0

200 megs... at which point your app grinds to a virtual halt, has about a gig working set memory, and the o/s starts to act like you'll need to reboot.

static void Main(string[] args)
{
    string s = "hello world";
    for(;;)
    {
        s = s + s.Substring(0, s.Length/10);
        Console.WriteLine(s.Length);
    }
}

12
13
14
15
16
17
18
...
158905664
174796230
192275853
211503438

answered Sep 26 '08 at 18:06

loudej

1,889
11
17

7

I'm not sure the behavior you'd get from creating just one really big string is the same as what you're seeing by allocating a bunch of them and concatenating. – Casey Feb 19 '16 at 19:56

score -1 · Answer 8 · answered Oct 13 '20 at 07:26

-1

String allocates dynamic memory size in the heap of your RAM. But string address is stored in stack that occupies 4 bytes of memory.

answered Oct 13 '20 at 07:26

krishna Reddy

1

This depends on the size of a reference. On 32-bit computers, 4 bytes is right. On 64-bit computers, it is 8 bytes. – rbwhitaker Apr 10 '22 at 12:05

What is the maximum possible length of a .NET string?

8 Answers8

Linked

Related