<TypeInstantiation-Element> (.NET Native)

Artikel
07/13/2023

Wendet eine Laufzeitreflektionsrichtlinie auf einen konstruierten generischen Typ an.

Syntax

<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" />

Attribute und Elemente

In den folgenden Abschnitten werden Attribute sowie untergeordnete und übergeordnete Elemente beschrieben.

Attribute

attribute	Attributtyp	BESCHREIBUNG
`Name`	Allgemein	Erforderliches Attribut. Gibt den Namen des Typs an
`Arguments`	Allgemein	Erforderliches Attribut. Gibt die generischen Typargumente an. Wenn mehrere Argumente vorhanden sind, werden sie durch Kommas getrennt.
`Activate`	Spiegelung	Optionales Attribut. Steuert den Laufzeitzugriff auf Konstruktoren, um die Aktivierung von Instanzen zu ermöglichen.
`Browse`	Spiegelung	Optionales Attribut. Steuert das Abfragen von Informationen über Programmelemente, ermöglicht jedoch keinen Laufzeitzugriff.
`Dynamic`	Spiegelung	Optionales Attribut. Steuert den Laufzeitzugriff auf alle Typmember, einschließlich Konstruktoren, Methoden, Felder, Eigenschaften und Ereignisse, um die dynamische Programmierung zu ermöglichen.
`Serialize`	Serialisierung	Optionales Attribut. Steuert den Laufzeitzugriff auf Konstruktoren, Felder und Eigenschaften, um Serialisierung und Deserialisierung von Typinstanzen durch Bibliotheken wie das Newtonsoft JSON-Serialisierungsprogramm zu ermöglichen.
`DataContractSerializer`	Serialisierung	Optionales Attribut. Steuert die Richtlinie für die Serialisierung, die die System.Runtime.Serialization.DataContractSerializer-Klasse verwendet.
`DataContractJsonSerializer`	Serialisierung	Optionales Attribut. Steuert die Richtlinie für die JSON-Serialisierung, die die System.Runtime.Serialization.Json.DataContractJsonSerializer-Klasse verwendet.
`XmlSerializer`	Serialisierung	Optionales Attribut. Steuert die Richtlinie für die XML-Serialisierung, die die System.Xml.Serialization.XmlSerializer-Klasse verwendet.
`MarshalObject`	Interop	Optionales Attribut. Steuert die Richtlinie für das Marshalling von Verweistypen zu Windows-Runtime und COM.
`MarshalDelegate`	Interop	Optionales Attribut. Steuert die Richtlinie für das Marshalling von Delegattypen als Funktionszeiger zu systemeigenem Code.
`MarshalStructure`	Interop	Optionales Attribut. Steuert die Richtlinie für das Marshalling von Strukturen zu nativem Code.

Namensattribut

Wert BESCHREIBUNG

type_name Der Typname. Wenn dieses <TypeInstantiation> Element das untergeordnete Element eines <Namespace-Elements>, eines Type-Elements> oder eines< anderen <TypeInstantiation> Elements ist, können type_name den Namen des Typs ohne dessen Namespace angeben. Andernfalls muss type_name den vollqualifizierten Typnamen enthalten. Der Typname wird nicht ergänzt. Für ein System.Collections.Generic.List<T>-Objekt könnte das <TypeInstantiation>-Element z. B. wie folgt aussehen:

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

Wert	BESCHREIBUNG
type_name	Der Typname. Wenn dieses `<TypeInstantiation>` Element das untergeordnete Element eines <Namespace-Elements>, eines Type-Elements> oder eines< anderen `<TypeInstantiation>` Elements ist, können type_name den Namen des Typs ohne dessen Namespace angeben. Andernfalls muss type_name den vollqualifizierten Typnamen enthalten. Der Typname wird nicht ergänzt. Für ein System.Collections.Generic.List<T>-Objekt könnte das `<TypeInstantiation>`-Element z. B. wie folgt aussehen: `\<TypeInstantiation Name=System.Collections.Generic.List Dynamic="Required Public" />`

Arguments-Attribut

Wert	BESCHREIBUNG
type_argument	Gibt die generischen Typargumente an. Wenn mehrere Argumente vorhanden sind, werden sie durch Kommas getrennt. Jedes Argument muss aus dem vollqualifizierten Typnamen bestehen.

Alle anderen Attribute

Wert	BESCHREIBUNG
policy_setting	Die Einstellung, die auf diesen Richtlinientyp für den konstruierten generischen Typ anzuwenden ist. Mögliche Werte sind `All`, `Auto`, `Excluded`, `Public`, `PublicAndInternal`, `Required Public`, `Required PublicAndInternal` und `Required All`. Weitere Informationen finden Sie unter Richtlinieneinstellungen für die Laufzeitanweisung.

Untergeordnete Elemente

Element	BESCHREIBUNG
<Ereignis>	Wendet die Reflektionsrichtlinie auf ein Ereignis dieses Typs an.
<Feld>	Wendet die Reflektionsrichtlinie auf ein Feld dieses Typs an.
<ImpliesType>	Wendet eine Richtlinie auf einen Typ an, wenn diese Richtlinie an den Typ angewendet wurde, der vom enthaltenden `<TypeInstantiation>`-Element dargestellt wird.
<Methode>	Wendet die Reflektionsrichtlinie auf eine Methode dieses Typs an.
<MethodInstantiation>	Wendet die Reflektionsrichtlinie auf eine konstruierte generische Methode dieses Typs an.
<Eigenschaft>	Wendet die Reflektionsrichtlinie auf eine Eigenschaft dieses Typs an.
<Typ>	Wendet die Reflektionsrichtlinie auf einen geschachtelten Typ an.
`<TypeInstantiation>`	Wendet die Reflektionsrichtlinie auf einen geschachtelten konstruierten generischen Typ an.

Übergeordnete Elemente

Element	BESCHREIBUNG
<Anwendung>	Dient als Container für anwendungsweite Typen und Typmember, deren Metadaten zur Laufzeit für die Reflektion verfügbar sind.
<Assembly>	Wendet die Reflektionsrichtlinie auf alle Typen in einer angegebenen Assembly an.
<Bibliothek>	Definiert die Assembly, die Typen und Typmember enthält, deren Metadaten zur Laufzeit für die Reflektion verfügbar sind.
<Namespace>	Wendet die Reflektionsrichtlinie auf alle Typen in einem Namespace an.
<Typ>	Wendet die Reflektionsrichtlinie auf einen Typ und alle seine Member an.
`<TypeInstantiation>`	Wendet die Reflektionsrichtlinie auf einen konstruierten generischen Typ und alle seine Member an.

Hinweise

Die Reflektions-, Serialisierungs- und Interop-Attribute sind optional. Allerdings muss mindestens eines vorhanden sein.

Wenn ein <TypeInstantiation> Element das untergeordnete Element eines <Assembly>-, <Namespace-> oder <Type-Elements> ist, überschreibt es die richtlinieneinstellungen, die vom übergeordneten Element definiert werden. Wenn ein <Type-Element> eine entsprechende generische Typdefinition definiert, überschreibt das Element die <TypeInstantiation> Laufzeitreflektionsrichtlinie nur für Instanziierungen des angegebenen konstruierten generischen Typs.

Beispiel

Im folgenden Beispiel wird Reflektion zum Abrufen der generischen Typdefinition von einem konstruierten Dictionary<TKey,TValue>-Objekt verwendet. Außerdem wird Reflektion zum Anzeigen von Informationen über Type-Objekte verwendet, die konstruierte generische Typen und generische Typdefinitionen darstellen. Die Variable b im Beispiel ist ein TextBlock -Steuerelement.

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

Nach der Kompilierung mit der .NET Native Toolkette löst das Beispiel eine MissingMetadataException-Ausnahme in der Zeile aus, die die Type.GetGenericTypeDefinition -Methode aufruft. Sie können die Ausnahme eliminieren und die erforderlichen Metadaten bereitstellen, indem Sie folgendes <TypeInstantiation>-Element in der Laufzeitanweisungsdatei hinzufügen:

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

Share via