C#泛型缓存仓库调用接口约束类静态方法报CS0119如何解决

错误原因 #

CS0119报错的核心是C# 接口中定义的普通静态方法不参与多态继承，无法通过泛型参数T调用实现类中定义的同名静态方法，静态方法是编译时绑定的，不会根据泛型的实际类型动态调度。

解决方案 #

方案1：全版本兼容实现（推荐） #

利用泛型静态类的字段隔离特性实现：每个闭合泛型类型会持有独立的静态字段副本，刚好满足「同类型共享基键、不同类型基键隔离」的需求，不需要依赖高版本C#特性。

步骤1：定义基础结构

// 空标记接口，用于约束可缓存类型
public interface ICacheModel { }

// 基键配置特性，可选，用于手动指定类型的缓存前缀
[AttributeUsage(AttributeTargets.Class, AllowMultiple = false)]
public class CacheBaseKeyAttribute : Attribute
{
    public string BaseKey { get; }
    public CacheBaseKeyAttribute(string baseKey)
    {
        BaseKey = baseKey ?? throw new ArgumentNullException(nameof(baseKey));
    }
}

// 泛型基键提供类，每个T对应独立的基键缓存
public static class CacheKeyProvider<T> where T : class, ICacheModel
{
    public static string BaseKey { get; }

    // 静态构造函数仅为每个T执行一次，性能无损耗
    static CacheKeyProvider()
    {
        var customKey = typeof(T)
            .GetCustomAttributes(typeof(CacheBaseKeyAttribute), false)
            .Cast<CacheBaseKeyAttribute>()
            .FirstOrDefault()?.BaseKey;
        // 未手动配置则默认用类型全名称作为基键，天然全局唯一
        BaseKey = customKey ?? $"{typeof(T).FullName}-";
    }
}

步骤2：改造缓存仓库

public interface ICacheRepository<T> where T : class, ICacheModel
{
    Task<T> GetAsync(string key);
}

public class CacheRepository<T> : ICacheRepository<T> where T : class, ICacheModel
{
    private readonly IDistributedCache _distributedCache;

    public CacheRepository(IDistributedCache distributedCache)
    {
        _distributedCache = distributedCache;
    }

    public async Task<T> GetAsync(string key)
    {
        var fullKey = CacheKeyProvider<T>.BaseKey + key;
        return await _distributedCache.GetAsync<T>(fullKey);
    }
}

步骤3：业务类使用

// 手动指定前缀，可选
[CacheBaseKey("CacheSampleClass-")]
public class CacheSampleClass : ICacheModel
{
    public Guid Id { get; set; }
    public string Prop1 { get; set; }
    public string Prop2 { get; set; }
}

方案2：C# 11+/NET 7+ 静态抽象接口实现 #

如果你的项目最低支持.NET 7和C# 11，可以用静态抽象接口成员的特性，更贴合你最初的设计思路：

步骤1：改造接口定义

// 用自约束泛型接口定义静态抽象方法
public interface ICacheModel<TSelf> where TSelf : ICacheModel<TSelf>
{
    static abstract string GetBaseCacheKey();
}

步骤2：改造缓存仓库

public interface ICacheRepository<T> where T : class, ICacheModel<T>
{
    Task<T> GetAsync(string key);
}

public class CacheRepository<T> : ICacheRepository<T> where T : class, ICacheModel<T>
{
    private readonly IDistributedCache _distributedCache;

    public CacheRepository(IDistributedCache distributedCache)
    {
        _distributedCache = distributedCache;
    }

    public async Task<T> GetAsync(string key)
    {
        // 可直接通过泛型参数调用静态抽象方法
        var fullKey = T.GetBaseCacheKey() + key;
        return await _distributedCache.GetAsync<T>(fullKey);
    }
}

步骤3：业务类实现

public class CacheSampleClass : ICacheModel<CacheSampleClass>
{
    public Guid Id { get; set; }
    public string Prop1 { get; set; }
    public string Prop2 { get; set; }

    private static readonly string _baseKey = "CacheSampleClass-";
    public static string GetBaseCacheKey() => _baseKey;
}

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