[c#] ¿Cuándo usarías delegados en C #?



Answers

Los delegados son muy útiles para muchos propósitos.

Uno de estos propósitos es usarlos para filtrar secuencias de datos. En este caso, usaría un delegado de predicado que acepta un argumento y devuelve verdadero o falso dependiendo de la implementación del delegado.

Aquí hay un ejemplo tonto: estoy seguro de que puedes extrapolar algo más útil a partir de esto:

using System;
using System.Linq;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        List<String> names = new List<String>
        {
            "Nicole Hare",
            "Michael Hare",
            "Joe Hare",
            "Sammy Hare",
            "George Washington",
        };

        // Here I am passing "inMyFamily" to the "Where" extension method
        // on my List<String>.  The C# compiler automatically creates 
        // a delegate instance for me.
        IEnumerable<String> myFamily = names.Where(inMyFamily);

        foreach (String name in myFamily)
            Console.WriteLine(name);
    }

    static Boolean inMyFamily(String name)
    {
        return name.EndsWith("Hare");
    }
}
Question

¿Cuál es su uso de delegados en C #?




  1. Para el controlador de eventos

  2. Pasar el método en los parámetros de un método




Un ejemplo podría ser como se ve here . Usted tiene un método para procesar un objeto que cumple con ciertos requisitos. Sin embargo, desea poder procesar el objeto de múltiples maneras. En lugar de tener que crear métodos separados, puede simplemente asignar un método de coincidencia que procese el objeto a un delegado y pasar el delegado al método que selecciona los objetos. De esta forma, puede asignar diferentes métodos al método de un solo selector. Traté de hacer esto fácilmente comprensible.




Me estoy metiendo en esto muy tarde pero estaba teniendo problemas para entender el propósito de los delegados de hoy y escribí dos programas sencillos que dan el mismo resultado que creo que explica bien su propósito.

NoDelegates.cs

using System;

public class Test {
    public const int MAX_VALUE = 255;
    public const int MIN_VALUE = 10;

    public static void checkInt(int a) {
        Console.Write("checkInt result of {0}: ", a);
        if (a < MAX_VALUE && a > MIN_VALUE)
            Console.WriteLine("max and min value is valid");
        else
            Console.WriteLine("max and min value is not valid");
    }

    public static void checkMax(int a) {
        Console.Write("checkMax result of {0}: ", a);
        if (a < MAX_VALUE)
            Console.WriteLine("max value is valid");
        else
            Console.WriteLine("max value is not valid");
    }

    public static void checkMin(int a) {
        Console.Write("checkMin result of {0}: ", a);
        if (a > MIN_VALUE)
            Console.WriteLine("min value is valid");
        else
            Console.WriteLine("min value is not valid");
        Console.WriteLine("");
    }
}

public class Driver {
    public static void Main(string [] args) {
        Test.checkInt(1);
        Test.checkMax(1);
        Test.checkMin(1);

        Test.checkInt(10);
        Test.checkMax(10);
        Test.checkMin(10);

        Test.checkInt(20);
        Test.checkMax(20);
        Test.checkMin(20);

        Test.checkInt(30);
        Test.checkMax(30);
        Test.checkMin(30);

        Test.checkInt(254);
        Test.checkMax(254);
        Test.checkMin(254);

        Test.checkInt(255);
        Test.checkMax(255);
        Test.checkMin(255);

        Test.checkInt(256);
        Test.checkMax(256);
        Test.checkMin(256);
    }
}

Delegates.cs

using System;

public delegate void Valid(int a);

public class Test {
    public const int MAX_VALUE = 255;
    public const int MIN_VALUE = 10;

    public static void checkInt(int a) {
        Console.Write("checkInt result of {0}: ", a);
        if (a < MAX_VALUE && a > MIN_VALUE)
            Console.WriteLine("max and min value is valid");
        else
            Console.WriteLine("max and min value is not valid");
    }

    public static void checkMax(int a) {
        Console.Write("checkMax result of {0}: ", a);
        if (a < MAX_VALUE)
            Console.WriteLine("max value is valid");
        else
            Console.WriteLine("max value is not valid");
    }

    public static void checkMin(int a) {
        Console.Write("checkMin result of {0}: ", a);
        if (a > MIN_VALUE)
            Console.WriteLine("min value is valid");
        else
            Console.WriteLine("min value is not valid");
        Console.WriteLine("");
    }
}

public class Driver {
    public static void Main(string [] args) {
        Valid v1 = new Valid(Test.checkInt);
        v1 += new Valid(Test.checkMax);
        v1 += new Valid(Test.checkMin);
        v1(1);
        v1(10);
        v1(20);
        v1(30);
        v1(254);
        v1(255);
        v1(256);
    }
}



Inicialización de parámetros perezosos! Además de todas las respuestas anteriores (patrón de estrategia, patrón de observador, etc.), los delegados le permiten manejar la inicialización lenta de los parámetros. Por ejemplo, supongamos que tiene una función Descargar () que lleva bastante tiempo y devuelve un determinado DownloadedObject. Este objeto es consumido por un Almacenamiento dependiendo de ciertas Condiciones. Por lo general, usted:

storage.Store(conditions, Download(item))

Sin embargo, con los delegados (más precisamente, lambdas) puede hacer lo siguiente, cambiando la firma de la tienda para que reciba una Condición y un Func <Artículo, un Objeto Descargado> y úselo de esta manera:

storage.Store(conditions, (item) => Download(item))

Por lo tanto, el almacenamiento solo evaluará al delegado si es necesario, y ejecutará la descarga en función de las Condiciones.




Eventos, otras operaciones de anynch




El parámetro de comparación en In Array.Sort (T [] array, Comparación de comparación), List.Sort (Comparación de comparación), etc.




Los delegados se utilizan para llamar a un método por su referencia. Por ejemplo:

  delegate void del_(int no1,int no2);
class Math
{
   public static void add(int x,int y)
   {
     Console.WriteLine(x+y);
   }
   public static void sub(int x,int y)
   {
     Console.WriteLine(x-y);
   }
}



    class Program
    {
        static void Main(string[] args)
        {
            del_ d1 = new del_(Math.add);
            d1(10, 20);
            del_ d2 = new del_(Math.sub);
            d2(20, 10);
            Console.ReadKey();
        }
    }



Puede usar delegados para declarar variables y parámetros de tipo función.

Ejemplo

Considere el patrón de "préstamo de recursos". Desea controlar la creación y la limpieza de un recurso, al mismo tiempo que permite que el código del cliente "tome prestado" el recurso intermedio.

Esto declara un tipo de delegado.

public delegate void DataReaderUser( System.Data.IDataReader dataReader );

Cualquier método que coincida con esta firma se puede usar para crear instancias de un delegado de este tipo. En C # 2.0, esto se puede hacer implícitamente, simplemente usando el nombre del método, así como usando métodos anónimos.

Este método usa el tipo como un parámetro. Tenga en cuenta la invocación del delegado.

public class DataProvider
{
    protected string _connectionString;

    public DataProvider( string psConnectionString )
    {
        _connectionString = psConnectionString;
    }

    public void UseReader( string psSELECT, DataReaderUser readerUser )
    {
        using ( SqlConnection connection = new SqlConnection( _connectionString ) )
        try
        {
            SqlCommand command = new SqlCommand( psSELECT, connection );
            connection.Open();
            SqlDataReader reader = command.ExecuteReader();

            while ( reader.Read() )
                readerUser( reader );  // the delegate is invoked
        }
        catch ( System.Exception ex )
        {
            // handle exception
            throw ex;
        }
    }
}

La función se puede llamar con un método anónimo de la siguiente manera. Tenga en cuenta que el método anónimo puede usar variables declaradas fuera de sí mismo. Esto es extremadamente útil (aunque el ejemplo es un poco artificial).

string sTableName = "test";
string sQuery = "SELECT COLUMN_NAME FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_NAME='" + sTableName + "'";

DataProvider.UseReader( sQuery,
    delegate( System.Data.IDataReader reader )
    {
        Console.WriteLine( sTableName + "." + reader[0] );
    } );



Los delegados se usan cada vez que usa eventos: ese es el mecanismo por el que funcionan.

Además, los delegados son muy útiles para cosas como el uso de consultas LINQ. Por ejemplo, muchas consultas LINQ toman un delegado (a menudo Func<T,TResult> ) que se puede usar para filtrar.




Links