Y a-t-il une raison technique pour laquelle C# n'émet pas de "queue"."CIL de l'enseignement? [dupliquer]

possibilité de duplication:

pourquoi .net / c# n'élimine-t-il pas la récursion de la queue?

prendre le code C suivant:

using System;

namespace TailTest
{
    class MainClass
    {
        public static void Main (string[] args)
        {
            Counter(0);
        }

        static void Counter(int i)
        {
            Console.WriteLine(i);
            if (i < int.MaxValue) Counter(++i);
        }
    }
}

le compilateur C# (mine anyway) compilera la méthode Counter dans le CIL suivant:

.method private static hidebysig default void Counter (int32 i) cil managed 
{
.maxstack 8
IL_0000:  ldarg.0 
IL_0001:  call void class [mscorlib]System.Console::WriteLine(int32)
IL_0006:  ldarg.0 
IL_0007:  ldc.i4 2147483647
IL_000c:  bge IL_0019
IL_0011:  ldarg.0 
IL_0012:  ldc.i4.1 
IL_0013:  add 
IL_0014:  call void class TailTest.MainClass::Counter(int32)
IL_0019:  ret 
}

Le problème avec le code ci-dessus est qu'il va provoquer un débordement de pile (à environ i = 262000 sur mon matériel). Pour contourner ce problème, certains langages font ce qu'on appelle l'élimination des appels de queue ou l'optimisation des appels de queue (TCO). Essentiellement, ils transforment l'appel récursif en une boucle.

D'après ce que j'ai compris, l'implémentation 64 bits du JIT.net 4 exécute maintenant TCO et évite le débordement sur le code comme le cil ci-dessus. Cependant, le JIT 32 bits ne le fait pas. Mono ne semble pas non plus. Il est intéressant que le JIT (qui est sous temps et ressources pressure) fait TCO alors que le compilateur C# ne le fait pas. Ma question est pourquoi le compilateur C# n'est-il pas plus conscient de TCO?

il y a une instruction du CAI qui dit au JIT d'exécuter TCO. Par exemple, le compilateur C# pourrait générer le CIL suivant:

.method private static hidebysig default void Counter (int32 i) cil managed 
{
.maxstack 8
IL_0000:  ldarg.0 
IL_0001:  call void class [mscorlib]System.Console::WriteLine(int32)
IL_0006:  ldarg.0 
IL_0007:  ldc.i4 2147483647
IL_000c:  bge IL_001c
IL_0011:  ldarg.0 
IL_0012:  ldc.i4.1 
IL_0013:  add 
IL_0014:  tail.
IL_0017:  call void class TailTest.MainClass::Counter(int32)
IL_001c:  ret 
}

contrairement à l'original, ce code ne débordera pas et sera exécuté même sur le JIT 32 bits (à la fois .NET et Mono). La magie se trouve dans l'instruction CIL tail. . Les compilateurs comme F# généreront CIL qui inclut cette instruction automatiquement.

donc ma question Est, y a-t-il une raison technique pour que le compilateur C# ne fasse pas cela?

je comprends qu'historiquement, ça n'en valait peut-être pas la peine. Le Code comme Counter() n'a pas été commun dans le cadre idiomatique C# et/ou .NET. Vous pouvez facilement voir TCO pour C# comme une optimisation inutile ou prématurée.

avec le introduction de LINQ et d'autres choses, il semble que les développeurs C# et C# se déplacent dans des directions plus fonctionnelles. Donc, ce serait bien si utiliser la récursion n'était pas une chose aussi dangereuse à faire. Mais ma question est vraiment un plus technique.

manque quelque chose qui fait de TCO une mauvaise idée (ou une idée risquée) pour C#. Ou y a-t-il quelque chose qui rend la tâche particulièrement difficile? C'est vraiment ce que je suis l'espoir de comprendre. Toute idée?

EDIT: Merci pour l'information. Je voulais juste être clair sur le fait que je ne critique pas l'absence ou même l'exigence de cette fonctionnalité. Je ne suis pas très intéressé par la logique autour de la priorisation. Ma curiosité est de savoir quels sont les obstacles que je ne pourrais pas percevoir ou comprendre qui font que c'est une chose difficile, dangereuse, ou indésirable à faire.

peut-être qu'un contexte différent aidera à orienter la conversation...

Disons que j'allais implémenter mon propre langage de type C#sur le CLR. Pourquoi n'inclurais-je pas (autre que le coût d'opportunité) l'émission automatique et transparente de la queue.'instruction le cas échéant? Quels défis rencontrerais-je ou quelles contraintes introduirais-je en supportant cette fonctionnalité dans une langue très proche de C#?

Merci encore (et à l'avance) pour les réponses.