¿Por qué estas dos funciones no devuelven el mismo valor?

Question

Considérese este fragmento de código y tratar de adivinar lo que y1y2 y evaluar a

static class Extensions 
{ 
    public static Func<T> AsDelegate<T>(this T value) 
    { 
     return() => value; 
    } 
} 
class Program 
{ 
    static void Main(string[] args) 
    { 
     new Program(); 
    } 

    Program() 
    { 
     double x = Math.PI; 

     Func<double> ff = x.AsDelegate(); 
     Func<double> fg =() => x; 

     x = -Math.PI; 

     double y1 = ff(); // y1 = 3.141.. 
     double y2 = fg(); // y2 = -3.141.. 

    } 
} 

Se podría decir -Aha- doble es un tipo de valor por lo que el valor devuelto por el método de extensión es una copia de la principal x. Pero cuando cambias lo anterior en delegados de clases, los resultados aún son diferentes. Ejemplo:

class Foo 
{ 
    public double x; 
} 
    Program() 
    { 
     Foo foo = new Foo() { x=1.0 }; 

     Func<Foo> ff = foo.AsDelegate(); 
     Func<Foo> fg =() => foo; 

     foo = new Foo() { x = -1.0 }; 

     double y1 = ff().x; // y1 = 1.0 
     double y2 = fg().x; // y2 = -1.0 
    } 

De modo que las dos funciones deben devolver dos instancias diferentes de la misma clase. Es interesante considerar que ff() lleva consigo una referencia a la variable local foo, pero fg() no y se basa en lo que está actualmente en el alcance.

Entonces, ¿qué sucede cuando estos dos delegados pasan a otras partes del código que no tienen visibilidad en la instancia foo? De alguna manera, la cuestión de quién posee qué información (datos) es cada vez menos clara cuando los métodos de extensión se combinan con los delegados.

Answer 1

ff capturas (se une) al valor de x en esta línea:

Func<double> ff = x.AsDelegate(); 

Por el contrario, fg se une a la variable dex en esta línea:

Func<double> fg =() => x; 

Así , cuando el valor de x cambia, ff no se ve afectado, pero fg cambios.

Answer 2

() => x captura el valor x. La clase especial es creada por el compilador para manejar lambdas o delegados anónimos, se captura cualquier variable utilizada en el lambda.

Por ejemplo si ejecuta código siguiente:

List<Func<int>> list = new List<Func<int>>(); 

    for (int i = 0; i < 5; i++) 
    { 
     list.Add(() => i); 
    } 

    list.ForEach(function => Console.WriteLine(function())); 

verá que los números impresos son los mismos.

Answer 3

AsDelegate capta la variable value (el parámetro de AsDelegate), mientras que () => x capta la variable x. Por lo tanto, si cambia el valor de x, la expresión lambda devolverá un valor diferente. Cambiar x no cambia value embargo.

Ver: Outer Variable Trap

Answer 4

es necesario leer acerca closures in C#. Consulte también Wikipedia.

Answer 5

El método de extensión AsDelegate utiliza el valor de x en el momento AsDelegate se llama mientras que la expresión lambda () => x capta la variable x y por lo tanto el valor de x se toma en el momento se invoca la expresión (en lugar del valor cuando se Fue definido).

Answer 6

En AsDelegate, estamos capturando el argumento "valor". el valor de esta estructura se toma como una copia del valor de la variable en el momento en que se invoca el método, y nunca cambia, por lo que vemos el objeto original.

La lambda directa captura la variable de foo (no el valor de la variable - la propia variable) - por lo tanto nos hacemos ver cambios en este.

Básicamente, agregar una llamada al método cambió el muslo que se está capturando.

Answer 7

El primer método crea un nuevo delegado en una función determinada y lo almacena. Más tarde sobrescribe foo, su delegado recién creado no se toca.

El segundo es un expresión lambda que ascensores/* captura * su contexto, que significa que la variable foo. Todos los cambios en las variables que han sido levantadas por las expresiones lambdas son vistas por esa expresión lambda.