¿Cómo combinar DebuggerHidden con métodos de bloques de iteradores?

Question

DebuggerHidden es bastante práctico para el marcado de los métodos de ayuda, asegurándose de que las excepciones no controladas detienen el depurador en un lugar conveniente:

                 

Desafortunadamente, esto no parece trabajar con bloques de iterador:

         

(si lo hiciera, el depurador mostraría in como la instrucción actual en el segundo ejemplo).

Si bien esto es obviamente una limitación de Visual Studio (para el que tengo submitted a report), ¿hay alguna manera de que pueda evitar este problema mientras sigo usando un bloque de iterador?

Supongo que esto sucede porque el código generado por el compilador para implementar el iterador no está marcado con [DebuggerHidden]. Tal vez haya alguna forma de convencer al compilador para que haga eso.

Answer 1

Quizás no sea la respuesta que esperaba, pero como solución alternativa podría obtener algunos puntos ... no estoy seguro de si ya lo había soñado.

Tiene una clase de ayuda que desenvuelve su iterador y luego usa un método de extensión para poner el envoltorio en juego en su iterador. Manejo de excepciones y vuelvo a lanzar. En VS2010 tuve que desmarcar de forma extraña la opción de depuración 'Habilitar solo mi código' para obtener un comportamiento cercano a lo que OP pedía. Dejar la opción marcada aún te deja en el iterador real, pero ik parece una línea demasiado lejos.

Eso hace que esta respuesta sea más un experimento para probar y respaldar que se necesita una mejor compatibilidad del compilador para que el escenario funcione.

extensión de clase método de ayuda:

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

Envoltura:

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

Uso:

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