Eu tenho um monte de aulas que podemProcess() objetos e retorne seus próprios objetos:

public override IEnumerable<T> Process(IEnumerable<T> incoming) { ... }

Quero escrever uma classe de processador que possa agrupar um desses processadores e registrar qualquer exceção não capturada que o agrupadoProcess() método pode jogar. Minha primeira ideia foi algo assim:

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

mas isso não funciona, devido aCS1626: Não é possível gerar um valor no corpo de um bloco try com uma cláusula catch.

Então, eu quero escrever algo que seja conceitualmente equivalente, mas compilado. :-) Eu tenho isso:

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

    while (true) {
        T value;
        try {
            if (!walker.MoveNext()) {
                break;
            }
            value = walker.Current;
        } catch (Exception e) {
            WriteToLog(e);
            throw;
        }
        yield return value;
    }
}

mas isso é mais complexo do que eu esperava, e não tenho muita certeza de sua exatidão ou de que não há uma maneira muito mais simples.

Estou no caminho certo aqui? Existe uma maneira mais fácil?