Delegate (Clase)

La clase Delegate es la clase base para los tipos de delegado. No obstante, el sistema y los compiladores son los únicos que pueden derivar explícitamente a partir de la clase Delegate o de la clase MulticastDelegate. Tampoco está permitido derivar un tipo nuevo a partir de un tipo de delegado. La clase Delegate no se considera un tipo de delegado; es una clase que se utiliza para derivar tipos de delegado.

La mayoría de los lenguajes implementan una palabra clave delegate y los compiladores de dichos lenguajes pueden derivar a partir de la clase MulticastDelegate; por lo tanto, los usuarios deben emplear la palabra clave delegate que proporciona el lenguaje.

Nota
Common Language Runtime proporciona un método Invoke para cada tipo de delegado, con la misma firma que el delegado. No tiene que llamar explícitamente a este método desde C#, Visual Basic o Visual C++, porque los compiladores lo llaman automáticamente. El método Invoke es útil en reflexión cunado se desea buscar la firma del tipo de delegado.

Common Language Runtime proporciona a cada tipo de delegado los métodos EndInvoke y BeginInvoke, para habilitar la invocación asincrónica del delegado. Para obtener más información sobre estos métodos, vea Llamar a métodos sincrónicos de forma asincrónica.

La declaración de un tipo de delegado establece un contrato que especifica la firma de uno o varios métodos. Un delegado es una instancia de un tipo de delegado que contiene referencias a:

• Un método de instancia de un tipo y un objeto de destino asignable a ese tipo.

• Un método de instancia de un tipo, con el parámetro this oculto expuesto en la lista de parámetros formales. Se dice que el delegado es un delegado de instancia abierto.

• Un método estático.

• Un método estático y un objeto de destino asignable al primer parámetro del método. Se dice que el delegado se cierra en su primer argumento.

Para obtener más información sobre los enlaces delegados, vea la sobrecarga del método CreateDelegate(Type, Object, MethodInfo, Boolean).

Nota
En las versiones 1.0 y 1.1 de .NET Framework, un delegado sólo puede representar un método si la firma del método coincide exactamente con la firma que especifica el tipo de delegado. Por tanto, sólo se admiten los puntos primero y tercero de la anterior lista y, en el caso del primero, es necesaria una coincidencia exacta de tipos.

Cuando un delegado representa un método de instancia cerrado en su primer argumento (el caso más habitual), el delegado almacena una referencia al punto de entrada del método y una referencia a un objeto, el objeto de destino, que es de un tipo asignable al tipo que define el método. Cuando un delegado representa un método de instancia abierto, almacena una referencia al punto de entrada del método. La firma del delegado debe incluir el parámetro this oculto en su lista de parámetros formales; en este caso, el delegado no tiene una referencia a un objeto de destino, por lo que se debe proporcionar un objeto de destino al invocar al delegado.

Cuando un delegado representa un método estático, el delegado almacena una referencia al punto de entrada del método. Cuando un delegado representa un método estático cerrado en su primer argumento, el delegado almacena una referencia al punto de entrada del método y una referencia a un objeto de destino asignable al tipo del primer argumento del método. Al invocar al delegado, el primer argumento del método estático recibe el objeto de destino.

La lista de invocaciones de un delegado es un conjunto ordenado de delegados donde cada elemento de la lista invoca exactamente a uno de los métodos representados por el delegado. Una lista de invocaciones puede contener métodos duplicados. Durante una invocación, los métodos se llaman en el orden en que aparecen en la lista de invocaciones. Un delegado intenta invocar a todos los métodos de la lista de invocaciones; se invoca a los duplicados una vez por cada aparición en la lista de invocaciones. Los delegados son inmutables; una vez creados, la lista de invocaciones de un delegado no cambia.

Se dice que los delegados son de multidifusión y combinables, porque un delegado puede invocar uno o varios métodos y se puede utilizar para combinar operaciones.

Las operaciones de combinación, como Combine y Remove, no modifican los delegados existentes. En lugar de ello, una operación de este tipo devuelve un nuevo delegado que contiene los resultados de la operación, un delegado sin modificar o null. Una operación de combinación devuelve null cuando el resultado de la operación es un delegado que no hace referencia a un método como mínimo. Una operación de combinación devuelve un delegado sin modificar cuando la operación solicitada no tiene efecto.

Nota
Los lenguajes administrados usan los métodos Remove y Combine para implementar las operaciones de delegado. Entre los ejemplos se incluyen las instrucciones AddHandler y RemoveHandler en Visual Basic y los operadores += y -= en tipos de delegados en C#.

Al iniciar con .NET Framework 4, los tipos de delegado genérico pueden tener parámetros de tipo variante. Puede usar parámetros de tipo contravariante como tipos de parámetro del delegado y un parámetro de tipo covariante se puede usar como tipo devuelto. Esta característica permite tipos de delegado genérico que se construyen de la misma definición de tipo genérico para ser compatible con la asignación si sus argumentos de tipo son los tipos de referencia con una relación de herencia, tal y como se explica en Covarianza y contravarianza en genéricos.

Nota

Los delegados genéricos que son compatibles con asignaciones debido a la desviación no son necesariamente combinables. Para ser combinables, los tipos deben coincidir exactamente. Por ejemplo, supongamos que una clase denominada Derived se deriva de una clase denominada Base. Un delegado de tipo Action<Base> (Action(Of Base) en Visual Basic) se puede asignar a una variable de tipo Action<Derived>, pero dos delegados no se pueden combinar porque los tipos no coinciden exactamente.

Si un método invocado produce una excepción, el método deja de ejecutarse, la excepción se pasa de nuevo al llamador del delegado y no se invoca al resto de los métodos de la lista de invocaciones. Aunque la excepción se detecte en el llamador, este comportamiento no cambia.

Cuando la firma de los métodos invocados por un delegado incluye un valor devuelto, el delegado devuelve el valor devuelto del último elemento de la lista de invocaciones. Cuando la firma incluye un parámetro que se pasa por referencia, el valor final del parámetro es el resultado que se obtiene después de que cada método de la lista de invocaciones se ejecute secuencialmente y actualice el valor del parámetro.

El equivalente que más se asemeja a un delegado en C o C++ es un puntero a una función. Un delegado puede representar un método estático o un método de instancia. Cuando representa un método de instancia, el delegado no sólo almacena una referencia al punto de entrada del método, sino que también almacena una referencia a la instancia de clase. A diferencia de los punteros a funciones, los delegados están orientados a objetos y presentan seguridad de tipos.

En el ejemplo siguiente se muestra la forma de definir un delegado denominado myMethodDelegate. Las instancias de este delegado se crean para un método de instancia y un método estático de la clase mySampleClass anidada. El delegado correspondiente al método de instancia requiere una instancia de mySampleClass. La instancia de mySampleClass se guarda en una variable denominada mySC.

using System;
public class SamplesDelegate  {

   // Declares a delegate for a method that takes in an int and returns a String.
   public delegate String myMethodDelegate( int myInt );

   // Defines some methods to which the delegate can point.
   public class mySampleClass  {

      // Defines an instance method.
      public String myStringMethod ( int myInt )  {
         if ( myInt > 0 )
            return( "positive" );
         if ( myInt < 0 )
            return( "negative" );
         return ( "zero" );
      }

      // Defines a static method.
      public static String mySignMethod ( int myInt )  {
         if ( myInt > 0 )
            return( "+" );
         if ( myInt < 0 )
            return( "-" );
         return ( "" );
      }
   }

   public static void Main()  {

      // Creates one delegate for each method. For the instance method, an
      // instance (mySC) must be supplied. For the static method, use the
      // class name.
      mySampleClass mySC = new mySampleClass();
      myMethodDelegate myD1 = new myMethodDelegate( mySC.myStringMethod );
      myMethodDelegate myD2 = new myMethodDelegate( mySampleClass.mySignMethod );

      // Invokes the delegates.
      Console.WriteLine( "{0} is {1}; use the sign \"{2}\".", 5, myD1( 5 ), myD2( 5 ) );
      Console.WriteLine( "{0} is {1}; use the sign \"{2}\".", -3, myD1( -3 ), myD2( -3 ) );
      Console.WriteLine( "{0} is {1}; use the sign \"{2}\".", 0, myD1( 0 ), myD2( 0 ) );
   }

}


/*
This code produces the following output:

5 is positive; use the sign "+".
-3 is negative; use the sign "-".
0 is zero; use the sign "".
*/ 

.NET Framework

.NET Framework Client Profile

Biblioteca de clases portable

.NET para aplicaciones de la Tienda Windows

Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (no se admite el rol Server Core), Windows Server 2008 R2 (se admite el rol Server Core con SP1 o versiones posteriores; no se admite Itanium)

Referencia

Otros recursos