What does the trailing dot on a C# type indicate?

Question

I've been looking at some code in a debugger associated with Razor View engine and I noticed that some of the types appear in Debugger with a trailing dot character at the end of the type name e.g.:

{Nancy.ViewEngines.Razor.RazorViewEngine.}

Does anyone know what this indicates? It's not valid syntax to use it when specifying a cast on an object so I'm intrigued as to what it indicates within the debugger.

EDIT: As requested by @Damien_The_Unbeliever, screenshot of the variable in debugger:

And the code that I'm looking at:

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

To give a little more background, we're trying to add logging to our Nancy View Cache to investigate an intermittent issue with Razor Views throwing compilation errors, but that isn't really relevant to the question.

Answer 1

I've seen this happen when the variable/value is actually of a compiler generated type (e.g. for holding the "local variables" captured by a lambda, async, iterator, etc). The debugger (in various places) seems unable to display the actual class name.

---

E.g. this example program:

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

With a breakpoint on Console.ReadLine(), you'll find the k class's type looks like Program. rather than Program+<>_DisplayClass0

---

Addition by Jeppe: This example is a slight simplification of the above, avoiding the expression tree. Looks at a delegate instance's Target which will be an instance of a generated class. For comparison also looks at an iterator block type:

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