按名称和签名隐藏考虑签名的所有部分，包括自定义修饰符、返回类型、参数类型、sentinels 和非托管调用约定。 这是二进制比较。

对于反射，属性和事件按名称和签名隐藏。 如果在基类中具有同时具有 get 和 set 访问器的属性，但派生类只有 get 访问器，则派生类属性将隐藏基类属性，并且您将无法访问基类上的 setter。

自定义属性不是通用类型系统的一部分。

除非数组或 COM 类型已加载到可用类的表中，否则不会搜索它们。

typeName 可以是由其命名空间限定的类型名称，也可以是包含程序集名称规范的程序集限定名称。 请参阅 AssemblyQualifiedName 。

如果 typeName 包括命名空间，但不包括程序集名称，则此方法仅搜索调用对象的程序集，并按该顺序mscorlib.dll/System.Private.CoreLib.dll。 如果 typeName 使用部分或完整程序集名称完全限定，则此方法在指定的程序集中搜索。 如果程序集具有强名称，则需要完整的程序集名称。

属性 AssemblyQualifiedName 返回一个完全限定的类型名称，包括嵌套类型、程序集名称和泛型类型参数。 支持公共语言运行时的所有编译器都将发出嵌套类的简单名称，并且反射在查询时会根据以下约定构造一个错误名称。

在 .NET Framework 版本 2.0 中，处理器体系结构已添加到程序集标识中，并且可以指定为程序集名称字符串的一部分。 例如，“ProcessorArchitecture=msil”。 但是，出于兼容性原因，属性返回 AssemblyQualifiedName 的字符串中不包含该属性。 还可以通过创建 AssemblyName 对象并将其传递给 方法的 Load 相应重载来加载类型。 然后， Assembly.GetType 可以使用 方法从程序集加载类型。 另请参阅 AssemblyName.ProcessorArchitecture 。

TopNamespace.SubNameSpace.ContainingClass+NestedClass,MyAssembly  
如果命名空间为 TopNamespace.Sub+Namespace，则字符串必须在加号 (+) 前面加上转义字符 (\) ，以防止将其解释为嵌套分隔符。 反射发出此字符串，如下所示：
TopNamespace.Sub\+Namespace.ContainingClass+NestedClass,MyAssembly  
“++”变为“\+\+”，“\”变为“\\”。
此限定名称可以持久保存，稍后用于加载 Type。 若要搜索并加载 Type，请 GetType 仅使用类型名称或程序集限定类型名称。 GetType 仅具有类型名称的 将在调用方程序集中查找 Type ，然后在系统程序集中查找 。 GetType 具有程序集限定的类型名称将在任何程序集中查找 Type 。
类型名称可能包含尾随字符，这些字符表示有关该类型的其他信息，例如类型是引用类型、指针类型还是数组类型。 若要检索没有这些尾随字符的类型名称，请使用 t.GetElementType().ToString()，其中 t 是 类型。
除程序集名称之外，空格与所有类型名称组件相关。 在程序集名称中，“，”分隔符前的空格是相关的，但“，”分隔符后面的空格将被忽略。
泛型类型的名称以反引号 (') 结尾，后跟表示泛型类型参数数的数字。 此名称整型的目的是允许编译器支持同名但类型参数数量不同的泛型类型，这些类型参数在同一范围内发生。 例如，反射从泛型方法和 Tuple(Of T0, T1) Visual Basic Tuple<T> 或 Visual C# 中的 和 返回经过修改的名称Tuple`1Tuple`2和Tuple<T0, T1>。Tuple(Of T)
对于泛型类型，类型参数列表用方括号括起来，类型参数用逗号分隔。 例如，泛型 Dictionary<TKey,TValue> 有两个类型参数。 Dictionary<TKey,TValue>MyType具有 类型String键的 ，可以按如下所示表示：
System.Collections.Generic.Dictionary`2[System.String,MyType]  
若要在类型参数列表中指定程序集限定类型，请将程序集限定类型括在方括号内。 否则，分隔程序集限定名称部分的逗号将被解释为分隔其他类型参数。 例如， Dictionary<TKey,TValue>MyType fromMyAssembly.dll 的 ，其键类型 String为 ，可按如下所示指定：
Type.GetType("System.Collections.Generic.Dictionary`2[System.String,[MyType,MyAssembly]]")  
仅当程序集限定类型出现在类型参数列表中时，才能将其括在方括号中。 用于在类型参数列表中搜索限定和未限定类型的程序集的规则与限定和未限定非常规类型的规则相同。
可以为 Null 的类型是泛型类型的特例。 例如，可为 null 值 Int32 由字符串“System.Nullable'1[System.Int32]”表示。
在 C#、C++ 和 Visual Basic 中，还可以使用类型运算符获取可为 null 的类型。 例如，可为 Boolean null 的类型在 C# 中返回，在 C++ 中由 Nullable<Boolean>::typeid 返回，在 Visual Basic 中由 返回typeof(Nullable<bool>)GetType(Nullable(Of Boolean))。
下表显示了用于各种类型的语法 GetType 。
具有两个程序集限定类型参数的泛型类型
Type.GetType("MyGenericType`2[[MyType,MyAssembly],[AnotherType,AnotherAssembly]]")
具有程序集限定类型参数的程序集限定泛型类型
Type.GetType("MyGenericType`1[[MyType,MyAssembly]],MyGenericTypeAssembly")
一个泛型类型，其类型参数是具有两个类型参数的泛型类型
Type.GetType("MyGenericType`1[AnotherGenericType`2[MyType,AnotherType]]")
	
public:
 static Type ^ GetType(System::String ^ typeName, bool throwOnError);
	
public static Type GetType (string typeName, bool throwOnError);
	
public static Type? GetType (string typeName, bool throwOnError);
	
static member GetType : string * bool -> Type
	
Public Shared Function GetType (typeName As String, throwOnError As Boolean) As Type
		
如果为 true，则在找不到该类型时引发异常；如果为 false，则返回 null。 指定 false 还会取消某些其他异常条件，但并不取消所有条件。 请参见“异常”部分。




    

throwOnError 的值为 true，且 typeName 包含无效字符，例如嵌入的制表符。
throwOnError 的值为 true，且 typeName 为空字符串。
throwOnError 的值为 true，且 typeName 表示大小无效的数组类型。
typeName 表示 TypedReference 的数组。
		    
throwOnError 是 true，且 typeName 包含无效的语法。 例如："MyType[,*,]"。
typeName 表示将指针类型、ByRef 类型或 Void 作为其类型参数之一的泛型类型。
typeName 表示具有错误的类型参数数目的泛型类型。
typeName 表示泛型类型，并且其类型参数之一不满足相应类型参数的约束。
    	
以下示例检索 的类型 System.Int32 ，并使用该类型对象显示 FullName 的 System.Int32属性。 如果类型对象引用不存在的程序集，则此示例将引发异常。
using namespace System;
int main()
   try {
      // Get the type of a specified class.
      Type^ myType1 = Type::GetType( "System.Int32" );
      Console::WriteLine( "The full name is {0}.\n", myType1->FullName );
   catch ( TypeLoadException^ e ) {
       Console::WriteLine("{0}: Unable to load type System.Int32",
                          e->GetType()->Name);
   try {
      // Since NoneSuch does not exist in this assembly, GetType throws a TypeLoadException.
      Type^ myType2 = Type::GetType( "NoneSuch", true );
      Console::WriteLine( "The full name is {0}.", myType2->FullName );
   catch ( TypeLoadException^ e ) {
       Console::WriteLine("{0}: Unable to load type NoneSuch",
                          e->GetType()->Name);
// The example displays the following output:
//       The full name is System.Int32.
//       TypeLoadException: Unable to load type NoneSuch
using System;
class Example
     public static void Main()
         try {
             // Get the type of a specified class.
             Type myType1 = Type.GetType("System.Int32");
             Console.WriteLine("The full name is {0}.\n", myType1.FullName);
         catch (TypeLoadException e)
            Console.WriteLine("{0}: Unable to load type System.Int32", e.GetType().Name);
         try {
             // Since NoneSuch does not exist in this assembly, GetType throws a TypeLoadException.
             Type myType2 = Type.GetType("NoneSuch", true);
             Console.WriteLine("The full name is {0}.", myType2.FullName);
         catch(TypeLoadException e) {
            Console.WriteLine("{0}: Unable to load type NoneSuch", e.GetType().Name);
// The example displays the following output:
//       The full name is System.Int32.
//       TypeLoadException: Unable to load type NoneSuch
open System
    // Get the type of a specified class.
    let myType1 = Type.GetType "System.Int32"
    printfn $"The full name is {myType1.FullName}.\n"
with :? TypeLoadException as e ->
    printfn $"{e.GetType().Name}: Unable to load type System.Int32"
    // Since NoneSuch does not exist in this assembly, GetType throws a TypeLoadException.
    let myType2 = Type.GetType("NoneSuch", true)
    printfn $"The full name is {myType2.FullName}."
with :? TypeLoadException as e ->
    printfn $"{e.GetType().Name}: Unable to load type NoneSuch"
// The example displays the following output:
//       The full name is System.Int32.
//       TypeLoadException: Unable to load type NoneSuch
Class Example
     Public Shared Sub Main()
             ' Get the type of the specified class.
             Dim myType1 As Type = Type.GetType("System.Int32")
             Console.WriteLine("The full name is {0}.", myType1.FullName)
         Catch e As TypeLoadException
             Console.WriteLine("{0}: Unable to load type System.Int32",
                               e.GetType().Name)
         End Try
         Console.WriteLine()
             ' Since NoneSuch does not exist in this assembly, GetType throws a TypeLoadException.
             Dim myType2 As Type = Type.GetType("NoneSuch", True)
             Console.WriteLine("The full name is {0}.", myType2.FullName)
         Catch e As TypeLoadException
             Console.WriteLine("{0}: Unable to load type NoneSuch", e.GetType().Name)
         End Try
     End Sub
End Class
' The example displays the following output:
'       The full name is System.Int32.
'       TypeLoadException: Unable to load type NoneSuch
    	
如果知道另一个Type程序集中的某个类型的对象，则可以使用 GetType 方法获取其程序集限定名称（可从 获取AssemblyQualifiedName）。 GetType 导致加载 中指定的 typeName程序集。 还可以使用 Assembly.Load 方法加载程序集，然后使用 Assembly.GetType 或 Assembly.GetTypes 方法获取 Type 对象。 如果类型在编译时位于程序已知的程序集中，则使用 C# 或 GetType Visual Basic 中的 运算符会更有效typeof。
GetType 仅适用于从磁盘加载的程序集。 如果调用 GetType 以查找在使用 System.Reflection.Emit 服务定义的动态程序集中定义的类型，则可能会出现不一致的行为。 该行为取决于动态程序集是否是永久性的，即使用 RunAndSave 枚举的 System.Reflection.Emit.AssemblyBuilderAccess 或 Save 访问模式创建的。 如果动态程序集是永久性的，并且已在调用 之前 GetType 写入磁盘，则加载程序将在磁盘上查找保存的程序集，加载该程序集，并从该程序集检索类型。 如果在调用 时 GetType 程序集尚未保存到磁盘，则 方法返回 null。 GetType 不了解暂时性动态程序集;因此，调用 GetType 以检索暂时性动态程序集中的类型将 null返回 。
若要在动态模块上使用 GetType ，请在 AppDomain.AssemblyResolve 保存之前订阅事件并调用 GetType 。 否则，将在内存中获取程序集的两个副本。
参数 throwOnError 指定在找不到类型时发生的情况，并取消某些其他异常条件，如异常部分中所述。 无论 的值 throwOnError如何，都会引发一些异常。 例如，如果找到类型但无法加载， TypeLoadException 则即使 throwOnError 为 false，也会引发 。
下表显示了在对类型进行反射时，方法返回 Get 的基类成员。
按名称隐藏和签名考虑签名的所有部分，包括自定义修饰符、返回类型、参数类型、sentinels 和非托管调用约定。 这是二进制比较。
为了反射，属性和事件是按名称和签名隐藏的。 如果基类中有一个同时具有 get 和 set 访问器的属性，但派生类只有一个 get 访问器，则派生类属性将隐藏基类属性，并且你将无法访问基类上的 setter。
自定义属性不是通用类型系统的一部分。
除非数组或 COM 类型已加载到可用类的表中，否则不会搜索它们。
typeName 可以是由其命名空间限定的类型名称，也可以是包含程序集名称规范的程序集限定名称。 请参阅 AssemblyQualifiedName。
如果 typeName 包括命名空间，但不包括程序集名称，则此方法仅按该顺序搜索调用对象的程序集并mscorlib.dll/System.Private.CoreLib.dll。 如果 typeName 使用部分或完整程序集名称完全限定，则此方法在指定的程序集中搜索。 如果程序集具有强名称，则需要完整的程序集名称。
属性 AssemblyQualifiedName 返回一个完全限定的类型名称，包括嵌套类型、程序集名称和泛型参数。 所有支持公共语言运行时的编译器都将发出嵌套类的简单名称，而反射会在查询时根据以下约定构造一个错误名称。
在.NET Framework版本 2.0 中，处理器体系结构已添加到程序集标识，并且可以指定为程序集名称字符串的一部分。 例如，“ProcessorArchitecture=msil”。 但是，出于兼容性原因，它不包括在 属性返回 AssemblyQualifiedName 的字符串中。 还可以通过创建 AssemblyName 对象并将其传递给 方法的适当 Load 重载来加载类型。 然后， Assembly.GetType 可以使用 方法从程序集加载类型。 另请参阅 AssemblyName.ProcessorArchitecture。
TopNamespace.SubNameSpace.ContainingClass+NestedClass,MyAssembly  
如果命名空间为 TopNamespace.Sub+Namespace，则字符串必须在加号 (+) 前面加上转义字符 (\) ，以防止将其解释为嵌套分隔符。 反射发出此字符串，如下所示：
TopNamespace.Sub\+Namespace.ContainingClass+NestedClass,MyAssembly  
“++”变为“\+\+”，“\”变为“\\”。
此限定名称可以持久保存，稍后用于加载 Type。 若要搜索并加载 Type，请 GetType 仅使用类型名称或程序集限定类型名称。 GetType 仅具有类型名称的 将在调用方程序集中查找 Type ，然后在系统程序集中查找 。 GetType 具有程序集限定的类型名称将在任何程序集中查找 Type 。
类型名称可能包含尾随字符，这些字符表示有关该类型的其他信息，例如类型是引用类型、指针类型还是数组类型。 若要检索没有这些尾随字符的类型名称，请使用 t.GetElementType().ToString()，其中 t 是 类型。
除程序集名称之外，空格与所有类型名称组件相关。 在程序集名称中，“，”分隔符前的空格是相关的，但“，”分隔符后面的空格将被忽略。
泛型类型的名称以反引号 (') 结尾，后跟表示泛型类型参数数的数字。 此名称整型的目的是允许编译器支持同名但类型参数数量不同的泛型类型，这些类型参数在同一范围内发生。 例如，反射从泛型方法和 Tuple(Of T0, T1) Visual Basic Tuple<T> 或 Visual C# 中的 和 返回经过修改的名称Tuple`1Tuple`2和Tuple<T0, T1>。Tuple(Of T)
对于泛型类型，类型参数列表用方括号括起来，类型参数用逗号分隔。 例如，泛型 Dictionary<TKey,TValue> 有两个类型参数。 Dictionary<TKey,TValue>MyType具有 类型String键的 ，可以按如下所示表示：
System.Collections.Generic.Dictionary`2[System.String,MyType]  
若要在类型参数列表中指定程序集限定类型，请将程序集限定类型括在方括号内。 否则，分隔程序集限定名称部分的逗号将被解释为分隔其他类型参数。 例如，Dictionary<TKey,TValue>MyType可以按如下所示指定来自 MyAssembly.dll 的 ，其键类型String为 ：
Type.GetType("System.Collections.Generic.Dictionary`2[System.String,[MyType,MyAssembly]]")  
仅当程序集限定类型出现在类型参数列表中时，才能将其括在方括号中。 用于在类型参数列表中搜索限定和未限定类型的程序集的规则与限定和未限定非泛型类型的规则相同。
可以为 null 的类型是泛型类型的一种特例。 例如，可为 null 的 Int32 由字符串“System.Nullable'1[System.Int32]”表示。
在 C#、C++ 和 Visual Basic 中，还可以使用类型运算符获取可为 null 的类型。 例如，可为 null 的类型 Boolean 在 C# 中 返回 typeof(Nullable<bool>) ，在 C++ 中返回 by Nullable<Boolean>::typeid ，在 Visual Basic 中返回 by GetType(Nullable(Of Boolean)) 。
下表显示了用于各种类型的语法 GetType 。
具有两个程序集限定的类型参数的泛型类型
Type.GetType("MyGenericType`2[[MyType,MyAssembly],[AnotherType,AnotherAssembly]]")
具有程序集限定类型参数的程序集限定泛型类型
Type.GetType("MyGenericType`1[[MyType,MyAssembly]],MyGenericTypeAssembly")
一个泛型类型，其类型参数是具有两个类型参数的泛型类型
Type.GetType("MyGenericType`1[AnotherGenericType`2[MyType,AnotherType]]")
	
public:
 static Type ^ GetType(System::String ^ typeName, bool throwOnError, bool ignoreCase);
	
public static Type GetType (string typeName, bool throwOnError, bool ignoreCase);
	
public static Type? GetType (string typeName, bool throwOnError, bool ignoreCase);
	
static member GetType : string * bool * bool -> Type
	
Public Shared Function GetType (typeName As String, throwOnError As Boolean, ignoreCase As Boolean) As Type
throwOnError 的值为 true，且 typeName 包含无效字符，例如嵌入的制表符。




    

throwOnError 的值为 true，且 typeName 为空字符串。
throwOnError 的值为 true，且 typeName 表示大小无效的数组类型。
typeName 表示 TypedReference 的数组。
		    
throwOnError 是 true，且 typeName 包含无效的语法。 例如："MyType[,*,]"。
typeName 表示将指针类型、ByRef 类型或 Void 作为其类型参数之一的泛型类型。
typeName 表示具有错误的类型参数数目的泛型类型。
typeName 表示泛型类型，并且其类型参数之一不满足相应类型参数的约束。
    	
如果知道另一个Type程序集中的类型具有程序集限定的名称（可从 获取），则可以使用 GetType 方法获取AssemblyQualifiedName该类型的对象。 GetType 导致加载 中指定的 typeName程序集。 还可以使用 Assembly.Load 方法加载程序集，然后使用 Assembly.GetType 或 Assembly.GetTypes 方法获取 Type 对象。 如果类型在编译时位于程序已知的程序集中，则使用 C# 或 GetType Visual Basic 中的 运算符会更有效typeof。
GetType 仅适用于从磁盘加载的程序集。 如果调用 GetType 以查找在使用 System.Reflection.Emit 服务定义的动态程序集中定义的类型，可能会出现不一致的行为。 该行为取决于动态程序集是否是永久性的，即使用 RunAndSave 枚举的 System.Reflection.Emit.AssemblyBuilderAccess 或 Save 访问模式创建的。 如果动态程序集是永久性的，并且已在调用 之前 GetType 写入磁盘，则加载程序将在磁盘上查找保存的程序集，加载该程序集，并从该程序集检索类型。 如果在调用 时 GetType 程序集尚未保存到磁盘，则该方法返回 null。 GetType 不了解暂时性动态程序集;因此，调用 GetType 以检索暂时性动态程序集中的类型将 null返回 。
若要在动态模块上使用 GetType ，请订阅 事件并在 AppDomain.AssemblyResolve 保存之前调用 GetType 。 否则，将在内存中获取程序集的两个副本。
参数 throwOnError 指定找不到类型时会发生什么情况，还禁止某些其他异常条件，如异常部分中所述。 无论 的值 throwOnError如何，都会引发一些异常。 例如，如果找到类型但无法加载， TypeLoadException 则即使 throwOnError 为 false，也会引发 。
下表显示了在对类型进行反射时方法返回 Get 的基类成员。
按名称隐藏和签名考虑签名的所有部分，包括自定义修饰符、返回类型、参数类型、sentinels 和非托管调用约定。 这是二进制比较。
为了反射，属性和事件是按名称和签名隐藏的。 如果基类中有一个同时具有 get 和 set 访问器的属性，但派生类只有一个 get 访问器，则派生类属性将隐藏基类属性，并且你将无法访问基类上的 setter。
自定义属性不是通用类型系统的一部分。
除非数组或 COM 类型已加载到可用类的表中，否则不会搜索它们。
typeName 可以是由其命名空间限定的类型名称，也可以是包含程序集名称规范的程序集限定名称。 请参阅 AssemblyQualifiedName。
如果 typeName 包括命名空间，但不包括程序集名称，则此方法仅按该顺序搜索调用对象的程序集并mscorlib.dll/System.Private.CoreLib.dll。 如果 typeName 使用部分或完整程序集名称完全限定，则此方法在指定的程序集中搜索。 如果程序集具有强名称，则需要完整的程序集名称。
属性 AssemblyQualifiedName 返回一个完全限定的类型名称，包括嵌套类型、程序集名称和类型参数。 所有支持公共语言运行时的编译器都将发出嵌套类的简单名称，而反射会在查询时根据以下约定构造一个错误名称。
在.NET Framework版本 2.0 中，处理器体系结构已添加到程序集标识，并且可以指定为程序集名称字符串的一部分。 例如，“ProcessorArchitecture=msil”。 但是，出于兼容性原因，它不包括在 属性返回 AssemblyQualifiedName 的字符串中。 还可以通过创建 AssemblyName 对象并将其传递给 方法的适当 Load 重载来加载类型。 然后， Assembly.GetType 可以使用 方法从程序集加载类型。 另请参阅 AssemblyName.ProcessorArchitecture。
TopNamespace.SubNameSpace.ContainingClass+NestedClass,MyAssembly  
如果命名空间为 TopNamespace.Sub+Namespace，则字符串必须在加号 (+) 前面加上转义字符 (\) ，以防止将其解释为嵌套分隔符。 反射发出此字符串，如下所示：
TopNamespace.Sub\+Namespace.ContainingClass+NestedClass,MyAssembly  
“++”变为“\+\+”，“\”变为“\\”。
此限定名称可以持久保存，稍后用于加载 Type。 若要搜索并加载 Type，请 GetType 仅使用类型名称或程序集限定类型名称。 GetType 仅具有类型名称的 将在调用方程序集中查找 Type ，然后在系统程序集中查找 。 GetType 具有程序集限定的类型名称将在任何程序集中查找 Type 。
类型名称可能包含尾随字符，这些字符表示有关该类型的其他信息，例如类型是引用类型、指针类型还是数组类型。 若要检索没有这些尾随字符的类型名称，请使用 t.GetElementType().ToString()，其中 t 是 类型。
除程序集名称之外，空格与所有类型名称组件相关。 在程序集名称中，“，”分隔符前的空格是相关的，但“，”分隔符后面的空格将被忽略。
泛型类型的名称以反引号 (') 结尾，后跟表示泛型类型参数数的数字。 此名称整型的目的是允许编译器支持同名但类型参数数量不同的泛型类型，这些类型参数在同一范围内发生。 例如，反射从泛型方法和 Tuple(Of T0, T1) Visual Basic Tuple<T> 或 Visual C# 中的 和 返回经过修改的名称Tuple`1Tuple`2和Tuple<T0, T1>。Tuple(Of T)
对于泛型类型，类型参数列表用方括号括起来，类型参数用逗号分隔。 例如，泛型 Dictionary<TKey,TValue> 有两个类型参数。 Dictionary<TKey,TValue>MyType具有 类型String键的 ，可以按如下所示表示：
System.Collections.Generic.Dictionary`2[System.String,MyType]  
若要在类型参数列表中指定程序集限定类型，请将程序集限定类型括在方括号内。 否则，分隔程序集限定名称部分的逗号将被解释为分隔其他类型参数。 例如，Dictionary<TKey,TValue>MyType可以按如下所示指定来自 MyAssembly.dll 的 ，其键类型String为 ：
Type.GetType("System.Collections.Generic.Dictionary`2[System.String,[MyType,MyAssembly]]")  
仅当程序集限定类型出现在类型参数列表中时，才能将其括在方括号中。 用于在类型参数列表中搜索限定和未限定类型的程序集的规则与限定和未限定非常规类型的规则相同。
可以为 Null 的类型是泛型类型的特例。 例如，可为 null 值 Int32 由字符串“System.Nullable'1[System.Int32]”表示。
在 C#、C++ 和 Visual Basic 中，还可以使用类型运算符获取可为 null 的类型。 例如，可为 Boolean null 的类型在 C# 中返回，在 C++ 中由 Nullable<Boolean>::typeid 返回，在 Visual Basic 中由 返回typeof(Nullable<bool>)GetType(Nullable(Of Boolean))。
下表显示了用于各种类型的语法 GetType 。
具有两个程序集限定类型参数的泛型类型
Type.GetType("MyGenericType`2[[MyType,MyAssembly],[AnotherType,AnotherAssembly]]")
具有程序集限定类型参数的程序集限定泛型类型
Type.GetType("MyGenericType`1[[MyType,MyAssembly]],MyGenericTypeAssembly")
一个泛型类型，其类型参数是具有两个类型参数的泛型类型
Type.GetType("MyGenericType`1[AnotherGenericType`2[MyType,AnotherType]]")
	
public:
 static Type ^ GetType(System::String ^ typeName, Func<System::Reflection::AssemblyName ^, System::Reflection::Assembly ^> ^ assemblyResolver, Func<System::Reflection::Assembly ^, System::String ^, bool, Type ^> ^ typeResolver);
	
public static Type? GetType (string typeName, Func<System.Reflection.AssemblyName,System.Reflection.Assembly?>? assemblyResolver, Func<System.Reflection.Assembly?,string,bool,Type?>? typeResolver);
	
public static Type GetType (string typeName, Func<System.Reflection.AssemblyName,System.Reflection.Assembly> assemblyResolver, Func<System.Reflection.Assembly,string,bool,Type> typeResolver);
	
static member GetType : string * Func<System.Reflection.AssemblyName, System.Reflection.Assembly> * Func<System.Reflection.Assembly, string, bool, Type> -> Type
	
Public Shared Function GetType (typeName As String, assemblyResolver As Func(Of AssemblyName, Assembly), typeResolver As Func(Of Assembly, String, Boolean, Type)) As Type
		
一个方法，它定位并返回 typeName 中指定的程序集。 以 assemblyResolver 对象形式传递给 AssemblyName 的程序集名称。 如果 typeName 不包含程序集的名称，则不调用 assemblyResolver。 如果未提供 assemblyResolver，则执行标准程序集解析。
警告 不要从未知或不受信任的调用方传递方法。 此操作可能会导致恶意代码特权提升。 仅使用你提供或者熟悉的方法。
		
一个方法，它在由 typeName 或标准程序集解析返回的程序集中定位并返回 assemblyResolver 所指定的类型。 如果未提供任何程序集，则 typeResolver 方法可以提供一个程序集。 该方法还采用一个参数以指定是否执行不区分大小写的搜索；false 传递给该参数。
警告 不要从未知或不受信任的调用方传递方法。
		    
当 typeName 解析为类型名称和程序集名称时（例如，当简单类型名称包含未转义的特殊字符时），发生错误。
typeName 表示将指针类型、ByRef 类型或 Void 作为其类型参数之一的泛型类型。
typeName 表示具有错误的类型参数数目的泛型类型。
typeName 表示泛型类型，并且其类型参数之一不满足相应类型参数的约束。
    	
此方法的使用方案以及有关 assemblyResolver 和 typeResolver 参数的详细信息可在方法重载中找到 GetType(String, Func<AssemblyName,Assembly>, Func<Assembly,String,Boolean,Type>, Boolean, Boolean) 。
如果 typeName 找不到 ，则对 方法的 GetType(String, Func<AssemblyName,Assembly>, Func<Assembly,String,Boolean,Type>) 调用将返回 null。 它不会引发异常。 若要控制是否引发异常，请调用具有 throwOnError 参数的方法的GetType重载。
调用此方法重载与调用 GetType(String, Func<AssemblyName,Assembly>, Func<Assembly,String,Boolean,Type>, Boolean, Boolean) 方法重载并指定 falsethrowOnError 和 ignoreCase 参数相同。
	
public:
 static Type ^ GetType(System::String ^ typeName, Func<System::Reflection::AssemblyName ^, System::Reflection::Assembly ^> ^ assemblyResolver, Func<System::Reflection::Assembly ^, System::String ^, bool, Type ^> ^ typeResolver, bool throwOnError);
	
public static Type? GetType (string typeName, Func<System.Reflection.AssemblyName,System.Reflection.Assembly?>? assemblyResolver, Func<System.Reflection.Assembly?,string,bool,Type?>? typeResolver, bool throwOnError);
	
public static Type GetType (string typeName, Func<System.Reflection.AssemblyName,System.Reflection.Assembly> assemblyResolver, Func<System.Reflection.Assembly,string,bool,Type> typeResolver, bool throwOnError);
	
static member GetType : string * Func<System.Reflection.AssemblyName, System.Reflection.Assembly> * Func<System.Reflection.Assembly, string, bool, Type> * bool -> Type
	
Public Shared Function GetType (typeName As String, assemblyResolver As Func(Of AssemblyName, Assembly), typeResolver As Func(Of Assembly, String, Boolean, Type), throwOnError As Boolean) As Type
		
一个方法，它定位并返回 typeName 中指定的程序集。 以 assemblyResolver 对象形式传递给 AssemblyName 的程序集名称。 如果 typeName 不包含程序集的名称，则不调用 assemblyResolver。 如果未提供 assemblyResolver，则执行标准程序集解析。




    

警告 不要从未知或不受信任的调用方传递方法。 此操作可能会导致恶意代码特权提升。 仅使用你提供或者熟悉的方法。
		
一个方法，它在由 typeName 或标准程序集解析返回的程序集中定位并返回 assemblyResolver 所指定的类型。 如果未提供任何程序集，则该方法可以提供一个程序集。 该方法还采用一个参数以指定是否执行不区分大小写的搜索；false 传递给该参数。
警告 不要从未知或不受信任的调用方传递方法。
		
如果为 true，则在找不到该类型时引发异常；如果为 false，则返回 null。 指定 false 还会取消某些其他异常条件，但并不取消所有条件。 请参见“异常”部分。
throwOnError 的值为 true，且 typeName 包含无效字符，例如嵌入的制表符。
throwOnError 的值为 true，且 typeName 为空字符串。
throwOnError 的值为 true，且 typeName 表示大小无效的数组类型。
typeName 表示 TypedReference 的数组。
		    
当 typeName 解析为类型名称和程序集名称时（例如，当简单类型名称包含未转义的特殊字符时），发生错误。
throwOnError 是 true，且 typeName 包含无效的语法（例如 "MyType[,*,]"）。
typeName 表示将指针类型、ByRef 类型或 Void 作为其类型参数之一的泛型类型。
typeName 表示具有错误的类型参数数目的泛型类型。
typeName 表示泛型类型，并且其类型参数之一不满足相应类型参数的约束。
    	
此方法的使用方案以及有关 assemblyResolver 和 typeResolver 参数的详细信息可在方法重载中找到 GetType(String, Func<AssemblyName,Assembly>, Func<Assembly,String,Boolean,Type>, Boolean, Boolean) 。
调用此方法重载与调用GetType(String, Func<AssemblyName,Assembly>, Func<Assembly,String,Boolean,Type>, Boolean, Boolean)方法重载并指定falseignoreCase参数相同。
	
public:
 static Type ^ GetType(System::String ^ typeName, Func<System::Reflection::AssemblyName ^, System::Reflection::Assembly ^> ^ assemblyResolver, Func<System::Reflection::Assembly ^, System::String ^, bool, Type ^> ^ typeResolver, bool throwOnError, bool ignoreCase);
	
public static Type? GetType (string typeName, Func<System.Reflection.AssemblyName,System.Reflection.Assembly?>? assemblyResolver, Func<System.Reflection.Assembly?,string,bool,Type?>? typeResolver, bool throwOnError, bool ignoreCase);
	
public static Type GetType (string typeName, Func<System.Reflection.AssemblyName,System.Reflection.Assembly> assemblyResolver, Func<System.Reflection.Assembly,string,bool,Type> typeResolver, bool throwOnError, bool ignoreCase);
	
static member GetType : string * Func<System.Reflection.AssemblyName, System.Reflection.Assembly> * Func<System.Reflection.Assembly, string, bool, Type> * bool * bool -> Type
	
Public Shared Function GetType (typeName As String, assemblyResolver As Func(Of AssemblyName, Assembly), typeResolver As Func(Of Assembly, String, Boolean, Type), throwOnError As Boolean, ignoreCase As Boolean) As Type
		
一个方法，它定位并返回 typeName 中指定的程序集。 以 assemblyResolver 对象形式传递给 AssemblyName 的程序集名称。 如果 typeName 不包含程序集的名称，则不调用 assemblyResolver。 如果未提供 assemblyResolver，则执行标准程序集解析。
警告 不要从未知或不受信任的调用方传递方法。 此操作可能会导致恶意代码特权提升。 仅使用你提供或者熟悉的方法。
		
一个方法，它在由 typeName 或标准程序集解析返回的程序集中定位并返回 assemblyResolver 所指定的类型。 如果未提供任何程序集，则该方法可以提供一个程序集。 该方法还采用一个参数以指定是否执行不区分大小写的搜索；ignoreCase 的值传递给该参数。
警告 不要从未知或不受信任的调用方传递方法。
throwOnError 的值为 true，且 typeName 包含无效字符，例如嵌入的制表符。
throwOnError 的值为 true，且 typeName 为空字符串。
throwOnError 的值为 true，且 typeName 表示大小无效的数组类型。
typeName 表示 TypedReference 的数组。
		    
当 typeName 解析为类型名称和程序集名称时（例如，当简单类型名称包含未转义的特殊字符时），发生错误。
throwOnError 是 true，且 typeName 包含无效的语法（例如 "MyType[,*,]"）。
typeName 表示将指针类型、ByRef 类型或 Void 作为其类型参数之一的泛型类型。
typeName 表示具有错误的类型参数数目的泛型类型。
typeName 表示泛型类型，并且其类型参数之一不满足相应类型参数的约束。
    	
使用此方法重载及其关联的重载 (GetType(String, Func<AssemblyName,Assembly>, Func<Assembly,String,Boolean,Type>) 和 GetType(String, Func<AssemblyName,Assembly>, Func<Assembly,String,Boolean,Type>, Boolean)) ，将方法的默认实现 GetType 替换为更灵活的实现。 通过提供自己的方法解析类型名称以及包含它们的程序集的名称，可以执行以下操作：
控制从中加载类型的程序集版本。
提供另一个位置来查找不包含程序集名称的类型名称。
使用部分程序集名称加载程序集。
返回不是由公共语言运行时 (CLR) 创建的子类 System.Type 。
例如，在版本容错序列化中，此方法使你能够使用部分名称搜索“最适合”程序集。 方法的其他重载 GetType 需要程序集限定的类型名称，其中包括版本号。
类型系统的备用实现可能需要返回不是由 CLR 创建的 子类 System.Type ;该方法的其他重载 GetType 返回的所有类型都是运行时类型。
此方法重载及其关联的重载将分析 typeName 为类型的名称和程序集的名称，然后解析这些名称。 程序集名称的解析发生在类型名称解析之前，因为必须在程序集的上下文中解析类型名称。
如果不熟悉程序集限定类型名称的概念，请参阅 AssemblyQualifiedName 属性。
如果 typeName 不是程序集限定的名称，则会跳过程序集解析。 可以在 mscorlib.dll/System.Private.CoreLib.dll 或当前正在执行的程序集的上下文中解析不限定的类型名称，也可以选择在 参数中 typeResolver 提供程序集。 包含或省略不同类型名称解析的程序集名称的效果显示为 “混合名称解析 ”部分中的表。
常规用法说明：
如果方法来自未知或不受信任的调用方，请不要将 assemblyResolver 方法传递给 或 typeResolver 。 仅使用你提供或者熟悉的方法。
使用来自未知或不受信任的调用方的方法可能会导致恶意代码的特权提升。
如果省略 assemblyResolver 和/或 typeResolver 参数，参数的值 throwOnError 将传递给执行默认解析的方法。
如果 throwOnError 为 true，则此方法在TypeLoadException返回 null时typeResolver引发 ，FileNotFoundException当返回 时assemblyResolver，此方法将引发 。null
此方法不会捕获 和 typeResolver引发的assemblyResolver异常。 你应对解析程序方法引发的任何异常负责。
解析程序集
方法 assemblyResolver 接收一个 AssemblyName 对象，该对象是通过分析 中包含的 typeName字符串程序集名称生成的。 如果 typeName 不包含程序集名称， assemblyResolver 则不调用 ，并且 null 将 typeResolver传递给 。
如果未 assemblyResolver 提供 ，则使用标准程序集探测来查找程序集。 如果 assemblyResolver 提供 ，则 GetType 方法不执行标准探测;在这种情况下，必须确保 assemblyResolver 可以处理传递给它的所有程序集。
如果无法解析程序集，方法 assemblyResolver 应返回 null 。 如果 assemblyResolver 返回 null， typeResolver 则不调用 并且不会进行进一步的处理;此外，如果 throwOnError 为 true， FileNotFoundException 则引发 。
AssemblyName如果传递给 assemblyResolver 的 是部分名称，则其一个或多个部分为 null。 例如，如果它没有版本，则 Version 属性为 null。 Version如果 属性、CultureInfo属性和 GetPublicKeyToken 方法都返回 null，则仅提供程序集的简单名称。 方法 assemblyResolver 可以使用或忽略程序集名称的所有部分。
对于简单和程序集限定的类型名称，不同程序集解析选项的效果显示为 “混合名称解析 ”部分中的一个表。
如果未 typeName 指定程序集名称， typeResolver 则始终调用 。 如果 typeName 指定程序集名称， typeResolver 则仅在成功解析程序集名称时调用 。 如果 assemblyResolver 或 标准程序集探测返回 null， typeResolver 则不调用 。
方法 typeResolver 接收三个参数：
要搜索的程序集，如果 nulltypeName 不包含程序集名称，则为 。
类型的简单名称。 对于嵌套类型，这是最外层的包含类型。 对于泛型类型，这是泛型类型的简单名称。
一个布尔值，如果 true 类型名称大小写将被忽略，则为 。
实现确定这些参数的使用方式。 typeResolver如果方法无法解析类型，则该方法应返回 null 。 如果 typeResolver 返回 null 和 throwOnError 为 true，则 的 GetType 此重载将 TypeLoadException引发 。
对于简单和程序集限定的类型名称，不同类型解析选项的效果显示为 “混合名称解析 ”部分中的一个表。
解析嵌套类型
如果 typeName 是嵌套类型，则仅将最外层包含类型的名称传递给 typeResolver。 返回此类型时 typeResolver ， GetNestedType 以递归方式调用 方法，直到最内部的嵌套类型已解析。
解析泛型类型
GetType以递归方式调用 以解析泛型类型：首先解析泛型类型本身，然后解析其类型参数。 如果类型参数为泛型， GetType 则以递归方式调用 以解析其类型参数，依此类而论。
提供的 和 typeResolver 的组合assemblyResolver必须能够解析此递归的所有级别。 例如，假设你提供一个 assemblyResolver 控制 加载的 MyAssembly。 假设你想要在 Visual Basic) Dictionary(Of String, MyType) 中解析泛型类型Dictionary<string, MyType> (。 可以传递以下泛型类型名称：
"System.Collections.Generic.Dictionary`2[System.String,[MyNamespace.MyType, MyAssembly]]"  
请注意， MyType 是唯一程序集限定的类型参数。 和 String 类的名称Dictionary<TKey,TValue>不是程序集限定的。 必须 typeResolver 能够处理程序集或 null，因为它将接收 null 和 Dictionary<TKey,TValue>String。 它可以通过调用采用字符串的方法的 GetType 重载来处理这种情况，因为两个非限定类型名称都在 /System.Private.CoreLib.dll mscorlib.dll中：
Type t = Type.GetType(test,
                      (aName) => aName.Name == "MyAssembly" ?
                          Assembly.LoadFrom(@".\MyPath\v5.0\MyAssembly.dll") : null,
                      (assem, name, ignore) => assem == null ?
                          Type.GetType(name, false, ignore) :
                              assem.GetType(name, false, ignore)
let t =
    Type.GetType(test,
        (fun aName ->
            if aName.Name = "MyAssembly" then
                Assembly.LoadFrom @".\MyPath\v5.0\MyAssembly.dll"
            else null),
        fun assem name ignr ->
            if assem = null then
                Type.GetType(name, false, ignr)
                assem.GetType(name, false, ignr))
assemblyResolver不会为字典类型和字符串类型调用 方法，因为这些类型名称不是程序集限定的。
现在，假设第一个 System.String泛型参数类型是 YourType，而不是 ，来自 YourAssembly：
"System.Collections.Generic.Dictionary`2[[YourNamespace.YourType, YourAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null], [MyNamespace.MyType, MyAssembly]]"  
由于此程序集既不是mscorlib.dll/System.Private.CoreLib.dll，也不是当前正在执行的程序集，因此如果没有程序集限定名称，则无法解析 YourType 。 由于将以递归方式调用， assemblyResolve 因此它必须能够处理这种情况。 它现在使用提供的 AssemblyName 对象执行程序集加载，而不是为 以外的MyAssembly程序集返回 null 。
Type t2 = Type.GetType(test,
                       (aName) => aName.Name == "MyAssembly" ?
                           Assembly.LoadFrom(@".\MyPath\v5.0\MyAssembly.dll") :
                           Assembly.Load(aName),
                       (assem, name, ignore) => assem == null ?
                           Type.GetType(name, false, ignore) :
                               assem.GetType(name, false, ignore), true
let t2 =
    Type.GetType(test,
        (fun aName ->
            if aName.Name = "MyAssembly" then
                Assembly.LoadFrom @".\MyPath\v5.0\MyAssembly.dll"
            else Assembly.Load aName),
        (fun assem name ignr ->
            if assem = null then
                Type.GetType(name, false, ignr)
                assem.GetType(name, false, ignr)), true)
返回到 使用情况说明。
解析具有特殊字符的类型名称
某些字符在程序集限定名称中具有特殊含义。 如果简单类型名称包含这些字符，则当简单名称是程序集限定名称的一部分时，这些字符会导致分析错误。 若要避免分析错误，必须先使用反斜杠转义特殊字符，然后才能将程序集限定名称传递给 GetType 方法。 例如，如果类型名为 Strange]Type，则必须在方括号前面添加转义字符，如下所示： Strange\]Type。
不能在 Visual Basic 或 C# 中创建具有此类特殊字符的名称，但可以使用 Microsoft 中间语言 (MSIL) 或通过发出动态程序集来创建。
下表显示了类型名称的特殊字符。
属性（如 AssemblyQualifiedName ）返回正确转义的字符串。 必须将正确的转义字符串传递给 GetType 方法。 方法又 GetType 将正确转义的名称传递给 typeResolver 和 默认类型解析方法。 如果需要将名称与 中的 typeResolver未转义名称进行比较，则必须删除转义字符。
返回到 使用情况说明。
混合名称解析
下表汇总了 、 typeResolver和 默认名称解析之间的assemblyResolver交互，用于 中typeName类型名称和程序集名称的所有组合：
类型名称的内容
程序集解析程序方法
类型解析程序方法
assemblyResolver 返回程序集，如果无法解析程序集，则返回 null 。 如果已解析程序集，则 Assembly.GetType(String, Boolean, Boolean) 使用方法重载从程序集加载类型;否则，不会尝试解析该类型。
type， assembly
等效于将程序集名称转换为 AssemblyName 对象并调用 Assembly.Load(AssemblyName) 方法重载以获取程序集。 如果已解析程序集，则将其传递给 typeResolver;否则， typeResolver 不会调用 ，并且不会进一步尝试解析类型。
type， assembly
assemblyResolver 返回程序集，如果无法解析程序集，则返回 null 。 如果已解析程序集，则将其传递给 typeResolver;否则， typeResolver 不会调用 ，并且不会进一步尝试解析类型。
null，提供
等效于调用 Type.GetType(String, Boolean, Boolean) 方法重载。 由于未提供程序集名称，因此仅搜索 mscorlib.dll/System.Private.CoreLib.dll 和当前正在执行的程序集。 如果 assemblyResolver 提供 ，则忽略它。
null，提供
typeResolver 调用 ，并为 null 程序集传递 。 typeResolver 可以从任何程序集提供类型，包括它为目的加载的程序集。 如果 assemblyResolver 提供 ，则忽略它。
程序集 (assembly)
null，提供
null，提供
FileLoadException引发 ，因为程序集名称被分析为程序集限定的类型名称。 这会导致程序集名称无效。
返回到： 使用说明、 解析程序集、 解析类型。