Este artigo foi traduzido por máquina. Para visualizar o arquivo em inglês, marque a caixa de seleção Inglês. Você também pode exibir o texto Em inglês em uma janela pop-up, movendo o ponteiro do mouse sobre o texto.
Tradução
Inglês
Esta documentação foi arquivada e não está sendo atualizada.

Método Delegate.CreateDelegate (Type, MethodInfo)

Cria um delegado do tipo especificado para representar o método estático especificado.

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

public static Delegate CreateDelegate(
	Type type,
	MethodInfo method
)

Parâmetros

type
Tipo: System.Type
The Type do delegado para criar.
method
Tipo: System.Reflection.MethodInfo
The MethodInfo descrevendo o estático ou método é o delegado representar da instância. Há suporte para apenas métodos estático no .NET estrutura versão 1.0 e 1.1.

Valor de retorno

Tipo: System.Delegate
Um delegado do tipo especificado para representar o método estático especificado.

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 é um método estático e é a versão do .NET estrutura 1.0 ou 1.1.

- ou -

method não pode ser limite.

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

No .NET estrutura versão 1.0 e 1.1, essa sobrecarga de método cria delegados para métodos estático apenas.No .NET estrutura versão 2.0, essa sobrecarga de método também pode criar em aberto delegados de método de instância, ou seja, delegados que fornecem explicitamente o primeiro argumento oculto de métodos de instância.Para obter uma explicação detalhada, consulte o mais geral CreateDelegate(Type, Object, MethodInfo) sobrecarga de método, que lhe permite criar todas as combinações de em aberto ou fechado delegados para instância ou métodos estático e, opcionalmente, para especificar um primeiro argumento.

ObservaçãoObservação:

Essa sobrecarga de método deve ser usada quando o delegado não for fechado através de seu primeiro argumento, porque ele é um pouco mais rápido, nesse caso.

Essa sobrecarga de método é equivalente a chamar o CreateDelegate(Type, MethodInfo, Boolean) sobrecarga de método e especificando true para throwOnBindFailure.

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

No .NET estrutura versão 2.0, os tipos de parâmetro e tipo de retorno de um delegado criado usando essa sobrecarga de método 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.Isso representa um relaxamento do comportamento de ligação no .NET estrutura versão 1.0 e 1.1, onde 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.

Esta seção contém dois exemplos de código.O primeiro exemplo demonstra os dois tipos de delegados que podem ser criados com essa sobrecarga de método: em em aberto em um método de instância e abra através de um método estático.

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

Exemplo 1

O exemplo de código a seguir demonstra duas formas a 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 um MethodInfo mas não é um argumento primeiro; 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 dois tipos: D1 obtém uma instância de C e uma seqüência de caracteres, e D2 usa uma cadeia de caracteres.

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

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

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.

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


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, 1.1, 1.0
Mostrar: