Discussion :

[maa]

En c# une interface déclare une propriété avec les accesseurs get; ou set;
La classe qui implémente cette interface doit déclarer cette propriété avec au moins les accesseurs de l'interface.
On peut donc écrire une interface avec une propriété {get;} et l'implémenter avec un {get; set;} dans la classe.

En VB cela ne semble pas être possible car on doit écrire Readonly au niveau de l'interface, ce qui nous contraint à écrire Readonly (et donc pas de set) au niveau de la propriété de la classe d'implémentation.

Laquelle des 2 approches vous parait la meilleure ?

[Nikoui]

Je suis aussi du genre à préférer sans hésitations C# à VB .Net, mais je le serait pas aussi catégorique que anthyme sur cette histoire : lorsqu'il m'arrive de déclarer une propriété dans une interface en ne mettant que le get (en C# donc ), c'est souvent parce que pour moi cette propriété doit être en lecture seule et n'est pas censée avoir de setter, ce qui rejoins du coup la "philosophie" de VB .Net.

Par contre, tout bien réfléchi, ça ne me choc pas du tout qu'on puisse étendre une interface en rajoutant un setter dans certains cas, et cette liberté (offerte par C#) me semble donc nécessaire.

La question que je me pose est donc : en C#, y'a t'il moyen de définir une propriété en read only (dans une interface et même dans un simple héritage de classe abstraite ou non) en interdisant de rajouter un setter par surcharge ?

Si oui, alors vive C#, si non, alors chacune des solutions me semble bonne (mais pas parfaite), selon l'utilisation voulue.

[SirJulio]

Salut,

si tu maintiens l'utilisation de la classe par interface, tu ne pourras pas rajouter un setter à une propriété en read-only :

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
    class Program
    {
        static void Main(string[] args)
        {
            ITruc truc = new TrucImpl();
            string str = truc.Truc;
            truc.Truc = "Coucou"; //Compile error 
        }
    }
 
    sealed class TrucImpl : ITruc
    {
 
        #region ITruc Members
 
        public string Truc
        {
            get { return "coucou"; }
            set { }
        }
        #endregion
    }
 
 
    interface ITruc
    {
        string Truc { get; }
    }

pour eviter le cast depuis l'interface vers l'implementation, il te suffit de la dissimuler, par exemple comme ceci :

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
    class Program
    {
        static void Main(string[] args)
        {
            ITruc truc = TrucFactory.Get();
            string str = truc.Truc;
        }
    }
 
 
    sealed class TrucFactory
    {
        public static ITruc Get()
        {
            return new TrucImpl();
        }
 
        private sealed class TrucImpl : ITruc
        {
 
            #region ITruc Members
 
            public string Truc
            {
                get { return "coucou"; }
            }
            #endregion
        }
    }

Bref, tu peux implementer une interface read-only avec un setter, mais le setter ne fera pas parti du contrat donc ca ne pose pas vraiment de probleme.

[Nikoui]

C'est vrai qu'en y réfléchissant bien, une interface est là pour contractualiser ce qui doit être présent et pas pour interdire des choses.

Donc au final, la version C# me semble aussi la plus logique

[anthyme]

La question que je me pose est donc : en C#, y'a t'il moyen de définir une propriété en read only (dans une interface et même dans un simple héritage de classe abstraite ou non) en interdisant de rajouter un setter par surcharge ?

Si oui, alors vive C#, si non, alors chacune des solutions me semble bonne (mais pas parfaite), selon l'utilisation voulue.

Pour rajouter a ce que disait SirJulio :
Bin non car tu manipule les contrat et plas les classe sinon l'interface ne sert a rien.

Un cas pratique (poc) sur des business objects :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
interface UIObject 
{
Value {get;}
}
 
interface DataObject 
{
Value {get;set;}
}
 
class BusinessObject : UIObject, DataObject {
override Value {get;set;}
}

Voila t'as des objets readonly sur la couche UI et en écriture coté Data.

comment tu fais en vb.net ?