C#: types Génériques qui ont un constructeur?

J'ai le C# suivants du code de test:

  class MyItem
  {
    MyItem( int a ) {}
  }

  class MyContainer< T >
    where T : MyItem, new()
  {
    public void CreateItem()
    {
      T oItem = new T( 10 );
    }
  }

Visual Studio ne peut pas compiler, l'erreur est à la ligne où la "nouvelle" est utilisé:

'T': cannot provide arguments when creating an instance of a variable type

Est-il possible en C# pour créer un objet de type générique avec des non-constructeur sans paramètre? Pas de problème pour faire ce genre de chose dans les modèles C++, donc je suis très curieux de savoir pourquoi je ne peux pas faire la même chose en C#. Peut-être quelques autres " où " est nécessaire, ou la syntaxe est différente?

InformationsquelleAutor grigoryvp | 2009-11-30
  1. 16

    Il peut être fait avec réflexion:

    public void CreateItem()
{
  int constructorparm1 = 10;
  T oItem = Activator.CreateInstance(typeof(T), constructorparm1) as T;
}

    Mais il n'y a pas de contrainte générique pour s'assurer que T implémente l'souhaité constructeur, donc je ne le conseille pas de faire cela, sauf si vous êtes prudent de déclarer que constructeur dans chaque type qui implémente l'interface.

    • Je me souviens, la new() contrainte se traduit par une Activator.CreateInstance() appel.
    InformationsquelleAutor Greg
  2. 25

    C#, et VB.Net pour cette question, ne prennent pas en charge la notion de contraindre un générique pour avoir un constructeur avec paramètres spécifiques. Il ne supporte que les contraignant d'avoir un constructeur vide.

    Un travail autour de est de demander à l'appelant de passer dans une usine lambda de créer de la valeur. Par exemple

    public void CreateItem(Func<int,T> del) {
  T oItem = del(10);
}

    Site d'appel

    CreateItem(x => new SomeClass(x));
    • Très intelligent approche!
    InformationsquelleAutor JaredPar
  3. 9

    Il n'y a pas une telle contrainte générique, de sorte qu'il n'est pas possible directement (ce qui est un CLR limitation). Si vous voulez cela, vous devez fournir une usine de classe (qui a un constructeur sans paramètre), et de le passer comme deuxième paramètre de type générique.

    InformationsquelleAutor Pavel Minaev
  4. 4

    De l'OMI, la meilleure approche ici est une méthode initialize, c'est à dire

    interface ISomeInterface {
    void Init(int i);
}
class Foo : ISomeInterface {
    void ISomeInterface.Init(int i) { /* ... */ }
}
static class Program {
    static T Create<T>(int i) where T : class, ISomeInterface, new() {
        T t = new T();
        t.Init(i);
        return t;
    }
    static void Main() {
        Foo foo = Create<Foo>(123);
    }
}

    Cependant, vous pouvez faire ce que vous voulez avec Expression (mais sans compilation de soutien):

    using System;
using System.Linq.Expressions;
class Foo {
    public Foo(int i) { /* ... */ }
}
static class Program {
    static T Create<T>(int i) {
        return CtorCache<T>.Create(i);
    }
    static class CtorCache<T> {
        static Func<int, T> ctor;
        public static T Create(int i) {
            if (ctor == null) ctor = CreateCtor();
            return ctor(i);
        }
        static Func<int, T> CreateCtor() {
            var param = Expression.Parameter(typeof(int), "i");
            var ci = typeof(T).GetConstructor(new[] {typeof(int)});
            if(ci == null) throw new InvalidOperationException("No such ctor");
            var body = Expression.New(ci, param);
            return Expression.Lambda<Func<int, T>>(body, param).Compile();
        }
    }
    static void Main() {
        Foo foo = Create<Foo>(123);
    }
}

    Noter que cette caches et réutilise le délégué pour la performance.

    • Est-ce à différer de façon importante de l'aide Activator.CreateInstance()? Si je comprends bien, qu'il n'ait le temps de compilation de soutien, et les deux lancent une erreur d'exécution si la durée de constructeur n'existe pas.
    • oui, si vous l'utilisez beaucoup (par exemple, une usine): une fois créé, le délégué est pré-en cache et jitted - pas plus de réflexion.
    InformationsquelleAutor Marc Gravell
  5. 2

    Un modèle que j'utilise est d'avoir la contrainte de la classe implémente une interface qui définit une méthode Init avec la signature appropriée: 

    interface IMyItem
{
    void Init(int a);
}

class MyItem : IMyItem
{
    MyItem() {}
    void Init(int a) { }
}    

class MyContainer< T >
    where T : MyItem, IMyItem, new()
{
    public void CreateItem()
    {
        T oItem = new T();
        oItem.Init( 10 );
    }
}
    • Généralement une mauvaise idée, parce que maintenant vous pouvez avoir créé mais non initialisée objets.
    InformationsquelleAutor Daniel Schaffer