Réponse acceptée !
Bonjour,
Il est vrai que ce n'est pas une notion très facile à appréhender.
Personnellement, je vais essayer de t'expliquer un peu plus avec un exemple:
Imagines que tu implémentes une librairie en .net (dll) qui va exécuter plein d'actions à la suite les unes des autres (un espèce de workflow :) ) mais que tu t'en fous de coder les actions.
Tu veux juste implémenter le système qui va enchaîner les actions les unes après les autres. En gros, on pourra dire que c'est une coquille vide, ton projet ne servira à rien tel que mais si les gens prennent ta librairie et codent des actions alors, elle prendra tout son sens.
Pour ce faire, tu peux alors opter pour une interface du type:
public interface IAction
{
/// <summary>
/// Executes process
/// </summary>
void Do();
}
Comme ça, tu te fous (excusez moi le langage) complet des actions. C'est pas ton boulot, toi tu veux juste les enchaîner.
Et alors, tu auras ta classe (j'ai fait simple, j'ai pas tout coder, on m'en voudras pas):
public class WorkFlow
{
/// <summary>
/// List of actions to execute
/// </summary>
private List<IAction> _actions;
/// <summary>
/// Constructor
/// </summary>
public WorkFlow()
{
_actions = new List<IAction>();
}
/// <summary>
/// Adds an action to current list
/// </summary>
/// <param name="action">Action implementing <see cref="IAction"/> interface</param>
public void Add(IAction action)
{
_actions.Add(action);
}
/// <summary>
/// Executes all actions from list
/// </summary>
public void Execute()
{
foreach (IAction action in _actions)
{
action.Do();
}
}
}
Et voila, ta librairie est prête ! (enfin faudrait coder un peu plus ^^)
Alors, là, un type à qui tu donne ta librairie n'aura plus qu'à créer une classe qui hérite de l'interface IAction pour pouvoir utiliser ton WorkFlow.
Bien entendu, il aura pour obligation (une fois hérité) de coder la fonction Do() [mais pas toi :) ]
Et cela ne l'empêchera aucunement d'hériter d'une autre classe et d'hériter en plus de ton interface. Ceci permet donc de palier aux problèmes de multi-héritage (en détournant un peu le principe) du C#. Car une classe C# ne peut hériter que d'une seule autre classe C#. Par contre, tu peux ajouter autant d'interface que tu veux !
En gros, cela te permet d'avoir un peu de transparence dans tes développements tout en proposant aux gens qui utiliserons ta librairie de pouvoir interagir avec tes classes sans trop de difficulté.
Un bon exemple dans le framework .Net est l'interface ICollection: http://msdn.microsoft.com/fr-fr/library/system.collections.icollection.aspx
C'est très intéressant d'hériter de cette interface de temps en temps :)
Voila, j'espère que ça t'aura au moins expliquer une partie (ou du moins, une utilisation).
Billou_13
Bask En Force
--------------------------------------------------------------------
Connaître la réponse est une chose, savoir pourquoi en est une autre
---------------------