Yield 返回与 try catch，如何解决？

Question

我有一段代码：

using (StreamReader stream = new StreamReader(file.OpenRead(), Encoding))
{
    char[] buffer = new char[chunksize];
    while (stream.Peek() >= 0)
    {
       int readCount = stream.Read(buffer, 0, chunksize);

       yield return new string(buffer, 0, readCount);
    }
 }

现在我必须用 try-catch 块包围它，

try
{
   using (StreamReader stream = new StreamReader(file.OpenRead(), Encoding))
   {
       char[] buffer = new char[chunksize];
       while (stream.Peek() >= 0)
       {
          int readCount = stream.Read(buffer, 0, chunksize);

          yield return new string(buffer, 0, readCount);
       }
    } 
}
catch (Exception ex)
{
    throw ExceptionMapper.Map(ex, file.FullName)
}

我看不到任何方法来做我想做的事情。

该方法具有签名：

public IEnumerable<string> ReadPieces(int pieces)

我需要一个 try/catch 并在 catch 情况下调用 ExceptionMapper 。 该方法由所有调用者延迟使用。

我必须捕获的异常来自这些调用：

File.OpenRead()
stream.Read()

Answer 1

这是一个适合我的代码片段（我没有达到错误条件）。

while (true)
{
    T ret = null;
    try
    {
        if (!enumerator.MoveNext())
        {
            break;
        }
        ret = enumerator.Current;
    }
    catch (Exception ex)
    {
        // handle the exception and end the iteration
        // probably you want it to re-throw it
        break;
    }
    // the yield statement is outside the try catch block
    yield return ret;
}

Answer 2

因为您希望在枚举期间保持 Stream 打开并处理异常并正确关闭文件句柄，所以我认为您不能使用常规枚举快捷方式（迭代器块、yield-return/yield-休息）。

相反，只需执行编译器会为您执行的操作并添加一些：

通过自己实现 IEnumerator，您还可以添加 IDisposable

public class LazyStream : IEnumerable<string>, IDisposable
{
  LazyEnumerator le;

  public LazyStream(FileInfo file, Encoding encoding)
  {
    le = new LazyEnumerator(file, encoding);
  }

  #region IEnumerable<string> Members
  public IEnumerator<string> GetEnumerator()
  {
    return le;
  }
  #endregion

  #region IEnumerable Members
  System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
  {
    return le;
  }
  #endregion

  #region IDisposable Members
  private bool disposed = false;

  public void Dispose()
  {
    Dispose(true);

    GC.SuppressFinalize(this);
  }

  protected virtual void Dispose(bool disposing)
  {
    if (!this.disposed)
    {
      if (disposing)
      {
        if (le != null) le.Dispose();
      }

      disposed = true;
    }
  }
  #endregion

  class LazyEnumerator : IEnumerator<string>, IDisposable
  {
    StreamReader streamReader;
    const int chunksize = 1024;
    char[] buffer = new char[chunksize];

    string current;

    public LazyEnumerator(FileInfo file, Encoding encoding)
    {
      try
      {
        streamReader = new StreamReader(file.OpenRead(), encoding);
      }
      catch
      {
        // Catch some generator related exception
      }
    }

    #region IEnumerator<string> Members
    public string Current
    {
      get { return current; }
    }
    #endregion

    #region IEnumerator Members
    object System.Collections.IEnumerator.Current
    {
      get { return current; }
    }

    public bool MoveNext()
    {
      try
      {
        if (streamReader.Peek() >= 0)
        {
          int readCount = streamReader.Read(buffer, 0, chunksize);

          current = new string(buffer, 0, readCount);

          return true;
        }
        else
        {
          return false;
        }
      }
      catch
      {
        // Trap some iteration error
      }
    }

    public void Reset()
    {
      throw new NotSupportedException();
    }
    #endregion

    #region IDisposable Members
    private bool disposed = false;

    public void Dispose()
    {
      Dispose(true);

      GC.SuppressFinalize(this);
    }

    protected virtual void Dispose(bool disposing)
    {
      if (!this.disposed)
      {
        if (disposing)
        {
          if (streamReader != null) streamReader.Dispose();
        }

        disposed = true;
      }
    }
    #endregion
  }
}

我没有对此进行测试，但我认为它已经很接近了。

像这样使用：

using (var fe = new LazyStream(new FileInfo("c:\\data.log"), Encoding.ASCII))
{
  foreach (var chunk in fe)
  {
    Console.WriteLine(chunk);
  }
}

编辑：我完全忘记添加 try-catch 块放置。哎呀。

Answer 3

您不能在 try/catch 块中使用 yield 构造。将 try 块限制为可以抛出异常的代码，而不是全部。如果你做不到这一点，那你就运气不好了——你需要把它放在堆栈的更上方。

Answer 4

编辑 - 这个答案实际上是不正确的，由于评论中详细阐述的原因 - “仅包装了枚举器生成，而不是迭代本身。” - 但我将这个答案留在这里作为举个例子，有时看似有效的方法由于语言的复杂性而并非如此。

把它当作一个警示故事——我感谢 uosɐſ。 =)

---

这是一个选项 - 将您的方法分为两种方法，一种是公共方法，一种是私有方法。公共方法是对私有方法（即生成器）的调用的包装器（带有 try/catch）。例如：

public IEnumerable<string> YourFunction(...)
{
    try
    {
        return _yourFunction(...);
    }
    catch (Exception e)
    {
        throw ExceptionMapper.Map(e, file.FullName);
    }
}

private IEnumerable<string> _yourFunction(...)
{
    // Your code here
}

这将允许您的用户依赖具有内置异常处理功能的生成器。此外，您可以对公共方法中的输入执行更多验证，根据需要抛出由于错误输入而导致的任何异常，并在调用方法时立即执行这些验证，而不是等待第一次枚举可枚举项。

Answer 5

看看这个问题。在特殊情况下，您可以在 try/catch 子句之后使用 yield break，yield value。我担心性能，但据信 try 不会对性能产生影响，同时不会引发异常。

Answer 6

您可以考虑使用 System.Interactive 包的高级 LINQ 功能，特别是Catch 和 抛出 运算符。只需将现有代码移动到 local function，并对本地函数的结果应用 Catch 运算符：

public IEnumerable<string> ReadPieces(int pieces)
{
    return Implementation(pieces)
        .Catch<string, Exception>(ex => EnumerableEx
            .Throw<string>(ExceptionMapper.Map(ex, file.FullName)));

    static IEnumerable<string> Implementation(int pieces)
    {
        /* Your existing code, without try/catch */
    }
}

Catch 运算符的签名：

// Creates a sequence that corresponds to the source sequence,
// concatenating it with the sequence resulting from calling
// an exception handler function in case of an error.
public static IEnumerable<TSource> Catch<TSource, TException>(
    this IEnumerable<TSource> source,
    Func<TException, IEnumerable<TSource>> handler)
    where TException : Exception;

Throw 的签名 运算符：

// Returns a sequence that throws an exception upon enumeration.
public static IEnumerable<TResult> Throw<TResult>(Exception exception);

上面的代码将无法编译，因为 file 变量不存在于 handler 委托的上下文中。如果必须以延迟方式构建文件，您可以使用Defer 运算符：

public IEnumerable<string> ReadPieces(int pieces)
{
    return EnumerableEx.Defer(() =>
    {
        FileInfo file = /* Initialize the variable */
        return Implementation(pieces, file)
            .Catch<string, Exception>(ex => EnumerableEx
                .Throw<string>(ExceptionMapper.Map(ex, file.FullName)));
    });

    static IEnumerable<string> Implementation(int pieces, FileInfo file)
    {
        /* Your existing code, without try/catch */
    }
}

如果您想抑制异常（而不是将其映射到不同的例外），请执行以下操作：

    .Catch<string, Exception>(ex => Enumerable.Empty<string>());

如果您的序列是异步的（IAsyncEnumerable），您可以找到相同的 Catch, 抛出和 Defer System.Interactive.Async 包。

Answer 7

不幸的是，您还没有描述您想要做什么，但您可以尝试强制您定义的函数的用户尝试/捕获自己：

public IEnumerable<string> YourFunction(...)
{
    //Your code
}

//later:
    //...
    try{
        foreach( string s in YourFunction(file) )
        {
            //Do Work
        }
    }
    catch(Exception e){
        throw ExceptionMapper.Map(e, file.FullName);
    }

Answer 8

一种有效的策略（如果读起来有点混乱……）是分解并包装可能会绕过实际 yield return 调用的每个部分。这可以解决该问题，以便 yield 本身不在 try/catch 块中，但仍包含可能失败的部分。

这是您的代码的可能实现：

StreamReader stream = null;
char[] buffer = new char[chunksize];

try
{
    try
    {
        stream = new StreamReader(file.OpenRead(), Encoding);
    }
    catch (Exception ex)
    {
        throw ExceptionMapper.Map(ex, file.FullName);
    }

    int readCount;
    Func<bool> peek = () =>
    {
        try
        {
            return stream.Peek() >= 0;
        }
        catch (Exception ex)
        {
            throw ExceptionMapper.Map(ex, file.FullName);
        }
    };

    while (peek())
    {
        try
        {
            readCount = stream.Read(buffer, 0, chunksize);
        }
        catch (Exception ex)
        {
            throw ExceptionMapper.Map(ex, file.FullName);
        }

        yield return new string(buffer, 0, readCount);
    }
}
finally
{
    if (stream != null)
    {
        stream.Dispose();
        stream = null;
    }
}

Answer 9

尝试在枚举器方法中使用本地函数：将 try..catch 的内容移动到本地函数，然后从 try..catch 中调用该函数。

使用您的示例：

public IEnumerable<string> YourFunction()
{
    // do stuff...

    try
    {
       // Move the try..catch content to the local function
       return getStrings()
    }
    catch (Exception ex)
    {
        throw ExceptionMapper.Map(ex, file.FullName)
    }

    // The local function
    IEnumerable<string> getStrings()
    {
       using (StreamReader stream = new StreamReader(file.OpenRead(), Encoding))
       {
           char[] buffer = new char[chunksize];
           while (stream.Peek() >= 0)
           {
              int readCount = stream.Read(buffer, 0, chunksize);

              yield return new string(buffer, 0, readCount);
           }
        }
    }

}

在很多情况下，使用本地函数实际上是一个好主意。使用此模式可以强制该方法立即验证参数，而不是等到调用者开始枚举（Roslyn 警告 RCS1227）。

Answer 10

尝试这种方法：

public IEnumerable<ReturnData> toto()
{
    using (StreamReader stream = new StreamReader(File.OpenRead(""), Encoding.UTF8))
    {
        char[] buffer = new char[1];
        while (stream.Peek() >= 0)
        {
            ReturnData result;
            try
            {
                int readCount = stream.Read(buffer, 0, 1);
                result = new ReturnData(new string(buffer, 0, readCount));
            }
            catch (Exception exc)
            {
                result = new ReturnData(exc);
            }
            yield return result;
        }
    }
}

public class ReturnData
{
    public string Data { get; private set; }
    public Exception Error { get; private set; }
    public bool HasError { get { return Error != null; } }
    public ReturnData(string data)
    {
        this.Data = data;
    }
    public ReturnData(Exception exc)
    {
        this.Error = exc;
    }
}

您只需要小心使用这种方法：您必须根据严重性过滤异常。有些异常必须停止整个过程，而其他异常则可以跳过并记录。

Answer 11

另一个考虑因素 - 如果您使用实现内部引发异常的 IEnumerable 方法实现 yield，则无法捕获该单个错误并继续枚举 - 请参阅“ https://msdn.microsoft.com/en-us/ 的“异常处理”部分Library/9k7k7cf0.aspx

示例：

void Main()
{
    // even is okay, odd will cause exception
    var operations = new[] { 2, 16, 5 /* ! */, 8, 91 /* ! */ };

    var results = process(operations);
    var en = results.GetEnumerator();

    "Regular Enumeration".Title();
    testEnumeration(en);

    results = process(operations, ex => log("Handled: {0}", ex.Message));
    en = results.GetEnumerator();   

    "Handled Exceptions".Title();
    testEnumeration(en);

    results = process(operations, ex => log("Handled+: {0}", ex.Message), true);
    en = results.GetEnumerator();   

    "Handled Exceptions and Continue".Title();
    testEnumeration(en);
}

/// run the test and debug results
void testEnumeration(IEnumerator en) {
    int successCount = 0, failCount = 0;
    bool keepGoing = false;
    do {
        try {
            log("==={0}===", "before next");
            keepGoing = en.MoveNext();
            log("==={0}=== (keepGoing={1}, curr={2})", "after next", keepGoing, en.Current);

            // did we have anything?
            if(keepGoing) {
                var curr = en.Current;
                log("==={0}===", "after curr");

                log("We did it? {0}", curr);
                successCount++;
            }
        }
        catch(InvalidOperationException iopex) {
            log(iopex.Message);
            failCount++;
        }
    } while(keepGoing);

    log("Successes={0}, Fails={1}", successCount, failCount);
}

/// enumerable that will stop completely on errors
IEnumerable<int> process(IEnumerable<int> stuff) {
    foreach(var thing in stuff) {
        if(thing % 2 == 1) {
            throw new InvalidOperationException("Aww, you broked it");
        }

        yield return thing;
    }
}
/// enumerable that can yield from exceptions
IEnumerable<int> process(IEnumerable<int> stuff, Action<Exception> handleException, bool yieldOnExceptions = false) {
    bool shouldYield = false;
    foreach(var thing in stuff) {
        var result = thing;
        try {
            if(thing % 2 == 1) {
                throw new InvalidOperationException("Aww, you broked it");
            }

            shouldYield = true;
        }
        catch(Exception ex) {
            handleException(ex);
            // `yield break` to stop loop
            shouldYield = yieldOnExceptions;
            if(yieldOnExceptions) result = -1; // so it returns a different result you could interpret differently
        }
        if(shouldYield) yield return result;
    }
}

void log(string message, params object[] tokens) {
    Console.WriteLine(message, tokens);
}

结果为

 常规枚举    

---------------------------- 
===下一个之前===
===下一个之后===（keepGoing=True，curr=2）
===当前之后===
我们做到了？ 2
===下一个之前===
===下一个之后===（keepGoing=True，curr=16）
===当前之后===
我们做到了？ 16
===下一个之前===
哇哦，你把它弄坏了
===下一个之前===
===下一个之后===（keepGoing=False，curr=16）
成功=2，失败=1


    已处理的异常    

-------------------------- 
===下一个之前===
===下一个之后===（keepGoing=True，curr=2）
===当前之后===
我们做到了？ 2
===下一个之前===
===下一个之后===（keepGoing=True，curr=16）
===当前之后===
我们做到了？ 16
===下一个之前===
处理：哇哦，你把它弄坏了
===下一个之后===（keepGoing=True，curr=8）
===当前之后===
我们做到了？ 8
===下一个之前===
处理：哇哦，你把它弄坏了
===下一个之后===（keepGoing=False，curr=8）
成功=3，失败=0


    处理异常并继续    

--------------------------------------- 
===下一个之前===
===下一个之后===（keepGoing=True，curr=2）
===当前之后===
我们做到了？ 2
===下一个之前===
===下一个之后===（keepGoing=True，curr=16）
===当前之后===
我们做到了？ 16
===下一个之前===
Handled+：哇哦，你把它弄坏了
===下一个之后===（keepGoing=True，curr=-1）
===当前之后===
我们做到了？ -1
===下一个之前===
===下一个之后===（keepGoing=True，curr=8）
===当前之后===
我们做到了？ 8
===下一个之前===
Handled+：哇哦，你把它弄坏了
===下一个之后===（keepGoing=True，curr=-1）
===当前之后===
我们做到了？ -1
===下一个之前===
===下一个之后===（keepGoing=False，curr=-1）
成功=5，失败=0

请注意，枚举器的 Current 在“常规枚举”期间“卡在”最后一次成功的 MoveNext 上，而处理的异常允许它完成循环。