Exportar (0) Imprimir
Expandir todo
Este artículo proviene de un motor de traducción automática. Mueva el puntero sobre las frases del artículo para ver el texto original. Más información.
Traducción
Original

GenericTypeParameterBuilder (Clase)

Define y crea parámetros de tipo genérico para los métodos y tipos genéricos definidos dinámicamente. Esta clase no puede heredarse.

System.Object
  System.Reflection.MemberInfo
    System.Type
      System.Reflection.TypeInfo
        System.Reflection.Emit.GenericTypeParameterBuilder

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

[ComVisibleAttribute(true)]
public sealed class GenericTypeParameterBuilder : TypeInfo

El tipo GenericTypeParameterBuilder expone los siguientes miembros.

  NombreDescripción
Propiedad públicaAssemblyObtiene un objeto Assembly que representa al ensamblado dinámico que contiene la definición de tipo genérico a que pertenece el parámetro de tipo actual. (Invalida a Type.Assembly).
Propiedad públicaAssemblyQualifiedNameObtiene null en todos los casos. (Invalida a Type.AssemblyQualifiedName).
Propiedad públicaAttributesObtiene los atributos asociados a Type. (Se hereda de Type).
Propiedad públicaBaseTypeObtiene la restricción de tipo base del parámetro de tipo genérico actual. (Invalida a Type.BaseType).
Propiedad públicaContainsGenericParametersObtiene true en todos los casos. (Invalida a Type.ContainsGenericParameters).
Propiedad públicaCustomAttributesObtiene una colección que contiene los atributos personalizados de este miembro. (Se hereda de MemberInfo).
Propiedad públicaDeclaredConstructorsObtiene una colección de los constructores declarados por el tipo actual. (Se hereda de TypeInfo).
Propiedad públicaDeclaredEventsObtiene una colección de los eventos definidos por el tipo actual. (Se hereda de TypeInfo).
Propiedad públicaDeclaredFieldsObtiene una colección de los campos definidos por el tipo actual. (Se hereda de TypeInfo).
Propiedad públicaDeclaredMembersObtiene una colección de los miembros definidos por el tipo actual. (Se hereda de TypeInfo).
Propiedad públicaDeclaredMethodsObtiene una colección de los métodos definidos por el tipo actual. (Se hereda de TypeInfo).
Propiedad públicaDeclaredNestedTypesObtiene una colección de los tipos anidados definidos por el tipo actual. (Se hereda de TypeInfo).
Propiedad públicaDeclaredPropertiesObtiene una colección de las propiedades definidas por el tipo actual. (Se hereda de TypeInfo).
Propiedad públicaDeclaringMethodSi el objeto GenericTypeParameterBuilder actual representa un parámetro de tipo de un método genérico, obtiene un objeto MethodInfo que representa el método declarativo. (Invalida a Type.DeclaringMethod).
Propiedad públicaDeclaringTypeObtiene la definición de tipo genérico o la definición de método genérico a la que pertenece el parámetro de tipo genérico. (Invalida a Type.DeclaringType).
Propiedad públicaFullNameObtiene null en todos los casos. (Invalida a Type.FullName).
Propiedad públicaGenericParameterAttributesObtiene una combinación de marcas GenericParameterAttributes que describen la covarianza y las restricciones especiales del parámetro de tipo genérico actual. (Invalida a Type.GenericParameterAttributes).

En .NET Framework Client Profile 4, este miembro se hereda de Type.GenericParameterAttributes.
Propiedad públicaGenericParameterPositionObtiene la posición del parámetro de tipo en la lista de parámetros de tipo del método o tipo genérico que declaró el parámetro. (Invalida a Type.GenericParameterPosition).
Propiedad públicaGenericTypeArgumentsObtiene una matriz de los argumentos de tipo genérico para este tipo. (Se hereda de Type).
Propiedad públicaGenericTypeParametersObtiene una matriz de los parámetros genéricos del tipo actual. (Se hereda de TypeInfo).
Propiedad públicaGUIDNo se admite para parámetros de tipo genérico incompletos. (Invalida a Type.GUID).
Propiedad públicaHasElementTypeObtiene un valor que indica si el objeto Type actual engloba o hace referencia a otro tipo; es decir, si el objeto Type actual es una matriz o un puntero, o si se pasa por referencia. (Se hereda de Type).
Propiedad públicaImplementedInterfacesObtiene una colección de las interfaces implementadas por el tipo actual. (Se hereda de TypeInfo).
Propiedad públicaIsAbstractObtiene un valor que indica si Type es abstracto y se debe invalidar. (Se hereda de Type).
Propiedad públicaIsAnsiClassObtiene un valor que indica si se selecciona el atributo de formato de cadena AnsiClass para el objeto Type. (Se hereda de Type).
Propiedad públicaIsArrayObtiene un valor que indica si Type es una matriz. (Se hereda de Type).
Propiedad públicaIsAutoClassObtiene un valor que indica si se selecciona el atributo de formato de cadena AutoClass para el objeto Type. (Se hereda de Type).
Propiedad públicaIsAutoLayoutObtiene un valor que indica si los campos de tipo de la actual se disponen automáticamente mediante Common Language Runtime. (Se hereda de Type).
Propiedad públicaIsByRefObtiene un valor que indica si Type se pasa por referencia. (Se hereda de Type).
Propiedad públicaIsClassObtiene un valor que indica si Type es una clase, es decir, no es un tipo de valor ni una interfaz. (Se hereda de Type).
Propiedad públicaIsCOMObjectObtiene un valor que indica si Type es un objeto COM. (Se hereda de Type).
Propiedad públicaIsConstructedGenericTypeObtiene un valor que indica si este objeto representa un tipo genérico construido. (Invalida a Type.IsConstructedGenericType).
Propiedad públicaIsContextfulObtiene un valor que indica si Type puede estar hospedado en un contexto. (Se hereda de Type).
Propiedad públicaIsEnumObtiene un valor que indica si el objeto Type actual representa una enumeración. (Se hereda de Type).
Propiedad públicaIsExplicitLayoutObtiene un valor que indica si los campos del tipo actual se disponen en los desplazamientos especificados explícitamente. (Se hereda de Type).
Propiedad públicaIsGenericParameterObtiene true en todos los casos. (Invalida a Type.IsGenericParameter).
Propiedad públicaIsGenericTypeDevuelve false en todos los casos. (Invalida a Type.IsGenericType).
Propiedad públicaIsGenericTypeDefinitionObtiene false en todos los casos. (Invalida a Type.IsGenericTypeDefinition).
Propiedad públicaIsImportObtiene un valor que indica si el objeto Type tiene aplicado un atributo ComImportAttribute, lo que indica que se ha importado de una biblioteca de tipos COM. (Se hereda de Type).
Propiedad públicaIsInterfaceObtiene un valor que indica si Type es una interfaz, es decir, no es una clase ni un tipo de valor. (Se hereda de Type).
Propiedad públicaIsLayoutSequentialObtiene un valor que indica si los campos del tipo actual se disponen secuencialmente, en el orden que se definieron o emitieron en los metadatos. (Se hereda de Type).
Propiedad públicaIsMarshalByRefObtiene un valor que indica si las referencias de Type se calculan por referencia. (Se hereda de Type).
Propiedad públicaIsNestedObtiene un valor que indica si el objeto Type actual representa un tipo cuya definición está anidada dentro de la definición de otro tipo. (Se hereda de Type).
Propiedad públicaIsNestedAssemblyObtiene un valor que indica si Type está anidado y solo se ve dentro de su propio ensamblado. (Se hereda de Type).
Propiedad públicaIsNestedFamANDAssemObtiene un valor que indica si Type está anidado y solo está visible para las clases que pertenezcan tanto a su propia familia como a su propio ensamblado. (Se hereda de Type).
Propiedad públicaIsNestedFamilyObtiene un valor que indica si Type está anidado y solo se ve dentro de su propia familia. (Se hereda de Type).
Propiedad públicaIsNestedFamORAssemObtiene un valor que indica si Type está anidado y solo está visible para las clases que pertenezcan a su propia familia o a su propio ensamblado. (Se hereda de Type).
Propiedad públicaIsNestedPrivateObtiene un valor que indica si Type está anidado y se ha declarado privado. (Se hereda de Type).
Propiedad públicaIsNestedPublicObtiene un valor que indica si hay una clase anidada que se ha declarado pública. (Se hereda de Type).
Propiedad públicaIsNotPublicObtiene un valor que indica si el objeto Type no se ha declarado público. (Se hereda de Type).
Propiedad públicaIsPointerObtiene un valor que indica si el objeto Type es un puntero. (Se hereda de Type).
Propiedad públicaIsPrimitiveObtiene un valor que indica si el objeto Type es uno de los tipos primitivos. (Se hereda de Type).
Propiedad públicaIsPublicObtiene un valor que indica si el objeto Type se ha declarado público. (Se hereda de Type).
Propiedad públicaIsSealedObtiene un valor que indica si Type se declaró "sealed". (Se hereda de Type).
Propiedad públicaIsSecurityCriticalObtiene un valor que indica si el tipo actual es crítico para la seguridad o crítico para la seguridad y disponible desde código transparente en el nivel de confianza actual y, por tanto, puede realizar operaciones críticas. (Se hereda de Type).
Propiedad públicaIsSecuritySafeCriticalObtiene un valor que indica si el tipo actual es crítico para la seguridad y disponible desde código transparente en el nivel de confianza actual; es decir, si puede realizar operaciones críticas y está disponible desde código transparente. (Se hereda de Type).
Propiedad públicaIsSecurityTransparentObtiene un valor que indica si el tipo actual es transparente en el nivel de confianza actual y, por tanto, no puede realizar operaciones críticas. (Se hereda de Type).
Propiedad públicaIsSerializableObtiene un valor que indica si el objeto Type es serializable. (Se hereda de Type).
Propiedad públicaIsSpecialNameObtiene un valor que indica si Type tiene un nombre que requiere un tratamiento especial. (Se hereda de Type).
Propiedad públicaIsUnicodeClassObtiene un valor que indica si se selecciona el atributo de formato de cadena UnicodeClass para el objeto Type. (Se hereda de Type).
Propiedad públicaIsValueTypeObtiene un valor que indica si el objeto Type es un tipo de valor. (Se hereda de Type).
Propiedad públicaIsVisibleObtiene un valor que indica si se puede obtener acceso al objeto Type mediante el código fuera del ensamblado. (Se hereda de Type).
Propiedad públicaMemberTypeObtiene un valor de MemberTypes que indica que este miembro es un tipo o un tipo anidado. (Se hereda de Type).
Propiedad públicaMetadataTokenObtiene un valor que identifica un elemento de metadatos. (Se hereda de MemberInfo).
Propiedad públicaModuleObtiene el módulo dinámico que contiene el parámetro de tipo genérico. (Invalida a Type.Module).
Propiedad públicaNameObtiene el nombre del parámetro de tipo genérico. (Invalida a MemberInfo.Name).
Propiedad públicaNamespaceObtiene null en todos los casos. (Invalida a Type.Namespace).
Propiedad públicaReflectedTypeObtiene el objeto Type utilizado para obtener el objeto GenericTypeParameterBuilder. (Invalida a Type.ReflectedType).
Propiedad públicaStructLayoutAttributeObtiene una clase StructLayoutAttribute que describe el diseño del tipo actual. (Se hereda de Type).
Propiedad públicaTypeHandleNo se admite para parámetros de tipo genérico incompletos. (Invalida a Type.TypeHandle).
Propiedad públicaTypeInitializerObtiene el inicializador del objeto Type. (Se hereda de Type).
Propiedad públicaUnderlyingSystemTypeObtiene el parámetro de tipo genérico actual. (Invalida a Type.UnderlyingSystemType).
Arriba

  NombreDescripción
Método públicoAsTypeDevuelve el tipo actual como un objeto Type. (Se hereda de TypeInfo).
Método públicoEquals(Object)Comprueba si el objeto determinado es una instancia de EventToken y es igual a la instancia actual. (Invalida a Type.Equals(Object)).
Método públicoEquals(Type)Determina si el tipo de sistema subyacente del objeto Type actual es igual que el tipo de sistema subyacente del objeto Type especificado. (Se hereda de Type).
Método públicoFindInterfacesDevuelve una matriz de objetos Type que representa una lista filtrada de interfaces implementadas o heredadas por el objeto Type actual. (Se hereda de Type).
Método públicoFindMembersDevuelve una matriz filtrada de objetos MemberInfo del tipo del miembro especificado. (Se hereda de Type).
Método públicoGetArrayRankObtiene el número de dimensiones de Array. (Se hereda de Type).
Método públicoGetConstructor(Type[])Busca un constructor de instancia público cuyos parámetros coincidan con los tipos de la matriz especificada. (Se hereda de Type).
Método públicoGetConstructor(BindingFlags, Binder, Type[], ParameterModifier[])Busca un constructor cuyos parámetros coincidan con los tipos y modificadores de argumento especificados, mediante las restricciones de enlace también especificadas. (Se hereda de Type).
Método públicoGetConstructor(BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])Busca un constructor cuyos parámetros coincidan con los modificadores y tipos de argumento especificados, mediante las restricciones de enlace indicadas y la convención de llamadas también especificada. (Se hereda de Type).
Método públicoGetConstructors()Devuelve todos los constructores públicos definidos para el objeto Type actual. (Se hereda de Type).
Método públicoGetConstructors(BindingFlags)No se admite para parámetros de tipo genérico incompletos. (Invalida a Type.GetConstructors(BindingFlags)).
Método públicoGetCustomAttributes(Boolean)No se admite para parámetros de tipo genérico incompletos. (Invalida a MemberInfo.GetCustomAttributes(Boolean)).
Método públicoGetCustomAttributes(Type, Boolean)No se admite para parámetros de tipo genérico incompletos. (Invalida a MemberInfo.GetCustomAttributes(Type, Boolean)).
Método públicoGetCustomAttributesDataDevuelve una lista de objetos CustomAttributeData que representan datos sobre los atributos que se han aplicado al miembro de destino. (Se hereda de MemberInfo).
Método públicoGetDeclaredEventDevuelve un objeto que representa el evento público especificado declarado por el tipo actual. (Se hereda de TypeInfo).
Método públicoGetDeclaredFieldDevuelve un objeto que representa el campo público especificado declarado por el tipo actual. (Se hereda de TypeInfo).
Método públicoGetDeclaredMethodDevuelve un objeto que representa el método público especificado declarado por el tipo actual. (Se hereda de TypeInfo).
Método públicoGetDeclaredMethodsDevuelve una colección que contiene todos los métodos públicos declarados en el tipo actual que coinciden con el nombre especificado. (Se hereda de TypeInfo).
Método públicoGetDeclaredNestedTypeDevuelve un objeto que representa el tipo anidado público especificado declarado por el tipo actual. (Se hereda de TypeInfo).
Método públicoGetDeclaredPropertyDevuelve un objeto que representa la propiedad pública especificada declarada por el tipo actual. (Se hereda de TypeInfo).
Método públicoGetDefaultMembersBusca los miembros definidos para el objeto Type actual cuya clase DefaultMemberAttribute esté establecida. (Se hereda de Type).
Método públicoGetElementTypeProduce una excepción NotSupportedException en todos los casos (Invalida a Type.GetElementType()).
Método públicoGetEnumNameDevuelve el nombre de la constante que tiene el valor especificado para el tipo de enumeración actual. (Se hereda de Type).
Método públicoGetEnumNamesDevuelve los nombres de los miembros del tipo de enumeración actual. (Se hereda de Type).
Método públicoGetEnumUnderlyingTypeDevuelve el tipo subyacente del tipo de enumeración actual. (Se hereda de Type).
Método públicoGetEnumValuesDevuelve una matriz con los valores de las constantes en el tipo de enumeración actual. (Se hereda de Type).
Método públicoGetEvent(String)Devuelve el objeto EventInfo que representa el evento público especificado. (Se hereda de Type).
Método públicoGetEvent(String, BindingFlags)No se admite para parámetros de tipo genérico incompletos. (Invalida a Type.GetEvent(String, BindingFlags)).
Método públicoGetEvents()No se admite para parámetros de tipo genérico incompletos. (Invalida a Type.GetEvents()).
Método públicoGetEvents(BindingFlags)No se admite para parámetros de tipo genérico incompletos. (Invalida a Type.GetEvents(BindingFlags)).
Método públicoGetField(String)Busca el campo público con el nombre especificado. (Se hereda de Type).
Método públicoGetField(String, BindingFlags)No se admite para parámetros de tipo genérico incompletos. (Invalida a Type.GetField(String, BindingFlags)).
Método públicoGetFields()Devuelve todos los campos públicos del objeto Type actual. (Se hereda de Type).
Método públicoGetFields(BindingFlags)No se admite para parámetros de tipo genérico incompletos. (Invalida a Type.GetFields(BindingFlags)).
Método públicoGetGenericArgumentsNo válido para parámetros de tipo genérico. (Invalida a Type.GetGenericArguments()).
Método públicoGetGenericParameterConstraintsDevuelve una matriz de objetos Type que representan las restricciones en el parámetro de tipo genérico actual. (Se hereda de Type).
Método públicoGetGenericTypeDefinitionNo válido para parámetros de tipo genérico. (Invalida a Type.GetGenericTypeDefinition()).
Método públicoGetHashCodeDevuelve un código hash entero de 32 bits para la instancia actual. (Invalida a Type.GetHashCode()).
Método públicoGetInterface(String)Busca la interfaz con el nombre especificado. (Se hereda de Type).
Método públicoGetInterface(String, Boolean)No se admite para parámetros de tipo genérico incompletos. (Invalida a Type.GetInterface(String, Boolean)).
Método públicoGetInterfaceMapNo se admite para parámetros de tipo genérico incompletos. (Invalida a Type.GetInterfaceMap(Type)).
Método públicoGetInterfacesNo se admite para parámetros de tipo genérico incompletos. (Invalida a Type.GetInterfaces()).
Método públicoGetMember(String)Busca los miembros públicos con el nombre especificado. (Se hereda de Type).
Método públicoGetMember(String, BindingFlags)Busca los miembros especificados mediante las restricciones de enlace especificadas. (Se hereda de Type).
Método públicoGetMember(String, MemberTypes, BindingFlags)No se admite para parámetros de tipo genérico incompletos. (Invalida a Type.GetMember(String, MemberTypes, BindingFlags)).
Método públicoGetMembers()Devuelve todos los miembros públicos del objeto Type actual. (Se hereda de Type).
Método públicoGetMembers(BindingFlags)No se admite para parámetros de tipo genérico incompletos. (Invalida a Type.GetMembers(BindingFlags)).
Método públicoGetMethod(String)Busca el método público con el nombre especificado. (Se hereda de Type).
Método públicoGetMethod(String, BindingFlags)Busca el método especificado mediante las restricciones de enlace especificadas. (Se hereda de Type).
Método públicoGetMethod(String, Type[])Busca el método público especificado cuyos parámetros coincidan con los tipos de argumentos especificados. (Se hereda de Type).
Método públicoGetMethod(String, Type[], ParameterModifier[])Busca el método público especificado cuyos parámetros coincidan con los tipos y modificadores de argumento especificados. (Se hereda de Type).
Método públicoGetMethod(String, BindingFlags, Binder, Type[], ParameterModifier[])Busca el método especificado cuyos parámetros coincidan con los tipos y modificadores de argumentos especificados, mediante las restricciones de enlace indicadas. (Se hereda de Type).
Método públicoGetMethod(String, BindingFlags, Binder, CallingConventions, Type[], ParameterModifier[])Busca el método especificado cuyos parámetros coincidan con los tipos y modificadores de argumentos especificados, usando las restricciones de enlace indicadas y la convención de llamada especificada. (Se hereda de Type).
Método públicoGetMethods()Devuelve todos los métodos públicos del objeto Type actual. (Se hereda de Type).
Método públicoGetMethods(BindingFlags)No se admite para parámetros de tipo genérico incompletos. (Invalida a Type.GetMethods(BindingFlags)).
Método públicoGetNestedType(String)Busca el tipo anidado público con el nombre especificado. (Se hereda de Type).
Método públicoGetNestedType(String, BindingFlags)No se admite para parámetros de tipo genérico incompletos. (Invalida a Type.GetNestedType(String, BindingFlags)).
Método públicoGetNestedTypes()Devuelve los tipos públicos anidados en el objeto Type actual. (Se hereda de Type).
Método públicoGetNestedTypes(BindingFlags)No se admite para parámetros de tipo genérico incompletos. (Invalida a Type.GetNestedTypes(BindingFlags)).
Método públicoGetProperties()Devuelve todas las propiedades públicas del objeto Type actual. (Se hereda de Type).
Método públicoGetProperties(BindingFlags)No se admite para parámetros de tipo genérico incompletos. (Invalida a Type.GetProperties(BindingFlags)).
Método públicoGetProperty(String)Busca la propiedad pública con el nombre especificado. (Se hereda de Type).
Método públicoGetProperty(String, BindingFlags)Busca la propiedad especificada, mediante las restricciones de enlace especificadas. (Se hereda de Type).
Método públicoGetProperty(String, Type)Busca la propiedad pública con el nombre especificado y el tipo de valor devuelto. (Se hereda de Type).
Método públicoGetProperty(String, Type[])Busca la propiedad pública especificada cuyos parámetros coincidan con los tipos de argumentos especificados. (Se hereda de Type).
Método públicoGetProperty(String, Type, Type[])Busca la propiedad pública especificada cuyos parámetros coincidan con los tipos de argumentos especificados. (Se hereda de Type).
Método públicoGetProperty(String, Type, Type[], ParameterModifier[])Busca la propiedad pública especificada cuyos parámetros coincidan con los tipos y modificadores de los argumentos especificados. (Se hereda de Type).
Método públicoGetProperty(String, BindingFlags, Binder, Type, Type[], ParameterModifier[])Busca la propiedad especificada cuyos parámetros coincidan con los tipos y modificadores de argumentos especificados, mediante las restricciones de enlace indicadas. (Se hereda de Type).
Método públicoGetType()Obtiene el objeto Type actual. (Se hereda de Type).
Método públicoInvokeMember(String, BindingFlags, Binder, Object, Object[])Invoca al miembro especificado, aplica las restricciones de enlace igualmente especificadas y compara la lista de argumentos indicada. (Se hereda de Type).
Método públicoInvokeMember(String, BindingFlags, Binder, Object, Object[], CultureInfo)Invoca al miembro especificado, aplica las restricciones de enlace especificadas y compara la lista de argumentos y la referencia cultural igualmente especificadas. (Se hereda de Type).
Método públicoInvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])No se admite para parámetros de tipo genérico incompletos. (Invalida a Type.InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])).
Método públicoIsAssignableFrom(Type)Produce una excepción NotSupportedException en todos los casos. (Invalida a Type.IsAssignableFrom(Type)).
Método públicoIsAssignableFrom(TypeInfo)Produce una excepción NotSupportedException en todos los casos. (Invalida a TypeInfo.IsAssignableFrom(TypeInfo)).
Método públicoIsDefinedNo se admite para parámetros de tipo genérico incompletos. (Invalida a MemberInfo.IsDefined(Type, Boolean)).
Método públicoIsEnumDefinedDevuelve un valor que indica si el valor especificado existe en el tipo de enumeración actual. (Se hereda de Type).
Método públicoIsEquivalentToDetermina si dos tipos COM tienen la misma identidad y se pueden usar para la equivalencia de tipos. (Se hereda de Type).
Método públicoIsInstanceOfTypeDetermina si el objeto especificado es una instancia del objeto Type actual. (Se hereda de Type).
Método públicoIsSubclassOfNo se admite para parámetros de tipo genérico incompletos. (Invalida a Type.IsSubclassOf(Type)).
Método públicoMakeArrayType()Devuelve el tipo de una matriz unidimensional cuyo tipo de elemento es el parámetro de tipo genérico. (Invalida a Type.MakeArrayType()).
Método públicoMakeArrayType(Int32)Devuelve el tipo de una matriz cuyo tipo de elemento es el parámetro de tipo genérico, con el número de dimensiones especificado. (Invalida a Type.MakeArrayType(Int32)).
Método públicoMakeByRefTypeDevuelve un objeto Type que representa el parámetro de tipo genérico actual cuando se pasa como parámetro de referencia. (Invalida a Type.MakeByRefType()).
Método públicoMakeGenericTypeNo válido para parámetros de tipo genérico incompletos. (Invalida a Type.MakeGenericType(Type[])).
Método públicoMakePointerTypeDevuelve un objeto Type que representa un puntero al parámetro de tipo genérico actual. (Invalida a Type.MakePointerType()).
Método públicoSetBaseTypeConstraintEstablece el tipo base que debe heredar un tipo con el fin de ser sustituido para el parámetro de tipo.
Método públicoSetCustomAttribute(CustomAttributeBuilder)Establece un atributo personalizado utilizando un generador de atributos personalizados.
Método públicoSetCustomAttribute(ConstructorInfo, Byte[])Establece un atributo personalizado mediante un objeto binario de atributo especificado y personalizado.
Método públicoSetGenericParameterAttributesEstablece las características de varianza y las restricciones especiales del parámetro genérico, como la restricción de constructor sin parámetros.
Método públicoSetInterfaceConstraintsEstablece las interfaces que un tipo debe implementar con el fin de ser sustituido para el parámetro de tipo.
Método públicoToStringDevuelve una representación de cadena del parámetro de tipo genérico actual. (Invalida a Type.ToString()).
Arriba

  NombreDescripción
Método de extensión públicoGetCustomAttribute(Type)Sobrecargado. Recupera un atributo personalizado de un tipo especificado que se aplica a un miembro concreto. (Definido por CustomAttributeExtensions).
Método de extensión públicoGetCustomAttribute(Type, Boolean)Sobrecargado. Recupera un atributo personalizado de un tipo especificado que se aplica a un miembro concreto y, opcionalmente, inspecciona los antecesores de dicho miembro. (Definido por CustomAttributeExtensions).
Método de extensión públicoGetCustomAttribute<T>()Sobrecargado. Recupera un atributo personalizado de un tipo especificado que se aplica a un miembro concreto. (Definido por CustomAttributeExtensions).
Método de extensión públicoGetCustomAttribute<T>(Boolean)Sobrecargado. Recupera un atributo personalizado de un tipo especificado que se aplica a un miembro concreto y, opcionalmente, inspecciona los antecesores de dicho miembro. (Definido por CustomAttributeExtensions).
Método de extensión públicoGetCustomAttributes()Sobrecargado. Recupera una colección de atributos personalizados que se aplican a un miembro especificado. (Definido por CustomAttributeExtensions).
Método de extensión públicoGetCustomAttributes(Type)Sobrecargado. Recupera una colección de atributos personalizados de un tipo especificado que se aplican a un miembro concreto. (Definido por CustomAttributeExtensions).
Método de extensión públicoGetCustomAttributes<T>()Sobrecargado. Recupera una colección de atributos personalizados de un tipo especificado que se aplican a un miembro concreto. (Definido por CustomAttributeExtensions).
Método de extensión públicoGetCustomAttributes<T>(Boolean)Sobrecargado. Recupera una colección de atributos personalizados de un tipo especificado que se aplican a un miembro concreto y, opcionalmente, inspecciona los antecesores de dicho miembro. (Definido por CustomAttributeExtensions).
Método de extensión públicoGetRuntimeEventRecupera un objeto que representa el evento especificado. (Definido por RuntimeReflectionExtensions).
Método de extensión públicoGetRuntimeEventsRecupera una colección que representa todos los eventos definidos en un tipo especificado. (Definido por RuntimeReflectionExtensions).
Método de extensión públicoGetRuntimeFieldRecupera un objeto que representa un campo especificado. (Definido por RuntimeReflectionExtensions).
Método de extensión públicoGetRuntimeFieldsRecupera una colección que representa todos los campos definidos en un tipo especificado. (Definido por RuntimeReflectionExtensions).
Método de extensión públicoGetRuntimeInterfaceMapDevuelve una asignación de interfaz para el tipo de interfaz y la interfaz especificada. (Definido por RuntimeReflectionExtensions).
Método de extensión públicoGetRuntimeMethodRecupera un objeto que representa un método especificado. (Definido por RuntimeReflectionExtensions).
Método de extensión públicoGetRuntimeMethodsRecupera una colección que representa todos los métodos definidos en un tipo especificado. (Definido por RuntimeReflectionExtensions).
Método de extensión públicoGetRuntimePropertiesRecupera una colección que representa todas las propiedades definidas en un tipo especificado. (Definido por RuntimeReflectionExtensions).
Método de extensión públicoGetRuntimePropertyRecupera un objeto que representa una propiedad especificada. (Definido por RuntimeReflectionExtensions).
Método de extensión públicoGetTypeInfoDevuelve la representación de TypeInfo del tipo especificado. (Definido por IntrospectionExtensions).
Método de extensión públicoIsDefinedIndica si se deben aplicar atributos personalizados de un tipo especificado a un miembro especificado. (Definido por CustomAttributeExtensions).
Arriba

  NombreDescripción
Implementación explícita de interfacesMétodo privado_MemberInfo.GetIDsOfNamesAsigna un conjunto de nombres a un conjunto correspondiente de identificadores de envío. (Se hereda de MemberInfo).
Implementación explícita de interfacesMétodo privado_MemberInfo.GetTypeObjeto Type que representa la clase MemberInfo. (Se hereda de MemberInfo).
Implementación explícita de interfacesMétodo privado_MemberInfo.GetTypeInfoRecupera la información de tipo de un objeto, que se puede utilizar después para obtener la información de tipo de una interfaz. (Se hereda de MemberInfo).
Implementación explícita de interfacesMétodo privado_MemberInfo.GetTypeInfoCount

Recupera el número de interfaces de tipo de información que suministra un objeto (0 ó 1)

(Se hereda de MemberInfo).
Implementación explícita de interfacesMétodo privado_MemberInfo.InvokeProporciona acceso a las propiedades y los métodos expuestos por un objeto. (Se hereda de MemberInfo).
Implementación explícita de interfacesMétodo privado_Type.GetIDsOfNamesAsigna un conjunto de nombres a un conjunto correspondiente de identificadores de envío. (Se hereda de Type).
Implementación explícita de interfacesMétodo privado_Type.GetTypeInfoRecupera la información de tipo de un objeto, que se puede utilizar después para obtener la información de tipo de una interfaz. (Se hereda de Type).
Implementación explícita de interfacesMétodo privado_Type.GetTypeInfoCount

Recupera el número de interfaces de tipo de información que suministra un objeto (0 ó 1)

(Se hereda de Type).
Implementación explícita de interfacesMétodo privado_Type.InvokeProporciona acceso a las propiedades y los métodos expuestos por un objeto. (Se hereda de Type).
Implementación explícita de interfacesMétodo privadoIReflectableType.GetTypeInfoDevuelve una representación del tipo actual en forma de objeto TypeInfo. (Se hereda de TypeInfo).
Arriba

Puede obtener una matriz de objetos GenericTypeParameterBuilder si utiliza el método TypeBuilder.DefineGenericParameters para agregar parámetros de tipo a un tipo dinámico, convirtiéndolo así en un tipo genérico, o utilizando el método MethodBuilder.DefineGenericParameters para agregar parámetros de tipo a un método dinámico. Utilice los objetos GenericTypeParameterBuilder para agregar restricciones a los parámetros de tipo. Las restricciones son de tres tipos:

  • La restricción de tipo base indica que cualquier tipo asignado al parámetro de tipo genérico debe derivar de un tipo base determinado. Establezca esta restricción utilizando el método SetBaseTypeConstraint.

  • Una restricción de interfaz especifica que cualquier tipo asignado al parámetro de tipo genérico debe implementar una interfaz determinada. Establezca las restricciones de interfaz utilizando el método SetInterfaceConstraints.

  • Las restricciones especiales especifican que cualquier tipo asignado al parámetro de tipo genérico debe tener un constructor predeterminado, debe ser un tipo de referencia, o debe ser un tipo de valor. Establezca las restricciones especiales para un parámetro de tipo utilizando el método SetGenericParameterAttributes.

Las restricciones de interfaz y las restricciones especiales no se pueden recuperar utilizando los métodos de la clase GenericTypeParameterBuilder. Una vez creado el tipo genérico que contiene los parámetros de tipo, se puede utilizar su objeto Type para reflejar las restricciones. Utilice el método Type.GetGenericArguments para obtener los parámetros de tipo y, para cada parámetro de tipo, use el método Type.GetGenericParameterConstraints para obtener la restricción de tipo base y las restricciones de interfaz, así como la propiedad Type.GenericParameterAttributes para obtener las restricciones especiales.

En el ejemplo de código siguiente se crea un tipo genérico con dos parámetros de tipo, y se guardan en el ensamblado GenericEmitExample1.dll. Se puede utilizar el Ildasm.exe (Desensamblador de IL) para ver los tipos generados. Para obtener una explicación más detallada de los pasos necesarios para definir un tipo genérico dinámico, vea Cómo: Definir un tipo genérico con emisión de reflexión.


using System;
using System.Reflection;
using System.Reflection.Emit;
using System.Collections.Generic;

// Define a trivial base class and two trivial interfaces 
// to use when demonstrating constraints.
//
public class ExampleBase {}

public interface IExampleA {}

public interface IExampleB {}

// Define a trivial type that can substitute for type parameter 
// TSecond.
//
public class ExampleDerived : ExampleBase, IExampleA, IExampleB {}


public class Example
{
    public static void Main()
    {
        // Define a dynamic assembly to contain the sample type. The
        // assembly will not be run, but only saved to disk, so
        // AssemblyBuilderAccess.Save is specified.
        //
        AppDomain myDomain = AppDomain.CurrentDomain;
        AssemblyName myAsmName = new AssemblyName("GenericEmitExample1");
        AssemblyBuilder myAssembly = 
            myDomain.DefineDynamicAssembly(myAsmName, 
                AssemblyBuilderAccess.RunAndSave);

        // An assembly is made up of executable modules. For a single-
        // module assembly, the module name and file name are the same 
        // as the assembly name. 
        //
        ModuleBuilder myModule = 
            myAssembly.DefineDynamicModule(myAsmName.Name, 
               myAsmName.Name + ".dll");

        // Get type objects for the base class trivial interfaces to
        // be used as constraints.
        //
        Type baseType = typeof(ExampleBase);
        Type interfaceA = typeof(IExampleA);
        Type interfaceB = typeof(IExampleB);

        // Define the sample type.
        //
        TypeBuilder myType = 
            myModule.DefineType("Sample", TypeAttributes.Public);

        Console.WriteLine("Type 'Sample' is generic: {0}", 
            myType.IsGenericType);

        // Define type parameters for the type. Until you do this, 
        // the type is not generic, as the preceding and following 
        // WriteLine statements show. The type parameter names are
        // specified as an array of strings. To make the code
        // easier to read, each GenericTypeParameterBuilder is placed
        // in a variable with the same name as the type parameter.
        // 
        string[] typeParamNames = {"TFirst", "TSecond"};
        GenericTypeParameterBuilder[] typeParams = 
            myType.DefineGenericParameters(typeParamNames);

        GenericTypeParameterBuilder TFirst = typeParams[0];
        GenericTypeParameterBuilder TSecond = typeParams[1];

        Console.WriteLine("Type 'Sample' is generic: {0}", 
            myType.IsGenericType);

        // Apply constraints to the type parameters.
        //
        // A type that is substituted for the first parameter, TFirst,
        // must be a reference type and must have a parameterless
        // constructor.
        TFirst.SetGenericParameterAttributes(
            GenericParameterAttributes.DefaultConstructorConstraint |
            GenericParameterAttributes.ReferenceTypeConstraint);

        // A type that is substituted for the second type
        // parameter must implement IExampleA and IExampleB, and
        // inherit from the trivial test class ExampleBase. The
        // interface constraints are specified as an array 
        // containing the interface types.
        TSecond.SetBaseTypeConstraint(baseType);
        Type[] interfaceTypes = {interfaceA, interfaceB};
        TSecond.SetInterfaceConstraints(interfaceTypes);

        // The following code adds a private field named ExampleField,
        // of type TFirst.
        FieldBuilder exField = 
            myType.DefineField("ExampleField", TFirst, 
                FieldAttributes.Private);

        // Define a static method that takes an array of TFirst and 
        // returns a List<TFirst> containing all the elements of 
        // the array. To define this method it is necessary to create
        // the type List<TFirst> by calling MakeGenericType on the
        // generic type definition, List<T>. (The T is omitted with
        // the typeof operator when you get the generic type 
        // definition.) The parameter type is created by using the
        // MakeArrayType method. 
        //
        Type listOf = typeof(List<>);
        Type listOfTFirst = listOf.MakeGenericType(TFirst);
        Type[] mParamTypes = {TFirst.MakeArrayType()};

        MethodBuilder exMethod = 
            myType.DefineMethod("ExampleMethod", 
                MethodAttributes.Public | MethodAttributes.Static, 
                listOfTFirst, 
                mParamTypes);

        // Emit the method body. 
        // The method body consists of just three opcodes, to load 
        // the input array onto the execution stack, to call the 
        // List<TFirst> constructor that takes IEnumerable<TFirst>,
        // which does all the work of putting the input elements into
        // the list, and to return, leaving the list on the stack. The
        // hard work is getting the constructor.
        // 
        // The GetConstructor method is not supported on a 
        // GenericTypeParameterBuilder, so it is not possible to get 
        // the constructor of List<TFirst> directly. There are two
        // steps, first getting the constructor of List<T> and then
        // calling a method that converts it to the corresponding 
        // constructor of List<TFirst>.
        //
        // The constructor needed here is the one that takes an
        // IEnumerable<T>. Note, however, that this is not the 
        // generic type definition of IEnumerable<T>; instead, the
        // T from List<T> must be substituted for the T of 
        // IEnumerable<T>. (This seems confusing only because both
        // types have type parameters named T. That is why this example
        // uses the somewhat silly names TFirst and TSecond.) To get
        // the type of the constructor argument, take the generic
        // type definition IEnumerable<T> (expressed as 
        // IEnumerable<> when you use the typeof operator) and 
        // call MakeGenericType with the first generic type parameter
        // of List<T>. The constructor argument list must be passed
        // as an array, with just one argument in this case.
        // 
        // Now it is possible to get the constructor of List<T>,
        // using GetConstructor on the generic type definition. To get
        // the constructor of List<TFirst>, pass List<TFirst> and
        // the constructor from List<T> to the static
        // TypeBuilder.GetConstructor method.
        //
        ILGenerator ilgen = exMethod.GetILGenerator();

        Type ienumOf = typeof(IEnumerable<>);
        Type TfromListOf = listOf.GetGenericArguments()[0];
        Type ienumOfT = ienumOf.MakeGenericType(TfromListOf);
        Type[] ctorArgs = {ienumOfT};

        ConstructorInfo ctorPrep = listOf.GetConstructor(ctorArgs);
        ConstructorInfo ctor = 
            TypeBuilder.GetConstructor(listOfTFirst, ctorPrep);

        ilgen.Emit(OpCodes.Ldarg_0);
        ilgen.Emit(OpCodes.Newobj, ctor);
        ilgen.Emit(OpCodes.Ret);

        // Create the type and save the assembly. 
        Type finished = myType.CreateType();
        myAssembly.Save(myAsmName.Name+".dll");

        // Invoke the method.
        // ExampleMethod is not generic, but the type it belongs to is
        // generic, so in order to get a MethodInfo that can be invoked
        // it is necessary to create a constructed type. The Example 
        // class satisfies the constraints on TFirst, because it is a 
        // reference type and has a default constructor. In order to
        // have a class that satisfies the constraints on TSecond, 
        // this code example defines the ExampleDerived type. These
        // two types are passed to MakeGenericMethod to create the
        // constructed type.
        //
        Type[] typeArgs = {typeof(Example), typeof(ExampleDerived)};
        Type constructed = finished.MakeGenericType(typeArgs);
        MethodInfo mi = constructed.GetMethod("ExampleMethod");

        // Create an array of Example objects, as input to the generic
        // method. This array must be passed as the only element of an 
        // array of arguments. The first argument of Invoke is 
        // null, because ExampleMethod is static. Display the count
        // on the resulting List<Example>.
        // 
        Example[] input = {new Example(), new Example()};
        object[] arguments = {input};

        List<Example> listX = 
            (List<Example>) mi.Invoke(null, arguments);

        Console.WriteLine(
            "\nThere are {0} elements in the List<Example>.", 
            listX.Count);

        DisplayGenericParameters(finished);
    }

    private static void DisplayGenericParameters(Type t)
    {
        if (!t.IsGenericType)
        {
            Console.WriteLine("Type '{0}' is not generic.");
            return;
        }
        if (!t.IsGenericTypeDefinition) 
        {
            t = t.GetGenericTypeDefinition();
        }

        Type[] typeParameters = t.GetGenericArguments();
        Console.WriteLine("\nListing {0} type parameters for type '{1}'.",
            typeParameters.Length, t);

        foreach( Type tParam in typeParameters )
        {
            Console.WriteLine("\r\nType parameter {0}:", tParam.ToString());

            foreach( Type c in tParam.GetGenericParameterConstraints() )
            {
                if (c.IsInterface)
                {
                    Console.WriteLine("    Interface constraint: {0}", c);
                }
                else
                {
                    Console.WriteLine("    Base type constraint: {0}", c);
                }
            }

            ListConstraintAttributes(tParam);
        }
    }

    // List the constraint flags. The GenericParameterAttributes
    // enumeration contains two sets of attributes, variance and
    // constraints. For this example, only constraints are used.
    //
    private static void ListConstraintAttributes(Type t)
    {
        // Mask off the constraint flags. 
        GenericParameterAttributes constraints = 
            t.GenericParameterAttributes & GenericParameterAttributes.SpecialConstraintMask;

        if ((constraints & GenericParameterAttributes.ReferenceTypeConstraint)
            != GenericParameterAttributes.None) 
        {
            Console.WriteLine("    ReferenceTypeConstraint");
        }

        if ((constraints & GenericParameterAttributes.NotNullableValueTypeConstraint)
            != GenericParameterAttributes.None) 
        {
            Console.WriteLine("    NotNullableValueTypeConstraint");
        }

        if ((constraints & GenericParameterAttributes.DefaultConstructorConstraint)
            !=GenericParameterAttributes.None) 
        {
            Console.WriteLine("    DefaultConstructorConstraint");
        }
    }
}

/* This code example produces the following output:

Type 'Sample' is generic: False
Type 'Sample' is generic: True

There are 2 elements in the List<Example>.

Listing 2 type parameters for type 'Sample[TFirst,TSecond]'.

Type parameter TFirst:
    ReferenceTypeConstraint
    DefaultConstructorConstraint

Type parameter TSecond:
    Interface constraint: IExampleA
    Interface constraint: IExampleB
    Base type constraint: ExampleBase
 */


.NET Framework

Compatible con: 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0

.NET Framework Client Profile

Compatible con: 4, 3.5 SP1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (no se admite el rol Server Core), Windows Server 2008 R2 (se admite el rol Server Core con SP1 o versiones posteriores; no se admite Itanium)

.NET Framework no admite todas las versiones de todas las plataformas. Para obtener una lista de las versiones compatibles, vea Requisitos de sistema de .NET Framework.

Todos los miembros static (Shared en Visual Basic) públicos de este tipo son seguros para la ejecución de subprocesos. No se garantiza que los miembros de instancias sean seguros para la ejecución de subprocesos.

Adiciones de comunidad

AGREGAR
Mostrar:
© 2015 Microsoft