如何实现基于抽象类派生类的SQL结果通用对象填充方法？

嗨，我之前也碰到过类似的困扰，C#确实不允许直接实例化抽象类，而且泛型方法里直接调用带参数的构造函数也有约束限制，给你几个可行的解决方案：

方案一：使用工厂委托（最灵活推荐） #

这种方法把对象实例化的逻辑交给调用方，避免泛型方法里的构造函数约束问题，同时兼容所有派生类的个性化初始化需求。

修改你的泛型方法，新增一个Func<DataRow, T>类型的参数，用来传入从数据行创建实例的逻辑：

public static List<T> PopulateList<T>(string sql, Func<DataRow, T> createInstance)
{
    List<T> list = new List<T>();
    
    // 这里补上你的SQL执行逻辑，以DataTable为例
    using (var connection = new SqlConnection("你的数据库连接字符串"))
    {
        connection.Open();
        using (var command = new SqlCommand(sql, connection))
        {
            using (var reader = command.ExecuteReader())
            {
                DataTable dt = new DataTable();
                dt.Load(reader);
                
                foreach (DataRow row in dt.Rows)
                {
                    // 调用传入的委托创建实例，添加到列表
                    list.Add(createInstance(row));
                }
            }
        }
    }
    
    return list;
}

调用的时候，只需要针对每个派生类传入对应的实例化逻辑即可，比如你有一个Customer派生自抽象类BaseEntity：

// 调用示例
var customerList = PopulateList<Customer>(
    "SELECT Id, Name, Email FROM Customers",
    row => new Customer(row) // 这里直接调用派生类的带参构造函数
);

方案二：反射+泛型约束（适合统一构造逻辑的场景） #

如果你的所有派生类都有相同签名的构造函数（比如都接受DataRow参数），可以用反射来创建实例，同时加上泛型约束确保T是抽象类的派生类。

// 约束T必须是BaseEntity的派生类
public static List<T> PopulateList<T>(string sql) where T : BaseEntity
{
    List<T> list = new List<T>();
    
    // 同样的SQL执行逻辑，获取DataTable
    using (var connection = new SqlConnection("你的连接字符串"))
    {
        connection.Open();
        using (var command = new SqlCommand(sql, connection))
        {
            using (var reader = command.ExecuteReader())
            {
                DataTable dt = new DataTable();
                dt.Load(reader);
                
                foreach (DataRow row in dt.Rows)
                {
                    // 通过反射调用带DataRow参数的构造函数
                    T instance = (T)Activator.CreateInstance(typeof(T), row);
                    list.Add(instance);
                }
            }
        }
    }
    
    return list;
}

⚠️ 重要提醒：你提到抽象类的构造函数会调用抽象方法，这是一个潜在的坑！因为基类构造函数执行时，派生类的成员还未完成初始化，此时调用派生类实现的抽象方法，很可能会访问到未初始化的属性，引发异常。

建议把初始化逻辑抽成单独的抽象方法，在实例化后调用，比如：

// 抽象基类
public abstract class BaseEntity
{
    // 空构造函数，避免在构造阶段调用抽象方法
    protected BaseEntity() { }
    
    // 抽象初始化方法，派生类实现具体赋值逻辑
    public abstract void Initialize(DataRow row);
}

// 派生类示例
public class Customer : BaseEntity
{
    public int Id { get; set; }
    public string Name { get; set; }

    public override void Initialize(DataRow row)
    {
        Id = Convert.ToInt32(row["Id"]);
        Name = row["Name"].ToString();
    }
}

对应的泛型方法可以改成：

// 新增new()约束，确保T有无参构造函数
public static List<T> PopulateList<T>(string sql) where T : BaseEntity, new()
{
    List<T> list = new List<T>();
    
    // SQL执行逻辑...
    foreach (DataRow row in dt.Rows)
    {
        T instance = new T();
        instance.Initialize(row); // 实例化后再执行初始化
        list.Add(instance);
    }
    
    return list;
}

这样既避免了构造阶段的风险，也能统一管理初始化逻辑。

备注：内容来源于stack exchange，提问作者Richard B. Sorensen