C#中不使用反射仅通过Type访问静态抽象接口成员的方法

首先纠正你代码里的两个问题：

1. 接口的静态抽象成员必须显式加abstract修饰，实现类实现该成员时不需要加abstract，否则代码无法编译
2. 你写的ISomeInterface interface = /* How? */ 思路本身不成立：静态抽象接口成员属于类型层面的成员，和实例完全无关，不可能通过转换得到接口实例来访问静态成员

实现方案 #

首先明确：静态抽象接口成员的合法访问路径，必须是带有对应接口约束的泛型上下文中直接通过泛型参数访问，这个路径本身完全不需要反射。你只需要解决「手里只有Type类型的实现类标识，怎么进入对应泛型上下文」的问题即可。

方案1：低反射委托缓存方案（推荐） #

该方案仅第一次访问对应实现类型时用到少量反射构造委托，后续所有访问零反射、性能接近原生调用，且不需要硬编码成员名，编译时就能检查成员合法性。

第一步：修正后的可编译业务代码

public interface ISomeInterface
{
    static abstract int SomeProperty { get; set; }
}

public class SomeClass : ISomeInterface
{
    public static int SomeProperty { get; set; } = 2;
}

第二步：实现泛型访问器

public static class InterfaceStaticAccessor<TInterface> where TInterface : class
{
    // 缓存已构造的Get访问委托，避免重复反射
    private static readonly Dictionary<Type, Func<int>> _somePropertyGetterCache = new();

    public static int GetSomeProperty(Type implementingType)
    {
        if (_somePropertyGetterCache.TryGetValue(implementingType, out var getter))
        {
            return getter();
        }

        // 仅首次访问该实现类型时执行一次反射构造委托
        var genericMethod = typeof(InterfaceStaticAccessor<TInterface>)
            .GetMethod(nameof(GetSomePropertyImpl), System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Static)!
            .MakeGenericMethod(implementingType);
        getter = (Func<int>)genericMethod.CreateDelegate(typeof(Func<int>));
        _somePropertyGetterCache[implementingType] = getter;

        return getter();
    }

    // 泛型约束下直接访问静态抽象成员，完全无反射
    private static int GetSomePropertyImpl<TImplement>() where TImplement : TInterface
    {
        return TImplement.SomeProperty;
    }

    // Set方法、其他静态成员的访问可以按照相同逻辑扩展
}

第三步：调用方式

Type implementingType = typeof(SomeClass);
// 不需要反射直接拿值，返回结果为2
int value = InterfaceStaticAccessor<ISomeInterface>.GetSomeProperty(implementingType);

方案2：完全零反射方案（适合实现类可提前枚举的场景） #

如果你可以提前穷举所有实现了ISomeInterface的类型，可以直接手动做类型到访问委托的映射，全程完全不涉及反射：

public static class SomeInterfaceStaticAccessor
{
    private static readonly Dictionary<Type, Func<int>> _somePropertyGetterMap = new()
    {
        [typeof(SomeClass)] = () => SomeClass.SomeProperty,
        // 其他实现类直接在这里加映射即可
    };

    public static int GetSomeProperty(Type implementingType)
    {
        return _somePropertyGetterMap[implementingType]();
    }
}

方案优势 #

• 完全避免了你示例中硬编码成员名的反射写法，不会出现拼写错误、成员改名后不报错的问题
• 性能远高于直接反射访问，委托调用的开销和原生静态成员调用几乎一致
• 不需要处理反射的权限限制、特殊类型成员的访问适配问题

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