Método CreateDelegate (Type, Object, MethodInfo, Boolean)
Este artigo foi traduzido por máquina. Coloque o ponteiro do mouse sobre as frases do artigo para ver o texto original. Mais informações.
Tradução
Original

Método Delegate.CreateDelegate (Type, Object, MethodInfo, Boolean)

Cria um delegado do tipo especificado que representa o estático especificado ou o método de instância, com o primeiro argumento especificado e o comportamento especificado em caso de falha para BIND.

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

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

Parâmetros

type
Tipo: System.Type
A Type que representa o tipo de delegado para criar.
firstArgument
Tipo: System.Object
An Object é o primeiro argumento do método que o delegado representa. Por exemplo métodos, ele deve ser compatível com o tipo de instância.
method
Tipo: System.Reflection.MethodInfo
The MethodInfo descrevendo o estático ou método é o delegado representar da instância.
throwOnBindFailure
Tipo: System.Boolean
true Lançar uma exceção se method não pode ser limite; caso contrário, false.

Valor de retorno

Tipo: System.Delegate
Um delegado do tipo especificado que representa a estático especificado ou método de instância ou null Se throwOnBindFailure é false e o delegado não pode ser limite a method.

ExceçãoCondição
ArgumentNullException

type é null.

- ou -

method é null.

ArgumentException

type não é herdada MulticastDelegate.

- ou -

type não é um RuntimeType. Consulte Tipos de tempo de execução em Reflexo.

- ou -

method não pode ser limite e throwOnBindFailure é true.

- ou -

method não é um RuntimeMethodInfo. Consulte Tipos de tempo de execução em Reflexo.

MissingMethodException

The Invoke método de type não foi encontrado.

MethodAccessException

O chamador não tem as permissões necessárias para acesso method.

Essa sobrecarga de método e o CreateDelegate(Type, Object, MethodInfo) sobrecarga de método, que sempre lança em caso de falha para BIND, fornecem o método mais flexível para criar delegados. Você pode usá-los para criar delegados para qualquer estático ou métodos de instância, com ou sem um argumento primeiro.

ObservaçãoObservação:

Se você não fornecer um primeiro argumento, use o CreateDelegate(Type, MethodInfo, Boolean) método de sobrecarga para melhorar o desempenho.

O tipo de delegado e o método devem ter tipos de retorno compatível.Ou seja, o retorno tipo de method deve ser pode ser atribuído ao tipo de retorno type.

If firstArgument é fornecido, ele é passado para method sempre que o delegado é chamado; firstArgument deve ser limite a delegado, e o delegado é chamado a ser fechado em seu primeiro argumento. If method é static (Shared no Visual Basic), a lista de argumento fornecida ao invocar o delegado inclui todos os parâmetros, exceto a primeira; se method é um método de instância, em seguida firstArgument é passado para o parâmetro da instância oculto (representado por this em translation from VPE for Csharp ou por Me no Visual Basic).

If firstArgument for fornecido, o primeiro parâmetro do method deve ser um tipo de referência e firstArgument deve ser compatível com esse tipo.

Observação importanteObservação importante:

Se method é static (Shared no Visual Basic) e seu primeiro parâmetro é do tipo Object ou ValueType, em seguida, firstArgument pode ser um tipo de valor. Neste caso firstArgument Processador automaticamente. Conversão boxing automático não ocorre para outros argumentos, sistema autônomo ele em uma função translation from VPE for Csharp ou o Visual Basic chamaria.

If firstArgument é um nulo referência e method é um método de instância, o resultado depende das assinaturas do tipo delegado type e do method:

  • Se a assinatura de type inclui explicitamente o primeiro parâmetro oculto do method, o delegado é chamado de representar um método de instância aberta. Quando o delegado é chamado, o primeiro argumento na lista do argumento é passado para o parâmetro instância oculto de method.

  • Se as assinaturas de method e type corresponder (ou seja, todos os tipos de parâmetro são compatível), e, em seguida, o delegado é chamado de ser fechado em um nulo referência. Invocar o delegado é como chamar um método de instância em um nulo instância, que não é algo muito útil fazer.

If firstArgument é um nulo referência e method é estático, o resultado depende as assinaturas do tipo delegado type e do method:

  • Se a assinatura de method e type corresponder (ou seja, todos os tipos de parâmetro são compatível), o delegado é chamado de representar um método estático em aberto. Isso é o caso mais comum para métodos estático.Nesse caso, você pode obter um pouco melhor desempenho usando o CreateDelegate(Type, MethodInfo, Boolean) sobrecarga de método.

  • Se a assinatura de type começa com o segundo parâmetro do method o restante dos tipos de parâmetro são compatível e o delegado é chamado de ser fechado em um nulo referência. Quando o delegado é chamado, uma referência nula é passada para o primeiro parâmetro de method.

ObservaçãoObservação:

Iniciando com o .NET Framework versão 2.0 Service Pack 1, esse método pode ser usado para acessar métodos não-públicos que o chamador tenha sido concedido ReflectionPermission com o ReflectionPermissionFlag.RestrictedMemberAccess Sinalizar e se o conjunto de concessão dos métodos não-públicos é restrito ao chamador conceder conjunto ou um subconjunto deles. (See Considerações de segurança parReflexo.)

Para usar esta funcionalidade, seu aplicativo deve destino o .NET Framework versão 3.5 .Para obter mais informações, consulte Arquitetura do .NET Framework 3.5 .

Compatível com tipos de parâmetros e o tipo de retorno

Os tipos de parâmetro e tipo de retorno de um delegado devem ser compatível com os tipos de parâmetro e tipo de retorno do método o delegado representa; os tipos não precisam coincidir exatamente.

ObservaçãoObservação:

No .NET estrutura versão 1.0 e 1.1 os tipos devem coincidir exatamente.

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

Da mesma forma, o tipo de retorno de um delegado é 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 de retorno do método possa ser difundido com segurança para o tipo retorno do delegado.

Por exemplo, um representante 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 de tipo Hashtable.

Determinando os métodos um delegado pode representar

Outra maneira útil de pensar a flexibilidade oferecida por essa sobrecarga de CreateDelegate é que qualquer dado delegado pode representar quatro combinações diferentes de assinatura do método e o tipo de método (estático em vez de instância). Considere um tipo de delegado D com um argumento de tipo C. A seguir descreve os métodos D pode representar, ignorando o tipo de retorno, pois devem corresponder em todos os casos:

  • D pode representar qualquer método de instância tem exatamente um argumento de tipo C, independentemente do tipo o método de instância pertence. Quando CreateDelegate é chamado, firstArgument é uma instância de tipo method pertence, e o delegado resultante é chamado a ser fechado por essa instância. (Muito, D também pode ser fechado em um nulo referência se firstArgument é null.)

  • D pode representar um método de instância de C que não possui argumentos. Quando CreateDelegate é chamado, firstArgument é um nulo referência. O delegado resultante representa um método de instância aberta e uma instância de C deve ser fornecido cada time é invocado.

  • D pode representar um método estático que tem um argumento de tipo C, e que o método pode pertencer a qualquer tipo. Quando CreateDelegate é chamado, firstArgument é um nulo referência. O delegado resultante representa um método estático em aberto e uma instância da C deve ser fornecida sempre que for chamado.

  • D pode representar um método estático que pertence ao digitar F e tem dois argumentos de tipo F e digite C. Quando CreateDelegate é chamado, firstArgument é uma instância de F. O delegado resultante representa um método estático que fechado por essa instância do F. Observe que, no caso em que F e C o mesmo tipo, o método estático tem dois argumentos desse tipo. (No caso, D é fechada através de uma referência nula se firstArgument é null.)

Esta seção contém três exemplos de código.O primeiro exemplo demonstra os quatro tipos de delegados que podem ser criados: fechada através de um método de instância em aberto por um método de instância em aberto por um método estático e fechado em um método estático.

O segundo exemplo de código demonstra os tipos de parâmetro compatível e tipos de retorno.

O terceiro exemplo de código define um tipo delegado único e mostra todos os métodos de tipo delegado podem representar.

Exemplo 1

O exemplo de código a seguir demonstra as quatro maneiras que um delegado pode ser criado com essa sobrecarga do CreateDelegate método.

ObservaçãoObservação:

Há duas sobrecargas das CreateDelegate método que especifica firstArgument e um MethodInfo; sua funcionalidade é o mesmo, exceto que um permite que você especifique se deseja lançar no caso de falha para BIND e o Outros sempre lança. Este exemplo de código usa ambas sobrecargas.

O exemplo declara uma classe C com um método estático M2 e um método de instância M1, e delegado a três tipos: D1 obtém uma instância de C e uma seqüência de caracteres D2 usa uma cadeia de caracteres e D3 não possui argumentos.

Uma segunda classe nomeada Example contém o código que cria os delegados.

  • Um delegado do tipo D2, fechado em uma instância do C, é criada para o método de instância M1. Ele é chamado com seqüências de caracteres diferentes, para mostrar que a instância limite de C é sempre usado.

  • Um delegado do tipo D1, que representa um método de instância aberta é criada para o método de instância M1. Uma instância deve ser passada quando o delegado é chamado.

  • Um delegado do tipo D2, que representa um método estático em aberto, é criada para o método estático M2.

  • Finalmente, um delegado do tipo D3, fechado em uma seqüência de caracteres, é criada para o método estático M2. O método é invocado para mostrar que ele usa a seqüência de caracteres de limite.

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.//publicdelegatevoid D1(C c, string s);
publicdelegatevoid D2(string s);
publicdelegatevoid D3();

// A sample class with an instance method and a static method.//publicclass C
{
    privateint id;
    public C(int id) { this.id = id; }

    publicvoid M1(string s) 
    { 
        Console.WriteLine("Instance method M1 on C:  id = {0}, s = {1}",
            this.id, s);
    }

    publicstaticvoid M2(string s)
    { 
        Console.WriteLine("Static method M2 on C:  s = {0}", s); 
    }
}

publicclass Example
{
    publicstaticvoid 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 static 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!
 */

Exemplo 2

O exemplo de código a seguir demonstra a compatibilidade dos tipos de parâmetro e tipos de retorno.

ObservaçãoObservação:

Este exemplo de código usa o CreateDelegate(Type, MethodInfo) sobrecarga de método. O uso de outras sobrecargas que utilizam MethodInfo é semelhante.

O exemplo de código define uma classe base chamada Base e uma classe chamada Derived que deriva de Base. A classe derivada possui um static (Shared no Visual Basic) chamado de método MyMethod com um parâmetro de tipo Base e um tipo de retorno de Derived. O exemplo de código também define um delegado chamado Example que tem um parâmetro de tipo Derived e um tipo de retorno de Base.

O exemplo de código demonstra que o delegado nomeada Example pode ser usado para representar o método MyMethod. O método pode ser limite ao delegado porque:

  • O tipo de parâmetro do delegado (Derived) é mais restritivo que o tipo de parâmetro MyMethod (Base), para que sempre seja seguro passar o argumento do representante para MyMethod.

  • O tipo de retorno de MyMethod (Derived) é mais restritivo que o tipo de parâmetro de (delegadoBase), para que sempre seja seguro para converter o tipo de retorno do método para o tipo de retorno do delegado.

O exemplo de código não produz nenhuma saída.

using System;
using System.Reflection;

// Define two classes to use in the demonstration, a base class and // a class that derives from it.//publicclass Base {}

publicclass 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. //publicstatic Derived MyMethod(Base arg)
    {
        Base dummy = arg;
        returnnew Derived();
    }
}

// Define a delegate that takes an instance of Derived and returns an// instance of Base.//publicdelegate Base Example(Derived arg);

class Test
{
    publicstaticvoid 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 covariance of parameter types and contravariance// 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());
    }
}


Exemplo 3

O exemplo de código a seguir mostra todos os métodos que pode representar um tipo delegado único.

ObservaçãoObservação:

Há duas sobrecargas das CreateDelegate método que especifica firstArgument e um MethodInfo; sua funcionalidade é o mesmo, exceto que um permite que você especifique se deseja lançar no caso de falha para BIND e o Outros sempre lança. Este exemplo de código usa ambas sobrecargas.

O exemplo de código define duas classes, C e Fe um tipo delegado D com um argumento de tipo C. As classes têm estática correspondente e métodos de instância M1, M3, e M4e classe C também tem um método de instância M2 que não possui argumentos.

Uma terceira classe chamado Example contém o código que cria os delegados.

  • Delegados são criados por exemplo do método M1 do tipo C e digite F; cada um é fechada através de uma instância do tipo respectivo. Método M1 do tipo C Exibe a ID Propriedades da instância acoplada e do argumento.

  • Um delegado é criado para o método M2 do tipo C. Este é um delegado de instância aberta, o argumento do delegado representa o primeiro argumento oculto no método de instância.O método não tem outros argumentos.

  • Delegados são criados para o método estático M3 do tipo C e digite F; Estes são abertos delegados estáticos.

  • Por fim, delegados são criados para o método estático M4 do tipo C e digite F; cada método tem o tipo declarativo sistema autônomo seu primeiro argumento, e uma instância do tipo for fornecida, para que sistema autônomo delegados são fechados em seus argumentos primeiro. Método M4 do tipo C Exibe a ID Propriedades da instância acoplada e do argumento.

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.//publicdelegatevoid D(C c);

// Declare two sample classes, C and F. Class C has an ID// property so instances can be identified.//publicclass C
{
    privateint id;
    publicint ID { get { return id; }}
    public C(int id) { this.id = id; }

    publicvoid M1(C c) 
    { 
        Console.WriteLine("Instance method M1(C c) on C:  this.id = {0}, c.ID = {1}",
            this.id, c.ID);
    }

    publicvoid M2() 
    { 
        Console.WriteLine("Instance method M2() on C:  this.id = {0}",
            this.id);
    }

    publicstaticvoid M3(C c)
    { 
        Console.WriteLine("Static method M3(C c) on C:  c.ID = {0}", c.ID); 
    }

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

publicclass F
{
    publicvoid M1(C c) 
    { 
        Console.WriteLine("Instance method M1(C c) on F:  c.ID = {0}",
            c.ID);
    }

    publicstaticvoid M3(C c)
    { 
        Console.WriteLine("Static method M3(C c) on F:  c.ID = {0}", c.ID); 
    }

    publicstaticvoid M4(F f, C c) 
    { 
        Console.WriteLine("Static method M4(F f, C c) on F:  c.ID = {0}",
            c.ID);
    }
}


publicclass Example
{
    publicstaticvoid 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
*/

Windows Vista, Windows XP SP2, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP Starter Edition, Windows Server 2003, Windows Server 2000 SP4, Windows Millennium Edition, Windows 98

o.NET Framework e.NET Compact Framework não oferecem suporte a todas as versões de cada plataforma. Para obter uma lista de versões suportadas, consulte Requisitos de sistema do .NET framework.

.NET Framework

Compatível com: 3.5, 3.0, 2.0

Contribuições da comunidade

ADICIONAR
Mostrar:
© 2016 Microsoft