Hasta hace poco siempre había pensado que en C# las expresiones lambda se compilaban siempre como clases, pero charlando en twitter sobre cómo se compilan en Java 8, @__josejuan__ puso un ejemplo en el que se veía claramente que se compilaban como métodos de la clase que las contiene:

Al principio pensé que era algo relativo a la versión del framework, pero como esa explicación no me acababa de cuadrar, no he podido resistirme a investigar un poco más.

OJO: Como se explica en la especificación de C# (sección 6.5.2) todo esto es un detalle de implementación, por lo que podría cambiar en futuras versiones.

Para decidir cómo compilar una expresión lambda, el compilador distingue dos casos:

• Funciones que no usan ninguna variable externa a la función.
• Funciones que usan variables externas a la función.

Funciones que no dependen de variables externas

El primer caso sería una función como ésta:

public static void Main(string[] args)
{
  Func<int, int, int> f = (a,b) => a + b;

  Console.WriteLine(f(2, 3));
}

En este caso, la función f no depende de ninguna variable externa a la función, sólo depende de sus parámetros: a y b. Por ello, es posible representarla como un método estático en la clase en que está declarada y eso es lo que hace el compilador de C#, genera un método estático parecido a esto:

[CompilerGenerated]
private static int <Main>__0(int a, int b)
{
  return a + b;
}

Al tener este método, se puede reescribir el código original como:

public static void Main(string[] args)
{
  var f = new Func<int, int, int>(<Main>__0);

  Console.WriteLine(f(2, 3));
}

Funciones que usan variables externas

Si la función utiliza variables externas a ella, tendríamos un caso como éste:

public static void Main(string[] args)
{
  var someValue = 17;

  Func<int, int> g = a => someValue + a;
  Console.WriteLine(g(3));
}

En este caso la función depende de un valor externo a ella (someValue), por lo que no se puede aplicar la misma técnica que en el ejemplo anterior y lo que hace el compilador es generar una clase más o menos así:

[CompilerGenerated]
private sealed class <>__DisplayClass3
{
  public int someValue;

  public int <>b__1(int a)
  {
    return this.someValue+ a;
  }
}

La clase mantiene referencias a aquellas variables externas que son usadas por la función, de manera que luego se puedan utilizar al “invocar” la función a través del método <>b__1. Con esto se puede reescribir el código original como:

public static void Main(string[] args)
{
  var someValue = 17;

  var g = new <>__DisplayClass3();
  g.someValue = someValue;

  Console.WriteLine(g.<>b__1(3))
}

Resumen

Aunque la técnica de crear clases es lo suficientemente flexible como para cubrir los dos casos de uso, el compilador de C# es bastante avanzado y es capaz de optimizar el código que genera, evitando crear clases si no es necesario.

Y recuerda que esto es un detalle de implementación que podría cambiar en futuras versiones del framework o del compilador, por lo que no deberías basarte en este comportamiento para nada.