Pourquoi la boucle de sortie 3, boucle 2, boucle 1, boucle 1?

C'est parce que vous avez une boucle et em> vous avez une récursion. Vous devez vous débarrasser de l'appel à Writetoconsole (I) Code> Intérieur Writetoconsole CODE> ou Débarrassez-vous de la boucle et collez-vous avec une récursion.

De plus, vous utilisez la valeur de retour. de l'appel récursif pour influencer i code> et donc votre pendant code> boucle. Je pense que cela provoque la principale affaire de votre confusion. P>

Heureusement, ce n'est que quelques étapes, afin que cela puisse être décomposé assez facilement. C'est ce qui se passe. La boucle tandis que la boucle est impliquée, je décris simplement la sortie, les modifications des appels i et les appels récursifs. P>

You call WriteToConsole(3); // Let's call this 'instance' of the function call 'A'
  A prints "Loop 3"
  A calls WriteToConsole(2); // Let's call this 'B'
    B prints "Loop 2"
    B calls WriteToConsole(1) // Let's call this 'C'
      C prints "Loop 1"
      C calls WriteToConsole(0); // Let's call this 'D'
        D doesn't enter it's loop. 
        D returns -1 (Lemmings - 1, where Lemmings is 0), i becomes -1 in C
      C's loop ends because i is -1
      C returns 0, i becomes 0 in B
    B's loop ends, because i is 0
    B returns 1, i becomes 1 in A
  A is still in the loop, since its 'i' > 0, so..
  A prints "Loop 1" (again)
  A calls WriteToConsole(0); // Let's call this 'E'
    E returns -1, i becomes -1 in A
  A returns 2, this value is ignored in your main function.
End of program

Pour réaliser ce que vous voulez, dans ce cas, vous avez besoin une boucle d'une boucle ou un autre mécanisme d'itération strong>, soit au moyen de la récursivité (sans pendant code>) ou au moyen de A pendant code> (mais ensuite sans récursion).

Voici la solution pour le pendant code> sans récursion: p>

private static void WriteToConsole(int Lemmings)
{
    int i = Lemmings;
    while (i > 0)
    {
        Console.WriteLine("loop {0}", i);
        i = i - 1; // Decrease i, no need for recursion here
    }
}

Dans votre appel récursif, vous passez dans i - 1 . Cela devient lemmings - que vous revenez comme lemmings - 1 .

Il y a deux -1 s se passe - est-ce ce que vous voulez?

Mais si vous regardez ce qui se passe:

• Le premier appel a lemmings comme 3 et i comme 3 . . .

  boucle 3 est écrit.

  Puis la récursion arrive, passant dans 3-1 :

  • Le deuxième appel a lemmings comme 2 et i comme 2 . . .

    boucle 2 est écrit.

    La récursivité se produit, passant dans 2-1 :

    • Le troisième appel a lemmings comme 1 et i comme 1 . . .

      boucle 1 est écrit.

      Puis la récursion arrive, passant dans 1-1 :

      • Le quatrième appel a lemmings comme 0 et i comme 0 . .

        Le pendant n'est pas entré, donc 0-1 est retourné.

      • retour à l'intérieur du troisième appel:

        i est attribué -1 , donc le moment se termine.

        Le troisième appel renvoie 1-1 .

      • retour à l'intérieur du deuxième appel:

        i est attribué 0 , de sorte que le moment se termine.

        Le deuxième appel renvoie 2-1 .

      • retour à l'intérieur du premier appel:

        i est attribué 1 , donc le moment continue.

        boucle 1 est écrit.

        L'exécution continue d'ici, mais tout sans sortie. Ce qui précède est la raison pour laquelle vous obtenez deux boucle 1 s.