Delegate Třída

Definice

Představuje delegáta, což je datová struktura, která odkazuje na statickou metodu nebo na instanci třídy a metodu instance této třídy.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
Dědičnost
Delegate
Odvozené
Atributy
Implementuje

Příklady

Následující příklad ukazuje, jak definovat delegáta s názvem myMethodDelegate.The following example shows how to define a delegate named myMethodDelegate. Instance tohoto delegáta jsou vytvořeny pro metodu instance a statickou metodu vnořené mySampleClass třídy.Instances of this delegate are created for an instance method and a static method of the nested mySampleClass class. Delegát pro metodu instance vyžaduje instanci mySampleClass.The delegate for the instance method requires an instance of mySampleClass. Instance je uložena v proměnné s názvem mySC. mySampleClassThe 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 "".


Poznámky

Delegate Třída je základní třídou pro typy delegátů.The Delegate class is the base class for delegate types. Pouze systém a kompilátory však mohou být odvozeny explicitně ze Delegate třídy nebo MulticastDelegate z třídy.However, only the system and compilers can derive explicitly from the Delegate class or from the MulticastDelegate class. Není také přípustné odvodit nový typ z typu delegáta.It is also not permissible to derive a new type from a delegate type. Delegate Třída není považována za typ delegáta; jedná se o třídu, která se používá pro odvození typů delegátů.The Delegate class is not considered a delegate type; it is a class used to derive delegate types.

Většina jazyků implementuje delegate klíčové slovo a kompilátory pro tyto jazyky jsou schopny odvozovat MulticastDelegate z třídy; proto by uživatelé měli použít delegate klíčové slovo poskytované jazykem.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.

Poznámka

Modul CLR (Common Language Runtime Invoke ) poskytuje metodu pro každý typ delegáta se stejnou signaturou jako delegát.The common language runtime provides an Invoke method for each delegate type, with the same signature as the delegate. Tuto metodu není nutné volat explicitně z C#, Visual Basic nebo vizuálu C++, protože kompilátory ji volají automaticky.You do not have to call this method explicitly from C#, Visual Basic, or Visual C++, because the compilers call it automatically. Metoda je užitečná v reflexi , pokud chcete najít signaturu typu delegáta. InvokeThe Invoke method is useful in reflection when you want to find the signature of the delegate type.

Modul CLR (Common Language Runtime) poskytuje každému BeginInvoke typu EndInvoke delegáta metody a a umožňuje tak asynchronní vyvolání delegáta.The common language runtime provides each delegate type with BeginInvoke and EndInvoke methods, to enable asynchronous invocation of the delegate. Další informace o těchto metodách naleznete v tématu asynchronní volání synchronních metod.For more information about these methods, see Calling Synchronous Methods Asynchronously.

Deklarace typu delegáta vytváří kontrakt, který určuje signaturu jedné nebo více metod.The declaration of a delegate type establishes a contract that specifies the signature of one or more methods. Delegát je instance typu delegáta, který má odkazy na:A delegate is an instance of a delegate type that has references to:

  • Metoda instance typu a cílového objektu, který je přiřazen k tomuto typu.An instance method of a type and a target object assignable to that type.

  • Metoda instance typu s skrytým this parametrem vystaveným v seznamu formálních parametrů.An instance method of a type, with the hidden this parameter exposed in the formal parameter list. Na delegáta se říká otevřený delegát instance.The delegate is said to be an open instance delegate.

  • Statická metoda.A static method.

  • Statická metoda a cílový objekt přiřadit k prvnímu parametru metody.A static method and a target object assignable to the first parameter of the method. Tento delegát je označován jako uzavřený v prvním argumentu.The delegate is said to be closed over its first argument.

Další informace o vazbě delegáta naleznete v CreateDelegate(Type, Object, MethodInfo, Boolean) tématu přetížení metody.For more information on delegate binding, see the CreateDelegate(Type, Object, MethodInfo, Boolean) method overload.

Poznámka

V .NET Framework verzích 1,0 a 1,1 může delegát vyjádřit metodu pouze v případě, že signatura metody přesně odpovídá signatuře určenému typem delegáta.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. Proto jsou podporovány pouze první a třetí odrážky v předchozím seznamu a první odrážka vyžaduje přesný typ shody.Thus, only the first and third bullets in the preceding list are supported, and the first bullet requires an exact type match.

Když delegát představuje metodu instance uzavřenou v prvním argumentu (Nejběžnější případ), delegát uloží odkaz na vstupní bod metody a odkaz na objekt, který se nazývá cíl, který je typu, který lze přiřadit typu, který definoval Metoda.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. Když delegát představuje metodu Open instance, ukládá odkaz na vstupní bod metody.When a delegate represents an open instance method, it stores a reference to the method's entry point. Podpis delegáta musí obsahovat skrytý this parametr v seznamu formálních parametrů; v tomto případě nemá delegát odkaz na cílový objekt a cílový objekt musí být dodán při volání delegáta.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.

Když delegát představuje statickou metodu, delegát uloží odkaz na vstupní bod metody.When a delegate represents a static method, the delegate stores a reference to the method's entry point. Když delegát představuje statickou metodu uzavřenou v prvním argumentu, delegát uloží odkaz na vstupní bod metody a odkaz na cílový objekt, který lze přiřadit typu prvního argumentu metody.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. Když je delegát vyvolán, první argument statické metody obdrží cílový objekt.When the delegate is invoked, the first argument of the static method receives the target object.

Seznam volání delegáta je uspořádaná sada delegátů, ve které každý prvek seznamu vyvolá přesně jednu z metod reprezentovaných delegátem.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. Seznam volání může obsahovat duplicitní metody.An invocation list can contain duplicate methods. Během vyvolání jsou metody vyvolány v pořadí, v jakém jsou uvedeny v seznamu volání.During an invocation, methods are invoked in the order in which they appear in the invocation list. Delegát se pokusí vyvolat každou metodu v seznamu jeho vyvolání; duplikáty jsou vyvolány jednou při každém zobrazení v seznamu volá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. Delegáti jsou neměnné; Po vytvoření se seznam vyvolání delegáta nezmění.Delegates are immutable; once created, the invocation list of a delegate does not change.

Delegáti jsou označováni jako vícesměrové vysílání nebo pomocí kombinace, protože delegát může vyvolat jednu nebo více metod a lze jej použít při kombinování operací.Delegates are referred to as multicast, or combinable, because a delegate can invoke one or more methods and can be used in combining operations.

Kombinování operací, jako Combine například Removea, nemění stávající delegáty.Combining operations, such as Combine and Remove, do not alter existing delegates. Místo toho tato operace vrátí nového delegáta, který obsahuje výsledky operace, nezměněného delegáta nebo null.Instead, such an operation returns a new delegate that contains the results of the operation, an unchanged delegate, or null. Operace kombinování vrátí null , když je výsledkem operace delegát, který neodkazuje alespoň na jednu metodu.A combining operation returns null when the result of the operation is a delegate that does not reference at least one method. Operace kombinování vrátí nezměněný delegát, pokud požadovaná operace nemá žádný vliv.A combining operation returns an unchanged delegate when the requested operation has no effect.

Poznámka

Spravované jazyky používají Combine metody a Remove k implementaci delegování operací.Managed languages use the Combine and Remove methods to implement delegate operations. Příklady zahrnují AddHandler příkazy a RemoveHandler v Visual Basic a operátory + = a-= na typech delegátů v. C#Examples include the AddHandler and RemoveHandler statements in Visual Basic and the += and -= operators on delegate types in C#.

.NET Framework 4.NET Framework 4Počínaje, obecné typy delegátů mohou mít parametry typu variant.Starting with the .NET Framework 4.NET Framework 4, generic delegate types can have variant type parameters. Parametry kontravariantního typu mohou být použity jako typy parametrů delegáta a Parametr kovariantního typu lze použít jako návratový typ.Contravariant type parameters can be used as parameter types of the delegate, and a covariant type parameter can be used as the return type. Tato funkce umožňuje, aby typy generických delegátů, které jsou vytvořené ze stejné definice obecného typu, byly kompatibilní s přiřazením, pokud jejich argumenty typu jsou odkazem na typy s relací dědičnosti, jak je vysvětleno v tématu kovariance a kontravariance. .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.

Poznámka

Obecní delegáti, kteří jsou kompatibilní s přiřazováním, protože variance nemusí být nutně kombinace.Generic delegates that are assignment-compatible because of variance are not necessarily combinable. Aby bylo možné typy kombinovat, musí se přesně shodovat.To be combinable, the types must match exactly. Předpokládejme například, že třída s názvem Derived je odvozena z třídy s názvem. BaseFor example, suppose that a class named Derived is derived from a class named Base. Delegát typu Action<Base> (Action(Of Base) v Visual Basic) lze přiřadit proměnné typu Action<Derived>, ale dva delegáty nelze kombinovat, protože typy se přesně neshodují.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.

Pokud vyvolaná metoda vyvolá výjimku, metoda se zastaví a výjimka se vrátí zpět volajícímu delegáta a zbývající metody v seznamu volání nejsou vyvolány.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. Zachycení výjimky v volajícím nemění toto chování.Catching the exception in the caller does not alter this behavior.

Pokud signatura metod vyvolaných delegátem obsahuje návratovou hodnotu, delegát vrátí vrácenou hodnotu posledního prvku v seznamu vyvolá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. Pokud signatura obsahuje parametr, který je předán odkazem, konečná hodnota parametru je výsledkem každé metody v seznamu volání prováděných postupně a aktualizuje hodnotu parametru.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.

Nejbližší ekvivalent delegáta v jazyce C je ukazatel na funkci.The closest equivalent of a delegate in C is a function pointer. Delegát může představovat statickou metodu nebo metodu instance.A delegate can represent a static method or an instance method. Když delegát představuje metodu instance, delegát ukládá nejen odkaz na vstupní bod metody, ale také odkaz na instanci třídy.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. Na rozdíl od ukazatelů na funkce jsou delegáti objektově orientované a typově bezpečné.Unlike function pointers, delegates are object oriented and type safe.

Konstruktory

Delegate(Object, String)

Inicializuje delegáta, který vyvolá zadanou metodu instance v zadané instanci třídy.Initializes a delegate that invokes the specified instance method on the specified class instance.

Delegate(Type, String)

Inicializuje delegáta, který vyvolá zadanou statickou metodu ze zadané třídy.Initializes a delegate that invokes the specified static method from the specified class.

Vlastnosti

Method

Získá metodu reprezentovanou delegátem.Gets the method represented by the delegate.

Target

Získá instanci třídy, na které aktuální delegát vyvolá metodu instance.Gets the class instance on which the current delegate invokes the instance method.

Metody

Clone()

Vytvoří kopii delegáta bez podstruktury.Creates a shallow copy of the delegate.

Combine(Delegate, Delegate)

Zřetězí seznamy volání dvou delegátů.Concatenates the invocation lists of two delegates.

Combine(Delegate[])

Zřetězí seznamy vyvolání pole delegátů.Concatenates the invocation lists of an array of delegates.

CombineImpl(Delegate)

Zřetězí seznam volání určeného vícesměrového (sloučeného) delegáta a aktuálního delegáta vícesměrového vysílání (s použitím kombinace).Concatenates the invocation lists of the specified multicast (combinable) delegate and the current multicast (combinable) delegate.

CreateDelegate(Type, MethodInfo)

Vytvoří delegáta zadaného typu, který představuje zadanou statickou metodu.Creates a delegate of the specified type to represent the specified static method.

CreateDelegate(Type, MethodInfo, Boolean)

Vytvoří delegát zadaného typu, který bude reprezentovat zadanou statickou metodu se zadaným chováním při neúspěšném vytvoření vazby.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)

Vytvoří delegáta zadaného typu, který představuje zadanou statickou metodu nebo metodu instance se zadaným prvním argumentem.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)

Vytvoří delegáta zadaného typu, který představuje zadanou statickou metodu nebo metodu instance se zadaným prvním argumentem a zadaným chováním při neúspěšném vytvoření vazby.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)

Vytvoří delegáta zadaného typu, který představuje zadanou metodu instance, která se má vyvolat u zadané instance třídy.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)

Vytvoří delegáta zadaného typu, který představuje zadanou metodu instance, která se má vyvolat u zadané instance třídy se zadaným rozlišováním velkých a malých písmen.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)

Vytvoří delegáta zadaného typu, který představuje zadanou metodu instance, která se má vyvolat u zadané instance třídy, se zadaným rozlišováním velkých a malých písmen a zadaným chováním při neúspěšném vytvoření vazby.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)

Vytvoří delegáta zadaného typu, který představuje zadanou statickou metodu zadané třídy.Creates a delegate of the specified type that represents the specified static method of the specified class.

CreateDelegate(Type, Type, String, Boolean)

Vytvoří delegáta zadaného typu, který představuje zadanou statickou metodu zadané třídy se zadaným rozlišováním velkých a malých písmen.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)

Vytvoří delegáta zadaného typu, který představuje zadanou statickou metodu zadané třídy, se zadaným rozlišováním velkých a malých písmen a zadaným chováním při neúspěšném vytvoření vazby.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[])

Dynamicky vyvolá (s pozdní vazbou) metodu reprezentovanou aktuálním delegátem.Dynamically invokes (late-bound) the method represented by the current delegate.

DynamicInvokeImpl(Object[])

Dynamicky vyvolá (s pozdní vazbou) metodu reprezentovanou aktuálním delegátem.Dynamically invokes (late-bound) the method represented by the current delegate.

Equals(Object)

Určuje, zda je zadaný objekt a aktuální delegát stejného typu a sdílí stejné cíle, metody a seznam volání.Determines whether the specified object and the current delegate are of the same type and share the same targets, methods, and invocation list.

GetHashCode()

Vrátí hodnotu hash delegáta.Returns a hash code for the delegate.

GetInvocationList()

Vrátí seznam volání delegáta.Returns the invocation list of the delegate.

GetMethodImpl()

Získá statickou metodu reprezentovanou aktuálním delegátem.Gets the static method represented by the current delegate.

GetObjectData(SerializationInfo, StreamingContext)

Není podporováno.Not supported.

GetType()

Gets the Type of the current instance.Gets the Type of the current instance.

(Zděděno od Object)
MemberwiseClone()

Creates a shallow copy of the current Object.Creates a shallow copy of the current Object.

(Zděděno od Object)
Remove(Delegate, Delegate)

Odebere poslední výskyt seznamu vyvolání delegáta ze seznamu volání jiného delegáta.Removes the last occurrence of the invocation list of a delegate from the invocation list of another delegate.

RemoveAll(Delegate, Delegate)

Odebere všechny výskyty seznamu vyvolání delegáta ze seznamu volání jiného delegáta.Removes all occurrences of the invocation list of a delegate from the invocation list of another delegate.

RemoveImpl(Delegate)

Odebere seznam vyvolání delegáta ze seznamu volání jiného delegáta.Removes the invocation list of a delegate from the invocation list of another delegate.

ToString()

Vrací řetězec, který představuje aktuální objekt.Returns a string that represents the current object.

(Zděděno od Object)

Operátory

Equality(Delegate, Delegate)

Určuje, zda jsou určení Delegáti shodná.Determines whether the specified delegates are equal.

Inequality(Delegate, Delegate)

Určuje, zda zadané delegáty nejsou stejné.Determines whether the specified delegates are not equal.

Metody rozšíření

GetMethodInfo(Delegate)

Získává objekt, který představuje metodu reprezentovanou zadaným delegátem.Gets an object that represents the method represented by the specified delegate.

Platí pro

Viz také