Delegate Sınıf

Tanım

Statik bir yönteme veya bir sınıf örneğine veya bu sınıfın örnek metoduna başvuran bir veri yapısı olan bir temsilciyi temsil eder.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
public ref class Delegate abstract : ICloneable, System::Runtime::Serialization::ISerializable
public abstract class Delegate
public abstract class Delegate : ICloneable, System.Runtime.Serialization.ISerializable
[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.AutoDual)]
[System.Serializable]
public abstract class Delegate : ICloneable, System.Runtime.Serialization.ISerializable
[System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.AutoDual)]
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public abstract class Delegate : ICloneable, System.Runtime.Serialization.ISerializable
type Delegate = class
type Delegate = class
    interface ICloneable
    interface ISerializable
[<System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.AutoDual)>]
[<System.Serializable>]
type Delegate = class
    interface ICloneable
    interface ISerializable
[<System.Runtime.InteropServices.ClassInterface(System.Runtime.InteropServices.ClassInterfaceType.AutoDual)>]
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type Delegate = class
    interface ICloneable
    interface ISerializable
Public MustInherit Class Delegate
Public MustInherit Class Delegate
Implements ICloneable, ISerializable
Devralma
Delegate
Türetilmiş
Öznitelikler
Uygulamalar

Örnekler

Aşağıdaki örnek adında bir temsilcinin nasıl tanımlanacağını gösterir myMethodDelegate .The following example shows how to define a delegate named myMethodDelegate. Bu temsilcinin örnekleri, bir örnek yöntemi ve iç içe yerleştirilmiş sınıfın statik bir yöntemi için oluşturulur mySampleClass .Instances of this delegate are created for an instance method and a static method of the nested mySampleClass class. Örnek yöntemi için olan temsilci bir örneği gerektirir mySampleClass .The delegate for the instance method requires an instance of mySampleClass. mySampleClassÖrnek adlı bir değişkende kaydedilir 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 "".

Açıklamalar

DelegateSınıfı, temsilci türleri için temel sınıftır.The Delegate class is the base class for delegate types. Ancak, yalnızca sistem ve derleyiciler doğrudan Delegate sınıftan veya sınıftan türetilebilir MulticastDelegate .However, only the system and compilers can derive explicitly from the Delegate class or from the MulticastDelegate class. Ayrıca, temsilci türünden yeni bir tür türetmeye izin verilmez.It is also not permissible to derive a new type from a delegate type. DelegateSınıf, temsilci türü olarak kabul edilmez; temsilci türlerini türetmek için kullanılan bir sınıftır.The Delegate class is not considered a delegate type; it is a class used to derive delegate types.

Çoğu dil bir delegate anahtar sözcük uygular ve bu dillere yönelik derleyiciler sınıftan türetilebilir MulticastDelegate ; Bu nedenle, kullanıcılar delegate dilin sunduğu anahtar sözcüğü kullanmalıdır.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.

Not

Ortak dil çalışma zamanı, Invoke temsilciyle aynı imzaya sahip her temsilci türü için bir yöntem sağlar.The common language runtime provides an Invoke method for each delegate type, with the same signature as the delegate. Derleyiciler otomatik olarak çağırdığından, bu yöntemi C#, Visual Basic veya Visual C++ açıkça çağırmak zorunda değilsiniz.You do not have to call this method explicitly from C#, Visual Basic, or Visual C++, because the compilers call it automatically. InvokeYöntemi, temsilci türünün imzasını bulmak istediğinizde, yansıma için yararlıdır.The Invoke method is useful in reflection when you want to find the signature of the delegate type.

Ortak dil çalışma zamanı, BeginInvoke EndInvoke temsilcinin zaman uyumsuz olarak çağrılmasını sağlamak için her bir temsilci türünü ve yöntemleri sağlar.The common language runtime provides each delegate type with BeginInvoke and EndInvoke methods, to enable asynchronous invocation of the delegate. Bu yöntemler hakkında daha fazla bilgi için bkz. zaman uyumsuz yöntemleri zaman uyumsuz olarak çağırma.For more information about these methods, see Calling Synchronous Methods Asynchronously.

Bir temsilci türünün bildirimi, bir veya daha fazla yöntemin imzasını belirten bir anlaşma oluşturur.The declaration of a delegate type establishes a contract that specifies the signature of one or more methods. Temsilci, başvurusu olan bir temsilci türünün örneğidir:A delegate is an instance of a delegate type that has references to:

  • Bir türün örnek yöntemi ve bu türe atanabilir bir hedef nesne.An instance method of a type and a target object assignable to that type.

  • Biçimsel parametre listesinde gösterilen gizli parametresi olan bir türün örnek yöntemi this .An instance method of a type, with the hidden this parameter exposed in the formal parameter list. Temsilci bir açık örnek temsilcisi olarak kabul edilir.The delegate is said to be an open instance delegate.

  • Statik bir yöntem.A static method.

  • Bir statik yöntem ve bir hedef nesne, yönteminin ilk parametresine atanabilir.A static method and a target object assignable to the first parameter of the method. Temsilcinin ilk bağımsız değişkeni üzerinde kapalı olduğu söylenir.The delegate is said to be closed over its first argument.

Temsilci bağlama hakkında daha fazla bilgi için bkz CreateDelegate(Type, Object, MethodInfo, Boolean) . yöntem aşırı yüklemesi.For more information on delegate binding, see the CreateDelegate(Type, Object, MethodInfo, Boolean) method overload.

Not

.NET Framework sürüm 1,0 ve 1,1 ' de, bir temsilci yalnızca yöntemin imzası temsilci türü tarafından belirtilen imzayla tam olarak eşleşiyorsa bir yöntemi temsil edebilir.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. Bu nedenle, yukarıdaki listede yalnızca birinci ve üçüncü madde işaretleri desteklenir ve ilk madde işareti tam bir tür eşleşmesi gerektirir.Thus, only the first and third bullets in the preceding list are supported, and the first bullet requires an exact type match.

Bir temsilci, ilk bağımsız değişkeniyle kapatılan bir örnek yöntemini temsil ettiğinde (en yaygın durum), temsilci yöntemin giriş noktasına bir başvuru ve yöntemi tanımlayan türe atanabilir bir tür olan Target adı verilen bir nesneye başvuru depolar.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. Bir temsilci bir açık örnek yöntemini temsil ettiğinde, yöntemin giriş noktasına bir başvuru depolar.When a delegate represents an open instance method, it stores a reference to the method's entry point. Temsilci imzası, this biçimsel parametre listesinde gizli parametresini içermelidir; bu durumda, temsilci bir hedef nesnesine bir başvuruya sahip değildir ve temsilci çağrıldığında hedef nesne sağlanmalıdır.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.

Bir temsilci statik bir yöntemi temsil ettiğinde, temsilci yöntemin giriş noktasına bir başvuru depolar.When a delegate represents a static method, the delegate stores a reference to the method's entry point. Bir temsilci, ilk bağımsız değişkeni üzerinden kapatılan bir statik yöntemi temsil ettiğinde, temsilci yöntemin giriş noktasına bir başvuru ve yöntemin ilk bağımsız değişkeninin türüne atanabilir bir hedef nesnesine bir başvuru depolar.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. Temsilci çağrıldığında, statik yöntemin ilk bağımsız değişkeni hedef nesneyi alır.When the delegate is invoked, the first argument of the static method receives the target object.

Bir temsilcinin çağırma listesi, listedeki her bir öğenin temsilci tarafından temsil edilen yöntemlerden tam olarak birini çağırdığı, sıralı bir temsilciler kümesidir.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. Bir çağırma listesi, yinelenen yöntemler içerebilir.An invocation list can contain duplicate methods. Çağırma sırasında Yöntemler, çağırma listesinde göründükleri sırada çağrılır.During an invocation, methods are invoked in the order in which they appear in the invocation list. Bir temsilci, çağırma listesindeki her yöntemi çağırmayı dener; yinelemeler, çağırma listesinde her görünzaman bir kez çağrılır.A delegate attempts to invoke every method in its invocation list; duplicates are invoked once for each time they appear in the invocation list. Temsilciler sabittir; bir temsilcinin çağırma listesi oluşturulduktan sonra değişmez.Delegates are immutable; once created, the invocation list of a delegate does not change.

Bir temsilci bir veya daha fazla yöntemi çağırabildiğinden ve işlemleri birleştirmek için kullanılabilir olduğundan, temsilciler çok noktaya yayın veya combinable olarak adlandırılır.Delegates are referred to as multicast, or combinable, because a delegate can invoke one or more methods and can be used in combining operations.

Ve gibi işlemleri birleştirme Combine Remove , mevcut temsilcileri değiştirmez.Combining operations, such as Combine and Remove, do not alter existing delegates. Bunun yerine, böyle bir işlem işlemin sonuçlarını, değiştirilmemiş bir temsilciyi veya öğesini içeren yeni bir temsilci döndürür null .Instead, such an operation returns a new delegate that contains the results of the operation, an unchanged delegate, or null. Bir birleştirme işlemi, null işlemin sonucu en az bir yönteme başvurmayan bir Temsilciyse döndürür.A combining operation returns null when the result of the operation is a delegate that does not reference at least one method. Bir birleştirme işlemi, istenen işlemin etkisi olmadığında değiştirilmemiş bir temsilci döndürür.A combining operation returns an unchanged delegate when the requested operation has no effect.

Not

Yönetilen diller, Combine Remove temsilci işlemlerini uygulamak için ve yöntemlerini kullanır.Managed languages use the Combine and Remove methods to implement delegate operations. Örnek olarak, AddHandler RemoveHandler Visual Basic ve deyimlerini C# ' deki temsilci türleri üzerinde + = ve-= Işleçleri içerir.Examples include the AddHandler and RemoveHandler statements in Visual Basic and the += and -= operators on delegate types in C#.

İle başlayarak .NET Framework 4.NET Framework 4 , genel temsilci türleri değişken tür parametrelerine sahip olabilir.Starting with the .NET Framework 4.NET Framework 4, generic delegate types can have variant type parameters. Değişken karşıtı tür parametreleri, temsilcinin parametre türleri olarak kullanılabilir ve dönüş türü olarak birlikte varyant türü bir parametre kullanılabilir.Contravariant type parameters can be used as parameter types of the delegate, and a covariant type parameter can be used as the return type. Bu özellik, tür bağımsız değişkenleri, Kovaryans ve değişken varyansbölümünde açıklandığı gibi devralma ilişkisi olan başvuru türleri ise, aynı genel tür tanımından oluşturulan genel temsilci türlerinin atama ile uyumlu olmasını sağlar.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.

Not

Varyans ile atama uyumlu olan genel temsilcilerin combinable olması gerekmez.Generic delegates that are assignment-compatible because of variance are not necessarily combinable. Combinable olması için, türlerin tam olarak eşleşmesi gerekir.To be combinable, the types must match exactly. Örneğin, adlı bir sınıfın Derived adlı bir sınıftan türetildiğini varsayalım Base .For example, suppose that a class named Derived is derived from a class named Base. Türü bir temsilci Action<Base> ( Action(Of Base) Visual Basic) türünde bir değişkene atanabilir Action<Derived> , ancak türler tam olarak eşleşmediğinden iki temsilci birleştirilemez.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.

Çağrılan bir yöntem bir özel durum oluşturursa, yöntem yürütmeyi sonlandırır, özel durum temsilciyi çağırana geri geçirilir ve çağırma listesindeki kalan Yöntemler çağrılmaz.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. Çağırandaki özel durumu yakalama bu davranışı değiştirmez.Catching the exception in the caller does not alter this behavior.

Bir temsilci tarafından çağrılan yöntemlerin imzası bir dönüş değeri içeriyorsa, temsilci, çağırma listesindeki son öğenin dönüş değerini döndürür.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. İmza, başvuruya göre geçirilen bir parametre içerdiğinde, parametrenin son değeri, çağırma listesindeki her yöntemin, sırayla yürütülen ve parametrenin değerini güncelleştiren sonucudur.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.

C 'deki bir temsilcinin en yakın eşdeğeri bir işlev işaretçisidir.The closest equivalent of a delegate in C is a function pointer. Bir temsilci statik bir yöntemi veya örnek yöntemi temsil edebilir.A delegate can represent a static method or an instance method. Temsilci bir örnek yöntemini temsil ettiğinde, temsilci yalnızca metodun giriş noktasına bir başvuru değil, aynı zamanda sınıf örneğine de bir başvuru içerir.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. İşlev işaretçilerinden farklı olarak, temsilciler nesne yönelimli ve tür güvenlidir.Unlike function pointers, delegates are object oriented and type safe.

Oluşturucular

Delegate(Object, String)

Belirtilen sınıf örneğinde belirtilen örnek yöntemini çağıran bir temsilci başlatır.Initializes a delegate that invokes the specified instance method on the specified class instance.

Delegate(Type, String)

Belirtilen sınıftan belirtilen statik yöntemi çağıran bir temsilciyi başlatır.Initializes a delegate that invokes the specified static method from the specified class.

Özellikler

Method

Temsilci tarafından temsil edilen yöntemi alır.Gets the method represented by the delegate.

Target

Geçerli temsilcinin örnek yöntemini çağırdığı sınıf örneğini alır.Gets the class instance on which the current delegate invokes the instance method.

Yöntemler

Clone()

Temsilcinin basit bir kopyasını oluşturur.Creates a shallow copy of the delegate.

Combine(Delegate, Delegate)

İki temsilciyi çağırma listelerini birleştirir.Concatenates the invocation lists of two delegates.

Combine(Delegate[])

Bir temsilciler dizisinin çağırma listelerini birleştirir.Concatenates the invocation lists of an array of delegates.

CombineImpl(Delegate)

Belirtilen çok noktaya yayın (combinable) temsilcisinin çağrı listelerini ve geçerli çok noktaya yayın (combinable) temsilcisini birleştirir.Concatenates the invocation lists of the specified multicast (combinable) delegate and the current multicast (combinable) delegate.

CreateDelegate(Type, MethodInfo)

Belirtilen statik yöntemi temsil etmek için belirtilen türde bir temsilci oluşturur.Creates a delegate of the specified type to represent the specified static method.

CreateDelegate(Type, MethodInfo, Boolean)

Belirtilen statik yöntemi temsil etmek için belirtilen türde bir temsilci oluşturur ve bu, bağlama hatası üzerine belirtilen davranışla birlikte oluşturulur.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)

Belirtilen ilk bağımsız değişkenle belirtilen statik veya örnek yöntemini temsil eden belirtilen tür için bir temsilci oluşturur.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)

Belirtilen ilk bağımsız değişkenle belirtilen bir statik veya örnek yöntemini temsil eden belirtilen tür için bir temsilci oluşturur ve bu, bağlama başarısızlığının belirtilen şekilde belirlenir.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)

Belirtilen sınıf örneğinde çağırmak için belirtilen örnek yöntemini temsil eden belirtilen türde bir temsilci oluşturur.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)

Belirtilen sınıf örneğinde belirtilen büyük/küçük harf duyarlılığı ile çağırmak için belirtilen örnek yöntemini temsil eden belirtilen türde bir temsilci oluşturur.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)

Belirtilen sınıf örneğinde çağırmak için belirtilen örnek yöntemini temsil eden belirtilen tür için bir temsilci oluşturur, belirtilen büyük/küçük harf duyarlılığı ve bağlama hatası için belirtilen davranışla birlikte.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)

Belirtilen sınıfın belirtilen statik yöntemini temsil eden belirtilen türde bir temsilci oluşturur.Creates a delegate of the specified type that represents the specified static method of the specified class.

CreateDelegate(Type, Type, String, Boolean)

Belirtilen sınıfın belirtilen statik yöntemini temsil eden belirtilen bir tür için belirtilen büyük/küçük harf duyarlılığı olan bir temsilci oluşturur.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)

Belirtilen sınıfın belirtilen statik yöntemini, belirtilen büyük/küçük harf duyarlılığı ve bağlama hatası üzerine belirtilen davranışla temsil eden belirtilen türde bir temsilci oluşturur.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[])

Geçerli temsilci tarafından temsil edilen yöntemi dinamik olarak çağırır (geç bağlı).Dynamically invokes (late-bound) the method represented by the current delegate.

DynamicInvokeImpl(Object[])

Geçerli temsilci tarafından temsil edilen yöntemi dinamik olarak çağırır (geç bağlı).Dynamically invokes (late-bound) the method represented by the current delegate.

Equals(Object)

Belirtilen nesnenin ve geçerli temsilcinin aynı türde olup olmadığını belirler ve aynı hedefleri, yöntemleri ve çağırma listesini paylaşır.Determines whether the specified object and the current delegate are of the same type and share the same targets, methods, and invocation list.

GetHashCode()

Temsilci için bir karma kod döndürür.Returns a hash code for the delegate.

GetInvocationList()

Temsilcinin çağırma listesini döndürür.Returns the invocation list of the delegate.

GetMethodImpl()

Geçerli temsilci tarafından temsil edilen statik yöntemi alır.Gets the static method represented by the current delegate.

GetObjectData(SerializationInfo, StreamingContext)

Desteklenmez.Not supported.

GetType()

TypeGeçerli örneği alır.Gets the Type of the current instance.

(Devralındığı yer: Object)
MemberwiseClone()

Geçerli bir basit kopyasını oluşturur Object .Creates a shallow copy of the current Object.

(Devralındığı yer: Object)
Remove(Delegate, Delegate)

Bir temsilcinin çağrı listesinin son oluşumunu başka bir temsilcinin çağırma listesinden kaldırır.Removes the last occurrence of the invocation list of a delegate from the invocation list of another delegate.

RemoveAll(Delegate, Delegate)

Bir temsilcinin çağrı listesinin tüm oluşumlarını başka bir temsilcinin çağırma listesinden kaldırır.Removes all occurrences of the invocation list of a delegate from the invocation list of another delegate.

RemoveImpl(Delegate)

Bir temsilcinin çağırma listesini başka bir temsilcinin çağırma listesinden kaldırır.Removes the invocation list of a delegate from the invocation list of another delegate.

ToString()

Geçerli nesneyi temsil eden dizeyi döndürür.Returns a string that represents the current object.

(Devralındığı yer: Object)

İşleçler

Equality(Delegate, Delegate)

Belirtilen temsilcilerin eşit olup olmadığını belirler.Determines whether the specified delegates are equal.

Inequality(Delegate, Delegate)

Belirtilen temsilcilerin eşit olup olmadığını belirler.Determines whether the specified delegates are not equal.

Uzantı Metotları

GetMethodInfo(Delegate)

Belirtilen temsilci tarafından temsil edilen yöntemi temsil eden bir nesne alır.Gets an object that represents the method represented by the specified delegate.

Şunlara uygulanır

Ayrıca bkz.