string.Format () - Parameter

Wie viele Parameter übergeben Sie einen string.Format () - Methode?

Es muss irgendeine Art von theoretischen oder erzwungene Beschränkung ist es. Ist es auf der Grundlage der Grenzen von den params [] - Typ oder der Speicherverbrauch der app, es zu benutzen oder etwas ganz anderes?

InformationsquelleAutor Blatfrig | 2009-02-18
  1. 19

    OK, ich ergeben sich aus verstecken... ich Folgendes Programm, um zu überprüfen, was Los war und während Marc darauf hingewiesen, dass eine Zeichenfolge wie diese "{0}{1}{2}...{2147483647}" erfolgreich wäre das memory-limit von 2 GB, bevor die Liste der Argumente, meine Ergebnisse nicht mit den Ihren übereinstimmen. So hart an der Grenze, von der Anzahl der Parameter, die Sie in einer Zeichenfolge.Format-Methode aufrufen, werden 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();

    Liebe die Diskussion, Leute!

    InformationsquelleAutor John Leidegren
  2. 19

    Nicht soweit ich weiß...

    gut, die theoretische Grenze wäre die int32-Grenze für das array, aber Sie würden trifft die string Länge begrenzen, die lange vor, denke ich...

    Nur nicht verrückt mit ihm ;-p ist Es vielleicht besser zu schreiben, viele kleine Fragmente (zum Beispiel) eine Datei oder ein Antwort -, als ein großer hit.

    Bearbeiten - es sah wie es war die Grenze in der IL (0xf4240), aber anscheinend ist dies nicht ganz so, wie es erscheint; ich kann es Recht groß (2^24), bevor ich einfach, dass der system-Speicher...

    Update; es scheint mir, dass die bounding-Punkt ist der format-string... diese {1000001}{1000002} hinzufügen, bis... eine schnelle etwas Mathematik (unten) zeigt, dass die maximale nützlich Anzahl der Argumente, die wir verwenden können, ist 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);
    • wow, eine willkürliche Grenze ohne Papiere... ich mag das nicht. +1 für die Forschung.
    • Naja, ich arbeite noch daran - nicht sicher, ob es richtig ist... noch zu spielen...
    • Der CLR nicht unterstützt Objekte reibe als 2GB. Da die format-Methode vor-reserviert einen StringBuilder mit 8 Zeichen für jedes argument eine theoretische Grenze wäre int.MaxValue/(sizeof(char)*8) entspricht 134,217,728
    • Es ist ok, ich poste es als Antwort für John . . . War nur ein SCHERZ! Ich bin nur ein kleiner Scherz 🙂 +1 Ausgezeichnete Antwort Marc
    • sind Sie sicher, dass über die 8 char detail? Es ist nur ein StringBuilder-Objekt, unabhängig von der Anzahl der Argumente...
    • Ja! Goto-string.Format(IFormatProvider,string format, params object[] args) versucht Zuordnung dieser neuen StringBuilder (- format.Länge + (args.Länge * 8)); die schließlich ruft FastAllocateString(int capacity) kann ich nur davon ausgehen, dass es allocate 2 bytes für jedes Zeichen.
    • yup, du hast Recht... Sie sollte wirklich Beitrag als Antwort, wissen Sie... Ihre Nummer ist die niedrigste, ergo die Grenze...
    • OK, habe eine Antwort für Sie, Ihre 107713904.

    InformationsquelleAutor Marc Gravell
  3. 4

    Erweiterung auf Marc ' s ausführliche Antwort.

    Die einzige andere Einschränkung, die wichtig ist für den debugger. Wenn man einmal eine gewisse Anzahl von Parametern, die direkt auf eine Funktion, der debugger wird weniger funktionale, die in dieser Methode. Ich glaube, die Grenze ist 64 Parameter.

    Hinweis: Dies bedeutet nicht, dass ein array mit 64 Mitgliedern, aber 64 übergebenen Parameter direkt an die Funktion.

    Könnte man lachen und sagen, "wer würde das tun?" das ist sicherlich eine berechtigte Frage. Doch LINQ macht dies viel einfacher als Sie denken. Unter der Haube in LINQ erzeugt der compiler eine große Menge code. Es ist möglich, dass für eine große generieren von SQL-Abfrage, wo mehr als 64 Felder ausgewählt sind, dass Sie treffen würde, dieses Problem. Da der compiler unter der Haube würde übergeben müssen alle Felder, die an den Konstruktor von einen anonymen Typ.

    Immer noch eine Ecke Fall.

    InformationsquelleAutor JaredPar
  4. 3

    Bedenkt, dass beide die Grenze der Array-Klasse und der Klasse "String" sind die Obere Grenze Int32 (dokumentiert bei 2,147,483,647 hier: Int32-Struktur), es ist vernünftig, zu glauben, dass dieser Wert die Grenze von der Zahl string format-Parameter.

    Update Beim Check-Reflektor, John hat Recht. String.Format, mit der Rote-Tor-Reflektor, zeigt der 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();
}

    Den format.Length + (args.Length * 8) Teil des Codes ist genug, um zu töten die meisten, die Anzahl. Ergo, '2,147,483,647 = x + 8x' lässt uns mit x = 238,609,294 (theoretisch).

    Es ist weit weniger als das, natürlich, wie die Jungs in den Kommentaren erwähnt die Zeichenfolge zu schlagen, die string Länge begrenzen früher, ist ziemlich wahrscheinlich.

    Vielleicht sollte jemand einfach nur dieser code in ein Rechner-problem! 😛

    • Das ist eigentlich falsch ist, überprüfen Sie die Kommentar-Links auf Marc ' s Antwort...
    • Dude, du solltest wirklich nur eine Antwort 😉
    • Neben der - in beiden Fällen sind Sie mehr behindert wird durch den format-string.... {1000000}{1000001}{1000002} usw... es summiert sich schnell...
    • Ja, das format-string selbst treffen sollte, der 2 GiB Grenze viel früher...
    • Limjap - nun, es ist irgendwie überflüssig, ich mag die Kommentare 😉
    • In der Tat, bei 206,449,129 (siehe update)
    • Das ist toll, Marc! 🙂

    InformationsquelleAutor Jon Limjap
Schreibe einen Kommentar