slytek
Messages postés16Date d'inscriptionjeudi 15 mars 2007StatutMembreDernière intervention10 janvier 2009
-
12 déc. 2008 à 09:01
slytek
Messages postés16Date d'inscriptionjeudi 15 mars 2007StatutMembreDernière intervention10 janvier 2009
-
12 déc. 2008 à 14:12
Bonjour a tous
Je suis débutant en Programmation C# .NET et actuellement en auto-formation. J'ai un problème qui m'ennuie énormément, je n'arrive pas à comprendre l'utilité concrète des interfaces (pas graphiques ).
Je sais seulement que l'on définit des méthodes et/ou des propriétés qu'une classe doit ensuite implémenter.
Mais quelle est la réelle utilité ? ça me fait beaucoup penser aux header (.h) en langage C mais j'ai l'impression que ce n'est pas aussi simple...
J'ai déjà cherché des réponses sur des forums mais je ne trouve pas... Je trouve souvent des explications en VB .NET...
En fait la notion d'interface m'a particulièrement embrouillé quand j'ai lu un cours sur les 3 couches : UI, métier et DAO ou ils se servaient des interfaces pour simplifier la maintenance du code. (enfin je crois )
Si quelqu'un peut m'éclaircir..sa sera avec plaisir
billou_13
Messages postés860Date d'inscriptionjeudi 4 mars 2004StatutMembreDernière intervention19 août 201429 12 déc. 2008 à 11:54
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 _actions;
/// <summary>
/// Constructor
/// </summary>
public WorkFlow()
{
_actions = new List();
}
/// <summary>
/// Adds an action to current list
/// </summary>
/// Action implementing <see cref="IAction"/> interface
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
---------------------
--------------------------------------------------------------------
Connaître la réponse est une chose, savoir pourquoi en est une autre
---------------------
slytek
Messages postés16Date d'inscriptionjeudi 15 mars 2007StatutMembreDernière intervention10 janvier 2009 12 déc. 2008 à 09:20
Dans cet exemple :
IImpotMetier metier = new ImpotMetier();
Si IImpotMetier est une Interface, metier est donc du type IImpotMetier.
Est ce que sa veut dire que l'objet métier ne pourra utiliser que les méthodes se trouvant
dans l'interface IImpotMetier et implémentées par la classe ImpotMetier ?
Je ne sais pas si j'ai été clair, mais c'est le genre d'exemple qui me trouble...
Vous n’avez pas trouvé la réponse que vous recherchez ?