C#中如何在运行时用可变类型实现类似is的类型比较？

嘿，我完全懂你为啥纠结——is运算符确实没法直接用一个Type变量来动态指定比较类型，因为它是编译时就绑定好目标类型的，编译器根本不认你那个T变量当类型用。不过别担心，咱们有好几种办法实现你想要的“运行时可变类型比较”，效果甚至比你最初的想法更灵活！

先解释下你的代码为啥无效 #

你尝试的代码里用public static Type T;来代替is后的类型，这行不通的核心原因是：is运算符要求右侧必须是编译时已知的具体类型，它的逻辑在编译阶段就被确定了，没法在运行时动态替换成一个Type实例。

下面给你几个可直接运行的替代方案：

方案1：精确类型匹配（等价于obj is SpecificType的精确判断） #

如果只需要判断对象的精确类型和目标类型完全一致，可以用obj.GetType() == targetType：

using System;

public class A { }
public class B : A { } // B继承自A

public class Program
{
    // 可在运行时动态赋值的目标类型
    public static Type TargetType;

    public static void Main(string[] args)
    {
        object testObj = new B();

        // 检查是否是精确的A类型
        TargetType = typeof(A);
        Console.WriteLine(IsExactMatch(testObj, TargetType)); // 输出False（testObj是B，不是精确的A）

        // 检查是否是精确的B类型
        TargetType = typeof(B);
        Console.WriteLine(IsExactMatch(testObj, TargetType)); // 输出True
    }

    public static bool IsExactMatch(object obj, Type targetType)
    {
        if (obj == null) return false; // 空对象直接返回false
        return obj.GetType() == targetType;
    }
}

方案2：支持继承/接口的匹配（完全等价于is运算符的行为） #

如果你需要和is一样的逻辑——比如允许子类匹配父类、实现类匹配接口，那用Type.IsAssignableFrom()就对了，它会自动处理继承和接口实现关系：

using System;

public interface IMyInterface { }
public class A : IMyInterface { }
public class B : A { }

public class Program
{
    public static Type TargetType;

    public static void Main(string[] args)
    {
        object testObj = new B();

        // 检查是否实现了IMyInterface接口
        TargetType = typeof(IMyInterface);
        Console.WriteLine(IsAssignableMatch(testObj, TargetType)); // 输出True

        // 检查是否可赋值给父类A
        TargetType = typeof(A);
        Console.WriteLine(IsAssignableMatch(testObj, TargetType)); // 输出True

        // 检查是否是精确的B类型
        TargetType = typeof(B);
        Console.WriteLine(IsAssignableMatch(testObj, TargetType)); // 输出True
    }

    public static bool IsAssignableMatch(object obj, Type targetType)
    {
        if (obj == null) return false;
        // 注意顺序：targetType.IsAssignableFrom(对象类型) 完全等价于 obj is targetType的逻辑
        return targetType.IsAssignableFrom(obj.GetType());
    }
}

方案3：结合泛型的灵活封装（兼顾类型安全和动态性） #

如果需要在部分场景保留编译时类型提示，还可以结合泛型和动态类型选择：

using System;

public class A { }
public class B { }

public class Program
{
    public static void Main(string[] args)
    {
        object testObj = new A();

        // 这里可以换成运行时从配置/用户输入获取的类型名称
        string targetTypeName = "A";
        Type targetType = Type.GetType(targetTypeName);

        // 根据动态获取的类型调用对应的泛型方法
        if (targetType == typeof(A))
        {
            CheckAndHandleType<A>(testObj);
        }
        else if (targetType == typeof(B))
        {
            CheckAndHandleType<B>(testObj);
        }
    }

    public static void CheckAndHandleType<T>(object obj)
    {
        if (obj is T typedObj)
        {
            Console.WriteLine($"对象是{T.Name}类型，可以直接转换为强类型：{typedObj}");
            // 这里可以直接使用typedObj做强类型操作
        }
        else
        {
            Console.WriteLine($"对象不是{T.Name}类型");
        }
    }
}

简单总结下：is是编译时绑定的语法糖，没法动态修改比较类型，但用GetType()、Type.IsAssignableFrom()这些反射相关的方法，完全可以实现你想要的“运行时可变类型比较”需求，甚至能做到比is更灵活的判断逻辑。

内容的提问来源于stack exchange，提问作者majorTom