DefineGenericParameters Método (String[])
Este artículo se tradujo automáticamente. Para ver el artículo en inglés, active la casilla Inglés. Además, puede mostrar el texto en inglés en una ventana emergente si mueve el puntero del mouse sobre el texto.
Traducción
Inglés

MethodBuilder.DefineGenericParameters (Método) (String[])

 

Establece el número de parámetros de tipo genérico del método actual, especifica sus nombres y devuelve una matriz de objetos GenericTypeParameterBuilder que se pueden utilizar para definir sus restricciones.

Espacio de nombres:   System.Reflection.Emit
Ensamblado:  mscorlib (en mscorlib.dll)

public GenericTypeParameterBuilder[] DefineGenericParameters(
	params string[] names
)

Parámetros

names

Matriz de cadenas que representan los nombres de los parámetros de tipo genérico.

Valor devuelto

Type: System.Reflection.Emit.GenericTypeParameterBuilder[]

Una matriz de objetos GenericTypeParameterBuilder que representan los parámetros de tipo del método genérico.

Exception Condition
InvalidOperationException

Los parámetros de tipo genérico ya se han definido para este método.

-o-

Ya ha finalizado el método.

-o-

El método actual ha llamado al método SetImplementationFlags.

ArgumentNullException

names es null.

-o-

Un elemento de names es null.

ArgumentException

names es una matriz vacía.

Al llamar al método DefineGenericParameters, el actual método se convierte en método genérico.No se puede deshacer este cambio.Si se llama otra vez a este método, se genera una excepción InvalidOperationException.

Los parámetros de tipo del método genérico pueden recuperarse más adelante mediante el método GetGenericArguments.

Por convención, el nombre de un parámetro de tipo es una sola letra mayúscula.

Para obtener más información, vea MethodInfo.IsGenericMethod y MethodInfo.GetGenericMethodDefinition.Para obtener información sobre los tipos genéricos, vea Type.IsGenericType.

En el ejemplo de código siguiente se crea un tipo dinámico, DemoType, que contiene el método genérico dinámico DemoMethod.Este método tiene dos parámetros de tipo genérico, uno de los cuales se utiliza como parámetro y el otro se utiliza como tipo de valor devuelto.

Cuando se ejecuta el código, el ensamblado dinámico se guarda como DemoGenericMethod1.dll y se puede examinar utilizando el desensamblador Ildasm.exe (Desensamblador de IL).

System_CAPS_noteNota

En este ejemplo de código se genera un cuerpo de método simple que meramente devuelve una referencia nula.Para obtener un ejemplo de código con un cuerpo de método totalmente desarrollado en que se crean y utilizan tipos genéricos, vea Cómo: Definir un método genérico con emisión de reflexión.

using System;
using System.Reflection;
using System.Reflection.Emit;

class DemoMethodBuilder
{

    public static void Main()
    {
        // Creating a dynamic assembly requires an AssemblyName
        // object, and the current application domain.
        //
        AssemblyName asmName = 
            new AssemblyName("DemoMethodBuilder1");
        AppDomain domain = AppDomain.CurrentDomain;
        AssemblyBuilder demoAssembly = 
            domain.DefineDynamicAssembly(
                asmName, 
                AssemblyBuilderAccess.RunAndSave
            );

        // Define the module that contains the code. For an 
        // assembly with one module, the module name is the 
        // assembly name plus a file extension.
        ModuleBuilder demoModule = 
            demoAssembly.DefineDynamicModule(
                asmName.Name, 
                asmName.Name + ".dll"
            );

        TypeBuilder demoType = demoModule.DefineType(
            "DemoType", 
            TypeAttributes.Public | TypeAttributes.Abstract
        );

        // Define a Shared, Public method with standard calling
        // conventions. Do not specify the parameter types or the
        // return type, because type parameters will be used for 
        // those types, and the type parameters have not been
        // defined yet.
        MethodBuilder demoMethod = demoType.DefineMethod(
            "DemoMethod", 
            MethodAttributes.Public | MethodAttributes.Static
        );

        // Defining generic parameters for the method makes it a
        // generic method. By convention, type parameters are 
        // single alphabetic characters. T and U are used here.
        //
        string[] typeParamNames = {"T", "U"};
        GenericTypeParameterBuilder[] typeParameters = 
            demoMethod.DefineGenericParameters(typeParamNames);

        // The second type parameter is constrained to be a 
        // reference type.
        typeParameters[1].SetGenericParameterAttributes( 
            GenericParameterAttributes.ReferenceTypeConstraint);

        // Use the IsGenericMethod property to find out if a
        // dynamic method is generic, and IsGenericMethodDefinition
        // to find out if it defines a generic method.
        Console.WriteLine("Is DemoMethod generic? {0}", 
            demoMethod.IsGenericMethod);
        Console.WriteLine("Is DemoMethod a generic method definition? {0}", 
            demoMethod.IsGenericMethodDefinition);

        // Set parameter types for the method. The method takes
        // one parameter, and its type is specified by the first
        // type parameter, T.
        Type[] parms = {typeParameters[0]};
        demoMethod.SetParameters(parms);

        // Set the return type for the method. The return type is
        // specified by the second type parameter, U.
        demoMethod.SetReturnType(typeParameters[1]);

        // Generate a code body for the method. The method doesn't
        // do anything except return null.
        //
        ILGenerator ilgen = demoMethod.GetILGenerator();
        ilgen.Emit(OpCodes.Ldnull);
        ilgen.Emit(OpCodes.Ret);

        // Complete the type.
        Type dt = demoType.CreateType();

        // To bind types to a dynamic generic method, you must 
        // first call the GetMethod method on the completed type.
        // You can then define an array of types, and bind them
        // to the method.
        MethodInfo m = dt.GetMethod("DemoMethod");
        Type[] typeArgs = {typeof(string), typeof(DemoMethodBuilder)};
        MethodInfo bound = m.MakeGenericMethod(typeArgs);
        // Display a string representing the bound method.
        Console.WriteLine(bound);

        // Save the assembly, so it can be examined with Ildasm.exe.
        demoAssembly.Save(asmName.Name + ".dll");
    }
}

/* This code example produces the following output:
Is DemoMethod generic? True
Is DemoMethod a generic method definition? True
DemoMethodBuilder DemoMethod[String,DemoMethodBuilder](System.String)
*/

.NET Framework
Disponible desde 2.0
Silverlight
Disponible desde 2.0
Volver al principio
Mostrar:
© 2016 Microsoft