Compartir a través de

<Elemento TypeInstantiation (.NET Native)>

  • Artículo

Aplica la directiva de reflexión en tiempo de ejecución a un tipo genérico construido.

Sintaxis

<TypeInstantiation Name="type_name"
                   Arguments="type_arguments"
                   Activate="policy_type"
                   Browse="policy_type"
                   Dynamic="policy_type"
                   Serialize="policy_type"
                   DataContractSerializer="policy_setting"
                   DataContractJsonSerializer="policy_setting"
                   XmlSerializer="policy_setting"
                   MarshalObject="policy_setting"
                   MarshalDelegate="policy_setting"
                   MarshalStructure="policy_setting" />

Atributos y elementos

En las siguientes secciones se describen los atributos, los elementos secundarios y los elementos primarios.

Atributos

Attribute Tipo de atributo Descripción
Name General Atributo necesario. Especifica el nombre de tipo.
Arguments General Atributo necesario. Especifica los argumentos de tipo genérico. Si hay varios argumentos, se separan mediante coma.
Activate Reflexión Atributo opcional. Controla el acceso en tiempo de ejecución a los constructores para permitir la activación de instancias.
Browse Reflexión Atributo opcional. Controla la consulta para obtener información sobre los elementos de programa, pero no permite el acceso en tiempo de ejecución.
Dynamic Reflexión Atributo opcional. Controla el acceso en tiempo de ejecución a todos los miembros de tipo (incluidos constructores, métodos, campos, propiedades y eventos) para permitir la programación dinámica.
Serialize Serialización Atributo opcional. Controla el acceso en tiempo de ejecución a constructores, campos y propiedades para permitir que bibliotecas como el serializador JSON Newtonsoft puedan serializar y deserializar instancias de tipo.
DataContractSerializer Serialización Atributo opcional. Controla la directiva de serialización que usa la clase System.Runtime.Serialization.DataContractSerializer.
DataContractJsonSerializer Serialización Atributo opcional. Controla la directiva de serialización JSON que usa la clase System.Runtime.Serialization.Json.DataContractJsonSerializer.
XmlSerializer Serialización Atributo opcional. Controla la directiva de serialización XML que usa la clase System.Xml.Serialization.XmlSerializer.
MarshalObject Interop Atributo opcional. Controla la directiva de serialización de tipos de referencia a Windows Runtime y COM.
MarshalDelegate Interop Atributo opcional. Controla la directiva de serialización de tipos de delegado como punteros de función a código nativo.
MarshalStructure Interop Atributo opcional. Controla la directiva para calcular referencias de estructuras a código nativo.

Name (atributo)

Valor Descripción
type_name Nombre de tipo. Si este <TypeInstantiation> elemento es el elemento secundario de un< elemento Namespace>, un <elemento Type> u otro <TypeInstantiation> elemento, type_name puede especificar el nombre del tipo sin su espacio de nombres. De lo contrario, type_name debe incluir el nombre de tipo completo. El nombre de tipo no es representativo. Por ejemplo, para un objeto System.Collections.Generic.List<T>, el elemento <TypeInstantiation> puede aparecer del siguiente modo:

\<TypeInstantiation Name=System.Collections.Generic.List Dynamic="Required Public" />

Arguments (atributo)

Valor Descripción
type_argument Especifica los argumentos de tipo genérico. Si hay varios argumentos, se separan mediante coma. Cada argumento debe contener el nombre de tipo completo.

Resto de atributos

Valor Descripción
policy_setting Configuración que se aplica a este tipo de directiva para el tipo genérico construido. Los valores posibles son All, Auto, Excluded, Public, PublicAndInternal, Required Public, Required PublicAndInternal y Required All. Para obtener más información, vea Runtime Directive Policy Settings (Configuración de directiva de la directiva en tiempo de ejecución).

Elementos secundarios

Elemento Descripción
<Evento> Aplica la directiva de reflexión a un evento perteneciente a este tipo.
<Campo> Aplica la directiva de reflexión a un campo de este tipo.
<ImpliesType> Aplica la directiva a un tipo, en caso de que dicha directiva se haya aplicado al tipo representado por el elemento <TypeInstantiation> que lo contiene.
<Método> Aplica la directiva de reflexión a un método perteneciente a este tipo.
<MethodInstantiation> Aplica la directiva de reflexión a un método genérico construido perteneciente a este tipo.
<Propiedad> Aplica la directiva de reflexión a una propiedad de este tipo.
<Tipo> Aplica la directiva de reflexión a un tipo anidado.
<TypeInstantiation> Aplica la directiva de reflexión a un tipo genérico construido anidado.

Elementos primarios

Elemento Descripción
<Aplicación> Sirve de contenedor de los tipos y miembros de tipo de la aplicación cuyos metadatos están disponibles para la reflexión en tiempo de ejecución.
<Ensamblado> Aplica la directiva de reflexión a todos los tipos en un ensamblado especificado.
<Library> Define el ensamblado que contiene los tipos y miembros de tipo cuyos metadatos están disponibles para la reflexión en tiempo de ejecución.
<Espacio de nombres> Aplica la directiva de reflexión a todos los tipos en un espacio de nombres.
<Tipo> Aplica la directiva de reflexión a un tipo y a todos sus miembros.
<TypeInstantiation> Aplica la directiva de reflexión a un tipo genérico construido y a todos sus miembros.

Comentarios

La reflexión, la serialización y los atributos de interoperabilidad son opcionales. Sin embargo, al menos uno debe estar presente.

Si un <TypeInstantiation> elemento es el elemento secundario de un< elemento Assembly>, <Namespace> o< Type>, invalida la configuración de directiva definida por el elemento primario. Si un <elemento Type> define una definición de tipo genérico correspondiente, el elemento invalida la <TypeInstantiation> directiva de reflexión en tiempo de ejecución solo para las instancias del tipo genérico construido especificado.

Ejemplo

En el siguiente ejemplo se usa la reflexión para recuperar la definición de tipo genérico de un objeto Dictionary<TKey,TValue> construido. También se usa la reflexión para mostrar información sobre objetos Type que representan tipos genéricos construidos y definiciones de tipos genéricos. La variable b del ejemplo es un TextBlock control .

   public static void GetGenericInfo()
   {
      // Get the type that represents the generic type definition and
      // display information about it.
      Type generic1 = typeof(Dictionary<,>);
      DisplayGenericType(generic1);

      // Get the type that represents a constructed generic type and its
      // generic type definition.
      Dictionary<string, Example> d1 = new Dictionary<string, Example>();
      Type constructed1 = d1.GetType();
      Type generic2 = constructed1.GetGenericTypeDefinition();

      // Display information for the generic type definition, and
      // for the constructed type Dictionary<String, Example>.
      DisplayGenericType(constructed1);
      DisplayGenericType(generic2);

      // Construct an array of type arguments.
      Type[] typeArgs = { typeof(string), typeof(Example) };
      // Construct the type Dictionary<String, Example>.
      Type constructed2 = generic1.MakeGenericType(typeArgs);

      DisplayGenericType(constructed2);

      object o = Activator.CreateInstance(constructed2);

      b.Text += "\r\nCompare types obtained by different methods:\n";
      b.Text += String.Format("   Are the constructed types equal? {0}\n",
                              (d1.GetType() == constructed2));
      b.Text += String.Format("   Are the generic definitions equal? {0}\n",
                              (generic1 == constructed2.GetGenericTypeDefinition()));

      // Demonstrate the DisplayGenericType and
      // DisplayGenericParameter methods with the Test class
      // defined above. This shows base, interface, and special
      // constraints.
      DisplayGenericType(typeof(TestGeneric<>));
   }

   // Display information about a generic type.
   private static void DisplayGenericType(Type t)
   {
      b.Text += String.Format("\n{0}\n", t);
      b.Text += String.Format("   Generic type? {0}\n",
                              t.GetTypeInfo().GenericTypeParameters.Length !=
                              t.GenericTypeArguments.Length);
      b.Text += String.Format("   Generic type definition? {0}\n",
                              ! t.IsConstructedGenericType);

      // Get the generic type parameters.
      Type[] typeParameters = t.GetTypeInfo().GenericTypeParameters;
      if (typeParameters.Length > 0)
      {
         b.Text += String.Format("   {0} type parameters:\n",
                                 typeParameters.Length);
         foreach (Type tParam in typeParameters)
            b.Text += String.Format("      Type parameter: {0} position {1}\n",
                     tParam.Name, tParam.GenericParameterPosition);
      }
      else
      {
         Type[] typeArgs = t.GenericTypeArguments;
         b.Text += String.Format("   {0} type arguments:\n",
                                 typeArgs.Length);
         foreach (var tArg in typeArgs)
               b.Text += String.Format("      Type argument: {0}\n",
                                       tArg);
      }
      b.Text += "\n-------------------------------\n";
   }
}

public interface ITestInterface { }

public class TestBase { }

public class TestGeneric<T> where T : TestBase, ITestInterface, new() { }

public class TestArgument : TestBase, ITestInterface
{
   public TestArgument()
   { }
}

Después de compilar con la cadena de herramientas de .NET Native, el ejemplo produce una excepción MissingMetadataException en la línea que llama al Type.GetGenericTypeDefinition método . Puede eliminar la excepción e indicar los metadatos necesarios agregando el siguiente elemento <TypeInstantiation> al archivo de directivas en tiempo de ejecución:

<Directives xmlns="http://schemas.microsoft.com/netfx/2013/01/metadata">
  <Application>
    <Assembly Name="*Application*" Dynamic="Required All" />
     <TypeInstantiation Name="System.Collections.Generic.Dictionary"
                        Arguments="System.String,GenericType.Example"
                        Dynamic="Required Public" />
  </Application>
</Directives>

Consulte también