Delegate Delegate Delegate Delegate Class

Definicja

Reprezentuje delegata, który jest strukturą danych, która odwołuje się do metody statycznej lub do wystąpienia klasy i metody wystąpienia tej klasy.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
Dziedziczenie
DelegateDelegateDelegateDelegate
Pochodne
Atrybuty
Implementuje

Przykłady

Poniższy przykład pokazuje, jak zdefiniować delegata o nazwie myMethodDelegate.The following example shows how to define a delegate named myMethodDelegate. Wystąpienia tego delegata są tworzone dla metody wystąpienia i statycznej metody klasy zagnieżdżonej mySampleClass .Instances of this delegate are created for an instance method and a static method of the nested mySampleClass class. Delegat dla metody Instance wymaga wystąpienia mySampleClass.The delegate for the instance method requires an instance of mySampleClass. Wystąpienie jest zapisywane w zmiennej o nazwie 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 "".
*/ 

Imports System

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 'mySampleClass

   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 'Main

End Class 'SamplesDelegate 


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


Uwagi

Delegate Klasa jest klasą bazową dla typów delegatów.The Delegate class is the base class for delegate types. Jednak tylko system i kompilatory mogą pochodzić jawnie z Delegate klasy lub MulticastDelegate z klasy.However, only the system and compilers can derive explicitly from the Delegate class or from the MulticastDelegate class. Nie jest również dozwolone uzyskanie nowego typu z typu delegata.It is also not permissible to derive a new type from a delegate type. Delegate Klasa nie jest uważana za typ delegata; jest to Klasa używana do wyprowadzania typów delegatów.The Delegate class is not considered a delegate type; it is a class used to derive delegate types.

Większość języków implementuje delegate słowo kluczowe i kompilatory dla tych języków mogą dziedziczyć MulticastDelegate z klasy, w związku z czym użytkownicy powinni używać delegate słowa kluczowego dostarczonego przez język.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.

Uwaga

Środowisko uruchomieniowe języka wspólnego udostępnia Invoke metodę dla każdego typu delegata z tą samą sygnaturą co delegat.The common language runtime provides an Invoke method for each delegate type, with the same signature as the delegate. Nie trzeba jawnie wywoływać tej metody z C#, Visual Basic lub wizualizacji C++, ponieważ kompilatory automatycznie wywołują tę metodę.You do not have to call this method explicitly from C#, Visual Basic, or Visual C++, because the compilers call it automatically. Metoda jest przydatna podczas odbicia, gdy chcesz znaleźć podpis typu delegata. InvokeThe Invoke method is useful in reflection when you want to find the signature of the delegate type.

Środowisko uruchomieniowe języka wspólnego zapewnia każdy typ delegata EndInvoke z BeginInvoke metodami i, aby umożliwić asynchroniczne wywołanie delegata.The common language runtime provides each delegate type with BeginInvoke and EndInvoke methods, to enable asynchronous invocation of the delegate. Aby uzyskać więcej informacji na temat tych metod, zobacz Asynchroniczne wywoływanie metod synchronicznych.For more information about these methods, see Calling Synchronous Methods Asynchronously.

Deklaracja typu delegata ustanawia kontrakt, który określa podpis jednej lub kilku metod.The declaration of a delegate type establishes a contract that specifies the signature of one or more methods. Delegat jest wystąpieniem typu delegata, do którego odwołuje się:A delegate is an instance of a delegate type that has references to:

  • Metoda wystąpienia typu i obiektu docelowego można przypisać do tego typu.An instance method of a type and a target object assignable to that type.

  • Metoda wystąpienia typu, z ukrytym this parametrem uwidocznionym na liście parametrów formalnych.An instance method of a type, with the hidden this parameter exposed in the formal parameter list. Delegat jest nazywany delegatem otwartego wystąpienia.The delegate is said to be an open instance delegate.

  • Metoda statyczna.A static method.

  • Metoda statyczna i obiekt docelowy można przypisać do pierwszego parametru metody.A static method and a target object assignable to the first parameter of the method. Delegat jest określany jako zamknięty w pierwszym argumencie.The delegate is said to be closed over its first argument.

Aby uzyskać więcej informacji na temat powiązania delegata CreateDelegate(Type, Object, MethodInfo, Boolean) , zobacz Przeciążenie metody.For more information on delegate binding, see the CreateDelegate(Type, Object, MethodInfo, Boolean) method overload.

Uwaga

W .NET Framework wersje 1,0 i 1,1 delegat może reprezentować metodę tylko wtedy, gdy podpis metody dokładnie pasuje do podpisu określonego przez typ delegata.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. W tym celu obsługiwane są tylko pierwsze i trzecie punktory na poprzedniej liście, a pierwszy punktor wymaga dokładnego dopasowania typu.Thus, only the first and third bullets in the preceding list are supported, and the first bullet requires an exact type match.

Gdy delegat reprezentuje metodę wystąpienia zamkniętą względem pierwszego argumentu (najczęściej używany przypadek), delegat przechowuje odwołanie do punktu wejścia metody i odwołanie do obiektu, nazywany obiektem docelowym, który jest typu, który można przypisać do typu, który definiuje Method.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. Gdy delegat reprezentuje metodę otwartego wystąpienia, przechowuje odwołanie do punktu wejścia metody.When a delegate represents an open instance method, it stores a reference to the method's entry point. Podpis delegata musi zawierać ukryty this parametr na liście parametrów formalnych. w tym przypadku delegat nie ma odwołania do obiektu docelowego, a obiekt docelowy musi być dostarczony, gdy delegat jest wywoływany.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.

Gdy delegat reprezentuje metodę statyczną, delegat przechowuje odwołanie do punktu wejścia metody.When a delegate represents a static method, the delegate stores a reference to the method's entry point. Gdy delegat reprezentuje statyczną metodę zamkniętą względem pierwszego argumentu, delegat przechowuje odwołanie do punktu wejścia metody i odwołanie do obiektu docelowego można przypisać do typu pierwszego 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. Gdy delegat jest wywoływany, pierwszy argument metody statycznej otrzymuje obiekt docelowy.When the delegate is invoked, the first argument of the static method receives the target object.

Lista wywołań delegata jest uporządkowanym zestawem delegatów, w których każdy element listy wywołuje dokładnie jedną z metod reprezentowanych przez delegata.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. Lista wywołań może zawierać zduplikowane metody.An invocation list can contain duplicate methods. W trakcie wywołania metody są wywoływane w kolejności, w jakiej występują na liście wywołań.During an invocation, methods are invoked in the order in which they appear in the invocation list. Delegat próbuje wywołać każdą metodę na swojej liście wywołań; duplikaty są wywoływane raz dla każdej chwili, gdy pojawiają się na liście wywołań.A delegate attempts to invoke every method in its invocation list; duplicates are invoked once for each time they appear in the invocation list. Delegaty są niezmienne; Po utworzeniu Lista wywołań delegata nie zmienia się.Delegates are immutable; once created, the invocation list of a delegate does not change.

Delegaty nazywa się multiemisją lub kombinacją, ponieważ delegat może wywołać jedną lub więcej metod i może być używany w operacjach łączenia.Delegates are referred to as multicast, or combinable, because a delegate can invoke one or more methods and can be used in combining operations.

Łączenie operacji, takich jak Combine i Remove, nie zmieniaj istniejących delegatów.Combining operations, such as Combine and Remove, do not alter existing delegates. Zamiast tego, taka operacja zwraca nowy delegat zawierający wyniki operacji, niezmieniony delegata lub null.Instead, such an operation returns a new delegate that contains the results of the operation, an unchanged delegate, or null. Operacja łączenia zwraca null , gdy wynik operacji jest delegatem, który nie odwołuje się do co najmniej jednej metody.A combining operation returns null when the result of the operation is a delegate that does not reference at least one method. Operacja łączenia zwraca niezmieniony delegata, gdy żądana operacja nie ma żadnego wpływu.A combining operation returns an unchanged delegate when the requested operation has no effect.

Uwaga

Języki zarządzane używają Combine metod i Remove do implementowania operacji delegatów.Managed languages use the Combine and Remove methods to implement delegate operations. Przykłady zawierają AddHandler instrukcje i RemoveHandler w Visual Basic oraz operatory + = i-= w typach delegatów w. C#Examples include the AddHandler and RemoveHandler statements in Visual Basic and the += and -= operators on delegate types in C#.

Począwszy od, typy delegatów ogólnych mogą zawierać parametry typu variant. Program .NET Framework 4.NET Framework 4Starting with the Program .NET Framework 4.NET Framework 4, generic delegate types can have variant type parameters. Parametry typu kontrawariantne mogą być używane jako typy parametrów delegata, a jako typ zwracany można użyć parametru typu współwariantowego.Contravariant type parameters can be used as parameter types of the delegate, and a covariant type parameter can be used as the return type. Ta funkcja umożliwia ogólne typy delegatów, które są tworzone na podstawie tej samej definicji typu ogólnego, tak aby były zgodne z przypisaniem, jeśli ich argumenty typu są typami odwołań z relacją dziedziczenia, jak wyjaśniono w kowariancji i kontrawariancja .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.

Uwaga

Delegaty ogólne, które są zgodne z przypisaniem ze względu na wariancję, nie muszą być kombinacją.Generic delegates that are assignment-compatible because of variance are not necessarily combinable. Aby można było połączyć, typy muszą dokładnie pasować.To be combinable, the types must match exactly. Załóżmy na przykład, że Klasa o nazwie Derived pochodzi od klasy o nazwie. BaseFor example, suppose that a class named Derived is derived from a class named Base. Delegat typu Action<Base> (Action(Of Base) w Visual Basic) można przypisać do zmiennej typu Action<Derived>, ale nie można łączyć dwóch delegatów, ponieważ typy nie są dokładnie zgodne.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.

Jeśli wywołana metoda zgłasza wyjątek, Metoda przerywa wykonywanie, wyjątek jest przenoszona z powrotem do obiektu wywołującego delegata, a pozostałe metody na liście wywołań nie są wywoływane.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. Przechwytywanie wyjątku w obiekcie wywołującym nie zmienia tego zachowania.Catching the exception in the caller does not alter this behavior.

Gdy sygnatura metod wywoływanych przez delegata zawiera wartość zwracaną, delegat zwraca wartość zwracaną ostatniego elementu na liście wywołań.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. Gdy podpis zawiera parametr, który jest przesyłany przez odwołanie, końcowa wartość parametru jest wynikiem każdej metody na liście wywołań, która wykonuje sekwencyjne i aktualizuje wartość 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.

Najbliższy odpowiednik delegata w C jest wskaźnikiem funkcji.The closest equivalent of a delegate in C is a function pointer. Delegat może reprezentować metodę statyczną lub metodę wystąpienia.A delegate can represent a static method or an instance method. Gdy delegat reprezentuje metodę wystąpienia, delegat przechowuje nie tylko odwołanie do punktu wejścia metody, ale również odwołanie do wystąpienia klasy.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. W przeciwieństwie do wskaźników funkcji Delegaty są zorientowane obiektowo i typu bezpieczne.Unlike function pointers, delegates are object oriented and type safe.

Konstruktory

Delegate(Object, String) Delegate(Object, String) Delegate(Object, String) Delegate(Object, String)

Inicjuje delegata, który wywołuje określoną metodę wystąpienia w określonym wystąpieniu klasy.Initializes a delegate that invokes the specified instance method on the specified class instance.

Delegate(Type, String) Delegate(Type, String) Delegate(Type, String) Delegate(Type, String)

Inicjuje delegata, który wywołuje określoną metodę statyczną z określonej klasy.Initializes a delegate that invokes the specified static method from the specified class.

Właściwości

Method Method Method Method

Pobiera metodę reprezentowaną przez delegata.Gets the method represented by the delegate.

Target Target Target Target

Pobiera wystąpienie klasy, dla którego bieżący delegat wywołuje metodę wystąpienia.Gets the class instance on which the current delegate invokes the instance method.

Metody

Clone() Clone() Clone() Clone()

Tworzy skróconą kopię delegata.Creates a shallow copy of the delegate.

Combine(Delegate, Delegate) Combine(Delegate, Delegate) Combine(Delegate, Delegate) Combine(Delegate, Delegate)

Łączy listy wywołań dwóch delegatów.Concatenates the invocation lists of two delegates.

Combine(Delegate[]) Combine(Delegate[]) Combine(Delegate[]) Combine(Delegate[])

Łączy listy wywołań tablicy delegatów.Concatenates the invocation lists of an array of delegates.

CombineImpl(Delegate) CombineImpl(Delegate) CombineImpl(Delegate) CombineImpl(Delegate)

Łączy listy wywołań określonego delegata multiemisji (z połączeniem) i bieżącego delegata multiemisji (połączonego).Concatenates the invocation lists of the specified multicast (combinable) delegate and the current multicast (combinable) delegate.

CreateDelegate(Type, MethodInfo) CreateDelegate(Type, MethodInfo) CreateDelegate(Type, MethodInfo) CreateDelegate(Type, MethodInfo)

Tworzy delegat określonego typu do reprezentowania określonej metody statycznej.Creates a delegate of the specified type to represent the specified static method.

CreateDelegate(Type, MethodInfo, Boolean) CreateDelegate(Type, MethodInfo, Boolean) CreateDelegate(Type, MethodInfo, Boolean) CreateDelegate(Type, MethodInfo, Boolean)

Tworzy delegat określonego typu reprezentujący określoną metodę statyczną, z określonym zachowaniem dotyczącym niepowodzenia powiązania.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) CreateDelegate(Type, Object, MethodInfo) CreateDelegate(Type, Object, MethodInfo) CreateDelegate(Type, Object, MethodInfo)

Tworzy delegat określonego typu, który reprezentuje określoną metodę statyczną lub wystąpienie, z określonym pierwszym 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) CreateDelegate(Type, Object, MethodInfo, Boolean) CreateDelegate(Type, Object, MethodInfo, Boolean) CreateDelegate(Type, Object, MethodInfo, Boolean)

Tworzy delegat określonego typu, który reprezentuje określoną metodę statyczną lub wystąpienie, z określonym pierwszym argumentem i określonym zachowaniem w przypadku niepowodzenia powiązania.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) CreateDelegate(Type, Object, String) CreateDelegate(Type, Object, String) CreateDelegate(Type, Object, String)

Tworzy delegat określonego typu, który reprezentuje określoną metodę wystąpienia do wywołania w określonym wystąpieniu klasy.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) CreateDelegate(Type, Object, String, Boolean) CreateDelegate(Type, Object, String, Boolean) CreateDelegate(Type, Object, String, Boolean)

Tworzy delegat określonego typu, który reprezentuje określoną metodę wystąpienia do wywołania w określonym wystąpieniu klasy o określonej wielkości liter.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) CreateDelegate(Type, Object, String, Boolean, Boolean) CreateDelegate(Type, Object, String, Boolean, Boolean) CreateDelegate(Type, Object, String, Boolean, Boolean)

Tworzy delegat określonego typu, który reprezentuje określoną metodę wystąpienia do wywołania w określonym wystąpieniu klasy, z określoną wielkością liter i określonym zachowaniem w przypadku niepowodzenia powiązania.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) CreateDelegate(Type, Type, String) CreateDelegate(Type, Type, String) CreateDelegate(Type, Type, String)

Tworzy delegat określonego typu, który reprezentuje określoną metodę statyczną określonej klasy.Creates a delegate of the specified type that represents the specified static method of the specified class.

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

Tworzy delegat określonego typu, który reprezentuje określoną metodę statyczną określonej klasy, z określoną rozróżnianiem wielkości liter.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) CreateDelegate(Type, Type, String, Boolean, Boolean) CreateDelegate(Type, Type, String, Boolean, Boolean) CreateDelegate(Type, Type, String, Boolean, Boolean)

Tworzy delegat określonego typu, który reprezentuje określoną metodę statyczną określonej klasy, z określoną wielkością liter i określonym zachowaniem w przypadku niepowodzenia powiązania.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[]) DynamicInvoke(Object[]) DynamicInvoke(Object[]) DynamicInvoke(Object[])

Dynamicznie wywołuje (późne wiązanie) metodę reprezentowaną przez bieżącego delegata.Dynamically invokes (late-bound) the method represented by the current delegate.

DynamicInvokeImpl(Object[]) DynamicInvokeImpl(Object[]) DynamicInvokeImpl(Object[]) DynamicInvokeImpl(Object[])

Dynamicznie wywołuje (późne wiązanie) metodę reprezentowaną przez bieżącego delegata.Dynamically invokes (late-bound) the method represented by the current delegate.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Określa, czy określony obiekt i bieżący delegat są tego samego typu i mają te same cele, metody i listę wywołań.Determines whether the specified object and the current delegate are of the same type and share the same targets, methods, and invocation list.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Zwraca kod skrótu delegata.Returns a hash code for the delegate.

GetInvocationList() GetInvocationList() GetInvocationList() GetInvocationList()

Zwraca listę wywołań delegata.Returns the invocation list of the delegate.

GetMethodImpl() GetMethodImpl() GetMethodImpl() GetMethodImpl()

Pobiera metodę statyczną reprezentowaną przez bieżącego delegata.Gets the static method represented by the current delegate.

GetObjectData(SerializationInfo, StreamingContext) GetObjectData(SerializationInfo, StreamingContext) GetObjectData(SerializationInfo, StreamingContext) GetObjectData(SerializationInfo, StreamingContext)

Nieobsługiwane.Not supported.

GetType() GetType() GetType() GetType()

Pobiera Type bieżącego wystąpienia.Gets the Type of the current instance.

(Inherited from Object)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Tworzy płytką kopię bieżącego Object.Creates a shallow copy of the current Object.

(Inherited from Object)
Remove(Delegate, Delegate) Remove(Delegate, Delegate) Remove(Delegate, Delegate) Remove(Delegate, Delegate)

Usuwa ostatnią liczbę wywołań listy delegatów z listy wywołań innego delegata.Removes the last occurrence of the invocation list of a delegate from the invocation list of another delegate.

RemoveAll(Delegate, Delegate) RemoveAll(Delegate, Delegate) RemoveAll(Delegate, Delegate) RemoveAll(Delegate, Delegate)

Usuwa wszystkie wystąpienia list wywołania delegata z listy wywołań innego delegata.Removes all occurrences of the invocation list of a delegate from the invocation list of another delegate.

RemoveImpl(Delegate) RemoveImpl(Delegate) RemoveImpl(Delegate) RemoveImpl(Delegate)

Usuwa listę wywołań delegata z listy wywołań innego delegata.Removes the invocation list of a delegate from the invocation list of another delegate.

ToString() ToString() ToString() ToString()

Zwraca ciąg, który reprezentuje bieżący obiekt.Returns a string that represents the current object.

(Inherited from Object)

Operatory

Equality(Delegate, Delegate) Equality(Delegate, Delegate) Equality(Delegate, Delegate) Equality(Delegate, Delegate)

Określa, czy określone Delegaty są równe.Determines whether the specified delegates are equal.

Inequality(Delegate, Delegate) Inequality(Delegate, Delegate) Inequality(Delegate, Delegate) Inequality(Delegate, Delegate)

Określa, czy określone Delegaty nie są równe.Determines whether the specified delegates are not equal.

Metody rozszerzania

GetMethodInfo(Delegate) GetMethodInfo(Delegate) GetMethodInfo(Delegate) GetMethodInfo(Delegate)

Pobiera obiekt, który reprezentuje metodę reprezentowaną przez określony delegat.Gets an object that represents the method represented by the specified delegate.

Dotyczy

Zobacz też