Exportieren (0) Drucken
Alle erweitern
Dieser Artikel wurde maschinell übersetzt. Bewegen Sie den Mauszeiger über die Sätze im Artikel, um den Originaltext anzuzeigen. Weitere Informationen
Übersetzung
Original

Delegate.CreateDelegate-Methode (Type, MethodInfo)

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
Typ: System.Type
Der Type des zu erstellenden Delegaten.
method
Typ: System.Reflection.MethodInfo
Die MethodInfo, die die statische 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

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

AusnahmeBedingung
ArgumentNullException

type ist null.

- oder -

method ist null.

ArgumentException

type erbt nicht MulticastDelegate.

- oder -

type ist kein RuntimeType. Siehe Laufzeittypen in Reflexion.

- 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. Siehe Laufzeittypen in Reflexion.

MissingMethodException

Die Invoke-Methode von type wurde nicht gefunden.

MethodAccessException

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

In .NET Framework, Version 1.0 und 1.1, erstellt diese Methodenüberladung Delegaten nur für statische Methoden. In .NET Framework, Version 2.0, kann diese Methodenüberladung außerdem Delegaten für offene Instanzmethoden erstellen, d. h., Delegaten, die das verborgene erste Argument von Instanzmethoden explizit bereitstellen. Eine ausführliche Erläuterung finden Sie unter der allgemeineren CreateDelegate(Type, Object, MethodInfo)-Methodenüberladung, die es erlaubt, alle Kombinationen aus offenen und geschlossenen Delegaten für Instanzmethoden oder statische Methoden zu erstellen und optional ein erstes Argument anzugeben.

HinweisHinweis

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

Diese Methodenüberladung entspricht dem Aufrufen der CreateDelegate(Type, MethodInfo, Boolean)-Methodenüberladung und dem Angeben von true für throwOnBindFailure.

HinweisHinweis

Ab .NET Framework 2.0 Service Pack 1 kann diese Methode verwendet werden, um auf nicht öffentliche Methoden zuzugreifen, wenn dem Aufrufer ReflectionPermission mit dem ReflectionPermissionFlag.RestrictedMemberAccess-Flag gewährt wurden und der Berechtigungssatz der nicht öffentlichen Methoden auf den Berechtigungssatz des Aufrufers oder auf eine Teilmenge dieses Berechtigungssatzes beschränkt ist. (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.

Kompatible Parametertypen und kompatibler Rückgabetyp

In .NET Framework, Version 2.0, müssen die mit dieser Methodenüberladung erstellten Parametertypen und der Rückgabetyp eines Delegaten mit den Parametertypen und dem Rückgabetyp der Methode, die der Delegat darstellt, kompatibel sein. Die Typen müssen nicht genau übereinstimmen. Dies entspricht einer Lockerung des Bindungsverhaltens in .NET Framework, Version 1.0 und 1.1, für das 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.

Beispielsweise kann ein Delegat mit dem Parametertyp Hashtable und dem Rückgabetyp Object eine Methode mit dem Parametertyp Object und dem Rückgabetyp Hashtable darstellen.

Dieser Abschnitt enthält zwei Codebeispiele. Im ersten Beispiel werden die beiden Arten von Delegaten veranschaulicht, die mit dieser Methodenüberladung erstellt werden können: offen über einer Instanzmethode und offen über einer statischen Methode.

Im zweiten Codebeispiel werden kompatible Parametertypen und Rückgabetypen veranschaulicht.

Beispiel 1

Im folgenden Codebeispiel werden die beiden Arten veranschaulicht, auf die ein Delegat mit dieser Überladung der CreateDelegate-Methode erstellt werden kann.

HinweisHinweis

Für die CreateDelegate-Methode sind zwei Überladungen vorhanden, die eine MethodInfo, aber kein erstes Argument angeben. Sie besitzen die gleiche Funktion, mit dem Unterschied, dass bei der einen angegeben werden kann, ob ein Bindungsfehler ausgelöst werden soll, der bei der anderen immer ausgelöst wird. In diesem Codebeispiel werden beide Überladungen verwendet.

Im Beispiel werden die Klasse C mit der statischen Methode M2 und der Instanzmethode M1 sowie zwei Delegattypen deklariert: D1 akzeptiert eine Instanz von C und eine Zeichenfolge, D2 akzeptiert eine Zeichenfolge.

Eine zweite Klasse mit dem Namen Example enthält den Code, in dem die Delegaten erstellt werden.

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

  • Ein Delegat des Typs D2, der eine offene statische Methode darstellt, wird für die statische Methode M2 erstellt.


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 die Kompatibilität von Parametertypen und Rückgabetypen veranschaulicht.

In diesem Codebeispiel wird eine Basisklasse mit dem Namen Base und eine Klasse mit dem Namen Derived definiert, die von Base abgeleitet ist. Die abgeleitete Klasse besitzt eine static-Methode (Shared in Visual Basic) mit dem Namen MyMethod und einem Parameter vom Typ Base sowie dem Rückgabetyp Derived. Im Codebeispiel wird außerdem ein Delegat mit dem Namen Example definiert, der einen Parameter vom Typ Derived und den Rückgabetyp Base besitzt.

Im Codebeispiel wird veranschaulicht, dass der Delegat mit dem Namen Example verwendet werden kann, um die Methode MyMethod darzustellen. Die Methode kann aus folgenden Gründen an den Delegaten gebunden werden:

  • Der Parametertyp des Delegaten (Derived) ist stärker eingeschränkt als der Parametertyp von MyMethod (Base), sodass das Argument des Delegaten immer sicher an MyMethod übergeben werden kann.

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

Im Codebeispiel wird keine Ausgabe erzeugt.


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


.NET Framework

Unterstützt in: 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Unterstützt in: 4, 3.5 SP1

Portable Klassenbibliothek

Unterstützt in: Portable Klassenbibliothek

.NET für Windows Phone-Apps

Unterstützt in: Windows Phone 8, Silverlight 8.1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (Server Core-Rolle wird nicht unterstützt), Windows Server 2008 R2 (Server Core-Rolle wird mit SP1 oder höher unterstützt; Itanium wird nicht unterstützt)

.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen für .NET Framework.

Community-Beiträge

HINZUFÜGEN
Anzeigen:
© 2015 Microsoft