Discussion :

[Xylan]

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 :

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

[Truelle]

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 :

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

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

[Bluedeep]

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.

[Xylan]

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 :

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

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

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

[Troopers]

question bête: ceci ne suffit pas?

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

[Bluedeep]

question bête: ceci ne suffit pas?

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

[Graffito]

Une solution :

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

[Bluedeep]

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

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

[Xylan]

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

Merci