Delegate.CreateDelegate Delegate.CreateDelegate Delegate.CreateDelegate Method

Definition

Erstellt einen Delegaten vom angegebenen Typs.Creates a delegate of the specified type.

Überlädt

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

Erstellt einen Delegaten vom angegebenen Typ, der die angegebene statische Methode der angegebenen Klasse darstellt, wobei die Groß- und Kleinschreibung und das Verhalten bei Bindungsfehlern den Angaben entsprechend berücksichtigt bzw. nicht berücksichtigt wird.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.

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

Erstellt einen Delegaten vom angegebenen Typ, der die angegebene statische Methode der angegebenen Klasse mit der angegebenen Berücksichtigung von Groß- und Kleinschreibung darstellt.Creates a delegate of the specified type that represents the specified static method of the specified class, with the specified case-sensitivity.

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

Erstellt einen Delegaten vom angegebenen Typ, der die angegebene Instanzenmethode darstellt, die für die angegebene Klasseninstanz aufgerufen werden soll, wobei die Groß- und Kleinschreibung den Angaben entsprechend berücksichtigt bzw. nicht berücksichtigt wird.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, MethodInfo, Boolean) CreateDelegate(Type, Object, MethodInfo, Boolean) CreateDelegate(Type, Object, MethodInfo, Boolean)

Erstellt einen Delegaten vom angegebenen Typ, der die angegebene statische Methode oder Instanzmethode mit dem angegebenen ersten Argument und dem angegebenen Verhalten bei Bindungsfehlern darstellt.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, Boolean, Boolean) CreateDelegate(Type, Object, String, Boolean, Boolean) CreateDelegate(Type, Object, String, Boolean, Boolean)

Erstellt einen Delegaten vom angegebenen Typ, der die angegebene Instanzenmethode darstellt, die für die angegebene Klasseninstanz aufgerufen werden soll, wobei die Groß- und Kleinschreibung und das Verhalten bei Bindungsfehlern den Angaben entsprechend berücksichtigt bzw. nicht berücksichtigt wird.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, MethodInfo, Boolean) CreateDelegate(Type, MethodInfo, Boolean) CreateDelegate(Type, MethodInfo, Boolean)

Erstellt einen Delegaten vom angegeben Typ zum Darstellen der angegebenen statischen Methode mit dem angegebenen Verhalten bei Bindungsfehlern.Creates a delegate of the specified type to represent the specified static method, with the specified behavior on failure to bind.

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

Erstellt einen Delegaten vom angegebenen Typ, der die angegebene Instanzenmethode darstellt, die für die angegebene Klasseninstanz aufgerufen werden soll.Creates a delegate of the specified type that represents the specified instance method to invoke on the specified class instance.

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

Erstellt einen Delegaten vom angegebenen Typ, der die angegebene statische Methode oder Instanzmethode mit dem angegebenen ersten Argument darstellt.Creates a delegate of the specified type that represents the specified static or instance method, with the specified first argument.

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

Erstellt einen Delegaten vom angegebenen Typ, der die angegebene statische Methode der angegebenen Klasse darstellt.Creates a delegate of the specified type that represents the specified static method of the specified class.

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

Erstellt einen Delegaten vom angegebenen Typ, der die angegebene statische Methode darstellen soll.Creates a delegate of the specified type to represent the specified static method.

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

Erstellt einen Delegaten vom angegebenen Typ, der die angegebene statische Methode der angegebenen Klasse darstellt, wobei die Groß- und Kleinschreibung und das Verhalten bei Bindungsfehlern den Angaben entsprechend berücksichtigt bzw. nicht berücksichtigt wird.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.

public:
 static Delegate ^ CreateDelegate(Type ^ type, Type ^ target, System::String ^ method, bool ignoreCase, bool throwOnBindFailure);
public static Delegate CreateDelegate (Type type, Type target, string method, bool ignoreCase, bool throwOnBindFailure);
static member CreateDelegate : Type * Type * string * bool * bool -> Delegate

Parameter

type
Type Type Type

Der Type des zu erstellenden Delegaten.The Type of delegate to create.

target
Type Type Type

Der Type, der die Klasse darstellt, die von method implementiert wird.The Type representing the class that implements method.

method
String String String

Der Name der statischen Methode, die durch den Delegaten dargestellt werden soll.The name of the static method that the delegate is to represent.

ignoreCase
Boolean Boolean Boolean

Ein boolescher Wert, der angibt, ob die Groß- und Kleinschreibung beim Vergleichen des Methodennamens berücksichtigt werden soll.A Boolean indicating whether to ignore the case when comparing the name of the method.

throwOnBindFailure
Boolean Boolean Boolean

true, um eine Ausnahme auszulösen, wenn method nicht gebunden werden kann, andernfalls false.true to throw an exception if method cannot be bound; otherwise, false.

Gibt zurück

Ein Delegat vom angegebenen Typ, der die angegebene statische Methode der angegebenen Klasse darstellt.A delegate of the specified type that represents the specified static method of the specified class.

Ausnahmen

type ist null.type is null.

- oder - -or- target ist null.target is null.

- oder - -or- method ist null.method is null.

type erbt nicht MulticastDelegate.type does not inherit MulticastDelegate.

- oder --or- type ist keine RuntimeType.type is not a RuntimeType. Siehe Laufzeittypen in Reflektion.See Runtime Types in Reflection.

- oder --or- target ist keine RuntimeType.target is not a RuntimeType.

- oder --or- target ist ein offener generischer Typ.target is an open generic type. Das bedeutet, die ContainsGenericParameters-Eigenschaft ist true.That is, its ContainsGenericParameters property is true.

- oder --or- method ist keine static-Methode (Shared-Methode in Visual Basic).method is not a static method (Shared method in Visual Basic).

- oder --or- method kann nicht gebunden werden, z. B. weil sie nicht gefunden wurde, und throwOnBindFailure ist gleich true.method cannot be bound, for example because it cannot be found, and throwOnBindFailure is true.

Die Invoke-Methode von type wurde nicht gefunden.The Invoke method of type is not found.

Der Aufrufer verfügt nicht über die erforderlichen Berechtigungen für den Zugriff auf method.The caller does not have the permissions necessary to access method.

Hinweise

Diese Methode erstellt die Delegaten für die nur statische Methoden.This method creates delegates for static methods only. Eine Instanzmethode handelt es sich um eine Methode, die eine Instanz einer Klasse zugeordnet ist; eine statische Methode handelt es sich um eine Methode, die die Klasse selbst zugeordnet ist.An instance method is a method that is associated with an instance of a class; a static method is a method that is associated with the class itself.

Hinweis

Beginnend mit der .NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1, diese Methode kann verwendet werden, um nicht öffentliche Methoden zugreifen, wenn der Aufrufer erteilt wurde ReflectionPermission mit der ReflectionPermissionFlag.RestrictedMemberAccess kennzeichnen und Menge oder eine Teilmenge der Berechtigungssatz die nicht öffentliche Methoden an des Aufrufers des beschränkt ist zu gewähren davon.Starting with the .NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1, this method can be used to access non-public methods if the caller has been granted ReflectionPermission with the ReflectionPermissionFlag.RestrictedMemberAccess flag and if the grant set of the non-public methods is restricted to the caller's grant set, or a subset thereof. (Finden Sie unter Überlegungen zur Sicherheit für die Reflektion.)(See Security Considerations for Reflection.)

Zur Verwendung dieser Funktionen sollte die Anwendung für .NET Framework 3,5.NET Framework 3.5 oder höher ausgelegt sein. To use this functionality, your application should target the .NET Framework 3,5.NET Framework 3.5 or later.

Sicherheit

ReflectionPermission
Beim Aufruf spät gebundene durch Mechanismen wie z. B. InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[]).when invoked late-bound through mechanisms such as InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[]). Zugeordnete Enumeration: MemberAccessAssociated enumeration: MemberAccess.

Siehe auch

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

Erstellt einen Delegaten vom angegebenen Typ, der die angegebene statische Methode der angegebenen Klasse mit der angegebenen Berücksichtigung von Groß- und Kleinschreibung darstellt.Creates a delegate of the specified type that represents the specified static method of the specified class, with the specified case-sensitivity.

public:
 static Delegate ^ CreateDelegate(Type ^ type, Type ^ target, System::String ^ method, bool ignoreCase);
public static Delegate CreateDelegate (Type type, Type target, string method, bool ignoreCase);
static member CreateDelegate : Type * Type * string * bool -> Delegate

Parameter

type
Type Type Type

Der Type des zu erstellenden Delegaten.The Type of delegate to create.

target
Type Type Type

Der Type, der die Klasse darstellt, die von method implementiert wird.The Type representing the class that implements method.

method
String String String

Der Name der statischen Methode, die durch den Delegaten dargestellt werden soll.The name of the static method that the delegate is to represent.

ignoreCase
Boolean Boolean Boolean

Ein boolescher Wert, der angibt, ob die Groß- und Kleinschreibung beim Vergleichen des Methodennamens berücksichtigt werden soll.A Boolean indicating whether to ignore the case when comparing the name of the method.

Gibt zurück

Ein Delegat vom angegebenen Typ, der die angegebene statische Methode der angegebenen Klasse darstellt.A delegate of the specified type that represents the specified static method of the specified class.

Ausnahmen

type ist null.type is null.

- oder - -or- target ist null.target is null.

- oder - -or- method ist null.method is null.

type erbt nicht MulticastDelegate.type does not inherit MulticastDelegate.

- oder --or- type ist keine RuntimeType.type is not a RuntimeType. Siehe Laufzeittypen in Reflektion.See Runtime Types in Reflection.

- oder --or- target ist keine RuntimeType.target is not a RuntimeType.

- oder --or- target ist ein offener generischer Typ.target is an open generic type. Das bedeutet, die ContainsGenericParameters-Eigenschaft ist true.That is, its ContainsGenericParameters property is true.

- oder --or- method ist keine static-Methode (Shared-Methode in Visual Basic).method is not a static method (Shared method in Visual Basic).

- oder --or- method kann nicht gebunden werden, z. B. weil sie nicht gefunden wurde.method cannot be bound, for example because it cannot be found.

Die Invoke-Methode von type wurde nicht gefunden.The Invoke method of type is not found.

Der Aufrufer verfügt nicht über die erforderlichen Berechtigungen für den Zugriff auf method.The caller does not have the permissions necessary to access method.

Hinweise

Diese Methode erstellt die Delegaten für die nur statische Methoden.This method creates delegates for static methods only. Eine Instanzmethode handelt es sich um eine Methode, die eine Instanz einer Klasse zugeordnet ist; eine statische Methode handelt es sich um eine Methode, die die Klasse selbst zugeordnet ist.An instance method is a method that is associated with an instance of a class; a static method is a method that is associated with the class itself.

Überladung dieser Methode entspricht dem Aufrufen der CreateDelegate(Type, Type, String, Boolean, Boolean) -methodenüberladung angeben true für throwOnBindFailure.This method overload is equivalent to calling the CreateDelegate(Type, Type, String, Boolean, Boolean) method overload, specifying true for throwOnBindFailure.

Hinweis

Beginnend mit der .NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1, diese Methode kann verwendet werden, um nicht öffentliche Methoden zugreifen, wenn der Aufrufer erteilt wurde ReflectionPermission mit der ReflectionPermissionFlag.RestrictedMemberAccess kennzeichnen und Menge oder eine Teilmenge der Berechtigungssatz die nicht öffentliche Methoden an des Aufrufers des beschränkt ist zu gewähren davon.Starting with the .NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1, this method can be used to access non-public methods if the caller has been granted ReflectionPermission with the ReflectionPermissionFlag.RestrictedMemberAccess flag and if the grant set of the non-public methods is restricted to the caller's grant set, or a subset thereof. (Finden Sie unter Überlegungen zur Sicherheit für die Reflektion.)(See Security Considerations for Reflection.)

Zur Verwendung dieser Funktionen sollte die Anwendung für .NET Framework 3,5.NET Framework 3.5 oder höher ausgelegt sein. To use this functionality, your application should target the .NET Framework 3,5.NET Framework 3.5 or later.

Sicherheit

ReflectionPermission
Beim Aufruf spät gebundene durch Mechanismen wie z. B. InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[]).when invoked late-bound through mechanisms such as InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[]). Zugeordnete Enumeration: MemberAccessAssociated enumeration: MemberAccess.

Siehe auch

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

Erstellt einen Delegaten vom angegebenen Typ, der die angegebene Instanzenmethode darstellt, die für die angegebene Klasseninstanz aufgerufen werden soll, wobei die Groß- und Kleinschreibung den Angaben entsprechend berücksichtigt bzw. nicht berücksichtigt wird.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.

public:
 static Delegate ^ CreateDelegate(Type ^ type, System::Object ^ target, System::String ^ method, bool ignoreCase);
public static Delegate CreateDelegate (Type type, object target, string method, bool ignoreCase);
static member CreateDelegate : Type * obj * string * bool -> Delegate

Parameter

type
Type Type Type

Der Type des zu erstellenden Delegaten.The Type of delegate to create.

target
Object Object Object

Die Klasseninstanz, für die method aufgerufen wird.The class instance on which method is invoked.

method
String String String

Der Name der Instanzenmethode, die durch den Delegaten dargestellt werden soll.The name of the instance method that the delegate is to represent.

ignoreCase
Boolean Boolean Boolean

Ein boolescher Wert, der angibt, ob die Groß- und Kleinschreibung beim Vergleichen des Methodennamens berücksichtigt werden soll.A Boolean indicating whether to ignore the case when comparing the name of the method.

Gibt zurück

Ein Delegat vom angegebenen Typ, der die angegebene Instanzenmethode darstellt, die für die angegebene Klasseninstanz aufgerufen werden soll.A delegate of the specified type that represents the specified instance method to invoke on the specified class instance.

Ausnahmen

type ist null.type is null.

- oder - -or- target ist null.target is null.

- oder - -or- method ist null.method is null.

type erbt nicht MulticastDelegate.type does not inherit MulticastDelegate.

- oder --or- type ist keine RuntimeType.type is not a RuntimeType. Siehe Laufzeittypen in Reflektion.See Runtime Types in Reflection.

- oder --or- method ist keine Instanzenmethode.method is not an instance method.

- oder --or- method kann nicht gebunden werden, z. B. weil sie nicht gefunden wurde.method cannot be bound, for example because it cannot be found.

Die Invoke-Methode von type wurde nicht gefunden.The Invoke method of type is not found.

Der Aufrufer verfügt nicht über die erforderlichen Berechtigungen für den Zugriff auf method.The caller does not have the permissions necessary to access method.

Hinweise

Diese Methode erstellt nur Delegaten für die Instanz.This method creates delegates for instance methods only. Eine Instanzmethode handelt es sich um eine Methode, die eine Instanz einer Klasse zugeordnet ist; eine statische Methode handelt es sich um eine Methode, die die Klasse selbst zugeordnet ist.An instance method is a method that is associated with an instance of a class; a static method is a method that is associated with the class itself.

Überladung dieser Methode entspricht dem Aufrufen der CreateDelegate(Type, Object, String, Boolean, Boolean) -methodenüberladung angeben true für throwOnBindFailure.This method overload is equivalent to calling the CreateDelegate(Type, Object, String, Boolean, Boolean) method overload, specifying true for throwOnBindFailure.

Hinweis

Beginnend mit der .NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1, diese Methode kann verwendet werden, um nicht öffentliche Methoden zugreifen, wenn der Aufrufer erteilt wurde ReflectionPermission mit der ReflectionPermissionFlag.RestrictedMemberAccess kennzeichnen und Menge oder eine Teilmenge der Berechtigungssatz die nicht öffentliche Methoden an des Aufrufers des beschränkt ist zu gewähren davon.Starting with the .NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1, this method can be used to access non-public methods if the caller has been granted ReflectionPermission with the ReflectionPermissionFlag.RestrictedMemberAccess flag and if the grant set of the non-public methods is restricted to the caller's grant set, or a subset thereof. (Finden Sie unter Überlegungen zur Sicherheit für die Reflektion.)(See Security Considerations for Reflection.)

Zur Verwendung dieser Funktionen sollte die Anwendung für .NET Framework 3,5.NET Framework 3.5 oder höher ausgelegt sein. To use this functionality, your application should target the .NET Framework 3,5.NET Framework 3.5 or later.

Sicherheit

ReflectionPermission
Beim Aufruf spät gebundene durch Mechanismen wie z. B. InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[]).when invoked late-bound through mechanisms such as InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[]). Zugeordnete Enumeration: MemberAccessAssociated enumeration: MemberAccess.

Siehe auch

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

Erstellt einen Delegaten vom angegebenen Typ, der die angegebene statische Methode oder Instanzmethode mit dem angegebenen ersten Argument und dem angegebenen Verhalten bei Bindungsfehlern darstellt.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.

public:
 static Delegate ^ CreateDelegate(Type ^ type, System::Object ^ firstArgument, System::Reflection::MethodInfo ^ method, bool throwOnBindFailure);
public static Delegate CreateDelegate (Type type, object firstArgument, System.Reflection.MethodInfo method, bool throwOnBindFailure);
static member CreateDelegate : Type * obj * System.Reflection.MethodInfo * bool -> Delegate

Parameter

type
Type Type Type

Ein Type, der den Typ des zu erstellenden Delegaten darstellt.A Type representing the type of delegate to create.

firstArgument
Object Object Object

Ein Object, das das erste Argument der Methode ist, die der Delegat darstellt.An Object that is the first argument of the method the delegate represents. Bei Instanzmethoden muss dieses mit dem Instanztyp kompatibel sein.For instance methods, it must be compatible with the instance type.

method
MethodInfo MethodInfo MethodInfo

Die MethodInfo, die die statische Methode oder Instanzmethode beschreibt, die der Delegat darstellen soll.The MethodInfo describing the static or instance method the delegate is to represent.

throwOnBindFailure
Boolean Boolean Boolean

true, um eine Ausnahme auszulösen, wenn method nicht gebunden werden kann, andernfalls false.true to throw an exception if method cannot be bound; otherwise, false.

Gibt zurück

Ein Delegat des angegebenen Typs, der die angegebene statische Methode oder Instanzmethode darstellt, oder null, wenn throwOnBindFailure false ist und der Delegat nicht an method gebunden werden kann.A delegate of the specified type that represents the specified static or instance method, or null if throwOnBindFailure is false and the delegate cannot be bound to method.

Ausnahmen

type ist null.type is null.

- oder - -or- method ist null.method is null.

type erbt nicht MulticastDelegate.type does not inherit MulticastDelegate.

- oder --or- type ist keine RuntimeType.type is not a RuntimeType. Siehe Laufzeittypen in Reflektion.See Runtime Types in Reflection.

- oder --or- method kann nicht gebunden werden, und throwOnBindFailure ist true.method cannot be bound, and throwOnBindFailure is true.

- oder --or- method ist keine RuntimeMethodInfo.method is not a RuntimeMethodInfo. Siehe Laufzeittypen in Reflektion.See Runtime Types in Reflection.

Die Invoke-Methode von type wurde nicht gefunden.The Invoke method of type is not found.

Der Aufrufer verfügt nicht über die erforderlichen Berechtigungen für den Zugriff auf method.The caller does not have the permissions necessary to access method.

Beispiele

Dieser Abschnitt enthält drei Codebeispiele aufgeführt.This section contains three code examples. Das erste Beispiel veranschaulicht die vier Arten von Delegaten, die erstellt werden können: über eine Instanzmethode, öffnen Sie über eine Instanzmethode, öffnen Sie über eine statische Methode geschlossen und über eine statische Methode geschlossen.The first example demonstrates the four kinds of delegates that can be created: closed over an instance method, open over an instance method, open over a static method, and closed over a static method.

Im zweiten Codebeispiel wird veranschaulicht, kompatible Parametertypen und Rückgabetypen.The second code example demonstrates compatible parameter types and return types.

Im dritten Codebeispiel wird einen einzelner Delegattyp definiert, und zeigt, dass alle Methoden, die den Delegattyp darstellen können.The third code example defines a single delegate type, and shows all the methods that delegate type can represent.

Beispiel 1Example 1

Im folgenden Codebeispiel wird veranschaulicht, die vier Möglichkeiten, die ein Delegat kann mit dieser Überladung der erstellt werden die CreateDelegate Methode.The following code example demonstrates the four ways a delegate can be created using this overload of the CreateDelegate method.

Hinweis

Es gibt zwei Überladungen der CreateDelegate Methode, die angeben, firstArgument und ein MethodInfo; ihre Funktionalität ist identisch, außer dass eine Ihnen die ermöglicht Angabe, ob bei Bindungsfehlern ausgelöst werden, und die andere löst immer eine.There are two overloads of the CreateDelegate method that specify firstArgument and a MethodInfo; their functionality is the same except that one allows you to specify whether to throw on failure to bind, and the other always throws. Dieses Codebeispiel verwendet beide Überladungen.This code example uses both overloads.

Das Beispiel deklariert eine Klasse C mit einer statischen Methode M2 und eine Instanzmethode M1, sowie zwei Delegattypen: D1 akzeptiert eine Instanz von C und eine Zeichenfolge, D2 akzeptiert eine Zeichenfolge und D3verfügt über keine Argumente.The example declares a class C with a static method M2 and an instance method M1, and three delegate types: D1 takes an instance of C and a string, D2 takes a string, and D3 has no arguments.

Eine zweite Klasse namens Example enthält den Code, der den Delegaten erstellt.A second class named Example contains the code that creates the delegates.

  • Ein Delegat vom Typ D2, geschlossen für eine Instanz von C, wird für die Instanzmethode erstellt M1.A delegate of type D2, closed over an instance of C, is created for the instance method M1. Er wird aufgerufen, mit anderen Zeichenfolgen, um anzugeben, dass die gebundene Instanz von C wird immer verwendet.It is invoked with different strings, to show that the bound instance of C is always used.

  • Ein Delegat vom Typ D1, der eine offene Instanzmethode darstellt, wird für die Instanzmethode erstellt M1.A delegate of type D1, representing an open instance method, is created for the instance method M1. Eine Instanz muss übergeben werden, wenn der Delegat aufgerufen wird.An instance must be passed when the delegate is invoked.

  • Ein Delegat vom Typ D2, eine offene statische Methode darstellt, wird für die statische Methode erstellt M2.A delegate of type D2, representing an open static method, is created for the static method M2.

  • Schließlich einen Delegaten vom Typ D3, über eine Zeichenfolge geschlossen, wird für die statische Methode erstellt M2.Finally, a delegate of type D3, closed over a string, is created for the static method M2. Die Methode wird aufgerufen, um anzugeben, dass sie die gebundene Zeichenfolge verwendet wird.The method is invoked to show that it uses the bound string.

using System;
using System.Reflection;
using System.Security.Permissions;

// Declare three delegate types for demonstrating the combinations
// of static versus instance methods and open versus closed
// delegates.
//
public delegate void D1(C c, string s);
public delegate void D2(string s);
public delegate void D3();

// A sample class with an instance method and a static method.
//
public class C
{
    private int id;
    public C(int id) { this.id = id; }

    public void M1(string s) 
    { 
        Console.WriteLine("Instance method M1 on C:  id = {0}, s = {1}",
            this.id, s);
    }
  
    public static void M2(string s)
    { 
        Console.WriteLine("Static method M2 on C:  s = {0}", s); 
    }
}

public class Example
{
    public static void Main()
    {
        C c1 = new C(42);

        // Get a MethodInfo for each method.
        //
        MethodInfo mi1 = typeof(C).GetMethod("M1", 
            BindingFlags.Public | BindingFlags.Instance);
        MethodInfo mi2 = typeof(C).GetMethod("M2",
            BindingFlags.Public | BindingFlags.Static);

        D1 d1;
        D2 d2;
        D3 d3;


        Console.WriteLine("\nAn instance method closed over C.");
        // In this case, the delegate and the
        // method must have the same list of argument types; use
        // delegate type D2 with instance method M1.
        //
        Delegate test = 
            Delegate.CreateDelegate(typeof(D2), c1, mi1, false);

        // Because false was specified for throwOnBindFailure 
        // in the call to CreateDelegate, the variable 'test'
        // contains null if the method fails to bind (for 
        // example, if mi1 happened to represent a method of  
        // some class other than C).
        //
        if (test != null)
        {
            d2 = (D2) test;

            // The same instance of C is used every time the 
            // delegate is invoked.
            d2("Hello, World!");
            d2("Hi, Mom!");
        }


        Console.WriteLine("\nAn open instance method.");
        // In this case, the delegate has one more 
        // argument than the instance method; this argument comes
        // at the beginning, and represents the hidden instance
        // argument of the instance method. Use delegate type D1
        // with instance method M1.
        //
        d1 = (D1) Delegate.CreateDelegate(typeof(D1), null, mi1);

        // An instance of C must be passed in each time the 
        // delegate is invoked.
        //
        d1(c1, "Hello, World!");
        d1(new C(5280), "Hi, Mom!");


        Console.WriteLine("\nAn open static method.");
        // In this case, the delegate and the method must 
        // have the same list of argument types; use delegate type
        // D2 with static method M2.
        //
        d2 = (D2) Delegate.CreateDelegate(typeof(D2), null, mi2);

        // No instances of C are involved, because this is a static
        // method. 
        //
        d2("Hello, World!");
        d2("Hi, Mom!");


        Console.WriteLine("\nA static method closed over the first argument (String).");
        // The delegate must omit the first argument of the method.
        // A string is passed as the firstArgument parameter, and 
        // the delegate is bound to this string. Use delegate type 
        // D3 with static method M2. 
        //
        d3 = (D3) Delegate.CreateDelegate(typeof(D3), 
            "Hello, World!", mi2);

        // Each time the delegate is invoked, the same string is
        // used.
        d3();
    }
}

/* This code example produces the following output:

An instance method closed over C.
Instance method M1 on C:  id = 42, s = Hello, World!
Instance method M1 on C:  id = 42, s = Hi, Mom!

An open instance method.
Instance method M1 on C:  id = 42, s = Hello, World!
Instance method M1 on C:  id = 5280, s = Hi, Mom!

An open static method.
Static method M2 on C:  s = Hello, World!
Static method M2 on C:  s = Hi, Mom!

A static method closed over the first argument (String).
Static method M2 on C:  s = Hello, World!
 */
Imports System
Imports System.Reflection
Imports System.Security.Permissions

' Declare three delegate types for demonstrating the combinations
' of Shared versus instance methods and open versus closed
' delegates.
'
Public Delegate Sub D1(ByVal c As C, ByVal s As String) 
Public Delegate Sub D2(ByVal s As String) 
Public Delegate Sub D3() 

' A sample class with an instance method and a Shared method.
'
Public Class C
    Private id As Integer
    Public Sub New(ByVal id As Integer) 
        Me.id = id
    End Sub 'New

    Public Sub M1(ByVal s As String) 
        Console.WriteLine("Instance method M1 on C:  id = {0}, s = {1}", _
            Me.id, s)
    End Sub
    
    Public Shared Sub M2(ByVal s As String) 
        Console.WriteLine("Shared method M2 on C:  s = {0}", s)
    End Sub
End Class

Public Class Example
    
    Public Shared Sub Main() 

        Dim c1 As New C(42)
        
        ' Get a MethodInfo for each method.
        '
        Dim mi1 As MethodInfo = GetType(C).GetMethod("M1", _
            BindingFlags.Public Or BindingFlags.Instance)
        Dim mi2 As MethodInfo = GetType(C).GetMethod("M2", _
            BindingFlags.Public Or BindingFlags.Static)
        
        Dim d1 As D1
        Dim d2 As D2
        Dim d3 As D3
        
        
        Console.WriteLine(vbLf & "An instance method closed over C.")
        ' In this case, the delegate and the
        ' method must have the same list of argument types; use
        ' delegate type D2 with instance method M1.
        '
        Dim test As [Delegate] = _
            [Delegate].CreateDelegate(GetType(D2), c1, mi1, False)

        ' Because False was specified for throwOnBindFailure 
        ' in the call to CreateDelegate, the variable 'test'
        ' contains Nothing if the method fails to bind (for 
        ' example, if mi1 happened to represent a method of 
        ' some class other than C).
        '
        If test IsNot Nothing Then
            d2 = CType(test, D2)

            ' The same instance of C is used every time the
            ' delegate is invoked.
            d2("Hello, World!")
            d2("Hi, Mom!")
        End If
        
        
        Console.WriteLine(vbLf & "An open instance method.")
        ' In this case, the delegate has one more 
        ' argument than the instance method; this argument comes
        ' at the beginning, and represents the hidden instance
        ' argument of the instance method. Use delegate type D1
        ' with instance method M1.
        '
        d1 = CType([Delegate].CreateDelegate(GetType(D1), Nothing, mi1), D1)
        
        ' An instance of C must be passed in each time the 
        ' delegate is invoked.
        '
        d1(c1, "Hello, World!")
        d1(New C(5280), "Hi, Mom!")
        
        
        Console.WriteLine(vbLf & "An open Shared method.")
        ' In this case, the delegate and the method must 
        ' have the same list of argument types; use delegate type
        ' D2 with Shared method M2.
        '
        d2 = CType([Delegate].CreateDelegate(GetType(D2), Nothing, mi2), D2)
        
        ' No instances of C are involved, because this is a Shared
        ' method. 
        '
        d2("Hello, World!")
        d2("Hi, Mom!")
        
        
        Console.WriteLine(vbLf & "A Shared method closed over the first argument (String).")
        ' The delegate must omit the first argument of the method.
        ' A string is passed as the firstArgument parameter, and 
        ' the delegate is bound to this string. Use delegate type 
        ' D3 with Shared method M2. 
        '
        d3 = CType([Delegate].CreateDelegate(GetType(D3), "Hello, World!", mi2), D3)
        
        ' Each time the delegate is invoked, the same string is
        ' used.
        d3()
    
    End Sub
End Class

' This code example produces the following output:
'
'An instance method closed over C.
'Instance method M1 on C:  id = 42, s = Hello, World!
'Instance method M1 on C:  id = 42, s = Hi, Mom!
'
'An open instance method.
'Instance method M1 on C:  id = 42, s = Hello, World!
'Instance method M1 on C:  id = 5280, s = Hi, Mom!
'
'An open Shared method.
'Shared method M2 on C:  s = Hello, World!
'Shared method M2 on C:  s = Hi, Mom!
'
'A Shared method closed over the first argument (String).
'Shared method M2 on C:  s = Hello, World!
' 

Beispiel 2Example 2

Im folgenden Codebeispiel wird veranschaulicht, die Kompatibilität der Parametertypen und Rückgabetypen.The following code example demonstrates compatibility of parameter types and return types.

Hinweis

Dieses Codebeispiel verwendet die CreateDelegate(Type, MethodInfo) -methodenüberladung.This code example uses the CreateDelegate(Type, MethodInfo) method overload. Die Verwendung der anderen Überladungen dieser MethodInfo ist ähnlich.The use of other overloads that take MethodInfo is similar.

Das Codebeispiel definiert eine Basisklasse, die mit dem Namen Base und eine Klasse namens Derived abgeleitet, die Base.The code example defines a base class named Base and a class named Derived that derives from Base. Die abgeleitete Klasse verfügt über eine static (Shared in Visual Basic) Methode, die mit dem Namen MyMethod mit einem Parameter vom Typ Base und dem Rückgabetyp der Derived.The derived class has a static (Shared in Visual Basic) method named MyMethod with one parameter of type Base and a return type of Derived. Im Codebeispiel wird definiert auch einen Delegaten, der mit dem Namen Example , die einen Parameter vom Typ hat Derived und dem Rückgabetyp der Base.The code example also defines a delegate named Example that has one parameter of type Derived and a return type of Base.

Im Codebeispiel wird veranschaulicht, dass der Delegat, mit dem Namen Example können verwendet werden, um die Methode darstellen MyMethod.The code example demonstrates that the delegate named Example can be used to represent the method MyMethod. Die Methode kann an den Delegaten gebunden werden, da:The method can be bound to the delegate because:

  • Der Parametertyp des Delegaten (Derived) ist stärker eingeschränkt als der Parametertyp des MyMethod (Base), sodass es immer sicher an das Argument des Delegaten zu übergeben sind MyMethod.The parameter type of the delegate (Derived) is more restrictive than the parameter type of MyMethod (Base), so that it is always safe to pass the argument of the delegate to MyMethod.

  • Der Rückgabetyp der MyMethod (Derived) ist stärker eingeschränkt als der Parametertyp des Delegaten (Base), sodass sie immer sicher, das den Rückgabetyp der Methode, die den Rückgabetyp des Delegaten umgewandelt werden kann.The return type of MyMethod (Derived) is more restrictive than the parameter type of the delegate (Base), so that it is always safe to cast the return type of the method to the return type of the delegate.

Im Codebeispiel erzeugt keine Ausgabe.The code example produces no output.

using namespace System;
using namespace System::Reflection;

// Define two classes to use in the demonstration, a base class and 
// a class that derives from it.
//
public ref class Base {};

public ref class Derived : Base
{
    // Define a static method to use in the demonstration. The method 
    // takes an instance of Base and returns an instance of Derived.  
    // For the purposes of the demonstration, it is not necessary for 
    // the method to do anything useful. 
    //
public:
    static Derived^ MyMethod(Base^ arg)
    {
        Base^ dummy = arg;
        return gcnew Derived();
    }
};

// Define a delegate that takes an instance of Derived and returns an
// instance of Base.
//
public delegate Base^ Example(Derived^ arg);

void main()
{
    // The binding flags needed to retrieve MyMethod.
    BindingFlags flags = BindingFlags::Public | BindingFlags::Static;

    // Get a MethodInfo that represents MyMethod.
    MethodInfo^ minfo = Derived::typeid->GetMethod("MyMethod", flags);

    // Demonstrate contravariance of parameter types and covariance
    // of return types by using the delegate Example to represent
    // MyMethod. The delegate binds to the method because the
    // parameter of the delegate is more restrictive than the 
    // parameter of the method (that is, the delegate accepts an
    // instance of Derived, which can always be safely passed to
    // a parameter of type Base), and the return type of MyMethod
    // is more restrictive than the return type of Example (that
    // is, the method returns an instance of Derived, which can
    // always be safely cast to type Base). 
    //
    Example^ ex = 
        (Example^) Delegate::CreateDelegate(Example::typeid, minfo);

    // Execute MyMethod using the delegate Example.
    //        
    Base^ b = ex(gcnew Derived());
}
using System;
using System.Reflection;

// Define two classes to use in the demonstration, a base class and 
// a class that derives from it.
//
public class Base {}

public class Derived : Base
{
    // Define a static method to use in the demonstration. The method 
    // takes an instance of Base and returns an instance of Derived.  
    // For the purposes of the demonstration, it is not necessary for 
    // the method to do anything useful. 
    //
    public static Derived MyMethod(Base arg)
    {
        Base dummy = arg;
        return new Derived();
    }
}

// Define a delegate that takes an instance of Derived and returns an
// instance of Base.
//
public delegate Base Example(Derived arg);

class Test
{
    public static void Main()
    {
        // The binding flags needed to retrieve MyMethod.
        BindingFlags flags = BindingFlags.Public | BindingFlags.Static;

        // Get a MethodInfo that represents MyMethod.
        MethodInfo minfo = typeof(Derived).GetMethod("MyMethod", flags);

        // Demonstrate contravariance of parameter types and covariance
        // of return types by using the delegate Example to represent
        // MyMethod. The delegate binds to the method because the
        // parameter of the delegate is more restrictive than the 
        // parameter of the method (that is, the delegate accepts an
        // instance of Derived, which can always be safely passed to
        // a parameter of type Base), and the return type of MyMethod
        // is more restrictive than the return type of Example (that
        // is, the method returns an instance of Derived, which can
        // always be safely cast to type Base). 
        //
        Example ex = 
            (Example) Delegate.CreateDelegate(typeof(Example), minfo);

        // Execute MyMethod using the delegate Example.
        //        
        Base b = ex(new Derived());
    }
}
Imports System
Imports System.Reflection

' Define two classes to use in the demonstration, a base class and 
' a class that derives from it.
'
Public Class Base
End Class

Public Class Derived
    Inherits Base

    ' Define a Shared method to use in the demonstration. The method 
    ' takes an instance of Base and returns an instance of Derived.  
    ' For the purposes of the demonstration, it is not necessary for 
    ' the method to do anything useful. 
    '
    Public Shared Function MyMethod(ByVal arg As Base) As Derived
        Dim dummy As Base = arg
        Return New Derived()
    End Function

End Class

' Define a delegate that takes an instance of Derived and returns an
' instance of Base.
'
Public Delegate Function Example(ByVal arg As Derived) As Base

Module Test

    Sub Main()

        ' The binding flags needed to retrieve MyMethod.
        Dim flags As BindingFlags = _
            BindingFlags.Public Or BindingFlags.Static

        ' Get a MethodInfo that represents MyMethod.
        Dim minfo As MethodInfo = _
            GetType(Derived).GetMethod("MyMethod", flags)

        ' Demonstrate contravariance of parameter types and covariance
        ' of return types by using the delegate Example to represent
        ' MyMethod. The delegate binds to the method because the
        ' parameter of the delegate is more restrictive than the 
        ' parameter of the method (that is, the delegate accepts an
        ' instance of Derived, which can always be safely passed to
        ' a parameter of type Base), and the return type of MyMethod
        ' is more restrictive than the return type of Example (that
        ' is, the method returns an instance of Derived, which can
        ' always be safely cast to type Base). 
        '
        Dim ex As Example = CType( _
            [Delegate].CreateDelegate(GetType(Example), minfo), _
            Example _
        )

        ' Execute MyMethod using the delegate Example.
        '        
        Dim b As Base = ex(New Derived())
    End Sub
End Module

Beispiel 3Example 3

Das folgende Codebeispiel zeigt die Methoden, die ein einzelner Delegattyp darstellen kann.The following code example shows all the methods a single delegate type can represent.

Hinweis

Es gibt zwei Überladungen der CreateDelegate Methode, die angeben, firstArgument und ein MethodInfo; ihre Funktionalität ist identisch, außer dass eine Ihnen die ermöglicht Angabe, ob bei Bindungsfehlern ausgelöst werden, und die andere löst immer eine.There are two overloads of the CreateDelegate method that specify firstArgument and a MethodInfo; their functionality is the same except that one allows you to specify whether to throw on failure to bind, and the other always throws. Dieses Codebeispiel verwendet beide Überladungen.This code example uses both overloads.

Im Codebeispiel werden zwei Klassen definiert C und F, und einen Delegattyp D mit einem Argument des Typs C.The code example defines two classes, C and F, and a delegate type D with one argument of type C. Die Klassen übereinstimmende statische und Instanzenmethoden M1, M3, und M4, und die Klasse C verfügt auch über eine Instanzmethode M2 , die keine Argumente verfügt.The classes have matching static and instance methods M1, M3, and M4, and class C also has an instance method M2 that has no arguments.

Eine dritte Klasse namens Example enthält den Code, der den Delegaten erstellt.A third class named Example contains the code that creates the delegates.

  • Delegaten werden erstellt, z. B. Methode M1 des Typs C und F; jede über eine Instanz des jeweiligen Typs geschlossen wird.Delegates are created for instance method M1 of type C and type F; each is closed over an instance of the respective type. Methode M1 des Typs C zeigt die ID Eigenschaften der gebundenen Instanz und des Arguments.Method M1 of type C displays the ID properties of the bound instance and of the argument.

  • Ein Delegat erstellt wird, für die Methode M2 des Typs C.A delegate is created for method M2 of type C. Dies ist eine offene Instanz-Delegaten, in dem das Argument des Delegaten ausgeblendete erste Argument für die Instanzmethode darstellt.This is an open instance delegate, in which the argument of the delegate represents the hidden first argument on the instance method. Die Methode hat keine anderen Argumente.The method has no other arguments.

  • Delegaten werden erstellt, für die statische Methode M3 des Typs C und F; Hierbei handelt es sich um open statische Delegaten.Delegates are created for static method M3 of type C and type F; these are open static delegates.

  • Schließlich werden die Delegaten für die statische Methode erstellt M4 des Typs C und F; jede Methode verfügt über den deklarierenden Typ als erstes Argument und eine Instanz des Typs angegeben wird, damit die Delegaten über dem ersten Argument geschlossen werden .Finally, delegates are created for static method M4 of type C and type F; each method has the declaring type as its first argument, and an instance of the type is supplied, so the delegates are closed over their first arguments. Methode M4 des Typs C zeigt die ID Eigenschaften der gebundenen Instanz und des Arguments.Method M4 of type C displays the ID properties of the bound instance and of the argument.

using System;
using System.Reflection;
using System.Security.Permissions;

// Declare a delegate type. The object of this code example
// is to show all the methods this delegate can bind to.
//
public delegate void D(C c);

// Declare two sample classes, C and F. Class C has an ID
// property so instances can be identified.
//
public class C
{
    private int id;
    public int ID { get { return id; }}
    public C(int id) { this.id = id; }

    public void M1(C c) 
    { 
        Console.WriteLine("Instance method M1(C c) on C:  this.id = {0}, c.ID = {1}",
            this.id, c.ID);
    }
  
    public void M2() 
    { 
        Console.WriteLine("Instance method M2() on C:  this.id = {0}",
            this.id);
    }
  
    public static void M3(C c)
    { 
        Console.WriteLine("Static method M3(C c) on C:  c.ID = {0}", c.ID); 
    }

    public static void M4(C c1, C c2) 
    { 
        Console.WriteLine("Static method M4(C c1, C c2) on C:  c1.ID = {0}, c2.ID = {1}",
            c1.ID, c2.ID);
    }
}

public class F
{
    public void M1(C c) 
    { 
        Console.WriteLine("Instance method M1(C c) on F:  c.ID = {0}",
            c.ID);
    }
  
    public static void M3(C c)
    { 
        Console.WriteLine("Static method M3(C c) on F:  c.ID = {0}", c.ID); 
    }

    public static void M4(F f, C c) 
    { 
        Console.WriteLine("Static method M4(F f, C c) on F:  c.ID = {0}",
            c.ID);
    }
}


public class Example
{
    public static void Main()
    {
        C c1 = new C(42);
        C c2 = new C(1491);
        F f1 = new F();

        D d;

        // Instance method with one argument of type C.
        MethodInfo cmi1 = typeof(C).GetMethod("M1"); 
        // Instance method with no arguments.
        MethodInfo cmi2 = typeof(C).GetMethod("M2"); 
        // Static method with one argument of type C.
        MethodInfo cmi3 = typeof(C).GetMethod("M3"); 
        // Static method with two arguments of type C.
        MethodInfo cmi4 = typeof(C).GetMethod("M4"); 

        // Instance method with one argument of type C.
        MethodInfo fmi1 = typeof(F).GetMethod("M1");
        // Static method with one argument of type C.
        MethodInfo fmi3 = typeof(F).GetMethod("M3"); 
        // Static method with an argument of type F and an argument 
        // of type C.
        MethodInfo fmi4 = typeof(F).GetMethod("M4"); 

        Console.WriteLine("\nAn instance method on any type, with an argument of type C.");
        // D can represent any instance method that exactly matches its
        // signature. Methods on C and F are shown here.
        //
        d = (D) Delegate.CreateDelegate(typeof(D), c1, cmi1);
        d(c2);
        d = (D) Delegate.CreateDelegate(typeof(D), f1, fmi1);
        d(c2);

        Console.WriteLine("\nAn instance method on C with no arguments.");
        // D can represent an instance method on C that has no arguments;
        // in this case, the argument of D represents the hidden first
        // argument of any instance method. The delegate acts like a 
        // static method, and an instance of C must be passed each time
        // it is invoked.
        //
        d = (D) Delegate.CreateDelegate(typeof(D), null, cmi2);
        d(c1);

        Console.WriteLine("\nA static method on any type, with an argument of type C.");
        // D can represent any static method with the same signature.
        // Methods on F and C are shown here.
        //
        d = (D) Delegate.CreateDelegate(typeof(D), null, cmi3);
        d(c1);
        d = (D) Delegate.CreateDelegate(typeof(D), null, fmi3);
        d(c1);

        Console.WriteLine("\nA static method on any type, with an argument of");
        Console.WriteLine("    that type and an argument of type C.");
        // D can represent any static method with one argument of the
        // type the method belongs and a second argument of type C.
        // In this case, the method is closed over the instance of
        // supplied for the its first argument, and acts like an instance
        // method. Methods on F and C are shown here.
        //
        d = (D) Delegate.CreateDelegate(typeof(D), c1, cmi4);
        d(c2);
        Delegate test = 
            Delegate.CreateDelegate(typeof(D), f1, fmi4, false);

        // This final example specifies false for throwOnBindFailure 
        // in the call to CreateDelegate, so the variable 'test'
        // contains Nothing if the method fails to bind (for 
        // example, if fmi4 happened to represent a method of  
        // some class other than F).
        //
        if (test != null)
        {
            d = (D) test;
            d(c2);
        }
    }
}

/* This code example produces the following output:

An instance method on any type, with an argument of type C.
Instance method M1(C c) on C:  this.id = 42, c.ID = 1491
Instance method M1(C c) on F:  c.ID = 1491

An instance method on C with no arguments.
Instance method M2() on C:  this.id = 42

A static method on any type, with an argument of type C.
Static method M3(C c) on C:  c.ID = 42
Static method M3(C c) on F:  c.ID = 42

A static method on any type, with an argument of
    that type and an argument of type C.
Static method M4(C c1, C c2) on C:  c1.ID = 42, c2.ID = 1491
Static method M4(F f, C c) on F:  c.ID = 1491
*/
Imports System
Imports System.Reflection
Imports System.Security.Permissions

' Declare a delegate type. The object of this code example
' is to show all the methods this delegate can bind to.
'
Public Delegate Sub D(ByVal c As C) 

' Declare two sample classes, C and F. Class C has an ID
' property so instances can be identified.
'
Public Class C

    Private _id As Integer

    Public ReadOnly Property ID() As Integer 
        Get
            Return _id
        End Get
    End Property

    Public Sub New(ByVal newId As Integer) 
        Me._id = newId
    End Sub
    
    Public Sub M1(ByVal c As C) 
        Console.WriteLine("Instance method M1(c As C) on C:  this.id = {0}, c.ID = {1}", _
            Me.id, c.ID)
    End Sub
    
    Public Sub M2() 
        Console.WriteLine("Instance method M2() on C:  this.id = {0}", Me.id)
    End Sub
    
    Public Shared Sub M3(ByVal c As C) 
        Console.WriteLine("Shared method M3(c As C) on C:  c.ID = {0}", c.ID)
    End Sub
    
    Public Shared Sub M4(ByVal c1 As C, ByVal c2 As C) 
        Console.WriteLine("Shared method M4(c1 As C, c2 As C) on C:  c1.ID = {0}, c2.ID = {1}", _
            c1.ID, c2.ID)
    End Sub
End Class


Public Class F
    
    Public Sub M1(ByVal c As C) 
        Console.WriteLine("Instance method M1(c As C) on F:  c.ID = {0}", c.ID)
    End Sub
    
    Public Shared Sub M3(ByVal c As C) 
        Console.WriteLine("Shared method M3(c As C) on F:  c.ID = {0}", c.ID)
    End Sub
    
    Public Shared Sub M4(ByVal f As F, ByVal c As C) 
        Console.WriteLine("Shared method M4(f As F, c As C) on F:  c.ID = {0}", c.ID)
    End Sub
End Class

Public Class Example
    
    Public Shared Sub Main() 

        Dim c1 As New C(42)
        Dim c2 As New C(1491)
        Dim f1 As New F()
        
        Dim d As D
        
        ' Instance method with one argument of type C.
        Dim cmi1 As MethodInfo = GetType(C).GetMethod("M1")
        ' Instance method with no arguments.
        Dim cmi2 As MethodInfo = GetType(C).GetMethod("M2")
        ' Shared method with one argument of type C.
        Dim cmi3 As MethodInfo = GetType(C).GetMethod("M3")
        ' Shared method with two arguments of type C.
        Dim cmi4 As MethodInfo = GetType(C).GetMethod("M4")
        
        ' Instance method with one argument of type C.
        Dim fmi1 As MethodInfo = GetType(F).GetMethod("M1")
        ' Shared method with one argument of type C.
        Dim fmi3 As MethodInfo = GetType(F).GetMethod("M3")
        ' Shared method with an argument of type F and an 
        ' argument of type C.
        Dim fmi4 As MethodInfo = GetType(F).GetMethod("M4")
        
        Console.WriteLine(vbLf & "An instance method on any type, with an argument of type C.")
        ' D can represent any instance method that exactly matches its
        ' signature. Methods on C and F are shown here.
        '
        d = CType([Delegate].CreateDelegate(GetType(D), c1, cmi1), D)
        d(c2)
        d = CType([Delegate].CreateDelegate(GetType(D), f1, fmi1), D)
        d(c2)
        
        Console.WriteLine(vbLf & "An instance method on C with no arguments.")
        ' D can represent an instance method on C that has no arguments;
        ' in this case, the argument of D represents the hidden first
        ' argument of any instance method. The delegate acts like a 
        ' Shared method, and an instance of C must be passed each time
        ' it is invoked.
        '
        d = CType([Delegate].CreateDelegate(GetType(D), Nothing, cmi2), D)
        d(c1)
        
        Console.WriteLine(vbLf & "A Shared method on any type, with an argument of type C.")
        ' D can represent any Shared method with the same signature.
        ' Methods on F and C are shown here.
        '
        d = CType([Delegate].CreateDelegate(GetType(D), Nothing, cmi3), D)
        d(c1)
        d = CType([Delegate].CreateDelegate(GetType(D), Nothing, fmi3), D)
        d(c1)
        
        Console.WriteLine(vbLf & "A Shared method on any type, with an argument of")
        Console.WriteLine("    that type and an argument of type C.")
        ' D can represent any Shared method with one argument of the
        ' type the method belongs and a second argument of type C.
        ' In this case, the method is closed over the instance of
        ' supplied for the its first argument, and acts like an instance
        ' method. Methods on F and C are shown here.
        '
        d = CType([Delegate].CreateDelegate(GetType(D), c1, cmi4), D)
        d(c2)
        Dim test As [Delegate] = _
            [Delegate].CreateDelegate(GetType(D), f1, fmi4, false)

        ' This final example specifies False for throwOnBindFailure 
        ' in the call to CreateDelegate, so the variable 'test'
        ' contains Nothing if the method fails to bind (for 
        ' example, if fmi4 happened to represent a method of  
        ' some class other than F).
        '
        If test IsNot Nothing Then
            d = CType(test, D)
            d(c2)
        End If
    
    End Sub
End Class

' This code example produces the following output:
'
'An instance method on any type, with an argument of type C.
'Instance method M1(c As C) on C:  this.id = 42, c.ID = 1491
'Instance method M1(c As C) on F:  c.ID = 1491
'
'An instance method on C with no arguments.
'Instance method M2() on C:  this.id = 42
'
'A Shared method on any type, with an argument of type C.
'Shared method M3(c As C) on C:  c.ID = 42
'Shared method M3(c As C) on F:  c.ID = 42
'
'A Shared method on any type, with an argument of
'    that type and an argument of type C.
'Shared method M4(c1 As C, c2 As C) on C:  c1.ID = 42, c2.ID = 1491
'Shared method M4(f As F, c As C) on F:  c.ID = 1491
'

Hinweise

Diese methodenüberladung und CreateDelegate(Type, Object, MethodInfo) methodenüberladung, die immer bei Bindungsfehlern auslöst, bieten die flexibelste Möglichkeit zum Erstellen von Delegaten.This method overload and the CreateDelegate(Type, Object, MethodInfo) method overload, which always throws on failure to bind, provide the most flexible way to create delegates. Sie können sie zum Erstellen von Delegaten für statische oder Instanzmethoden zur Verfügung, mit oder ohne ein erstes Argument verwenden.You can use them to create delegates for either static or instance methods, with or without a first argument.

Hinweis

Wenn Sie ein erstes Argument nicht angeben, verwenden Sie die CreateDelegate(Type, MethodInfo, Boolean) methodenüberladung für eine bessere Leistung.If you do not supply a first argument, use the CreateDelegate(Type, MethodInfo, Boolean) method overload for better performance.

Der Delegattyp und die Methode müssen kompatible Rückgabetypen haben.The delegate type and the method must have compatible return types. D. h. der Rückgabetyp der method muss der Rückgabetyp der zugewiesen werden können type.That is, the return type of method must be assignable to the return type of type.

Wenn firstArgument wird angegeben, wird es an übergeben method jedes Mal, wenn der Delegat aufgerufen wird; firstArgument hört sich an den Delegaten gebunden werden und der Delegat wird gesagt, über das erste Argument geschlossen ist.If firstArgument is supplied, it is passed to method every time the delegate is invoked; firstArgument is said to be bound to the delegate, and the delegate is said to be closed over its first argument. Wenn method ist static (Shared in Visual Basic), wird das Argument bereitgestellte beim Aufrufen des Delegaten Liste schließt alle Parameter außer dem ersten; aus, wenn method ist eine Instanzmethode firstArgument an der ausgeblendeten Instanz übergeben wird Parameter (dargestellt durch this in c# oder durch Me in Visual Basic).If method is static (Shared in Visual Basic), the argument list supplied when invoking the delegate includes all parameters except the first; if method is an instance method, then firstArgument is passed to the hidden instance parameter (represented by this in C#, or by Me in Visual Basic).

Wenn firstArgument angegeben wird, der erste Parameter der method muss ein Verweistyp sein und firstArgument mit diesem Typ kompatibel sein muss.If firstArgument is supplied, the first parameter of method must be a reference type, and firstArgument must be compatible with that type.

Wichtig

Wenn method ist static (Shared in Visual Basic) und der erste Parameter ist vom Typ Object oder ValueType, klicken Sie dann firstArgument kann ein Werttyp sein.If method is static (Shared in Visual Basic) and its first parameter is of type Object or ValueType, then firstArgument can be a value type. In diesem Fall firstArgument automatisch eingeschlossen.In this case firstArgument is automatically boxed. Automatische Boxing erfolgt nicht für alle anderen Argumente, wie es in einer C#- oder Visual Basic-Funktion aufrufen würden.Automatic boxing does not occur for any other arguments, as it would in a C# or Visual Basic function call.

Wenn firstArgument ist ein null-Verweis und method eine Instanzmethode ist das Ergebnis hängt von den Signaturen der Typ des Delegaten type und method:If firstArgument is a null reference and method is an instance method, the result depends on the signatures of the delegate type type and of method:

  • Wenn die Signatur der type schließt explizit die ersten verborgenen Parameter von method, der Delegaten gesagt, dass eine offene Instanzmethode darstellt.If the signature of type explicitly includes the hidden first parameter of method, the delegate is said to represent an open instance method. Wenn der Delegat aufgerufen wird, wird das erste Argument in der Liste der Argumente an den ausgeblendeten Instanz-Parameter übergeben method.When the delegate is invoked, the first argument in the argument list is passed to the hidden instance parameter of method.

  • Wenn die Signaturen der method und type übereinstimmen (d. h. alle Parametertypen sind kompatibel), und klicken Sie dann der Delegaten gesagt, dass er über einen null-Verweis geschlossen werden.If the signatures of method and type match (that is, all parameter types are compatible), then the delegate is said to be closed over a null reference. Aufrufen des Delegaten entspricht dem Aufrufen einer Instanzmethode auf eine null-Instanz, die nicht besonders nützlich, etwas zu tun ist.Invoking the delegate is like calling an instance method on a null instance, which is not a particularly useful thing to do.

Wenn firstArgument ist ein null-Verweis und method ist statisch und das Ergebnis hängt von den Signaturen des Delegattyps type und method:If firstArgument is a null reference and method is static, the result depends on the signatures of the delegate type type and of method:

  • Wenn die Signatur der method und type übereinstimmen (d. h. alle Parametertypen sind kompatibel), der Delegaten gesagt, dass eine offene statische Methode darstellt.If the signature of method and type match (that is, all parameter types are compatible), the delegate is said to represent an open static method. Dies ist der häufigste Fall für statische Methoden.This is the most common case for static methods. In diesem Fall erhalten Sie eine etwas bessere Leistung mithilfe der CreateDelegate(Type, MethodInfo, Boolean) -methodenüberladung.In this case, you can get slightly better performance by using the CreateDelegate(Type, MethodInfo, Boolean) method overload.

  • Wenn die Signatur der type beginnt mit dem zweiten Parameter der method der Rest der Parametertypen kompatibel sind, und die Delegaten gesagt, dass Sie über ein null-Verweis geschlossen werden.If the signature of type begins with the second parameter of method and the rest of the parameter types are compatible, then the delegate is said to be closed over a null reference. Wenn der Delegat aufgerufen wird, wird ein null-Verweis auf den ersten Parameter übergeben method.When the delegate is invoked, a null reference is passed to the first parameter of method.

Hinweis

Beginnend mit der .NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1, diese Methode kann verwendet werden, um nicht öffentliche Methoden zugreifen, wenn der Aufrufer erteilt wurde ReflectionPermission mit der ReflectionPermissionFlag.RestrictedMemberAccess kennzeichnen und Menge oder eine Teilmenge der Berechtigungssatz die nicht öffentliche Methoden an des Aufrufers des beschränkt ist zu gewähren davon.Starting with the .NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1, this method can be used to access non-public methods if the caller has been granted ReflectionPermission with the ReflectionPermissionFlag.RestrictedMemberAccess flag and if the grant set of the non-public methods is restricted to the caller's grant set, or a subset thereof. (Finden Sie unter Überlegungen zur Sicherheit für die Reflektion.)(See Security Considerations for Reflection.)

Zur Verwendung dieser Funktionen sollte die Anwendung für .NET Framework 3,5.NET Framework 3.5 oder höher ausgelegt sein. To use this functionality, your application should target the .NET Framework 3,5.NET Framework 3.5 or later.

Kompatible Parameter und RückgabetypenCompatible Parameter Types and Return Type

Die Parameter und Rückgabetypen eines Delegaten müssen mit den Parametertypen und den Rückgabetyp der Methode, die den Delegaten dargestellt kompatibel sein. die Typen müssen nicht genau übereinstimmen.The parameter types and return type of a delegate must be compatible with the parameter types and return type of the method the delegate represents; the types do not have to match exactly.

Hinweis

In .NET Framework, Version 1.0 und 1.1 müssen die Typen exakt übereinstimmen.In the .NET Framework version 1.0 and 1.1 the types must match exactly.

Ein Parameter eines Delegaten ist mit dem entsprechenden Parameter einer Methode kompatibel, wenn der Typ des Delegatenparameters restriktiver ist als der Methodenparameter, da so gewährleistet ist, dass ein an den Delegaten übergebenes Argument problemlos an die Methode weitergeleitet werden kann.A parameter of a delegate is compatible with the corresponding parameter of a method if the type of the delegate parameter is more restrictive than the type of the method parameter, because this guarantees that an argument passed to the delegate can be passed safely to the method.

Ebenso ist der Rückgabetyp eines Delegaten kompatibel mit dem Rückgabetyp einer Methode, wenn der Rückgabetyp der Methode restriktiver ist als der Rückgabetyp des Delegaten, da so gewährleistet ist, dass der Rückgabewert der Methode problemlos in den Rückgabetyp des Delegaten umgewandelt werden kann.Similarly, the return type of a delegate is compatible with the return type of a method if the return type of the method is more restrictive than the return type of the delegate, because this guarantees that the return value of the method can be cast safely to the return type of the delegate.

Angenommen, ein Delegat mit einem Parameter vom Typ Hashtable und dem Rückgabetyp der Object kann eine Methode mit einem Parameter des Typs darstellen Object sowie einen Rückgabewert vom Typ Hashtable.For example, a delegate with a parameter of type Hashtable and a return type of Object can represent a method with a parameter of type Object and a return value of type Hashtable.

Bestimmen die Methoden kann ein Delegat darstellen.Determining the Methods a Delegate Can Represent

Eine weitere nützliche Methode, die Flexibilität, die von dieser Überladung der bereitgestellten betrachten CreateDelegate besteht darin, dass jeder angegebene Delegat vier verschiedene Kombinationen der Methodensignatur und Methodenart (statisch oder Instanz) darstellen kann.Another useful way to think of the flexibility provided by this overload of CreateDelegate is that any given delegate can represent four different combinations of method signature and method kind (static versus instance). Betrachten Sie einen Delegattyp D mit einem Argument des Typs C.Consider a delegate type D with one argument of type C. Im folgenden wird beschrieben, die Methoden D darstellen kann, wird den Rückgabetyp wird ignoriert, da es in allen Fällen entsprechen muss:The following describes the methods D can represent, ignoring the return type since it must match in all cases:

  • D kann Instanzmethode, die genau ein Argument des Typs darstellen C, unabhängig davon, welchen Typ die Instanzmethode gehört.D can represent any instance method that has exactly one argument of type C, regardless of what type the instance method belongs to. Wenn CreateDelegate aufgerufen wird, firstArgument ist eine Instanz des Typs method angehört, und der resultierende Delegat wird gesagt, über diese Instanz geschlossen werden.When CreateDelegate is called, firstArgument is an instance of the type method belongs to, and the resulting delegate is said to be closed over that instance. (Im Grunde D kann auch über ein null-Verweis geschlossen werden, wenn firstArgument ist null.)(Trivially, D can also be closed over a null reference if firstArgument is null.)

  • D kann eine Instanzmethode darstellen C , die keine Argumente verfügt.D can represent an instance method of C that has no arguments. Wenn CreateDelegate aufgerufen wird, firstArgument ist ein null-Verweis.When CreateDelegate is called, firstArgument is a null reference. Der resultierende Delegat stellt eine offene Instanz-Methode und eine Instanz von C müssen angegeben werden, bei jedem Aufruf erfolgte.The resulting delegate represents an open instance method, and an instance of C must be supplied each time it is invoked.

  • D kann eine statische Methode, die ein des Typs Argument darstellen C, und dass die Methode in einen beliebigen Typ angehören kann.D can represent a static method that takes one argument of type C, and that method can belong to any type. Wenn CreateDelegate aufgerufen wird, firstArgument ist ein null-Verweis.When CreateDelegate is called, firstArgument is a null reference. Der resultierende Delegat stellt eine offene statische Methode und einer Instanz von C müssen angegeben werden, bei jedem Aufruf erfolgte.The resulting delegate represents an open static method, and an instance of C must be supplied each time it is invoked.

  • D können eine statische Methode darstellen, die zum Typ gehört F und verfügt über zwei Argumente des Typs F und C.D can represent a static method that belongs to type F and has two arguments, of type F and type C. Wenn CreateDelegate aufgerufen wird, firstArgument ist eine Instanz der F.When CreateDelegate is called, firstArgument is an instance of F. Der resultierende Delegat stellt eine statische Methode, die über diese Instanz geschlossen ist F.The resulting delegate represents a static method that is closed over that instance of F. Beachten Sie, dass im Fall, in denen F und C denselben Typ aufweisen, die statische Methode verfügt über zwei Argumente des Typs.Note that in the case where F and C are the same type, the static method has two arguments of that type. (In diesem Fall D wird über einen null-Verweis geschlossen, wenn firstArgument ist null.)(In this case, D is closed over a null reference if firstArgument is null.)

Sicherheit

ReflectionPermission
Beim Aufruf spät gebundene durch Mechanismen wie z. B. InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[]).when invoked late-bound through mechanisms such as InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[]). Zugeordnete Enumeration: MemberAccessAssociated enumeration: MemberAccess.

Siehe auch

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

Erstellt einen Delegaten vom angegebenen Typ, der die angegebene Instanzenmethode darstellt, die für die angegebene Klasseninstanz aufgerufen werden soll, wobei die Groß- und Kleinschreibung und das Verhalten bei Bindungsfehlern den Angaben entsprechend berücksichtigt bzw. nicht berücksichtigt wird.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.

public:
 static Delegate ^ CreateDelegate(Type ^ type, System::Object ^ target, System::String ^ method, bool ignoreCase, bool throwOnBindFailure);
public static Delegate CreateDelegate (Type type, object target, string method, bool ignoreCase, bool throwOnBindFailure);
static member CreateDelegate : Type * obj * string * bool * bool -> Delegate

Parameter

type
Type Type Type

Der Type des zu erstellenden Delegaten.The Type of delegate to create.

target
Object Object Object

Die Klasseninstanz, für die method aufgerufen wird.The class instance on which method is invoked.

method
String String String

Der Name der Instanzenmethode, die durch den Delegaten dargestellt werden soll.The name of the instance method that the delegate is to represent.

ignoreCase
Boolean Boolean Boolean

Ein boolescher Wert, der angibt, ob die Groß- und Kleinschreibung beim Vergleichen des Methodennamens berücksichtigt werden soll.A Boolean indicating whether to ignore the case when comparing the name of the method.

throwOnBindFailure
Boolean Boolean Boolean

true, um eine Ausnahme auszulösen, wenn method nicht gebunden werden kann, andernfalls false.true to throw an exception if method cannot be bound; otherwise, false.

Gibt zurück

Ein Delegat vom angegebenen Typ, der die angegebene Instanzenmethode darstellt, die für die angegebene Klasseninstanz aufgerufen werden soll.A delegate of the specified type that represents the specified instance method to invoke on the specified class instance.

Ausnahmen

type ist null.type is null.

- oder - -or- target ist null.target is null.

- oder - -or- method ist null.method is null.

type erbt nicht MulticastDelegate.type does not inherit MulticastDelegate.

- oder --or- type ist keine RuntimeType.type is not a RuntimeType. Siehe Laufzeittypen in Reflektion.See Runtime Types in Reflection.

- oder --or- method ist keine Instanzenmethode.method is not an instance method.

- oder --or- method kann nicht gebunden werden, z. B. weil sie nicht gefunden wurde, und throwOnBindFailure ist gleich true.method cannot be bound, for example because it cannot be found, and throwOnBindFailure is true.

Die Invoke-Methode von type wurde nicht gefunden.The Invoke method of type is not found.

Der Aufrufer verfügt nicht über die erforderlichen Berechtigungen für den Zugriff auf method.The caller does not have the permissions necessary to access method.

Hinweise

Diese Methode erstellt nur Delegaten für die Instanz.This method creates delegates for instance methods only. Eine Instanzmethode handelt es sich um eine Methode, die eine Instanz einer Klasse zugeordnet ist; eine statische Methode handelt es sich um eine Methode, die die Klasse selbst zugeordnet ist.An instance method is a method that is associated with an instance of a class; a static method is a method that is associated with the class itself.

Hinweis

Beginnend mit der .NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1, diese Methode kann verwendet werden, um nicht öffentliche Methoden zugreifen, wenn der Aufrufer erteilt wurde ReflectionPermission mit der ReflectionPermissionFlag.RestrictedMemberAccess kennzeichnen und Menge oder eine Teilmenge der Berechtigungssatz die nicht öffentliche Methoden an des Aufrufers des beschränkt ist zu gewähren davon.Starting with the .NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1, this method can be used to access non-public methods if the caller has been granted ReflectionPermission with the ReflectionPermissionFlag.RestrictedMemberAccess flag and if the grant set of the non-public methods is restricted to the caller's grant set, or a subset thereof. (Finden Sie unter Überlegungen zur Sicherheit für die Reflektion.)(See Security Considerations for Reflection.)

Zur Verwendung dieser Funktionen sollte die Anwendung für .NET Framework 3,5.NET Framework 3.5 oder höher ausgelegt sein. To use this functionality, your application should target the .NET Framework 3,5.NET Framework 3.5 or later.

Sicherheit

ReflectionPermission
Beim Aufruf spät gebundene durch Mechanismen wie z. B. InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[]).when invoked late-bound through mechanisms such as InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[]). Zugeordnete Enumeration: MemberAccessAssociated enumeration: MemberAccess.

Siehe auch

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

Erstellt einen Delegaten vom angegeben Typ zum Darstellen der angegebenen statischen Methode mit dem angegebenen Verhalten bei Bindungsfehlern.Creates a delegate of the specified type to represent the specified static method, with the specified behavior on failure to bind.

public:
 static Delegate ^ CreateDelegate(Type ^ type, System::Reflection::MethodInfo ^ method, bool throwOnBindFailure);
public static Delegate CreateDelegate (Type type, System.Reflection.MethodInfo method, bool throwOnBindFailure);
static member CreateDelegate : Type * System.Reflection.MethodInfo * bool -> Delegate

Parameter

type
Type Type Type

Der Type des zu erstellenden Delegaten.The Type of delegate to create.

method
MethodInfo MethodInfo MethodInfo

Die MethodInfo, die die statische Methode oder Instanzmethode beschreibt, die der Delegat darstellen soll.The MethodInfo describing the static or instance method the delegate is to represent.

throwOnBindFailure
Boolean Boolean Boolean

true, um eine Ausnahme auszulösen, wenn method nicht gebunden werden kann, andernfalls false.true to throw an exception if method cannot be bound; otherwise, false.

Gibt zurück

Ein Delegat vom angegebenen Typ, der die angegebene statische Methode darstellen soll.A delegate of the specified type to represent the specified static method.

Ausnahmen

type ist null.type is null.

- oder - -or- method ist null.method is null.

type erbt nicht MulticastDelegate.type does not inherit MulticastDelegate.

- oder --or- type ist keine RuntimeType.type is not a RuntimeType. Siehe Laufzeittypen in Reflektion.See Runtime Types in Reflection.

- oder --or- method kann nicht gebunden werden, und throwOnBindFailure ist true.method cannot be bound, and throwOnBindFailure is true.

- oder --or- method ist keine RuntimeMethodInfo.method is not a RuntimeMethodInfo. Siehe Laufzeittypen in Reflektion.See Runtime Types in Reflection.

Die Invoke-Methode von type wurde nicht gefunden.The Invoke method of type is not found.

Der Aufrufer verfügt nicht über die erforderlichen Berechtigungen für den Zugriff auf method.The caller does not have the permissions necessary to access method.

Beispiele

Dieser Abschnitt enthält zwei Codebeispiele.This section contains two code examples. Das erste Beispiel veranschaulicht die beiden Arten von Delegaten, die Überladung dieser Methode erstellt werden können: Öffnen Sie über eine Instanzmethode und über eine statische Methode.The first example demonstrates the two kinds of delegates that can be created with this method overload: open over an instance method and open over a static method.

Im zweiten Codebeispiel wird veranschaulicht, kompatible Parametertypen und Rückgabetypen.The second code example demonstrates compatible parameter types and return types.

Beispiel 1Example 1

Im folgenden Codebeispiel wird veranschaulicht, die zwei Möglichkeiten, die ein Delegat erstellt werden kann, verwenden diese Überladung von der CreateDelegate Methode.The following code example demonstrates the two ways a delegate can be created using this overload of the CreateDelegate method.

Hinweis

Es gibt zwei Überladungen der der CreateDelegate Methode, die angeben, ein MethodInfo jedoch kein erstes Argument; ihre Funktionalität ist identisch, außer dass eine Ihnen die ermöglicht Angabe, ob bei Bindungsfehlern ausgelöst werden, und die andere löst immer eine.There are two overloads of the CreateDelegate method that specify a MethodInfo but not a first argument; their functionality is the same except that one allows you to specify whether to throw on failure to bind, and the other always throws. Dieses Codebeispiel verwendet beide Überladungen.This code example uses both overloads.

Das Beispiel deklariert eine Klasse C mit einer statischen Methode M2 und eine Instanzmethode M1, und zwei Delegattypen: D1 akzeptiert eine Instanz von C und eine Zeichenfolge, und D2 nimmt eine Zeichenfolge.The example declares a class C with a static method M2 and an instance method M1, and two delegate types: D1 takes an instance of C and a string, and D2 takes a string.

Eine zweite Klasse namens Example enthält den Code, der den Delegaten erstellt.A second class named Example contains the code that creates the delegates.

  • Ein Delegat vom Typ D1, der eine offene Instanzmethode darstellt, wird für die Instanzmethode erstellt M1.A delegate of type D1, representing an open instance method, is created for the instance method M1. Eine Instanz muss übergeben werden, wenn der Delegat aufgerufen wird.An instance must be passed when the delegate is invoked.

  • Ein Delegat vom Typ D2, eine offene statische Methode darstellt, wird für die statische Methode erstellt M2.A delegate of type D2, representing an open static method, is created for the static method M2.

using System;
using System.Reflection;
using System.Security.Permissions;

// Declare three delegate types for demonstrating the combinations
// of static versus instance methods and open versus closed
// delegates.
//
public delegate void D1(C c, string s);
public delegate void D2(string s);
public delegate void D3();

// A sample class with an instance method and a static method.
//
public class C
{
    private int id;
    public C(int id) { this.id = id; }

    public void M1(string s) 
    { 
        Console.WriteLine("Instance method M1 on C:  id = {0}, s = {1}",
            this.id, s);
    }
  
    public static void M2(string s)
    { 
        Console.WriteLine("Static method M2 on C:  s = {0}", s); 
    }
}

public class Example
{
    public static void Main()
    {
        C c1 = new C(42);

        // Get a MethodInfo for each method.
        //
        MethodInfo mi1 = typeof(C).GetMethod("M1", 
            BindingFlags.Public | BindingFlags.Instance);
        MethodInfo mi2 = typeof(C).GetMethod("M2",
            BindingFlags.Public | BindingFlags.Static);

        D1 d1;
        D2 d2;
        D3 d3;


        Console.WriteLine("\nAn instance method closed over C.");
        // In this case, the delegate and the
        // method must have the same list of argument types; use
        // delegate type D2 with instance method M1.
        //
        Delegate test = 
            Delegate.CreateDelegate(typeof(D2), c1, mi1, false);

        // Because false was specified for throwOnBindFailure 
        // in the call to CreateDelegate, the variable 'test'
        // contains null if the method fails to bind (for 
        // example, if mi1 happened to represent a method of  
        // some class other than C).
        //
        if (test != null)
        {
            d2 = (D2) test;

            // The same instance of C is used every time the 
            // delegate is invoked.
            d2("Hello, World!");
            d2("Hi, Mom!");
        }


        Console.WriteLine("\nAn open instance method.");
        // In this case, the delegate has one more 
        // argument than the instance method; this argument comes
        // at the beginning, and represents the hidden instance
        // argument of the instance method. Use delegate type D1
        // with instance method M1.
        //
        d1 = (D1) Delegate.CreateDelegate(typeof(D1), null, mi1);

        // An instance of C must be passed in each time the 
        // delegate is invoked.
        //
        d1(c1, "Hello, World!");
        d1(new C(5280), "Hi, Mom!");


        Console.WriteLine("\nAn open static method.");
        // In this case, the delegate and the method must 
        // have the same list of argument types; use delegate type
        // D2 with static method M2.
        //
        d2 = (D2) Delegate.CreateDelegate(typeof(D2), null, mi2);

        // No instances of C are involved, because this is a static
        // method. 
        //
        d2("Hello, World!");
        d2("Hi, Mom!");


        Console.WriteLine("\nA static method closed over the first argument (String).");
        // The delegate must omit the first argument of the method.
        // A string is passed as the firstArgument parameter, and 
        // the delegate is bound to this string. Use delegate type 
        // D3 with static method M2. 
        //
        d3 = (D3) Delegate.CreateDelegate(typeof(D3), 
            "Hello, World!", mi2);

        // Each time the delegate is invoked, the same string is
        // used.
        d3();
    }
}

/* This code example produces the following output:

An instance method closed over C.
Instance method M1 on C:  id = 42, s = Hello, World!
Instance method M1 on C:  id = 42, s = Hi, Mom!

An open instance method.
Instance method M1 on C:  id = 42, s = Hello, World!
Instance method M1 on C:  id = 5280, s = Hi, Mom!

An open static method.
Static method M2 on C:  s = Hello, World!
Static method M2 on C:  s = Hi, Mom!

A static method closed over the first argument (String).
Static method M2 on C:  s = Hello, World!
 */
Imports System
Imports System.Reflection
Imports System.Security.Permissions

' Declare three delegate types for demonstrating the combinations
' of Shared versus instance methods and open versus closed
' delegates.
'
Public Delegate Sub D1(ByVal c As C, ByVal s As String) 
Public Delegate Sub D2(ByVal s As String) 
Public Delegate Sub D3() 

' A sample class with an instance method and a Shared method.
'
Public Class C
    Private id As Integer
    Public Sub New(ByVal id As Integer) 
        Me.id = id
    End Sub 'New

    Public Sub M1(ByVal s As String) 
        Console.WriteLine("Instance method M1 on C:  id = {0}, s = {1}", _
            Me.id, s)
    End Sub
    
    Public Shared Sub M2(ByVal s As String) 
        Console.WriteLine("Shared method M2 on C:  s = {0}", s)
    End Sub
End Class

Public Class Example
    
    Public Shared Sub Main() 

        Dim c1 As New C(42)
        
        ' Get a MethodInfo for each method.
        '
        Dim mi1 As MethodInfo = GetType(C).GetMethod("M1", _
            BindingFlags.Public Or BindingFlags.Instance)
        Dim mi2 As MethodInfo = GetType(C).GetMethod("M2", _
            BindingFlags.Public Or BindingFlags.Static)
        
        Dim d1 As D1
        Dim d2 As D2
        Dim d3 As D3
        
        
        Console.WriteLine(vbLf & "An instance method closed over C.")
        ' In this case, the delegate and the
        ' method must have the same list of argument types; use
        ' delegate type D2 with instance method M1.
        '
        Dim test As [Delegate] = _
            [Delegate].CreateDelegate(GetType(D2), c1, mi1, False)

        ' Because False was specified for throwOnBindFailure 
        ' in the call to CreateDelegate, the variable 'test'
        ' contains Nothing if the method fails to bind (for 
        ' example, if mi1 happened to represent a method of 
        ' some class other than C).
        '
        If test IsNot Nothing Then
            d2 = CType(test, D2)

            ' The same instance of C is used every time the
            ' delegate is invoked.
            d2("Hello, World!")
            d2("Hi, Mom!")
        End If
        
        
        Console.WriteLine(vbLf & "An open instance method.")
        ' In this case, the delegate has one more 
        ' argument than the instance method; this argument comes
        ' at the beginning, and represents the hidden instance
        ' argument of the instance method. Use delegate type D1
        ' with instance method M1.
        '
        d1 = CType([Delegate].CreateDelegate(GetType(D1), Nothing, mi1), D1)
        
        ' An instance of C must be passed in each time the 
        ' delegate is invoked.
        '
        d1(c1, "Hello, World!")
        d1(New C(5280), "Hi, Mom!")
        
        
        Console.WriteLine(vbLf & "An open Shared method.")
        ' In this case, the delegate and the method must 
        ' have the same list of argument types; use delegate type
        ' D2 with Shared method M2.
        '
        d2 = CType([Delegate].CreateDelegate(GetType(D2), Nothing, mi2), D2)
        
        ' No instances of C are involved, because this is a Shared
        ' method. 
        '
        d2("Hello, World!")
        d2("Hi, Mom!")
        
        
        Console.WriteLine(vbLf & "A Shared method closed over the first argument (String).")
        ' The delegate must omit the first argument of the method.
        ' A string is passed as the firstArgument parameter, and 
        ' the delegate is bound to this string. Use delegate type 
        ' D3 with Shared method M2. 
        '
        d3 = CType([Delegate].CreateDelegate(GetType(D3), "Hello, World!", mi2), D3)
        
        ' Each time the delegate is invoked, the same string is
        ' used.
        d3()
    
    End Sub
End Class

' This code example produces the following output:
'
'An instance method closed over C.
'Instance method M1 on C:  id = 42, s = Hello, World!
'Instance method M1 on C:  id = 42, s = Hi, Mom!
'
'An open instance method.
'Instance method M1 on C:  id = 42, s = Hello, World!
'Instance method M1 on C:  id = 5280, s = Hi, Mom!
'
'An open Shared method.
'Shared method M2 on C:  s = Hello, World!
'Shared method M2 on C:  s = Hi, Mom!
'
'A Shared method closed over the first argument (String).
'Shared method M2 on C:  s = Hello, World!
' 

Beispiel 2Example 2

Im folgenden Codebeispiel wird veranschaulicht, die Kompatibilität der Parametertypen und Rückgabetypen.The following code example demonstrates compatibility of parameter types and return types.

Hinweis

Dieses Codebeispiel verwendet die CreateDelegate(Type, MethodInfo) -methodenüberladung.This code example uses the CreateDelegate(Type, MethodInfo) method overload. Die Verwendung der anderen Überladungen dieser MethodInfo ist ähnlich.The use of other overloads that take MethodInfo is similar.

Das Codebeispiel definiert eine Basisklasse, die mit dem Namen Base und eine Klasse namens Derived abgeleitet, die Base.The code example defines a base class named Base and a class named Derived that derives from Base. Die abgeleitete Klasse verfügt über eine static (Shared in Visual Basic) Methode, die mit dem Namen MyMethod mit einem Parameter vom Typ Base und dem Rückgabetyp der Derived.The derived class has a static (Shared in Visual Basic) method named MyMethod with one parameter of type Base and a return type of Derived. Im Codebeispiel wird definiert auch einen Delegaten, der mit dem Namen Example , die einen Parameter vom Typ hat Derived und dem Rückgabetyp der Base.The code example also defines a delegate named Example that has one parameter of type Derived and a return type of Base.

Im Codebeispiel wird veranschaulicht, dass der Delegat, mit dem Namen Example können verwendet werden, um die Methode darstellen MyMethod.The code example demonstrates that the delegate named Example can be used to represent the method MyMethod. Die Methode kann an den Delegaten gebunden werden, da:The method can be bound to the delegate because:

  • Der Parametertyp des Delegaten (Derived) ist stärker eingeschränkt als der Parametertyp des MyMethod (Base), sodass es immer sicher an das Argument des Delegaten zu übergeben sind MyMethod.The parameter type of the delegate (Derived) is more restrictive than the parameter type of MyMethod (Base), so that it is always safe to pass the argument of the delegate to MyMethod.

  • Der Rückgabetyp der MyMethod (Derived) ist stärker eingeschränkt als der Parametertyp des Delegaten (Base), sodass sie immer sicher, das den Rückgabetyp der Methode, die den Rückgabetyp des Delegaten umgewandelt werden kann.The return type of MyMethod (Derived) is more restrictive than the parameter type of the delegate (Base), so that it is always safe to cast the return type of the method to the return type of the delegate.

Im Codebeispiel erzeugt keine Ausgabe.The code example produces no output.

using namespace System;
using namespace System::Reflection;

// Define two classes to use in the demonstration, a base class and 
// a class that derives from it.
//
public ref class Base {};

public ref class Derived : Base
{
    // Define a static method to use in the demonstration. The method 
    // takes an instance of Base and returns an instance of Derived.  
    // For the purposes of the demonstration, it is not necessary for 
    // the method to do anything useful. 
    //
public:
    static Derived^ MyMethod(Base^ arg)
    {
        Base^ dummy = arg;
        return gcnew Derived();
    }
};

// Define a delegate that takes an instance of Derived and returns an
// instance of Base.
//
public delegate Base^ Example(Derived^ arg);

void main()
{
    // The binding flags needed to retrieve MyMethod.
    BindingFlags flags = BindingFlags::Public | BindingFlags::Static;

    // Get a MethodInfo that represents MyMethod.
    MethodInfo^ minfo = Derived::typeid->GetMethod("MyMethod", flags);

    // Demonstrate contravariance of parameter types and covariance
    // of return types by using the delegate Example to represent
    // MyMethod. The delegate binds to the method because the
    // parameter of the delegate is more restrictive than the 
    // parameter of the method (that is, the delegate accepts an
    // instance of Derived, which can always be safely passed to
    // a parameter of type Base), and the return type of MyMethod
    // is more restrictive than the return type of Example (that
    // is, the method returns an instance of Derived, which can
    // always be safely cast to type Base). 
    //
    Example^ ex = 
        (Example^) Delegate::CreateDelegate(Example::typeid, minfo);

    // Execute MyMethod using the delegate Example.
    //        
    Base^ b = ex(gcnew Derived());
}
using System;
using System.Reflection;

// Define two classes to use in the demonstration, a base class and 
// a class that derives from it.
//
public class Base {}

public class Derived : Base
{
    // Define a static method to use in the demonstration. The method 
    // takes an instance of Base and returns an instance of Derived.  
    // For the purposes of the demonstration, it is not necessary for 
    // the method to do anything useful. 
    //
    public static Derived MyMethod(Base arg)
    {
        Base dummy = arg;
        return new Derived();
    }
}

// Define a delegate that takes an instance of Derived and returns an
// instance of Base.
//
public delegate Base Example(Derived arg);

class Test
{
    public static void Main()
    {
        // The binding flags needed to retrieve MyMethod.
        BindingFlags flags = BindingFlags.Public | BindingFlags.Static;

        // Get a MethodInfo that represents MyMethod.
        MethodInfo minfo = typeof(Derived).GetMethod("MyMethod", flags);

        // Demonstrate contravariance of parameter types and covariance
        // of return types by using the delegate Example to represent
        // MyMethod. The delegate binds to the method because the
        // parameter of the delegate is more restrictive than the 
        // parameter of the method (that is, the delegate accepts an
        // instance of Derived, which can always be safely passed to
        // a parameter of type Base), and the return type of MyMethod
        // is more restrictive than the return type of Example (that
        // is, the method returns an instance of Derived, which can
        // always be safely cast to type Base). 
        //
        Example ex = 
            (Example) Delegate.CreateDelegate(typeof(Example), minfo);

        // Execute MyMethod using the delegate Example.
        //        
        Base b = ex(new Derived());
    }
}
Imports System
Imports System.Reflection

' Define two classes to use in the demonstration, a base class and 
' a class that derives from it.
'
Public Class Base
End Class

Public Class Derived
    Inherits Base

    ' Define a Shared method to use in the demonstration. The method 
    ' takes an instance of Base and returns an instance of Derived.  
    ' For the purposes of the demonstration, it is not necessary for 
    ' the method to do anything useful. 
    '
    Public Shared Function MyMethod(ByVal arg As Base) As Derived
        Dim dummy As Base = arg
        Return New Derived()
    End Function

End Class

' Define a delegate that takes an instance of Derived and returns an
' instance of Base.
'
Public Delegate Function Example(ByVal arg As Derived) As Base

Module Test

    Sub Main()

        ' The binding flags needed to retrieve MyMethod.
        Dim flags As BindingFlags = _
            BindingFlags.Public Or BindingFlags.Static

        ' Get a MethodInfo that represents MyMethod.
        Dim minfo As MethodInfo = _
            GetType(Derived).GetMethod("MyMethod", flags)

        ' Demonstrate contravariance of parameter types and covariance
        ' of return types by using the delegate Example to represent
        ' MyMethod. The delegate binds to the method because the
        ' parameter of the delegate is more restrictive than the 
        ' parameter of the method (that is, the delegate accepts an
        ' instance of Derived, which can always be safely passed to
        ' a parameter of type Base), and the return type of MyMethod
        ' is more restrictive than the return type of Example (that
        ' is, the method returns an instance of Derived, which can
        ' always be safely cast to type Base). 
        '
        Dim ex As Example = CType( _
            [Delegate].CreateDelegate(GetType(Example), minfo), _
            Example _
        )

        ' Execute MyMethod using the delegate Example.
        '        
        Dim b As Base = ex(New Derived())
    End Sub
End Module

Hinweise

Überladung dieser Methode kann offene statische methodendelegaten erstellen und öffnen die Instanz-Methode-Delegaten – d. h., Delegaten, die das ausgeblendete erste Argument von Instanzmethoden verfügbar zu machen.This method overload can create open static method delegates and open instance method delegates - that is, delegates that expose the hidden first argument of instance methods. Eine ausführlichere Erklärung finden Sie unter die allgemeinere CreateDelegate(Type, Object, MethodInfo, Boolean) methodenüberladung, die Ihnen ermöglicht, z. B. alle Kombinationen von offenen oder geschlossenen Delegaten zu erstellen oder statische Methoden.For a detailed explanation, see the more general CreateDelegate(Type, Object, MethodInfo, Boolean) method overload, which allows you to create all combinations of open or closed delegates for instance or static methods.

Hinweis

Überladung dieser Methode sollte verwendet werden, wenn der Delegat nicht über die ersten Arguments, geschlossen wird, da er in diesem Fall etwas schneller ist.This method overload should be used when the delegate is not closed over its first argument, because it is somewhat faster in that case.

Hinweis

Beginnend mit der .NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1, diese Methode kann verwendet werden, um nicht öffentliche Methoden zugreifen, wenn der Aufrufer erteilt wurde ReflectionPermission mit der ReflectionPermissionFlag.RestrictedMemberAccess kennzeichnen und Menge oder eine Teilmenge der Berechtigungssatz die nicht öffentliche Methoden an des Aufrufers des beschränkt ist zu gewähren davon.Starting with the .NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1, this method can be used to access non-public methods if the caller has been granted ReflectionPermission with the ReflectionPermissionFlag.RestrictedMemberAccess flag and if the grant set of the non-public methods is restricted to the caller's grant set, or a subset thereof. (Finden Sie unter Überlegungen zur Sicherheit für die Reflektion.)(See Security Considerations for Reflection.)

Zur Verwendung dieser Funktionen sollte die Anwendung für .NET Framework 3,5.NET Framework 3.5 oder höher ausgelegt sein. To use this functionality, your application should target the .NET Framework 3,5.NET Framework 3.5 or later.

Kompatible Parameter und RückgabetypenCompatible Parameter Types and Return Type

Die Parameter und Rückgabetypen eines Delegaten müssen mit den Parametertypen und den Rückgabetyp der Methode, die den Delegaten dargestellt kompatibel sein. die Typen müssen nicht genau übereinstimmen.The parameter types and return type of a delegate must be compatible with the parameter types and return type of the method the delegate represents; the types do not have to match exactly.

Hinweis

In .NET Framework, Version 1.0 und 1.1 müssen die Typen exakt übereinstimmen.In the .NET Framework version 1.0 and 1.1, the types must match exactly.

Ein Parameter eines Delegaten ist mit dem entsprechenden Parameter einer Methode kompatibel, wenn der Typ des Delegatenparameters restriktiver ist als der Methodenparameter, da so gewährleistet ist, dass ein an den Delegaten übergebenes Argument problemlos an die Methode weitergeleitet werden kann.A parameter of a delegate is compatible with the corresponding parameter of a method if the type of the delegate parameter is more restrictive than the type of the method parameter, because this guarantees that an argument passed to the delegate can be passed safely to the method.

Ebenso ist der Rückgabetyp eines Delegaten kompatibel mit dem Rückgabetyp einer Methode, wenn der Rückgabetyp der Methode restriktiver ist als der Rückgabetyp des Delegaten, da so gewährleistet ist, dass der Rückgabewert der Methode problemlos in den Rückgabetyp des Delegaten umgewandelt werden kann.Similarly, the return type of a delegate is compatible with the return type of a method if the return type of the method is more restrictive than the return type of the delegate, because this guarantees that the return value of the method can be cast safely to the return type of the delegate.

Angenommen, ein Delegat mit einem Parameter vom Typ Hashtable und dem Rückgabetyp der Object kann eine Methode mit einem Parameter des Typs darstellen Object sowie einen Rückgabewert vom Typ Hashtable.For example, a delegate with a parameter of type Hashtable and a return type of Object can represent a method with a parameter of type Object and a return value of type Hashtable.

Sicherheit

ReflectionPermission
Beim Aufruf spät gebundene durch Mechanismen wie z. B. InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[]).when invoked late-bound through mechanisms such as InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[]). Zugeordnete Enumeration: MemberAccessAssociated enumeration: MemberAccess.

Siehe auch

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

Erstellt einen Delegaten vom angegebenen Typ, der die angegebene Instanzenmethode darstellt, die für die angegebene Klasseninstanz aufgerufen werden soll.Creates a delegate of the specified type that represents the specified instance method to invoke on the specified class instance.

public:
 static Delegate ^ CreateDelegate(Type ^ type, System::Object ^ target, System::String ^ method);
public static Delegate CreateDelegate (Type type, object target, string method);
static member CreateDelegate : Type * obj * string -> Delegate

Parameter

type
Type Type Type

Der Type des zu erstellenden Delegaten.The Type of delegate to create.

target
Object Object Object

Die Klasseninstanz, für die method aufgerufen wird.The class instance on which method is invoked.

method
String String String

Der Name der Instanzenmethode, die durch den Delegaten dargestellt werden soll.The name of the instance method that the delegate is to represent.

Gibt zurück

Ein Delegat vom angegebenen Typ, der die angegebene Instanzenmethode darstellt, die für die angegebene Klasseninstanz aufgerufen werden soll.A delegate of the specified type that represents the specified instance method to invoke on the specified class instance.

Ausnahmen

type ist null.type is null.

- oder - -or- target ist null.target is null.

- oder - -or- method ist null.method is null.

type erbt nicht MulticastDelegate.type does not inherit MulticastDelegate.

- oder --or- type ist keine RuntimeType.type is not a RuntimeType. Siehe Laufzeittypen in Reflektion.See Runtime Types in Reflection.

- oder --or- method ist keine Instanzenmethode.method is not an instance method.

- oder --or- method kann nicht gebunden werden, z. B. weil sie nicht gefunden wurde.method cannot be bound, for example because it cannot be found.

Die Invoke-Methode von type wurde nicht gefunden.The Invoke method of type is not found.

Der Aufrufer verfügt nicht über die erforderlichen Berechtigungen für den Zugriff auf method.The caller does not have the permissions necessary to access method.

Hinweise

Diese Methode erstellt nur Delegaten für die Instanz.This method creates delegates for instance methods only. Eine Instanzmethode handelt es sich um eine Methode, die eine Instanz einer Klasse zugeordnet ist; eine statische Methode handelt es sich um eine Methode, die die Klasse selbst zugeordnet ist.An instance method is a method that is associated with an instance of a class; a static method is a method that is associated with the class itself.

Überladung dieser Methode entspricht dem Aufrufen der CreateDelegate(Type, Object, String, Boolean, Boolean) -methodenüberladung angeben false für ignoreCase und true für throwOnBindFailure.This method overload is equivalent to calling the CreateDelegate(Type, Object, String, Boolean, Boolean) method overload, specifying false for ignoreCase and true for throwOnBindFailure.

Hinweis

Beginnend mit der .NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1, diese Methode kann verwendet werden, um nicht öffentliche Methoden zugreifen, wenn der Aufrufer erteilt wurde ReflectionPermission mit der ReflectionPermissionFlag.RestrictedMemberAccess kennzeichnen und Menge oder eine Teilmenge der Berechtigungssatz die nicht öffentliche Methoden an des Aufrufers des beschränkt ist zu gewähren davon.Starting with the .NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1, this method can be used to access non-public methods if the caller has been granted ReflectionPermission with the ReflectionPermissionFlag.RestrictedMemberAccess flag and if the grant set of the non-public methods is restricted to the caller's grant set, or a subset thereof. (Finden Sie unter Überlegungen zur Sicherheit für die Reflektion.)(See Security Considerations for Reflection.)

Zur Verwendung dieser Funktionen sollte die Anwendung für .NET Framework 3,5.NET Framework 3.5 oder höher ausgelegt sein. To use this functionality, your application should target the .NET Framework 3,5.NET Framework 3.5 or later.

Sicherheit

ReflectionPermission
Beim Aufruf spät gebundene durch Mechanismen wie z. B. InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[]).when invoked late-bound through mechanisms such as InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[]). Zugeordnete Enumeration: MemberAccessAssociated enumeration: MemberAccess.

Siehe auch

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

Erstellt einen Delegaten vom angegebenen Typ, der die angegebene statische Methode oder Instanzmethode mit dem angegebenen ersten Argument darstellt.Creates a delegate of the specified type that represents the specified static or instance method, with the specified first argument.

public:
 static Delegate ^ CreateDelegate(Type ^ type, System::Object ^ firstArgument, System::Reflection::MethodInfo ^ method);
public static Delegate CreateDelegate (Type type, object firstArgument, System.Reflection.MethodInfo method);
static member CreateDelegate : Type * obj * System.Reflection.MethodInfo -> Delegate

Parameter

type
Type Type Type

Der Type des zu erstellenden Delegaten.The Type of delegate to create.

firstArgument
Object Object Object

Das Objekt, an das der Delegat gebunden ist, oder null, um method als static (Shared in Visual Basic) zu behandeln.The object to which the delegate is bound, or null to treat method as static (Shared in Visual Basic).

method
MethodInfo MethodInfo MethodInfo

Die MethodInfo, die die statische Methode oder Instanzmethode beschreibt, die der Delegat darstellen soll.The MethodInfo describing the static or instance method the delegate is to represent.

Gibt zurück

Ein Delegat vom angegebenen Typ, der die angegebene statische Methode oder Instanzmethode darstellt.A delegate of the specified type that represents the specified static or instance method.

Ausnahmen

type ist null.type is null.

- oder - -or- method ist null.method is null.

type erbt nicht MulticastDelegate.type does not inherit MulticastDelegate.

- oder --or- type ist keine RuntimeType.type is not a RuntimeType. Siehe Laufzeittypen in Reflektion.See Runtime Types in Reflection.

- oder --or- method kann nicht gebunden werden.method cannot be bound.

- oder --or- method ist keine RuntimeMethodInfo.method is not a RuntimeMethodInfo. Siehe Laufzeittypen in Reflektion.See Runtime Types in Reflection.

Die Invoke-Methode von type wurde nicht gefunden.The Invoke method of type is not found.

Der Aufrufer verfügt nicht über die erforderlichen Berechtigungen für den Zugriff auf method.The caller does not have the permissions necessary to access method.

Beispiele

Dieser Abschnitt enthält drei Codebeispiele aufgeführt.This section contains three code examples. Das erste Beispiel veranschaulicht die vier Arten von Delegaten, die erstellt werden können: über eine Instanzmethode, öffnen Sie über eine Instanzmethode, öffnen Sie über eine statische Methode geschlossen und über eine statische Methode geschlossen.The first example demonstrates the four kinds of delegates that can be created: closed over an instance method, open over an instance method, open over a static method, and closed over a static method.

Im zweiten Codebeispiel wird veranschaulicht, kompatible Parametertypen und Rückgabetypen.The second code example demonstrates compatible parameter types and return types.

Im dritten Codebeispiel wird einen einzelner Delegattyp definiert, und zeigt, dass alle Methoden, die den Delegattyp darstellen können.The third code example defines a single delegate type, and shows all the methods that delegate type can represent.

Beispiel 1Example 1

Im folgenden Codebeispiel wird veranschaulicht, die vier Möglichkeiten, die ein Delegat kann mit dieser Überladung der erstellt werden die CreateDelegate Methode.The following code example demonstrates the four ways a delegate can be created using this overload of the CreateDelegate method.

Hinweis

Es gibt zwei Überladungen der CreateDelegate Methode, die angeben, firstArgument und ein MethodInfo; ihre Funktionalität ist identisch, außer dass eine Ihnen die ermöglicht Angabe, ob bei Bindungsfehlern ausgelöst werden, und die andere löst immer eine.There are two overloads of the CreateDelegate method that specify firstArgument and a MethodInfo; their functionality is the same except that one allows you to specify whether to throw on failure to bind, and the other always throws. Dieses Codebeispiel verwendet beide Überladungen.This code example uses both overloads.

Das Beispiel deklariert eine Klasse C mit einer statischen Methode M2 und eine Instanzmethode M1, sowie zwei Delegattypen: D1 akzeptiert eine Instanz von C und eine Zeichenfolge, D2 akzeptiert eine Zeichenfolge und D3verfügt über keine Argumente.The example declares a class C with a static method M2 and an instance method M1, and three delegate types: D1 takes an instance of C and a string, D2 takes a string, and D3 has no arguments.

Eine zweite Klasse namens Example enthält den Code, der den Delegaten erstellt.A second class named Example contains the code that creates the delegates.

  • Ein Delegat vom Typ D2, geschlossen für eine Instanz von C, wird für die Instanzmethode erstellt M1.A delegate of type D2, closed over an instance of C, is created for the instance method M1. Er wird aufgerufen, mit anderen Zeichenfolgen, um anzugeben, dass die gebundene Instanz von C wird immer verwendet.It is invoked with different strings, to show that the bound instance of C is always used.

  • Ein Delegat vom Typ D1, der eine offene Instanzmethode darstellt, wird für die Instanzmethode erstellt M1.A delegate of type D1, representing an open instance method, is created for the instance method M1. Eine Instanz muss übergeben werden, wenn der Delegat aufgerufen wird.An instance must be passed when the delegate is invoked.

  • Ein Delegat vom Typ D2, eine offene statische Methode darstellt, wird für die statische Methode erstellt M2.A delegate of type D2, representing an open static method, is created for the static method M2.

  • Schließlich einen Delegaten vom Typ D3, über eine Zeichenfolge geschlossen, wird für die statische Methode erstellt M2.Finally, a delegate of type D3, closed over a string, is created for the static method M2. Die Methode wird aufgerufen, um anzugeben, dass sie die gebundene Zeichenfolge verwendet wird.The method is invoked to show that it uses the bound string.

using System;
using System.Reflection;
using System.Security.Permissions;

// Declare three delegate types for demonstrating the combinations
// of static versus instance methods and open versus closed
// delegates.
//
public delegate void D1(C c, string s);
public delegate void D2(string s);
public delegate void D3();

// A sample class with an instance method and a static method.
//
public class C
{
    private int id;
    public C(int id) { this.id = id; }

    public void M1(string s) 
    { 
        Console.WriteLine("Instance method M1 on C:  id = {0}, s = {1}",
            this.id, s);
    }
  
    public static void M2(string s)
    { 
        Console.WriteLine("Static method M2 on C:  s = {0}", s); 
    }
}

public class Example
{
    public static void Main()
    {
        C c1 = new C(42);

        // Get a MethodInfo for each method.
        //
        MethodInfo mi1 = typeof(C).GetMethod("M1", 
            BindingFlags.Public | BindingFlags.Instance);
        MethodInfo mi2 = typeof(C).GetMethod("M2",
            BindingFlags.Public | BindingFlags.Static);

        D1 d1;
        D2 d2;
        D3 d3;


        Console.WriteLine("\nAn instance method closed over C.");
        // In this case, the delegate and the
        // method must have the same list of argument types; use
        // delegate type D2 with instance method M1.
        //
        Delegate test = 
            Delegate.CreateDelegate(typeof(D2), c1, mi1, false);

        // Because false was specified for throwOnBindFailure 
        // in the call to CreateDelegate, the variable 'test'
        // contains null if the method fails to bind (for 
        // example, if mi1 happened to represent a method of  
        // some class other than C).
        //
        if (test != null)
        {
            d2 = (D2) test;

            // The same instance of C is used every time the 
            // delegate is invoked.
            d2("Hello, World!");
            d2("Hi, Mom!");
        }


        Console.WriteLine("\nAn open instance method.");
        // In this case, the delegate has one more 
        // argument than the instance method; this argument comes
        // at the beginning, and represents the hidden instance
        // argument of the instance method. Use delegate type D1
        // with instance method M1.
        //
        d1 = (D1) Delegate.CreateDelegate(typeof(D1), null, mi1);

        // An instance of C must be passed in each time the 
        // delegate is invoked.
        //
        d1(c1, "Hello, World!");
        d1(new C(5280), "Hi, Mom!");


        Console.WriteLine("\nAn open static method.");
        // In this case, the delegate and the method must 
        // have the same list of argument types; use delegate type
        // D2 with static method M2.
        //
        d2 = (D2) Delegate.CreateDelegate(typeof(D2), null, mi2);

        // No instances of C are involved, because this is a static
        // method. 
        //
        d2("Hello, World!");
        d2("Hi, Mom!");


        Console.WriteLine("\nA static method closed over the first argument (String).");
        // The delegate must omit the first argument of the method.
        // A string is passed as the firstArgument parameter, and 
        // the delegate is bound to this string. Use delegate type 
        // D3 with static method M2. 
        //
        d3 = (D3) Delegate.CreateDelegate(typeof(D3), 
            "Hello, World!", mi2);

        // Each time the delegate is invoked, the same string is
        // used.
        d3();
    }
}

/* This code example produces the following output:

An instance method closed over C.
Instance method M1 on C:  id = 42, s = Hello, World!
Instance method M1 on C:  id = 42, s = Hi, Mom!

An open instance method.
Instance method M1 on C:  id = 42, s = Hello, World!
Instance method M1 on C:  id = 5280, s = Hi, Mom!

An open static method.
Static method M2 on C:  s = Hello, World!
Static method M2 on C:  s = Hi, Mom!

A static method closed over the first argument (String).
Static method M2 on C:  s = Hello, World!
 */
Imports System
Imports System.Reflection
Imports System.Security.Permissions

' Declare three delegate types for demonstrating the combinations
' of Shared versus instance methods and open versus closed
' delegates.
'
Public Delegate Sub D1(ByVal c As C, ByVal s As String) 
Public Delegate Sub D2(ByVal s As String) 
Public Delegate Sub D3() 

' A sample class with an instance method and a Shared method.
'
Public Class C
    Private id As Integer
    Public Sub New(ByVal id As Integer) 
        Me.id = id
    End Sub 'New

    Public Sub M1(ByVal s As String) 
        Console.WriteLine("Instance method M1 on C:  id = {0}, s = {1}", _
            Me.id, s)
    End Sub
    
    Public Shared Sub M2(ByVal s As String) 
        Console.WriteLine("Shared method M2 on C:  s = {0}", s)
    End Sub
End Class

Public Class Example
    
    Public Shared Sub Main() 

        Dim c1 As New C(42)
        
        ' Get a MethodInfo for each method.
        '
        Dim mi1 As MethodInfo = GetType(C).GetMethod("M1", _
            BindingFlags.Public Or BindingFlags.Instance)
        Dim mi2 As MethodInfo = GetType(C).GetMethod("M2", _
            BindingFlags.Public Or BindingFlags.Static)
        
        Dim d1 As D1
        Dim d2 As D2
        Dim d3 As D3
        
        
        Console.WriteLine(vbLf & "An instance method closed over C.")
        ' In this case, the delegate and the
        ' method must have the same list of argument types; use
        ' delegate type D2 with instance method M1.
        '
        Dim test As [Delegate] = _
            [Delegate].CreateDelegate(GetType(D2), c1, mi1, False)

        ' Because False was specified for throwOnBindFailure 
        ' in the call to CreateDelegate, the variable 'test'
        ' contains Nothing if the method fails to bind (for 
        ' example, if mi1 happened to represent a method of 
        ' some class other than C).
        '
        If test IsNot Nothing Then
            d2 = CType(test, D2)

            ' The same instance of C is used every time the
            ' delegate is invoked.
            d2("Hello, World!")
            d2("Hi, Mom!")
        End If
        
        
        Console.WriteLine(vbLf & "An open instance method.")
        ' In this case, the delegate has one more 
        ' argument than the instance method; this argument comes
        ' at the beginning, and represents the hidden instance
        ' argument of the instance method. Use delegate type D1
        ' with instance method M1.
        '
        d1 = CType([Delegate].CreateDelegate(GetType(D1), Nothing, mi1), D1)
        
        ' An instance of C must be passed in each time the 
        ' delegate is invoked.
        '
        d1(c1, "Hello, World!")
        d1(New C(5280), "Hi, Mom!")
        
        
        Console.WriteLine(vbLf & "An open Shared method.")
        ' In this case, the delegate and the method must 
        ' have the same list of argument types; use delegate type
        ' D2 with Shared method M2.
        '
        d2 = CType([Delegate].CreateDelegate(GetType(D2), Nothing, mi2), D2)
        
        ' No instances of C are involved, because this is a Shared
        ' method. 
        '
        d2("Hello, World!")
        d2("Hi, Mom!")
        
        
        Console.WriteLine(vbLf & "A Shared method closed over the first argument (String).")
        ' The delegate must omit the first argument of the method.
        ' A string is passed as the firstArgument parameter, and 
        ' the delegate is bound to this string. Use delegate type 
        ' D3 with Shared method M2. 
        '
        d3 = CType([Delegate].CreateDelegate(GetType(D3), "Hello, World!", mi2), D3)
        
        ' Each time the delegate is invoked, the same string is
        ' used.
        d3()
    
    End Sub
End Class

' This code example produces the following output:
'
'An instance method closed over C.
'Instance method M1 on C:  id = 42, s = Hello, World!
'Instance method M1 on C:  id = 42, s = Hi, Mom!
'
'An open instance method.
'Instance method M1 on C:  id = 42, s = Hello, World!
'Instance method M1 on C:  id = 5280, s = Hi, Mom!
'
'An open Shared method.
'Shared method M2 on C:  s = Hello, World!
'Shared method M2 on C:  s = Hi, Mom!
'
'A Shared method closed over the first argument (String).
'Shared method M2 on C:  s = Hello, World!
' 

Beispiel 2Example 2

Im folgenden Codebeispiel wird veranschaulicht, die Kompatibilität der Parametertypen und Rückgabetypen.The following code example demonstrates compatibility of parameter types and return types.

Hinweis

Dieses Codebeispiel verwendet die CreateDelegate(Type, MethodInfo) -methodenüberladung.This code example uses the CreateDelegate(Type, MethodInfo) method overload. Die Verwendung der anderen Überladungen dieser MethodInfo ist ähnlich.The use of other overloads that take MethodInfo is similar.

Das Codebeispiel definiert eine Basisklasse, die mit dem Namen Base und eine Klasse namens Derived abgeleitet, die Base.The code example defines a base class named Base and a class named Derived that derives from Base. Die abgeleitete Klasse verfügt über eine static (Shared in Visual Basic) Methode, die mit dem Namen MyMethod mit einem Parameter vom Typ Base und dem Rückgabetyp der Derived.The derived class has a static (Shared in Visual Basic) method named MyMethod with one parameter of type Base and a return type of Derived. Im Codebeispiel wird definiert auch einen Delegaten, der mit dem Namen Example , die einen Parameter vom Typ hat Derived und dem Rückgabetyp der Base.The code example also defines a delegate named Example that has one parameter of type Derived and a return type of Base.

Im Codebeispiel wird veranschaulicht, dass der Delegat, mit dem Namen Example können verwendet werden, um die Methode darstellen MyMethod.The code example demonstrates that the delegate named Example can be used to represent the method MyMethod. Die Methode kann an den Delegaten gebunden werden, da:The method can be bound to the delegate because:

  • Der Parametertyp des Delegaten (Derived) ist stärker eingeschränkt als der Parametertyp des MyMethod (Base), sodass es immer sicher an das Argument des Delegaten zu übergeben sind MyMethod.The parameter type of the delegate (Derived) is more restrictive than the parameter type of MyMethod (Base), so that it is always safe to pass the argument of the delegate to MyMethod.

  • Der Rückgabetyp der MyMethod (Derived) ist stärker eingeschränkt als der Parametertyp des Delegaten (Base), sodass sie immer sicher, das den Rückgabetyp der Methode, die den Rückgabetyp des Delegaten umgewandelt werden kann.The return type of MyMethod (Derived) is more restrictive than the parameter type of the delegate (Base), so that it is always safe to cast the return type of the method to the return type of the delegate.

Im Codebeispiel erzeugt keine Ausgabe.The code example produces no output.

using namespace System;
using namespace System::Reflection;

// Define two classes to use in the demonstration, a base class and 
// a class that derives from it.
//
public ref class Base {};

public ref class Derived : Base
{
    // Define a static method to use in the demonstration. The method 
    // takes an instance of Base and returns an instance of Derived.  
    // For the purposes of the demonstration, it is not necessary for 
    // the method to do anything useful. 
    //
public:
    static Derived^ MyMethod(Base^ arg)
    {
        Base^ dummy = arg;
        return gcnew Derived();
    }
};

// Define a delegate that takes an instance of Derived and returns an
// instance of Base.
//
public delegate Base^ Example(Derived^ arg);

void main()
{
    // The binding flags needed to retrieve MyMethod.
    BindingFlags flags = BindingFlags::Public | BindingFlags::Static;

    // Get a MethodInfo that represents MyMethod.
    MethodInfo^ minfo = Derived::typeid->GetMethod("MyMethod", flags);

    // Demonstrate contravariance of parameter types and covariance
    // of return types by using the delegate Example to represent
    // MyMethod. The delegate binds to the method because the
    // parameter of the delegate is more restrictive than the 
    // parameter of the method (that is, the delegate accepts an
    // instance of Derived, which can always be safely passed to
    // a parameter of type Base), and the return type of MyMethod
    // is more restrictive than the return type of Example (that
    // is, the method returns an instance of Derived, which can
    // always be safely cast to type Base). 
    //
    Example^ ex = 
        (Example^) Delegate::CreateDelegate(Example::typeid, minfo);

    // Execute MyMethod using the delegate Example.
    //        
    Base^ b = ex(gcnew Derived());
}
using System;
using System.Reflection;

// Define two classes to use in the demonstration, a base class and 
// a class that derives from it.
//
public class Base {}

public class Derived : Base
{
    // Define a static method to use in the demonstration. The method 
    // takes an instance of Base and returns an instance of Derived.  
    // For the purposes of the demonstration, it is not necessary for 
    // the method to do anything useful. 
    //
    public static Derived MyMethod(Base arg)
    {
        Base dummy = arg;
        return new Derived();
    }
}

// Define a delegate that takes an instance of Derived and returns an
// instance of Base.
//
public delegate Base Example(Derived arg);

class Test
{
    public static void Main()
    {
        // The binding flags needed to retrieve MyMethod.
        BindingFlags flags = BindingFlags.Public | BindingFlags.Static;

        // Get a MethodInfo that represents MyMethod.
        MethodInfo minfo = typeof(Derived).GetMethod("MyMethod", flags);

        // Demonstrate contravariance of parameter types and covariance
        // of return types by using the delegate Example to represent
        // MyMethod. The delegate binds to the method because the
        // parameter of the delegate is more restrictive than the 
        // parameter of the method (that is, the delegate accepts an
        // instance of Derived, which can always be safely passed to
        // a parameter of type Base), and the return type of MyMethod
        // is more restrictive than the return type of Example (that
        // is, the method returns an instance of Derived, which can
        // always be safely cast to type Base). 
        //
        Example ex = 
            (Example) Delegate.CreateDelegate(typeof(Example), minfo);

        // Execute MyMethod using the delegate Example.
        //        
        Base b = ex(new Derived());
    }
}
Imports System
Imports System.Reflection

' Define two classes to use in the demonstration, a base class and 
' a class that derives from it.
'
Public Class Base
End Class

Public Class Derived
    Inherits Base

    ' Define a Shared method to use in the demonstration. The method 
    ' takes an instance of Base and returns an instance of Derived.  
    ' For the purposes of the demonstration, it is not necessary for 
    ' the method to do anything useful. 
    '
    Public Shared Function MyMethod(ByVal arg As Base) As Derived
        Dim dummy As Base = arg
        Return New Derived()
    End Function

End Class

' Define a delegate that takes an instance of Derived and returns an
' instance of Base.
'
Public Delegate Function Example(ByVal arg As Derived) As Base

Module Test

    Sub Main()

        ' The binding flags needed to retrieve MyMethod.
        Dim flags As BindingFlags = _
            BindingFlags.Public Or BindingFlags.Static

        ' Get a MethodInfo that represents MyMethod.
        Dim minfo As MethodInfo = _
            GetType(Derived).GetMethod("MyMethod", flags)

        ' Demonstrate contravariance of parameter types and covariance
        ' of return types by using the delegate Example to represent
        ' MyMethod. The delegate binds to the method because the
        ' parameter of the delegate is more restrictive than the 
        ' parameter of the method (that is, the delegate accepts an
        ' instance of Derived, which can always be safely passed to
        ' a parameter of type Base), and the return type of MyMethod
        ' is more restrictive than the return type of Example (that
        ' is, the method returns an instance of Derived, which can
        ' always be safely cast to type Base). 
        '
        Dim ex As Example = CType( _
            [Delegate].CreateDelegate(GetType(Example), minfo), _
            Example _
        )

        ' Execute MyMethod using the delegate Example.
        '        
        Dim b As Base = ex(New Derived())
    End Sub
End Module

Beispiel 3Example 3

Das folgende Codebeispiel zeigt alle Methoden ein einzelner Delegattyp darstellen kann, mit der CreateDelegate Methode, um die Delegaten zu erstellen.The following code example shows all the methods a single delegate type can represent, using the CreateDelegate method to create the delegates.

Hinweis

Es gibt zwei Überladungen der CreateDelegate Methode, die angeben, firstArgument und ein MethodInfo; ihre Funktionalität ist identisch, außer dass eine Ihnen die ermöglicht Angabe, ob bei Bindungsfehlern ausgelöst werden, und die andere löst immer eine.There are two overloads of the CreateDelegate method that specify firstArgument and a MethodInfo; their functionality is the same except that one allows you to specify whether to throw on failure to bind, and the other always throws. Dieses Codebeispiel verwendet beide Überladungen.This code example uses both overloads.

Im Codebeispiel werden zwei Klassen definiert C und F, und einen Delegattyp D mit einem Argument des Typs C.The code example defines two classes, C and F, and a delegate type D with one argument of type C. Die Klassen übereinstimmende statische und Instanzenmethoden M1, M3, und M4, und die Klasse C verfügt auch über eine Instanzmethode M2 , die keine Argumente verfügt.The classes have matching static and instance methods M1, M3, and M4, and class C also has an instance method M2 that has no arguments.

Eine dritte Klasse namens Example enthält den Code, der den Delegaten erstellt.A third class named Example contains the code that creates the delegates.

  • Delegaten werden erstellt, z. B. Methode M1 des Typs C und F; jede über eine Instanz des jeweiligen Typs geschlossen wird.Delegates are created for instance method M1 of type C and type F; each is closed over an instance of the respective type. Methode M1 des Typs C zeigt die ID Eigenschaften der gebundenen Instanz und des Arguments.Method M1 of type C displays the ID properties of the bound instance and of the argument.

  • Ein Delegat erstellt wird, für die Methode M2 des Typs C.A delegate is created for method M2 of type C. Dies ist eine offene Instanz-Delegaten, in dem das Argument des Delegaten ausgeblendete erste Argument für die Instanzmethode darstellt.This is an open instance delegate, in which the argument of the delegate represents the hidden first argument on the instance method. Die Methode hat keine anderen Argumente.The method has no other arguments. Sie wird aufgerufen, als handele es sich um eine statische Methode.It is called as if it were a static method.

  • Delegaten werden erstellt, für die statische Methode M3 des Typs C und F; Hierbei handelt es sich um open statische Delegaten.Delegates are created for static method M3 of type C and type F; these are open static delegates.

  • Schließlich werden die Delegaten für die statische Methode erstellt M4 des Typs C und F; jede Methode verfügt über den deklarierenden Typ als erstes Argument und eine Instanz des Typs angegeben wird, damit die Delegaten über dem ersten Argument geschlossen werden .Finally, delegates are created for static method M4 of type C and type F; each method has the declaring type as its first argument, and an instance of the type is supplied, so the delegates are closed over their first arguments. Methode M4 des Typs C zeigt die ID Eigenschaften der gebundenen Instanz und des Arguments.Method M4 of type C displays the ID properties of the bound instance and of the argument.

using System;
using System.Reflection;
using System.Security.Permissions;

// Declare a delegate type. The object of this code example
// is to show all the methods this delegate can bind to.
//
public delegate void D(C c);

// Declare two sample classes, C and F. Class C has an ID
// property so instances can be identified.
//
public class C
{
    private int id;
    public int ID { get { return id; }}
    public C(int id) { this.id = id; }

    public void M1(C c) 
    { 
        Console.WriteLine("Instance method M1(C c) on C:  this.id = {0}, c.ID = {1}",
            this.id, c.ID);
    }
  
    public void M2() 
    { 
        Console.WriteLine("Instance method M2() on C:  this.id = {0}",
            this.id);
    }
  
    public static void M3(C c)
    { 
        Console.WriteLine("Static method M3(C c) on C:  c.ID = {0}", c.ID); 
    }

    public static void M4(C c1, C c2) 
    { 
        Console.WriteLine("Static method M4(C c1, C c2) on C:  c1.ID = {0}, c2.ID = {1}",
            c1.ID, c2.ID);
    }
}

public class F
{
    public void M1(C c) 
    { 
        Console.WriteLine("Instance method M1(C c) on F:  c.ID = {0}",
            c.ID);
    }
  
    public static void M3(C c)
    { 
        Console.WriteLine("Static method M3(C c) on F:  c.ID = {0}", c.ID); 
    }

    public static void M4(F f, C c) 
    { 
        Console.WriteLine("Static method M4(F f, C c) on F:  c.ID = {0}",
            c.ID);
    }
}


public class Example
{
    public static void Main()
    {
        C c1 = new C(42);
        C c2 = new C(1491);
        F f1 = new F();

        D d;

        // Instance method with one argument of type C.
        MethodInfo cmi1 = typeof(C).GetMethod("M1"); 
        // Instance method with no arguments.
        MethodInfo cmi2 = typeof(C).GetMethod("M2"); 
        // Static method with one argument of type C.
        MethodInfo cmi3 = typeof(C).GetMethod("M3"); 
        // Static method with two arguments of type C.
        MethodInfo cmi4 = typeof(C).GetMethod("M4"); 

        // Instance method with one argument of type C.
        MethodInfo fmi1 = typeof(F).GetMethod("M1");
        // Static method with one argument of type C.
        MethodInfo fmi3 = typeof(F).GetMethod("M3"); 
        // Static method with an argument of type F and an argument 
        // of type C.
        MethodInfo fmi4 = typeof(F).GetMethod("M4"); 

        Console.WriteLine("\nAn instance method on any type, with an argument of type C.");
        // D can represent any instance method that exactly matches its
        // signature. Methods on C and F are shown here.
        //
        d = (D) Delegate.CreateDelegate(typeof(D), c1, cmi1);
        d(c2);
        d = (D) Delegate.CreateDelegate(typeof(D), f1, fmi1);
        d(c2);

        Console.WriteLine("\nAn instance method on C with no arguments.");
        // D can represent an instance method on C that has no arguments;
        // in this case, the argument of D represents the hidden first
        // argument of any instance method. The delegate acts like a 
        // static method, and an instance of C must be passed each time
        // it is invoked.
        //
        d = (D) Delegate.CreateDelegate(typeof(D), null, cmi2);
        d(c1);

        Console.WriteLine("\nA static method on any type, with an argument of type C.");
        // D can represent any static method with the same signature.
        // Methods on F and C are shown here.
        //
        d = (D) Delegate.CreateDelegate(typeof(D), null, cmi3);
        d(c1);
        d = (D) Delegate.CreateDelegate(typeof(D), null, fmi3);
        d(c1);

        Console.WriteLine("\nA static method on any type, with an argument of");
        Console.WriteLine("    that type and an argument of type C.");
        // D can represent any static method with one argument of the
        // type the method belongs and a second argument of type C.
        // In this case, the method is closed over the instance of
        // supplied for the its first argument, and acts like an instance
        // method. Methods on F and C are shown here.
        //
        d = (D) Delegate.CreateDelegate(typeof(D), c1, cmi4);
        d(c2);
        Delegate test = 
            Delegate.CreateDelegate(typeof(D), f1, fmi4, false);

        // This final example specifies false for throwOnBindFailure 
        // in the call to CreateDelegate, so the variable 'test'
        // contains Nothing if the method fails to bind (for 
        // example, if fmi4 happened to represent a method of  
        // some class other than F).
        //
        if (test != null)
        {
            d = (D) test;
            d(c2);
        }
    }
}

/* This code example produces the following output:

An instance method on any type, with an argument of type C.
Instance method M1(C c) on C:  this.id = 42, c.ID = 1491
Instance method M1(C c) on F:  c.ID = 1491

An instance method on C with no arguments.
Instance method M2() on C:  this.id = 42

A static method on any type, with an argument of type C.
Static method M3(C c) on C:  c.ID = 42
Static method M3(C c) on F:  c.ID = 42

A static method on any type, with an argument of
    that type and an argument of type C.
Static method M4(C c1, C c2) on C:  c1.ID = 42, c2.ID = 1491
Static method M4(F f, C c) on F:  c.ID = 1491
*/
Imports System
Imports System.Reflection
Imports System.Security.Permissions

' Declare a delegate type. The object of this code example
' is to show all the methods this delegate can bind to.
'
Public Delegate Sub D(ByVal c As C) 

' Declare two sample classes, C and F. Class C has an ID
' property so instances can be identified.
'
Public Class C

    Private _id As Integer

    Public ReadOnly Property ID() As Integer 
        Get
            Return _id
        End Get
    End Property

    Public Sub New(ByVal newId As Integer) 
        Me._id = newId
    End Sub
    
    Public Sub M1(ByVal c As C) 
        Console.WriteLine("Instance method M1(c As C) on C:  this.id = {0}, c.ID = {1}", _
            Me.id, c.ID)
    End Sub
    
    Public Sub M2() 
        Console.WriteLine("Instance method M2() on C:  this.id = {0}", Me.id)
    End Sub
    
    Public Shared Sub M3(ByVal c As C) 
        Console.WriteLine("Shared method M3(c As C) on C:  c.ID = {0}", c.ID)
    End Sub
    
    Public Shared Sub M4(ByVal c1 As C, ByVal c2 As C) 
        Console.WriteLine("Shared method M4(c1 As C, c2 As C) on C:  c1.ID = {0}, c2.ID = {1}", _
            c1.ID, c2.ID)
    End Sub
End Class


Public Class F
    
    Public Sub M1(ByVal c As C) 
        Console.WriteLine("Instance method M1(c As C) on F:  c.ID = {0}", c.ID)
    End Sub
    
    Public Shared Sub M3(ByVal c As C) 
        Console.WriteLine("Shared method M3(c As C) on F:  c.ID = {0}", c.ID)
    End Sub
    
    Public Shared Sub M4(ByVal f As F, ByVal c As C) 
        Console.WriteLine("Shared method M4(f As F, c As C) on F:  c.ID = {0}", c.ID)
    End Sub
End Class

Public Class Example
    
    Public Shared Sub Main() 

        Dim c1 As New C(42)
        Dim c2 As New C(1491)
        Dim f1 As New F()
        
        Dim d As D
        
        ' Instance method with one argument of type C.
        Dim cmi1 As MethodInfo = GetType(C).GetMethod("M1")
        ' Instance method with no arguments.
        Dim cmi2 As MethodInfo = GetType(C).GetMethod("M2")
        ' Shared method with one argument of type C.
        Dim cmi3 As MethodInfo = GetType(C).GetMethod("M3")
        ' Shared method with two arguments of type C.
        Dim cmi4 As MethodInfo = GetType(C).GetMethod("M4")
        
        ' Instance method with one argument of type C.
        Dim fmi1 As MethodInfo = GetType(F).GetMethod("M1")
        ' Shared method with one argument of type C.
        Dim fmi3 As MethodInfo = GetType(F).GetMethod("M3")
        ' Shared method with an argument of type F and an 
        ' argument of type C.
        Dim fmi4 As MethodInfo = GetType(F).GetMethod("M4")
        
        Console.WriteLine(vbLf & "An instance method on any type, with an argument of type C.")
        ' D can represent any instance method that exactly matches its
        ' signature. Methods on C and F are shown here.
        '
        d = CType([Delegate].CreateDelegate(GetType(D), c1, cmi1), D)
        d(c2)
        d = CType([Delegate].CreateDelegate(GetType(D), f1, fmi1), D)
        d(c2)
        
        Console.WriteLine(vbLf & "An instance method on C with no arguments.")
        ' D can represent an instance method on C that has no arguments;
        ' in this case, the argument of D represents the hidden first
        ' argument of any instance method. The delegate acts like a 
        ' Shared method, and an instance of C must be passed each time
        ' it is invoked.
        '
        d = CType([Delegate].CreateDelegate(GetType(D), Nothing, cmi2), D)
        d(c1)
        
        Console.WriteLine(vbLf & "A Shared method on any type, with an argument of type C.")
        ' D can represent any Shared method with the same signature.
        ' Methods on F and C are shown here.
        '
        d = CType([Delegate].CreateDelegate(GetType(D), Nothing, cmi3), D)
        d(c1)
        d = CType([Delegate].CreateDelegate(GetType(D), Nothing, fmi3), D)
        d(c1)
        
        Console.WriteLine(vbLf & "A Shared method on any type, with an argument of")
        Console.WriteLine("    that type and an argument of type C.")
        ' D can represent any Shared method with one argument of the
        ' type the method belongs and a second argument of type C.
        ' In this case, the method is closed over the instance of
        ' supplied for the its first argument, and acts like an instance
        ' method. Methods on F and C are shown here.
        '
        d = CType([Delegate].CreateDelegate(GetType(D), c1, cmi4), D)
        d(c2)
        Dim test As [Delegate] = _
            [Delegate].CreateDelegate(GetType(D), f1, fmi4, false)

        ' This final example specifies False for throwOnBindFailure 
        ' in the call to CreateDelegate, so the variable 'test'
        ' contains Nothing if the method fails to bind (for 
        ' example, if fmi4 happened to represent a method of  
        ' some class other than F).
        '
        If test IsNot Nothing Then
            d = CType(test, D)
            d(c2)
        End If
    
    End Sub
End Class

' This code example produces the following output:
'
'An instance method on any type, with an argument of type C.
'Instance method M1(c As C) on C:  this.id = 42, c.ID = 1491
'Instance method M1(c As C) on F:  c.ID = 1491
'
'An instance method on C with no arguments.
'Instance method M2() on C:  this.id = 42
'
'A Shared method on any type, with an argument of type C.
'Shared method M3(c As C) on C:  c.ID = 42
'Shared method M3(c As C) on F:  c.ID = 42
'
'A Shared method on any type, with an argument of
'    that type and an argument of type C.
'Shared method M4(c1 As C, c2 As C) on C:  c1.ID = 42, c2.ID = 1491
'Shared method M4(f As F, c As C) on F:  c.ID = 1491
'

Hinweise

Aufrufen der Überladung dieser Methode entspricht dem Aufrufen der CreateDelegate(Type, Object, MethodInfo, Boolean) -methodenüberladung, und geben true für throwOnBindFailure.Calling this method overload is equivalent to calling the CreateDelegate(Type, Object, MethodInfo, Boolean) method overload and specifying true for throwOnBindFailure. Diese beiden Überladungen bieten die flexibelste Möglichkeit zum Erstellen von Delegaten.These two overloads provide the most flexible way to create delegates. Sie können diese verwenden, um Delegaten für statische oder Instanzmethoden zu erstellen und optional an das erste Argument.You can use them to create delegates for either static or instance methods, and optionally to specify the first argument.

Hinweis

Wenn Sie ein erstes Argument nicht angeben, verwenden Sie die CreateDelegate(Type, MethodInfo) methodenüberladung für eine bessere Leistung.If you do not supply a first argument, use the CreateDelegate(Type, MethodInfo) method overload for better performance.

Der Delegattyp und die Methode müssen kompatible Rückgabetypen haben.The delegate type and the method must have compatible return types. D. h. der Rückgabetyp der method muss der Rückgabetyp der zugewiesen werden können type.That is, the return type of method must be assignable to the return type of type.

Wenn firstArgument wird angegeben, wird es an übergeben method jedes Mal, wenn der Delegat aufgerufen wird; firstArgument hört sich an den Delegaten gebunden werden und der Delegat wird gesagt, über das erste Argument geschlossen ist.If firstArgument is supplied, it is passed to method every time the delegate is invoked; firstArgument is said to be bound to the delegate, and the delegate is said to be closed over its first argument. Wenn method ist static (Shared in Visual Basic), wird das Argument bereitgestellte beim Aufrufen des Delegaten Liste schließt alle Parameter außer dem ersten; aus, wenn method ist eine Instanzmethode firstArgument an der ausgeblendeten Instanz übergeben wird Parameter (dargestellt durch this in c# oder durch Me in Visual Basic).If method is static (Shared in Visual Basic), the argument list supplied when invoking the delegate includes all parameters except the first; if method is an instance method, then firstArgument is passed to the hidden instance parameter (represented by this in C#, or by Me in Visual Basic).

Wenn firstArgument angegeben wird, der erste Parameter der method muss ein Verweistyp sein und firstArgument mit diesem Typ kompatibel sein muss.If firstArgument is supplied, the first parameter of method must be a reference type, and firstArgument must be compatible with that type.

Wichtig

Wenn method ist static (Shared in Visual Basic) und der erste Parameter ist vom Typ Object oder ValueType, klicken Sie dann firstArgument kann ein Werttyp sein.If method is static (Shared in Visual Basic) and its first parameter is of type Object or ValueType, then firstArgument can be a value type. In diesem Fall firstArgument automatisch eingeschlossen.In this case firstArgument is automatically boxed. Automatische Boxing erfolgt nicht für alle anderen Argumente, wie es in einer C#- oder Visual Basic-Funktion aufrufen würden.Automatic boxing does not occur for any other arguments, as it would in a C# or Visual Basic function call.

Wenn firstArgument ist ein null-Verweis und method eine Instanzmethode ist das Ergebnis hängt von den Signaturen der Typ des Delegaten type und method:If firstArgument is a null reference and method is an instance method, the result depends on the signatures of the delegate type type and of method:

  • Wenn die Signatur der type schließt explizit die ersten verborgenen Parameter von method, der Delegaten gesagt, dass eine offene Instanzmethode darstellt.If the signature of type explicitly includes the hidden first parameter of method, the delegate is said to represent an open instance method. Wenn der Delegat aufgerufen wird, wird das erste Argument in der Liste der Argumente an den ausgeblendeten Instanz-Parameter übergeben method.When the delegate is invoked, the first argument in the argument list is passed to the hidden instance parameter of method.

  • Wenn die Signaturen der method und type übereinstimmen (d. h. alle Parametertypen sind kompatibel), und klicken Sie dann der Delegaten gesagt, dass er über einen null-Verweis geschlossen werden.If the signatures of method and type match (that is, all parameter types are compatible), then the delegate is said to be closed over a null reference. Aufrufen des Delegaten entspricht dem Aufrufen einer Instanzmethode auf eine null-Instanz, die nicht besonders nützlich, etwas zu tun ist.Invoking the delegate is like calling an instance method on a null instance, which is not a particularly useful thing to do.

Wenn firstArgument ist ein null-Verweis und method ist statisch und das Ergebnis hängt von den Signaturen des Delegattyps type und method:If firstArgument is a null reference and method is static, the result depends on the signatures of the delegate type type and of method:

  • Wenn die Signatur der method und type übereinstimmen (d. h. alle Parametertypen sind kompatibel), der Delegaten gesagt, dass eine offene statische Methode darstellt.If the signature of method and type match (that is, all parameter types are compatible), the delegate is said to represent an open static method. Dies ist der häufigste Fall für statische Methoden.This is the most common case for static methods. In diesem Fall erhalten Sie eine etwas bessere Leistung mithilfe der CreateDelegate(Type, MethodInfo) -methodenüberladung.In this case, you can get slightly better performance by using the CreateDelegate(Type, MethodInfo) method overload.

  • Wenn die Signatur der type beginnt mit dem zweiten Parameter der method der Rest der Parametertypen kompatibel sind, und die Delegaten gesagt, dass Sie über ein null-Verweis geschlossen werden.If the signature of type begins with the second parameter of method and the rest of the parameter types are compatible, then the delegate is said to be closed over a null reference. Wenn der Delegat aufgerufen wird, wird ein null-Verweis auf den ersten Parameter übergeben method.When the delegate is invoked, a null reference is passed to the first parameter of method.

Hinweis

Beginnend mit der .NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1, diese Methode kann verwendet werden, um nicht öffentliche Methoden zugreifen, wenn der Aufrufer erteilt wurde ReflectionPermission mit der ReflectionPermissionFlag.RestrictedMemberAccess kennzeichnen und Menge oder eine Teilmenge der Berechtigungssatz die nicht öffentliche Methoden an des Aufrufers des beschränkt ist zu gewähren davon.Starting with the .NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1, this method can be used to access non-public methods if the caller has been granted ReflectionPermission with the ReflectionPermissionFlag.RestrictedMemberAccess flag and if the grant set of the non-public methods is restricted to the caller's grant set, or a subset thereof. (Finden Sie unter Überlegungen zur Sicherheit für die Reflektion.)(See Security Considerations for Reflection.)

Zur Verwendung dieser Funktionen sollte die Anwendung für .NET Framework 3,5.NET Framework 3.5 oder höher ausgelegt sein. To use this functionality, your application should target the .NET Framework 3,5.NET Framework 3.5 or later.

Kompatible Parameter und RückgabetypenCompatible Parameter Types and Return Type

Die Parameter und Rückgabetypen eines Delegaten müssen mit den Parametertypen und den Rückgabetyp der Methode, die den Delegaten dargestellt kompatibel sein. die Typen müssen nicht genau übereinstimmen.The parameter types and return type of a delegate must be compatible with the parameter types and return type of the method the delegate represents; the types do not have to match exactly.

Hinweis

In .NET Framework, Version 1.0 und 1.1 müssen die Typen exakt übereinstimmen.In the .NET Framework version 1.0 and 1.1, the types must match exactly.

Ein Parameter eines Delegaten ist mit dem entsprechenden Parameter einer Methode kompatibel, wenn der Typ des Delegatenparameters restriktiver ist als der Methodenparameter, da so gewährleistet ist, dass ein an den Delegaten übergebenes Argument problemlos an die Methode weitergeleitet werden kann.A parameter of a delegate is compatible with the corresponding parameter of a method if the type of the delegate parameter is more restrictive than the type of the method parameter, because this guarantees that an argument passed to the delegate can be passed safely to the method.

Ebenso ist der Rückgabetyp eines Delegaten kompatibel mit dem Rückgabetyp einer Methode, wenn der Rückgabetyp der Methode restriktiver ist als der Rückgabetyp des Delegaten, da so gewährleistet ist, dass der Rückgabewert der Methode problemlos in den Rückgabetyp des Delegaten umgewandelt werden kann.Similarly, the return type of a delegate is compatible with the return type of a method if the return type of the method is more restrictive than the return type of the delegate, because this guarantees that the return value of the method can be cast safely to the return type of the delegate.

Angenommen, ein Delegat mit einem Parameter vom Typ Hashtable und dem Rückgabetyp der Object kann eine Methode mit einem Parameter des Typs darstellen Object sowie einen Rückgabewert vom Typ Hashtable.For example, a delegate with a parameter of type Hashtable and a return type of Object can represent a method with a parameter of type Object and a return value of type Hashtable.

Bestimmen die Methoden kann ein Delegat darstellen.Determining the Methods a Delegate Can Represent

Eine weitere nützliche Methode, die Flexibilität, die von dieser Überladung der bereitgestellten betrachten CreateDelegate besteht darin, dass jeder angegebene Delegat vier verschiedene Kombinationen der Methodensignatur und Methodenart (statisch oder Instanz) darstellen kann.Another useful way to think of the flexibility provided by this overload of CreateDelegate is that any given delegate can represent four different combinations of method signature and method kind (static versus instance). Betrachten Sie einen Delegattyp D mit einem Argument des Typs C.Consider a delegate type D with one argument of type C. Im folgenden wird beschrieben, die Methoden D darstellen kann, wird den Rückgabetyp wird ignoriert, da es in allen Fällen entsprechen muss:The following describes the methods D can represent, ignoring the return type since it must match in all cases:

  • D kann Instanzmethode, die genau ein Argument des Typs darstellen C, unabhängig davon, welchen Typ die Instanzmethode gehört.D can represent any instance method that has exactly one argument of type C, regardless of what type the instance method belongs to. Wenn CreateDelegate aufgerufen wird, firstArgument ist eine Instanz des Typs method angehört, und der resultierende Delegat wird gesagt, über diese Instanz geschlossen werden.When CreateDelegate is called, firstArgument is an instance of the type method belongs to, and the resulting delegate is said to be closed over that instance. (Im Grunde D kann auch über ein null-Verweis geschlossen werden, wenn firstArgument ein null-Verweis ist.)(Trivially, D can also be closed over a null reference if firstArgument is a null reference.)

  • D kann eine Instanzmethode darstellen C , die keine Argumente verfügt.D can represent an instance method of C that has no arguments. Wenn CreateDelegate aufgerufen wird, firstArgument ist ein null-Verweis.When CreateDelegate is called, firstArgument is a null reference. Der resultierende Delegat stellt eine offene Instanz-Methode und eine Instanz von C müssen angegeben werden, bei jedem Aufruf erfolgte.The resulting delegate represents an open instance method, and an instance of C must be supplied each time it is invoked.

  • D kann eine statische Methode, die ein des Typs Argument darstellen C, und dass die Methode in einen beliebigen Typ angehören kann.D can represent a static method that takes one argument of type C, and that method can belong to any type. Wenn CreateDelegate aufgerufen wird, firstArgument ist ein null-Verweis.When CreateDelegate is called, firstArgument is a null reference. Der resultierende Delegat stellt eine offene statische Methode und einer Instanz von C müssen angegeben werden, bei jedem Aufruf erfolgte.The resulting delegate represents an open static method, and an instance of C must be supplied each time it is invoked.

  • D können eine statische Methode darstellen, die zum Typ gehört F und verfügt über zwei Argumente des Typs F und C.D can represent a static method that belongs to type F and has two arguments, of type F and type C. Wenn CreateDelegate aufgerufen wird, firstArgument ist eine Instanz der F.When CreateDelegate is called, firstArgument is an instance of F. Der resultierende Delegat stellt eine statische Methode, die über diese Instanz geschlossen ist F.The resulting delegate represents a static method that is closed over that instance of F. Beachten Sie, dass im Fall, in denen F und C denselben Typ aufweisen, die statische Methode verfügt über zwei Argumente des Typs.Note that in the case where F and C are the same type, the static method has two arguments of that type. (In diesem Fall D wird über einen null-Verweis geschlossen, wenn firstArgument ein null-Verweis ist.)(In this case, D is closed over a null reference if firstArgument is a null reference.)

Sicherheit

ReflectionPermission
Beim Aufruf spät gebundene durch Mechanismen wie z. B. InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[]).when invoked late-bound through mechanisms such as InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[]). Zugeordnete Enumeration: MemberAccessAssociated enumeration: MemberAccess.

Siehe auch

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

Erstellt einen Delegaten vom angegebenen Typ, der die angegebene statische Methode der angegebenen Klasse darstellt.Creates a delegate of the specified type that represents the specified static method of the specified class.

public:
 static Delegate ^ CreateDelegate(Type ^ type, Type ^ target, System::String ^ method);
public static Delegate CreateDelegate (Type type, Type target, string method);
static member CreateDelegate : Type * Type * string -> Delegate

Parameter

type
Type Type Type

Der Type des zu erstellenden Delegaten.The Type of delegate to create.

target
Type Type Type

Der Type, der die Klasse darstellt, die von method implementiert wird.The Type representing the class that implements method.

method
String String String

Der Name der statischen Methode, die durch den Delegaten dargestellt werden soll.The name of the static method that the delegate is to represent.

Gibt zurück

Ein Delegat vom angegebenen Typ, der die angegebene statische Methode der angegebenen Klasse darstellt.A delegate of the specified type that represents the specified static method of the specified class.

Ausnahmen

type ist null.type is null.

- oder - -or- target ist null.target is null.

- oder - -or- method ist null.method is null.

type erbt nicht MulticastDelegate.type does not inherit MulticastDelegate.

- oder --or- type ist keine RuntimeType.type is not a RuntimeType. Siehe Laufzeittypen in Reflektion.See Runtime Types in Reflection.

- oder --or- target ist keine RuntimeType.target is not a RuntimeType.

- oder --or- target ist ein offener generischer Typ.target is an open generic type. Das bedeutet, die ContainsGenericParameters-Eigenschaft ist true.That is, its ContainsGenericParameters property is true.

- oder --or- method ist keine static-Methode (Shared-Methode in Visual Basic).method is not a static method (Shared method in Visual Basic).

- oder --or- method kann nicht gebunden werden, z. B. weil sie nicht gefunden wurde, und throwOnBindFailure ist gleich true.method cannot be bound, for example because it cannot be found, and throwOnBindFailure is true.

Die Invoke-Methode von type wurde nicht gefunden.The Invoke method of type is not found.

Der Aufrufer verfügt nicht über die erforderlichen Berechtigungen für den Zugriff auf method.The caller does not have the permissions necessary to access method.

Hinweise

Diese Methode erstellt die Delegaten für die nur statische Methoden.This method creates delegates for static methods only. Eine Instanzmethode handelt es sich um eine Methode, die eine Instanz einer Klasse zugeordnet ist; eine statische Methode handelt es sich um eine Methode, die die Klasse selbst zugeordnet ist.An instance method is a method that is associated with an instance of a class; a static method is a method that is associated with the class itself.

Überladung dieser Methode entspricht dem Aufrufen der CreateDelegate(Type, Type, String, Boolean, Boolean) -methodenüberladung angeben false für ignoreCase und true für throwOnBindFailure.This method overload is equivalent to calling the CreateDelegate(Type, Type, String, Boolean, Boolean) method overload, specifying false for ignoreCase and true for throwOnBindFailure.

Hinweis

Beginnend mit der .NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1, diese Methode kann verwendet werden, um nicht öffentliche Methoden zugreifen, wenn der Aufrufer erteilt wurde ReflectionPermission mit der ReflectionPermissionFlag.RestrictedMemberAccess kennzeichnen und Menge oder eine Teilmenge der Berechtigungssatz die nicht öffentliche Methoden an des Aufrufers des beschränkt ist zu gewähren davon.Starting with the .NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1, this method can be used to access non-public methods if the caller has been granted ReflectionPermission with the ReflectionPermissionFlag.RestrictedMemberAccess flag and if the grant set of the non-public methods is restricted to the caller's grant set, or a subset thereof. (Finden Sie unter Überlegungen zur Sicherheit für die Reflektion.)(See Security Considerations for Reflection.)

Zur Verwendung dieser Funktionen sollte die Anwendung für .NET Framework 3,5.NET Framework 3.5 oder höher ausgelegt sein. To use this functionality, your application should target the .NET Framework 3,5.NET Framework 3.5 or later.

Sicherheit

ReflectionPermission
Beim Aufruf spät gebundene durch Mechanismen wie z. B. InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[]).when invoked late-bound through mechanisms such as InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[]). Zugeordnete Enumeration: MemberAccessAssociated enumeration: MemberAccess.

Siehe auch

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

Erstellt einen Delegaten vom angegebenen Typ, der die angegebene statische Methode darstellen soll.Creates a delegate of the specified type to represent the specified static method.

public:
 static Delegate ^ CreateDelegate(Type ^ type, System::Reflection::MethodInfo ^ method);
public static Delegate CreateDelegate (Type type, System.Reflection.MethodInfo method);
static member CreateDelegate : Type * System.Reflection.MethodInfo -> Delegate

Parameter

type
Type Type Type

Der Type des zu erstellenden Delegaten.The Type of delegate to create.

method
MethodInfo MethodInfo MethodInfo

Die MethodInfo, die die statische Methode oder Instanzmethode beschreibt, die der Delegat darstellen soll.The MethodInfo describing the static or instance method the delegate is to represent. In .NET Framework, Version 1.0 und 1.1, werden nur statische Methoden unterstützt.Only static methods are supported in the .NET Framework version 1.0 and 1.1.

Gibt zurück

Ein Delegat vom angegebenen Typ, der die angegebene statische Methode darstellen soll.A delegate of the specified type to represent the specified static method.

Ausnahmen

type ist null.type is null.

- oder - -or- method ist null.method is null.

type erbt nicht MulticastDelegate.type does not inherit MulticastDelegate.

- oder --or- type ist keine RuntimeType.type is not a RuntimeType. Siehe Laufzeittypen in Reflektion.See Runtime Types in Reflection.

- oder --or- method ist keine statische Methode und die .NET Framework-Version ist 1.0 oder 1.1.method is not a static method, and the .NET Framework version is 1.0 or 1.1.

- oder --or- method kann nicht gebunden werden.method cannot be bound.

- oder --or- method ist keine RuntimeMethodInfo.method is not a RuntimeMethodInfo. Siehe Laufzeittypen in Reflektion.See Runtime Types in Reflection.

Die Invoke-Methode von type wurde nicht gefunden.The Invoke method of type is not found.

Der Aufrufer verfügt nicht über die erforderlichen Berechtigungen für den Zugriff auf method.The caller does not have the permissions necessary to access method.

Beispiele

Dieser Abschnitt enthält zwei Codebeispiele.This section contains two code examples. Das erste Beispiel veranschaulicht die beiden Arten von Delegaten, die Überladung dieser Methode erstellt werden können: Öffnen Sie über eine Instanzmethode und über eine statische Methode.The first example demonstrates the two kinds of delegates that can be created with this method overload: open over an instance method and open over a static method.

Im zweiten Codebeispiel wird veranschaulicht, kompatible Parametertypen und Rückgabetypen.The second code example demonstrates compatible parameter types and return types.

Beispiel 1Example 1

Im folgenden Codebeispiel wird veranschaulicht, die zwei Möglichkeiten, die ein Delegat erstellt werden kann, verwenden diese Überladung von der CreateDelegate Methode.The following code example demonstrates the two ways a delegate can be created using this overload of the CreateDelegate method.

Hinweis

Es gibt zwei Überladungen der der CreateDelegate Methode, die angeben, ein MethodInfo jedoch kein erstes Argument; ihre Funktionalität ist identisch, außer dass eine Ihnen die ermöglicht Angabe, ob bei Bindungsfehlern ausgelöst werden, und die andere löst immer eine.There are two overloads of the CreateDelegate method that specify a MethodInfo but not a first argument; their functionality is the same except that one allows you to specify whether to throw on failure to bind, and the other always throws. Dieses Codebeispiel verwendet beide Überladungen.This code example uses both overloads.

Das Beispiel deklariert eine Klasse C mit einer statischen Methode M2 und eine Instanzmethode M1, und zwei Delegattypen: D1 akzeptiert eine Instanz von C und eine Zeichenfolge, und D2 nimmt eine Zeichenfolge.The example declares a class C with a static method M2 and an instance method M1, and two delegate types: D1 takes an instance of C and a string, and D2 takes a string.

Eine zweite Klasse namens Example enthält den Code, der den Delegaten erstellt.A second class named Example contains the code that creates the delegates.

  • Ein Delegat vom Typ D1, der eine offene Instanzmethode darstellt, wird für die Instanzmethode erstellt M1.A delegate of type D1, representing an open instance method, is created for the instance method M1. Eine Instanz muss übergeben werden, wenn der Delegat aufgerufen wird.An instance must be passed when the delegate is invoked.

  • Ein Delegat vom Typ D2, eine offene statische Methode darstellt, wird für die statische Methode erstellt M2.A delegate of type D2, representing an open static method, is created for the static method M2.

using System;
using System.Reflection;
using System.Security.Permissions;

// Declare three delegate types for demonstrating the combinations
// of static versus instance methods and open versus closed
// delegates.
//
public delegate void D1(C c, string s);
public delegate void D2(string s);
public delegate void D3();

// A sample class with an instance method and a static method.
//
public class C
{
    private int id;
    public C(int id) { this.id = id; }

    public void M1(string s) 
    { 
        Console.WriteLine("Instance method M1 on C:  id = {0}, s = {1}",
            this.id, s);
    }
  
    public static void M2(string s)
    { 
        Console.WriteLine("Static method M2 on C:  s = {0}", s); 
    }
}

public class Example
{
    public static void Main()
    {
        C c1 = new C(42);

        // Get a MethodInfo for each method.
        //
        MethodInfo mi1 = typeof(C).GetMethod("M1", 
            BindingFlags.Public | BindingFlags.Instance);
        MethodInfo mi2 = typeof(C).GetMethod("M2",
            BindingFlags.Public | BindingFlags.Static);

        D1 d1;
        D2 d2;
        D3 d3;


        Console.WriteLine("\nAn instance method closed over C.");
        // In this case, the delegate and the
        // method must have the same list of argument types; use
        // delegate type D2 with instance method M1.
        //
        Delegate test = 
            Delegate.CreateDelegate(typeof(D2), c1, mi1, false);

        // Because false was specified for throwOnBindFailure 
        // in the call to CreateDelegate, the variable 'test'
        // contains null if the method fails to bind (for 
        // example, if mi1 happened to represent a method of  
        // some class other than C).
        //
        if (test != null)
        {
            d2 = (D2) test;

            // The same instance of C is used every time the 
            // delegate is invoked.
            d2("Hello, World!");
            d2("Hi, Mom!");
        }


        Console.WriteLine("\nAn open instance method.");
        // In this case, the delegate has one more 
        // argument than the instance method; this argument comes
        // at the beginning, and represents the hidden instance
        // argument of the instance method. Use delegate type D1
        // with instance method M1.
        //
        d1 = (D1) Delegate.CreateDelegate(typeof(D1), null, mi1);

        // An instance of C must be passed in each time the 
        // delegate is invoked.
        //
        d1(c1, "Hello, World!");
        d1(new C(5280), "Hi, Mom!");


        Console.WriteLine("\nAn open static method.");
        // In this case, the delegate and the method must 
        // have the same list of argument types; use delegate type
        // D2 with static method M2.
        //
        d2 = (D2) Delegate.CreateDelegate(typeof(D2), null, mi2);

        // No instances of C are involved, because this is a static
        // method. 
        //
        d2("Hello, World!");
        d2("Hi, Mom!");


        Console.WriteLine("\nA static method closed over the first argument (String).");
        // The delegate must omit the first argument of the method.
        // A string is passed as the firstArgument parameter, and 
        // the delegate is bound to this string. Use delegate type 
        // D3 with static method M2. 
        //
        d3 = (D3) Delegate.CreateDelegate(typeof(D3), 
            "Hello, World!", mi2);

        // Each time the delegate is invoked, the same string is
        // used.
        d3();
    }
}

/* This code example produces the following output:

An instance method closed over C.
Instance method M1 on C:  id = 42, s = Hello, World!
Instance method M1 on C:  id = 42, s = Hi, Mom!

An open instance method.
Instance method M1 on C:  id = 42, s = Hello, World!
Instance method M1 on C:  id = 5280, s = Hi, Mom!

An open static method.
Static method M2 on C:  s = Hello, World!
Static method M2 on C:  s = Hi, Mom!

A static method closed over the first argument (String).
Static method M2 on C:  s = Hello, World!
 */
Imports System
Imports System.Reflection
Imports System.Security.Permissions

' Declare three delegate types for demonstrating the combinations
' of Shared versus instance methods and open versus closed
' delegates.
'
Public Delegate Sub D1(ByVal c As C, ByVal s As String) 
Public Delegate Sub D2(ByVal s As String) 
Public Delegate Sub D3() 

' A sample class with an instance method and a Shared method.
'
Public Class C
    Private id As Integer
    Public Sub New(ByVal id As Integer) 
        Me.id = id
    End Sub 'New

    Public Sub M1(ByVal s As String) 
        Console.WriteLine("Instance method M1 on C:  id = {0}, s = {1}", _
            Me.id, s)
    End Sub
    
    Public Shared Sub M2(ByVal s As String) 
        Console.WriteLine("Shared method M2 on C:  s = {0}", s)
    End Sub
End Class

Public Class Example
    
    Public Shared Sub Main() 

        Dim c1 As New C(42)
        
        ' Get a MethodInfo for each method.
        '
        Dim mi1 As MethodInfo = GetType(C).GetMethod("M1", _
            BindingFlags.Public Or BindingFlags.Instance)
        Dim mi2 As MethodInfo = GetType(C).GetMethod("M2", _
            BindingFlags.Public Or BindingFlags.Static)
        
        Dim d1 As D1
        Dim d2 As D2
        Dim d3 As D3
        
        
        Console.WriteLine(vbLf & "An instance method closed over C.")
        ' In this case, the delegate and the
        ' method must have the same list of argument types; use
        ' delegate type D2 with instance method M1.
        '
        Dim test As [Delegate] = _
            [Delegate].CreateDelegate(GetType(D2), c1, mi1, False)

        ' Because False was specified for throwOnBindFailure 
        ' in the call to CreateDelegate, the variable 'test'
        ' contains Nothing if the method fails to bind (for 
        ' example, if mi1 happened to represent a method of 
        ' some class other than C).
        '
        If test IsNot Nothing Then
            d2 = CType(test, D2)

            ' The same instance of C is used every time the
            ' delegate is invoked.
            d2("Hello, World!")
            d2("Hi, Mom!")
        End If
        
        
        Console.WriteLine(vbLf & "An open instance method.")
        ' In this case, the delegate has one more 
        ' argument than the instance method; this argument comes
        ' at the beginning, and represents the hidden instance
        ' argument of the instance method. Use delegate type D1
        ' with instance method M1.
        '
        d1 = CType([Delegate].CreateDelegate(GetType(D1), Nothing, mi1), D1)
        
        ' An instance of C must be passed in each time the 
        ' delegate is invoked.
        '
        d1(c1, "Hello, World!")
        d1(New C(5280), "Hi, Mom!")
        
        
        Console.WriteLine(vbLf & "An open Shared method.")
        ' In this case, the delegate and the method must 
        ' have the same list of argument types; use delegate type
        ' D2 with Shared method M2.
        '
        d2 = CType([Delegate].CreateDelegate(GetType(D2), Nothing, mi2), D2)
        
        ' No instances of C are involved, because this is a Shared
        ' method. 
        '
        d2("Hello, World!")
        d2("Hi, Mom!")
        
        
        Console.WriteLine(vbLf & "A Shared method closed over the first argument (String).")
        ' The delegate must omit the first argument of the method.
        ' A string is passed as the firstArgument parameter, and 
        ' the delegate is bound to this string. Use delegate type 
        ' D3 with Shared method M2. 
        '
        d3 = CType([Delegate].CreateDelegate(GetType(D3), "Hello, World!", mi2), D3)
        
        ' Each time the delegate is invoked, the same string is
        ' used.
        d3()
    
    End Sub
End Class

' This code example produces the following output:
'
'An instance method closed over C.
'Instance method M1 on C:  id = 42, s = Hello, World!
'Instance method M1 on C:  id = 42, s = Hi, Mom!
'
'An open instance method.
'Instance method M1 on C:  id = 42, s = Hello, World!
'Instance method M1 on C:  id = 5280, s = Hi, Mom!
'
'An open Shared method.
'Shared method M2 on C:  s = Hello, World!
'Shared method M2 on C:  s = Hi, Mom!
'
'A Shared method closed over the first argument (String).
'Shared method M2 on C:  s = Hello, World!
' 

Beispiel 2Example 2

Im folgenden Codebeispiel wird veranschaulicht, die Kompatibilität der Parametertypen und Rückgabetypen.The following code example demonstrates compatibility of parameter types and return types.

Das Codebeispiel definiert eine Basisklasse, die mit dem Namen Base und eine Klasse namens Derived abgeleitet, die Base.The code example defines a base class named Base and a class named Derived that derives from Base. Die abgeleitete Klasse verfügt über eine static (Shared in Visual Basic) Methode, die mit dem Namen MyMethod mit einem Parameter vom Typ Base und dem Rückgabetyp der Derived.The derived class has a static (Shared in Visual Basic) method named MyMethod with one parameter of type Base and a return type of Derived. Im Codebeispiel wird definiert auch einen Delegaten, der mit dem Namen Example , die einen Parameter vom Typ hat Derived und dem Rückgabetyp der Base.The code example also defines a delegate named Example that has one parameter of type Derived and a return type of Base.

Im Codebeispiel wird veranschaulicht, dass der Delegat, mit dem Namen Example können verwendet werden, um die Methode darstellen MyMethod.The code example demonstrates that the delegate named Example can be used to represent the method MyMethod. Die Methode kann an den Delegaten gebunden werden, da:The method can be bound to the delegate because:

  • Der Parametertyp des Delegaten (Derived) ist stärker eingeschränkt als der Parametertyp des MyMethod (Base), sodass es immer sicher an das Argument des Delegaten zu übergeben sind MyMethod.The parameter type of the delegate (Derived) is more restrictive than the parameter type of MyMethod (Base), so that it is always safe to pass the argument of the delegate to MyMethod.

  • Der Rückgabetyp der MyMethod (Derived) ist stärker eingeschränkt als der Parametertyp des Delegaten (Base), sodass sie immer sicher, das den Rückgabetyp der Methode, die den Rückgabetyp des Delegaten umgewandelt werden kann.The return type of MyMethod (Derived) is more restrictive than the parameter type of the delegate (Base), so that it is always safe to cast the return type of the method to the return type of the delegate.

Im Codebeispiel erzeugt keine Ausgabe.The code example produces no output.

using namespace System;
using namespace System::Reflection;

// Define two classes to use in the demonstration, a base class and 
// a class that derives from it.
//
public ref class Base {};

public ref class Derived : Base
{
    // Define a static method to use in the demonstration. The method 
    // takes an instance of Base and returns an instance of Derived.  
    // For the purposes of the demonstration, it is not necessary for 
    // the method to do anything useful. 
    //
public:
    static Derived^ MyMethod(Base^ arg)
    {
        Base^ dummy = arg;
        return gcnew Derived();
    }
};

// Define a delegate that takes an instance of Derived and returns an
// instance of Base.
//
public delegate Base^ Example(Derived^ arg);

void main()
{
    // The binding flags needed to retrieve MyMethod.
    BindingFlags flags = BindingFlags::Public | BindingFlags::Static;

    // Get a MethodInfo that represents MyMethod.
    MethodInfo^ minfo = Derived::typeid->GetMethod("MyMethod", flags);

    // Demonstrate contravariance of parameter types and covariance
    // of return types by using the delegate Example to represent
    // MyMethod. The delegate binds to the method because the
    // parameter of the delegate is more restrictive than the 
    // parameter of the method (that is, the delegate accepts an
    // instance of Derived, which can always be safely passed to
    // a parameter of type Base), and the return type of MyMethod
    // is more restrictive than the return type of Example (that
    // is, the method returns an instance of Derived, which can
    // always be safely cast to type Base). 
    //
    Example^ ex = 
        (Example^) Delegate::CreateDelegate(Example::typeid, minfo);

    // Execute MyMethod using the delegate Example.
    //        
    Base^ b = ex(gcnew Derived());
}
using System;
using System.Reflection;

// Define two classes to use in the demonstration, a base class and 
// a class that derives from it.
//
public class Base {}

public class Derived : Base
{
    // Define a static method to use in the demonstration. The method 
    // takes an instance of Base and returns an instance of Derived.  
    // For the purposes of the demonstration, it is not necessary for 
    // the method to do anything useful. 
    //
    public static Derived MyMethod(Base arg)
    {
        Base dummy = arg;
        return new Derived();
    }
}

// Define a delegate that takes an instance of Derived and returns an
// instance of Base.
//
public delegate Base Example(Derived arg);

class Test
{
    public static void Main()
    {
        // The binding flags needed to retrieve MyMethod.
        BindingFlags flags = BindingFlags.Public | BindingFlags.Static;

        // Get a MethodInfo that represents MyMethod.
        MethodInfo minfo = typeof(Derived).GetMethod("MyMethod", flags);

        // Demonstrate contravariance of parameter types and covariance
        // of return types by using the delegate Example to represent
        // MyMethod. The delegate binds to the method because the
        // parameter of the delegate is more restrictive than the 
        // parameter of the method (that is, the delegate accepts an
        // instance of Derived, which can always be safely passed to
        // a parameter of type Base), and the return type of MyMethod
        // is more restrictive than the return type of Example (that
        // is, the method returns an instance of Derived, which can
        // always be safely cast to type Base). 
        //
        Example ex = 
            (Example) Delegate.CreateDelegate(typeof(Example), minfo);

        // Execute MyMethod using the delegate Example.
        //        
        Base b = ex(new Derived());
    }
}
Imports System
Imports System.Reflection

' Define two classes to use in the demonstration, a base class and 
' a class that derives from it.
'
Public Class Base
End Class

Public Class Derived
    Inherits Base

    ' Define a Shared method to use in the demonstration. The method 
    ' takes an instance of Base and returns an instance of Derived.  
    ' For the purposes of the demonstration, it is not necessary for 
    ' the method to do anything useful. 
    '
    Public Shared Function MyMethod(ByVal arg As Base) As Derived
        Dim dummy As Base = arg
        Return New Derived()
    End Function

End Class

' Define a delegate that takes an instance of Derived and returns an
' instance of Base.
'
Public Delegate Function Example(ByVal arg As Derived) As Base

Module Test

    Sub Main()

        ' The binding flags needed to retrieve MyMethod.
        Dim flags As BindingFlags = _
            BindingFlags.Public Or BindingFlags.Static

        ' Get a MethodInfo that represents MyMethod.
        Dim minfo As MethodInfo = _
            GetType(Derived).GetMethod("MyMethod", flags)

        ' Demonstrate contravariance of parameter types and covariance
        ' of return types by using the delegate Example to represent
        ' MyMethod. The delegate binds to the method because the
        ' parameter of the delegate is more restrictive than the 
        ' parameter of the method (that is, the delegate accepts an
        ' instance of Derived, which can always be safely passed to
        ' a parameter of type Base), and the return type of MyMethod
        ' is more restrictive than the return type of Example (that
        ' is, the method returns an instance of Derived, which can
        ' always be safely cast to type Base). 
        '
        Dim ex As Example = CType( _
            [Delegate].CreateDelegate(GetType(Example), minfo), _
            Example _
        )

        ' Execute MyMethod using the delegate Example.
        '        
        Dim b As Base = ex(New Derived())
    End Sub
End Module

Hinweise

In .NET Framework, Version 1.0 und 1.1 erstellt diese methodenüberladung Delegaten für die nur statische Methoden.In the .NET Framework version 1.0 and 1.1, this method overload creates delegates for static methods only. In .NET Framework, Version 2.0 kann diese methodenüberladung auch Instanz öffnen-methodendelegaten erstellen. Delegaten, die das ausgeblendete erste Argument von explizit angeben haben, also Instanzmethoden.In the .NET Framework version 2.0, this method overload also can create open instance method delegates; that is, delegates that explicitly supply the hidden first argument of instance methods. Eine ausführlichere Erklärung finden Sie unter die allgemeinere CreateDelegate(Type, Object, MethodInfo) methodenüberladung, um alle Kombinationen von offenen oder geschlossenen Delegaten für die Instanz oder statische Methoden zu erstellen und optional ein erstes Argument angeben können.For a detailed explanation, see the more general CreateDelegate(Type, Object, MethodInfo) method overload, which allows you to create all combinations of open or closed delegates for instance or static methods, and optionally to specify a first argument.

Hinweis

Überladung dieser Methode sollte verwendet werden, wenn der Delegat nicht über die ersten Arguments, geschlossen wird, da er in diesem Fall etwas schneller ist.This method overload should be used when the delegate is not closed over its first argument, because it is somewhat faster in that case.

Überladung dieser Methode entspricht dem Aufrufen der CreateDelegate(Type, MethodInfo, Boolean) -methodenüberladung, und geben true für throwOnBindFailure.This method overload is equivalent to calling the CreateDelegate(Type, MethodInfo, Boolean) method overload and specifying true for throwOnBindFailure.

Hinweis

Beginnend mit der .NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1, diese Methode kann verwendet werden, um nicht öffentliche Methoden zugreifen, wenn der Aufrufer erteilt wurde ReflectionPermission mit der ReflectionPermissionFlag.RestrictedMemberAccess kennzeichnen und Menge oder eine Teilmenge der Berechtigungssatz die nicht öffentliche Methoden an des Aufrufers des beschränkt ist zu gewähren davon.Starting with the .NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1, this method can be used to access non-public methods if the caller has been granted ReflectionPermission with the ReflectionPermissionFlag.RestrictedMemberAccess flag and if the grant set of the non-public methods is restricted to the caller's grant set, or a subset thereof. (Finden Sie unter Überlegungen zur Sicherheit für die Reflektion.)(See Security Considerations for Reflection.)

Zur Verwendung dieser Funktionen sollte die Anwendung für .NET Framework 3,5.NET Framework 3.5 oder höher ausgelegt sein. To use this functionality, your application should target the .NET Framework 3,5.NET Framework 3.5 or later.

Kompatible Parameter und RückgabetypenCompatible Parameter Types and Return Type

In .NET Framework, Version 2.0 müssen die Parametertypen und der Rückgabetyp eines Delegaten mit der Überladung dieser Methode erstellte kompatibel sein mit den Parametertypen und den Rückgabetyp der Methode, die der Delegat darstellt. die Typen müssen nicht genau übereinstimmen.In the .NET Framework version 2.0, the parameter types and return type of a delegate created using this method overload must be compatible with the parameter types and return type of the method the delegate represents; the types do not have to match exactly. Dies stellt eine Lockerung der Bindung-Verhalten in .NET Framework, Version 1.0 und 1.1 wird, in denen die Typen exakt übereinstimmen müssen.This represents a relaxation of the binding behavior in the .NET Framework version 1.0 and 1.1, where the types must match exactly.

Ein Parameter eines Delegaten ist mit dem entsprechenden Parameter einer Methode kompatibel, wenn der Typ des Delegatenparameters restriktiver ist als der Methodenparameter, da so gewährleistet ist, dass ein an den Delegaten übergebenes Argument problemlos an die Methode weitergeleitet werden kann.A parameter of a delegate is compatible with the corresponding parameter of a method if the type of the delegate parameter is more restrictive than the type of the method parameter, because this guarantees that an argument passed to the delegate can be passed safely to the method.

Ebenso ist der Rückgabetyp eines Delegaten kompatibel mit dem Rückgabetyp einer Methode, wenn der Rückgabetyp der Methode restriktiver ist als der Rückgabetyp des Delegaten, da so gewährleistet ist, dass der Rückgabewert der Methode problemlos in den Rückgabetyp des Delegaten umgewandelt werden kann.Similarly, the return type of a delegate is compatible with the return type of a method if the return type of the method is more restrictive than the return type of the delegate, because this guarantees that the return value of the method can be cast safely to the return type of the delegate.

Angenommen, ein Delegat mit einem Parameter vom Typ Hashtable und dem Rückgabetyp der Object kann eine Methode mit einem Parameter des Typs darstellen Object sowie einen Rückgabewert vom Typ Hashtable.For example, a delegate with a parameter of type Hashtable and a return type of Object can represent a method with a parameter of type Object and a return value of type Hashtable.

Sicherheit

ReflectionPermission
Beim Aufruf spät gebundene durch Mechanismen wie z. B. InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[]).when invoked late-bound through mechanisms such as InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[]). Zugeordnete Enumeration: MemberAccessAssociated enumeration: MemberAccess.

Siehe auch

Gilt für: