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

Delegate.CreateDelegate-Methode (Type, Object, MethodInfo)

Erstellt einen Delegaten vom angegebenen Typ, der die angegebene statische Methode oder Instanzmethode mit dem angegebenen ersten Argument darstellt.

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

public static Delegate CreateDelegate(
	Type type,
	Object firstArgument,
	MethodInfo method
)

Parameter

type
Typ: System.Type
Der Type des zu erstellenden Delegaten.
firstArgument
Typ: System.Object
Das Objekt, an das der Delegat gebunden ist, oder null, um method als static (Shared in Visual Basic) zu behandeln.
method
Typ: System.Reflection.MethodInfo
Die MethodInfo, die die statische oder Instanzmethode beschreibt, die der Delegat darstellen soll.

Rückgabewert

Typ: System.Delegate
Ein Delegat vom angegebenen Typ, der die angegebene statische Methode oder Instanzmethode darstellt.

AusnahmeBedingung
ArgumentNullException

type hat den Wert null.

– oder –

method hat den Wert null.

ArgumentException

type vererbt MulticastDelegate nicht.

- oder -

type ist kein RuntimeType. Weitere Informationen finden Sie unter Laufzeittypen in Reflexion.

- oder -

method kann nicht gebunden werden.

- oder -

method ist kein RuntimeMethodInfo. Weitere Informationen finden Sie unter 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.

Das Aufrufen dieser Methodenüberladung entspricht dem Aufrufen der CreateDelegate(Type, Object, MethodInfo, Boolean)-Methodenüberladung und dem Angeben von true für throwOnBindFailure. Diese beiden Überladungen bieten die flexibelste Möglichkeit, Delegaten zu erstellen. Sie können diese verwenden, um Delegaten für statische Methoden oder Instanzmethoden zu erstellen und optional das erste Argument anzugeben.

HinweisHinweis

Wenn Sie kein erstes Argument angeben, verwenden Sie aus Gründen der besseren Leistung die CreateDelegate(Type, MethodInfo)-Methodenüberladung.

Der Delegattyp und die Methode müssen über kompatible Rückgabetypen verfügen. Das heißt, der Rückgabetyp von method muss dem Rückgabetyp type zugewiesen werden können.

Wenn firstArgument angegeben wird, wird es bei jedem Aufruf des Delegaten an method übergeben. firstArgument wird als an den Delegaten gebunden bezeichnet, und der Delegat wird als über dem ersten Argument geschlossen bezeichnet. Wenn methodstatic (Shared in Visual Basic) ist, enthält die beim Aufrufen des Delegaten angegebene Argumentliste alle Parameter mit Ausnahme des ersten. Wenn method eine Instanzmethode ist, wird firstArgument an den (durch this in C# oder Me in Visual Basic dargestellten) verborgenen Instanzparameter übergeben.

Wenn firstArgument angegeben wird, muss der erste Parameter von method ein Referenztyp sein, und firstArgument muss zu diesem Typ kompatibel sein.

Wichtiger HinweisWichtig

Wenn methodstatic (Shared in Visual Basic) ist und ihr erster Parameter vom Typ Object oder ValueType ist, kann firstArgument ein Werttyp sein. In diesem Fall wird firstArgument automatisch eingeschlossen. Automatisches Boxing wird für keines der anderen Argumente ausgeführt, wie es in einem C#- Visual Basic-Funktionsaufruf der Fall ist.

Wenn firstArgument ein NULL-Verweis ist und method eine Instanzmethode ist, hängt das Ergebnis von den Signaturen des Delegattypen type und der method ab:

  • Wenn die Signatur von type explizit den ersten verborgenen Parameter von method enthält, wird vom Delegaten gesagt, dass er eine offene Instanzmethode darstellt. Wenn der Delegat aufgerufen wird, wird das erste Argument in der Argumentliste an den verborgenen Instanzparameter von method übergeben.

  • Wenn die Signaturen von method und type übereinstimmen (d. h., alle Parametertypen sind kompatibel), wird vom Delegaten gesagt, dass er über einem NULL-Verweis geschlossen ist. Das Aufrufen des Delegaten entspricht dem Aufrufen einer Instanzmethode für eine NULL-Instanz, was jedoch wenig sinnvoll ist.

Wenn firstArgument ein NULL-Verweis ist und method statisch ist, hängt das Ergebnis von den Signaturen des Delegattypen type und der method ab:

  • Wenn die Signatur von method und type übereinstimmt (d. h., alle Parametertypen sind kompatibel), wird vom Delegaten gesagt, dass er eine offene statische Methode darstellt. Dies ist der häufigste Fall für statische Methoden. In diesem Fall können Sie eine etwas bessere Leistung erzielen, indem Sie die CreateDelegate(Type, MethodInfo)-Methodenüberladung verwenden.

  • Wenn die Signatur von type mit dem zweiten Parameter von method beginnt und die verbleibenden Parametertypen kompatibel sind, dann wird vom Delegaten gesagt, dass er über einem NULL-Verweis geschlossen ist. Wenn der Delegat aufgerufen wird, wird ein NULL-Verweis an den ersten Parameter von methodübergeben.

HinweisHinweis

Ab .NET Framework Version 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. (Weitere Informationen finden Sie unter Sicherheitsüberlegungen für die Reflektion.)

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

Kompatible Parametertypen und kompatibler Rückgabetyp

Die Parametertypen und der Rückgabetyp eines Delegaten muss mit den Parametertypen und dem Rückgabetyp der Methode kompatibel sein, die der Delegat darstellt. Die Typen müssen nicht genau übereinstimmen.

HinweisHinweis

In .NET Framework, Version 1.0 und 1.1, müssen die Typen genau übereinstimmen.

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.

Bestimmen der Methoden, die ein Delegat darstellen kann

Die von dieser Überladung von CreateDelegate ermöglichte Flexibilität lässt sich auch so verstehen, dass jeder angegebene Delegat vier verschiedene Kombinationen aus Methodensignatur und Methodenart (statisch oder Instanz) darstellen kann. Betrachten Sie einen Delegattyp D mit einem Argument des Typs C. Im Folgenden werden die Methoden beschrieben, die D darstellen kann, wobei der Rückgabetyp ignoriert wird, da er in allen Fällen übereinstimmen muss:

  • D kann eine beliebige Instanzmethode mit genau einem Argument vom Typ C darstellen, unabhängig vom Typ, dem die Instanzmethode angehört. Wenn CreateDelegate aufgerufen wird, ist firstArgument eine Instanz des Typs, dem method angehört, und vom resultierenden Delegaten wird gesagt, dass er über dieser Instanz geschlossen ist. (Im Grunde kann D auch über einem NULL-Verweis geschlossen sein, wenn firstArgument ein NULL-Verweis ist.)

  • D kann eine Instanzmethode von C darstellen, die über keine Argumente verfügt. Wenn CreateDelegate aufgerufen wird, ist firstArgument ein NULL-Verweis. Der resultierende Delegat stellt eine offene Instanzmethode dar, und eine Instanz von C muss bei jedem Aufruf angegeben werden.

  • D kann eine statische Methode darstellen, die ein Argument vom Typ C akzeptiert, und die Methode kann zu einem beliebigen Typ gehören. Wenn CreateDelegate aufgerufen wird, ist firstArgument ein NULL-Verweis. Der resultierende Delegat stellt eine offene statische Methode dar, und eine Instanz von C muss bei jedem Aufruf angegeben werden.

  • D kann eine statische Methode darstellen, die zum Typ F gehört und zwei Argumente besitzt, eines vom Typ F und eines vom Typ C. Wenn CreateDelegate aufgerufen wird, ist firstArgument eine Instanz von F. Der resultierende Delegat stellt eine statische Methode dar, die über dieser Instanz von F geschlossen ist. Beachten Sie, dass in dem Fall, dass F und C den gleichen Typ besitzen, die statische Methode zwei Argumente von diesem Typ besitzt. (In diesem Fall ist D über einem NULL-Verweis geschlossen, wenn firstArgument ein NULL-Verweis ist.)

Dieser Abschnitt enthält drei Codebeispiele. Im ersten Beispiel werden die vier Arten von Delegaten veranschaulicht, die erstellt werden können: geschlossen über einer Instanzmethode, offen über einer Instanzmethode, offen über einer statische Methode und geschlossen über einer statischen Methode.

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

Im dritten Codebeispiel wird ein einzelner Delegattyp definiert, und es werden alle Methoden veranschaulicht, die dieser Delegattyp darstellen kann.

Beispiel 1

Im folgenden Codebeispiel werden die vier 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 ein firstArgument und eine MethodInfo 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, und D3 akzeptiert keine Argumente.

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

  • Ein Delegat des Typs D2, der über einer Instanz von C geschlossen ist, wird für die Instanzmethode M1 erstellt. Sie wird mit unterschiedlichen Zeichenfolgen aufgerufen, um zu veranschaulichen, dass die gebundene Instanz von C immer verwendet wird.

  • 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.

  • Schließlich wird ein Delegat des Typs D3, der über einer Zeichenfolge geschlossen ist, für die statische Methode M2 erstellt. Die Methode wird aufgerufen, um zu veranschaulichen, dass die gebundene Zeichenfolge verwendet wird.


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.

HinweisHinweis

Dieses Codebeispiel verwendet die CreateDelegate(Type, MethodInfo)-Methodenüberladung. Die Verwendung anderer Überladungen, die MethodInfo akzeptieren, ist ähnlich.

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


Beispiel 3

Im folgenden Codebeispiel werden alle Methoden veranschaulicht, die ein einzelner Delegattyp darstellen kann. Dabei wird zum Erstellen der Delegaten die CreateDelegate-Methode verwendet.

HinweisHinweis

Für die CreateDelegate-Methode sind zwei Überladungen vorhanden, die ein firstArgument und eine MethodInfo 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 Codebeispiel werden die beiden Klassen C und F und ein Delegattyp D mit einem Argument vom Typ C definiert. Die Klassen besitzen die übereinstimmenden statischen und Instanzmethoden M1, M3 and M4, und die Klasse C besitzt ebenfalls eine Instanzmethode M2, die keine Argumente besitzt.

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

  • Delegaten werden für die Instanzmethode M1 vom Typ C und Typ F erstellt, die jeweils über einer Instanz des entsprechenden Typs geschlossen sind. Die Methode M1 des Typs C zeigt die ID-Eigenschaften der gebundenen Instanz und des Arguments an.

  • Ein Delegat wird für die Methode M2 des Typs C erstellt. Dies ist ein offener Instanzdelegat, in dem das Argument des Delegaten das verborgene erste Argument für die Instanzmethode darstellt. Die Methode verfügt über keine anderen Argumente. Sie wird wie eine statische Methode aufgerufen.

  • Delegaten werden für die statischen Methoden M3 des Typs C und des Typs F erstellt, bei denen es sich um offene statische Delegaten handelt.

  • Schließlich werden Delegaten für die statischen Methoden M4 des Typs C und des Typs F erstellt. Jede Methode besitzt als erstes Argument den deklarierenden Typ, und eine Instanz des Typs wird angegeben, damit die Delegaten über dem ersten Argument geschlossen sind. Die Methode M4 des Typs C zeigt die ID-Eigenschaften der gebundenen Instanz und des Arguments an.


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
*/


.NET Framework

Unterstützt in: 4, 3.5, 3.0, 2.0

.NET Framework Client Profile

Unterstützt in: 4, 3.5 SP1

Unterstützt in:

Windows 7, Windows Vista SP1 oder höher, Windows XP SP3, Windows XP SP2 x64 Edition, Windows Server 2008 (Server Core wird nicht unterstützt), Windows Server 2008 R2 (Server Core wird mit SP1 oder höher unterstützt), Windows Server 2003 SP2

.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:
© 2014 Microsoft