Da alles begrenzt ist, habe ich mich gefragt, ob die Anzahl der verschachtelten forSchleifen begrenzt ist oder ob ich sie hinzufügen kann, solange ich Speicher habe. Kann der Visual Studio-Compiler ein solches Programm erstellen?

Natürlich forwären 64 oder mehr verschachtelte Schleifen nicht praktisch zum Debuggen, aber ist es machbar?

private void TestForLoop()
{
  for (int a = 0; a < 4; a++)
  {
    for (int b = 0; b < 56; b++)
    {
      for (int c = 0; c < 196; c++)
      {
        //etc....
      }
    }
  }
}

Ich gehe auf die Nerven, indem ich dies poste, aber ich denke, dass die Antwort lautet:

Zwischen 550 und 575

^{mit Standardeinstellungen in Visual Studio 2015}

Ich habe ein kleines Programm erstellt, das verschachtelte forSchleifen generiert ...

for (int i0=0; i0<10; i0++)
{
    for (int i1=0; i1<10; i1++)
    {
        ...
        ...
        for (int i573=0; i573<10; i573++)
        {
            for (int i574=0; i574<10; i574++)
            {
                Console.WriteLine(i574);
            }
        }
        ...
        ...
    }
}

Für 500 verschachtelte Schleifen kann das Programm weiterhin kompiliert werden. Mit 575 Schleifen rettet der Compiler:

Warnung AD0001 Analyzer 'Microsoft.CodeAnalysis.CSharp.Diagnostics.SimplifyTypeNames.CSharpSimplifyTypeNamesDiagnosticAnalyzer' hat eine Ausnahme vom Typ 'System.InsufficientExecutionStackException' mit der Meldung 'Unzureichender Stack ausgelöst, um die sichere Ausführung des Programms fortzusetzen. Dies kann passieren, wenn zu viele Funktionen auf dem Aufrufstapel oder auf dem Stapel zu viel Stapelspeicherplatz vorhanden sind. '

mit der zugrunde liegenden Compiler-Nachricht

Fehler CS8078: Ein Ausdruck ist zu lang oder zu komplex zum Kompilieren

Dies ist natürlich ein rein hypothetisches Ergebnis. Wenn die innerste Schleife mehr als a Console.WriteLineausführt, sind möglicherweise weniger verschachtelte Schleifen möglich, bevor die Stapelgröße überschritten wird. Dies ist möglicherweise auch keine rein technische Grenze, da möglicherweise versteckte Einstellungen vorhanden sind, um die maximale Stapelgröße für den in der Fehlermeldung genannten "Analyzer" oder (falls erforderlich) für die resultierende ausführbare Datei zu erhöhen. Dieser Teil der Antwort bleibt jedoch den Leuten überlassen, die C # genau kennen.

Aktualisieren

Als Antwort auf die Frage in den Kommentaren :

Es würde mich interessieren, wenn diese Antwort erweitert würde, um experimentell zu "beweisen", ob Sie 575 lokale Variablen auf den Stapel legen können, wenn sie nicht in for-Schleifen verwendet werden, und / oder ob Sie 575 nicht verschachtelte for-Schleifen einfügen können eine einzige Funktion

In beiden Fällen lautet die Antwort: Ja, das ist möglich. Beim Füllen der Methode mit 575 automatisch generierten Anweisungen

int i0=0;
Console.WriteLine(i0);
int i1=0;
Console.WriteLine(i1);
...
int i574=0;
Console.WriteLine(i574);

es kann noch kompiliert werden. Alles andere hätte mich überrascht. Die für die intVariablen erforderliche Stapelgröße beträgt nur 2,3 KB. Aber ich war neugierig und um weitere Grenzen zu testen, habe ich diese Zahl erhöht. Schließlich wurde es nicht kompiliert, was den Fehler verursachte

Fehler CS0204: Nur 65534 Einheimische, einschließlich der vom Compiler generierten, sind zulässig

Das ist ein interessanter Punkt, wurde aber bereits an anderer Stelle beobachtet: Maximale Anzahl von Variablen in der Methode

In ähnlicher Weise 575 nicht verschachtelte for Schleifen, wie in

for (int i0=0; i0<10; i0++)
{
    Console.WriteLine(i0);
}
for (int i1=0; i1<10; i1++)
{
    Console.WriteLine(i1);
}
...
for (int i574=0; i574<10; i574++)
{
    Console.WriteLine(i574);
}

kann auch kompiliert werden. Hier habe ich auch versucht, das Limit zu finden, und mehr dieser Schleifen erstellt. Insbesondere war ich mir nicht sicher, ob die Schleifenvariablen in diesem Fall auch als "Einheimische" gelten, weil sie in ihren eigenen sind { block }. Mehr als 65534 ist jedoch nicht möglich. Schließlich habe ich einen Test hinzugefügt, der aus 40000 Schleifen des Musters besteht

for (int i39999 = 0; i39999 < 10; i39999++)
{
    int j = 0;
    Console.WriteLine(j + i39999);
}

das enthielt eine zusätzliche Variable in der Schleife, aber diese scheinen auch als "Einheimische" zu zählen, und es war nicht möglich, diese zu kompilieren.

Zusammenfassend: Die Grenze von ~ 550 wird tatsächlich durch die Verschachtelungstiefe der Schleifen verursacht. Dies wurde auch durch die Fehlermeldung angezeigt

Fehler CS8078: Ein Ausdruck ist zu lang oder zu komplex zum Kompilieren

Die Dokumentation des Fehlers CS1647 spezifiziert leider (aber verständlicherweise) keine "Messung" der Komplexität, sondern gibt nur den pragmatischen Rat

Es gab einen Stapelüberlauf im Compiler, der Ihren Code verarbeitete. Vereinfachen Sie Ihren Code, um diesen Fehler zu beheben.

Um dies noch einmal zu betonen: Für den speziellen Fall tief verschachtelter forSchleifen ist dies alles eher akademisch und hypothetisch . Die Websuche nach der Fehlermeldung von CS1647 zeigt jedoch mehrere Fälle, in denen dieser Fehler für Code auftrat, der höchstwahrscheinlich nicht absichtlich komplex war, sondern in realistischen Szenarien erstellt wurde.

In der C # -Sprachenspezifikation oder der CLR gibt es keine feste Grenze. Ihr Code wäre eher iterativ als rekursiv, was sehr schnell zu einem Stapelüberlauf führen könnte.

Es gibt einige Dinge, die als Schwellenwert gelten könnten, z. B. den (allgemein) verwendeten intZähler, der intjeder Schleife einen In-Speicher zuweist (und bevor Sie Ihren gesamten Stapel mit Ints zugewiesen haben ...). Beachten Sie, dass die Verwendung interforderlich ist und Sie dieselbe Variable möglicherweise wiederverwenden.

Wie von Marco hervorgehoben , liegt der aktuelle Schwellenwert mehr im Compiler als in der tatsächlichen Sprachspezifikation oder Laufzeit. Sobald dies neu codiert ist, können Sie weitere Iterationen durchführen. Wenn Sie beispielsweise Ideone verwenden , das standardmäßig den alten Compiler verwendet, können Sie forproblemlos über 1200 Schleifen erhalten.

So viel zu Loops ist jedoch ein Indikator für schlechtes Design. Ich hoffe, diese Frage ist rein hypothetisch.

Es gibt ein Limit für alle C #, die bis zu MSIL kompiliert wurden. MSIL kann nur 65535 lokale Variablen unterstützen. Wenn Ihre forSchleifen denen entsprechen, die Sie im Beispiel gezeigt haben, benötigt jede eine Variable.

Es ist möglich, dass Ihr Compiler Objekte auf dem Heap als Speicher für lokale Variablen zuweist und diese Grenze umgeht. Ich bin mir jedoch nicht sicher, welche seltsamen Ergebnisse daraus resultieren würden. Bei der Reflexion können Probleme auftreten, die einen solchen Ansatz illegal machen.

Zwischen 800 und 900 für leere for(;;)Schleifen.

Der Ansatz von Marco13 wurde gespiegelt, mit Ausnahme der versuchten for(;;)Schleifen:

for (;;)  // 0
for (;;)  // 1
for (;;)  // 2
// ...
for (;;)  // n_max
{
  // empty body
}

Es funktionierte für 800 verschachtelte for(;;), aber es gab den gleichen Fehler, den Marco13 beim Versuch von 900 Schleifen hatte.

Wenn es kompiliert wird, for(;;)scheint der Thread zu blockieren, ohne die CPU zu maximieren. oberflächlich scheint es sich wie ein zu verhalten Thread.Sleep().