Cosa indica il punto finale su un tipo C#?

Question

Ho cercato un codice in un debugger associato al motore Razor View e ho notato che alcuni tipi appaiono in Debugger con un carattere punto finale alla fine del nome del tipo ad esempio:

{Nancy. ViewEngines.Razor.RazorViewEngine.}

Qualcuno sa cosa indica questo? Non è valida la sintassi per usarlo quando si specifica un cast su un oggetto, quindi sono incuriosito da ciò che indica all'interno del debugger.

EDIT: Come richiesto dal @Damien_The_Unbeliever, screenshot della variabile nel debugger:

E il codice che sto guardando:

public TCompiledView GetOrAdd<TCompiledView>(
      ViewLocationResult viewLocationResult, Func<ViewLocationResult, TCompiledView> valueFactory) 
     { 
      TCompiledView compiledView = default(TCompiledView); 
      compiledView = (TCompiledView)this.cache.GetOrAdd(viewLocationResult, x => valueFactory(x)); 

Per dare un Un po 'più di background, stiamo cercando di aggiungere il logging alla nostra Nancy View Cache per indagare su un problema intermittente con Razor Views che genera errori di compilazione, ma questo non è davvero rilevante per la ricerca ionico.

Answer 1

Ho visto accadere questo quando la variabile/valore è in realtà di un tipo generato dal compilatore (ad esempio per contenere le "variabili locali" catturate da un lambda, async, iteratore, ecc.). Il debugger (in vari punti) sembra non essere in grado di visualizzare il nome effettivo della classe.

---

E.g. questo programma di esempio:

class Program 
{ 
    static void Main(string[] args) 
    { 
     var p = new Program(); 
     p.DoStuff(); 
    } 

    void DoStuff() 
    { 
     int i = 19; 
     Expression<Func<int>> j =() => i + 10; 
     var k = (((j.Body as BinaryExpression).Left as MemberExpression).Expression as ConstantExpression).Value; 
     Console.ReadLine(); 
    } 
} 

Con un punto di interruzione Console.ReadLine(), troverete il tipo della classe k sembra Program. piuttosto che Program+<>_DisplayClass0

---

Aggiunta di Jeppe: Questo esempio è una leggera semplificazione di quanto sopra, evitando l'albero delle espressioni. Guarda l'istanza di un delegato Target che sarà un'istanza di una classe generata. Per il confronto guarda anche un tipo di blocco iteratore:

using System; 
using System.Collections.Generic; 

static class Program 
{ 
    static void Main() 
    { 
    int i = 19; // to be captured by lambda, will become field on a generated class 
    Func<int> f =() => i; 
    var target = f.Target; // when debugging type looks like "Program." 
    Console.WriteLine(target.GetType().ToString()); // writes "Program+<>c__DisplayClass1" 

    var seq = GetSeq(); // when debugging type looks like "Program.GetSeq" 
    Console.WriteLine(seq.GetType().ToString()); // writes "Program+<GetSeq>d__3" 
    } 

    static IEnumerable<int> GetSeq() // returns "state machine" (iterator block) 
    { 
    yield return 42; 
    } 
}