Как работать вокруг ограничений в универсальных ограничениях типа в C#?

Вы не можете этого сделать. Ограничения new (конструктор) предназначены только для конструкторов без параметров. У вас не может быть ограничения для конструктора с определенными параметрами.

Однако я столкнулся с той же проблемой и, наконец, остановился на выполнении части «инъекции» с помощью метода, который предоставляется в одном из интерфейсов, который указан как ограничение (как показано в вашем коде ).

(Надеюсь, здесь кто-то нашел более элегантный ответ на эту проблему!)

Мне законно интересно, как вы будете загружать значения класса без использования рефлексии, если только у вас нет жестко закодированных методов для этого. Я уверен, что есть другой ответ, но мне не стыдно сказать, что у меня нет опыта в этом. Что касается того, что я написал для автозагрузки данных, у меня есть два базовых класса данных, с которыми я работаю: один объект и список. В единственном объекте (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);
                }
            }
        }

Я предполагаю, что это работает, хотя я не проверял это. Нет необходимости использовать отражение в этой части.

Как сказал 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).