ejemplo - string.format c# number

parámetros string.Format()

Question

¿Cuántos parámetros puede pasar a un método string.Format ()?

Debe haber algún tipo de límite teórico o impuesto. ¿Se basa en los límites del tipo params [] o en el uso de la memoria de la aplicación que lo está utilizando o algo completamente diferente?

Answer 1

Ampliando la respuesta detallada de Marc.

La única otra limitación que es importante es para el depurador. Una vez que pasa un cierto número de parámetros directamente a una función, el depurador se vuelve menos funcional en ese método. Creo que el límite es 64 parámetros.

Nota: Esto no significa una matriz con 64 miembros, pero 64 parámetros pasaron directamente a la función.

Podrías reírte y decir "¿quién haría esto?" que sin duda es una pregunta válida. Sin embargo, LINQ hace que esto sea mucho más fácil de lo que piensas. Bajo el capó en LINQ el compilador genera una gran cantidad de código. Es posible que para una consulta de generación de SQL grande en la que se seleccionen más de 64 campos, se llegue a este problema. Porque el compilador bajo el capó necesitaría pasar todos los campos al constructor de un tipo anónimo.

Sigue siendo un caso de esquina.

Answer 2

No tan lejos como sé...

bueno, el límite teórico sería el límite int32 para la matriz, pero alcanzarías el límite de longitud de la cadena mucho antes, supongo ...

Simplemente no te vuelvas loco con él ;-p Puede ser mejor escribir muchos fragmentos pequeños para (por ejemplo) un archivo o respuesta, que un gran golpe.

editar - parecía que había un límite en el IL (0xf4240), pero aparentemente esto no es lo que parece; Puedo hacer que sea bastante grande (2 ^ 24) antes de que simplemente me quede sin memoria del sistema ...

Actualizar; me parece que el punto límite es la cadena de formato ... esos {1000001} {1000002} se suman ... un poco de matemática rápida (abajo) muestra que el número máximo de argumentos útiles que podemos usar es 206,449,129:

    long remaining = 2147483647;// max theoretical format arg length
    long count = 10; // i.e. {0}-{9}
    long len = 1;
    int total = 0;
    while (remaining >= 0) {
        for(int i = 0 ; i < count && remaining >= 0; i++) {
            total++;
            remaining -= len + 2; // allow for {}
        }
        count *= 10;
        len++;
    }

    Console.WriteLine(total - 1);

Answer 3

OK, salí de mi escondite ... Utilicé el siguiente programa para verificar lo que estaba pasando y, mientras Marc señalaba que una cadena como esta "{0} {1} {2} ... {2147483647}" sucedería a la límite de memoria de 2 GiB antes de la lista de argumentos, mis hallazgos no coinciden con los tuyos. Por lo tanto, el límite estricto, la cantidad de parámetros que puede poner en una cadena. La llamada al método de formato debe ser 107713904 .

int i = 0;
long sum = 0;
while (sum < int.MaxValue)
{
    var s = sizeof(char) * ("{" + i + "}").Length;
    sum += s; // pseudo append
    ++i;
}
Console.WriteLine(i);
Console.ReadLine();

Me encanta la discusión personas!

Answer 4

Teniendo en cuenta que tanto el límite de la clase Array como de la clase String son el límite superior de Int32 (documentado en 2,147,483,647 aquí: Estructura Int32 ), es razonable creer que este valor es el límite de la serie de parámetros de formato.

Actualización Al verificar el reflector, John tiene razón. String.Format, utilizando el reflector Red Gate, muestra el ff:

public static string Format(IFormatProvider provider, string format, params object[] args)
{
    if ((format == null) || (args == null))
    {
        throw new ArgumentNullException((format == null) ? "format" : "args");
    }
    StringBuilder builder = new StringBuilder(format.Length + (args.Length * 8));
    builder.AppendFormat(provider, format, args);
    return builder.ToString();
}

El format.Length + (args.Length * 8) parte del código es suficiente para matar la mayor parte de ese número. Ergo, ''2,147,483,647 = x + 8x'' nos deja con x = 238,609,294 (teórico).

Es mucho menos que eso, por supuesto; como los muchachos en los comentarios mencionaron que la cuerda golpeando el límite de longitud de la cuerda antes es bastante probable.

¡Tal vez alguien debería simplemente codificar esto en un problema de máquina! :PAG