Làm thế nào để kết hợp DebuggerHidden với các phương thức khối lặp?

Question

DebuggerHidden là khá tiện dụng để đánh dấu phương pháp helper, đảm bảo hợp ngoại lệ unhandled ngăn chặn các chương trình gỡ rối ở một nơi thuận tiện:

                 

Thật không may này dường như không làm việc với khối lặp:

         

(nếu có, trình gỡ lỗi sẽ hiển thị in làm tuyên bố hiện tại trong ví dụ thứ hai).

Trong khi điều này rõ ràng là một giới hạn của Visual Studio (mà tôi đã submitted a report), có cách nào tôi có lẽ có thể làm việc xung quanh vấn đề này trong khi vẫn sử dụng một khối lặp?

Tôi đoán rằng điều này xảy ra vì mã do trình biên dịch tạo để triển khai trình lặp không được đánh dấu bằng [DebuggerHidden]. Có lẽ có một số cách để thuyết phục trình biên dịch làm điều đó?

Answer 1

Có lẽ không phải là câu trả lời bạn mong đợi nhưng như một giải pháp, nó có thể đạt được một số điểm ... không chắc chắn nếu bạn đã mơ ước này lên.

Có lớp trợ giúp mở trình lặp của bạn và sau đó sử dụng một phương pháp mở rộng để đưa trình bao bọc vào trình lặp của bạn. Tôi xử lý ngoại lệ và quay lại. Trong VS2010 tôi đã phải bỏ chọn tùy chọn gỡ lỗi một cách kỳ lạ 'Chỉ kích hoạt mã của tôi' để có được hành vi gần với những gì mà OP yêu cầu. Rời khỏi tùy chọn kiểm tra vẫn giảm bạn trong vòng lặp thực tế nhưng ik trông giống như một dòng quá xa.

Điều đó làm cho câu trả lời này thêm một thử nghiệm để chứng minh và củng cố rằng hỗ trợ trình biên dịch tốt hơn là cần thiết cho kịch bản hoạt động.

mở rộng phương pháp helper class:

public static class HiddenHelper 
{ 
    public static HiddenEnumerator<T> Hide<T>(this IEnumerable<T> enu) 
    { 
     return HiddenEnumerator<T>.Enumerable(enu); 
    } 
} 

Wrapper:

public class HiddenEnumerator<T> : IEnumerable<T>, IEnumerator<T> 
    { 
     IEnumerator<T> _actual; 
     private HiddenEnumerator(IEnumerable<T> enu) 
     { 
      _actual = enu.GetEnumerator(); 
     } 

     public static HiddenEnumerator<T> Enumerable(IEnumerable<T> enu) 
     { 
      return new HiddenEnumerator<T>(enu); 
     } 

     public T Current 
     { 
      [DebuggerHidden] 
      get 
      { 
       T someThing = default(T); 
       try 
       { 
        someThing = _actual.Current; 
       } 
       catch 
       { 
        throw new Exception(); 
       } 
       return someThing; 
      } 
     } 

     public IEnumerator<T> GetEnumerator() 
     { 
      return this; 
     } 

     IEnumerator IEnumerable.GetEnumerator() 
     { 
      throw new NotImplementedException(); 
     } 

     public void Dispose() 
     { 
      _actual.Dispose(); 
     } 

     object IEnumerator.Current 
     { 
      get { return _actual.Current; } 
     } 

     [DebuggerHidden] 
     public bool MoveNext() 
     { 
       bool move = false; 
       try 
       { 
        move = _actual.MoveNext(); 
       } 
       catch 
       { 
        throw new IndexOutOfRangeException(); 
       } 
       return move; 
     } 

     public void Reset() 
     { 
      _actual.Reset(); 
     } 
    } 

Cách sử dụng:

 public IEnumerable<int> Power(int number, int exponent) 
     { 
      int counter = 0; 
      int result = 1; 
      while (counter++ < exponent) 
      { 
       if (result>Int16.MaxValue) throw new Exception(); 
       result = result * number; 
       yield return result; 
      } 
     } 

     public void UseIt() 
     { 
      foreach(var i in Power(Int32.MaxValue-1,5).Hide()) 
      { 
       Debug.WriteLine(i); 
      } 
     }