Delegate.CreateDelegate Metodo

Definizione

Crea un delegato del tipo specificato.Creates a delegate of the specified type.

Overload

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

Crea un delegato del tipo specificato che rappresenta il metodo statico indicato della classe specificata, con la distinzione tra maiuscole e minuscole indicata e il funzionamento specificato in caso di errore di associazione.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)

Crea un delegato del tipo indicato che rappresenta il metodo statico specificato della classe indicata, con la distinzione tra maiuscole e minuscole specificata.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)

Crea un delegato del tipo specificato che rappresenta il metodo di istanza specificato, per il richiamo dell'istanza di classe specificata, con la distinzione tra maiuscole e minuscole specificata.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)

Crea un delegato del tipo specificato che rappresenta il metodo statico o il metodo di istanza indicato, con il primo argomento specificato e il funzionamento indicato in caso di errore di associazione.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)

Crea un delegato del tipo specificato che rappresenta il metodo di istanza specificato, per il richiamo dell'istanza di classe specificata, con la distinzione tra maiuscole e minuscole specificata e il funzionamento specificato in caso di errore di associazione.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)

Crea un delegato del tipo indicato per rappresentare il metodo statico specificato, in cui viene indicato anche il funzionamento in caso di errore di associazione.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)

Crea un delegato del tipo specificato che rappresenta il metodo di istanza specificato per il richiamo dell'istanza di classe specificata.Creates a delegate of the specified type that represents the specified instance method to invoke on the specified class instance.

CreateDelegate(Type, Object, MethodInfo)

Crea un delegato del tipo specificato che rappresenta il metodo statico o il metodo di istanza indicato, con il primo argomento specificato.Creates a delegate of the specified type that represents the specified static or instance method, with the specified first argument.

CreateDelegate(Type, Type, String)

Crea un delegato del tipo specificato che rappresenta il metodo statico specificato della classe specificata.Creates a delegate of the specified type that represents the specified static method of the specified class.

CreateDelegate(Type, MethodInfo)

Crea un delegato del tipo specificato che rappresenta il metodo statico specificato.Creates a delegate of the specified type to represent the specified static method.

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

Crea un delegato del tipo specificato che rappresenta il metodo statico indicato della classe specificata, con la distinzione tra maiuscole e minuscole indicata e il funzionamento specificato in caso di errore di associazione.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

Parametri

type
Type

Type del delegato da creare.The Type of delegate to create.

target
Type

Type che rappresenta la classe che implementa method.The Type representing the class that implements method.

method
String

Nome del metodo statico che deve essere rappresentato dal delegato.The name of the static method that the delegate is to represent.

ignoreCase
Boolean

Valore booleano che indica se ignorare o meno la distinzione tra maiuscole e minuscole al momento di confrontare il nome del metodo.A Boolean indicating whether to ignore the case when comparing the name of the method.

throwOnBindFailure
Boolean

true per generare un'eccezione se non è possibile associare method. In caso contrario, false.true to throw an exception if method cannot be bound; otherwise, false.

Restituisce

Delegato del tipo specificato che rappresenta il metodo statico specificato della classe specificata.A delegate of the specified type that represents the specified static method of the specified class.

Eccezioni

type è null.type is null.

-oppure--or- target è null.target is null.

-oppure--or- method è null.method is null.

type non eredita MulticastDelegate.type does not inherit MulticastDelegate.

-oppure--or- type non è un oggetto RuntimeType.type is not a RuntimeType. Vedere Tipi di runtime nella reflection.See Runtime Types in Reflection.

-oppure--or- target non è un oggetto RuntimeType.target is not a RuntimeType.

In alternativa-or- target è un tipo generico aperto.target is an open generic type. Ciò significa che la proprietà ContainsGenericParameters è true.That is, its ContainsGenericParameters property is true.

-oppure--or- method non è un metodo static (metodo Shared in Visual Basic).method is not a static method (Shared method in Visual Basic).

-oppure--or- Non è possibile associare method, ad esempio perché non è stato trovato, e throwOnBindFailure è true.method cannot be bound, for example because it cannot be found, and throwOnBindFailure is true.

Non è possibile trovare il metodo Invoke di type.The Invoke method of type is not found.

Il chiamante non ha le autorizzazioni necessarie per accedere a method.The caller does not have the permissions necessary to access method.

Commenti

Questo metodo crea delegati solo per i metodi statici.This method creates delegates for static methods only. Un metodo di istanza è un metodo associato a un'istanza di una classe; un metodo statico è un metodo associato alla classe stessa.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.

Nota

A partire da .NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1, questo metodo può essere usato per accedere a metodi non pubblici se il chiamante è stato concesso ReflectionPermission con il ReflectionPermissionFlag.RestrictedMemberAccess flag e se il set di concessioni dei metodi non pubblici è limitato al set di concessioni del chiamante o a un subset loro.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. Vedere considerazioni sulla sicurezza per la reflection.(See Security Considerations for Reflection.)

Per usare questa funzionalità, l'applicazione deve essere destinata a .NET Framework 3.5.NET Framework 3.5 o versione successiva.To use this functionality, your application should target the .NET Framework 3.5.NET Framework 3.5 or later.

Sicurezza

ReflectionPermission
Quando viene richiamato ad associazione tardiva tramite InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])meccanismi come.when invoked late-bound through mechanisms such as InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[]). Enumerazione associata: MemberAccess.Associated enumeration: MemberAccess.

Vedi anche

CreateDelegate(Type, Type, String, Boolean)

Crea un delegato del tipo indicato che rappresenta il metodo statico specificato della classe indicata, con la distinzione tra maiuscole e minuscole specificata.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

Parametri

type
Type

Type del delegato da creare.The Type of delegate to create.

target
Type

Type che rappresenta la classe che implementa method.The Type representing the class that implements method.

method
String

Nome del metodo statico che deve essere rappresentato dal delegato.The name of the static method that the delegate is to represent.

ignoreCase
Boolean

Valore booleano che indica se ignorare o meno la distinzione tra maiuscole e minuscole al momento di confrontare il nome del metodo.A Boolean indicating whether to ignore the case when comparing the name of the method.

Restituisce

Delegato del tipo specificato che rappresenta il metodo statico specificato della classe specificata.A delegate of the specified type that represents the specified static method of the specified class.

Eccezioni

type è null.type is null.

-oppure--or- target è null.target is null.

-oppure--or- method è null.method is null.

type non eredita MulticastDelegate.type does not inherit MulticastDelegate.

In alternativa-or- type non è un oggetto RuntimeType.type is not a RuntimeType. Vedere Tipi di runtime nella reflection.See Runtime Types in Reflection.

In alternativa-or- target non è un oggetto RuntimeType.target is not a RuntimeType.

-oppure--or- target è un tipo generico aperto.target is an open generic type. Ciò significa che la proprietà ContainsGenericParameters è true.That is, its ContainsGenericParameters property is true.

-oppure--or- method non è un metodo static (metodo Shared in Visual Basic).method is not a static method (Shared method in Visual Basic).

-oppure--or- Non possibile associare method, ad esempio perché non è stato trovato.method cannot be bound, for example because it cannot be found.

Non è possibile trovare il metodo Invoke di type.The Invoke method of type is not found.

Il chiamante non ha le autorizzazioni necessarie per accedere a method.The caller does not have the permissions necessary to access method.

Commenti

Questo metodo crea delegati solo per i metodi statici.This method creates delegates for static methods only. Un metodo di istanza è un metodo associato a un'istanza di una classe; un metodo statico è un metodo associato alla classe stessa.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.

Questo overload del metodo equivale a chiamare l' CreateDelegate(Type, Type, String, Boolean, Boolean) overload del metodo, true specificando per throwOnBindFailure.This method overload is equivalent to calling the CreateDelegate(Type, Type, String, Boolean, Boolean) method overload, specifying true for throwOnBindFailure.

Nota

A partire da .NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1, questo metodo può essere usato per accedere a metodi non pubblici se il chiamante è stato concesso ReflectionPermission con il ReflectionPermissionFlag.RestrictedMemberAccess flag e se il set di concessioni dei metodi non pubblici è limitato al set di concessioni del chiamante o a un subset loro.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. Vedere considerazioni sulla sicurezza per la reflection.(See Security Considerations for Reflection.)

Per usare questa funzionalità, l'applicazione deve essere destinata a .NET Framework 3.5.NET Framework 3.5 o versione successiva.To use this functionality, your application should target the .NET Framework 3.5.NET Framework 3.5 or later.

Sicurezza

ReflectionPermission
Quando viene richiamato ad associazione tardiva tramite InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])meccanismi come.when invoked late-bound through mechanisms such as InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[]). Enumerazione associata: MemberAccess.Associated enumeration: MemberAccess.

Vedi anche

CreateDelegate(Type, Object, String, Boolean)

Crea un delegato del tipo specificato che rappresenta il metodo di istanza specificato, per il richiamo dell'istanza di classe specificata, con la distinzione tra maiuscole e minuscole specificata.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

Parametri

type
Type

Type del delegato da creare.The Type of delegate to create.

target
Object

Istanza di classe per la quale viene richiamato method.The class instance on which method is invoked.

method
String

Nome del metodo di istanza che deve essere rappresentato dal delegato.The name of the instance method that the delegate is to represent.

ignoreCase
Boolean

Valore booleano che indica se ignorare o meno la distinzione tra maiuscole e minuscole al momento di confrontare il nome del metodo.A Boolean indicating whether to ignore the case when comparing the name of the method.

Restituisce

Delegato del tipo specificato che rappresenta il metodo di istanza specificato per il richiamo dell'istanza di classe specificata.A delegate of the specified type that represents the specified instance method to invoke on the specified class instance.

Eccezioni

type è null.type is null.

-oppure--or- target è null.target is null.

-oppure--or- method è null.method is null.

type non eredita MulticastDelegate.type does not inherit MulticastDelegate.

-oppure--or- type non è un oggetto RuntimeType.type is not a RuntimeType. Vedere Tipi di runtime nella reflection.See Runtime Types in Reflection.

-oppure--or- method non è un metodo di istanza.method is not an instance method.

In alternativa-or- Non possibile associare method, ad esempio perché non è stato trovato.method cannot be bound, for example because it cannot be found.

Non è possibile trovare il metodo Invoke di type.The Invoke method of type is not found.

Il chiamante non ha le autorizzazioni necessarie per accedere a method.The caller does not have the permissions necessary to access method.

Commenti

Questo metodo crea delegati solo per i metodi di istanza.This method creates delegates for instance methods only. Un metodo di istanza è un metodo associato a un'istanza di una classe; un metodo statico è un metodo associato alla classe stessa.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.

Questo overload del metodo equivale a chiamare l' CreateDelegate(Type, Object, String, Boolean, Boolean) overload del metodo, true specificando per throwOnBindFailure.This method overload is equivalent to calling the CreateDelegate(Type, Object, String, Boolean, Boolean) method overload, specifying true for throwOnBindFailure.

Nota

A partire da .NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1, questo metodo può essere usato per accedere a metodi non pubblici se il chiamante è stato concesso ReflectionPermission con il ReflectionPermissionFlag.RestrictedMemberAccess flag e se il set di concessioni dei metodi non pubblici è limitato al set di concessioni del chiamante o a un subset loro.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. Vedere considerazioni sulla sicurezza per la reflection.(See Security Considerations for Reflection.)

Per usare questa funzionalità, l'applicazione deve essere destinata a .NET Framework 3.5.NET Framework 3.5 o versione successiva.To use this functionality, your application should target the .NET Framework 3.5.NET Framework 3.5 or later.

Sicurezza

ReflectionPermission
Quando viene richiamato ad associazione tardiva tramite InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])meccanismi come.when invoked late-bound through mechanisms such as InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[]). Enumerazione associata: MemberAccess.Associated enumeration: MemberAccess.

Vedi anche

CreateDelegate(Type, Object, MethodInfo, Boolean)

Crea un delegato del tipo specificato che rappresenta il metodo statico o il metodo di istanza indicato, con il primo argomento specificato e il funzionamento indicato in caso di errore di associazione.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

Parametri

type
Type

Type che rappresenta il tipo di delegato da creare.A Type representing the type of delegate to create.

firstArgument
Object

Object che rappresenta il primo argomento del metodo rappresentato dal delegato.An Object that is the first argument of the method the delegate represents. Per i metodi di istanza, tale oggetto deve essere compatibile con il tipo di istanza.For instance methods, it must be compatible with the instance type.

method
MethodInfo

MethodInfo che descrive il metodo statico o il metodo di istanza che deve essere rappresentato dal delegato.The MethodInfo describing the static or instance method the delegate is to represent.

throwOnBindFailure
Boolean

true per generare un'eccezione se non è possibile associare method. In caso contrario, false.true to throw an exception if method cannot be bound; otherwise, false.

Restituisce

Delegato del tipo specificato che rappresenta il metodo statico o di istanza specificato oppure null se throwOnBindFailure è false e non è possibile associare il delegato a method.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.

Eccezioni

type è null.type is null.

-oppure--or- method è null.method is null.

type non eredita MulticastDelegate.type does not inherit MulticastDelegate.

-oppure--or- type non è un oggetto RuntimeType.type is not a RuntimeType. Vedere Tipi di runtime nella reflection.See Runtime Types in Reflection.

-oppure--or- method non può essere associato e throwOnBindFailure è true.method cannot be bound, and throwOnBindFailure is true.

In alternativa-or- method non è un oggetto RuntimeMethodInfo.method is not a RuntimeMethodInfo. Vedere Tipi di runtime nella reflection.See Runtime Types in Reflection.

Non è possibile trovare il metodo Invoke di type.The Invoke method of type is not found.

Il chiamante non ha le autorizzazioni necessarie per accedere a method.The caller does not have the permissions necessary to access method.

Esempi

Questa sezione contiene tre esempi di codice.This section contains three code examples. Nel primo esempio vengono illustrati i quattro tipi di delegati che è possibile creare: chiusi su un metodo di istanza, aperti su un metodo di istanza, aperti su un metodo statico e chiusi su un metodo statico.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.

Nel secondo esempio di codice vengono illustrati i tipi di parametro e i tipi restituiti compatibili.The second code example demonstrates compatible parameter types and return types.

Il terzo esempio di codice definisce un solo tipo delegato e Mostra tutti i metodi che possono essere rappresentati dal tipo delegato.The third code example defines a single delegate type, and shows all the methods that delegate type can represent.

Esempio 1Example 1

Nell'esempio di codice riportato di seguito vengono illustrati i quattro modi in cui un delegato può CreateDelegate essere creato utilizzando questo overload del metodo.The following code example demonstrates the four ways a delegate can be created using this overload of the CreateDelegate method.

Nota

Sono disponibili due overload del CreateDelegate metodo che specificano firstArgument e MethodInfo. la loro funzionalità è la stessa, con la differenza che consente di specificare se generare un errore di binding e l'altro genera sempre.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. Questo esempio di codice usa entrambi gli overload.This code example uses both overloads.

Nell'esempio viene dichiarata C una classe con un M2 metodo statico e un M1metodo di istanza e tre tipi D1 delegati: C accetta un'istanza di D2 e una stringa, accetta una stringa e D3non ha argomenti.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.

Una seconda classe denominata Example contiene il codice che crea i delegati.A second class named Example contains the code that creates the delegates.

  • Un delegato di tipo D2, chiuso su un'istanza di C, viene creato per il metodo M1di istanza.A delegate of type D2, closed over an instance of C, is created for the instance method M1. Viene richiamato con stringhe diverse per indicare che l'istanza associata di C viene sempre utilizzata.It is invoked with different strings, to show that the bound instance of C is always used.

  • Un delegato di tipo D1, che rappresenta un metodo di istanza aperto, viene creato per il M1metodo di istanza.A delegate of type D1, representing an open instance method, is created for the instance method M1. Un'istanza deve essere passata quando viene richiamato il delegato.An instance must be passed when the delegate is invoked.

  • Un delegato di tipo D2, che rappresenta un metodo statico aperto, viene creato per il metodo M2statico.A delegate of type D2, representing an open static method, is created for the static method M2.

  • Infine, viene creato un delegato D3di tipo, chiuso su una stringa, per il metodo M2statico.Finally, a delegate of type D3, closed over a string, is created for the static method M2. Il metodo viene richiamato per indicare che usa la stringa associata.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.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

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

Esempio 2Example 2

Nell'esempio di codice seguente viene illustrata la compatibilità dei tipi di parametro e dei tipi restituiti.The following code example demonstrates compatibility of parameter types and return types.

Nota

Questo esempio di codice usa CreateDelegate(Type, MethodInfo) l'overload del metodo.This code example uses the CreateDelegate(Type, MethodInfo) method overload. L'uso di altri overload che accettano MethodInfo è simile.The use of other overloads that take MethodInfo is similar.

Nell'esempio di codice viene definita una classe Base base denominata e una Derived classe denominata che deriva Baseda.The code example defines a base class named Base and a class named Derived that derives from Base. La classe derivata ha un static metodoShared (in Visual Basic) denominato MyMethod con un parametro di tipo Base e un tipo restituito di 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. Nell'esempio di codice viene inoltre definito un Example delegato denominato con un parametro di Derived tipo Basee un tipo restituito.The code example also defines a delegate named Example that has one parameter of type Derived and a return type of Base.

Nell'esempio di codice viene illustrato che il Example delegato denominato può essere utilizzato per rappresentare MyMethodil metodo.The code example demonstrates that the delegate named Example can be used to represent the method MyMethod. Il metodo può essere associato al delegato perché:The method can be bound to the delegate because:

  • Il tipo di parametro del delegato (Derived) è più restrittivo rispetto al tipo di parametro di MyMethod (Base), in modo che sia sempre sicuro passare l'argomento del delegato a 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.

  • Il tipo restituito di MyMethod (Derived) è più restrittivo del tipo di parametro del delegato (Base), in modo che sia sempre sicuro eseguire il cast del tipo restituito del metodo al tipo restituito del delegato.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.

L'esempio di codice non produce alcun output.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.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

Esempio 3Example 3

Nell'esempio di codice seguente vengono illustrati tutti i metodi che possono essere rappresentati da un singolo tipo delegato.The following code example shows all the methods a single delegate type can represent.

Nota

Sono disponibili due overload del CreateDelegate metodo che specificano firstArgument e MethodInfo. la loro funzionalità è la stessa, con la differenza che consente di specificare se generare un errore di binding e l'altro genera sempre.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. Questo esempio di codice usa entrambi gli overload.This code example uses both overloads.

L'esempio di codice definisce due classi C , Fe e un tipo D delegato con un argomento di tipo C.The code example defines two classes, C and F, and a delegate type D with one argument of type C. Le classi hanno M1metodi statici e di istanza corrispondenti, M3, M4e, e C la classe dispone anche di M2 un metodo di istanza senza argomenti.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.

Una terza classe denominata Example contiene il codice che crea i delegati.A third class named Example contains the code that creates the delegates.

  • I delegati vengono creati M1 per il C metodo di Fistanza di tipo e di tipo. ognuno viene chiuso su un'istanza del rispettivo tipo.Delegates are created for instance method M1 of type C and type F; each is closed over an instance of the respective type. Metodo M1 di tipo C consente di ID visualizzare le proprietà dell'istanza associata e dell'argomento.Method M1 of type C displays the ID properties of the bound instance and of the argument.

  • Viene creato un delegato per il M2 metodo di Ctipo.A delegate is created for method M2 of type C. Si tratta di un delegato di istanza aperto, in cui l'argomento del delegato rappresenta il primo argomento nascosto nel metodo di istanza.This is an open instance delegate, in which the argument of the delegate represents the hidden first argument on the instance method. Il metodo non ha altri argomenti.The method has no other arguments.

  • I delegati vengono creati M3 per il C metodo statico Fdi tipo e di tipo. si tratta di delegati statici aperti.Delegates are created for static method M3 of type C and type F; these are open static delegates.

  • Infine, i delegati vengono creati M4 per il C metodo statico Fdi tipo e di tipo. ogni metodo ha il tipo dichiarante come primo argomento e viene fornita un'istanza del tipo, quindi i delegati vengono chiusi sui rispettivi primi argomenti. .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. Metodo M4 di tipo C consente di ID visualizzare le proprietà dell'istanza associata e dell'argomento.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.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
'

Commenti

Questo overload del metodo e CreateDelegate(Type, Object, MethodInfo) l'overload del metodo, che genera sempre in caso di errore di associazione, forniscono il modo più flessibile per creare delegati.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. È possibile usarli per creare delegati per metodi statici o di istanza, con o senza un primo argomento.You can use them to create delegates for either static or instance methods, with or without a first argument.

Nota

Se non si specifica un primo argomento, utilizzare l'overload CreateDelegate(Type, MethodInfo, Boolean) del metodo per ottenere prestazioni migliori.If you do not supply a first argument, use the CreateDelegate(Type, MethodInfo, Boolean) method overload for better performance.

Il tipo delegato e il metodo devono avere tipi restituiti compatibili.The delegate type and the method must have compatible return types. Ovvero, il tipo restituito di method deve essere assegnabile al tipo restituito di. typeThat is, the return type of method must be assignable to the return type of type.

Se firstArgument viene fornito, viene passato a method ogni volta che viene richiamato il delegato. firstArgument viene definito associato al delegato e il delegato viene detto chiuso sul primo argomento.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. Se method è static ( method firstArgument in Visual Basic), l'elenco di argomenti fornito quando si richiama il delegato include tutti i parametri eccetto il primo; se è un metodo di istanza, viene passato all'istanza nascostaShared parametro (rappresentato da this in C#o da 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).

Se firstArgument viene fornito, il primo parametro di method deve essere un tipo di riferimento e firstArgument deve essere compatibile con tale tipo.If firstArgument is supplied, the first parameter of method must be a reference type, and firstArgument must be compatible with that type.

Importante

Se method è static ( Object inVisualBasicValueType) e ilfirstArgument primo parametro è di tipo o, può essere un tipo valore.SharedIf 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 questo caso firstArgument viene automaticamente eseguita la conversione boxing.In this case firstArgument is automatically boxed. La conversione boxing automatica non viene eseguita per altri argomenti, come in una C# chiamata di funzione o Visual Basic.Automatic boxing does not occur for any other arguments, as it would in a C# or Visual Basic function call.

Se firstArgument è un riferimento null e method è un metodo di istanza, il risultato dipende dalle firme del tipo type delegato e di 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:

  • Se la firma di type include in modo esplicito il primo parametro methodnascosto di, viene detto che il delegato rappresenta un metodo di istanza aperto.If the signature of type explicitly includes the hidden first parameter of method, the delegate is said to represent an open instance method. Quando il delegato viene richiamato, il primo argomento nell'elenco di argomenti viene passato al parametro di istanza nascosto methoddi.When the delegate is invoked, the first argument in the argument list is passed to the hidden instance parameter of method.

  • Se le firme di method e type corrispondono (ovvero tutti i tipi di parametro sono compatibili), il delegato viene detto chiuso su un riferimento null.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. Richiamare il delegato è come chiamare un metodo di istanza su un'istanza null, operazione che non è particolarmente utile.Invoking the delegate is like calling an instance method on a null instance, which is not a particularly useful thing to do.

Se firstArgument è un riferimento null ed method è statico, il risultato dipende dalle firme del tipo type delegato e di 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:

  • Se la firma e method type la corrispondenza, ovvero tutti i tipi di parametro sono compatibili, il delegato viene definito come un metodo statico aperto.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. Questo è il caso più comune per i metodi statici.This is the most common case for static methods. In questo caso, è possibile ottenere prestazioni leggermente migliori usando l'overload CreateDelegate(Type, MethodInfo, Boolean) del metodo.In this case, you can get slightly better performance by using the CreateDelegate(Type, MethodInfo, Boolean) method overload.

  • Se la firma di type inizia con il secondo parametro di method e i restanti tipi di parametro sono compatibili, il delegato viene detto chiuso su un riferimento null.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. Quando il delegato viene richiamato, viene passato un riferimento null al primo parametro di method.When the delegate is invoked, a null reference is passed to the first parameter of method.

Nota

A partire da .NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1, questo metodo può essere usato per accedere a metodi non pubblici se il chiamante è stato concesso ReflectionPermission con il ReflectionPermissionFlag.RestrictedMemberAccess flag e se il set di concessioni dei metodi non pubblici è limitato al set di concessioni del chiamante o a un subset loro.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. Vedere considerazioni sulla sicurezza per la reflection.(See Security Considerations for Reflection.)

Per usare questa funzionalità, l'applicazione deve essere destinata a .NET Framework 3.5.NET Framework 3.5 o versione successiva.To use this functionality, your application should target the .NET Framework 3.5.NET Framework 3.5 or later.

Tipi di parametro compatibili e tipo restituitoCompatible Parameter Types and Return Type

I tipi di parametro e il tipo restituito di un delegato devono essere compatibili con i tipi di parametro e il tipo restituito del metodo rappresentato dal delegato. non è necessario che i tipi corrispondano esattamente.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.

Nota

In .NET Framework versione 1,0 e 1,1 i tipi devono corrispondere esattamente.In the .NET Framework version 1.0 and 1.1 the types must match exactly.

Un parametro di un delegato è compatibile con il parametro di un metodo corrispondente se il tipo del parametro del delegato è più restrittivo rispetto al tipo del parametro del metodo. In questo modo si garantisce che un argomento passato al delegato possa essere passato in modo sicuro al metodo.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.

Analogamente, il tipo restituito di un delegato è compatibile con il tipo restituito di un metodo se il tipo restituito del metodo è più restrittivo rispetto al tipo restituito del delegato. In questo modo si garantisce la possibilità di eseguire in modo sicuro il cast del valore restituito del metodo nel tipo restituito del delegato.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.

Un delegato con un Hashtable parametro di tipo e un Object tipo restituito può, ad esempio, rappresentare un metodo con un parametro di tipo Object e un valore restituito di tipo 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.

Determinazione dei metodi che possono essere rappresentati da un delegatoDetermining the Methods a Delegate Can Represent

Un altro modo utile per considerare la flessibilità fornita da questo overload di CreateDelegate è che qualsiasi delegato specificato può rappresentare quattro combinazioni diverse di firma del metodo e tipo di metodo (statico e istanza).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). Si consideri D un tipo delegato con un Cargomento di tipo.Consider a delegate type D with one argument of type C. Di seguito vengono descritti i D metodi che possono rappresentare, ignorando il tipo restituito perché deve corrispondere in tutti i casi:The following describes the methods D can represent, ignoring the return type since it must match in all cases:

  • Dpuò rappresentare qualsiasi metodo di istanza che dispone di un solo argomento Cdi tipo, indipendentemente dal tipo a cui appartiene il metodo di istanza.D can represent any instance method that has exactly one argument of type C, regardless of what type the instance method belongs to. Quando CreateDelegate viene chiamato il firstArgument metodo, è un'istanza del method tipo a cui appartiene e il delegato risultante viene detto chiuso su tale istanza.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. (In maniera banale D , può essere chiuso anche su un riferimento null firstArgument se nullè.)(Trivially, D can also be closed over a null reference if firstArgument is null.)

  • Dpuò rappresentare un metodo di istanza C di senza argomenti.D can represent an instance method of C that has no arguments. Quando CreateDelegate viene chiamato il firstArgument metodo, è un riferimento null.When CreateDelegate is called, firstArgument is a null reference. Il delegato risultante rappresenta un metodo di istanza aperto e un'istanza di C deve essere fornita ogni volta che viene richiamata.The resulting delegate represents an open instance method, and an instance of C must be supplied each time it is invoked.

  • Dpuò rappresentare un metodo statico che accetta un argomento di tipo Ce tale metodo può appartenere a qualsiasi tipo.D can represent a static method that takes one argument of type C, and that method can belong to any type. Quando CreateDelegate viene chiamato il firstArgument metodo, è un riferimento null.When CreateDelegate is called, firstArgument is a null reference. Il delegato risultante rappresenta un metodo statico aperto ed è necessario specificare un' C istanza di ogni volta che viene richiamata.The resulting delegate represents an open static method, and an instance of C must be supplied each time it is invoked.

  • Dpuò rappresentare un metodo statico che appartiene al tipo F e ha due argomenti, di tipo F e Cdi tipo.D can represent a static method that belongs to type F and has two arguments, of type F and type C. Quando CreateDelegate viene chiamato il firstArgument metodo, è un' Fistanza di.When CreateDelegate is called, firstArgument is an instance of F. Il delegato risultante rappresenta un metodo statico chiuso sull'istanza di F.The resulting delegate represents a static method that is closed over that instance of F. Si noti che nel caso in F cui C e siano dello stesso tipo, il metodo statico ha due argomenti di quel tipo.Note that in the case where F and C are the same type, the static method has two arguments of that type. (In questo caso, D viene chiuso su un riferimento null se firstArgument è null.)(In this case, D is closed over a null reference if firstArgument is null.)

Sicurezza

ReflectionPermission
Quando viene richiamato ad associazione tardiva tramite InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])meccanismi come.when invoked late-bound through mechanisms such as InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[]). Enumerazione associata: MemberAccess.Associated enumeration: MemberAccess.

Vedi anche

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

Crea un delegato del tipo specificato che rappresenta il metodo di istanza specificato, per il richiamo dell'istanza di classe specificata, con la distinzione tra maiuscole e minuscole specificata e il funzionamento specificato in caso di errore di associazione.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

Parametri

type
Type

Type del delegato da creare.The Type of delegate to create.

target
Object

Istanza di classe per la quale viene richiamato method.The class instance on which method is invoked.

method
String

Nome del metodo di istanza che deve essere rappresentato dal delegato.The name of the instance method that the delegate is to represent.

ignoreCase
Boolean

Valore booleano che indica se ignorare o meno la distinzione tra maiuscole e minuscole al momento di confrontare il nome del metodo.A Boolean indicating whether to ignore the case when comparing the name of the method.

throwOnBindFailure
Boolean

true per generare un'eccezione se non è possibile associare method. In caso contrario, false.true to throw an exception if method cannot be bound; otherwise, false.

Restituisce

Delegato del tipo specificato che rappresenta il metodo di istanza specificato per il richiamo dell'istanza di classe specificata.A delegate of the specified type that represents the specified instance method to invoke on the specified class instance.

Eccezioni

type è null.type is null.

-oppure--or- target è null.target is null.

In alternativa-or- method è null.method is null.

type non eredita MulticastDelegate.type does not inherit MulticastDelegate.

-oppure--or- type non è un oggetto RuntimeType.type is not a RuntimeType. Vedere Tipi di runtime nella reflection.See Runtime Types in Reflection.

-oppure--or- method non è un metodo di istanza.method is not an instance method.

-oppure--or- Non è possibile associare method, ad esempio perché non è stato trovato, e throwOnBindFailure è true.method cannot be bound, for example because it cannot be found, and throwOnBindFailure is true.

Non è possibile trovare il metodo Invoke di type.The Invoke method of type is not found.

Il chiamante non ha le autorizzazioni necessarie per accedere a method.The caller does not have the permissions necessary to access method.

Commenti

Questo metodo crea delegati solo per i metodi di istanza.This method creates delegates for instance methods only. Un metodo di istanza è un metodo associato a un'istanza di una classe; un metodo statico è un metodo associato alla classe stessa.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.

Nota

A partire da .NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1, questo metodo può essere usato per accedere a metodi non pubblici se il chiamante è stato concesso ReflectionPermission con il ReflectionPermissionFlag.RestrictedMemberAccess flag e se il set di concessioni dei metodi non pubblici è limitato al set di concessioni del chiamante o a un subset loro.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. Vedere considerazioni sulla sicurezza per la reflection.(See Security Considerations for Reflection.)

Per usare questa funzionalità, l'applicazione deve essere destinata a .NET Framework 3.5.NET Framework 3.5 o versione successiva.To use this functionality, your application should target the .NET Framework 3.5.NET Framework 3.5 or later.

Sicurezza

ReflectionPermission
Quando viene richiamato ad associazione tardiva tramite InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])meccanismi come.when invoked late-bound through mechanisms such as InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[]). Enumerazione associata: MemberAccess.Associated enumeration: MemberAccess.

Vedi anche

CreateDelegate(Type, MethodInfo, Boolean)

Crea un delegato del tipo indicato per rappresentare il metodo statico specificato, in cui viene indicato anche il funzionamento in caso di errore di associazione.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

Parametri

type
Type

Type del delegato da creare.The Type of delegate to create.

method
MethodInfo

MethodInfo che descrive il metodo statico o il metodo di istanza che deve essere rappresentato dal delegato.The MethodInfo describing the static or instance method the delegate is to represent.

throwOnBindFailure
Boolean

true per generare un'eccezione se non è possibile associare method. In caso contrario, false.true to throw an exception if method cannot be bound; otherwise, false.

Restituisce

Delegato del tipo specificato che rappresenta il metodo statico specificato.A delegate of the specified type to represent the specified static method.

Eccezioni

type è null.type is null.

-oppure--or- method è null.method is null.

type non eredita MulticastDelegate.type does not inherit MulticastDelegate.

-oppure--or- type non è un oggetto RuntimeType.type is not a RuntimeType. Vedere Tipi di runtime nella reflection.See Runtime Types in Reflection.

-oppure--or- method non può essere associato e throwOnBindFailure è true.method cannot be bound, and throwOnBindFailure is true.

-oppure--or- method non è un oggetto RuntimeMethodInfo.method is not a RuntimeMethodInfo. Vedere Tipi di runtime nella reflection.See Runtime Types in Reflection.

Non è possibile trovare il metodo Invoke di type.The Invoke method of type is not found.

Il chiamante non ha le autorizzazioni necessarie per accedere a method.The caller does not have the permissions necessary to access method.

Esempi

In questa sezione sono riportati due esempi di codice.This section contains two code examples. Nel primo esempio vengono illustrati i due tipi di delegati che possono essere creati con questo overload del metodo, ovvero aperti su un metodo di istanza e aperti su un metodo statico.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.

Nel secondo esempio di codice vengono illustrati i tipi di parametro e i tipi restituiti compatibili.The second code example demonstrates compatible parameter types and return types.

Esempio 1Example 1

Nell'esempio di codice riportato di seguito vengono illustrati i due modi in cui un delegato può CreateDelegate essere creato utilizzando questo overload del metodo.The following code example demonstrates the two ways a delegate can be created using this overload of the CreateDelegate method.

Nota

Sono disponibili due overload del CreateDelegate metodo che specificano un oggetto ma non un primo argomento. la loro funzionalità è la stessa, ad eccezione del fatto che consente di specificare se generare un MethodInfo errore di binding e l'altro genera sempre.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. Questo esempio di codice usa entrambi gli overload.This code example uses both overloads.

Nell'esempio viene dichiarata C una classe con un M2 metodo statico e un M1metodo di istanza e due tipi D1 delegati: C accetta un'istanza di e D2 una stringa e accetta una stringa.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.

Una seconda classe denominata Example contiene il codice che crea i delegati.A second class named Example contains the code that creates the delegates.

  • Un delegato di tipo D1, che rappresenta un metodo di istanza aperto, viene creato per il M1metodo di istanza.A delegate of type D1, representing an open instance method, is created for the instance method M1. Un'istanza deve essere passata quando viene richiamato il delegato.An instance must be passed when the delegate is invoked.

  • Un delegato di tipo D2, che rappresenta un metodo statico aperto, viene creato per il metodo M2statico.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.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

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

Esempio 2Example 2

Nell'esempio di codice seguente viene illustrata la compatibilità dei tipi di parametro e dei tipi restituiti.The following code example demonstrates compatibility of parameter types and return types.

Nota

Questo esempio di codice usa CreateDelegate(Type, MethodInfo) l'overload del metodo.This code example uses the CreateDelegate(Type, MethodInfo) method overload. L'uso di altri overload che accettano MethodInfo è simile.The use of other overloads that take MethodInfo is similar.

Nell'esempio di codice viene definita una classe Base base denominata e una Derived classe denominata che deriva Baseda.The code example defines a base class named Base and a class named Derived that derives from Base. La classe derivata ha un static metodoShared (in Visual Basic) denominato MyMethod con un parametro di tipo Base e un tipo restituito di 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. Nell'esempio di codice viene inoltre definito un Example delegato denominato con un parametro di Derived tipo Basee un tipo restituito.The code example also defines a delegate named Example that has one parameter of type Derived and a return type of Base.

Nell'esempio di codice viene illustrato che il Example delegato denominato può essere utilizzato per rappresentare MyMethodil metodo.The code example demonstrates that the delegate named Example can be used to represent the method MyMethod. Il metodo può essere associato al delegato perché:The method can be bound to the delegate because:

  • Il tipo di parametro del delegato (Derived) è più restrittivo rispetto al tipo di parametro di MyMethod (Base), in modo che sia sempre sicuro passare l'argomento del delegato a 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.

  • Il tipo restituito di MyMethod (Derived) è più restrittivo del tipo di parametro del delegato (Base), in modo che sia sempre sicuro eseguire il cast del tipo restituito del metodo al tipo restituito del delegato.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.

L'esempio di codice non produce alcun output.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.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

Commenti

Questo overload del metodo può creare delegati di metodi statici aperti e delegati del metodo di istanza aperti, ovvero delegati che espongono il primo argomento nascosto dei metodi di istanza.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. Per una spiegazione dettagliata, vedere l'overload del CreateDelegate(Type, Object, MethodInfo, Boolean) metodo più generale, che consente di creare tutte le combinazioni di delegati aperti o chiusi per i metodi di istanza o statici.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.

Nota

Questo overload del metodo deve essere usato quando il delegato non viene chiuso sul primo argomento, perché in questo caso è leggermente più veloce.This method overload should be used when the delegate is not closed over its first argument, because it is somewhat faster in that case.

Nota

A partire da .NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1, questo metodo può essere usato per accedere a metodi non pubblici se il chiamante è stato concesso ReflectionPermission con il ReflectionPermissionFlag.RestrictedMemberAccess flag e se il set di concessioni dei metodi non pubblici è limitato al set di concessioni del chiamante o a un subset loro.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. Vedere considerazioni sulla sicurezza per la reflection.(See Security Considerations for Reflection.)

Per usare questa funzionalità, l'applicazione deve essere destinata a .NET Framework 3.5.NET Framework 3.5 o versione successiva.To use this functionality, your application should target the .NET Framework 3.5.NET Framework 3.5 or later.

Tipi di parametro compatibili e tipo restituitoCompatible Parameter Types and Return Type

I tipi di parametro e il tipo restituito di un delegato devono essere compatibili con i tipi di parametro e il tipo restituito del metodo rappresentato dal delegato. non è necessario che i tipi corrispondano esattamente.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.

Nota

In .NET Framework versione 1,0 e 1,1, i tipi devono corrispondere esattamente.In the .NET Framework version 1.0 and 1.1, the types must match exactly.

Un parametro di un delegato è compatibile con il parametro di un metodo corrispondente se il tipo del parametro del delegato è più restrittivo rispetto al tipo del parametro del metodo. In questo modo si garantisce che un argomento passato al delegato possa essere passato in modo sicuro al metodo.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.

Analogamente, il tipo restituito di un delegato è compatibile con il tipo restituito di un metodo se il tipo restituito del metodo è più restrittivo rispetto al tipo restituito del delegato. In questo modo si garantisce la possibilità di eseguire in modo sicuro il cast del valore restituito del metodo nel tipo restituito del delegato.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.

Un delegato con un Hashtable parametro di tipo e un Object tipo restituito può, ad esempio, rappresentare un metodo con un parametro di tipo Object e un valore restituito di tipo 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.

Sicurezza

ReflectionPermission
Quando viene richiamato ad associazione tardiva tramite InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])meccanismi come.when invoked late-bound through mechanisms such as InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[]). Enumerazione associata: MemberAccess.Associated enumeration: MemberAccess.

Vedi anche

CreateDelegate(Type, Object, String)

Crea un delegato del tipo specificato che rappresenta il metodo di istanza specificato per il richiamo dell'istanza di classe specificata.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

Parametri

type
Type

Type del delegato da creare.The Type of delegate to create.

target
Object

Istanza di classe per la quale viene richiamato method.The class instance on which method is invoked.

method
String

Nome del metodo di istanza che deve essere rappresentato dal delegato.The name of the instance method that the delegate is to represent.

Restituisce

Delegato del tipo specificato che rappresenta il metodo di istanza specificato per il richiamo dell'istanza di classe specificata.A delegate of the specified type that represents the specified instance method to invoke on the specified class instance.

Eccezioni

type è null.type is null.

In alternativa-or- target è null.target is null.

-oppure--or- method è null.method is null.

type non eredita MulticastDelegate.type does not inherit MulticastDelegate.

-oppure--or- type non è un oggetto RuntimeType.type is not a RuntimeType. Vedere Tipi di runtime nella reflection.See Runtime Types in Reflection.

In alternativa-or- method non è un metodo di istanza.method is not an instance method.

-oppure--or- Non possibile associare method, ad esempio perché non è stato trovato.method cannot be bound, for example because it cannot be found.

Non è possibile trovare il metodo Invoke di type.The Invoke method of type is not found.

Il chiamante non ha le autorizzazioni necessarie per accedere a method.The caller does not have the permissions necessary to access method.

Commenti

Questo metodo crea delegati solo per i metodi di istanza.This method creates delegates for instance methods only. Un metodo di istanza è un metodo associato a un'istanza di una classe; un metodo statico è un metodo associato alla classe stessa.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.

Questo overload del metodo equivale a chiamare l' CreateDelegate(Type, Object, String, Boolean, Boolean) overload del metodo, false specificando true per throwOnBindFailure ignoreCase e per.This method overload is equivalent to calling the CreateDelegate(Type, Object, String, Boolean, Boolean) method overload, specifying false for ignoreCase and true for throwOnBindFailure.

Nota

A partire da .NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1, questo metodo può essere usato per accedere a metodi non pubblici se il chiamante è stato concesso ReflectionPermission con il ReflectionPermissionFlag.RestrictedMemberAccess flag e se il set di concessioni dei metodi non pubblici è limitato al set di concessioni del chiamante o a un subset loro.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. Vedere considerazioni sulla sicurezza per la reflection.(See Security Considerations for Reflection.)

Per usare questa funzionalità, l'applicazione deve essere destinata a .NET Framework 3.5.NET Framework 3.5 o versione successiva.To use this functionality, your application should target the .NET Framework 3.5.NET Framework 3.5 or later.

Sicurezza

ReflectionPermission
Quando viene richiamato ad associazione tardiva tramite InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])meccanismi come.when invoked late-bound through mechanisms such as InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[]). Enumerazione associata: MemberAccess.Associated enumeration: MemberAccess.

Vedi anche

CreateDelegate(Type, Object, MethodInfo)

Crea un delegato del tipo specificato che rappresenta il metodo statico o il metodo di istanza indicato, con il primo argomento specificato.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

Parametri

type
Type

Type del delegato da creare.The Type of delegate to create.

firstArgument
Object

Oggetto a cui il delegato è associato oppure null per trattare method come static (Shared in Visual Basic).The object to which the delegate is bound, or null to treat method as static (Shared in Visual Basic).

method
MethodInfo

MethodInfo che descrive il metodo statico o il metodo di istanza che deve essere rappresentato dal delegato.The MethodInfo describing the static or instance method the delegate is to represent.

Restituisce

Delegato del tipo specificato che rappresenta il metodo statico o di istanza specificato.A delegate of the specified type that represents the specified static or instance method.

Eccezioni

type è null.type is null.

-oppure--or- method è null.method is null.

type non eredita MulticastDelegate.type does not inherit MulticastDelegate.

In alternativa-or- type non è un oggetto RuntimeType.type is not a RuntimeType. Vedere Tipi di runtime nella reflection.See Runtime Types in Reflection.

In alternativa-or- method non può essere associato.method cannot be bound.

-oppure--or- method non è un oggetto RuntimeMethodInfo.method is not a RuntimeMethodInfo. Vedere Tipi di runtime nella reflection.See Runtime Types in Reflection.

Non è possibile trovare il metodo Invoke di type.The Invoke method of type is not found.

Il chiamante non ha le autorizzazioni necessarie per accedere a method.The caller does not have the permissions necessary to access method.

Esempi

Questa sezione contiene tre esempi di codice.This section contains three code examples. Nel primo esempio vengono illustrati i quattro tipi di delegati che è possibile creare: chiusi su un metodo di istanza, aperti su un metodo di istanza, aperti su un metodo statico e chiusi su un metodo statico.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.

Nel secondo esempio di codice vengono illustrati i tipi di parametro e i tipi restituiti compatibili.The second code example demonstrates compatible parameter types and return types.

Il terzo esempio di codice definisce un solo tipo delegato e Mostra tutti i metodi che possono essere rappresentati dal tipo delegato.The third code example defines a single delegate type, and shows all the methods that delegate type can represent.

Esempio 1Example 1

Nell'esempio di codice riportato di seguito vengono illustrati i quattro modi in cui un delegato può CreateDelegate essere creato utilizzando questo overload del metodo.The following code example demonstrates the four ways a delegate can be created using this overload of the CreateDelegate method.

Nota

Sono disponibili due overload del CreateDelegate metodo che specificano firstArgument e MethodInfo. la loro funzionalità è la stessa, con la differenza che consente di specificare se generare un errore di binding e l'altro genera sempre.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. Questo esempio di codice usa entrambi gli overload.This code example uses both overloads.

Nell'esempio viene dichiarata C una classe con un M2 metodo statico e un M1metodo di istanza e tre tipi D1 delegati: C accetta un'istanza di D2 e una stringa, accetta una stringa e D3non ha argomenti.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.

Una seconda classe denominata Example contiene il codice che crea i delegati.A second class named Example contains the code that creates the delegates.

  • Un delegato di tipo D2, chiuso su un'istanza di C, viene creato per il metodo M1di istanza.A delegate of type D2, closed over an instance of C, is created for the instance method M1. Viene richiamato con stringhe diverse per indicare che l'istanza associata di C viene sempre utilizzata.It is invoked with different strings, to show that the bound instance of C is always used.

  • Un delegato di tipo D1, che rappresenta un metodo di istanza aperto, viene creato per il M1metodo di istanza.A delegate of type D1, representing an open instance method, is created for the instance method M1. Un'istanza deve essere passata quando viene richiamato il delegato.An instance must be passed when the delegate is invoked.

  • Un delegato di tipo D2, che rappresenta un metodo statico aperto, viene creato per il metodo M2statico.A delegate of type D2, representing an open static method, is created for the static method M2.

  • Infine, viene creato un delegato D3di tipo, chiuso su una stringa, per il metodo M2statico.Finally, a delegate of type D3, closed over a string, is created for the static method M2. Il metodo viene richiamato per indicare che usa la stringa associata.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.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

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

Esempio 2Example 2

Nell'esempio di codice seguente viene illustrata la compatibilità dei tipi di parametro e dei tipi restituiti.The following code example demonstrates compatibility of parameter types and return types.

Nota

Questo esempio di codice usa CreateDelegate(Type, MethodInfo) l'overload del metodo.This code example uses the CreateDelegate(Type, MethodInfo) method overload. L'uso di altri overload che accettano MethodInfo è simile.The use of other overloads that take MethodInfo is similar.

Nell'esempio di codice viene definita una classe Base base denominata e una Derived classe denominata che deriva Baseda.The code example defines a base class named Base and a class named Derived that derives from Base. La classe derivata ha un static metodoShared (in Visual Basic) denominato MyMethod con un parametro di tipo Base e un tipo restituito di 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. Nell'esempio di codice viene inoltre definito un Example delegato denominato con un parametro di Derived tipo Basee un tipo restituito.The code example also defines a delegate named Example that has one parameter of type Derived and a return type of Base.

Nell'esempio di codice viene illustrato che il Example delegato denominato può essere utilizzato per rappresentare MyMethodil metodo.The code example demonstrates that the delegate named Example can be used to represent the method MyMethod. Il metodo può essere associato al delegato perché:The method can be bound to the delegate because:

  • Il tipo di parametro del delegato (Derived) è più restrittivo rispetto al tipo di parametro di MyMethod (Base), in modo che sia sempre sicuro passare l'argomento del delegato a 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.

  • Il tipo restituito di MyMethod (Derived) è più restrittivo del tipo di parametro del delegato (Base), in modo che sia sempre sicuro eseguire il cast del tipo restituito del metodo al tipo restituito del delegato.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.

L'esempio di codice non produce alcun output.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.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

Esempio 3Example 3

Nell'esempio di codice seguente vengono illustrati tutti i metodi che possono essere rappresentati da CreateDelegate un singolo tipo delegato, utilizzando il metodo per creare i delegati.The following code example shows all the methods a single delegate type can represent, using the CreateDelegate method to create the delegates.

Nota

Sono disponibili due overload del CreateDelegate metodo che specificano firstArgument e MethodInfo. la loro funzionalità è la stessa, con la differenza che consente di specificare se generare un errore di binding e l'altro genera sempre.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. Questo esempio di codice usa entrambi gli overload.This code example uses both overloads.

L'esempio di codice definisce due classi C , Fe e un tipo D delegato con un argomento di tipo C.The code example defines two classes, C and F, and a delegate type D with one argument of type C. Le classi hanno M1metodi statici e di istanza corrispondenti, M3, M4e, e C la classe dispone anche di M2 un metodo di istanza senza argomenti.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.

Una terza classe denominata Example contiene il codice che crea i delegati.A third class named Example contains the code that creates the delegates.

  • I delegati vengono creati M1 per il C metodo di Fistanza di tipo e di tipo. ognuno viene chiuso su un'istanza del rispettivo tipo.Delegates are created for instance method M1 of type C and type F; each is closed over an instance of the respective type. Metodo M1 di tipo C consente di ID visualizzare le proprietà dell'istanza associata e dell'argomento.Method M1 of type C displays the ID properties of the bound instance and of the argument.

  • Viene creato un delegato per il M2 metodo di Ctipo.A delegate is created for method M2 of type C. Si tratta di un delegato di istanza aperto, in cui l'argomento del delegato rappresenta il primo argomento nascosto nel metodo di istanza.This is an open instance delegate, in which the argument of the delegate represents the hidden first argument on the instance method. Il metodo non ha altri argomenti.The method has no other arguments. Viene chiamato come se fosse un metodo statico.It is called as if it were a static method.

  • I delegati vengono creati M3 per il C metodo statico Fdi tipo e di tipo. si tratta di delegati statici aperti.Delegates are created for static method M3 of type C and type F; these are open static delegates.

  • Infine, i delegati vengono creati M4 per il C metodo statico Fdi tipo e di tipo. ogni metodo ha il tipo dichiarante come primo argomento e viene fornita un'istanza del tipo, quindi i delegati vengono chiusi sui rispettivi primi argomenti. .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. Metodo M4 di tipo C consente di ID visualizzare le proprietà dell'istanza associata e dell'argomento.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.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
'

Commenti

La chiamata a questo overload del metodo equivale alla CreateDelegate(Type, Object, MethodInfo, Boolean) chiamata dell'overload del true metodo throwOnBindFailuree alla specifica di per.Calling this method overload is equivalent to calling the CreateDelegate(Type, Object, MethodInfo, Boolean) method overload and specifying true for throwOnBindFailure. Questi due overload forniscono il modo più flessibile per creare delegati.These two overloads provide the most flexible way to create delegates. È possibile usarli per creare delegati per i metodi statici o di istanza e, facoltativamente, per specificare il primo argomento.You can use them to create delegates for either static or instance methods, and optionally to specify the first argument.

Nota

Se non si specifica un primo argomento, utilizzare l'overload CreateDelegate(Type, MethodInfo) del metodo per ottenere prestazioni migliori.If you do not supply a first argument, use the CreateDelegate(Type, MethodInfo) method overload for better performance.

Il tipo delegato e il metodo devono avere tipi restituiti compatibili.The delegate type and the method must have compatible return types. Ovvero, il tipo restituito di method deve essere assegnabile al tipo restituito di. typeThat is, the return type of method must be assignable to the return type of type.

Se firstArgument viene fornito, viene passato a method ogni volta che viene richiamato il delegato. firstArgument viene definito associato al delegato e il delegato viene detto chiuso sul primo argomento.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. Se method è static ( method firstArgument in Visual Basic), l'elenco di argomenti fornito quando si richiama il delegato include tutti i parametri eccetto il primo; se è un metodo di istanza, viene passato all'istanza nascostaShared parametro (rappresentato da this in C#o da 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).

Se firstArgument viene fornito, il primo parametro di method deve essere un tipo di riferimento e firstArgument deve essere compatibile con tale tipo.If firstArgument is supplied, the first parameter of method must be a reference type, and firstArgument must be compatible with that type.

Importante

Se method è static ( Object inVisualBasicValueType) e ilfirstArgument primo parametro è di tipo o, può essere un tipo valore.SharedIf 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 questo caso firstArgument viene automaticamente eseguita la conversione boxing.In this case firstArgument is automatically boxed. La conversione boxing automatica non viene eseguita per altri argomenti, come in una C# chiamata di funzione o Visual Basic.Automatic boxing does not occur for any other arguments, as it would in a C# or Visual Basic function call.

Se firstArgument è un riferimento null e method è un metodo di istanza, il risultato dipende dalle firme del tipo type delegato e di 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:

  • Se la firma di type include in modo esplicito il primo parametro methodnascosto di, viene detto che il delegato rappresenta un metodo di istanza aperto.If the signature of type explicitly includes the hidden first parameter of method, the delegate is said to represent an open instance method. Quando il delegato viene richiamato, il primo argomento nell'elenco di argomenti viene passato al parametro di istanza nascosto methoddi.When the delegate is invoked, the first argument in the argument list is passed to the hidden instance parameter of method.

  • Se le firme di method e type corrispondono (ovvero tutti i tipi di parametro sono compatibili), il delegato viene detto chiuso su un riferimento null.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. Richiamare il delegato è come chiamare un metodo di istanza su un'istanza null, operazione che non è particolarmente utile.Invoking the delegate is like calling an instance method on a null instance, which is not a particularly useful thing to do.

Se firstArgument è un riferimento null ed method è statico, il risultato dipende dalle firme del tipo type delegato e di 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:

  • Se la firma e method type la corrispondenza, ovvero tutti i tipi di parametro sono compatibili, il delegato viene definito come un metodo statico aperto.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. Questo è il caso più comune per i metodi statici.This is the most common case for static methods. In questo caso, è possibile ottenere prestazioni leggermente migliori usando l'overload CreateDelegate(Type, MethodInfo) del metodo.In this case, you can get slightly better performance by using the CreateDelegate(Type, MethodInfo) method overload.

  • Se la firma di type inizia con il secondo parametro di method e i restanti tipi di parametro sono compatibili, il delegato viene detto chiuso su un riferimento null.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. Quando il delegato viene richiamato, viene passato un riferimento null al primo parametro di method.When the delegate is invoked, a null reference is passed to the first parameter of method.

Nota

A partire da .NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1, questo metodo può essere usato per accedere a metodi non pubblici se il chiamante è stato concesso ReflectionPermission con il ReflectionPermissionFlag.RestrictedMemberAccess flag e se il set di concessioni dei metodi non pubblici è limitato al set di concessioni del chiamante o a un subset loro.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. Vedere considerazioni sulla sicurezza per la reflection.(See Security Considerations for Reflection.)

Per usare questa funzionalità, l'applicazione deve essere destinata a .NET Framework 3.5.NET Framework 3.5 o versione successiva.To use this functionality, your application should target the .NET Framework 3.5.NET Framework 3.5 or later.

Tipi di parametro compatibili e tipo restituitoCompatible Parameter Types and Return Type

I tipi di parametro e il tipo restituito di un delegato devono essere compatibili con i tipi di parametro e il tipo restituito del metodo rappresentato dal delegato. non è necessario che i tipi corrispondano esattamente.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.

Nota

In .NET Framework versione 1,0 e 1,1, i tipi devono corrispondere esattamente.In the .NET Framework version 1.0 and 1.1, the types must match exactly.

Un parametro di un delegato è compatibile con il parametro di un metodo corrispondente se il tipo del parametro del delegato è più restrittivo rispetto al tipo del parametro del metodo. In questo modo si garantisce che un argomento passato al delegato possa essere passato in modo sicuro al metodo.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.

Analogamente, il tipo restituito di un delegato è compatibile con il tipo restituito di un metodo se il tipo restituito del metodo è più restrittivo rispetto al tipo restituito del delegato. In questo modo si garantisce la possibilità di eseguire in modo sicuro il cast del valore restituito del metodo nel tipo restituito del delegato.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.

Un delegato con un Hashtable parametro di tipo e un Object tipo restituito può, ad esempio, rappresentare un metodo con un parametro di tipo Object e un valore restituito di tipo 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.

Determinazione dei metodi che possono essere rappresentati da un delegatoDetermining the Methods a Delegate Can Represent

Un altro modo utile per considerare la flessibilità fornita da questo overload di CreateDelegate è che qualsiasi delegato specificato può rappresentare quattro combinazioni diverse di firma del metodo e tipo di metodo (statico e istanza).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). Si consideri D un tipo delegato con un Cargomento di tipo.Consider a delegate type D with one argument of type C. Di seguito vengono descritti i D metodi che possono rappresentare, ignorando il tipo restituito perché deve corrispondere in tutti i casi:The following describes the methods D can represent, ignoring the return type since it must match in all cases:

  • Dpuò rappresentare qualsiasi metodo di istanza che dispone di un solo argomento Cdi tipo, indipendentemente dal tipo a cui appartiene il metodo di istanza.D can represent any instance method that has exactly one argument of type C, regardless of what type the instance method belongs to. Quando CreateDelegate viene chiamato il firstArgument metodo, è un'istanza del method tipo a cui appartiene e il delegato risultante viene detto chiuso su tale istanza.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. (In maniera banale D , può essere chiuso anche su un riferimento null firstArgument se è un riferimento null).(Trivially, D can also be closed over a null reference if firstArgument is a null reference.)

  • Dpuò rappresentare un metodo di istanza C di senza argomenti.D can represent an instance method of C that has no arguments. Quando CreateDelegate viene chiamato il firstArgument metodo, è un riferimento null.When CreateDelegate is called, firstArgument is a null reference. Il delegato risultante rappresenta un metodo di istanza aperto e un'istanza di C deve essere fornita ogni volta che viene richiamata.The resulting delegate represents an open instance method, and an instance of C must be supplied each time it is invoked.

  • Dpuò rappresentare un metodo statico che accetta un argomento di tipo Ce tale metodo può appartenere a qualsiasi tipo.D can represent a static method that takes one argument of type C, and that method can belong to any type. Quando CreateDelegate viene chiamato il firstArgument metodo, è un riferimento null.When CreateDelegate is called, firstArgument is a null reference. Il delegato risultante rappresenta un metodo statico aperto ed è necessario specificare un' C istanza di ogni volta che viene richiamata.The resulting delegate represents an open static method, and an instance of C must be supplied each time it is invoked.

  • Dpuò rappresentare un metodo statico che appartiene al tipo F e ha due argomenti, di tipo F e Cdi tipo.D can represent a static method that belongs to type F and has two arguments, of type F and type C. Quando CreateDelegate viene chiamato il firstArgument metodo, è un' Fistanza di.When CreateDelegate is called, firstArgument is an instance of F. Il delegato risultante rappresenta un metodo statico chiuso sull'istanza di F.The resulting delegate represents a static method that is closed over that instance of F. Si noti che nel caso in F cui C e siano dello stesso tipo, il metodo statico ha due argomenti di quel tipo.Note that in the case where F and C are the same type, the static method has two arguments of that type. (In questo caso, D viene chiuso su un riferimento null se firstArgument è un riferimento null).(In this case, D is closed over a null reference if firstArgument is a null reference.)

Sicurezza

ReflectionPermission
Quando viene richiamato ad associazione tardiva tramite InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])meccanismi come.when invoked late-bound through mechanisms such as InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[]). Enumerazione associata: MemberAccess.Associated enumeration: MemberAccess.

Vedi anche

CreateDelegate(Type, Type, String)

Crea un delegato del tipo specificato che rappresenta il metodo statico specificato della classe specificata.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

Parametri

type
Type

Type del delegato da creare.The Type of delegate to create.

target
Type

Type che rappresenta la classe che implementa method.The Type representing the class that implements method.

method
String

Nome del metodo statico che deve essere rappresentato dal delegato.The name of the static method that the delegate is to represent.

Restituisce

Delegato del tipo specificato che rappresenta il metodo statico specificato della classe specificata.A delegate of the specified type that represents the specified static method of the specified class.

Eccezioni

type è null.type is null.

In alternativa-or- target è null.target is null.

In alternativa-or- method è null.method is null.

type non eredita MulticastDelegate.type does not inherit MulticastDelegate.

In alternativa-or- type non è un oggetto RuntimeType.type is not a RuntimeType. Vedere Tipi di runtime nella reflection.See Runtime Types in Reflection.

In alternativa-or- target non è un oggetto RuntimeType.target is not a RuntimeType.

-oppure--or- target è un tipo generico aperto.target is an open generic type. Ciò significa che la proprietà ContainsGenericParameters è true.That is, its ContainsGenericParameters property is true.

In alternativa-or- method non è un metodo static (metodo Shared in Visual Basic).method is not a static method (Shared method in Visual Basic).

-oppure--or- Non è possibile associare method, ad esempio perché non è stato trovato, e throwOnBindFailure è true.method cannot be bound, for example because it cannot be found, and throwOnBindFailure is true.

Non è possibile trovare il metodo Invoke di type.The Invoke method of type is not found.

Il chiamante non ha le autorizzazioni necessarie per accedere a method.The caller does not have the permissions necessary to access method.

Commenti

Questo metodo crea delegati solo per i metodi statici.This method creates delegates for static methods only. Un metodo di istanza è un metodo associato a un'istanza di una classe; un metodo statico è un metodo associato alla classe stessa.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.

Questo overload del metodo equivale a chiamare l' CreateDelegate(Type, Type, String, Boolean, Boolean) overload del metodo, false specificando true per throwOnBindFailure ignoreCase e per.This method overload is equivalent to calling the CreateDelegate(Type, Type, String, Boolean, Boolean) method overload, specifying false for ignoreCase and true for throwOnBindFailure.

Nota

A partire da .NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1, questo metodo può essere usato per accedere a metodi non pubblici se il chiamante è stato concesso ReflectionPermission con il ReflectionPermissionFlag.RestrictedMemberAccess flag e se il set di concessioni dei metodi non pubblici è limitato al set di concessioni del chiamante o a un subset loro.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. Vedere considerazioni sulla sicurezza per la reflection.(See Security Considerations for Reflection.)

Per usare questa funzionalità, l'applicazione deve essere destinata a .NET Framework 3.5.NET Framework 3.5 o versione successiva.To use this functionality, your application should target the .NET Framework 3.5.NET Framework 3.5 or later.

Sicurezza

ReflectionPermission
Quando viene richiamato ad associazione tardiva tramite InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])meccanismi come.when invoked late-bound through mechanisms such as InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[]). Enumerazione associata: MemberAccess.Associated enumeration: MemberAccess.

Vedi anche

CreateDelegate(Type, MethodInfo)

Crea un delegato del tipo specificato che rappresenta il metodo statico specificato.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

Parametri

type
Type

Type del delegato da creare.The Type of delegate to create.

method
MethodInfo

MethodInfo che descrive il metodo statico o il metodo di istanza che deve essere rappresentato dal delegato.The MethodInfo describing the static or instance method the delegate is to represent. Nelle versioni 1.0 e 1.1 di .NET Framework sono supportati solo i metodi statici.Only static methods are supported in the .NET Framework version 1.0 and 1.1.

Restituisce

Delegato del tipo specificato che rappresenta il metodo statico specificato.A delegate of the specified type to represent the specified static method.

Eccezioni

type è null.type is null.

-oppure--or- method è null.method is null.

type non eredita MulticastDelegate.type does not inherit MulticastDelegate.

-oppure--or- type non è un oggetto RuntimeType.type is not a RuntimeType. Vedere Tipi di runtime nella reflection.See Runtime Types in Reflection.

-oppure--or- method non è un metodo statico e la versione di .NET Framework è 1.0 o 1.1.method is not a static method, and the .NET Framework version is 1.0 or 1.1.

In alternativa-or- method non può essere associato.method cannot be bound.

In alternativa-or- method non è un oggetto RuntimeMethodInfo.method is not a RuntimeMethodInfo. Vedere Tipi di runtime nella reflection.See Runtime Types in Reflection.

Non è possibile trovare il metodo Invoke di type.The Invoke method of type is not found.

Il chiamante non ha le autorizzazioni necessarie per accedere a method.The caller does not have the permissions necessary to access method.

Esempi

In questa sezione sono riportati due esempi di codice.This section contains two code examples. Nel primo esempio vengono illustrati i due tipi di delegati che possono essere creati con questo overload del metodo, ovvero aperti su un metodo di istanza e aperti su un metodo statico.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.

Nel secondo esempio di codice vengono illustrati i tipi di parametro e i tipi restituiti compatibili.The second code example demonstrates compatible parameter types and return types.

Esempio 1Example 1

Nell'esempio di codice riportato di seguito vengono illustrati i due modi in cui un delegato può CreateDelegate essere creato utilizzando questo overload del metodo.The following code example demonstrates the two ways a delegate can be created using this overload of the CreateDelegate method.

Nota

Sono disponibili due overload del CreateDelegate metodo che specificano un oggetto ma non un primo argomento. la loro funzionalità è la stessa, ad eccezione del fatto che consente di specificare se generare un MethodInfo errore di binding e l'altro genera sempre.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. Questo esempio di codice usa entrambi gli overload.This code example uses both overloads.

Nell'esempio viene dichiarata C una classe con un M2 metodo statico e un M1metodo di istanza e due tipi D1 delegati: C accetta un'istanza di e D2 una stringa e accetta una stringa.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.

Una seconda classe denominata Example contiene il codice che crea i delegati.A second class named Example contains the code that creates the delegates.

  • Un delegato di tipo D1, che rappresenta un metodo di istanza aperto, viene creato per il M1metodo di istanza.A delegate of type D1, representing an open instance method, is created for the instance method M1. Un'istanza deve essere passata quando viene richiamato il delegato.An instance must be passed when the delegate is invoked.

  • Un delegato di tipo D2, che rappresenta un metodo statico aperto, viene creato per il metodo M2statico.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.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

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

Esempio 2Example 2

Nell'esempio di codice seguente viene illustrata la compatibilità dei tipi di parametro e dei tipi restituiti.The following code example demonstrates compatibility of parameter types and return types.

Nell'esempio di codice viene definita una classe Base base denominata e una Derived classe denominata che deriva Baseda.The code example defines a base class named Base and a class named Derived that derives from Base. La classe derivata ha un static metodoShared (in Visual Basic) denominato MyMethod con un parametro di tipo Base e un tipo restituito di 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. Nell'esempio di codice viene inoltre definito un Example delegato denominato con un parametro di Derived tipo Basee un tipo restituito.The code example also defines a delegate named Example that has one parameter of type Derived and a return type of Base.

Nell'esempio di codice viene illustrato che il Example delegato denominato può essere utilizzato per rappresentare MyMethodil metodo.The code example demonstrates that the delegate named Example can be used to represent the method MyMethod. Il metodo può essere associato al delegato perché:The method can be bound to the delegate because:

  • Il tipo di parametro del delegato (Derived) è più restrittivo rispetto al tipo di parametro di MyMethod (Base), in modo che sia sempre sicuro passare l'argomento del delegato a 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.

  • Il tipo restituito di MyMethod (Derived) è più restrittivo del tipo di parametro del delegato (Base), in modo che sia sempre sicuro eseguire il cast del tipo restituito del metodo al tipo restituito del delegato.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.

L'esempio di codice non produce alcun output.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.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

Commenti

In .NET Framework versione 1,0 e 1,1, questo overload del metodo crea solo i delegati per i metodi statici.In the .NET Framework version 1.0 and 1.1, this method overload creates delegates for static methods only. In .NET Framework versione 2,0, questo overload del metodo può anche creare delegati di metodi di istanza aperti; ovvero delegati che forniscono in modo esplicito il primo argomento nascosto dei metodi di istanza.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. Per una spiegazione dettagliata, vedere l'overload del CreateDelegate(Type, Object, MethodInfo) metodo più generale, che consente di creare tutte le combinazioni di delegati aperti o chiusi per i metodi di istanza o statici e, facoltativamente, di specificare un primo argomento.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.

Nota

Questo overload del metodo deve essere usato quando il delegato non viene chiuso sul primo argomento, perché in questo caso è leggermente più veloce.This method overload should be used when the delegate is not closed over its first argument, because it is somewhat faster in that case.

Questo overload del metodo equivale alla chiamata dell' CreateDelegate(Type, MethodInfo, Boolean) overload del metodo e true alla throwOnBindFailurespecifica di per.This method overload is equivalent to calling the CreateDelegate(Type, MethodInfo, Boolean) method overload and specifying true for throwOnBindFailure.

Nota

A partire da .NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1, questo metodo può essere usato per accedere a metodi non pubblici se il chiamante è stato concesso ReflectionPermission con il ReflectionPermissionFlag.RestrictedMemberAccess flag e se il set di concessioni dei metodi non pubblici è limitato al set di concessioni del chiamante o a un subset loro.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. Vedere considerazioni sulla sicurezza per la reflection.(See Security Considerations for Reflection.)

Per usare questa funzionalità, l'applicazione deve essere destinata a .NET Framework 3.5.NET Framework 3.5 o versione successiva.To use this functionality, your application should target the .NET Framework 3.5.NET Framework 3.5 or later.

Tipi di parametro compatibili e tipo restituitoCompatible Parameter Types and Return Type

In .NET Framework versione 2,0, i tipi di parametro e il tipo restituito di un delegato creato utilizzando questo overload del metodo devono essere compatibili con i tipi di parametro e il tipo restituito del metodo rappresentato dal delegato. non è necessario che i tipi corrispondano esattamente.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. Questo rappresenta un rilassamento del comportamento dell'associazione nella .NET Framework versione 1,0 e 1,1, dove i tipi devono corrispondere esattamente.This represents a relaxation of the binding behavior in the .NET Framework version 1.0 and 1.1, where the types must match exactly.

Un parametro di un delegato è compatibile con il parametro di un metodo corrispondente se il tipo del parametro del delegato è più restrittivo rispetto al tipo del parametro del metodo. In questo modo si garantisce che un argomento passato al delegato possa essere passato in modo sicuro al metodo.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.

Analogamente, il tipo restituito di un delegato è compatibile con il tipo restituito di un metodo se il tipo restituito del metodo è più restrittivo rispetto al tipo restituito del delegato. In questo modo si garantisce la possibilità di eseguire in modo sicuro il cast del valore restituito del metodo nel tipo restituito del delegato.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.

Un delegato con un Hashtable parametro di tipo e un Object tipo restituito può, ad esempio, rappresentare un metodo con un parametro di tipo Object e un valore restituito di tipo 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.

Sicurezza

ReflectionPermission
Quando viene richiamato ad associazione tardiva tramite InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])meccanismi come.when invoked late-bound through mechanisms such as InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[]). Enumerazione associata: MemberAccess.Associated enumeration: MemberAccess.

Vedi anche

Si applica a