Discussion :

[drakon1991]

Bonjour à tous, je me permet de poster ici car je suis débutant et aurait une question quant à la meilleur pratique à adopter pour ce type de comportement.
Je possède deux classes Error et Information (que je n'ai pas implémenté, mais plus ou moins le même code que Error).
Ces deux classes possèdent des propriétés ainsi que des méthodes communes, mais aussi d'autres spécifiques. Plus tard dans le code les objets qui leur correspondent seront ajoutés à une liste contenant le type de base de ces deux classes.
Je voudrais donc savoir si la meilleure solution pour leur faire partager cela était de les faire hériter d'une interface, ou bien plutôt d'une classe abstraite (ou autre ?) ? Merci d'avance

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
public interface Interaction
{
    int Code { get; set; }
    string Message { get; set; }
    /* many others properties */
    void DoSomething();
}
 
public class Error : Interaction
{
    public int Code { get; set; }
    public string Message { get; set; }
    public Error() { /* initialize properties */ }
    public void DoSomething(){ /* implementation */ }
}

ou bien :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public abstract class Interaction
{
    int Code { get; set; }
    string Message { get; set; }
    public Interaction(int Code, string Message) { /* initialize properties */ }
    /* many others properties */
    public abstract void DoSomething();
}
 
public class Error : Interaction
{
    public Error(int Code, string Message) : base(Code, Message) {  }
    public override void DoSomething(){ /* implementation */ }
}

[Jean-Philippe André]

SAlut;

il y a un item à ce sujet chez MS :
https://msdn.microsoft.com/fr-fr/lib...(v=vs.71).aspx (en anglais uniquement)

If you anticipate creating multiple versions of your component, create an abstract class. Abstract classes provide a simple and easy way to version your components. By updating the base class, all inheriting classes are automatically updated with the change. Interfaces, on the other hand, cannot be changed once created. If a new version of an interface is required, you must create a whole new interface.

If the functionality you are creating will be useful across a wide range of disparate objects, use an interface. Abstract classes should be used primarily for objects that are closely related, whereas interfaces are best suited for providing common functionality to unrelated classes.

If you are designing small, concise bits of functionality, use interfaces. If you are designing large functional units, use an abstract class.

If you want to provide common, implemented functionality among all implementations of your component, use an abstract class. Abstract classes allow you to partially implement your class, whereas interfaces contain no implementation for any members.

ce qu'on peut synthétiser en

Si plusieurs versions de votre composant=>classe abstraite.

Si les fonctionnalités seront utiles dans une large gamme d'objets disparates, =>interface.

Si éléments de fonctionnalité petits et concis => interface. Si grandes unités fonctionnelles, =>classe abstraite.

Si fonctionnalités communes et mises en œuvre parmi toutes les implémentations de votre composant, => classe abstraite.

[drakon1991]

Merci beaucoup Jean-phillipe André, votre réponse fut concise et m'a beaucoup informé.
Je n'avais pas vu cette documentation, mais en la suivant je pense donc me tourner vers la classe abstraite pour adapter mon problème.
En effet ce sont de grandes parties des classes qui sont partagées et non juste des petites fonctionnalités.

[François DORIN]

Bonjour,

A avoir aussi à l'esprit les aspects suivants :

• Une classe ne peut hériter que d'une seule classe ;
• Une classe peut implémenter autant d'interface que nécessaire.

Ensuite, une classe abstraite peut définir et implémenter des méthodes, alors qu'une interface ne peut que les définir.