.net - net - string length c#

¿Cuál es la longitud máxima posible de una cadena.NET?

Question

¿Cuál es la cadena más larga que se puede crear en .NET? Los documentos de la clase String guardan silencio sobre esta pregunta, por lo que puedo ver, por lo que una respuesta autorizada podría requerir cierto conocimiento de los aspectos internos. ¿El cambio máximo en un sistema de 64 bits?

[Esto se pide más por curiosidad que por uso práctico. ¡No tengo la intención de crear ningún código que use cadenas gigantescas!]

Answer 1

200 megas ... en qué punto su aplicación se detiene de forma virtual, tiene aproximadamente una memoria de conjunto de trabajo de concierto y la o / s comienza a actuar como si fuera necesario reiniciar.

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

Answer 2

Basado en mi experimento científico y preciso, se completa en mi máquina mucho antes de 1,000,000,000 de caracteres. (Todavía estoy ejecutando el código de abajo para obtener un mejor punto de referencia).

ACTUALIZACIÓN: Después de unas horas, me he rendido. Resultados finales: puede ir mucho más grande que 100,000,000 caracteres, dado instantáneamente System.OutOfMemoryException con 1,000,000,000 de caracteres.

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
}

Answer 3

Como String.Length es un entero (que es un alias para Int32 ), su tamaño está limitado a los caracteres Unicode Int32.MaxValue . ;-)

Answer 4

Dado que la propiedad Length de System.String es un Int32 , supongo que la longitud máxima sería de 2.147.483.647 caracteres (tamaño máximo de Int32 ). Si se permitía más tiempo, no se podía verificar la longitud ya que eso fallaría.

Answer 5

El límite teórico puede ser 2.147.483.647, pero el límite práctico no se acerca a eso. Dado que ningún objeto individual en un programa .Net puede tener más de 2 GB y el tipo de cadena usa unicode (2 bytes para cada carácter), lo mejor que puede hacer es 1,073,741,823, pero es probable que nunca pueda asignarlo a un Máquina de 32 bits.

Esta es una de esas situaciones en las que "si tiene que preguntar, probablemente esté haciendo algo mal".

Answer 6

Las cadenas no están limitadas por el número entero como se cree comúnmente.

Dejando de lado las restricciones de memoria, las cadenas no pueden tener más de 2 ³⁰ (1,073,741,824) caracteres, ya que el CLR de Microsoft (Common Language Runtime) impone un límite de 2GB.

Con suerte, esto puede cambiar en el futuro.

Answer 7

Para cualquier persona que llegue tarde a este tema, podría ver que "probablemente no deberías hacer eso" de Hitescan podría hacer que alguien pregunte qué debería hacer ...

La clase StringBuilder es a menudo un reemplazo fácil. Considere una de las clases basadas en transmisión , especialmente si sus datos provienen de un archivo.

El problema con s += "stuff" es que tiene que asignar un área completamente nueva para guardar los datos y luego copiar todos los datos antiguos más el material nuevo: CADA Y CADA ITERACIÓN DE LAZO. Entonces, agregar cinco bytes a 1,000,000 con s += "stuff" es extremadamente costoso. Si lo que desea es escribir solo cinco bytes al final y continuar con su programa, debe elegir una clase que deje espacio para el crecimiento:

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

StringBuilder crecerá automáticamente al duplicarse cuando se alcance el límite. Entonces, verá el dolor de crecimiento una vez al inicio, una vez a 5,000 bytes, nuevamente a 10,000, nuevamente a 20,000. Anexar cadenas incurrirá en el dolor de cada iteración de bucle.