Delegate.CreateDelegate Método

Definição

Cria um delegado do tipo especificado.Creates a delegate of the specified type.

Sobrecargas

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

Cria um delegado do tipo especificado que representa o método estático especificado da classe especificada, com a diferenciação de maiúsculas e minúsculas especificada e o comportamento especificado na falha de associação.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)

Cria um delegado do tipo especificado que representa o método estático especificado da classe especificada, com a diferenciação de maiúsculas e minúsculas especificada.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)

Cria um delegado do tipo especificado que representa o método de instância especificado a ser invocado na instância da classe especificada, com a diferenciação de maiúsculas e minúsculas especificada.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)

Cria um delegado do tipo especificado que representa o método de instância ou estático especificado, com o primeiro argumento especificado e o comportamento especificado na falha para associação.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)

Cria um delegado do tipo especificado que representa o método de instância especificado a ser invocado na instância da classe especificada, com a diferenciação de maiúsculas e minúsculas especificada e o comportamento especificado na falha de associação.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)

Cria um delegado do tipo especificado para representar o método estático especificado, com o comportamento em falhas especificado a ser associado.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)

Cria um delegado do tipo especificado que representa o método de instância especificado a ser invocado na instância da classe especificada.Creates a delegate of the specified type that represents the specified instance method to invoke on the specified class instance.

CreateDelegate(Type, Object, MethodInfo)

Cria um delegado do tipo especificado que representa o método de instância ou estático especificado com o primeiro argumento especificado.Creates a delegate of the specified type that represents the specified static or instance method, with the specified first argument.

CreateDelegate(Type, Type, String)

Cria um delegado do tipo especificado que representa o método estático especificado da classe especificada.Creates a delegate of the specified type that represents the specified static method of the specified class.

CreateDelegate(Type, MethodInfo)

Cria um delegado do tipo especificado para representar o método estático especificado.Creates a delegate of the specified type to represent the specified static method.

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

Cria um delegado do tipo especificado que representa o método estático especificado da classe especificada, com a diferenciação de maiúsculas e minúsculas especificada e o comportamento especificado na falha de associação.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);
public static Delegate CreateDelegate (Type type, Type target, string method, bool ignoreCase, bool throwOnBindFailure);
static member CreateDelegate : Type * Type * string * bool * bool -> Delegate
Public Shared Function CreateDelegate (type As Type, target As Type, method As String, ignoreCase As Boolean, throwOnBindFailure As Boolean) As Delegate

Parâmetros

type
Type

O Type do representante a ser criado.The Type of delegate to create.

target
Type

O Type que representa a classe que implementa method.The Type representing the class that implements method.

method
String

O nome do método estático que o delegado deve representar.The name of the static method that the delegate is to represent.

ignoreCase
Boolean

Um booliano indicando se é necessário ignorar as maiúsculas durante a comparação do nome do método.A Boolean indicating whether to ignore the case when comparing the name of the method.

throwOnBindFailure
Boolean

true para lançar uma exceção caso method não possa ser associado; do contrário, false.true to throw an exception if method cannot be bound; otherwise, false.

Retornos

Delegate

Um delegado do tipo especificado que representa o método especificado estático da classe especificada.A delegate of the specified type that represents the specified static method of the specified class.

Exceções

type é null.type is null.

- ou --or- target é null.target is null.

- ou --or- method é null.method is null.

type não herda MulticastDelegate.type does not inherit MulticastDelegate.

- ou --or- type não é um RuntimeType.type is not a RuntimeType. Consulte Runtime Types in Reflection (Tipos de tempo de execução na reflexão).See Runtime Types in Reflection.

- ou --or- target não é um RuntimeType.target is not a RuntimeType.

- ou --or- target é um tipo genérico aberto.target is an open generic type. Ou seja, sua propriedade ContainsGenericParameters é true.That is, its ContainsGenericParameters property is true.

- ou --or- O method não é um método static (método Shared no Visual Basic).method is not a static method (Shared method in Visual Basic).

- ou --or- method não pode ser associado, por exemplo, porque não foi encontrado e throwOnBindFailure é true.method cannot be bound, for example because it cannot be found, and throwOnBindFailure is true.

O método Invoke de type não foi encontrado.The Invoke method of type is not found.

O chamador não tem as permissões necessárias para acessar method.The caller does not have the permissions necessary to access method.

Comentários

Esse método cria delegados somente para métodos estáticos.This method creates delegates for static methods only. Método de instância é um método associado a uma instância de uma classe; método estático é um método associado à própria classe.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.

Observação

A partir do .NET Framework 2,0 Service Pack 1, esse método poderá ser usado para acessar métodos não públicos se o chamador tiver sido concedido ReflectionPermission com o ReflectionPermissionFlag.RestrictedMemberAccess sinalizador e se o Grant Set dos métodos não públicos for restrito ao conjunto de concessão do chamador ou a um subconjunto dele.Starting with the .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. (Consulte considerações de segurança para reflexão.)(See Security Considerations for Reflection.)

Para usar essa funcionalidade, seu aplicativo deve ter como destino o .NET Framework 3,5 ou posterior.To use this functionality, your application should target the .NET Framework 3.5 or later.

Confira também

Aplica-se a

CreateDelegate(Type, Type, String, Boolean)

Cria um delegado do tipo especificado que representa o método estático especificado da classe especificada, com a diferenciação de maiúsculas e minúsculas especificada.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
Public Shared Function CreateDelegate (type As Type, target As Type, method As String, ignoreCase As Boolean) As Delegate

Parâmetros

type
Type

O Type do representante a ser criado.The Type of delegate to create.

target
Type

O Type que representa a classe que implementa method.The Type representing the class that implements method.

method
String

O nome do método estático que o delegado deve representar.The name of the static method that the delegate is to represent.

ignoreCase
Boolean

Um booliano indicando se é necessário ignorar as maiúsculas durante a comparação do nome do método.A Boolean indicating whether to ignore the case when comparing the name of the method.

Retornos

Delegate

Um delegado do tipo especificado que representa o método especificado estático da classe especificada.A delegate of the specified type that represents the specified static method of the specified class.

Exceções

type é null.type is null.

- ou --or- target é null.target is null.

- ou --or- method é null.method is null.

type não herda MulticastDelegate.type does not inherit MulticastDelegate.

- ou --or- type não é um RuntimeType.type is not a RuntimeType. Consulte Runtime Types in Reflection (Tipos de tempo de execução na reflexão).See Runtime Types in Reflection.

- ou --or- target não é um RuntimeType.target is not a RuntimeType.

- ou --or- target é um tipo genérico aberto.target is an open generic type. Ou seja, sua propriedade ContainsGenericParameters é true.That is, its ContainsGenericParameters property is true.

- ou --or- O method não é um método static (método Shared no Visual Basic).method is not a static method (Shared method in Visual Basic).

- ou --or- O method não pode ser associado, por exemplo, porque não foi encontrado.method cannot be bound, for example because it cannot be found.

O método Invoke de type não foi encontrado.The Invoke method of type is not found.

O chamador não tem as permissões necessárias para acessar method.The caller does not have the permissions necessary to access method.

Comentários

Esse método cria delegados somente para métodos estáticos.This method creates delegates for static methods only. Método de instância é um método associado a uma instância de uma classe; método estático é um método associado à própria classe.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.

Essa sobrecarga de método é equivalente a chamar a CreateDelegate(Type, Type, String, Boolean, Boolean) sobrecarga do método, especificando true for throwOnBindFailure .This method overload is equivalent to calling the CreateDelegate(Type, Type, String, Boolean, Boolean) method overload, specifying true for throwOnBindFailure.

Observação

A partir do .NET Framework 2,0 Service Pack 1, esse método poderá ser usado para acessar métodos não públicos se o chamador tiver sido concedido ReflectionPermission com o ReflectionPermissionFlag.RestrictedMemberAccess sinalizador e se o Grant Set dos métodos não públicos for restrito ao conjunto de concessão do chamador ou a um subconjunto dele.Starting with the .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. (Consulte considerações de segurança para reflexão.)(See Security Considerations for Reflection.)

Para usar essa funcionalidade, seu aplicativo deve ter como destino o .NET Framework 3,5 ou posterior.To use this functionality, your application should target the .NET Framework 3.5 or later.

Confira também

Aplica-se a

CreateDelegate(Type, Object, String, Boolean)

Cria um delegado do tipo especificado que representa o método de instância especificado a ser invocado na instância da classe especificada, com a diferenciação de maiúsculas e minúsculas especificada.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
Public Shared Function CreateDelegate (type As Type, target As Object, method As String, ignoreCase As Boolean) As Delegate

Parâmetros

type
Type

O Type do representante a ser criado.The Type of delegate to create.

target
Object

A instância de classe na qual method é invocado.The class instance on which method is invoked.

method
String

O nome do método de instância que o delegado deve representar.The name of the instance method that the delegate is to represent.

ignoreCase
Boolean

Um booliano indicando se é necessário ignorar as maiúsculas durante a comparação do nome do método.A Boolean indicating whether to ignore the case when comparing the name of the method.

Retornos

Delegate

Um delegado do tipo especificado que representa o método de instância especificado a ser invocado na instância da classe especificada.A delegate of the specified type that represents the specified instance method to invoke on the specified class instance.

Exceções

type é null.type is null.

- ou --or- target é null.target is null.

- ou --or- method é null.method is null.

type não herda MulticastDelegate.type does not inherit MulticastDelegate.

- ou --or- type não é um RuntimeType.type is not a RuntimeType. Consulte Runtime Types in Reflection (Tipos de tempo de execução na reflexão).See Runtime Types in Reflection.

- ou --or- method não é um método de instância.method is not an instance method.

- ou --or- O method não pode ser associado, por exemplo, porque não foi encontrado.method cannot be bound, for example because it cannot be found.

O método Invoke de type não foi encontrado.The Invoke method of type is not found.

O chamador não tem as permissões necessárias para acessar method.The caller does not have the permissions necessary to access method.

Comentários

Esse método cria delegados somente para métodos de instância.This method creates delegates for instance methods only. Método de instância é um método associado a uma instância de uma classe; método estático é um método associado à própria classe.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.

Essa sobrecarga de método é equivalente a chamar a CreateDelegate(Type, Object, String, Boolean, Boolean) sobrecarga do método, especificando true for throwOnBindFailure .This method overload is equivalent to calling the CreateDelegate(Type, Object, String, Boolean, Boolean) method overload, specifying true for throwOnBindFailure.

Observação

A partir do .NET Framework 2,0 Service Pack 1, esse método poderá ser usado para acessar métodos não públicos se o chamador tiver sido concedido ReflectionPermission com o ReflectionPermissionFlag.RestrictedMemberAccess sinalizador e se o Grant Set dos métodos não públicos for restrito ao conjunto de concessão do chamador ou a um subconjunto dele.Starting with the .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. (Consulte considerações de segurança para reflexão.)(See Security Considerations for Reflection.)

Para usar essa funcionalidade, seu aplicativo deve ter como destino o .NET Framework 3,5 ou posterior.To use this functionality, your application should target the .NET Framework 3.5 or later.

Confira também

Aplica-se a

CreateDelegate(Type, Object, MethodInfo, Boolean)

Cria um delegado do tipo especificado que representa o método de instância ou estático especificado, com o primeiro argumento especificado e o comportamento especificado na falha para associação.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);
public static Delegate CreateDelegate (Type type, object firstArgument, System.Reflection.MethodInfo method, bool throwOnBindFailure);
static member CreateDelegate : Type * obj * System.Reflection.MethodInfo * bool -> Delegate
Public Shared Function CreateDelegate (type As Type, firstArgument As Object, method As MethodInfo, throwOnBindFailure As Boolean) As Delegate

Parâmetros

type
Type

Um Type que representa o tipo de delegado a ser criado.A Type representing the type of delegate to create.

firstArgument
Object

Um Object que é o primeiro argumento do método que o delegado representa.An Object that is the first argument of the method the delegate represents. Por exemplo, para métodos, ele deve ser compatível com o tipo de instância.For instance methods, it must be compatible with the instance type.

method
MethodInfo

O MethodInfo que descreve o método estático ou de instância que o representante deve representar.The MethodInfo describing the static or instance method the delegate is to represent.

throwOnBindFailure
Boolean

true para lançar uma exceção caso method não possa ser associado; do contrário, false.true to throw an exception if method cannot be bound; otherwise, false.

Retornos

Delegate

Um delegado do tipo especificado que representa o método de instância ou estático especificado ou null se throwOnBindFailure é false e o delegado não pode ser associado 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.

Exceções

type é null.type is null.

- ou --or- method é null.method is null.

type não herda MulticastDelegate.type does not inherit MulticastDelegate.

- ou --or- type não é um RuntimeType.type is not a RuntimeType. Consulte Runtime Types in Reflection (Tipos de tempo de execução na reflexão).See Runtime Types in Reflection.

- ou --or- method não pode ser associado e throwOnBindFailure é true.method cannot be bound, and throwOnBindFailure is true.

- ou --or- method não é um RuntimeMethodInfo.method is not a RuntimeMethodInfo. Consulte Runtime Types in Reflection (Tipos de tempo de execução na reflexão).See Runtime Types in Reflection.

O método Invoke de type não foi encontrado.The Invoke method of type is not found.

O chamador não tem as permissões necessárias para acessar method.The caller does not have the permissions necessary to access method.

Exemplos

Esta seção contém três exemplos de código.This section contains three code examples. O primeiro exemplo demonstra os quatro tipos de delegados que podem ser criados: fechado em um método de instância, aberto em um método de instância, aberto em um método estático e fechado em um método estático.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.

O segundo exemplo de código demonstra tipos de parâmetro correspondentes e tipos de retorno.The second code example demonstrates compatible parameter types and return types.

O terceiro exemplo de código define um único tipo delegate e mostra todos os métodos que o tipo delegado pode representar.The third code example defines a single delegate type, and shows all the methods that delegate type can represent.

Exemplo 1Example 1

O exemplo de código a seguir demonstra as quatro maneiras como um delegado pode ser criado usando essa sobrecarga do CreateDelegate método.The following code example demonstrates the four ways a delegate can be created using this overload of the CreateDelegate method.

Observação

Há duas sobrecargas do método CreateDelegate que especificam firstArgument e MethodInfo; sua funcionalidade é a mesma, exceto por uma permitir especificar se é necessário lançar falha de associação e a outra lançar 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. Este exemplo de código usa ambas as sobrecargas.This code example uses both overloads.

O exemplo declara uma classe C com um método estático M2 e um método de instância M1 , e três tipos delegados: D1 usa uma instância de C e uma cadeia de caracteres, D2 usa uma cadeia de caracteres e D3 não tem argumentos.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.

Uma segunda classe chamada Example contém o código que cria os representantes.A second class named Example contains the code that creates the delegates.

  • Um delegado do tipo D2 , fechado em uma instância do C , é criado para o método de instância M1 .A delegate of type D2, closed over an instance of C, is created for the instance method M1. Ele é invocado com cadeias de caracteres diferentes, para mostrar que a instância associada do C é sempre usada.It is invoked with different strings, to show that the bound instance of C is always used.

  • Um representante de tipo D1, representando um método de instância aberto, é criado para o método de instância M1.A delegate of type D1, representing an open instance method, is created for the instance method M1. Uma instância deve ser passada quando o representante é invocado.An instance must be passed when the delegate is invoked.

  • Um representante de tipo D2, representando um método estático aberto, é criado para o método estático M2.A delegate of type D2, representing an open static method, is created for the static method M2.

  • Por fim, um delegado do tipo D3 , fechado em uma cadeia de caracteres, é criado para o método estático M2 .Finally, a delegate of type D3, closed over a string, is created for the static method M2. O método é chamado para mostrar que ele usa a cadeia de caracteres associada.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!
'

Exemplo 2Example 2

O exemplo de código a seguir demonstra a compatibilidade dos tipos de parâmetro e de retorno.The following code example demonstrates compatibility of parameter types and return types.

Observação

Este exemplo de código usa a CreateDelegate(Type, MethodInfo) sobrecarga do método.This code example uses the CreateDelegate(Type, MethodInfo) method overload. O uso de outras sobrecargas que o Take MethodInfo é semelhante.The use of other overloads that take MethodInfo is similar.

O exemplo de código define uma classe base chamada Base e uma classe chamada Derived derivada de Base.The code example defines a base class named Base and a class named Derived that derives from Base. A classe derivada tem um método static (Shared no Visual Basic) chamado MyMethod com um parâmetro do tipo Base e um retorno do tipo de 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. O exemplo de código também define um representante chamado Example que tem um parâmetro do tipo Derived e um tipo de retorno de Base.The code example also defines a delegate named Example that has one parameter of type Derived and a return type of Base.

O exemplo de código demonstra que o representante chamado Example pode ser usado para representar o método MyMethod.The code example demonstrates that the delegate named Example can be used to represent the method MyMethod. O método pode ser associado ao representante porque:The method can be bound to the delegate because:

  • O tipo de parâmetro do representante (Derived) é mais restritivo do que o tipo de parâmetro MyMethod (Base), logo, é sempre seguro passar o argumento do representante para 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.

  • O tipo de retorno de MyMethod (Derived) é mais restritivo do que o tipo de parâmetro do representante (Base), logo, é sempre seguro converter o tipo de retorno do método no tipo de retorno do representante.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.

O exemplo de código não produz nenhuma saída.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

Exemplo 3Example 3

O exemplo de código a seguir mostra todos os métodos que um único tipo delegate pode representar.The following code example shows all the methods a single delegate type can represent.

Observação

Há duas sobrecargas do método CreateDelegate que especificam firstArgument e MethodInfo; sua funcionalidade é a mesma, exceto por uma permitir especificar se é necessário lançar falha de associação e a outra lançar 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. Este exemplo de código usa ambas as sobrecargas.This code example uses both overloads.

O exemplo de código define duas classes, C e F , e um tipo delegate D com um argumento do tipo C .The code example defines two classes, C and F, and a delegate type D with one argument of type C. As classes têm os métodos static e Instance correspondentes M1 , M3 , e e M4 C a classe também tem um método M2 de instância que não tem argumentos.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.

Uma terceira classe denominada Example contém o código que cria os delegados.A third class named Example contains the code that creates the delegates.

  • Os delegados são criados para M1 o método de instância do tipo C e tipo F ; cada um é fechado em uma instância do respectivo tipo.Delegates are created for instance method M1 of type C and type F; each is closed over an instance of the respective type. Método M1 de tipo C exibe as ID Propriedades da instância associada e do argumento.Method M1 of type C displays the ID properties of the bound instance and of the argument.

  • Um delegado é criado para o método M2 do tipo C .A delegate is created for method M2 of type C. Esse é um delegado de instância aberta, no qual o argumento do delegado representa o primeiro argumento oculto no método de instância.This is an open instance delegate, in which the argument of the delegate represents the hidden first argument on the instance method. O método não tem nenhum outro argumento.The method has no other arguments.

  • Delegados são criados para método estático M3 de tipo C e tipo F ; são delegados estáticos abertos.Delegates are created for static method M3 of type C and type F; these are open static delegates.

  • Por fim, os delegados são criados para método estático M4 de tipo C e tipo F ; cada método tem o tipo declarativo como seu primeiro argumento e uma instância do tipo é fornecida, portanto, os delegados são fechados sobre seus primeiros argumentos.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. Método M4 de tipo C exibe as ID Propriedades da instância associada e do argumento.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
'

Comentários

Esse método é sobrecarga e a CreateDelegate(Type, Object, MethodInfo) sobrecarga do método, que sempre é lançada em caso de falha na ligação, fornece a maneira mais flexível de criar delegados.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. Você pode usá-los para criar delegados para métodos estáticos ou de instância, com ou sem um primeiro argumento.You can use them to create delegates for either static or instance methods, with or without a first argument.

Observação

Se você não fornecer um primeiro argumento, use a CreateDelegate(Type, MethodInfo, Boolean) sobrecarga do método para melhorar o desempenho.If you do not supply a first argument, use the CreateDelegate(Type, MethodInfo, Boolean) method overload for better performance.

O tipo delegado e o método devem ter tipos de retorno compatíveis.The delegate type and the method must have compatible return types. Ou seja, o tipo de retorno de method deve ser atribuível ao tipo de retorno de type .That is, the return type of method must be assignable to the return type of type.

Se firstArgument for fornecido, ele será transmitido a method cada vez que o delegado for invocado; firstArgument deve estar associado ao delegado e o delegado deve ser fechado em seu primeiro argumento.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 for static ( Shared em Visual Basic), a lista de argumentos fornecida ao invocar o delegado incluirá todos os parâmetros, exceto o primeiro; se method for um método de instância, firstArgument será passada para o parâmetro de instância oculta (representado por this em C# ou por Me no 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 for fornecido, o primeiro parâmetro de method deve ser um tipo de referência e firstArgument deve ser compatível com esse 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 ( Shared em Visual Basic) e seu primeiro parâmetro é do tipo Object ou ValueType , firstArgument pode ser um tipo de valor.If method is static (Shared in Visual Basic) and its first parameter is of type Object or ValueType, then firstArgument can be a value type. Nesse caso, firstArgument é automaticamente emoldurado.In this case firstArgument is automatically boxed. A Boxing automática não ocorre para nenhum outro argumento, como faria em uma chamada de função C# ou Visual Basic.Automatic boxing does not occur for any other arguments, as it would in a C# or Visual Basic function call.

Se firstArgument for uma referência nula e method for um método de instância, o resultado dependerá das assinaturas do tipo delegado type e de 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 a assinatura de type incluir explicitamente o primeiro parâmetro oculto de method , o delegado será considerado para representar um método de instância aberta.If the signature of type explicitly includes the hidden first parameter of method, the delegate is said to represent an open instance method. Quando o delegado é invocado, o primeiro argumento na lista de argumentos é passado para o parâmetro de instância oculta de method .When the delegate is invoked, the first argument in the argument list is passed to the hidden instance parameter of method.

  • Se as assinaturas de method e type corresponderem (ou seja, todos os tipos de parâmetro forem compatíveis), o delegado será considerado para ser fechado em uma referência nula.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. Invocar o delegado é como chamar um método de instância em uma instância nula, o que não é uma coisa particularmente útil.Invoking the delegate is like calling an instance method on a null instance, which is not a particularly useful thing to do.

Se firstArgument for uma referência nula e method for estática, o resultado dependerá das assinaturas do tipo delegado type e de 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 a assinatura method e a type correspondência (ou seja, todos os tipos de parâmetro forem compatíveis), o delegado será considerado para representar um método estático aberto.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. Esse é o caso mais comum para métodos estáticos.This is the most common case for static methods. Nesse caso, você pode obter um desempenho ligeiramente melhor usando a CreateDelegate(Type, MethodInfo, Boolean) sobrecarga do método.In this case, you can get slightly better performance by using the CreateDelegate(Type, MethodInfo, Boolean) method overload.

  • Se a assinatura de type começar com o segundo parâmetro de method e o restante dos tipos de parâmetro forem compatíveis, o delegado será considerado para ser fechado em uma referência nula.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 o delegado é invocado, uma referência nula é passada para o primeiro parâmetro de method .When the delegate is invoked, a null reference is passed to the first parameter of method.

Observação

A partir do .NET Framework 2,0 Service Pack 1, esse método poderá ser usado para acessar métodos não públicos se o chamador tiver sido concedido ReflectionPermission com o ReflectionPermissionFlag.RestrictedMemberAccess sinalizador e se o Grant Set dos métodos não públicos for restrito ao conjunto de concessão do chamador ou a um subconjunto dele.Starting with the .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. (Consulte considerações de segurança para reflexão.)(See Security Considerations for Reflection.)

Para usar essa funcionalidade, seu aplicativo deve ter como destino o .NET Framework 3,5 ou posterior.To use this functionality, your application should target the .NET Framework 3.5 or later.

Tipos de parâmetro compatíveis e tipo de retornoCompatible Parameter Types and Return Type

Os tipos de parâmetro e o tipo de retorno de um delegado devem ser compatíveis com os tipos de parâmetro e o tipo de retorno do método que o delegado representa; os tipos não precisam corresponder exatamente.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.

Observação

No .NET Framework versão 1,0 e 1,1, os tipos devem corresponder exatamente.In the .NET Framework version 1.0 and 1.1 the types must match exactly.

Um parâmetro de um delegado será compatível com o parâmetro correspondente de um método se o tipo do parâmetro de delegado for mais restritivo do que o tipo do parâmetro de método, porque isso garante que um argumento passado para o delegado possa ser passado com segurança para o método.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.

Da mesma forma, o tipo de retorno de um delegado será compatível com o tipo de retorno de um método se o tipo de retorno do método for mais restritivo do que o tipo de retorno do delegado, porque isso garante que o valor retornado do método possa ser convertido com segurança para o tipo retorno do delegado.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.

Por exemplo, um delegado com um parâmetro de tipo Hashtable e um tipo de retorno de Object pode representar um método com um parâmetro de tipo Object e um valor de retorno do 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.

Determinando os métodos que um delegado pode representarDetermining the Methods a Delegate Can Represent

Outra maneira útil de considerar a flexibilidade fornecida por essa sobrecarga de CreateDelegate é que qualquer delegado determinado pode representar quatro combinações diferentes de assinatura de método e tipo de método (estático versus instância).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). Considere um tipo delegado D com um argumento do tipo C .Consider a delegate type D with one argument of type C. Veja a seguir uma descrição dos métodos D que podem ser representados, ignorando o tipo de retorno, pois ele deve corresponder em todos os casos:The following describes the methods D can represent, ignoring the return type since it must match in all cases:

  • D pode representar qualquer método de instância que tenha exatamente um argumento do tipo C , independentemente do tipo ao qual o método de instância pertence.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 é chamado, firstArgument é uma instância do tipo method que pertence e o delegado resultante é dito para ser fechado nessa instância.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. (Trivialmente, D também pode ser fechado em uma referência nula se firstArgument for null .)(Trivially, D can also be closed over a null reference if firstArgument is null.)

  • D pode representar um método de instância do C que não tem argumentos.D can represent an instance method of C that has no arguments. Quando CreateDelegate é chamado, firstArgument é uma referência nula.When CreateDelegate is called, firstArgument is a null reference. O delegado resultante representa um método de instância aberta e uma instância do C deve ser fornecida cada vez que é invocada.The resulting delegate represents an open instance method, and an instance of C must be supplied each time it is invoked.

  • D pode representar um método estático que usa um argumento do tipo C , e esse método pode pertencer a qualquer tipo.D can represent a static method that takes one argument of type C, and that method can belong to any type. Quando CreateDelegate é chamado, firstArgument é uma referência nula.When CreateDelegate is called, firstArgument is a null reference. O delegado resultante representa um método estático aberto, e uma instância de C deve ser fornecida sempre que for invocada.The resulting delegate represents an open static method, and an instance of C must be supplied each time it is invoked.

  • D pode representar um método estático que pertence ao tipo F e tem dois argumentos, do tipo F e do tipo C .D can represent a static method that belongs to type F and has two arguments, of type F and type C. Quando CreateDelegate é chamado, firstArgument é uma instância do F .When CreateDelegate is called, firstArgument is an instance of F. O delegado resultante representa um método estático que é fechado nessa instância do F .The resulting delegate represents a static method that is closed over that instance of F. Observe que, no caso F e C são do mesmo tipo, o método estático tem dois argumentos desse tipo.Note that in the case where F and C are the same type, the static method has two arguments of that type. (Nesse caso, D será fechado em uma referência nula se firstArgument for null .)(In this case, D is closed over a null reference if firstArgument is null.)

Confira também

Aplica-se a

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

Cria um delegado do tipo especificado que representa o método de instância especificado a ser invocado na instância da classe especificada, com a diferenciação de maiúsculas e minúsculas especificada e o comportamento especificado na falha de associação.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);
public static Delegate CreateDelegate (Type type, object target, string method, bool ignoreCase, bool throwOnBindFailure);
static member CreateDelegate : Type * obj * string * bool * bool -> Delegate
Public Shared Function CreateDelegate (type As Type, target As Object, method As String, ignoreCase As Boolean, throwOnBindFailure As Boolean) As Delegate

Parâmetros

type
Type

O Type do representante a ser criado.The Type of delegate to create.

target
Object

A instância de classe na qual method é invocado.The class instance on which method is invoked.

method
String

O nome do método de instância que o delegado deve representar.The name of the instance method that the delegate is to represent.

ignoreCase
Boolean

Um booliano indicando se é necessário ignorar as maiúsculas durante a comparação do nome do método.A Boolean indicating whether to ignore the case when comparing the name of the method.

throwOnBindFailure
Boolean

true para lançar uma exceção caso method não possa ser associado; do contrário, false.true to throw an exception if method cannot be bound; otherwise, false.

Retornos

Delegate

Um delegado do tipo especificado que representa o método de instância especificado a ser invocado na instância da classe especificada.A delegate of the specified type that represents the specified instance method to invoke on the specified class instance.

Exceções

type é null.type is null.

- ou --or- target é null.target is null.

- ou --or- method é null.method is null.

type não herda MulticastDelegate.type does not inherit MulticastDelegate.

- ou --or- type não é um RuntimeType.type is not a RuntimeType. Consulte Runtime Types in Reflection (Tipos de tempo de execução na reflexão).See Runtime Types in Reflection.

- ou --or- method não é um método de instância.method is not an instance method.

- ou --or- method não pode ser associado, por exemplo, porque não foi encontrado e throwOnBindFailure é true.method cannot be bound, for example because it cannot be found, and throwOnBindFailure is true.

O método Invoke de type não foi encontrado.The Invoke method of type is not found.

O chamador não tem as permissões necessárias para acessar method.The caller does not have the permissions necessary to access method.

Comentários

Esse método cria delegados somente para métodos de instância.This method creates delegates for instance methods only. Método de instância é um método associado a uma instância de uma classe; método estático é um método associado à própria classe.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.

Observação

A partir do .NET Framework 2,0 Service Pack 1, esse método poderá ser usado para acessar métodos não públicos se o chamador tiver sido concedido ReflectionPermission com o ReflectionPermissionFlag.RestrictedMemberAccess sinalizador e se o Grant Set dos métodos não públicos for restrito ao conjunto de concessão do chamador ou a um subconjunto dele.Starting with the .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. (Consulte considerações de segurança para reflexão.)(See Security Considerations for Reflection.)

Para usar essa funcionalidade, seu aplicativo deve ter como destino o .NET Framework 3,5 ou posterior.To use this functionality, your application should target the .NET Framework 3.5 or later.

Confira também

Aplica-se a

CreateDelegate(Type, MethodInfo, Boolean)

Cria um delegado do tipo especificado para representar o método estático especificado, com o comportamento em falhas especificado a ser associado.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);
public static Delegate CreateDelegate (Type type, System.Reflection.MethodInfo method, bool throwOnBindFailure);
static member CreateDelegate : Type * System.Reflection.MethodInfo * bool -> Delegate
Public Shared Function CreateDelegate (type As Type, method As MethodInfo, throwOnBindFailure As Boolean) As Delegate

Parâmetros

type
Type

O Type do representante a ser criado.The Type of delegate to create.

method
MethodInfo

O MethodInfo que descreve o método estático ou de instância que o representante deve representar.The MethodInfo describing the static or instance method the delegate is to represent.

throwOnBindFailure
Boolean

true para lançar uma exceção caso method não possa ser associado; do contrário, false.true to throw an exception if method cannot be bound; otherwise, false.

Retornos

Delegate

Um delegado do tipo especificado para representar o método estático especificado.A delegate of the specified type to represent the specified static method.

Exceções

type é null.type is null.

- ou --or- method é null.method is null.

type não herda MulticastDelegate.type does not inherit MulticastDelegate.

- ou --or- type não é um RuntimeType.type is not a RuntimeType. Consulte Runtime Types in Reflection (Tipos de tempo de execução na reflexão).See Runtime Types in Reflection.

- ou --or- method não pode ser associado e throwOnBindFailure é true.method cannot be bound, and throwOnBindFailure is true.

- ou --or- method não é um RuntimeMethodInfo.method is not a RuntimeMethodInfo. Consulte Runtime Types in Reflection (Tipos de tempo de execução na reflexão).See Runtime Types in Reflection.

O método Invoke de type não foi encontrado.The Invoke method of type is not found.

O chamador não tem as permissões necessárias para acessar method.The caller does not have the permissions necessary to access method.

Exemplos

Esta seção contém dois exemplos de código.This section contains two code examples. O primeiro exemplo demonstra os dois tipos de delegados que podem ser criados com essa sobrecarga de método: abrir em um método de instância e abrir em um método estático.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.

O segundo exemplo de código demonstra tipos de parâmetro correspondentes e tipos de retorno.The second code example demonstrates compatible parameter types and return types.

Exemplo 1Example 1

O exemplo de código a seguir demonstra as duas maneiras como um delegado pode ser criado usando essa sobrecarga do CreateDelegate método.The following code example demonstrates the two ways a delegate can be created using this overload of the CreateDelegate method.

Observação

Há duas sobrecargas do CreateDelegate método que especificam um MethodInfo , mas não um primeiro argumento; sua funcionalidade é a mesma, exceto pelo fato de que um permite que você especifique se deseja gerar uma falha na associação e o outro sempre é gerado.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. Este exemplo de código usa ambas as sobrecargas.This code example uses both overloads.

O exemplo declara uma classe C com um método estático M2 e um método de instância M1 , e dois tipos delegados: D1 usa uma instância de C e uma cadeia de caracteres e D2 usa uma cadeia de caracteres.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.

Uma segunda classe chamada Example contém o código que cria os representantes.A second class named Example contains the code that creates the delegates.

  • Um representante de tipo D1, representando um método de instância aberto, é criado para o método de instância M1.A delegate of type D1, representing an open instance method, is created for the instance method M1. Uma instância deve ser passada quando o representante é invocado.An instance must be passed when the delegate is invoked.

  • Um representante de tipo D2, representando um método estático aberto, é criado para o método estático M2.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!
'

Exemplo 2Example 2

O exemplo de código a seguir demonstra a compatibilidade dos tipos de parâmetro e de retorno.The following code example demonstrates compatibility of parameter types and return types.

Observação

Este exemplo de código usa a CreateDelegate(Type, MethodInfo) sobrecarga do método.This code example uses the CreateDelegate(Type, MethodInfo) method overload. O uso de outras sobrecargas que o Take MethodInfo é semelhante.The use of other overloads that take MethodInfo is similar.

O exemplo de código define uma classe base chamada Base e uma classe chamada Derived derivada de Base.The code example defines a base class named Base and a class named Derived that derives from Base. A classe derivada tem um método static (Shared no Visual Basic) chamado MyMethod com um parâmetro do tipo Base e um retorno do tipo de 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. O exemplo de código também define um representante chamado Example que tem um parâmetro do tipo Derived e um tipo de retorno de Base.The code example also defines a delegate named Example that has one parameter of type Derived and a return type of Base.

O exemplo de código demonstra que o representante chamado Example pode ser usado para representar o método MyMethod.The code example demonstrates that the delegate named Example can be used to represent the method MyMethod. O método pode ser associado ao representante porque:The method can be bound to the delegate because:

  • O tipo de parâmetro do representante (Derived) é mais restritivo do que o tipo de parâmetro MyMethod (Base), logo, é sempre seguro passar o argumento do representante para 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.

  • O tipo de retorno de MyMethod (Derived) é mais restritivo do que o tipo de parâmetro do representante (Base), logo, é sempre seguro converter o tipo de retorno do método no tipo de retorno do representante.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.

O exemplo de código não produz nenhuma saída.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

Comentários

Essa sobrecarga de método pode criar delegados de método estático aberto e delegados de método de instância aberto – ou seja, delegados que expõem o primeiro argumento oculto de métodos de instância.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. Para obter uma explicação detalhada, consulte a sobrecarga de método mais geral CreateDelegate(Type, Object, MethodInfo, Boolean) , que permite que você crie todas as combinações de delegados abertos ou fechados para métodos de instância ou estáticos.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.

Observação

Essa sobrecarga de método deve ser usada quando o delegado não é fechado em seu primeiro argumento, pois é um pouco mais rápido nesse caso.This method overload should be used when the delegate is not closed over its first argument, because it is somewhat faster in that case.

Observação

A partir do .NET Framework 2,0 Service Pack 1, esse método poderá ser usado para acessar métodos não públicos se o chamador tiver sido concedido ReflectionPermission com o ReflectionPermissionFlag.RestrictedMemberAccess sinalizador e se o Grant Set dos métodos não públicos for restrito ao conjunto de concessão do chamador ou a um subconjunto dele.Starting with the .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. (Consulte considerações de segurança para reflexão.)(See Security Considerations for Reflection.)

Para usar essa funcionalidade, seu aplicativo deve ter como destino o .NET Framework 3,5 ou posterior.To use this functionality, your application should target the .NET Framework 3.5 or later.

Tipos de parâmetro compatíveis e tipo de retornoCompatible Parameter Types and Return Type

Os tipos de parâmetro e o tipo de retorno de um delegado devem ser compatíveis com os tipos de parâmetro e o tipo de retorno do método que o delegado representa; os tipos não precisam corresponder exatamente.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.

Observação

No .NET Framework versão 1,0 e 1,1, os tipos devem corresponder exatamente.In the .NET Framework version 1.0 and 1.1, the types must match exactly.

Um parâmetro de um delegado será compatível com o parâmetro correspondente de um método se o tipo do parâmetro de delegado for mais restritivo do que o tipo do parâmetro de método, porque isso garante que um argumento passado para o delegado possa ser passado com segurança para o método.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.

Da mesma forma, o tipo de retorno de um delegado será compatível com o tipo de retorno de um método se o tipo de retorno do método for mais restritivo do que o tipo de retorno do delegado, porque isso garante que o valor retornado do método possa ser convertido com segurança para o tipo retorno do delegado.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.

Por exemplo, um delegado com um parâmetro de tipo Hashtable e um tipo de retorno de Object pode representar um método com um parâmetro de tipo Object e um valor de retorno do 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.

Confira também

Aplica-se a

CreateDelegate(Type, Object, String)

Cria um delegado do tipo especificado que representa o método de instância especificado a ser invocado na instância da classe especificada.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
Public Shared Function CreateDelegate (type As Type, target As Object, method As String) As Delegate

Parâmetros

type
Type

O Type do representante a ser criado.The Type of delegate to create.

target
Object

A instância de classe na qual method é invocado.The class instance on which method is invoked.

method
String

O nome do método de instância que o delegado deve representar.The name of the instance method that the delegate is to represent.

Retornos

Delegate

Um delegado do tipo especificado que representa o método de instância especificado a ser invocado na instância da classe especificada.A delegate of the specified type that represents the specified instance method to invoke on the specified class instance.

Exceções

type é null.type is null.

- ou --or- target é null.target is null.

- ou --or- method é null.method is null.

type não herda MulticastDelegate.type does not inherit MulticastDelegate.

- ou --or- type não é um RuntimeType.type is not a RuntimeType. Consulte Runtime Types in Reflection (Tipos de tempo de execução na reflexão).See Runtime Types in Reflection.

- ou --or- method não é um método de instância.method is not an instance method.

- ou --or- O method não pode ser associado, por exemplo, porque não foi encontrado.method cannot be bound, for example because it cannot be found.

O método Invoke de type não foi encontrado.The Invoke method of type is not found.

O chamador não tem as permissões necessárias para acessar method.The caller does not have the permissions necessary to access method.

Comentários

Esse método cria delegados somente para métodos de instância.This method creates delegates for instance methods only. Método de instância é um método associado a uma instância de uma classe; método estático é um método associado à própria classe.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.

Essa sobrecarga de método é equivalente a chamar a CreateDelegate(Type, Object, String, Boolean, Boolean) sobrecarga do método, especificando false para ignoreCase e true para throwOnBindFailure .This method overload is equivalent to calling the CreateDelegate(Type, Object, String, Boolean, Boolean) method overload, specifying false for ignoreCase and true for throwOnBindFailure.

Observação

A partir do .NET Framework 2,0 Service Pack 1, esse método poderá ser usado para acessar métodos não públicos se o chamador tiver sido concedido ReflectionPermission com o ReflectionPermissionFlag.RestrictedMemberAccess sinalizador e se o Grant Set dos métodos não públicos for restrito ao conjunto de concessão do chamador ou a um subconjunto dele.Starting with the .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. (Consulte considerações de segurança para reflexão.)(See Security Considerations for Reflection.)

Para usar essa funcionalidade, seu aplicativo deve ter como destino o .NET Framework 3,5 ou posterior.To use this functionality, your application should target the .NET Framework 3.5 or later.

Confira também

Aplica-se a

CreateDelegate(Type, Object, MethodInfo)

Cria um delegado do tipo especificado que representa o método de instância ou estático especificado com o primeiro argumento especificado.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);
public static Delegate CreateDelegate (Type type, object firstArgument, System.Reflection.MethodInfo method);
static member CreateDelegate : Type * obj * System.Reflection.MethodInfo -> Delegate
Public Shared Function CreateDelegate (type As Type, firstArgument As Object, method As MethodInfo) As Delegate

Parâmetros

type
Type

O Type do representante a ser criado.The Type of delegate to create.

firstArgument
Object

O objeto ao qual o delegado está associado ou null para tratar method como static (Shared no Visual Basic).The object to which the delegate is bound, or null to treat method as static (Shared in Visual Basic).

method
MethodInfo

O MethodInfo que descreve o método estático ou de instância que o representante deve representar.The MethodInfo describing the static or instance method the delegate is to represent.

Retornos

Delegate

Um delegado do tipo especificado que representa o método de instância ou estático especificado.A delegate of the specified type that represents the specified static or instance method.

Exceções

type é null.type is null.

- ou --or- method é null.method is null.

type não herda MulticastDelegate.type does not inherit MulticastDelegate.

- ou --or- type não é um RuntimeType.type is not a RuntimeType. Consulte Runtime Types in Reflection (Tipos de tempo de execução na reflexão).See Runtime Types in Reflection.

- ou --or- method não pode ser associado.method cannot be bound.

- ou --or- method não é um RuntimeMethodInfo.method is not a RuntimeMethodInfo. Consulte Runtime Types in Reflection (Tipos de tempo de execução na reflexão).See Runtime Types in Reflection.

O método Invoke de type não foi encontrado.The Invoke method of type is not found.

O chamador não tem as permissões necessárias para acessar method.The caller does not have the permissions necessary to access method.

Exemplos

Esta seção contém três exemplos de código.This section contains three code examples. O primeiro exemplo demonstra os quatro tipos de delegados que podem ser criados: fechado em um método de instância, aberto em um método de instância, aberto em um método estático e fechado em um método estático.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.

O segundo exemplo de código demonstra tipos de parâmetro correspondentes e tipos de retorno.The second code example demonstrates compatible parameter types and return types.

O terceiro exemplo de código define um único tipo delegate e mostra todos os métodos que o tipo delegado pode representar.The third code example defines a single delegate type, and shows all the methods that delegate type can represent.

Exemplo 1Example 1

O exemplo de código a seguir demonstra as quatro maneiras como um delegado pode ser criado usando essa sobrecarga do CreateDelegate método.The following code example demonstrates the four ways a delegate can be created using this overload of the CreateDelegate method.

Observação

Há duas sobrecargas do método CreateDelegate que especificam firstArgument e MethodInfo; sua funcionalidade é a mesma, exceto por uma permitir especificar se é necessário lançar falha de associação e a outra lançar 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. Este exemplo de código usa ambas as sobrecargas.This code example uses both overloads.

O exemplo declara uma classe C com um método estático M2 e um método de instância M1 , e três tipos delegados: D1 usa uma instância de C e uma cadeia de caracteres, D2 usa uma cadeia de caracteres e D3 não tem argumentos.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.

Uma segunda classe chamada Example contém o código que cria os representantes.A second class named Example contains the code that creates the delegates.

  • Um delegado do tipo D2 , fechado em uma instância do C , é criado para o método de instância M1 .A delegate of type D2, closed over an instance of C, is created for the instance method M1. Ele é invocado com cadeias de caracteres diferentes, para mostrar que a instância associada do C é sempre usada.It is invoked with different strings, to show that the bound instance of C is always used.

  • Um representante de tipo D1, representando um método de instância aberto, é criado para o método de instância M1.A delegate of type D1, representing an open instance method, is created for the instance method M1. Uma instância deve ser passada quando o representante é invocado.An instance must be passed when the delegate is invoked.

  • Um representante de tipo D2, representando um método estático aberto, é criado para o método estático M2.A delegate of type D2, representing an open static method, is created for the static method M2.

  • Por fim, um delegado do tipo D3 , fechado em uma cadeia de caracteres, é criado para o método estático M2 .Finally, a delegate of type D3, closed over a string, is created for the static method M2. O método é chamado para mostrar que ele usa a cadeia de caracteres associada.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!
'

Exemplo 2Example 2

O exemplo de código a seguir demonstra a compatibilidade dos tipos de parâmetro e de retorno.The following code example demonstrates compatibility of parameter types and return types.

Observação

Este exemplo de código usa a CreateDelegate(Type, MethodInfo) sobrecarga do método.This code example uses the CreateDelegate(Type, MethodInfo) method overload. O uso de outras sobrecargas que o Take MethodInfo é semelhante.The use of other overloads that take MethodInfo is similar.

O exemplo de código define uma classe base chamada Base e uma classe chamada Derived derivada de Base.The code example defines a base class named Base and a class named Derived that derives from Base. A classe derivada tem um método static (Shared no Visual Basic) chamado MyMethod com um parâmetro do tipo Base e um retorno do tipo de 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. O exemplo de código também define um representante chamado Example que tem um parâmetro do tipo Derived e um tipo de retorno de Base.The code example also defines a delegate named Example that has one parameter of type Derived and a return type of Base.

O exemplo de código demonstra que o representante chamado Example pode ser usado para representar o método MyMethod.The code example demonstrates that the delegate named Example can be used to represent the method MyMethod. O método pode ser associado ao representante porque:The method can be bound to the delegate because:

  • O tipo de parâmetro do representante (Derived) é mais restritivo do que o tipo de parâmetro MyMethod (Base), logo, é sempre seguro passar o argumento do representante para 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.

  • O tipo de retorno de MyMethod (Derived) é mais restritivo do que o tipo de parâmetro do representante (Base), logo, é sempre seguro converter o tipo de retorno do método no tipo de retorno do representante.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.

O exemplo de código não produz nenhuma saída.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

Exemplo 3Example 3

O exemplo de código a seguir mostra todos os métodos que um único tipo delegate pode representar, usando o CreateDelegate método para criar os delegados.The following code example shows all the methods a single delegate type can represent, using the CreateDelegate method to create the delegates.

Observação

Há duas sobrecargas do método CreateDelegate que especificam firstArgument e MethodInfo; sua funcionalidade é a mesma, exceto por uma permitir especificar se é necessário lançar falha de associação e a outra lançar 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. Este exemplo de código usa ambas as sobrecargas.This code example uses both overloads.

O exemplo de código define duas classes, C e F , e um tipo delegate D com um argumento do tipo C .The code example defines two classes, C and F, and a delegate type D with one argument of type C. As classes têm os métodos static e Instance correspondentes M1 , M3 , e e M4 C a classe também tem um método M2 de instância que não tem argumentos.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.

Uma terceira classe denominada Example contém o código que cria os delegados.A third class named Example contains the code that creates the delegates.

  • Os delegados são criados para M1 o método de instância do tipo C e tipo F ; cada um é fechado em uma instância do respectivo tipo.Delegates are created for instance method M1 of type C and type F; each is closed over an instance of the respective type. Método M1 de tipo C exibe as ID Propriedades da instância associada e do argumento.Method M1 of type C displays the ID properties of the bound instance and of the argument.

  • Um delegado é criado para o método M2 do tipo C .A delegate is created for method M2 of type C. Esse é um delegado de instância aberta, no qual o argumento do delegado representa o primeiro argumento oculto no método de instância.This is an open instance delegate, in which the argument of the delegate represents the hidden first argument on the instance method. O método não tem nenhum outro argumento.The method has no other arguments. Ele é chamado como se fosse um método estático.It is called as if it were a static method.

  • Delegados são criados para método estático M3 de tipo C e tipo F ; são delegados estáticos abertos.Delegates are created for static method M3 of type C and type F; these are open static delegates.

  • Por fim, os delegados são criados para método estático M4 de tipo C e tipo F ; cada método tem o tipo declarativo como seu primeiro argumento e uma instância do tipo é fornecida, portanto, os delegados são fechados sobre seus primeiros argumentos.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. Método M4 de tipo C exibe as ID Propriedades da instância associada e do argumento.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
'

Comentários

Chamar essa sobrecarga de método é equivalente a chamar a CreateDelegate(Type, Object, MethodInfo, Boolean) sobrecarga do método e especificar true for throwOnBindFailure .Calling this method overload is equivalent to calling the CreateDelegate(Type, Object, MethodInfo, Boolean) method overload and specifying true for throwOnBindFailure. Essas duas sobrecargas fornecem a maneira mais flexível de criar delegados.These two overloads provide the most flexible way to create delegates. Você pode usá-los para criar delegados para os métodos estáticos ou de instância e, opcionalmente, especificar o primeiro argumento.You can use them to create delegates for either static or instance methods, and optionally to specify the first argument.

Observação

Se você não fornecer um primeiro argumento, use a CreateDelegate(Type, MethodInfo) sobrecarga do método para melhorar o desempenho.If you do not supply a first argument, use the CreateDelegate(Type, MethodInfo) method overload for better performance.

O tipo delegado e o método devem ter tipos de retorno compatíveis.The delegate type and the method must have compatible return types. Ou seja, o tipo de retorno de method deve ser atribuível ao tipo de retorno de type .That is, the return type of method must be assignable to the return type of type.

Se firstArgument for fornecido, ele será transmitido a method cada vez que o delegado for invocado; firstArgument deve estar associado ao delegado e o delegado deve ser fechado em seu primeiro argumento.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 for static ( Shared em Visual Basic), a lista de argumentos fornecida ao invocar o delegado incluirá todos os parâmetros, exceto o primeiro; se method for um método de instância, firstArgument será passada para o parâmetro de instância oculta (representado por this em C# ou por Me no 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 for fornecido, o primeiro parâmetro de method deve ser um tipo de referência e firstArgument deve ser compatível com esse 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 ( Shared em Visual Basic) e seu primeiro parâmetro é do tipo Object ou ValueType , firstArgument pode ser um tipo de valor.If method is static (Shared in Visual Basic) and its first parameter is of type Object or ValueType, then firstArgument can be a value type. Nesse caso, firstArgument é automaticamente emoldurado.In this case firstArgument is automatically boxed. A Boxing automática não ocorre para nenhum outro argumento, como faria em uma chamada de função C# ou Visual Basic.Automatic boxing does not occur for any other arguments, as it would in a C# or Visual Basic function call.

Se firstArgument for uma referência nula e method for um método de instância, o resultado dependerá das assinaturas do tipo delegado type e de 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 a assinatura de type incluir explicitamente o primeiro parâmetro oculto de method , o delegado será considerado para representar um método de instância aberta.If the signature of type explicitly includes the hidden first parameter of method, the delegate is said to represent an open instance method. Quando o delegado é invocado, o primeiro argumento na lista de argumentos é passado para o parâmetro de instância oculta de method .When the delegate is invoked, the first argument in the argument list is passed to the hidden instance parameter of method.

  • Se as assinaturas de method e type corresponderem (ou seja, todos os tipos de parâmetro forem compatíveis), o delegado será considerado para ser fechado em uma referência nula.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. Invocar o delegado é como chamar um método de instância em uma instância nula, o que não é uma coisa particularmente útil.Invoking the delegate is like calling an instance method on a null instance, which is not a particularly useful thing to do.

Se firstArgument for uma referência nula e method for estática, o resultado dependerá das assinaturas do tipo delegado type e de 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 a assinatura method e a type correspondência (ou seja, todos os tipos de parâmetro forem compatíveis), o delegado será considerado para representar um método estático aberto.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. Esse é o caso mais comum para métodos estáticos.This is the most common case for static methods. Nesse caso, você pode obter um desempenho ligeiramente melhor usando a CreateDelegate(Type, MethodInfo) sobrecarga do método.In this case, you can get slightly better performance by using the CreateDelegate(Type, MethodInfo) method overload.

  • Se a assinatura de type começar com o segundo parâmetro de method e o restante dos tipos de parâmetro forem compatíveis, o delegado será considerado para ser fechado em uma referência nula.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 o delegado é invocado, uma referência nula é passada para o primeiro parâmetro de method .When the delegate is invoked, a null reference is passed to the first parameter of method.

Observação

A partir do .NET Framework 2,0 Service Pack 1, esse método poderá ser usado para acessar métodos não públicos se o chamador tiver sido concedido ReflectionPermission com o ReflectionPermissionFlag.RestrictedMemberAccess sinalizador e se o Grant Set dos métodos não públicos for restrito ao conjunto de concessão do chamador ou a um subconjunto dele.Starting with the .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. (Consulte considerações de segurança para reflexão.)(See Security Considerations for Reflection.)

Para usar essa funcionalidade, seu aplicativo deve ter como destino o .NET Framework 3,5 ou posterior.To use this functionality, your application should target the .NET Framework 3.5 or later.

Tipos de parâmetro compatíveis e tipo de retornoCompatible Parameter Types and Return Type

Os tipos de parâmetro e o tipo de retorno de um delegado devem ser compatíveis com os tipos de parâmetro e o tipo de retorno do método que o delegado representa; os tipos não precisam corresponder exatamente.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.

Observação

No .NET Framework versão 1,0 e 1,1, os tipos devem corresponder exatamente.In the .NET Framework version 1.0 and 1.1, the types must match exactly.

Um parâmetro de um delegado será compatível com o parâmetro correspondente de um método se o tipo do parâmetro de delegado for mais restritivo do que o tipo do parâmetro de método, porque isso garante que um argumento passado para o delegado possa ser passado com segurança para o método.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.

Da mesma forma, o tipo de retorno de um delegado será compatível com o tipo de retorno de um método se o tipo de retorno do método for mais restritivo do que o tipo de retorno do delegado, porque isso garante que o valor retornado do método possa ser convertido com segurança para o tipo retorno do delegado.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.

Por exemplo, um delegado com um parâmetro de tipo Hashtable e um tipo de retorno de Object pode representar um método com um parâmetro de tipo Object e um valor de retorno do 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.

Determinando os métodos que um delegado pode representarDetermining the Methods a Delegate Can Represent

Outra maneira útil de considerar a flexibilidade fornecida por essa sobrecarga de CreateDelegate é que qualquer delegado determinado pode representar quatro combinações diferentes de assinatura de método e tipo de método (estático versus instância).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). Considere um tipo delegado D com um argumento do tipo C .Consider a delegate type D with one argument of type C. Veja a seguir uma descrição dos métodos D que podem ser representados, ignorando o tipo de retorno, pois ele deve corresponder em todos os casos:The following describes the methods D can represent, ignoring the return type since it must match in all cases:

  • D pode representar qualquer método de instância que tenha exatamente um argumento do tipo C , independentemente do tipo ao qual o método de instância pertence.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 é chamado, firstArgument é uma instância do tipo method que pertence e o delegado resultante é dito para ser fechado nessa instância.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. (Trivialmente, D também pode ser fechado em uma referência nula se firstArgument for uma referência nula.)(Trivially, D can also be closed over a null reference if firstArgument is a null reference.)

  • D pode representar um método de instância do C que não tem argumentos.D can represent an instance method of C that has no arguments. Quando CreateDelegate é chamado, firstArgument é uma referência nula.When CreateDelegate is called, firstArgument is a null reference. O delegado resultante representa um método de instância aberta e uma instância do C deve ser fornecida cada vez que é invocada.The resulting delegate represents an open instance method, and an instance of C must be supplied each time it is invoked.

  • D pode representar um método estático que usa um argumento do tipo C , e esse método pode pertencer a qualquer tipo.D can represent a static method that takes one argument of type C, and that method can belong to any type. Quando CreateDelegate é chamado, firstArgument é uma referência nula.When CreateDelegate is called, firstArgument is a null reference. O delegado resultante representa um método estático aberto, e uma instância de C deve ser fornecida sempre que for invocada.The resulting delegate represents an open static method, and an instance of C must be supplied each time it is invoked.

  • D pode representar um método estático que pertence ao tipo F e tem dois argumentos, do tipo F e do tipo C .D can represent a static method that belongs to type F and has two arguments, of type F and type C. Quando CreateDelegate é chamado, firstArgument é uma instância do F .When CreateDelegate is called, firstArgument is an instance of F. O delegado resultante representa um método estático que é fechado nessa instância do F .The resulting delegate represents a static method that is closed over that instance of F. Observe que, no caso F e C são do mesmo tipo, o método estático tem dois argumentos desse tipo.Note that in the case where F and C are the same type, the static method has two arguments of that type. (Nesse caso, D será fechado em uma referência nula se firstArgument for uma referência nula.)(In this case, D is closed over a null reference if firstArgument is a null reference.)

Confira também

Aplica-se a

CreateDelegate(Type, Type, String)

Cria um delegado do tipo especificado que representa o método estático especificado da classe especificada.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
Public Shared Function CreateDelegate (type As Type, target As Type, method As String) As Delegate

Parâmetros

type
Type

O Type do representante a ser criado.The Type of delegate to create.

target
Type

O Type que representa a classe que implementa method.The Type representing the class that implements method.

method
String

O nome do método estático que o delegado deve representar.The name of the static method that the delegate is to represent.

Retornos

Delegate

Um delegado do tipo especificado que representa o método especificado estático da classe especificada.A delegate of the specified type that represents the specified static method of the specified class.

Exceções

type é null.type is null.

- ou --or- target é null.target is null.

- ou --or- method é null.method is null.

type não herda MulticastDelegate.type does not inherit MulticastDelegate.

- ou --or- type não é um RuntimeType.type is not a RuntimeType. Consulte Runtime Types in Reflection (Tipos de tempo de execução na reflexão).See Runtime Types in Reflection.

- ou --or- target não é um RuntimeType.target is not a RuntimeType.

- ou --or- target é um tipo genérico aberto.target is an open generic type. Ou seja, sua propriedade ContainsGenericParameters é true.That is, its ContainsGenericParameters property is true.

- ou --or- O method não é um método static (método Shared no Visual Basic).method is not a static method (Shared method in Visual Basic).

- ou --or- method não pode ser associado, por exemplo, porque não foi encontrado e throwOnBindFailure é true.method cannot be bound, for example because it cannot be found, and throwOnBindFailure is true.

O método Invoke de type não foi encontrado.The Invoke method of type is not found.

O chamador não tem as permissões necessárias para acessar method.The caller does not have the permissions necessary to access method.

Comentários

Esse método cria delegados somente para métodos estáticos.This method creates delegates for static methods only. Método de instância é um método associado a uma instância de uma classe; método estático é um método associado à própria classe.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.

Essa sobrecarga de método é equivalente a chamar a CreateDelegate(Type, Type, String, Boolean, Boolean) sobrecarga do método, especificando false para ignoreCase e true para throwOnBindFailure .This method overload is equivalent to calling the CreateDelegate(Type, Type, String, Boolean, Boolean) method overload, specifying false for ignoreCase and true for throwOnBindFailure.

Observação

A partir do .NET Framework 2,0 Service Pack 1, esse método poderá ser usado para acessar métodos não públicos se o chamador tiver sido concedido ReflectionPermission com o ReflectionPermissionFlag.RestrictedMemberAccess sinalizador e se o Grant Set dos métodos não públicos for restrito ao conjunto de concessão do chamador ou a um subconjunto dele.Starting with the .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. (Consulte considerações de segurança para reflexão.)(See Security Considerations for Reflection.)

Para usar essa funcionalidade, seu aplicativo deve ter como destino o .NET Framework 3,5 ou posterior.To use this functionality, your application should target the .NET Framework 3.5 or later.

Confira também

Aplica-se a

CreateDelegate(Type, MethodInfo)

Cria um delegado do tipo especificado para representar o método estático especificado.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
Public Shared Function CreateDelegate (type As Type, method As MethodInfo) As Delegate

Parâmetros

type
Type

O Type do representante a ser criado.The Type of delegate to create.

method
MethodInfo

O MethodInfo que descreve o método estático ou de instância que o representante deve representar.The MethodInfo describing the static or instance method the delegate is to represent. Há suporte apenas para métodos estáticos no .NET Framework versão 1.0 e 1.1.Only static methods are supported in the .NET Framework version 1.0 and 1.1.

Retornos

Delegate

Um delegado do tipo especificado para representar o método estático especificado.A delegate of the specified type to represent the specified static method.

Exceções

type é null.type is null.

- ou --or- method é null.method is null.

type não herda MulticastDelegate.type does not inherit MulticastDelegate.

- ou --or- type não é um RuntimeType.type is not a RuntimeType. Consulte Runtime Types in Reflection (Tipos de tempo de execução na reflexão).See Runtime Types in Reflection.

- ou --or- method não é um método estático, e a versão do .NET Framework é 1.0 ou 1.1.method is not a static method, and the .NET Framework version is 1.0 or 1.1.

- ou --or- method não pode ser associado.method cannot be bound.

- ou --or- method não é um RuntimeMethodInfo.method is not a RuntimeMethodInfo. Consulte Runtime Types in Reflection (Tipos de tempo de execução na reflexão).See Runtime Types in Reflection.

O método Invoke de type não foi encontrado.The Invoke method of type is not found.

O chamador não tem as permissões necessárias para acessar method.The caller does not have the permissions necessary to access method.

Exemplos

Esta seção contém dois exemplos de código.This section contains two code examples. O primeiro exemplo demonstra os dois tipos de delegados que podem ser criados com essa sobrecarga de método: abrir em um método de instância e abrir em um método estático.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.

O segundo exemplo de código demonstra tipos de parâmetro correspondentes e tipos de retorno.The second code example demonstrates compatible parameter types and return types.

Exemplo 1Example 1

O exemplo de código a seguir demonstra as duas maneiras como um delegado pode ser criado usando essa sobrecarga do CreateDelegate método.The following code example demonstrates the two ways a delegate can be created using this overload of the CreateDelegate method.

Observação

Há duas sobrecargas do CreateDelegate método que especificam um MethodInfo , mas não um primeiro argumento; sua funcionalidade é a mesma, exceto pelo fato de que um permite que você especifique se deseja gerar uma falha na associação e o outro sempre é gerado.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. Este exemplo de código usa ambas as sobrecargas.This code example uses both overloads.

O exemplo declara uma classe C com um método estático M2 e um método de instância M1 , e dois tipos delegados: D1 usa uma instância de C e uma cadeia de caracteres e D2 usa uma cadeia de caracteres.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.

Uma segunda classe chamada Example contém o código que cria os representantes.A second class named Example contains the code that creates the delegates.

  • Um representante de tipo D1, representando um método de instância aberto, é criado para o método de instância M1.A delegate of type D1, representing an open instance method, is created for the instance method M1. Uma instância deve ser passada quando o representante é invocado.An instance must be passed when the delegate is invoked.

  • Um representante de tipo D2, representando um método estático aberto, é criado para o método estático M2.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!
'

Exemplo 2Example 2

O exemplo de código a seguir demonstra a compatibilidade dos tipos de parâmetro e de retorno.The following code example demonstrates compatibility of parameter types and return types.

O exemplo de código define uma classe base chamada Base e uma classe chamada Derived derivada de Base.The code example defines a base class named Base and a class named Derived that derives from Base. A classe derivada tem um método static (Shared no Visual Basic) chamado MyMethod com um parâmetro do tipo Base e um retorno do tipo de 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. O exemplo de código também define um representante chamado Example que tem um parâmetro do tipo Derived e um tipo de retorno de Base.The code example also defines a delegate named Example that has one parameter of type Derived and a return type of Base.

O exemplo de código demonstra que o representante chamado Example pode ser usado para representar o método MyMethod.The code example demonstrates that the delegate named Example can be used to represent the method MyMethod. O método pode ser associado ao representante porque:The method can be bound to the delegate because:

  • O tipo de parâmetro do representante (Derived) é mais restritivo do que o tipo de parâmetro MyMethod (Base), logo, é sempre seguro passar o argumento do representante para 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.

  • O tipo de retorno de MyMethod (Derived) é mais restritivo do que o tipo de parâmetro do representante (Base), logo, é sempre seguro converter o tipo de retorno do método no tipo de retorno do representante.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.

O exemplo de código não produz nenhuma saída.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

Comentários

No .NET Framework versão 1,0 e 1,1, essa sobrecarga de método cria delegados somente para métodos estáticos.In the .NET Framework version 1.0 and 1.1, this method overload creates delegates for static methods only. Na versão .NET Framework 2,0, essa sobrecarga de método também pode criar delegados de método de instância aberta; ou seja, delegados que fornecem explicitamente o primeiro argumento oculto de métodos de instância.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. Para obter uma explicação detalhada, consulte a sobrecarga de método mais geral CreateDelegate(Type, Object, MethodInfo) , que permite criar todas as combinações de delegados abertos ou fechados para métodos de instância ou estático e, opcionalmente, especificar um primeiro argumento.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.

Observação

Essa sobrecarga de método deve ser usada quando o delegado não é fechado em seu primeiro argumento, pois é um pouco mais rápido nesse caso.This method overload should be used when the delegate is not closed over its first argument, because it is somewhat faster in that case.

Essa sobrecarga de método é equivalente a chamar a CreateDelegate(Type, MethodInfo, Boolean) sobrecarga do método e especificar true for throwOnBindFailure .This method overload is equivalent to calling the CreateDelegate(Type, MethodInfo, Boolean) method overload and specifying true for throwOnBindFailure.

Observação

A partir do .NET Framework 2,0 Service Pack 1, esse método poderá ser usado para acessar métodos não públicos se o chamador tiver sido concedido ReflectionPermission com o ReflectionPermissionFlag.RestrictedMemberAccess sinalizador e se o Grant Set dos métodos não públicos for restrito ao conjunto de concessão do chamador ou a um subconjunto dele.Starting with the .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. (Consulte considerações de segurança para reflexão.)(See Security Considerations for Reflection.)

Para usar essa funcionalidade, seu aplicativo deve ter como destino o .NET Framework 3,5 ou posterior.To use this functionality, your application should target the .NET Framework 3.5 or later.

Tipos de parâmetro compatíveis e tipo de retornoCompatible Parameter Types and Return Type

No .NET Framework versão 2,0, os tipos de parâmetro e o tipo de retorno de um delegado criado usando essa sobrecarga de método devem ser compatíveis com os tipos de parâmetro e o tipo de retorno do método que o delegado representa; os tipos não precisam corresponder exatamente.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. Isso representa um relaxamento do comportamento de associação no .NET Framework versão 1,0 e 1,1, em que os tipos devem corresponder exatamente.This represents a relaxation of the binding behavior in the .NET Framework version 1.0 and 1.1, where the types must match exactly.

Um parâmetro de um delegado será compatível com o parâmetro correspondente de um método se o tipo do parâmetro de delegado for mais restritivo do que o tipo do parâmetro de método, porque isso garante que um argumento passado para o delegado possa ser passado com segurança para o método.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.

Da mesma forma, o tipo de retorno de um delegado será compatível com o tipo de retorno de um método se o tipo de retorno do método for mais restritivo do que o tipo de retorno do delegado, porque isso garante que o valor retornado do método possa ser convertido com segurança para o tipo retorno do delegado.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.

Por exemplo, um delegado com um parâmetro de tipo Hashtable e um tipo de retorno de Object pode representar um método com um parâmetro de tipo Object e um valor de retorno do 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.

Confira também

Aplica-se a