C# - cierres sobre campos de clase dentro de un inicializador?

Question

Considere el siguiente código:

using System; 

namespace ConsoleApplication2 
{ 
    class Program 
    { 
     static void Main(string[] args) 
     { 
      var square = new Square(4); 
      Console.WriteLine(square.Calculate()); 
     } 
    } 

    class MathOp 
    {   
     protected MathOp(Func<int> calc) { _calc = calc; } 
     public int Calculate() { return _calc(); } 
     private Func<int> _calc; 
    } 

    class Square : MathOp 
    { 
     public Square(int operand) 
      : base(() => _operand * _operand) // runtime exception 
     { 
      _operand = operand; 
     } 

     private int _operand; 
    } 
} 

(! Ignoran el diseño de la clase, no estoy realmente escribir una calculadora de este código representa meramente una repro mínimo para un problema mucho más grande que tomó un tiempo para reducir)

yo esperaría que sea:

• de impresión "16", O
• lanzar un error de tiempo de compilación si no se permite el cierre sobre un campo miembro en este escenario

En su lugar obtengo una excepción sin sentido lanzada en la línea indicada. En el 3.0 CLR es NullReferenceException; en el Silverlight CLR es el infame La operación podría desestabilizar el tiempo de ejecución.

Answer 1

No va a dar lugar a un error en tiempo de compilación porque es un cierre válido.

El problema es que this aún no se ha inicializado en el momento en que se creó el cierre. Su constructor no se ha ejecutado aún cuando se proporciona ese argumento. Entonces, el resultante NullReferenceException es bastante lógico. ¡Es this que es null!

Te lo demostraré. Vamos a reescribir el código de esta manera:

class Program 
{ 
    static void Main(string[] args) 
    { 
     var test = new DerivedTest(); 
     object o = test.Func(); 
     Console.WriteLine(o == null); 
     Console.ReadLine(); 
    } 
} 

class BaseTest 
{ 
    public BaseTest(Func<object> func) 
    { 
     this.Func = func; 
    } 

    public Func<object> Func { get; private set; } 
} 

class DerivedTest : BaseTest 
{ 
    public DerivedTest() : base(() => this) 
    { 
    } 
} 

¿Adivina qué se imprime? Sí, es true, el cierre devuelve null porque this no se inicializa cuando se ejecuta.

Editar

tenía curiosidad acerca de la declaración de Thomas, pensando que tal vez se había cambiado el comportamiento en una posterior VS liberación. De hecho, encontré un Microsoft Connect issue sobre esto mismo. Fue cerrado como "no arreglará". Impar.

Como dice Microsoft en su respuesta, normalmente no es válido utilizar la referencia this dentro de la lista de argumentos de una llamada al constructor base; la referencia simplemente no existe en ese momento y obtendrá un error en tiempo de compilación si intenta usarlo "desnudo". Entonces, podría decirse si produce un error de compilación para el caso de cierre, pero la referencia this está oculta del compilador, que (al menos en VS 2008) debería saber mirar dentro del cierre para evitar que las personas hagan esto. No es así, por lo que terminas con este comportamiento.

Answer 2

¿Ha intentado usar () => operand * operand en su lugar? El problema es que no hay certeza de que la operación se establecerá cuando llame a la base. Sí, está intentando crear un cierre en su método, y no hay garantía del orden de las cosas aquí.

Dado que no está configurando _operand en absoluto, yo recomendaría simplemente usar () => operand * operand en su lugar.

Answer 3

¿Qué tal esto:

using System; 
using System.Linq.Expressions; 

namespace ConsoleApplication2 
{ 
    class Program 
    { 
     static void Main(string[] args) 
     { 
      var square = new Square(4); 
      Console.WriteLine(square.Calculate()); 
     } 
    } 

    class MathOp 
    { 
     protected MathOp(Expression<Func<int>> calc) { _calc = calc.Compile(); } 
     public int Calculate() { return _calc(); } 
     private Func<int> _calc; 
    } 

    class Square : MathOp 
    { 
     public Square(int operand) 
      : base(() => _operand * _operand) 
     { 
      _operand = operand; 
     } 

     private int _operand; 
    } 
} 

Answer 4

Fue un error del compilador que se ha fijado. El código nunca debería haber sido legal en primer lugar, y si lo vamos a permitir, deberíamos haber generado al menos un código válido. Mi error. Perdon por el inconveniente.