如何在泛型类中访问抽象类的静态成员？通用数据导出器优化实现咨询

这个问题我之前也遇到过——泛型里访问抽象类的静态成员确实会踩坑，因为静态成员属于具体类型，而泛型约束没法直接关联静态成员。下面给你几个不同方向的解决方案，你可以根据自己的项目情况选择：

方案1：反射获取静态字段（最小改动） #

如果不想大幅修改现有代码，用反射直接读取子类的ColumnNames静态字段是最快的方式。我们可以在导出器里提前缓存反射结果，避免重复开销：

public class ReportExporter<TReportRowType> where TReportRowType : ReportRow
{
    // 缓存静态字段值，避免每次导出都反射
    private static readonly string[] _columnNames = typeof(TReportRowType)
        .GetField(nameof(ReportRow.ColumnNames), System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Static)
        .GetValue(null) as string[];
    private static readonly int _columnCount = _columnNames.Length;

    public void Export(IEnumerable<TReportRowType> reportEntries)
    {
        // 添加表头
        foreach (var columnName in _columnNames)
        {
            AddColumn(columnName);
        }

        foreach (var entry in reportEntries)
        {
            for (int i = 0; i < _columnCount; i++)
            {
                AddValue(entry.GetColumnValueAsString(i));
            }
            CommitLine();
        }
    }

    // 模拟你的导出方法
    private void AddColumn(string columnName) { }
    private void AddValue(string value) { }
    private void CommitLine() { }
}

优点：几乎不用修改现有ReportRow和子类的代码，快速解决问题。
缺点：依赖反射，有轻微性能开销（报表导出场景下基本可以忽略）。

方案2：静态抽象接口成员（类型安全，无反射） #

如果你用的是C# 10及以上版本，可以利用静态抽象接口成员的特性，让泛型约束直接支持访问静态成员，完全避免反射：

首先定义一个带静态抽象属性的接口：

public interface IReportRow
{
    static abstract string[] ColumnNames { get; }
    string GetColumnValueAsString(int index);
}

修改抽象类实现这个接口：

public abstract class ReportRow : IReportRow
{
    // 把原来的静态字段改成静态抽象属性，强制子类实现
    public static abstract string[] ColumnNames { get; }
    public static int ColumnCount => ColumnNames.Length;

    public string GetColumnValueAsString(int index)
    {
        var value = GetColumnValue(index);
        if (value is DateTime date)
        {
            return date.ToString("dd/MM/yyyy");
        }
        return value?.ToString() ?? string.Empty;
    }

    // 把GetColumnValue改成protected抽象方法，避免子类用new隐藏
    protected abstract dynamic GetColumnValue(int index);
}

修改子类实现静态抽象属性：

public class OrdersReportRow : ReportRow
{
    public override static string[] ColumnNames => new[] { "Date", "StoreId", "StoreName", "SkuId", "Quantity" };

    public DateTime Date { get; set; }
    public int StoreId { get; set; }
    public string StoreName { get; set; }
    public int SkuId { get; set; }
    public decimal Quantity { get; set; }

    protected override dynamic GetColumnValue(int index)
    {
        return index switch
        {
            0 => Date,
            1 => StoreId,
            2 => StoreName,
            3 => SkuId,
            4 => Quantity,
            _ => throw new IndexOutOfRangeException(),
        };
    }
}

最后修改导出器的泛型约束：

public class ReportExporter<TReportRowType> where TReportRowType : IReportRow
{
    public void Export(IEnumerable<TReportRowType> reportEntries)
    {
        // 现在可以直接访问静态成员了！
        foreach (var columnName in TReportRowType.ColumnNames)
        {
            AddColumn(columnName);
        }

        foreach (var entry in reportEntries)
        {
            for (int i = 0; i < TReportRowType.ColumnNames.Length; i++)
            {
                AddValue(entry.GetColumnValueAsString(i));
            }
            CommitLine();
        }
    }

    // 模拟导出方法
    private void AddColumn(string columnName) { }
    private void AddValue(string value) { }
    private void CommitLine() { }
}

优点：类型安全，编译期就能检查错误，完全没有反射开销，代码结构更清晰。
缺点：需要C# 10+版本，对旧项目不友好。

方案3：自定义特性（最灵活，减少重复代码） #

如果想彻底摆脱switch语句和手动维护ColumnNames数组的麻烦，可以用自定义特性标记属性，通过反射自动生成表头和列值：

首先定义标记列的特性：

[AttributeUsage(AttributeTargets.Property, Inherited = false, AllowMultiple = false)]
public class ReportColumnAttribute : Attribute
{
    public string ColumnName { get; }
    public int Order { get; }

    public ReportColumnAttribute(string columnName, int order)
    {
        ColumnName = columnName;
        Order = order;
    }
}

修改抽象类，添加获取表头和列值的通用方法：

public abstract class ReportRow
{
    // 静态方法获取指定类型的表头
    public static string[] GetColumnNames<T>() where T : ReportRow
    {
        return typeof(T)
            .GetProperties()
            .Where(p => Attribute.IsDefined(p, typeof(ReportColumnAttribute)))
            .OrderBy(p => ((ReportColumnAttribute)p.GetCustomAttribute(typeof(ReportColumnAttribute))).Order)
            .Select(p => ((ReportColumnAttribute)p.GetCustomAttribute(typeof(ReportColumnAttribute))).ColumnName)
            .ToArray();
    }

    // 实例方法获取当前对象的列值（转成字符串）
    public string[] GetColumnValuesAsString()
    {
        return this.GetType()
            .GetProperties()
            .Where(p => Attribute.IsDefined(p, typeof(ReportColumnAttribute)))
            .OrderBy(p => ((ReportColumnAttribute)p.GetCustomAttribute(typeof(ReportColumnAttribute))).Order)
            .Select(p => FormatValue(p.GetValue(this)))
            .ToArray();
    }

    // 统一格式化值的逻辑
    private string FormatValue(object value)
    {
        if (value is DateTime date)
        {
            return date.ToString("dd/MM/yyyy");
        }
        return value?.ToString() ?? string.Empty;
    }
}

修改子类，用特性标记属性：

public class OrdersReportRow : ReportRow
{
    [ReportColumn("Date", 0)]
    public DateTime Date { get; set; }

    [ReportColumn("StoreId", 1)]
    public int StoreId { get; set; }

    [ReportColumn("StoreName", 2)]
    public string StoreName { get; set; }

    [ReportColumn("SkuId", 3)]
    public int SkuId { get; set; }

    [ReportColumn("Quantity", 4)]
    public decimal Quantity { get; set; }
}

最后修改导出器：

public class ReportExporter<TReportRowType> where TReportRowType : ReportRow
{
    private static readonly string[] _columnNames = ReportRow.GetColumnNames<TReportRowType>();

    public void Export(IEnumerable<TReportRowType> reportEntries)
    {
        // 添加表头
        foreach (var columnName in _columnNames)
        {
            AddColumn(columnName);
        }

        foreach (var entry in reportEntries)
        {
            var values = entry.GetColumnValuesAsString();
            foreach (var value in values)
            {
                AddValue(value);
            }
            CommitLine();
        }
    }

    // 模拟导出方法
    private void AddColumn(string columnName) { }
    private void AddValue(string value) { }
    private void CommitLine() { }
}

优点：完全不用维护switch语句和ColumnNames数组，新增列只需要加属性和特性，扩展性极强。
缺点：依赖反射，性能略低（但报表导出场景完全够用）。

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