Delegate Clase

Definición

Representa un delegado, que es una estructura de datos que hace referencia a un método estático o a una instancia de clase y a un método de instancia de dicha clase.Represents a delegate, which is a data structure that refers to a static method or to a class instance and an instance method of that class.

public ref class Delegate abstract : ICloneable, System::Runtime::Serialization::ISerializable
[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.AutoDual)]
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public abstract class Delegate : ICloneable, System.Runtime.Serialization.ISerializable
type Delegate = class
    interface ICloneable
    interface ISerializable
Public MustInherit Class Delegate
Implements ICloneable, ISerializable
Herencia
Delegate
Derivado
Atributos
Implementaciones

Ejemplos

En el ejemplo siguiente se muestra cómo definir un delegado myMethodDelegatedenominado.The following example shows how to define a delegate named myMethodDelegate. Las instancias de este delegado se crean para un método de instancia y un método estático de la mySampleClass clase anidada.Instances of this delegate are created for an instance method and a static method of the nested mySampleClass class. El delegado para el método de instancia requiere una instancia mySampleClassde.The delegate for the instance method requires an instance of mySampleClass. La mySampleClass instancia se guarda en una variable denominada mySC.The mySampleClass instance is saved in a variable named mySC.

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

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

   // Defines an instance method.
   String^ myStringMethod( int myInt )
   {
      if ( myInt > 0 )
            return ("positive");

      if ( myInt < 0 )
            return ("negative");

      return ("zero");
   }


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

      if ( myInt < 0 )
            return ("-");

      return ("");
   }

};

int main()
{
   
   // Creates one delegate for each method. For the instance method, an 
   // instance (mySC) must be supplied. For the static method, only the
   // method name is needed.
   mySampleClass^ mySC = gcnew mySampleClass;
   myMethodDelegate^ myD1 = gcnew myMethodDelegate( mySC, &mySampleClass::myStringMethod );
   myMethodDelegate^ myD2 = gcnew 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 "".
*/
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 "".
*/ 

Public Class SamplesDelegate

   ' Declares a delegate for a method that takes in an int and returns a String.
   Delegate Function myMethodDelegate(myInt As Integer) As [String]

   ' Defines some methods to which the delegate can point.
   Public Class mySampleClass

      ' Defines an instance method.
      Public Function myStringMethod(myInt As Integer) As [String]
         If myInt > 0 Then
            Return "positive"
         End If
         If myInt < 0 Then
            Return "negative"
         End If
         Return "zero"
      End Function 'myStringMethod

      ' Defines a static method.
      Public Shared Function mySignMethod(myInt As Integer) As [String]
         If myInt > 0 Then
            Return "+"
         End If
         If myInt < 0 Then
            Return "-"
         End If
         Return ""
      End Function 'mySignMethod
   End Class

   Public Shared Sub Main()

      ' Creates one delegate for each method. For the instance method, an
      ' instance (mySC) must be supplied. For the Shared method, the
      ' method name is qualified by the class name.
      Dim mySC As New mySampleClass()
      Dim myD1 As New myMethodDelegate(AddressOf mySC.myStringMethod)
      Dim myD2 As New myMethodDelegate(AddressOf 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))

   End Sub

End Class


'This code produces the following output:
' 
'5 is positive; use the sign "+".
'-3 is negative; use the sign "-".
'0 is zero; use the sign "".


Comentarios

La Delegate clase es la clase base para los tipos de delegado.The Delegate class is the base class for delegate types. Sin embargo, solo los compiladores y del sistema pueden derivar Delegate explícitamente de la MulticastDelegate clase o de la clase.However, only the system and compilers can derive explicitly from the Delegate class or from the MulticastDelegate class. Tampoco se permite derivar un nuevo tipo a partir de un tipo de delegado.It is also not permissible to derive a new type from a delegate type. La Delegate clase no se considera un tipo de delegado; es una clase que se usa para derivar tipos de delegado.The Delegate class is not considered a delegate type; it is a class used to derive delegate types.

La mayoría de los delegate lenguajes implementan una palabra clave y los compiladores de esos lenguajes pueden derivar de la MulticastDelegate clase; delegate por lo tanto, los usuarios deben usar la palabra clave proporcionada por el lenguaje.Most languages implement a delegate keyword, and compilers for those languages are able to derive from the MulticastDelegate class; therefore, users should use the delegate keyword provided by the language.

Nota

El Common Language Runtime proporciona un Invoke método para cada tipo de delegado, con la misma firma que el delegado.The common language runtime provides an Invoke method for each delegate type, with the same signature as the delegate. No es necesario llamar a este método explícitamente desde C#, Visual Basic o visual C++, porque los compiladores lo llaman automáticamente.You do not have to call this method explicitly from C#, Visual Basic, or Visual C++, because the compilers call it automatically. El Invoke método es útil en la reflexión cuando se desea buscar la firma del tipo de delegado.The Invoke method is useful in reflection when you want to find the signature of the delegate type.

El Common Language Runtime proporciona cada tipo de delegado BeginInvoke con EndInvoke métodos y para habilitar la invocación asincrónica del delegado.The common language runtime provides each delegate type with BeginInvoke and EndInvoke methods, to enable asynchronous invocation of the delegate. Para obtener más información sobre estos métodos, consulte llamar a métodos sincrónicos de forma asincrónica.For more information about these methods, see Calling Synchronous Methods Asynchronously.

La declaración de un tipo de delegado establece un contrato que especifica la firma de uno o más métodos.The declaration of a delegate type establishes a contract that specifies the signature of one or more methods. Un delegado es una instancia de un tipo de delegado que tiene referencias a:A delegate is an instance of a delegate type that has references to:

  • Un método de instancia de un tipo y un objeto de destino asignable a ese tipo.An instance method of a type and a target object assignable to that type.

  • Un método de instancia de un tipo, con el this parámetro Hidden expuesto en la lista de parámetros formales.An instance method of a type, with the hidden this parameter exposed in the formal parameter list. Se dice que el delegado es un delegado de instancia abierto.The delegate is said to be an open instance delegate.

  • Método estático.A static method.

  • Un método estático y un objeto de destino asignables al primer parámetro del método.A static method and a target object assignable to the first parameter of the method. Se dice que el delegado está cerrado sobre su primer argumento.The delegate is said to be closed over its first argument.

Para obtener más información sobre el enlace de delegado CreateDelegate(Type, Object, MethodInfo, Boolean) , vea la sobrecarga del método.For more information on delegate binding, see the CreateDelegate(Type, Object, MethodInfo, Boolean) method overload.

Nota

En las versiones 1,0 y 1,1 de .NET Framework, un delegado puede representar un método solo si la firma del método coincide exactamente con la firma especificada por el tipo de delegado.In the .NET Framework versions 1.0 and 1.1, a delegate can represent a method only if the signature of the method exactly matches the signature specified by the delegate type. Por lo tanto, solo se admiten la primera y la tercera viñetas de la lista anterior, y la primera viñeta requiere una coincidencia de tipo exacto.Thus, only the first and third bullets in the preceding list are supported, and the first bullet requires an exact type match.

Cuando un delegado representa un método de instancia cerrado sobre su primer argumento (el caso más común), el delegado almacena una referencia al punto de entrada del método y una referencia a un objeto, denominado destino, que es de un tipo asignable al tipo que definió el forma.When a delegate represents an instance method closed over its first argument (the most common case), the delegate stores a reference to the method's entry point and a reference to an object, called the target, which is of a type assignable to the type that defined the method. Cuando un delegado representa un método de instancia abierto, almacena una referencia al punto de entrada del método.When a delegate represents an open instance method, it stores a reference to the method's entry point. La Signatura del delegado debe incluir el this parámetro Hidden en su lista de parámetros formales; en este caso, el delegado no tiene una referencia a un objeto de destino y se debe proporcionar un objeto de destino cuando se invoca el delegado.The delegate signature must include the hidden this parameter in its formal parameter list; in this case, the delegate does not have a reference to a target object, and a target object must be supplied when the delegate is invoked.

Cuando un delegado representa un método estático, el delegado almacena una referencia al punto de entrada del método.When a delegate represents a static method, the delegate stores a reference to the method's entry point. Cuando un delegado representa un método estático cerrado sobre 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.When a delegate represents a static method closed over its first argument, the delegate stores a reference to the method's entry point and a reference to a target object assignable to the type of the method's first argument. Cuando se invoca el delegado, el primer argumento del método estático recibe el objeto de destino.When the delegate is invoked, the first argument of the static method receives the target object.

La lista de invocaciones de un delegado es un conjunto ordenado de delegados en el que cada elemento de la lista invoca exactamente uno de los métodos representados por el delegado.The invocation list of a delegate is an ordered set of delegates in which each element of the list invokes exactly one of the methods represented by the delegate. Una lista de invocación puede contener métodos duplicados.An invocation list can contain duplicate methods. Durante una invocación, los métodos se invocan en el orden en que aparecen en la lista de invocación.During an invocation, methods are invoked in the order in which they appear in the invocation list. Un delegado intenta invocar cada método en su lista de invocación. los duplicados se invocan una vez para cada vez que aparecen en la lista de invocación.A delegate attempts to invoke every method in its invocation list; duplicates are invoked once for each time they appear in the invocation list. Los delegados son inmutables; una vez creada, la lista de invocaciones de un delegado no cambia.Delegates are immutable; once created, the invocation list of a delegate does not change.

Los delegados se conocen como multidifusión, o combinable, porque un delegado puede invocar uno o varios métodos y se puede usar en operaciones de combinación.Delegates are referred to as multicast, or combinable, because a delegate can invoke one or more methods and can be used in combining operations.

Las operaciones de combinación, Combine como Removey, no modifican los delegados existentes.Combining operations, such as Combine and Remove, do not alter existing delegates. En su lugar, este tipo de operación devuelve un nuevo delegado que contiene los resultados de la operación, un delegado sin modificar o null.Instead, such an operation returns a new delegate that contains the results of the operation, an unchanged delegate, or null. Una operación de combinación null devuelve cuando el resultado de la operación es un delegado que no hace referencia al menos a un método.A combining operation returns null when the result of the operation is a delegate that does not reference at least one method. Una operación de combinación devuelve un delegado sin modificar cuando la operación solicitada no tiene ningún efecto.A combining operation returns an unchanged delegate when the requested operation has no effect.

Nota

Los lenguajes administrados Remove usan los Combine métodos y para implementar operaciones de delegado.Managed languages use the Combine and Remove methods to implement delegate operations. Entre los ejemplos AddHandler se RemoveHandler incluyen las instrucciones y en Visual Basic y los operadores + = y-= en C#los tipos de delegado de.Examples include the AddHandler and RemoveHandler statements in Visual Basic and the += and -= operators on delegate types in C#.

A partir de .NET Framework 4.NET Framework 4, los tipos de delegado genérico pueden tener parámetros de tipo variante.Starting with the .NET Framework 4.NET Framework 4, generic delegate types can have variant type parameters. Los parámetros de tipo contravariante se pueden usar como tipos de parámetro del delegado y se puede usar un parámetro de tipo covariante como el tipo de valor devuelto.Contravariant type parameters can be used as parameter types of the delegate, and a covariant type parameter can be used as the return type. Esta característica permite que los tipos de delegado genéricos que se crean a partir de la misma definición de tipo genérico sean compatibles con la asignación si sus argumentos de tipo son tipos de referencia con una relación de herencia, como se explica en covarianza y contravarianza. .This feature allows generic delegate types that are constructed from the same generic type definition to be assignment-compatible if their type arguments are reference types with an inheritance relationship, as explained in Covariance and Contravariance.

Nota

Los delegados genéricos que son compatibles con la asignación debido a la varianza no tienen por qué ser combinables.Generic delegates that are assignment-compatible because of variance are not necessarily combinable. Para que sea combinable, los tipos deben coincidir exactamente.To be combinable, the types must match exactly. Por ejemplo, supongamos que una Derived clase denominada se deriva de una Baseclase denominada.For example, suppose that a class named Derived is derived from a class named Base. Un delegado de tipo Action<Base> (Action(Of Base) en Visual Basic) se puede asignar a una variable de tipo Action<Derived>, pero los dos delegados no se pueden combinar porque los tipos no coinciden exactamente.A delegate of type Action<Base> (Action(Of Base) in Visual Basic) can be assigned to a variable of type Action<Derived>, but the two delegates cannot be combined because the types do not match exactly.

Si un método invocado produce una excepción, el método deja de ejecutarse, la excepción se devuelve al autor de la llamada del delegado y no se invocan los métodos restantes de la lista de invocación.If an invoked method throws an exception, the method stops executing, the exception is passed back to the caller of the delegate, and remaining methods in the invocation list are not invoked. La detección de la excepción en el llamador no altera este comportamiento.Catching the exception in the caller does not alter this behavior.

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 invocación.When the signature of the methods invoked by a delegate includes a return value, the delegate returns the return value of the last element in the invocation list. Cuando la firma incluye un parámetro que se pasa por referencia, el valor final del parámetro es el resultado de cada método de la lista de invocación que se ejecuta secuencialmente y actualiza el valor del parámetro.When the signature includes a parameter that is passed by reference, the final value of the parameter is the result of every method in the invocation list executing sequentially and updating the parameter's value.

El equivalente más cercano de un delegado en C es un puntero de función.The closest equivalent of a delegate in C is a function pointer. Un delegado puede representar un método estático o un método de instancia.A delegate can represent a static method or an instance method. Cuando el delegado representa un método de instancia, el delegado almacena no solo una referencia al punto de entrada del método, sino también una referencia a la instancia de clase.When the delegate represents an instance method, the delegate stores not only a reference to the method's entry point, but also a reference to the class instance. A diferencia de los punteros de función, los delegados están orientados a objetos y tienen seguridad de tipos.Unlike function pointers, delegates are object oriented and type safe.

Constructores

Delegate(Object, String)

Inicializa un delegado que invoca al método de instancia especificado en la instancia de clase especificada.Initializes a delegate that invokes the specified instance method on the specified class instance.

Delegate(Type, String)

Inicializa un delegado que invoca al método estático especificado a partir de la clase especificada.Initializes a delegate that invokes the specified static method from the specified class.

Propiedades

Method

Obtiene el método representado por el delegado.Gets the method represented by the delegate.

Target

Obtiene la instancia de clase donde el delegado actual invoca al método de instancia.Gets the class instance on which the current delegate invokes the instance method.

Métodos

Clone()

Crea una copia superficial del delegado.Creates a shallow copy of the delegate.

Combine(Delegate, Delegate)

Concatena las listas de invocaciones de dos delegados.Concatenates the invocation lists of two delegates.

Combine(Delegate[])

Concatena las listas de invocaciones de una matriz de delegados.Concatenates the invocation lists of an array of delegates.

CombineImpl(Delegate)

Concatena las listas de invocaciones del delegado de multidifusión (combinable) especificado y del delegado de multidifusión (combinable) actual.Concatenates the invocation lists of the specified multicast (combinable) delegate and the current multicast (combinable) delegate.

CreateDelegate(Type, MethodInfo)

Crea un delegado del tipo especificado para representar el método estático especificado.Creates a delegate of the specified type to represent the specified static method.

CreateDelegate(Type, MethodInfo, Boolean)

Crea un delegado del tipo especificado para representar el método estático especificado, con el comportamiento establecido para el caso de que se produzca un error al enlazar.Creates a delegate of the specified type to represent the specified static method, with the specified behavior on failure to bind.

CreateDelegate(Type, Object, MethodInfo)

Crea un delegado del tipo especificado que representa el método estático o de instancia especificado, con el primer argumento definido.Creates a delegate of the specified type that represents the specified static or instance method, with the specified first argument.

CreateDelegate(Type, Object, MethodInfo, Boolean)

Crea un delegado del tipo especificado que representa el método estático o de instancia determinado, con el primer argumento definido y el comportamiento especificado si se produce un error en el enlace.Creates a delegate of the specified type that represents the specified static or instance method, with the specified first argument and the specified behavior on failure to bind.

CreateDelegate(Type, Object, String)

Crea un delegado del tipo especificado que representa el método de instancia especificado que se va a invocar en la instancia de clase especificada.Creates a delegate of the specified type that represents the specified instance method to invoke on the specified class instance.

CreateDelegate(Type, Object, String, Boolean)

Crea un delegado del tipo especificado que representa el método de instancia especificado que se va a invocar en la instancia de clase especificada con la distinción de mayúsculas y minúsculas que se haya especificado.Creates a delegate of the specified type that represents the specified instance method to invoke on the specified class instance with the specified case-sensitivity.

CreateDelegate(Type, Object, String, Boolean, Boolean)

Crea un delegado del tipo especificado que representa el método de instancia determinado que se va a invocar en la instancia de clase especificada, con la distinción de mayúsculas y minúsculas y el comportamiento que se hayan concretado para cuando se produce un error al enlazar.Creates a delegate of the specified type that represents the specified instance method to invoke on the specified class instance, with the specified case-sensitivity and the specified behavior on failure to bind.

CreateDelegate(Type, Type, String)

Crea un delegado del tipo especificado que representa el método estático especificado de la clase especificada.Creates a delegate of the specified type that represents the specified static method of the specified class.

CreateDelegate(Type, Type, String, Boolean)

Crea un delegado del tipo especificado que representa el método estático determinado de la clase especificada, con la distinción de mayúsculas y minúsculas definida.Creates a delegate of the specified type that represents the specified static method of the specified class, with the specified case-sensitivity.

CreateDelegate(Type, Type, String, Boolean, Boolean)

Crea un delegado del tipo especificado que representa el método estático determinado de la clase especificada, con la distinción de mayúsculas y minúsculas definida y el comportamiento que se haya concretado para cuando se produce un error al enlazar.Creates a delegate of the specified type that represents the specified static method of the specified class, with the specified case-sensitivity and the specified behavior on failure to bind.

DynamicInvoke(Object[])

Invoca dinámicamente (en tiempo de ejecución) al método representado por el delegado actual.Dynamically invokes (late-bound) the method represented by the current delegate.

DynamicInvokeImpl(Object[])

Invoca dinámicamente (en tiempo de ejecución) al método representado por el delegado actual.Dynamically invokes (late-bound) the method represented by the current delegate.

Equals(Object)

Determina si el objeto especificado y el delegado actual son del mismo tipo y comparten los mismos destinos, métodos y listas de invocaciones.Determines whether the specified object and the current delegate are of the same type and share the same targets, methods, and invocation list.

GetHashCode()

Devuelve un código hash para el delegado.Returns a hash code for the delegate.

GetInvocationList()

Devuelve la lista de invocaciones del delegado.Returns the invocation list of the delegate.

GetMethodImpl()

Obtiene el método estático representado por el delegado actual.Gets the static method represented by the current delegate.

GetObjectData(SerializationInfo, StreamingContext)

No se admite.Not supported.

GetType()

Obtiene el Type de la instancia actual.Gets the Type of the current instance.

(Heredado de Object)
MemberwiseClone()

Crea una copia superficial del Object actual.Creates a shallow copy of the current Object.

(Heredado de Object)
Remove(Delegate, Delegate)

Quita la última aparición de la lista de invocaciones de un delegado de la lista de invocaciones de otro delegado.Removes the last occurrence of the invocation list of a delegate from the invocation list of another delegate.

RemoveAll(Delegate, Delegate)

Quita todas las apariciones de la lista de invocaciones de un delegado de la lista de invocaciones de otro delegado.Removes all occurrences of the invocation list of a delegate from the invocation list of another delegate.

RemoveImpl(Delegate)

Quita la lista de invocaciones de un delegado de la lista de invocaciones de otro delegado.Removes the invocation list of a delegate from the invocation list of another delegate.

ToString()

Devuelve un valor de tipo string que representa el objeto actual.Returns a string that represents the current object.

(Heredado de Object)

Operadores

Equality(Delegate, Delegate)

Determina si los delegados especificados son iguales.Determines whether the specified delegates are equal.

Inequality(Delegate, Delegate)

Determina si los delegados especificados no son iguales.Determines whether the specified delegates are not equal.

Métodos de extensión

GetMethodInfo(Delegate)

Obtiene un objeto que representa el método representado por el delegado especificado.Gets an object that represents the method represented by the specified delegate.

Se aplica a

Consulte también: