<TypeInstantiation > 요소(.NET 네이티브)

아티클
07/13/2023

생성된 제네릭 형식에 런타임 리플렉션 정책을 적용합니다.

구문

<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	특성 유형	설명
`Name`	일반	필수 특성입니다. 형식 이름을 지정합니다.
`Arguments`	일반	필수 특성입니다. 제네릭 형식 인수를 지정합니다. 인수가 여러 개이면 쉼표로 구분합니다.
`Activate`	반영	선택적 특성입니다. 인스턴스를 활성화할 수 있도록 생성자에 대한 런타임 액세스를 제어합니다.
`Browse`	반영	선택적 특성입니다. 프로그램 요소에 대한 정보 쿼리를 제어하지만 런타임 액세스를 사용하도록 설정하지는 않습니다.
`Dynamic`	반영	선택적 특성입니다. 동적 프로그래밍을 수행할 수 있도록 생성자, 메서드, 필드, 속성 및 이벤트를 비롯한 모든 형식 멤버에 대한 런타임 액세스를 제어합니다.
`Serialize`	직렬화	선택적 특성입니다. Newtonsoft JSON 직렬 변환기 등의 라이브러리를 통해 형식 인스턴스를 직렬화 및 역직렬화할 수 있도록 생성자, 필드 및 속성에 대한 런타임 액세스를 제어합니다.
`DataContractSerializer`	직렬화	선택적 특성입니다. System.Runtime.Serialization.DataContractSerializer 클래스를 사용하는 serialization에 대한 정책을 제어합니다.
`DataContractJsonSerializer`	직렬화	선택적 특성입니다. System.Runtime.Serialization.Json.DataContractJsonSerializer 클래스를 사용하는 JSON serialization에 대한 정책을 제어합니다.
`XmlSerializer`	직렬화	선택적 특성입니다. System.Xml.Serialization.XmlSerializer 클래스를 사용하는 XML serialization에 대한 정책을 제어합니다.
`MarshalObject`	Interop	선택적 특성입니다. Windows 런타임 및 COM에 대한 참조 형식을 마샬링하는 정책을 제어합니다.
`MarshalDelegate`	Interop	선택적 특성입니다. 네이티브 코드에 대한 함수 포인터로 대리자 형식을 마샬링하는 정책을 제어합니다.
`MarshalStructure`	Interop	선택적 특성입니다. 구조체를 네이티브 코드로 마샬링하는 정책을 제어합니다.

Name 특성

값 설명

type_name 형식 이름입니다. 이 <TypeInstantiation>요소가 <Namespace> 요소, <Type> 요소 또는 다른 <TypeInstantiation> 요소의 자식인 경우 type_name은 네임스페이스가 없는 형식 이름을 지정할 수 있습니다. 그러지 않으면 type_name은 정규화된 형식 이름을 포함해야 합니다. 형식 이름은 데코레이팅되지 않습니다. 예를 들어 System.Collections.Generic.List<T> 개체의 <TypeInstantiation> 요소는 다음과 같이 표시될 수 있습니다.

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

값	설명
type_name	형식 이름입니다. 이 `<TypeInstantiation>`요소가 <Namespace> 요소, <Type> 요소 또는 다른 `<TypeInstantiation>` 요소의 자식인 경우 type_name은 네임스페이스가 없는 형식 이름을 지정할 수 있습니다. 그러지 않으면 type_name은 정규화된 형식 이름을 포함해야 합니다. 형식 이름은 데코레이팅되지 않습니다. 예를 들어 System.Collections.Generic.List<T> 개체의 `<TypeInstantiation>` 요소는 다음과 같이 표시될 수 있습니다. `\<TypeInstantiation Name=System.Collections.Generic.List Dynamic="Required Public" />`

인수 특성

값	설명
type_argument	제네릭 형식 인수를 지정합니다. 인수가 여러 개이면 쉼표로 구분합니다. 각 인수는 정규화된 형식 이름으로 구성되어야 합니다.

기타 모든 특성

값	설명
policy_setting	생성된 제네릭 형식에 대해 이 정책 형식에 적용할 설정입니다. 가능한 값은 `All`, `Auto`, `Excluded`, `Public`, `PublicAndInternal`, `Required Public`, `Required PublicAndInternal` 및 `Required All`입니다. 자세한 내용은 런타임 지시문 정책 설정을 참조하세요.

자식 요소

요소	설명
<이벤트>	이 형식에 속하는 이벤트에 리플렉션 정책을 적용합니다.
<필드>	이 형식에 속하는 필드에 리플렉션 정책을 적용합니다.
<ImpliesType>	포함 `<TypeInstantiation>` 요소가 나타내는 형식에 정책이 적용된 경우 형식에 해당 정책을 적용합니다.
<방법>	이 형식에 속하는 메서드에 리플렉션 정책을 적용합니다.
<MethodInstantiation>	이 형식에 속하는 생성된 제네릭 메서드에 리플렉션 정책을 적용합니다.
<속성>	이 형식에 속하는 속성에 리플렉션 정책을 적용합니다.
<Type>	중첩된 형식에 리플렉션 정책을 적용합니다.
`<TypeInstantiation>`	생성된 중첩 제네릭 형식에 리플렉션 정책을 적용합니다.

부모 요소

요소	설명
<애플리케이션>	런타임에 해당 메타데이터를 리플렉션에 사용할 수 있는 애플리케이션 수준 형식 및 형식 멤버에 대한 컨테이너로 사용됩니다.
<어셈블리>	지정된 어셈블리의 모든 형식에 리플렉션 정책을 적용합니다.
<라이브러리>	런타임에 해당 메타데이터를 리플렉션에 사용할 수 있는 형식 및 형식 멤버가 포함된 어셈블리를 정의합니다.
<네임스페이스>	네임스페이스의 모든 형식에 리플렉션 정책을 적용합니다.
<Type>	형식 및 모든 해당 멤버에 리플렉션 정책을 적용합니다.
`<TypeInstantiation>`	생성된 제네릭 형식 및 모든 해당 멤버에 리플렉션 정책을 적용합니다.

설명

리플렉션, serialization 및 interop 특성은 모두 선택 사항입니다. 그러나 이러한 특성이 하나 이상 있어야 합니다.

<TypeInstantiation> 요소가 <Assembly>, <Namespace> 또는 <Type> 요소의 자식인 경우 부모 요소가 정의하는 정책 설정을 재정의합니다. <Type> 요소가 해당 제네릭 형식 정의를 정의하는 경우 <TypeInstantiation> 요소는 지정한 생성된 제네릭 형식의 인스턴스화에 대해서만 런타임 리플렉션 정책을 재정의합니다.

예시

다음 예제에서는 리플렉션을 사용하여 생성된 Dictionary<TKey,TValue> 개체에서 제네릭 형식 정의를 검색합니다. 또한 리플렉션을 사용하여 생성된 제네릭 형식 및 제네릭 형식 정의를 나타내는 Type 개체에 대한 정보를 표시합니다. 예제에서 b 변수는 TextBlock 컨트롤입니다.

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

이 예제는 .NET 네이티브 도구 체인을 사용하여 컴파일하면 Type.GetGenericTypeDefinition 메서드를 호출하는 줄에서 MissingMetadataException 예외를 throw합니다. 다음 <TypeInstantiation> 요소를 런타임 지시문 파일에 추가하면 예외를 방지하고 필요한 메타데이터를 제공할 수 있습니다.

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