Question

好的，我正在寻找一些输入，我很确定.NET 3.5目前不支持这个，但是这里有。

我想要一个传递给我的类的泛型类型，以获得这样的构造函数：

new(IDictionary<string,object>)

所以课程看起来像这样

public MyClass<T>  where T : new(IDictionary<string,object>)
{
  T CreateObject(IDictionary<string,object> values)
  {
    return new T(values);
  }
}

但是编译器不支持这个，它并不真正知道我在问什么。

有些人可能会问，你为什么要这样做？好吧，我正在开发一个ORM的宠物项目，所以我从数据库中获取值，然后创建对象并加载值。

我认为允许对象只使用我给它的值创建自己会更清晰。据我所知，我有两个选择：

1）使用反射（我试图避免）来获取PropertyInfo []数组，然后使用它来加载值。

2）要求T支持这样的界面：

公共接口ILoadValues { void LoadValues（IDictionary values）; }

然后执行此操作

public MyClass<T> where T:new(),ILoadValues
{
  T CreateObject(IDictionary<string,object> values)
  {
    T obj = new T();
    obj.LoadValues(values);
    return obj;
  }
}

我认为界面的问题是哲学的，我真的不想公开一种公共方法供人们加载值。使用构造函数的想法是，如果我有一个像这样的对象

namespace DataSource.Data
{
  public class User
  {
    protected internal User(IDictionary<string,object> values)
    {
      //Initialize
    }
  }
}

只要MyClass<T>在同一个程序集中，构造函数就可用。我个人认为我认为Type约束应该问（我有权访问这个构造函数吗？我做的很棒！）

无论如何，欢迎提出任何意见。

Answer 1

正如stakx所说，你不能用通用约束来做到这一点。我过去使用的一种解决方法是让泛型类构造函数采用可用于构造T的工厂方法：

public class MyClass<T>
{
  public delegate T Factory(IDictionary<string, object> values);

  private readonly Factory _factory;

  public MyClass(Factory factory)
  {
    _factory = factory;
  }

  public T CreateObject(IDictionary<string, object> values)
  {
    return _factory(values);
  }
}

使用如下：

MyClass<Bob> instance = new MyClass<Bob>(dict => new Bob(dict));
Bob bob = instance.CreateObject(someDictionary);

这给你编译时类型安全，代价是一个稍微复杂的构造模式，以及有人可以传递给你一个实际上没有创建一个新对象（可能是也可能不是主要对象）的委托的可能性问题取决于您希望CreateObject的语义有多严格。

Answer 2

如果你可以为你将作为类型参数传递给MyClass的所有T对象创建公共基类，那么你可以这样做：

internal interface ILoadValues
{
    void LoadValues<TKey, TValue>(IDictionary<TKey, TValue> values);
}

public class Base : ILoadValues
{
    void ILoadValues.LoadValues<TKey, TValue>(IDictionary<TKey, TValue> values)
    {
        // Load values.
    }
}

public class MyClass<T>
    where T : Base, new()
{
    public T CreateObject(IDictionary<string,object> values)
    {
        ILoadValues obj = new T();
        obj.LoadValues(values);
        return (T)obj;
    }
}

如果你不能拥有共同的基础课程，我认为你应该选择itowlson提出的解决方案。

Answer 3

你做不到。 new（构造函数）约束仅适用于无参数构造函数。对于具有特定参数的构造函数，您不能有约束。

我遇到了同样的问题，但我终于决定通过一个被列为约束的接口中提供的方法来执行“注入”部分（如代码中所示））。

（我希望有人在这里找到一个更优雅的答案！）

Answer 4

我非常好奇你如何在不使用反射的情况下加载类的值，除非你有硬编码的方法来实现它。我确定还有另一个答案，但我不会羞于说我没有经验。至于我写的自动加载数据的东西，我有两个我工作的基础数据类：一个对象然后一个列表。在单个对象（BaseDataClass）中，我有这个方法。

    public virtual void InitializeClass(DataRow dr)
    {
        Type type = this.GetType();
        PropertyInfo[] propInfos = type.GetProperties();

        for (int i = 0; i < dr.ItemArray.GetLength(0); i++)
        {
            if (dr[i].GetType() != typeof(DBNull))
            {
                string field = dr.Table.Columns[i].ColumnName;
                foreach (PropertyInfo propInfo in propInfos)
                {
                    if (field.ToLower() == propInfo.Name.ToLower())
                    {
                        // get data value, set property, break
                        object o = dr[i];
                        propInfo.SetValue(this, o, null);
                        break;
                    }
                }
            }
        }
    }

然后在数据列表中

public abstract class GenericDataList<T> : List<T> where T : BaseDataClass
{
    protected void InitializeList(string sql)
    {
        DataHandler dh = new DataHandler(); // my general database class
        DataTable dt = dh.RetrieveData(sql); 
        if (dt != null)
        {
            this.InitializeList(dt);
            dt.Dispose();
        }
        dt = null;
        dh = null;
    }

    protected void InitializeList(DataTable dt)
    {
        if (dt != null)
        {
            Type type = typeof(T);
            MethodInfo methodInfo = type.GetMethod("InitializeClass");

            foreach (DataRow dr in dt.Rows)
            {
                T t = Activator.CreateInstance<T>();
                if (methodInfo != null)
                {
                    object[] paramArray = new object[1];
                    paramArray[0] = dr;
                    methodInfo.Invoke(t, paramArray);
                }

                this.Add(t);
            }
        }
    }
}

我接受批评，因为之前没有人审查过这段代码。我是我工作的唯一程序员，所以我没有其他人可以反复思考。谢天谢地，现在我遇到了这个网站！

编辑：你知道吗？现在看一下，我不明白为什么我不应该只重写最后一个方法

        protected void InitializeList(DataTable dt)
        {
            if (dt != null)
            {
                Type type = typeof(T);

                foreach (DataRow dr in dt.Rows)
                {
                    T t = Activator.CreateInstance<T>();
                    (t as BaseDataClass).InitializeClass(dr);

                    this.Add(t);
                }
            }
        }

我认为这有效，尽管我还没有测试过。无需在该部分使用反射。

如何解决C＃中泛型类型约束的局限性？

4 个答案: