DebuggerStepTrough ignorato

Question

Ho notato recentemente che il debugger di Visual Studio 2010 continua a saltare in questo metodo contrassegnato con l'attributo [DebuggerStepThrough].

Lo stack simile a questa:

1. Page.OnLoad chiama un metodo IsSubclassOfGeneric in una classe contrassegnata come [DebuggerStepThrough].
2. IsSubclassOfGeneric chiama GetHierarchy come mostrato, passando un'espressione lambda al estensione System.Linq.Enumerable.Any.
3. Visual Studio esegue il metodo come illustrato sopra.

Ho appena sostituito la chiamata Linq con un ciclo foreach, come di seguito, senza alcun risultato:

Questo è un po 'di un fastidio, dal momento che questo metodo viene chiamato abbastanza di frequente, e Non capisco perché l'attributo viene ignorato.

Answer 1

Prova questa semplice applicazione console, inserisci i punti di interruzione sulle linee indicate, esegui il debugger e sul primo punto di interruzione, premi il passaggio in (F11). Dovrebbe mancare il secondo punto di rottura. Otherwsie se potrebbe essere un'impostazione/estensione di Visual Studio che incasina le cose.

using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Text; 
using System.Diagnostics; 

namespace tmp { 
    class Program { 
     static void Main(string[] args) { 
      IEnumerable<Type> types = typeof(System.IO.IOException).GetHierarchy(typeof(System.Exception)); //break point here 
      int i = 0; 
     } 
    } 
    static class Ext { 
     //[DebuggerStepThrough] 
     //[DebuggerNonUserCode] 
     //[DebuggerStepperBoundary] 
     public static IEnumerable<Type> GetHierarchy(this Type type, Type limit) { 
      if (type == null) { //break point here 
       throw new Exception(); 
      } 
      do { 
       yield return type; 
       if (type == limit) { 
        yield break; 
       } 
      } while ((type = type.BaseType) != null); 
     } 

     [DebuggerStepThrough] 
     public static IEnumerable<Type> GetHierarchy2(this Type type, Type limit) { 
      if (type == null) { //break point here 
       throw new Exception(); 
      } 
      IList<Type> types = new List<Type>(); 
      do { 
       types.Add(type); 
       if (type == limit) { 
        break; 
       } 
      } while ((type = type.BaseType) != null); 
      return types; 
     } 
    } 
} 

EDIT

In realtà credo che abbia qualcosa a che fare con l'istruzione yield. Se provo a creare un elenco (GetHierarchy2), non ho alcun problema con l'attributo DebuggerStepThrough

Answer 2

Stai eseguendo il debug di un metodo di rilascio binario? Potrebbe essere ottimizzato e forse solo deterministico per il compilatore in fase di compilazione, in modo da non essere in grado di intervenire. Guarda l'IL generato e verifica se questo è il caso.