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, Object, MethodInfo)

 

Veröffentlicht: Oktober 2016

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 Shared Function CreateDelegate (
	type As Type,
	firstArgument As Object,
	method As MethodInfo
) As Delegate

Parameter

type
Type: System.Type

Der Type des zu erstellenden Delegaten.

firstArgument
Type: System.Object

Das Objekt, an das der Delegat gebunden ist, oder null, um method als static (Shared in Visual Basic) zu behandeln.

method
Type: System.Reflection.MethodInfo

Die MethodInfo, die die statische Methode oder Instanzmethode beschreibt, die der Delegat darstellen soll.

Rückgabewert

Type: System.Delegate

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

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

Das Aufrufen dieser methodenüberladung entspricht dem Aufrufen der CreateDelegate(Type, Object, MethodInfo, Boolean) methodenüberladung und Angeben von true für throwOnBindFailure. Diese zwei Überladungen bereitstellen, die flexibelste Möglichkeit zum Erstellen von Delegaten. Sie können Delegaten für statische oder Instanzmethoden zu erstellen und optional an das erste Argument verwenden.

System_CAPS_noteHinweis

Wenn Sie ein erstes Argument nicht angeben, verwenden Sie die CreateDelegate(Type, MethodInfo) methodenüberladung für eine bessere Leistung.

Der Delegattyp und die Methode müssen kompatibel Rückgabetypen aufweisen. D. h., der Rückgabetyp der method muss der Rückgabetyp der zugewiesen werden type.

Wenn firstArgument wird angegeben, erfolgt eine Übergabe an method jedes Mal, wenn der Delegat aufgerufen wird. firstArgument gilt als an den Delegaten gebunden werden und der Delegat wird als über das erste Argument geschlossen werden. Wenn method ist static (Shared in Visual Basic), wird das Argument beim Aufrufen des Delegaten bereitgestellte Liste enthält alle Parameter außer der ersten; aus, wenn method eine Instanzmethode ist, dann ist firstArgument an der ausgeblendeten Instanzparameter übergeben wird (dargestellte this in c# oder durch Me in Visual Basic).

Wenn firstArgument angegeben wird, der erste Parameter der method muss ein Verweistyp sein und firstArgument muss mit diesem Typ kompatibel sein.

System_CAPS_importantWichtig

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. In diesem Fall firstArgument automatisch mittels Boxing konvertiert. Automatische Boxing erfolgt für alle anderen Argumente nicht, wie es in einem C#- oder Visual Basic-Funktion aufrufen.

Wenn firstArgument ist ein null-Verweis und method eine Instanzmethode ist, ist das Ergebnis hängt von den Signaturen des Delegattyps type und method:

  • Wenn die Signatur der type explizit schließt ausgeblendete ersten Parameters der method, Delegaten gesagt, dass eine offene Instanzmethode darstellt. Wenn der Delegat aufgerufen wird, wird das erste Argument in der Argumentliste übergeben, auf den ausgeblendeten Instanzparameter method.

  • Wenn die Signaturen der method und type entsprechen (d. h., alle Parametertypen sind kompatibel), und klicken Sie dann der Delegaten gesagt, dass er über ein null-Verweis geschlossen werden. Aufrufen des Delegaten entspricht dem Aufrufen einer Instanzmethode auf eine null-Instanz, die eine besonders nützlich, wenn man nicht ist.

Wenn firstArgument ist ein null-Verweis und method ist statisch, das Ergebnis hängt von den Signaturen des Delegattyps type und method:

  • Wenn die Signatur der method und type entsprechen (d. h., alle Parametertypen sind kompatibel), der Delegat wird als eine offene statische Methode darstellen. Dies ist der häufigste Fall für statische Methoden. In diesem Fall erhalten Sie eine etwas bessere Leistung mithilfe der CreateDelegate(Type, MethodInfo) -methodenüberladung.

  • Wenn die Signatur der type beginnt mit der zweite Parameter der method der Rest der Parametertypen kompatibel sind, und der Delegat wird als über ein null-Verweis geschlossen werden. Wenn der Delegat aufgerufen wird, wird ein null-Verweis auf den ersten Parameter übergeben method.

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.

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

System_CAPS_noteHinweis

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.

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.

Eine andere hilfreiche Möglichkeit, um die Flexibilität, die von dieser Überladung von vorstellen CreateDelegate darin, dass jeder angegebene Delegat vier verschiedene Kombinationen der Methodensignatur und die Methodenart (statisch oder Instanz) darstellen kann. Betrachten Sie einen Delegattyp D mit einem Argument des Typs C. Im folgenden werden die Methoden beschrieben D darstellen kann, wird den Rückgabetyp wird ignoriert, da es in allen Fällen entsprechen muss:

  • Dkann Instanzmethode mit genau ein Argument des Typs darstellen C, unabhängig davon, welchen Typ die Instanzmethode angehört. Wenn CreateDelegate aufgerufen wird, firstArgument ist eine Instanz des Typs method gehört, und der resultierende Delegat herrscht die verbreitete über diese Instanz geschlossen werden. (Trivial, D kann auch über ein null-Verweis geschlossen werden, wenn firstArgument ein null-Verweis ist.)

  • Dkann eine Instanzmethode darstellen C , die keine Argumente verfügt. Wenn CreateDelegate aufgerufen wird, firstArgument ist ein null-Verweis. Der resultierende Delegat stellt eine offene Instanz-Methode und einer Instanz von C muss angegeben werden, bei jedem Aufruf erfolgte.

  • Deine statische Methode, die ein Argument des Typs darstellen kann C, und dass die Methode auf einen beliebigen Typ angehören kann. Wenn CreateDelegate aufgerufen wird, firstArgument ist ein null-Verweis. Der resultierende Delegat stellt eine offene statische Methode und einer Instanz von C muss angegeben werden, bei jedem Aufruf erfolgte.

  • Dkann eine statische Methode, die zum Typ gehört darstellen F und verfügt über zwei Argumente, des Typs F und Typ C. Wenn CreateDelegate aufgerufen wird, firstArgument ist eine Instanz der F. Der resultierende Delegat stellt eine statische Methode, die über diese Instanz geschlossen wird F. Beachten Sie, dass im Fall, in dem F und C denselben Typ aufweisen, der die statische Methode verfügt über zwei Argumente des Typs. (In diesem Fall D ist über ein null-Verweis geschlossen, wenn firstArgument ein null-Verweis ist.)

Dieser Abschnitt enthält drei Codebeispiele. Das erste Beispiel veranschaulicht die vier Arten von Delegaten, die erstellt werden können: über eine Instanzmethode ist, öffnen Sie über eine Instanzmethode ist, öffnen Sie über eine statische Methode geschlossen und über eine statische Methode geschlossen.

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

Das dritte Codebeispiel definiert einen einzelne Delegattyp und zeigt, dass alle Methoden, die Delegattyp darstellen können.

Beispiel 1

Im folgenden Codebeispiel wird veranschaulicht, der ein Delegaten erstellt werden kann, verwenden diese Überladung von vier Arten der CreateDelegate Methode.

System_CAPS_noteHinweis

Es gibt zwei Überladungen der CreateDelegate Methode, die angeben firstArgument und ein MethodInfo; 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, sowie drei Delegattypen: D1 akzeptiert eine Instanz von C und eine Zeichenfolge, D2 nimmt eine Zeichenfolge, und D3 besitzt keine Argumente.

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

  • Ein Delegat des Typs D2, über eine Instanz des geschlossenen C, wird für die Instanzmethode erstellt M1. Wird aufgerufen, mit anderen Zeichenfolgen, um anzugeben, dass die gebundene Instanz von C immer verwendet wird.

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

  • Schließlich, einen Delegaten vom Typ D3, geschlossen, die über eine Zeichenfolge, für die statische Methode erstellt M2. Die Methode wird aufgerufen, um anzuzeigen, dass die gebundene Zeichenfolge verwendet.

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 'NewNew

    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 2

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

System_CAPS_noteHinweis

Dieses Codebeispiel verwendet die CreateDelegate(Type, MethodInfo) -methodenüberladung. Die Verwendung der anderen Überladungen dieser MethodInfo ähnelt.

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.

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 3

Das folgende Codebeispiel zeigt alle Methoden ein einzelner Delegattyp darstellen kann, mithilfe der CreateDelegate Methode, um den Delegaten zu erstellen.

System_CAPS_noteHinweis

Es gibt zwei Überladungen der CreateDelegate Methode, die angeben firstArgument und ein MethodInfo; 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 Codebeispiel werden zwei Klassen definiert C und F, und ein Delegattyp D mit einem Argument des Typs C. Die Klassen übereinstimmende statische und Instanzmethoden M1, M3, und M4, und die Klasse C verfügt auch über eine Instanzmethode M2 , die keine Argumente verfügt.

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

  • Delegaten werden erstellt, z. B. Methode M1 des Typs C und Typ F; jede über eine Instanz des entsprechenden Typs geschlossen wird. Methode M1 des Typs C zeigt die ID Eigenschaften der gebundenen Instanz und des Arguments.

  • Ein Delegat wird für die Methode erstellt M2 vom Typ C. Dies ist eine offene Instanz Delegaten, in dem das Argument des Delegaten als ausgeblendete erste Argument in der Instanzmethode darstellt. Die Methode hat keine anderen Argumente. Sie wird aufgerufen, als wäre er eine statische Methode.

  • Delegaten werden für die statische Methode erstellt M3 des Typs C und Typ F; Hierbei handelt es sich um open statische Delegaten.

  • Abschließend werden die Delegaten für die statische Methode erstellt M4 des Typs C und Typ F; jede Methode verfügt über den deklarierenden Typ als erstes Argument und eine Instanz des Typs angegeben werden, damit die Delegaten über ihre erste Argumente geschlossen werden. Methode M4 des Typs C zeigt die ID Eigenschaften der gebundenen Instanz und des Arguments.

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
'

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 2.0
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: