Discussion :

[sybaris]

Bonjour,

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[Tober]

peut etre en mettant un constructeur comme tu veux dans MyObjectBase en virtuel...

[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.

[sybaris]

Bonjour,

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

Mon code est du genre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[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).

[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

[Guulh]

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.

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, ...

[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

[smyley]

Perso je me serai suffit de celà :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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;}
}

///

[tomlev]

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

[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, ...