Discussion :

[CUCARACHA]

Salut,

Soit une classe abstraite A (qui factorise les membres communs à 2 contrôles web personnalisés).

Soit contrôles web personnalisés dont le code behind hérite de A.

Un méthode calculFin qui, dans un cas renvoie une date et dans l'autre un int.

J'ai essayé de déclarer calculFin en abstrait dans la classe de base en mettant des membre de type object mais dans le cas où c'est des dates, ça me fait faire trop de conversion de date à chaine, de chaine à date, avec à chaque fois le risque de générer des erreurs.

Mon objectif est de disposer de cette méthode dans les deux composants.

Existerait-il un montage qui permettrait de les déclarer dans les deux composants et qu'elles héritent du membre abstrait de la classe de base sachant que j'aimerais passer des paramètres en typage fort ?

D'avance merci

Laurent

[Arthis]

Pourquoi ne pas mettre deux fonction calculfin dans A l'une te renvoyant un int l'autre une date. Ensuite dans tes contrôles tu appelles celle que tu veux.

[CUCARACHA]

C'est ce que je vais faire mais ça ne correspondait pas à ma vision de l'héritage.

[CUCARACHA]

Je précise que certaines méthodes factorisées de la classe de base utilisent cette méthode qui est implémentée dans les contrôles, en conséquence, je suis obligé de la(les) déclarer en abstract dans la classe de base.

Si je fais des signatures différentes, je vais mettre des if de partout et c'est justement ce que je cherchais à éviter.

[CUCARACHA]

Je crois que j'ai une idée

Je crée une classe de base pour le paramètre d'entrée et deux héritiers.

Lorsque j'invoque la méthode, je passe l'une ou l'autre des héritiers (paramètre) à la méthode qui attend la casse paramètre de base.

Ainsi par le jeu des héritages, je peux définir le paramètre avec le bon héritier en fonction de la classe depuis laquelle j'invoque la méthode.

Qu'en penses tu ?

Merci

Laurent

[Arthis]

pourquoi ne pas avoir une méthode qui regroupe ton code CoreCalculFin dans ta classe A, et ensuite avoir simplement différentes façons d'accéder au résultat de ton CoreCalculFin tel que Datetime CalculFin ou int CalculFin par exemple.

Ainsi le code de ta classe A fonctionne avec ce qu'il connait à savoir CoreCalculFin sans avoir a se préoccuper de qui demande l'information.

mes deux cents...

maintenant, je laisse les grands de la POO parler!

Bon courage à toi en tout cas, j'espère juste ne pas t'avoir embrouillé plus!

[EDIt]: oh tu as deja ecrit quelque chose[/Edit]

[Arthis]

quelque chose comme ca?

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
 
using System;
using System.Data;
 
public abstract class BaseClass
{
    public float Calcul2()
    {
        float returnvalue;
 
        returnvalue = 2 + CoreCalculFin();
 
        return returnvalue;
    }
 
    public long CoreCalculFin()
    {
        long returnvalue;
 
        returnvalue = 3;
 
        return returnvalue;
    }
}
 
 
public class Class1 : BaseClass
{
    public int CalculFinToDateTime()
    {
        return int.Parse(CoreCalculFin().ToString());
    }
 
}
 
public class Class2 : BaseClass
{
    public DateTime CalculFinToDateTime()
    {
        return DateTime.Parse(CoreCalculFin().ToString());
    }
}

ou comme ca?

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
using System;
using System.Data;
 
public interface IParametre
{
}
 
public class p1 : IParametre
{
}
 
public class p2 : IParametre
{
}
 
public abstract class BaseClass
{
    public float Calcul2(IParametre p)
    {
        float returnvalue;
 
        returnvalue = 2 + CoreCalculFin(p);
 
        return returnvalue;
    }
 
    public long CoreCalculFin(IParametre p)
    {
        long returnvalue=0;
 
        if (p is p1)
            returnvalue = 3;
        if (p is p2)
            returnvalue = 4;
 
        return returnvalue;
    }
}
 
 
public class Class1 : BaseClass
{
    public int CalculFinToDateTime()
    {
        p1 p = new p1();
        return (int)CoreCalculFin(p);
    }
 
}
 
public class Class2 : BaseClass
{
    public DateTime CalculFinToDateTime()
    {
        p2 p = new p2();
        return DateTime.Parse(CoreCalculFin(p).ToString());
    }
}