tipos - metodos anonimos c#

BackgroundWorker con métodos anónimos?

Question

Voy a crear un BackgroundWorker con un método anónimo.
He escrito el siguiente código:

BackgroundWorker bgw = new BackgroundWorker();
bgw.DoWork += new DoWorkEventHandler(
    () =>
    {
        int i = 0;
        foreach (var item in query2)
        {
            ....
            ....
        }
    }
);

Pero el delegado ''System.ComponentModel.DoWorkEventHandler'' no toma los argumentos ''0'' y tengo que pasar dos objetos al método anónimo: remitente del objeto, DoWorkEventArgs e

¿Podría por favor guiarme, cómo puedo hacerlo? Gracias.

Answer 1

Vamos a hacerlo simple

Las expresiones Lambda son realmente útiles para hacer el código más corto y más legible. Sin embargo, a los programadores de nivel de entrada les puede resultar un poco difícil tratar con ellos. Hay tres conceptos separados por los que se debe pasar: métodos anónimos, delegados y expresiones lambda. Un recorrido detallado de cada uno de ellos está fuera del alcance de esta respuesta. Espero que el ejemplo de código que se proporciona a continuación sirva para dar una vista rápida de los diferentes enfoques disponibles.

class TestBed
{
    BackgroundWorker bgw = new BackgroundWorker();
    void sample()
    {            
        //approach #1
        bgw.DoWork += new DoWorkEventHandler(bgw_DoWork);
        //DoWorkEventHandler is nothing but a readily available delegate written by smart Microsoft guys

        //approach #2, to make it a little shorter
        bgw.DoWork += (s,e) => 
        {
            //...
        };
        //this is called lambda expression (see the => symbol)

        //approach #3, if lambda scares you
        bgw.DoWork += delegate 
        { 
            //... (but you can''t have parameters in this approach
        };

        //approach #4, have a helper method to prepare the background worker
        prepareBgw((s,e)=>
        {
            //...
        }
        );

        //approach #5, helper along with a simple delegate, but no params possible
        prepareBgw(delegate 
        {
            //...
        }
        );

        //approach #6, helper along with passing the methodname as a delegate
        prepareBgw(bgw_DoWork);

        //approach #7, helper method applied on approach #1
        prepareBgw(new DoWorkEventHandler(bgw_DoWork));

    }

    void bgw_DoWork(object sender, DoWorkEventArgs e)
    {
        //...
    }
    void prepareBgw(DoWorkEventHandler doWork)
    {
        bgw.DoWork+= doWork;
    }
}

Tenga en cuenta que en este ejemplo usamos "delegar" y no "delegar" (hay una diferencia entre las dos)

Answer 2

Si especifica un lambda, debe asegurarse de que toma el mismo número de argumentos:

bgw.DoWork += (s, e) => ...;

Pero si no está utilizando los argumentos, podría usar un delegado anónimo sin parámetros:

bgw.DoWork += delegate
{
    ...
};

Answer 3

Si has escrito lo anterior sin lambdas ¿cómo sería?

backgroundWorker1.DoWork += 
                new DoWorkEventHandler(backgroundWorker1_DoWork);

y el método nombrado:

private void backgroundWorker1_DoWork(object sender, 
        DoWorkEventArgs e)
    {   
        // Get the BackgroundWorker that raised this event.
        BackgroundWorker worker = sender as BackgroundWorker;

        // Assign the result of the computation
        // to the Result property of the DoWorkEventArgs
        // object. This is will be available to the 
        // RunWorkerCompleted eventhandler.
        e.Result = ComputeFibonacci((int)e.Argument, worker, e);
    }

Pero ahora está utilizando lambdas sin variables enlazadas () => Debe proporcionar dos objetos remitente y e (que se deducirán del tipo más adelante).

backgroundWorker1.DoWork += (sender, e) => ...

Answer 4

Solo necesita agregar parámetros a la función anónima:

bgw.DoWork += (sender, e) => { ... }

O si no te importan los parámetros puedes simplemente:

bgw.DoWork += delegate { ... }