Was ist die richtige Art zu verwenden async/await in eine rekursive Methode?

Wenn ich code hinzufügen, um Ihr Beispiel zu konkretisieren, finde ich zwei mögliche Wege für die Rekursion zu schlecht ausgehen. Beide gehen davon aus, dass Ihre Daten ist ziemlich groß und benötigen bestimmte Bedingungen zum auslösen.

1. Wenn ProcessItem(string) gibt eine Task abgeschlossen werden, bevor es awaited auf (oder ich nehme an, es abgeschlossen, bevor die await beendet Spinnen), die Fortsetzung wird synchron ausgeführt. In meinem code unten, habe ich simuliert dies, indem er ProcessItem(string) zurück Task.CompletedTask. Wenn ich das mache, das Programm sehr schnell beendet mit einem StackOverflowException. Dies ist weil .net TPL "Veröffentlichungen Zalgo" von opportunistisch Ausführung Fortsetzungen synchron ohne Rücksicht auf wie viel Platz steht in der aktuellen Stapel. Das bedeutet, dass es verschärfen das Potenzial Stapelspeicher Problem, dass Sie bereits durch die Verwendung eines rekursiven Algorithmus. Um dies zu sehen, kommentieren Sie await Task.Yield(); in meinem code-Beispiel unten.
2. Wenn Sie eine Technik, um zu verhindern, dass TPL aus fortgeführten asynchron (unten verwende ich Task.Yield()), schließlich läuft das Programm aus der Erinnerung und sterben mit einem OutOfMemoryException. Wenn ich das richtig verstehe, würde das nicht passieren, wenn return await waren in der Lage zu emulieren, die tail-call-Optimierung. Ich kann mir vorstellen, dass das, was hier passiert, ist jeder Aufruf erzeugt so etwas wie eine Buchführung Task<string> und hält Generierung von Ihnen, obwohl Sie konnte sein verschmolz. Diesen Fehler zu reproduzieren mit dem Beispiel unten, sicherzustellen, dass Sie das Programm läuft als 32-bit, deaktivieren Sie die Console.WriteLine() nennen (weil Konsolen sind wirklich sehr langsam), und sorgen für die await Task.Yield() ist aufgehoben.

using System;
using System.Collections.Generic;
using System.Threading.Tasks;

//Be sure to run this 32-bit to avoid making your system unstable.
class StreamProcessor
{
    Stream GetStream(string streamPosition)
    {
        var parsedStreamPosition = Convert.ToInt32(streamPosition);
        return new Stream(
            //Terminate after we reach 0.
            parsedStreamPosition > 0 ? new[] { streamPosition, } : new string[] { },
            Convert.ToString(parsedStreamPosition - 1));
    }

    Task ProcessItem(string item)
    {
        //Comment out this next line to make things go faster.
        Console.WriteLine(item);
        //Simulate the Task represented by ProcessItem finishing in
        //time to make the await continue synchronously.
        return Task.CompletedTask;
    }

    public async Task<string> ProcessStream(string streamPosition)
    {
        var stream = GetStream(streamPosition);

        if (stream.Items.Count == 0)
            return stream.NextPosition;

        foreach (var item in stream.Items)
        {
            await ProcessItem(item); //ProcessItem() is now an async method
        }

        //Without this yield (which prevents inline synchronous
        //continuations which quickly eat up the stack),
        //you get a StackOverflowException fairly quickly.
        //With it, you get an OutOfMemoryException eventually—I bet
        //that “return await” isn’t able to tail-call properly at the Task
        //level or that TPL is incapable of collapsing a chain of Tasks
        //which are all set to resolve to the value that other tasks
        //resolve to?
        await Task.Yield();

        return await ProcessStream(stream.NextPosition);
    }
}

class Program
{
    static int Main(string[] args) => new Program().Run(args).Result;
    async Task<int> Run(string[] args)
    {
        await new StreamProcessor().ProcessStream(
            Convert.ToString(int.MaxValue));
        return 0;
    }
}

class Stream
{
    public IList<string> Items { get; }
    public string NextPosition { get; }
    public Stream(
        IList<string> items,
        string nextPosition)
    {
        Items = items;
        NextPosition = nextPosition;
    }
}

So, ich denke, meine zwei Empfehlungen sind:

1. Verwenden Task.Yield() wenn Sie nicht sicher, dass der Stapel Wachstum der Rekursion unterbrochen wird durch etwas anderes.
2. Wie schon vorgeschlagen, vermeiden Sie Rekursion, wenn es nicht sogar sinnvoll für Ihr problem in den ersten Platz. Und selbst wenn, macht es einen sauberen Algorithmus, vermeiden Sie es, wenn Ihr problem die Größe ist unbegrenzt.