¿Qué es Delegate? [cerrado]

Un delegado es simplemente un puntero de función.
simplemente asigne el método que desea ejecutar su delegado. luego, más adelante en code, puede llamar a ese método a través de Invoke.

Algún código para demostrar (escribió esto de memoria para que la sintaxis pueda estar desactivada)

delegate void delMyDelegate(object o);

private void MethodToExecute1(object o)
{
    // do something with object
}

private void MethodToExecute2(object o)
{
    // do something else with object
}

private void DoSomethingToList(delMyDelegate methodToRun)
{
    foreach(object o in myList)
        methodToRun.Invoke(o);
}

public void ApplyMethodsToList()
{
    DoSomethingToList(MethodToExecute1);
    DoSomethingToList(MethodToExecute2);
}

Tomado de aquí

P ¿Qué son los delegados?
A Cuando un objeto recibe una solicitud, el objeto puede manejar la solicitud en sí o pasar la solicitud a un segundo objeto para hacer el trabajo. Si el objeto decide pasar la solicitud, usted dice que el objeto ha reenviado la responsabilidad de manejar la solicitud al segundo objeto.

O, como un sencillo pseudo ejemplo: algo envía una solicitud a object1. object1 then forwards la petición y sí mismo a objeto2 the el delegado. object2 procesa la solicitud y hace algún trabajo. (nota: el enlace anterior da buenos ejemplos)

Piense en delegate como en una implementación simplificada del patrón de comandos.

Un delegado es un objeto que puede referirse a un método. Por lo tanto, cuando creamos un delegado, estamos creando un objeto que puede contener una referencia a un método. Además, el método se puede llamar a través de esta referencia. Por lo tanto, un delegado puede invocar el método al que se refiere. La principal ventaja de un delegado es que nos permite especificar una llamada a un método, pero el método realmente invocado se determina en tiempo de ejecución, no en tiempo de compilación.

Simple Delegate

Declaration of delegate:
delegate-modifier delegate return-type delegate-name(parameters)
Implementation of delegate:
Delegate-name delegate-object=new Delegate-name(method of class)

Http://knowpacific.wordpress.com/2012/01/26/delegate /

Aquí voy a explicar los delegados, los delegados multicast y su uso.. Delegate es un tipo que contiene la referencia de método(s) en un objeto. También se conoce como un puntero de función de tipo seguro. Podemos decir que un delegado es un tipo que define una firma de método.

Cuando crea una instancia de un delegado, puede asociar su instancia con cualquier método con una firma compatible. Puede invocar (o llamar) el método a través de la instancia delegada. Los delegados se utilizan para aprobar los métodos como argumentos a otros métodos. Los controladores de eventos no son más que métodos que se invocan a través de delegados. Las ventajas de usar delegados son, Encapsular la llamada del método desde el llamante El uso eficaz de delegate mejora el rendimiento de la aplicación Se usa para llamar a un método de forma asíncrona. Hay algunas propiedades de los delegados son

Delegates are like C++ function pointers but are type safe.
Delegates allow methods to be passed as parameters.
Delegates can be used to define callback methods.
Delegates can be chained together; for example, multiple methods can be called on a single event.
Methods do not have to match the delegate signature exactly.

Public delegate type_of_delegate delegate_name () / / Declaration

You can use delegates without parameters or with parameter list
If you are referring to the method with some data type then the delegate which you are declaring should be in the same format. This is why it is referred to as type safe function pointer. Here I am giving an example with String.

El siguiente ejemplo muestra un delegado operación:

    namespace MyDelegate
    {
        class Program
        {
            private delegate void Show(string s);


            // Create a method for a delegate.
            public static void MyDelegateMethod(string me

ssage)
        {
            System.Console.WriteLine(message);
        }

        static void Main(string[] args)
        {
            Show p = MyDelegateMethod;
            p("My Delegate");
            p.Invoke("My Delegate");
            System.Console.ReadLine();
        }
    }
}

Qué es Multicast Delegate?

Es un delegado que contiene la referencia de más de un método. Los delegados de multidifusión solo deben contener métodos que devuelvan void, de lo contrario hay una excepción en tiempo de ejecución.

 delegate void MyMulticastDelegate(int i, string s);
 Class Class2
 {
  static void MyFirstDelegateMethod(int i, string s)
  {
    Console.WriteLine("My First Method");
  }

  static void MySecondDelegateMethod(int i, string s)
  {
    Console.WriteLine("My Second Method");
  }

  static void Main(string[] args)
  {
    MyMulticastDelegate Method= new MyMulticastDelegate(MyFirstDelegateMethod);
    Method+= new MyMulticastDelegate (MySecondDelegateMethod);
    Method(1,"Hi");             // Calling 2 Methodscalled
    Method-= new MyMulticastDelegate (MyFirstDelegateMethod);
    Method(2,"Hi");             //Only 2nd Method calling
  }
}

Aquí Delegate se agrega usando el operador += y se elimina usando el operador -=.

Los tipos de delegados se derivan de la clase Delegate en.NET Framework. Los tipos de delegados están sellados - no se pueden derivar. Porque el el delegado instanciado es un objeto, puede pasarse como parámetro o asignarse a una propiedad. Esto permite que un método acepte un delegado como parámetro, y llame al delegado en algún momento posterior. Esto se conoce como devolución de llamada asíncrona.

Una gran explicación e implementación práctica del patrón Delegado se puede encontrar en las clases Google Collections Forwarding (también, el patrón Decorador).

En la comunicación de eventos, el remitente no sabe qué objeto manejará el evento. Delegate es el tipo que contiene la referencia del método. El delegado tiene firma y contiene referencia al método que coincide con su firma por lo tanto, Delegar es como el tipo puntero de función segura.

Button1.Haga clic en + = nuevo sistema.EventHandler (button1_Click) Sistema.EventHandler es declarado como delegado aquí En los eventos. net se trabaja en el concepto de Delegado (Clic en el botón me gusta)

Delegate se usa cuando no lo hace saber qué código invocar en tiempo de ejecución Entonces, en ese momento, Delegate se usa para manejar eventos

Http://msdn.microsoft.com/en-us/library/ms173171 (v=vs.80). aspx

A objeto delegado es un objeto que otro objeto consulta cuando algo sucede en ese objeto. Para por ejemplo, tu reparador es tu delegado si algo le pasa a tu coche. usted va a su reparador y le pide que arregle el coche para usted (aunque algunos prefieren reparar el coche ellos mismos, en cuyo caso, son su propio delegado para su coche).

Un delegado es un objeto que representa un puntero a una función. Sin embargo, no es un puntero de función ordinario en que:

1) Está Orientado A Objetos

2) Es seguro de tipo, es decir, solo puede apuntar a un método y no puede leer la dirección de memoria raw a la que apunta

3) Está fuertemente escrito. Solo puede apuntar a métodos que coincidan con sus firmas.

4) Puede apuntar a más de un método al mismo tiempo.

Delegates se utiliza principalmente con eventos.

La necesidad es:

No desea ejecutar un fragmento de código en el momento en que ejecuta el programa. Después de ejecutar el programa que desea ejecutar esa pieza de código cada vez que se produce un evento.

Ejemplo :

1. Aplicación de consola - el código solo se puede ejecutar en el momento en que se ejecuta el programa. (Escrito dentro del método principal)
2. Aplicación de Windows (interfaz de usuario programación) - el código se puede ejecutar al hacer clic en el botón después de ejecutar el programa.

Esto es lo que dicen, no sabes qué método invocará en el momento de la compilación. solo lo sabes en tiempo de ejecución, es decir, al hacer clic en el botón.

Sin delegados no es posible programar la interfaz de usuario. Debido a que está ejecutando código cada vez que el usuario realiza eventos que está haciendo clic en el botón , escribiendo en el cuadro de texto, seleccionando elemento de lista desplegable y así sucesivamente....

Un delegado es algo a lo que se está delegando una tarea. El propósito principal de la delegación es desacoplar el código y permitir una mayor flexibilidad y reutilización.

En la programación, y específicamente en la programación orientada a objetos, esto significa que cuando un método es llamado para hacer algún trabajo, pasa el trabajo al método de otro objeto al que tiene una referencia. La referencia podría apuntar a cualquier objeto que deseemos, siempre y cuando el objeto se ajuste a un conjunto predefinido de métodos. Lo llamamos "programación a una interfaz" (versus programación a una implementación de clase concreta). Una interfaz es básicamente una plantilla genérica y no tiene implementación; simplemente significa una receta, un conjunto de métodos, precondiciones y postcondiciones (reglas).

Ejemplo simple:

SomeInterface
{
   public void doSomething();
}


SomeImplementation implements SomeInterface
{
   public void doSomething()
   {
      System.err.println("Was it good for you?");
   }

}


SomeCaller
{
   public void doIt(SomeInterface someInterface)
   {
      someInterface.doSomething();
   }
}

Ahora ves que puedo usar cualquier implementación que quiera en cualquier momento sin cambiar el código en SomeCaller porque el tipo que doIt() se pasa no es concreto sino más bien abstracto ya que es un interfaz. En el mundo de Java, esto a menudo se expresa en el paradigma de servicio donde se llama a un servicio (un objeto que se anuncia a sí mismo como un servicio a través de una interfaz específica) y el servicio luego llama a los delegados para ayudarlo a hacer su trabajo. Los métodos del servicio se nombran como tareas de grano grueso (makePayment (), createNewUser (), etc.), mientras que internamente hace mucho trabajo a través de la delegación, con los tipos de delegados siendo interfaces en lugar del concreto aplicación.

SomeService
{
    SomeInterface someImplementation = ... // assign here
    SomeOtherInterface someOtherImplementation = ... // okay, let's add a second

    public void doSomeWork()
    {
         someImplementation.doSomething();
         someOtherImplementation.doSomethingElse();
    }
}

(N.B.: Cómo se asigna una implementación está más allá del alcance de este hilo. Inversión de búsqueda de control e inyección de dependencias.)

Si bien no es realmente un "puntero de función", un delegado podría parecer que este es un lenguaje dinámico como PHP:

$func = 'foo';
$func();

function foo() {
    print 'foo';
}

O en JavaScript podrías hacer algo como:

var func = function(){ alert('foo!'); }
func();