c# - que - Acción para delegar: ¿nueva acción o acción de lanzamiento?

proceso para delegar en las organizaciones

Question

Encontré dos formas diferentes de inicializar un delegado con una acción:

Crea una nueva acción o conversión a Acción.

Delegate foo = new Action(() => DoNothing(param));
Delegate bar = (Action)(() => DoNothing(param));

¿Hay alguna diferencia entre estas 2 sintaxis?

¿Cuál es mejor y por qué?

Editar:
El delegado se usa en este ejemplo porque la sintaxis es útil para llamar a métodos como BeginInvoke o Invoke con una expresión lambda, y es importante convertir la expresión lambda en una acción.

static main 
{
    Invoke((Action)(() => DoNothing())); // OK
    Invoke(new Action(() => DoNothing())); // OK
    Invoke(() => DoNothing()); // Doesn''t compil
}

private static void Invoke(Delegate del) { }

Pero es interesante ver que el compilador autorizó esto:

Action action = () => DoNothing();
Invoke(action);

Answer 1

En mi opinión, no hay diferencia.

new Action(() => DoNothing(param));

Esto solo crea una nueva Acción y pasa a lo largo de una expresión Lambda, que el compilador tratará y se asegurará de que todo esté bien conectado.

(Action)(() => DoNothing(param));

Esto funciona porque un método lambda como este no devuelve ningún valor y no toma ningún parámetro, como tal, el compilador puede verificar que es "asignable" a una Acción basándose en que pasa por el sistema delegado.

Son más o menos uno y lo mismo, dependiendo de cualquier tipo de optimizaciones de compilador, es difícil decir cuál es más eficiente, quizás debería probar el rendimiento y verlo usted mismo.

Es una pregunta interesante y una exploración del sistema de delegación y cómo Linq y Expressions encajan.

new Func<string>(() => "Boo!");

es más o menos equivalente a:

(Func<String>)() => "Boo!";

Por lo que sé, ambos terminan descendiendo por el sistema de delegados, piensan en Invoke() , etc., sería interesante si probaran el rendimiento y compartieran sus resultados.

Answer 2

No hay diferencia entre estas dos instrucciones. En ambas instrucciones, se crea una nueva instancia de Acción.

El código IL a continuación parece confirmar esto.

Programa de consola:

class Program
{
    static void Main(string[] args)
    {
        Delegate barInit = (Action)(() => DoNothing());
        Delegate fooInit = new Action(() => DoNothing());
    }

    private static void DoNothing() { }
}

Código IL:

// First instruction
IL_0000: ldsfld class [mscorlib]System.Action CodeMachineTest.Program::''CS$<>9__CachedAnonymousMethodDelegate2''
IL_0005: brtrue.s IL_0018

IL_0007: ldnull
IL_0008: ldftn void CodeMachineTest.Program::''<Main>b__0''()

// Create a new Action instance for the instruction (Action)(() => DoNothing())
IL_000e: newobj instance void [mscorlib]System.Action::.ctor(object, native int)

IL_0013: stsfld class [mscorlib]System.Action CodeMachineTest.Program::''CS$<>9__CachedAnonymousMethodDelegate2''

IL_0018: ldsfld class [mscorlib]System.Action CodeMachineTest.Program::''CS$<>9__CachedAnonymousMethodDelegate2''
IL_001d: pop

// Second instruction
IL_001e: ldsfld class [mscorlib]System.Action CodeMachineTest.Program::''CS$<>9__CachedAnonymousMethodDelegate3''
IL_0023: brtrue.s IL_0036

IL_0025: ldnull
IL_0026: ldftn void CodeMachineTest.Program::''<Main>b__1''()
IL_002c: newobj instance void [mscorlib]System.Action::.ctor(object, native int)
IL_0031: stsfld class [mscorlib]System.Action CodeMachineTest.Program::''CS$<>9__CachedAnonymousMethodDelegate3''

IL_0036: ldsfld class [mscorlib]System.Action CodeMachineTest.Program::''CS$<>9__CachedAnonymousMethodDelegate3''
IL_003b: pop
IL_003c: ret

Answer 3

No hay diferencia, solo son dos sintaxis para lo mismo. Personalmente, utilizo el último, porque es más corto.

Pero, ¿por qué necesitas una variable de tipo Delegate ? En la mayoría de los casos, desea que la variable tenga el mismo tipo que la instancia, y luego puede usar

var bar = (Action)(() => DoNothing(param));

o

Action bar = () => DoNothing(param);

en lugar de

Delegate bar = (Action)(() => DoNothing(param));  // (from your question)