Dieser Artikel wurde maschinell übersetzt. Wenn Sie die englische Version des Artikels anzeigen möchten, aktivieren Sie das Kontrollkästchen Englisch. Sie können den englischen Text auch in einem Popupfenster anzeigen, indem Sie den Mauszeiger über den Text bewegen.
Übersetzung
Englisch

Delegate.CreateDelegate-Methode: (Type, MethodInfo)

 

Veröffentlicht: Oktober 2016

Erstellt einen Delegaten vom angegebenen Typ, der die angegebene statische Methode darstellen soll.

Namespace:   System
Assembly:  mscorlib (in mscorlib.dll)

public static Delegate CreateDelegate(
	Type type,
	MethodInfo method
)

Parameter

type
Type: System.Type

Der Type des zu erstellenden Delegaten.

method
Type: System.Reflection.MethodInfo

Die MethodInfo, die die statische Methode oder Instanzmethode beschreibt, die der Delegat darstellen soll. In .NET Framework, Version 1.0 und 1.1, werden nur statische Methoden unterstützt.

Rückgabewert

Type: System.Delegate

Ein Delegat vom angegebenen Typ, der die angegebene statische Methode darstellen soll.

Exception Condition
ArgumentNullException

type ist null.

- oder -

method ist null.

ArgumentException

type erbt nicht MulticastDelegate.

- oder -

type ist keine RuntimeType. Finden Sie unter Laufzeittypen in Reflektion.

- oder -

method ist keine statische Methode und die .NET Framework-Version ist 1.0 oder 1.1.

- oder -

method kann nicht gebunden werden.

- oder -

method ist keine RuntimeMethodInfo. Finden Sie unter Laufzeittypen in Reflektion.

MissingMethodException

Die Invoke-Methode von type wurde nicht gefunden.

MethodAccessException

Der Aufrufer verfügt nicht über die erforderlichen Berechtigungen für den Zugriff auf method.

In .NET Framework, Version 1.0 und 1.1 erstellt diese methodenüberladung Delegate für nur statische Methoden. In .NET Framework, Version 2.0 kann diese methodenüberladung auch offenen Instanz Methode Delegaten erstellen. d. h. Instanz Delegaten, die explizit, das verborgene erste Argument der angeben Methoden. Eine ausführliche Erläuterung finden Sie unter die allgemeinere CreateDelegate(Type, Object, MethodInfo) methodenüberladung, dem Sie alle Kombinationen von offenen und geschlossenen Delegaten für die Instanz oder statische Methoden und optional ein erstes Argument angeben kann.

System_CAPS_noteHinweis

Diese methodenüberladung sollte verwendet werden, wenn der Delegat nicht über dem ersten Argument geschlossen wird, da in diesem Fall etwas schneller ist.

Überladung dieser Methode entspricht dem Aufrufen der CreateDelegate(Type, MethodInfo, Boolean) methodenüberladung und Angeben von true für throwOnBindFailure.

System_CAPS_noteHinweis

Beginnend mit der .NET Framework 2.0 Service Pack 1, diese Methode kann verwendet werden, auf nicht öffentliche Methoden zuzugreifen, wenn der Aufrufer erteilt wurde ReflectionPermission mit dem ReflectionPermissionFlag.RestrictedMemberAccess kennzeichnen und erteilen Sie der Berechtigungssatz für die nicht öffentlichen Methoden an des Aufrufers beschränkt ist Set- oder eine Teilmenge davon. (Siehe Sicherheitsüberlegungen für die Reflektion.)

Zur Verwendung dieser Funktionen sollte die Anwendung für .NET Framework 3.5 oder höher ausgelegt sein.

In .NET Framework, Version 2.0 muss die Parametertypen und den Rückgabetyp eines Delegaten mit der Überladung dieser Methode erstellt kompatibel mit den Parametertypen und den Rückgabetyp der Methode, die der Delegat darstellt; die Typen müssen nicht exakt übereinstimmen. Dies stellt eine Lockerung der das Bindungsverhalten in .NET Framework, Version 1.0 und 1.1, bei denen die Typen genau übereinstimmen müssen.

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.

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.

Angenommen, ein Delegat mit einem Parameter vom Typ Hashtable und dem Rückgabetyp des Object kann eine Methode mit einem Parameter vom Typ darstellen Object sowie einen Rückgabewert vom Typ Hashtable.

Dieser Abschnitt enthält zwei Codebeispiele. Das erste Beispiel veranschaulicht die zwei Arten von Delegaten, die Überladung dieser Methode erstellt werden können: Öffnen Sie über eine Instanzmethode und über eine statische Methode.

Im zweiten Codebeispiel wird veranschaulicht, kompatible Parametertypen und Rückgabetypen.

Beispiel 1

Im folgenden Codebeispiel wird veranschaulicht, die zwei Möglichkeiten, ein Delegaten erstellt werden kann, verwenden diese Überladung von, der CreateDelegate Methode.

System_CAPS_noteHinweis

Es gibt zwei Überladungen der der CreateDelegate Methode, die angeben, ein MethodInfo jedoch kein erstes Argument; ihre Funktionalität ist identisch, außer dass Ihnen die ermöglicht Angabe, ob bei Bindungsfehlern ausgelöst, und die andere immer löst. Dieses Codebeispiel verwendet beide Überladungen.

Im Beispiel wird eine Klasse deklariert C mit einer statischen Methode M2 und eine Instanzenmethode M1, und zwei Delegattypen: D1 akzeptiert eine Instanz von C und eine Zeichenfolge, und D2 nimmt eine Zeichenfolge.

Eine zweite Klasse Example enthält den Code, der den Delegaten erstellt.

  • Ein Delegat des Typs D1, der eine offene Instanzmethode darstellt, wird für die Instanzmethode erstellt M1. Eine Instanz muss übergeben werden, wenn der Delegat aufgerufen wird.

  • Ein Delegat des Typs D2, eine offene statische Methode darstellt, wird für die statische Methode erstellt 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!
 */

Beispiel 2

Im folgenden Codebeispiel wird veranschaulicht, die Kompatibilität der Parametertypen und Rückgabetypen.

Das Codebeispiel definiert eine Basisklasse, die mit dem Namen Base und eine Klasse namens Derived abgeleitet, die Base. Die abgeleitete Klasse verfügt über eine static (Shared in Visual Basic) Methode mit dem Namen MyMethod mit einem Parameter vom Typ Base und dem Rückgabetyp der Derived. Das Codebeispiel definiert auch einen Delegaten mit dem Namen Example , die einen Parameter des Typs hat Derived und dem Rückgabetyp der Base.

Im Codebeispiel wird veranschaulicht, dass der Delegat mit dem Namen Example können verwendet werden, um die Methode darstellen MyMethod. Die Methode kann an den Delegaten gebunden werden, da:

  • Der Parametertyp des Delegaten (Derived) ist stärker eingeschränkt als der Parametertyp der MyMethod (Base), sodass es immer sicher, das Argument des Delegaten zu übergeben sind MyMethod.

  • Der Rückgabetyp der MyMethod (Derived) ist stärker eingeschränkt als der Parametertyp des Delegaten (Base), sodass immer den Rückgabetyp der Methode in den Rückgabetyp des Delegaten umgewandelt werden kann.

Das Codebeispiel erzeugt keine Ausgabe.

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());
    }
}

ReflectionPermission

for accessing a non-public method when the grant set of the non-public method is restricted to the caller's grant set, or a subset thereof. Associated enumeration: F:System.Security.Permissions.ReflectionPermissionFlag.RestrictedMemberAccess

ReflectionPermission

for accessing a non-public method regardless of its grant set. Associated enumeration: F:System.Security.Permissions.ReflectionPermissionFlag.MemberAccess

ReflectionPermission

when invoked late-bound through mechanisms such as M:System.Type.InvokeMember(System.String,System.Reflection.BindingFlags,System.Reflection.Binder,System.Object,System.Object[],System.Reflection.ParameterModifier[],System.Globalization.CultureInfo,System.String[]). Associated enumeration: F:System.Security.Permissions.ReflectionPermissionFlag.MemberAccess.

.NET Framework
Verfügbar seit 1.1
Portierbare Klassenbibliothek
Unterstützt in: portierbare .NET-Plattformen
Silverlight
Verfügbar seit 2.0
Windows Phone Silverlight
Verfügbar seit 7.0
Zurück zum Anfang
Anzeigen: