Générics et constructeur

Version imprimable

04/08/2008, 07h44
sybaris

Générics et constructeur
Bonjour,

Le code suivant me provoque cette erreur de compilation :
"'T': cannot provide arguments when creating an instance of a variable type."
Code:

1 2 3 4 5 6 7 8 9 public class MyList<T> where T : MyObjectBase, new() { public void Test() { T Myobj = new T("Test"); } }
Or les types que je fournirais pour T ont un constructeur avec 1 argument de type string.

Existe-t-il une syntaxe (hormis la réflexion) pour permettre de spécifier une signature de constructeur obligatoire sur le type T ?

Est-il possible d'ailleurs à une classe de dire qu'elle implémente une certaine signature de constructeur, et d'obliger tous les descendant de cette classe d'implémenter cette signature de constructeur ?

Merci d'avance.

Sybaris
04/08/2008, 09h01
Tober

peut etre en mettant un constructeur comme tu veux dans MyObjectBase en virtuel...
04/08/2008, 09h17
SirJulio

Bonjour,

en un mot, non il n'est pas possible d'obliger une derivation d'implementer un constructeur specifique, et in extenso dans la norme actuelle, on ne peut que specifier qu'un constructeur par defaut sur des constraintes de genericité.

Pour resoudre ton probleme, mais tu es deja au courant apparement, il reste la reflexion.

Bon courage.

Bonjour,

Merci pour vos réponse.
J'ai donc adopté comme solution d'utiliser la réflexion

Mon code est du genre :
Code:

1 2 3 4 ConstructorInfo[] ci = typeof(T).GetConstructors(); object[] parameters; parameters = new object[] { "Test" }; T Myobj = (T)ci[0].Invoke(parameters);
Je ne trouves pas cela très propre, ni très optimisé, mais bon... Des fois faut être pragmatique...

Je pense qu'il serait utile que le Framework dotnet rajoute une fonctionnalité "interface de constructeur".
Une "interface de constructeur" définirait une signature de constructeur.
Une classe de base qui implémenterait cette "interface de constructeur" obligerait toutes ses classes descendante à l'implémenter aussi...

Qu'en pensez vous ?

Sybaris

11/08/2008, 10h50
Guulh

Je vois pas l'intérêt. Si vraiment le fait d'obtenir une objet à partir d'une chaîne est la caractéristique qui t'intéresse, tu peux imaginer une interface du style IConvertibleFromString<T> avec une méthode T FromString(string s).
12/08/2008, 22h58
sybaris

Bonjour,

Ici l'argument du constructeur est une chaine de caractère uniquement pour exemple.

L'intérêt de préciser des paramètres à un constructeur est par exemple d'obliger de fournir des informations ou des objets,et de vérifier leur validité 1 fois pour toute dans le constructeur.

L'alternative est d'avoir un constructeur sans paramètre et autant de propriétés. Cependant, la validation devra être faite à chaque méthode "sensible" ou à chaque accesseur de propriété. Cela peut devenir très rapidement pénible...

Bref, pouvoir imposer une signature de constructeur me parait être quelque chose d'utile...

Sybaris
13/08/2008, 09h25
Guulh

Citation:

Envoyé par sybaris

Bonjour,

Ici l'argument du constructeur est une chaine de caractère uniquement pour exemple.

L'intérêt de préciser des paramètres à un constructeur est par exemple d'obliger de fournir des informations ou des objets,et de vérifier leur validité 1 fois pour toute dans le constructeur.

Je suis d'accord que ça pourrait avoir du sens pour les objets immutable, qui ne sont plus modifiables après leur construction.

Citation:

Envoyé par sybaris

Bref, pouvoir imposer une signature de constructeur me parait être quelque chose d'utile...

Les langages objets que je connais (C++, C#, java) ont pas mal en commun dans la gestion des constructeurs. Notamment le fait qu'ils ne sont pas hérités. Le fait d'avoir une contrainte "new()" dans la définition d'un type générique est déjà un peu limite limite, puisqu'elle peut être vérifiée par un type A1 mais mas par un type A2 qui hérite de A1.

Je lisais sur je sais plus quel blog que pour ces histoires de contraintes (mot-clé where), les concepteurs de C# se demandaient jusqu'où ça valait la peine d'aller dans le pattern matching. Tu peux imaginer quelque chose de bien plus puissant, mais risqué : tu pourrais forcer un type à avoir une certaine propriété, une certaine méthode, ...
13/08/2008, 22h29
sybaris

Bonjour,

En Delphi par exemple il y a possibilité d'hériter d'un constructeur...
Et grâce aux méta classe en delphi, il est possible d'appeler ce constructeur sur une classe dont le type est fixé à l'exécution.

En .net pour faire cela, il faut utiliser la réflexion...

Sybaris

Perso je me serai suffit de celà :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
public class MyList<T>
        where T : MyObjectBase, new(), IInitializable
    {
        public void Test()
        {
            T Myobj = new T();
            Myobj.Initialize("Test");
        } 
    }
 
public interface IInitializable
{
  void Initialize(string param);
  bool Initialized{get;}
}

///

14/08/2008, 10h18
tomlev

Citation:

Envoyé par Guulh

Tu peux imaginer quelque chose de bien plus puissant, mais risqué : tu pourrais forcer un type à avoir une certaine propriété, une certaine méthode, ...

Ben ça on peut le faire, il suffit de mettre une interface dans les contraintes ;)
14/08/2008, 10h56
Guulh

Oui, mais je pensais aux cas où on manipule des classes existantes.

Le framework a déjà ce genre de comportemnts, parfois : le foreach fonctionne avec tout objet ayant une méthode GetEnumerator(), les initialisateurs de listes fonctionnent (en C#3) avec tout objet ayant une méthode Add, ...