Quấn một IEnumerable và bắt ngoại lệ

Question

Tôi đã có một loạt các lớp học có thể Process() đối tượng, và trở về đối tượng của mình:

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

Tôi muốn viết một lớp xử lý có thể quấn một trong những nhà chế biến, và đăng nhập bất kỳ ngoại lệ không thể bắt buộc nào mà phương thức được bọc Process() có thể bị ném. Ý tưởng đầu tiên của tôi là một cái gì đó như thế này:

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; 
    } 
} 

nhưng điều này không hoạt động, do CS1626: Cannot yield a value in the body of a try block with a catch clause.

Vì vậy, tôi muốn viết một cái gì đó tương đương về khái niệm nhưng biên dịch. :-) Tôi đã có điều này:

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; 
    } 
} 

nhưng điều đó phức tạp hơn tôi mong đợi và tôi không hoàn toàn chắc chắn về tính chính xác của nó hoặc không có cách nào đơn giản hơn nhiều.

Tôi có đi đúng hướng ở đây không? Có cách nào dễ hơn không?

Answer 1

Vòng lặp và năng suất không cần thiết (ít nhất là trong ví dụ của bạn). Đơn giản loại bỏ chúng và không còn là một hạn chế đối với các khối catch.

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

Tôi giả định this.processor.Process(incoming) trả về một bộ sưu tập thực hiện IEnumerable<T>, vì thế bạn không cần phải tạo ra một iterator mới. Nếu this.processor.Process(incoming) là lười biếng đánh giá sau đó

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

Answer 2

Nó có thể là đẹp hơn nếu đối tượng process là cái gì mà xử lý chỉ là một mục trong danh sách tại một thời điểm (nếu đó là thậm chí có thể), như vậy bạn có thể thu thập từng ngoại lệ cá nhân và trả về một số AggregateException giống như thư viện Task Parallel.

[Nếu quá trình hoạt động trên danh sách như một toàn thể, hoặc nếu một ngoại lệ duy nhất cần phải hủy bỏ toàn bộ quá trình rõ ràng đề nghị này là không thích hợp.]

Answer 3

Thay vì giải quyết vấn đề cụ thể của bạn mà thôi, bạn có thể có các chức năng helper trong bộ công cụ của bạn:

static IEnumerable<T> RunEnumerator<T>(Func<IEnumerator<T>> generator, 
     Action<Exception> onException) 
    { 
     using (var enumerator = generator()) 
     { 
      if (enumerator == null) 
       yield break; 
      for (; ;) 
      { 
       //Avoid creating a default value with 
       //unknown type T, as we don't know is it possible to do so 
       T[] value = null; 
       try 
       { 
        if (enumerator.MoveNext()) 
         value = new T[] { enumerator.Current }; 
       } 
       catch (Exception e) 
       { 
        onException(e); 
       } 
       if (value != null) 
        yield return value[0]; 
       else 
        yield break; 
      } 
     } 
    } 

    public static IEnumerable<T> WithExceptionHandler<T>(this IEnumerable<T> orig, 
     Action<Exception> onException) 
    { 
     return RunEnumerator(() => 
     { 
      try 
      { 
       return orig.GetEnumerator(); 
      } 
      catch (Exception e) 
      { 
       onException(e); 
       return null; 
      } 
     }, onException); 
    } 
} 

WithExceptionHandler<T> chuyển đổi một IEnumerable<T> thành khác, và khi ngoại lệ xảy ra, gọi lại onException sẽ được gọi. Bằng cách này bạn có thể có chức năng process bạn thực hiện như thế này:

public override IEnumerable<T> Process(IEnumerable<T> incoming) { 
    return incoming.WithExceptionHandler(e => { 
     WriteToLog(e); 
     throw; 
    } 
} 

Bằng cách này, bạn cũng có thể làm điều gì đó khác như bỏ qua trừ hoàn toàn và để cho các lần lặp chỉ đơn giản dừng lại. Bạn cũng có thể điều chỉnh nó một chút bằng cách sử dụng Func<Exception, bool> thay vì Action<Exception> và cho phép gọi lại ngoại lệ để quyết định liệu việc lặp lại có tiếp tục hay không.

Answer 4

Có thể viết phần mở rộng LINQ để bỏ qua tất cả các yếu tố gây ra ngoại lệ và chuyển nó sang chức năng ghi nhật ký.

public static IEnumerable<T> CatchExceptions<T> (this IEnumerable<T> src, Action<Exception> action = null) { 
     using (var enumerator = src.GetEnumerator()) { 
      bool next = true; 

      while (next) { 
       try { 
        next = enumerator.MoveNext(); 
       } catch (Exception ex) { 
        if (action != null) { 
         action(ex); 
        } 
        continue; 
       } 

       if (next) { 
        yield return enumerator.Current; 
       } 
      } 
     } 
    } 

Ví dụ:

ienumerable.Select(e => e.something).CatchExceptions().ToArray() 

ienumerable.Select(e => e.something).CatchExceptions((ex) => Logger.Log(ex, "something failed")).ToArray() 

Answer 5

Nếu những gì bạn muốn làm là xử lý một ngoại lệ trong việc xử lý các kết quả của một liệt kê, sau đó bạn cố gắng Logic đơn giản chỉ cần đi thẳng bên trong của bạn cho/trong khi vòng lặp.

Nhưng ví dụ của bạn đọc như thể bạn đang cố bắt và bỏ qua các ngoại lệ do nhà cung cấp liệt kê nêu ra.

Theo như tôi có thể xác định, không có cách nào trong C# để lặp qua một điều tra viên và bỏ qua và ngoại lệ xảy ra trong chính điều tra viên. Nếu điều tra tăng ngoại lệ, thì tất cả các cuộc gọi trong tương lai tới MoveNext() sẽ dẫn đến kết quả sai.

Cách đơn giản nhất để giải thích lý do tại sao điều này xảy ra là với điều này đếm được rất đơn giản:

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

dễ hiểu khi chúng ta nhìn vào ví dụ này rõ ràng là ném ngoại lệ sẽ gây ra toàn bộ khối này để thoát ra, và tuyên bố lợi nhuận thứ 3 và thứ 4 sẽ không bao giờ được xử lý. Trong thực tế, nhận được cảnh báo trình biên dịch 'Unreachable code detect' thông thường trên báo cáo yield thứ 3.

Vì vậy, khi đếm được là một phức tạp hơn, các quy tắc tương tự áp dụng:

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; 
     } 
    } 
} 

Khi ngoại lệ xảy ra, quá trình xử lý của khối này không còn và họ sẽ trả lại lên các cuộc gọi stack để xử lý ngoại lệ gần nhất.

TẤT CẢ các ví dụ khả thi để khắc phục sự cố này mà tôi đã tìm thấy trên SO không tiến hành mục tiếp theo trong điều tra, tất cả đều ngắt ở ngoại lệ đầu tiên.

Do đó, để bỏ qua vi hợp lệ trong điều tra, bạn sẽ cần nhà cung cấp tạo điều kiện thuận lợi. Này chỉ có thể thực sự nếu mã của bạn nhà cung cấp, hoặc bạn có thể liên hệ với nhà phát triển những người đã làm, sau đây là một ví dụ quá đơn giản về cách bạn có thể đạt được điều này:

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); 
} 

này sẽ cho kết quả sau:

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

tôi hy vọng điều này đã xóa bỏ những vấn đề đối với các nhà phát triển khác trong tương lai vì nó là một ý tưởng khá phổ biến mà tất cả chúng ta có được một khi chúng ta bắt đầu getti ng sâu vào Linq và liệt kê. Công cụ mạnh mẽ nhưng có một số hạn chế hợp lý.