C# typeof 介绍 – wiki基地

作者： /

深入探讨 C# 中的 typeof 运算符

在 C# 编程语言中，我们经常需要处理类型（Type）。类型是构建程序的基础，它定义了数据的结构和行为。了解如何在运行时或编译时获取和操作类型信息，对于编写灵活、动态甚至进行元编程的应用程序至关重要。而 typeof 运算符正是 C# 中用于在编译时获取类型信息的关键工具。

本文将深入探讨 typeof 运算符的各个方面，包括它的作用、语法、与 System.Type 类的关系、各种使用场景、与 GetType() 和 is 运算符的区别，以及一些高级用法和注意事项。

1. typeof 运算符是什么？

typeof 是 C# 中的一个一元运算符，它在编译时工作。它的主要作用是获取指定类型的 System.Type 对象。简单来说，当你使用 typeof(SomeType) 时，编译器会在编译期间确定 SomeType 的类型信息，并生成代码来获取表示这个类型信息的 System.Type 类的实例。

核心特点：

  • 编译时求值： typeof 表达式的结果在编译时就已经确定。这意味着它比在运行时通过 GetType() 获取类型信息效率更高，因为它不需要在运行时查找对象的实际类型。
  • 返回 System.Type 对象： typeof 运算符的返回值是一个 System.Type 类的实例。这个 System.Type 对象包含了关于该类型的所有元数据信息（如名称、方法、属性、字段、事件、接口、基类、特性等）。
  • 操作数必须是类型名称： typeof 的参数必须是一个类型名称（包括类、结构体、枚举、接口、委托、数组、泛型类型定义或开放/封闭泛型类型）。它不能是一个变量或表达式的值。

基本语法：

csharp
System.Type typeInfo = typeof(TypeName);

这里的 TypeName 可以是任何有效的 C# 类型名称。

2. System.Type 类：typeof 的返回结果

理解 typeof 的作用，就必须理解它的返回结果——System.Type 类。System.Type 类是 .NET 反射（Reflection）机制的入口点。它是一个抽象类，表示公共语言运行时（CLR）中的类型声明：类、接口、枚举、数组、值类型、委托、泛型类型定义、开放或封闭构造的泛型类型等等。

System.Type 对象包含了关于类型的丰富元数据。通过 System.Type 对象，你可以：

  • 获取类型的名称、全名、命名空间。
  • 判断类型是类、结构体、枚举、接口还是委托。
  • 判断类型是否是泛型类型、数组类型、指针类型。
  • 获取类型的基类和实现的接口。
  • 获取类型的所有成员（方法、属性、字段、事件、嵌套类型等）。
  • 获取应用于类型或其成员的特性（Attributes）。
  • 动态创建该类型的实例（如果类型允许）。
  • 检查一个对象是否是该类型的实例，或者一个类型是否可以赋值给另一个类型。

System.Type 类提供了大量的属性和方法来获取这些信息，例如：

  • Name: 获取类型的简单名称（不包含命名空间）。
  • FullName: 获取类型的完全限定名（包含命名空间）。
  • Namespace: 获取类型的命名空间。
  • BaseType: 获取类型的直接基类。
  • IsClass: 判断是否是类。
  • IsValueType: 判断是否是值类型（结构体或枚举）。
  • IsInterface: 判断是否是接口。
  • IsEnum: 判断是否是枚举。
  • IsGenericType: 判断是否是泛型类型。
  • IsGenericTypeDefinition: 判断是否是泛型类型定义（如 List<> 而不是 List<int>）。
  • IsArray: 判断是否是数组类型。
  • GetMethods(): 获取类型的所有公共方法。
  • GetProperties(): 获取类型的所有公共属性。
  • GetFields(): 获取类型的所有公共字段。
  • GetCustomAttributes(): 获取应用于类型的特性。
  • IsAssignableFrom(Type c): 判断当前类型是否可以从类型 c 赋值。
  • IsInstanceOfType(object o): 判断对象 o 是否是当前类型的实例。
  • GetGenericArguments(): 获取泛型类型的类型参数。

因此，typeof 运算符是获取 System.Type 对象的第一步，而 System.Type 对象则是进行类型检查、反射和许多动态操作的基础。

3. typeof 的基本用法示例

让我们看一些 typeof 运算符的基本用法。

“`csharp
using System;

public class MyClass
{
public int MyProperty { get; set; }
public void MyMethod() { }
}

public enum MyEnum { Value1, Value2 }

public interface IMyInterface { }

public delegate void MyDelegate();

class Program
{
static void Main(string[] args)
{
// 获取基本数据类型的 Type 对象
Type intType = typeof(int);
Type stringType = typeof(string);
Type boolType = typeof(bool);
Type doubleType = typeof(double);

    Console.WriteLine($"Type of int: {intType.FullName}");       // System.Int32
    Console.WriteLine($"Type of string: {stringType.FullName}"); // System.String
    Console.WriteLine($"Type of bool: {boolType.FullName}");     // System.Boolean

    Console.WriteLine("---");

    // 获取自定义类型的 Type 对象
    Type myClassType = typeof(MyClass);
    Type myEnumType = typeof(MyEnum);
    Type myInterfaceType = typeof(IMyInterface);
    Type myDelegateType = typeof(MyDelegate);

    Console.WriteLine($"Type of MyClass: {myClassType.FullName}");     // Program+MyClass (如果 MyClass 是嵌套在 Program 中)
    Console.WriteLine($"Type of MyEnum: {myEnumType.FullName}");       // Program+MyEnum
    Console.WriteLine($"Type of IMyInterface: {myInterfaceType.FullName}"); // Program+IMyInterface
    Console.WriteLine($"Type of MyDelegate: {myDelegateType.FullName}"); // Program+MyDelegate

    Console.WriteLine("---");

    // 获取内置引用类型的 Type 对象 (object)
    Type objectType = typeof(object);
    Console.WriteLine($"Type of object: {objectType.FullName}"); // System.Object

    Console.WriteLine("---");

    // 获取 void 的 Type 对象 (用于表示不返回值的方法)
    Type voidType = typeof(void);
    Console.WriteLine($"Type of void: {voidType.FullName}");     // System.Void

    // 注意：不能对变量使用 typeof
    // int myVariable = 10;
    // Type variableType = typeof(myVariable); // 这会导致编译错误！
}

}
“`

这个例子展示了 typeof 如何用于各种常见的类型。需要记住的关键点是 typeof 的参数必须是一个合法的类型名称。

4. typeof 在泛型中的应用

泛型是 C# 的一个强大特性，typeof 也可以用于获取泛型类型的信息。这包括开放泛型类型定义和封闭泛型类型。

  • 封闭泛型类型 (Closed Generic Type): 指的是泛型类型的所有类型参数都已被具体类型替换，例如 List<int>、Dictionary<string, MyClass>。
  • 开放泛型类型定义 (Open Generic Type Definition): 指的是泛型类型本身，带有未指定的类型参数，例如 List<>、Dictionary<,>。它代表了该泛型类型的一个模板。
  • 泛型类型参数 (Generic Type Parameter): 在泛型类或方法的定义中使用的类型占位符，例如 class MyGeneric<T> 中的 T。

“`csharp
using System;
using System.Collections.Generic;
using System.Reflection;

// 开放泛型类型定义
public class MyGenericClass
{
public T ValueT { get; set; }
public U ValueU { get; set; }

public void Process(T arg1, U arg2) { }

}

class Program
{
static void Main(string[] args)
{
// 获取封闭泛型类型的 Type 对象
Type listIntType = typeof(List);
Console.WriteLine($”Type of List: {listIntType.FullName}”); // System.Collections.Generic.List`1[[System.Int32, …]]
Console.WriteLine($”Is List a generic type? {listIntType.IsGenericType}”); // True
Console.WriteLine($”Is List a generic type definition? {listIntType.IsGenericTypeDefinition}”); // False

    Console.WriteLine("---");

    // 获取开放泛型类型定义的 Type 对象
    Type listDefinitionType = typeof(List<>);
    Console.WriteLine($"Type of List<> Definition: {listDefinitionType.FullName}"); // System.Collections.Generic.List`1
    Console.WriteLine($"Is List<> Definition a generic type? {listDefinitionType.IsGenericType}"); // True
    Console.WriteLine($"Is List<> Definition a generic type definition? {listDefinitionType.IsGenericTypeDefinition}"); // True

    // 获取自定义开放泛型类型定义的 Type 对象
    Type myGenericDefinitionType = typeof(MyGenericClass<,>);
    Console.WriteLine($"Type of MyGenericClass<,> Definition: {myGenericDefinitionType.FullName}"); // Program+MyGenericClass`2
    Console.WriteLine($"Is MyGenericClass<,> Definition a generic type? {myGenericDefinitionType.IsGenericType}"); // True
    Console.WriteLine($"Is MyGenericClass<,> Definition a generic type definition? {myGenericDefinitionType.IsGenericTypeDefinition}"); // True

    // 对于封闭泛型类型，可以获取其类型参数
    Type[] genericArguments = listIntType.GetGenericArguments();
    Console.WriteLine($"Generic argument of List<int>: {genericArguments[0].FullName}"); // System.Int32

    // 对于开放泛型类型定义，可以获取其泛型类型参数的 Type 对象（它们是代表 T, U 等的类型）
    Type[] genericParameters = myGenericDefinitionType.GetGenericArguments();
    Console.WriteLine($"Generic parameter 0 of MyGenericClass<,>: {genericParameters[0].Name} (IsGenericParameter: {genericParameters[0].IsGenericParameter})"); // T (IsGenericParameter: True)
    Console.WriteLine($"Generic parameter 1 of MyGenericClass<,>: {genericParameters[1].Name} (IsGenericParameter: {genericParameters[1].IsGenericParameter})"); // U (IsGenericParameter: True)
}

}
“`

在泛型类或泛型方法内部，typeof(T) （其中 T 是泛型类型参数）将返回在运行时实际用于实例化该泛型类型的具体类型的 System.Type 对象。

“`csharp
using System;

public class GenericHelper
{
public void Process(T item)
{
// 在运行时，typeof(T) 将获取用于实例化 GenericHelper 的具体类型
Type actualItemType = typeof(T);
Type itemTypeUsingGetInstance = item.GetType(); // GetType() 也能获取，但 typeof 是编译时确定泛型参数类型的方式

    Console.WriteLine($"Inside GenericHelper<{typeof(T).Name}>:");
    Console.WriteLine($"  typeof(T) gives: {actualItemType.FullName}");
    Console.WriteLine($"  item.GetType() gives: {itemTypeUsingGetInstance.FullName}");
    Console.WriteLine($"  Are they the same? {actualItemType == itemTypeUsingGetInstance}"); // 通常情况下，对于 item 来说，它们是相同的
}

}

class Program
{
static void Main(string[] args)
{
GenericHelper intHelper = new GenericHelper();
intHelper.Process(123); // Inside GenericHelper: typeof(T) gives: System.Int32, item.GetType() gives: System.Int32

    Console.WriteLine("---");

    GenericHelper<string> stringHelper = new GenericHelper<string>();
    stringHelper.Process("hello"); // Inside GenericHelper<String>: typeof(T) gives: System.String, item.GetType() gives: System.String

    Console.WriteLine("---");

    GenericHelper<List<double>> listHelper = new GenericHelper<List<double>>();
    listHelper.Process(new List<double>() { 1.0, 2.0 }); // Inside GenericHelper<List>: typeof(T) gives: System.Collections.Generic.List`1[[System.Double, ...]], item.GetType() gives: System.Collections.Generic.List`1[[System.Double, ...]]
}

}
``
这个例子表明，在泛型上下文中，typeof(T)允许你在编译时引用泛型参数的类型，并在运行时获取其具体的System.Type` 实例。

5. typeof 在数组和可空类型中的应用

typeof 也能用于获取数组类型和可空类型 (Nullable<T>) 的 System.Type 对象。

“`csharp
using System;

class Program
{
static void Main(string[] args)
{
// 获取一维数组的 Type 对象
Type intArrayType = typeof(int[]);
Console.WriteLine($”Type of int[]: {intArrayType.FullName}”); // System.Int32[]
Console.WriteLine($”Is int[] an array? {intArrayType.IsArray}”); // True
Console.WriteLine($”Array element type: {intArrayType.GetElementType().FullName}”); // System.Int32

    // 获取二维数组的 Type 对象
    Type multiDimArrayType = typeof(string[,]);
    Console.WriteLine($"Type of string[,]: {multiDimArrayType.FullName}"); // System.String[,]
    Console.WriteLine($"Is string[,] an array? {multiDimArrayType.IsArray}"); // True
    Console.WriteLine($"Array element type: {multiDimArrayType.GetElementType().FullName}"); // System.String
    Console.WriteLine($"Array rank: {multiDimArrayType.GetArrayRank()}"); // 2

    Console.WriteLine("---");

    // 获取可空类型的 Type 对象 (System.Nullable<T>)
    Type nullableIntType = typeof(int?);
    Console.WriteLine($"Type of int?: {nullableIntType.FullName}"); // System.Nullable`1[[System.Int32, ...]]
    Console.WriteLine($"Is int? a value type? {nullableIntType.IsValueType}"); // True (Nullable<T> 是一个 struct)
    Console.WriteLine($"Is int? a generic type? {nullableIntType.IsGenericType}"); // True
    Console.WriteLine($"Generic argument of int?: {nullableIntType.GetGenericArguments()[0].FullName}"); // System.Int32

    Type nullableStringType = typeof(string?); // 在 .NET 6+ 中，string? 表示可空引用类型，其 Type 仍然是 System.String
    Console.WriteLine($"Type of string?: {nullableStringType.FullName}"); // System.String
    Console.WriteLine($"Is string? a generic type? {nullableStringType.IsGenericType}"); // False (string 是引用类型，不是 Nullable<T>)
    // 注意：typeof(string?) 和 typeof(string) 在获取 Type 对象上是等效的。
    // 可空引用类型的概念更多是编译器的静态分析特性，而不是引入了新的 System.Type。
}

}
“`

对于数组类型，typeof 能够准确地获取其维度和元素类型信息。对于值类型的可空类型（如 int?），typeof 获取的是 System.Nullable<T> 的 System.Type 对象，并可以进一步获取其底层类型（如 int）。

6. typeof vs GetType()：关键区别

typeof 和 GetType() 都用于获取 System.Type 对象，但它们之间存在根本性的区别：

  1. 求值时间：

    • typeof: 编译时 求值。它直接获取代码中指定的类型名称所对应的 System.Type 对象。
    • GetType(): 运行时 求值。它是 System.Object 类（因此所有 C# 类型都继承它）的一个实例方法。它获取的是对象在运行时实际类型所对应的 System.Type 对象。

  2. 操作数：

    • typeof: 接受一个 类型名称 作为参数。
    • GetType(): 在一个 对象实例 上调用。

  3. 使用场景：

    • typeof: 当你需要获取已知类型的 System.Type 对象时使用，尤其是在编译时就可以确定类型的情况下（如用作反射的起点、泛型约束检查、定义特性等）。
    • GetType(): 当你需要获取一个变量或表达式在运行时所引用的对象的实际类型时使用。这在处理多态、继承或动态加载的类型时非常有用。

让我们通过代码示例来强调这些区别：

“`csharp
using System;

public class BaseClass { }
public class DerivedClass : BaseClass { }

class Program
{
static void Main(string[] args)
{
// typeof 示例：在编译时获取已知类型的 Type
Type baseCompileTimeType = typeof(BaseClass);
Type derivedCompileTimeType = typeof(DerivedClass);

    Console.WriteLine($"typeof(BaseClass): {baseCompileTimeType.FullName}");   // BaseClass 的 Type
    Console.WriteLine($"typeof(DerivedClass): {derivedCompileTimeType.FullName}"); // DerivedClass 的 Type

    Console.WriteLine("---");

    // GetType() 示例：在运行时获取对象的实际类型
    BaseClass obj1 = new BaseClass();
    BaseClass obj2 = new DerivedClass(); // 多态性

    Type obj1RuntimeType = obj1.GetType();
    Type obj2RuntimeType = obj2.GetType();

    Console.WriteLine($"obj1.GetType(): {obj1RuntimeType.FullName}"); // BaseClass 的 Type
    Console.WriteLine($"obj2.GetType(): {obj2RuntimeType.FullName}"); // DerivedClass 的 Type (尽管变量声明是 BaseClass)

    Console.WriteLine("---");

    // 比较 typeof 和 GetType()
    Console.WriteLine($"typeof(BaseClass) == obj1.GetType(): {typeof(BaseClass) == obj1.GetType()}"); // True
    Console.WriteLine($"typeof(BaseClass) == obj2.GetType(): {typeof(BaseClass) == obj2.GetType()}"); // False (obj2 实际是 DerivedClass)
    Console.WriteLine($"typeof(DerivedClass) == obj2.GetType(): {typeof(DerivedClass) == obj2.GetType()}"); // True

    // 编译错误示例：不能对变量使用 typeof
    // int x = 10;
    // Type typeOfX = typeof(x); // 编译错误：'x' is a variable but is used like a type
}

}
“`

总结来说，typeof 适用于你知道类型名称的情况，并且类型信息在编译时确定；GetType() 适用于你有一个对象实例，想知道它在运行时的具体类型是什么。

7. typeof 与 is 运算符

is 运算符用于检查一个对象是否与给定类型兼容（即对象是该类型本身，或其派生类型，或实现了该接口）。它考虑了继承和接口实现。

虽然你可以使用 GetType() 和 typeof 来进行类型比较，例如 obj.GetType() == typeof(MyClass) 或 typeof(MyClass).IsInstanceOfType(obj)，但这通常不如 is 运算符方便和安全，尤其是在考虑继承的情况下。

  • obj.GetType() == typeof(BaseClass) 只会在 obj 的运行时类型恰好是 BaseClass 时为 true。
  • obj is BaseClass 会在 obj 的运行时类型是 BaseClass 或任何从 BaseClass 派生的类型时为 true。

“`csharp
using System;

public class BaseClass { }
public class DerivedClass : BaseClass { }

class Program
{
static void Main(string[] args)
{
BaseClass obj = new DerivedClass();

    // 使用 GetType() 和 typeof 进行精确类型比较 (不考虑继承)
    Console.WriteLine($"obj.GetType() == typeof(BaseClass): {obj.GetType() == typeof(BaseClass)}");       // False
    Console.WriteLine($"obj.GetType() == typeof(DerivedClass): {obj.GetType() == typeof(DerivedClass)}"); // True

    Console.WriteLine("---");

    // 使用 is 运算符进行类型兼容性检查 (考虑继承)
    Console.WriteLine($"obj is BaseClass: {obj is BaseClass}");           // True (DerivedClass 兼容 BaseClass)
    Console.WriteLine($"obj is DerivedClass: {obj is DerivedClass}");       // True (obj 实际就是 DerivedClass)
    Console.WriteLine($"obj is object: {obj is object}");               // True (所有引用类型都兼容 object)

    Console.WriteLine("---");

    // 使用 typeof 和 IsAssignableFrom 进行类型兼容性检查 (类似于 is 的行为，但用于 Type 对象)
    Console.WriteLine($"typeof(BaseClass).IsAssignableFrom(obj.GetType()): {typeof(BaseClass).IsAssignableFrom(obj.GetType())}"); // True (obj.GetType() 即 DerivedClass 可以赋值给 BaseClass)
    Console.WriteLine($"typeof(DerivedClass).IsAssignableFrom(obj.GetType()): {typeof(DerivedClass).IsAssignableFrom(obj.GetType())}"); // True
}

}
“`

因此，对于判断一个对象是否属于某个类型或其派生类型，或者是否实现了某个接口，is 运算符通常是更简洁、更符合习惯的选择。而 typeof 更侧重于获取类型本身的元数据，以便进行更深入的反射操作。

8. typeof 的常见使用场景

typeof 运算符在许多高级 C# 编程场景中扮演着重要角色：

8.1 反射 (Reflection)

这是 typeof 最常见的用途。通过 typeof(TypeName) 获取 System.Type 对象后，你可以利用 System.Type 提供的各种方法来检查类型的成员、访问属性值、调用方法等。

“`csharp
using System;
using System.Reflection;

public class ReflectionTarget
{
public string Name { get; set; }
private int _id;

public ReflectionTarget(int id, string name)
{
    _id = id;
    Name = name;
}

public string Greet(string greeting)
{
    return $"{greeting}, {Name}! ID: {_id}";
}

}

class Program
{
static void Main(string[] args)
{
// 1. 获取 Type 对象
Type targetType = typeof(ReflectionTarget);

    Console.WriteLine($"Type Name: {targetType.FullName}");

    // 2. 获取构造函数并创建实例
    // 获取接受 int 和 string 参数的公共构造函数
    ConstructorInfo constructor = targetType.GetConstructor(new[] { typeof(int), typeof(string) });
    object instance = constructor.Invoke(new object[] { 101, "Alice" });
    Console.WriteLine($"Created instance of type: {instance.GetType().Name}"); // ReflectionTarget

    Console.WriteLine("---");

    // 3. 获取属性并访问值
    PropertyInfo nameProperty = targetType.GetProperty("Name");
    if (nameProperty != null)
    {
        // 获取属性值
        object nameValue = nameProperty.GetValue(instance);
        Console.WriteLine($"Property 'Name' value: {nameValue}"); // Alice

        // 设置属性值
        nameProperty.SetValue(instance, "Bob");
        Console.WriteLine($"Property 'Name' new value: {nameProperty.GetValue(instance)}"); // Bob
    }

    Console.WriteLine("---");

    // 4. 获取方法并调用
    MethodInfo greetMethod = targetType.GetMethod("Greet");
    if (greetMethod != null)
    {
        // 调用方法
        object result = greetMethod.Invoke(instance, new object[] { "Hello" });
        Console.WriteLine($"Method 'Greet' result: {result}"); // Hello, Bob! ID: 101
    }

    Console.WriteLine("---");

    // 5. 获取私有字段 (需要指定 BindingFlags)
    FieldInfo idField = targetType.GetField("_id", BindingFlags.Instance | BindingFlags.NonPublic);
    if (idField != null)
    {
        object idValue = idField.GetValue(instance);
        Console.WriteLine($"Private field '_id' value: {idValue}"); // 101
    }
}

}
``
这个示例演示了如何使用typeof获取System.Type，然后利用System.Type` 的反射 API 来动态地检查和操作类型的成员。这是构建框架、插件系统、序列化器、ORM 工具等的基石。

8.2 特性 (Attributes)

特性是附加到代码元素（如类、方法、属性）上的元数据。反射允许你在运行时读取这些特性信息，而 typeof 经常用于指定你要查找的特定特性类型。

“`csharp
using System;
using System.Reflection;

[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)]
public class MyCustomAttribute : Attribute
{
public string Description { get; }
public MyCustomAttribute(string description)
{
Description = description;
}
}

[MyCustom(“This is a sample class”)]
public class AttributeTarget
{
[MyCustom(“This is a sample method”)]
public void SampleMethod() { }
}

class Program
{
static void Main(string[] args)
{
Type targetType = typeof(AttributeTarget);

    // 检查类上是否存在 MyCustomAttribute
    bool isClassAttributeDefined = Attribute.IsDefined(targetType, typeof(MyCustomAttribute));
    Console.WriteLine($"Is MyCustomAttribute defined on AttributeTarget class? {isClassAttributeDefined}"); // True

    if (isClassAttributeDefined)
    {
        // 获取类上的 MyCustomAttribute
        MyCustomAttribute classAttribute = (MyCustomAttribute)Attribute.GetCustomAttribute(targetType, typeof(MyCustomAttribute));
        Console.WriteLine($"Class Attribute Description: {classAttribute.Description}"); // This is a sample class
    }

    Console.WriteLine("---");

    // 检查方法上是否存在 MyCustomAttribute
    MethodInfo method = targetType.GetMethod("SampleMethod");
    if (method != null)
    {
        bool isMethodAttributeDefined = Attribute.IsDefined(method, typeof(MyCustomAttribute));
        Console.WriteLine($"Is MyCustomAttribute defined on SampleMethod? {isMethodAttributeDefined}"); // True

        if (isMethodAttributeDefined)
        {
            // 获取方法上的 MyCustomAttribute
            MyCustomAttribute methodAttribute = (MyCustomAttribute)Attribute.GetCustomAttribute(method, typeof(MyCustomAttribute));
            Console.WriteLine($"Method Attribute Description: {methodAttribute.Description}"); // This is a sample method
        }
    }
}

}
``
在Attribute.IsDefined和Attribute.GetCustomAttribute等方法中，你需要提供你想要检查或获取的特性的System.Type对象，这里就用到了typeof(MyCustomAttribute)`。

8.3 序列化和反序列化

许多序列化库（如 System.Text.Json 或 Newtonsoft.Json）在序列化对象时，需要知道对象的类型；在反序列化时，尤其是在处理抽象类或接口时，可能需要提供具体的类型信息才能正确地创建对象。typeof 在这里用于指定这些类型。

“`csharp
using System;
using System.Text.Json;
using System.Text.Json.Serialization; // 需要 NuGet 包 System.Text.Json

public class MyData
{
public int Id { get; set; }
public string Text { get; set; }
}

class Program
{
static void Main(string[] args)
{
MyData data = new MyData { Id = 1, Text = “Hello Json” };

    // 序列化：通常直接传递对象，库会自动获取类型 (GetType())
    string jsonString = JsonSerializer.Serialize(data);
    Console.WriteLine($"Serialized JSON: {jsonString}"); // {"Id":1,"Text":"Hello Json"}

    // 反序列化：需要提供目标类型
    // typeof(MyData) 提供了反序列化所需的类型信息
    MyData deserializedData = (MyData)JsonSerializer.Deserialize(jsonString, typeof(MyData));
    Console.WriteLine($"Deserialized Id: {deserializedData.Id}, Text: {deserializedData.Text}");
}

}
“`

在 JsonSerializer.Deserialize 的一个重载版本中，它接受一个 Type 参数，用于指定反序列化后的目标类型。在这里，typeof(MyData) 就提供了这个信息。其他序列化技术（如 XML 序列化）也有类似用法。

8.4 泛型约束 (Indirectly)

虽然 typeof 本身不能直接作为泛型类型参数的约束（例如 where T : typeof(MyClass) 是错误的），但在泛型方法或类内部，typeof(T) 用于获取泛型参数 T 的具体类型，进而可以用于一些基于类型参数的逻辑判断或反射操作。

“`csharp
using System;

// 约束 T 必须是引用类型并有一个无参构造函数
public class Factory where T : class, new()
{
public T CreateInstance()
{
// 在这里，typeof(T) 获取的是具体类型 T 的 Type 对象
Type typeOfT = typeof(T);

    Console.WriteLine($"Attempting to create instance of type: {typeOfT.FullName}");

    // 可以使用反射来做一些事情，尽管在这里 new() 约束已经确保可以直接 new T()
    // 如果没有 new() 约束，可能需要 Activator.CreateInstance(typeOfT)
    return new T();
}

}

class Program
{
static void Main(string[] args)
{
// T 被实例化为 MyData
Factory dataFactory = new Factory();
MyData instance = dataFactory.CreateInstance(); // Attempting to create instance of type: MyData

    Console.WriteLine($"Created instance type: {instance.GetType().Name}"); // MyData

    // 以下会因为不满足约束而编译错误
    // Factory<int> intFactory = new Factory<int>(); // int 是值类型
    // Factory<AbstractClass> absFactory = new Factory<AbstractClass>(); // AbstractClass 没有无参构造函数或不能被实例化
}

}
``
虽然typeof没有直接参与where T : …的约束语法，但typeof(T)` 在泛型类的成员或方法内部被广泛用于获取运行时具体的类型信息，这是处理泛型的重要手段。

8.5 动态创建对象 (Activator)

System.Activator 类提供了在运行时创建对象实例、访问成员等功能，而 Activator 的许多方法都需要一个 System.Type 对象作为输入，这通常通过 typeof 或 GetType() 获取。

“`csharp
using System;
using System.Reflection;

public class DynamicObject
{
public string Message { get; set; }

public DynamicObject()
{
    Message = "Default Message";
}

public DynamicObject(string initialMessage)
{
    Message = initialMessage;
}

public void DisplayMessage()
{
    Console.WriteLine($"The message is: {Message}");
}

}

class Program
{
static void Main(string[] args)
{
Type objType = typeof(DynamicObject);

    // 使用 Activator 创建对象 (调用无参构造函数)
    object instance1 = Activator.CreateInstance(objType);
    DynamicObject dynamicObj1 = (DynamicObject)instance1;
    dynamicObj1.DisplayMessage(); // The message is: Default Message

    Console.WriteLine("---");

    // 使用 Activator 创建对象 (调用带参数的构造函数)
    // 需要知道构造函数的参数类型
    object instance2 = Activator.CreateInstance(objType, new object[] { "Hello from Activator" });
    DynamicObject dynamicObj2 = (DynamicObject)instance2;
    dynamicObj2.DisplayMessage(); // The message is: Hello from Activator
}

}
``
这里的Activator.CreateInstance方法就直接使用了typeof(DynamicObject)` 来指定要创建的类型。这在需要根据运行时信息（如从配置文件读取的类型名称）动态加载和创建对象时非常有用。

9. typeof 的一些高级细节

  • typeof(void): typeof 可以用于 void 关键字。这通常在反射中用于获取一个不返回任何值的方法的返回类型信息。例如，MethodInfo.ReturnType 对于一个 void 方法就会返回 typeof(void)。
  • 指针类型: 在允许不安全代码的情况下，typeof 也可以用于获取指针类型的 System.Type 对象，例如 typeof(int*)。
  • 嵌套类型: typeof 可以直接引用嵌套类型，例如 typeof(OuterClass.InnerClass)。

10. 总结

typeof 运算符是 C# 中一个强大且基础的工具，用于在编译时获取任何指定类型的 System.Type 对象。这个 System.Type 对象是 .NET 反射机制的核心，提供了访问类型元数据和进行动态操作的能力。

通过 typeof 获取 System.Type，你可以实现：

  • 检查类型的属性、方法、字段、特性等元数据。
  • 动态创建对象实例。
  • 在泛型代码中获取具体类型信息。
  • 在需要类型信息的 API 中（如序列化、特性查找）提供参数。

理解 typeof 与 GetType() 的区别（编译时 vs. 运行时，类型名称 vs. 对象实例）以及与 is 运算符的不同侧重点，对于正确有效地在 C# 中处理类型信息至关重要。

掌握 typeof 和 System.Type 是迈向更高级 C# 特性（如反射、动态编程、框架开发）的关键一步。无论你是进行元编程、构建插件系统，还是仅仅需要检查对象的类型，typeof 都是你工具箱中不可或缺的一员。通过本文的详细介绍和示例，希望你对 typeof 运算符有了全面而深入的理解。

发表评论

您的邮箱地址不会被公开。 必填项已用 * 标注

滚动至顶部