Reprise du message précédent :

 
En gros, la question, c'est "est-ce que je vais regarder mon écran à plus de 50cm de distance ?".
Si c'est oui, le 17'' c'est quand même violemment à chier de chez à chier ch'est chûr.

plus un, d'autant que la réponse est on ne peut plus bateau, quoique pragmatique (s'il ne connait pas ça buzz l'éclair, moi je dis ossekoor).

bah t'as du caca dans les yeux, alors!
Cela dit, vu ton pseudo, ça n'a rien d'étronnant.  

[edit] Zyva!! La faute de frappe méga bienvenue!

loule, je pensait que c'était intentionel.
1PQ  

Une simple classe abstraite et un peu d'héritage ça fait rigoureusement la même chose dans ce cas précis.
Et c'est justement là que je ne pige pas "c'est quoi / à quoi ça sert".
 
Bon, en C#, si, la réelle utilité, dans ce cas précis, c'est qu'une classe peut hériter d'une seule classe, mais de multiples interfaces. Du coup il devient particulièrement intéressant de travailler avec des interfaces quand on commence à avoir des besoins complexes niveaux modèle objet.
 
Mais pour de l'héritage "simple", je vois toujours pas la différence avec une bête classe abstraite.

une interface c'est une classe abstraite sans membres ni aucune méthode implémentée.

 
    * Points communs entre interface et classe abstraite
          o tous deux spécifient un comportement (éventuellement abstrait),
          o tous deux permettent d'utiliser le polymorphisme et la liaison dynamique grâce à la compatibilité de type,
          o tous deux peuvent donner lieu à implémentation multiple : une classe abstraite peut avoir plusieurs sous-classes concrètes, une interface peut être implémentée par plusieurs classes.
 
    * Différences entre interface et classe abstraite
          o le comportement d'une interface est purement abstrait, par contre une classe abstraite peut implémenter tout ou partie du comportement, dit autrement : une interface ne permet pas de factoriser l'implémentation alors qu'une classe abstraite peut le faire,
 
          o une classe peut implémenter plusieurs interfaces (chaque interface représente alors un vue différente sur un même objet), par contre une classe hérite exactement d'une super-classe (héritage simple),
 
          o les interfaces permettent de représenter des relations inter-classes indépendantes des relations d'héritage.
 
En résumé, les interfaces ne permettent de factoriser que la spécification d'un comportement, pas son implémentation, alors qu'une classe abstraite permet de factoriser à la fois la spécification et au moins une partie de l'implémentation. Ceci semble faire pencher la balance du côté des classes abstraites. Cependant les interfaces reprennent l'avantage dès qu'on veut organiser des comportements qui ne collent pas avec la hiérarchie de classes. Un exemple frappant est l'interface prédéfinie Runnable qui permet de donner un scénario à un objet qu'on veut rendre actif en lui attachant son propre flot d'exécution (Thread) : grâce à cette interface, toute classe peut proposer un scénario pour ces instances, quelle que soit sa situation dans la hiérarchie des classes.  

ça définit ce que ta classe doit faire, mais la laisse libre de le faire comme elle le souhaite, quoi.

de memoire :  
une classe abstraite contient des prototypes de methode et des methodes implementée  
 
une interface ne contient que les prototypes des methodes

 
http://www2.lifl.fr/~bogaert/clfc/ [...] ode40.html

 
 
Ca augmente mon score au char average

ben non

+1 pour le coup, parce que c'est un genre de question qui intéresse, le plus souvent.

 
Oui
 
Et perso j'abuse aussi des interface, ça OBLIGE les gens avec qui je travaille d'homogeneiser leur code (l'implémentation d'une méthodes lors d'un héritage d'interface étant obligatoire)

ben quoi ? personnellement j'ai jamais été fan des réponses du genre "une interface est un contrat que la classe qui l'implémente doit respecter, et patati et patata...", ça ne sert qu'à embrouiller encore plus et ça ne répond pas à la vraie question : à quoi ça sert ?
ma réponse a le mérite d'exposer un cas concret d'utilisation des interfaces, sans le verbiage qui va avec

voila !
c'est clair que c'est plus intéressant de répondre à ce genre de questions qu'à des questions du genre "pourquoi mon programme Java me renvoie un NoClassDefFoundError", etc...

Ne connaissant pas C# (faudrait que je m'y remette et dépasse les trois premiers tutoriaux un jour...), la réponse d'Harko m'a intéressé.

 
Ben t'as surtout pas le choix, si tu veux pouvoir bosser tranquille, quoi.
 
 

 
C'est ce que je dis , les interface sont une benediction

j'ai pas posé de question hein
 
et depuis 2001, année à laquelle cette cat à vu le jour à force que je m'égosie dans blabla pour l'avoir, j'ai jamais acheté un bouquin, et un "rtfm" à mon attention, c'est comme pisser dans un violoncelle. y'a que les noobs pour pas le savoir

tu veux dire que c'est un truc avec rien dedans ?

d'accord
 
avec toutes ces explication, je pense avoir pigé le truc alors
 
en fait, les interfaces, ça permet de faire exactement ce que je fais habituellement avec une classe abstraite, puisque je colle jamais de code dedans
 
en fait, si je comprends bien, une interface, ça fa faire un truc du genre :
 

 
Alors qu'une classe abstraite permet (mais je ne l'utilise habituellement pas)

 
Ok
 
Et du coup, j'imagine que quand on override une méthode d'interface, on ne peux pas appeler l'objet interne "base".
 
 
 

 
Ouais, enfin, c'est pas ça qui m'étonnais.
C'est que si un n00b avait posté ton message, Harko n'aurait pas fait sa petite explication de texte, lui permettant au passage dese pogner devant tout le monde avec son plugin tout pourrÿ
 
 

J'pense que si, c'est déjà arrivé qu'un newb se pointe avec une question intéressante. C'est rare mais suffisament remarquable pour que je m'en souvienne.

Caramba, encore raté!

 
Tu n'as pas d'attribut dans une interface. Simplement des méthodes.

m'en fout, depuis que je sais lire depuis la CG du streaming WMV en une seule ligne de code C#, les plugins winamp tout pourri de harko...

j'ai édité entre temps d'abors
ah ok, pas d'attribut. ok
 
donc, pas d'attributs... et pas de propriété non plus j'imagine.

À créer des types abstraits en pis-aller du manque de mixins et MI

Ah
 
Bon ben ok, désolé alors

Au pif je dirais "quand on a besoin d'une implémentation partielle commune" histoire de pas dupliquer le code d'une classe à l'autre (pattern Factory par exemple, si je me plante pas. La full factory, pas Factory Method).
 
Après, vu que les interfaces ne sont rien de plus que des classes pûrement abstraites (classes abstraites dont toutes les méthodes sont abstraites) et qu'on utilise justement des classes abstraites pour jouer le même rôle en C++, voila quoi

Bravo, tu viens de gagner un point Flamby (je rappelle que les interfaces ont fonctionnellement été inventée en et pour Java, afin de combler le manque de MI)

Non une classe abstraite peut contenir des méthodes implémentées, elle n'y est pas obligée (classe pûrement abstraite)
 
Et accessoirement je me rappelle d'un très long thread sur le sujet il y a très longtemps (enfin c'était surtout sur l"intérêt d'utiliser des interfaces plutôt que des types concrets), si quelqu'un veut le retrouver j'avais fait un post parlant de boites et de manettes que les gens avaient, si je me souviens bien, fort apprécié

Non, les interfaces sont un remplacement un peu moisi pour un truc retiré/manquant de java (MI, mixins, typeclasses, ...)

Oui, où est le problème

Tu imagines mal, les interfaces C# spécifient aussi les propriétés (ce qui n'empêche pas les propriétés C# d'être à chier )

 
si, des propriétés
 

précision importante
 
 
 

A mon tour de poser la question con du jour : je vois pas bien la distinction que tu fais entre attribut et propriété, à part le a, le p, le u, le o, le b et le é.

(je précise que je parle de Java, hein.)

c'est pour ça qu'habituellement j'utilise des classes abstraites, qui ont le mérite de porter un nom en rapport avec leur utilité
et vu que j'ai jamais eu de réel besoin de faire de l'héritage multiple, j'ai jamais été obligé d'utiliser d'interface.
et à première vue, vu que le nom ne contient ni "abstract", ni "class", que dans VS l'icône associée n'a rien à voir avec celle d'une classe dans l'intellisene, je pensais que c'était complètement différent d'une classe abstraite. en fait, c'est une bête classe, avec des restrictions particulières afin de déjouer les limitations ud compilo si j'ai bien compris

De toute manière il faut être sacrément tordu pour faire de l'heritage multiple de classe

voici mon interface IPlayerWatcher :
 

using System;
 
namespace Plugin
{
    public interface IPlayerWatcher
    {
        void Start(); // démarre la surveillance
        void Stop(); // stoppe la surveillance
        event SongChangedEventHandler SongChanged; // évenement déclenché quand le morceau change
        event PlayerStoppedEventHandler PlayerStopped; // évenement déclenché quand le player est arrêté
        bool Started { get; set; } // property indiquant si la surveillance est démarrée ou non
    }
}

 
puis le WinampWatcher, qui surveille Winamp et qui implémente cette interface :

namespace Plugin
{
    public delegate void PEWindowSongChangedEventHandler(Object source, EventArgs e);
    public delegate void WAWindowSongStoppedEventHandler(Object source, EventArgs e);
 
    public class WinampWatcher : IPlayerWatcher
    {
        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
        unsafe struct extendedFileInfoStruct
        {
            public sbyte* filename;
            public byte* metadata;
            public sbyte* ret;
            public int retlen;
        }
 
        // P/Invoke
        [DllImport("user32.dll", EntryPoint = "SendMessageW" )]
        static unsafe extern int SendMessage(
            IntPtr hWnd,
            int msg,
            int wParam,
            int lParam);
                
        // constantes du SDK de Winamp
        const int WM_WA_IPC = 0x400;
        const int IPC_GETWND_PE = 1;
        const int IPC_ISPLAYING = 104;
        const int IPC_GETLISTPOS = 125;
        const int IPC_GETPLAYLISTFILE = 211;
        const int IPC_GETPLAYLISTTITLE = 212;
        const int IPC_GETWND = 260;
        const int IPC_GET_EXTENDED_FILE_INFO = 290;
        
        StringCollection attributes;
        NameValueCollection atts;
        IntPtr pluginWindow;
        PEWindow PlayListWindow;
        WAWindow WinampWindow;
 
        bool WatcherStarted;
        string PreviousTitle;
 
        public event SongChangedEventHandler SongChanged; // évenement déclenché si le morceau en cours de lecture a changé
        public event PlayerStoppedEventHandler PlayerStopped; // déclenché si le player est arrété
 
        public bool Started
        {
            get { return WatcherStarted; }
            set { WatcherStarted = value; }
        }
 
        public WinampWatcher(IntPtr winampHWnd)
        {
            IntPtr PEhwnd = (IntPtr)SendMessage(winampHWnd, WM_WA_IPC, IPC_GETWND_PE, IPC_GETWND);
            if (PEhwnd == IntPtr.Zero)
                return;
            else
            {
                pluginWindow = winampHWnd;
                PlayListWindow = new PEWindow(PEhwnd);
                WinampWindow = new WAWindow(winampHWnd);
                attributes = new StringCollection();
                string[] arrAttrs = { "TITLE", "ARTIST", "YEAR", "TRACK", "ALBUM" };
                attributes.AddRange(arrAttrs);
                PlayListWindow.PEWindowSongChanged += new PEWindowSongChangedEventHandler(PlayListWindow_PEWindowSongChanged);
                WinampWindow.WAWindowSongStopped += new WAWindowSongStoppedEventHandler(WinampWindow_WAWindowSongStopped);
            }
        }
 
        public void Start()
        {
            WatcherStarted = true;
            PlayListWindow.Subclassed = true;
            WinampWindow.Subclassed = true;
        }
 
        public void Stop()
        {
            PreviousTitle = null;
            PlayListWindow.Subclassed = false;
            WinampWindow.Subclassed = false;
            WatcherStarted = false;
            EventArgs args = new EventArgs();
            if (PlayerStopped != null)
                PlayerStopped(this, args);
        }
 
        private void GetTitleTags()
        {
            extendedFileInfoStruct efi;
            int pos = SendMessage(pluginWindow, WM_WA_IPC, 0, IPC_GETLISTPOS);
            unsafe
            {
                sbyte* title = (sbyte*)SendMessage(pluginWindow, WM_WA_IPC, pos, IPC_GETPLAYLISTTITLE);
                if (title == null)
                    return;
                string CurrentTitle = new string(title);
 
                if (!(CurrentTitle.Equals(PreviousTitle)))
                {
                    PreviousTitle = CurrentTitle;
                    sbyte* fileName = (sbyte*)SendMessage(pluginWindow, WM_WA_IPC, pos, IPC_GETPLAYLISTFILE);
                    string CurrentFile = new string(fileName);
                
                    efi.filename = fileName;
                    efi.retlen = 255;
                    atts = getID3Attributes(&efi);
 
#if DEBUG
                    Utils.Log("CurrentFile : " + CurrentFile);
                    Utils.Log("CurrentTitle : " + CurrentTitle);
#endif
                    SongChangedEventArgs e = new SongChangedEventArgs(atts, CurrentTitle, CurrentFile);
#if DEBUG
                    Utils.Log("Changement de titre" );
#endif
                    if (SongChanged != null)
                        SongChanged(this, e);
 
                }
                CurrentTitle = null;
            }
        }
 
        private unsafe NameValueCollection getID3Attributes(extendedFileInfoStruct* efi)
        {
            NameValueCollection coll = new NameValueCollection();
            StringEnumerator attrsEnumerator = attributes.GetEnumerator();
            sbyte* retBuffer = (sbyte*)Marshal.AllocHGlobal(256).ToPointer();
 
            while (attrsEnumerator.MoveNext())
            {
                byte[] tmpMeta = Encoding.ASCII.GetBytes(attrsEnumerator.Current.ToCharArray());
                efi->ret = retBuffer;
                fixed (byte* metadata = &tmpMeta[0])
                    efi->metadata = metadata;
                SendMessage(pluginWindow, WM_WA_IPC, new IntPtr(efi).ToInt32(), IPC_GET_EXTENDED_FILE_INFO);
                string strAttr = new String(retBuffer);
                coll.Add(attrsEnumerator.Current, strAttr);
            }
 
            Marshal.FreeHGlobal((IntPtr)retBuffer);
            return coll;
        }
 
        void WinampWindow_WAWindowSongStopped(object source, EventArgs e)
        {
            PreviousTitle = null;
            EventArgs args = new EventArgs();
            if (PlayerStopped != null)
                PlayerStopped(this, args);
        }
 
        void PlayListWindow_PEWindowSongChanged(object source, EventArgs e)
        {
            GetTitleTags();
        }
    }
}

tu peux constater que j'y ai implémenté tous les events, méthodes et properties que j'ai déclaré dans l'interface.
 
et enfin, une partie du "noyau" du plugin :

namespace Plugin
{
    public delegate void SongChangedEventHandler(Object source, SongChangedEventArgs e);
    public delegate void PlayerStoppedEventHandler(Object source, EventArgs e);
    public delegate void ConfigChangedEventHandler(Object source, EventArgs e);
 
    /// <summary>
    /// Description résumée de mainApp.
    /// </summary>
    public class MainApp : IDisposable
    {
        PluginPrefs Prefs;
        WebClient ClientWeb;
        WebProxy Proxy;
        NetworkCredential Credentials;
        IPlayerWatcher watcher; // ici, je déclare mon watcher de type IPlayerWatcher, et non de type WinampWatcher
(...)
        // souscription aux évenements déclenchés par le watcher
        watcher = new WinampWatcher(pluginHwnd);
        watcher.SongChanged += new SongChangedEventHandler(watcher_SongChanged);
        watcher.PlayerStopped += new PlayerStoppedEventHandler(watcher_PlayerStopped);
(...)
        // le handler qui est appelé quand le morceau change
        private void watcher_SongChanged(Object sender, SongChangedEventArgs e)
        {
            CurrentID3Atts = e.ID3Attributes;
            if (Prefs.PluginActif) {
                if (AttributesAreHere(CurrentID3Atts))
                    PostToForum(CreateSignature(Prefs.PatternLecture, CurrentID3Atts));
                else
                    PostToForum(CreateSignature(Prefs.PatternLecture, e.SongTitle));
            }
        }
(...)

 
tu vois ? pas une seule fois je n'appelle les méthodes de WinampWatcher, je me contente juste d'appeler celles de l'interface. si un jour je veux gérer ITunes, je n'aurai que cette ligne à modifier :

watcher = new WinampWatcher(pluginHwnd);

en

watcher = new ITunesWatcher(pluginHwnd);

 
au niveau maintenance, les interfaces c'est le top

J'ai tout retrouvé  \o/
 
Le thread dont je parlais est http://forum.hardware.fr/hfr/Progr [...] 4116_1.htm
 
Et mon SuperPost (C) (TM) est http://forum.hardware.fr/hfr/Progr [...] m#t1296679

ben si
quand la question est intéressante, je réponds... quand la question est chiante, je RTFMise

en java, je sais pas. à mon avis, c'est pareil qu'en C#.
 
en parlant de C#, un attribut, c'est une "variable" dans ton objet, qui a une portée public, private ou autre.
un propriété, c'est un mic mac entre une variable et une méthode. c'est à dire qu'elle s'appelle comme un attribut, mais contient du code.
exemple :
 

 
Ensuite, à l'appel :
 

en C# si, tu peux avoir de tout : méthodes, attributs, events...

c'te bordel

putain mais uppez un topic dédié bourdel. Vouz defeatez le purpose des topics merde ;'(