Question au sujet d'une méthode abstraite

Version imprimable

Bonjour!

Voici ma classe parent : BusinessBase

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
26
27
28
29
30
31
 
    [Serializable]
    public abstract class BusinessBase : ICloneable
    {
        #region Private Properties
        private Hashtable brokenRules;
        #endregion
 
        #region Constructors
        public BusinessBase()
        {
            brokenRules = new Hashtable();
        }
        #endregion
 
        ....
 
        #region Methods
        protected abstract void Initialize();
        protected abstract void Initialize(BusinessBase businessBase);
        protected abstract void Initialize(DataRow row);
        public abstract override string ToString();
        public abstract object Clone();
        #endregion
 
        #region SQL Methods
        protected abstract void Load(int id);
        protected abstract void Save();
        protected abstract void Delete();
        #endregion
    }

et un exemple de classe qui hérite de BusinessBase

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
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
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
 
    public class FeatureType : BusinessBase
    {
        #region Private Properties
        private int _featureTypeId;
        private string _featureTypeName;
        private int _featureTypePosition;
        private bool _featureTypeHasFeatures;
        #endregion
 
        #region Constructors
        public FeatureType() : 
            base()
        {
            Initialize();
        }
 
        public FeatureType(FeatureType featureType) :
            base()
        {
            Initialize(featureType);
        }
 
        public FeatureType(DataRow row) :
            base()
        {
            Initialize(row);
        }
 
        public FeatureType(int featureTypeId) : 
            base()
        {
            Load(featureTypeId);
        }
        #endregion
 
        ...
 
        #region Methods
        protected override void Initialize()
        {
             ...
        }
 
        protected override void Initialize(FeatureType featureType)
        {
            this._featureTypeId = 0;
            this.FeatureTypeName = featureType.FeatureTypeName;
            this.FeatureTypePosition = featureType.FeatureTypePosition;
            this.FeatureTypeHasFeatures = featureType.FeatureTypeHasFeatures;
        }
 
        protected override void Initialize(DataRow row)
        {
             ...
        }
 
        public override string ToString()
        {
            return String.Format("FeatureType : [{0}, {1}, {2}, {3}]",
                this.FeatureTypeId,
                this.FeatureTypeName,
                this.FeatureTypePosition,
                this.FeatureTypeHasFeatures);
        }
 
        public override object Clone()
        {
            return new FeatureType(this);
        }
        #endregion
 
        #region SQL Methods
        protected override void Load(int airpotId)
        {
             ...
        }
 
        protected override void Save()
        {
             ...
        }
 
        protected override void Delete()
        {
             ...
        }
        #endregion
    }

Et ma question... Comment se fait-il que je reçoive l'erreur suivante ?

Citation:

'Feature' does not implement inherited abstract member 'BusinessBase.Initialize(BusinessBase)'

Le paramètre de la méthode Initialize(FeatureType featureType) recoit bel et bien un parametre de type "enfant de" BusinessBase... Qu'est-ce qui se passe?

Merci de vos éclaircissements!!

25/02/2009, 15h52
thelpi

Il me semble que ce que tu cherche à faire est impossible, je crois qu'il faut implémenter la méthode Initialize de ta classe fille avec un objet BusinessBase que tu casteras ensuite en objet enfant dans la méthode...

si je me trompe la solution m'intéresse :p
25/02/2009, 15h56
JeePI196

C'est ce que j'ai du faire pour l'instant (pour ne pas bloquer le développement) mais je me demandais si C# était assez intelligent pour deviner que les paramètres étaient des enfants...

Les experts, nous vous attendons :lol:
25/02/2009, 16h19
Philippe Vialatte

ce que tu devrais faire, c'est te baser sur des interfaces, et pas sur des objets...

genre, faire une interface commune IBusinessBase, ou tu definis tes fonctions (comme ca, tes classes enfants devront l'implementer)

Apres, si tu veux initialiser brokenrules (hmmm, ce serait du CSLA que ca ne m'etonnerait qu'a moitie ;) ), tu peux faire une classe BusinessBase, qui contient un contructeur, et faire heriter FeatureType de IBusinessBase et de BusinessBase...

Ca devrait le faire ;)
25/02/2009, 16h39
DarkHerumor

Citation:

Envoyé par JeePI196

C'est ce que j'ai du faire pour l'instant (pour ne pas bloquer le développement) mais je me demandais si C# était assez intelligent pour deviner que les paramètres étaient des enfants...

Normalement c# 4 me semble :)

Citation:

Envoyé par JeePI196

Bonjour!
...
Le paramètre de la méthode Initialize(FeatureType featureType) recoit bel et bien un parametre de type "enfant de" BusinessBase... Qu'est-ce qui se passe?

Merci de vos éclaircissements!!

salut. si je comprends bien FeatureType hérite de BusinessBase c'est ça ?
Alors c'est normal : tu ne peux pas demander dans ton implémentation de Initialize(...) un type plus restrictif que celui que tu déclares demander dans la version abstraite.(J'ai le même problème d'ailleurs :))

si Initialize était une méthode publique ça serait encore plus flagrant:
Code:

1 2 3 4 5 6 7 8 9 BusinessBase objet1 = new FeatureType(); //AutreClasse hérite de BusinessClass BusinessBase objet2 = new AutreClasse(); //Problème : c'est la méthode FeatureType.Initialize() qui est appellée, //pourtant elle ne prend que des FeatureType en argument : objet1.Initialize(objet2);
exemple:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 abstract class A { public abstract B maMethode(C); } class D:A { public override E maMethode(F); } class G:C { ... }
E doit hériter de B ou être un B. (covariance)
Au contraire, C doit hériter de F ou être un F (contravariance) car on doit pouvoir passer un C à D.maMethode() sans dommage : D.maMethode(G)

maintenant, c'est vrai que ta méthode est déclarée comme "protected",
donc on voit mal comment un client de BusinessBase pourrait l'appeller (?)...

Ou alors, si BusinessBase implémente et expose une méthode publique qui prend comme argument un BusinessBase, et passe cet argument à BusinessBase.Initialize(BusinessBase bb), effectivement là y a problème...?

C'est bête parce que (il me semble ?) que dans Eiffel tu peux exiger un argument du type de ta classe dans tes méthodes sans perdre en généralité:
Code:

1 2 3 4 5 6 7 8 9 abstract class BusinessBase { protected abstract void Initialize(b like Current);//b est de type BusinessBase } class FeatureType:BusinessBase { protected override void Initialize(f like Current);//f est de type FeatureType }
(je suis pas trop sûr non plus...)

@pvialatte : si tu déclares une interface tu mets quoi comme argument des fonctions ?
Code:

1 2 3 4 5 public interface IBusinessBase { void Initialize(IBusinessBase bb); // <--- ça ? }
et tu recastes après bb en FeatureType dans FeatureType.Initialize() ?

un truc dans ce genre ne marcherait-il pas?
Code:

1 2 protected abstract void Initialize<T>(T business) where T: BusinessBase;