Wickeln Sie ein IEnumerable und abfangen von Ausnahmen

Wenn das, was Sie wollen zu tun ist, behandeln einer Ausnahme während der Verarbeitung des Ergebnisses einer Aufzählung, dann versucht man die Logik einfach gehen muss, direkt in Ihrem for/while-Schleife.

Aber dein Beispiel liest sich, als ob Sie versuchen, zu fangen und zu überspringen, von Ausnahmen die durch die enumeration-Anbieter.

Soweit ich feststellen kann, gibt es keine Möglichkeit in C# Iteration über einen enumerator und überspringen und Ausnahme tritt innerhalb der enumerator selbst.
Wenn der enumerator eine Ausnahme auslöst, dann werden alle zukünftigen Aufrufe von MoveNext() führt zu falschen Ausgang.

Der einfachste Weg, um zu erklären, warum dies geschieht, ist mit diesem sehr einfach enumerable:

IEnumerable<int> TestCases()
{
    yield return 1;
    yield return 2;
    throw new ApplicationException("fail eunmeration");
    yield return 3;
    yield return 4;
}

Verständlich, wenn wir bei diesem Beispiel ist es offensichtlich, dass die geworfene exception Ursache für diesen ganzen block zu verlassen, und die 3. und 4. yield-Anweisung wird nicht immer verarbeitet werden. In der Tat das übliche "Unreachable code erkannt' compiler-Warnung auf der 3. yield-Anweisung.

Also, wenn das Durchlaufen ist ein komplexer, gelten die gleichen Regeln:

IEnumerable<int> TestCases2()
{
    foreach (var item in Enumerable.Range(0,10))
    {
        switch(item)
        {
            case 2:
            case 5:
                throw new ApplicationException("This bit failed");
            default:
                yield return item;
                break;
        }
    }
}

Wenn die Ausnahme ausgelöst wird, wird die Verarbeitung dieser block aufhört und geht zurück bis den call-stack auf die nächste exception-handler.

ALLE brauchbare Beispiele zu bekommen, um dieses Problem, das ich gefunden habe ALSO nicht gehen, um das nächste Element in der Aufzählung, Sie alle Pause auf die erste Ausnahme.

Daher überspringen en Ausnahme in der Aufzählung müssen Sie den Anbieter, um es zu erleichtern. Dies ist nur möglich, wirklich, wenn Ihr codiert die Anbieter an oder Kontaktieren Sie die Entwickler haben, das folgende ist ein stark vereinfacht Beispiel, wie könnte man dies erreichen:

IEnumerable<int> TestCases3(Action<int, Exception> exceptionHandler)
{
    foreach (var item in Enumerable.Range(0, 10))
    {
        int value = default(int);
        try
        {
            switch (item)
            {
                case 2:
                case 5:
                    throw new ApplicationException("This bit failed");
                default:
                    value = item;
                    break;
            }
        }
        catch(Exception e)
        {
            if (exceptionHandler != null)
            {
                exceptionHandler(item, e);
                continue;
            }
            else
                throw;
        }
        yield return value;
    }
}

...

foreach (var item in TestCases3(
    (int item, Exception ex) 
    => 
    Console.Out.WriteLine("Error on item: {0}, Exception: {1}", item, ex.Message)))
{
    Console.Out.WriteLine(item);
}

Dies ergibt die folgende Ausgabe:

0
1
Error on item: 2, Exception: This bit failed
3
4
Error on item: 5, Exception: This bit failed
6
7
8
9

Ich hoffe, das klärt das Problem für andere Entwickler in der Zukunft, wie es ist eine ziemlich Allgemeine Idee, dass wir alle, sobald wir anfangen, tief in Linq und Aufzählungen. Leistungsstarke Sachen, aber es gibt einige logische Einschränkungen.

Könnte es schöner sein, wenn die process Objekt war etwas, das verarbeitet nur ein Element in der Liste zu einem Zeitpunkt (wenn das überhaupt möglich ist), so dass Sie sammeln konnte jede einzelne Ausnahme und eine AggregateException genau wie die Task Parallel library stellt.

[Wenn Verfahren arbeitet auf der Liste als ganzes, oder wenn eine einzige Ausnahme muss zum Abbruch des gesamten Prozesses offensichtlich ist dieser Vorschlag ist nicht geeignet.]

Schleife und Ertrag werden nicht benötigt (zumindest in deinem Beispiel). Einfach entfernen und es ist nicht mehr eine Beschränkung auf die catch-Blöcke.

public override IEnumerable<T> Process(IEnumerable<T> incoming) {
    try {
        return this.processor.Process(incoming);
    } catch (Exception e) {
        WriteToLog(e);
        throw;
    }
}

Ich gehe davon aus, dass this.processor.Process(incoming) gibt eine collection zurück, die Umsetzung IEnumerable<T> daher müssen Sie nicht erstellen Sie einen neuen iterator. Wenn this.processor.Process(incoming) faul ist die Bewertung dann

public override IEnumerable<T> Process(IEnumerable<T> incoming) {
    try {
        return this.processor.Process(incoming).ToList();
    } catch (Exception e) {
        WriteToLog(e);
        throw;
    }
}