Test de paramètre d'un constructeur avant l'appel au constructeur de base

Version imprimable

Bonjour,

Je me pose une question depuis un moment et je ne trouve pas grand chose sur le net qui en parle. Je voulais savoir s'il était possible d'insérer du code dans un constructeur avant l'appel d'un autre constructeur via this ou base.

Plus précisément je cherche à faire quelque chose dans le genre
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 public class A { public A(int x) { // du code } } public class B : A { public B(int[] array) : base(array.Length) /* là je voudrais tester si array est égal à null * et lancer une exception le cas échéant avant * l'appel au constructeur de base */ { // du code } }
Si quelqu'un a une solution ou une astuce, je lui en serais très reconnaissant.

Je n'ai pas de solution a te proposer.

Ceci dit, pourquoi ne pas faire le test de nullité de ton array avant de l'envoyer a ton constructeur et de lancer l'exception a ce moment là ?

Il y a aussi la solution de le faire après, du genre :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
    public class A
    {
        public A(int x)
        {
            if (x == -1)
            {
                throw new NullReferenceException();
            }
        }
    }
 
    public class B : A
    {
        public B(int[] array) : base(array != null ? array.Length : -1)
        /* là je voudrais tester si array est égal à null
         * et lancer une exception le cas échéant avant
         * l'appel au constructeur de base
         */
        {
            // du code 
        }
    }

28/07/2010, 08h07
Invité

Je suis d'accord avec truelle, normalement tu vérifies que la données passé au constructeur est correcte avant de l'appeler pas pendant.
28/07/2010, 09h44
Bluedeep

Citation:

Envoyé par gcorbineau

Je suis d'accord avec truelle, normalement tu vérifies que la données passé au constructeur est correcte avant de l'appeler pas pendant.

Pas très logique. Si tu livres une classe; tu dois t'assurer que le client va passer des paramètres cohérents. Règle générale : Don't trust client !

Xylan : dans ton cas, si tu as des constructeurs différents pour chaque classe héritée, une solution pourrait être d'introduire une classe intermédiaire générique, donc le paramétres de généricité serait le type de la classe file, et de là, avoir une méthode centralisée testant les différents type de paramètres aux constructeur.

Citation:

Envoyé par truelle

Ceci dit, pourquoi ne pas faire le test de nullité de ton array avant de l'envoyer a ton constructeur et de lancer l'exception a ce moment là ?

C'est un constructeur publique d'une bibliothèque donc c'est justement pour détecter une utilisation erronée que je cherche à faire ça.

J'avais effectivement envisagée cette solution mais je la trouve inadaptée au niveau de la maintenance du code.

@Bluedeep : Je ne suis pas sûr de comprendre ce que tu proposes, tu pourrais développer?

Sinon pour l'instant et faute de mieux j'ai dû ajouter un paramètre int à mon constructeur correspondant à la longueur du tableau que je passe en paramètre et je fais le test de comparaison entre ce paramètre et la taille réelle du tableau.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 public class A { public A(int x) { // du code } } public class B : A { public B(int length, int[] array) : base(length) { if (array == null) { throw new ArgumentNullException("array"); } if (array.Length != length) { throw new ArgumentException("La longueur ne correspond pas.", "array"); } // du code } }
Mais ça modifie la spécification que j'avais prévu pour ma classe.

28/07/2010, 10h49
Bluedeep

Non, ça ne colle pas, j'avais lu trop vite, désolé.

Par contre, on peut peut être reprendre le problème depuis le début. En l'occurrence, as tu absolument besoin d'hériter de ta classe A ici. Qu'est ce qui empêche de procéder par agrégation plutôt ? (quitte a implémenter dans B un operateur de cast explicite vers et/ou depuis A si nécessaire ).

Je me permets cette question car je vois trop souvent l'héritage utilisé pour de mauvaises raisons : l'héritage ne sert pas à réutiliser du code, il sert à faire des regroupement sémantiques. pour la réutilisation du code, l'aggrégation est plus adaptée.
28/07/2010, 11h50
Xylan

J'ai besoin de l'héritage car A est une classe abstraite et B une implémentation. Il y a réellement un lien sémantique.

En fait A est une classe abstraite qui me permet de regrouper des méthodes communes à toutes les implémentations possibles sans connaitre le détail de celles-ci et elle me construit aussi les champs de base communs.
Ca me permet par exemple de définir une égalité sur l'ensemble des classes qui héritent de A uniquement en utilisant les méthodes abstraites qu'elles devront redéfinir.

question bête: ceci ne suffit pas?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class A
{
    public A(int x)
    {
        // du code
    }
}
 
public class B : A
{
    public B(int[] array)
     {
            if (array == null)
            {
                throw new NullReferenceException();
            }
            base(array.Length)
    } 
}

29/07/2010, 14h00
Bluedeep

Citation:

Envoyé par Troopers

question bête: ceci ne suffit pas?

Syntaxiquement faux : on ne peut pas appeler un constructeur directement.

Une solution :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class A
{
    public A(int x)   {  // du code }
}
 
public class B : A
{
    public static B Create(int[] array) 
    {
       if (array==null) throw new Exception ....
       return new B(array) ;
     }
    
public B(int[] array) : base(array.Length)
    /* là je voudrais tester si array est égal à null
     * et lancer une exception le cas échéant avant
     * l'appel au constructeur de base
     */
    {
        // du code
    } 
}

Au lieu de : B b=new B(array) ;
faire : B b=B.Create(array) ;

Ceci dit, qu'est ce qui t'empêche de faire tout bétement cela :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
 
public class A
{
public A(int x)
{
// du code
}
}
 
public class B : A
{
public B(int[] array)
: base(checkCtorParams(array))
{
// du code
}
private static int checkCtorParams(int[] array)
{
if (array == null)
{
throw new ArgumentNullException("Param .ctor incorrect");
}
return array.Length;
}
}

30/07/2010, 22h56
Xylan

Effectivement, c'est tellement bête qu'on y pense pas -_-

Merci :)