En C #, une classe peut-elle hériter d'une autre classe et d'une interface?

Je veux savoir si une classe peut hériter d'une classe et d'une interface. L'exemple de code ci-dessous ne fonctionne pas mais je pense qu'il exprime ce que je veux faire. La raison pour laquelle je veux faire cela est que dans mon entreprise, nous fabriquons des périphériques USB, série, Ethernet, etc. J'essaie de développer un composant / une interface générique que je peux utiliser pour écrire des programmes pour tous nos appareils qui aideront à garder les choses courantes (comme la connexion, la déconnexion, l'obtention du micrologiciel) les mêmes pour toutes nos applications.

Pour ajouter à cette question: Si GenericDevice est dans un projet différent, puis-je mettre l'interface IOurDevices dans ce projet, puis faire en sorte que la classe USBDevice implémente l'interface si j'ajoute une référence au premier projet? Parce que je voudrais simplement référencer un projet, puis implémenter différentes interfaces en fonction de l'appareil.

class GenericDevice
{
   private string _connectionState;
   public connectionState
   {
      get{return _connectionState; }
      set{ _connectionState = value;}
   }
}

interface IOurDevices
{
   void connectToDevice();
   void DisconnectDevice();
   void GetFirmwareVersion();
}

class USBDevice : IOurDevices : GenericDevice
{
   //here I would define the methods in the interface
   //like this...
   void connectToDevice()
   {
       connectionState = "connected";
   }
}

//so that in my main program I can do this...

class myProgram
{
   main()
   {
      USBDevice myUSB = new USBDevice();
      myUSB.ConnectToDevice;
   }
}

Oui. Essayer:

class USBDevice : GenericDevice, IOurDevice

Remarque: la classe de base doit précéder la liste des noms d'interface.

Bien sûr, vous devrez toujours implémenter tous les membres définis par les interfaces. Toutefois, si la classe de base contient un membre qui correspond à un membre d'interface, le membre de classe de base peut fonctionner comme l'implémentation du membre d'interface et vous n'êtes pas obligé de l'implémenter à nouveau manuellement.

Non, pas exactement. Mais il peut hériter d'une classe et implémenter une ou plusieurs interfaces.

Une terminologie claire est importante pour discuter de concepts comme celui-ci. L'une des choses que vous verrez marquer l'écriture de Jon Skeet, par exemple, à la fois ici et sur papier, est qu'il est toujours précis dans la façon dont il décrit les choses.

Sans rapport avec la question (la réponse de Mehrdad devrait vous faire avancer), et j'espère que cela n'est pas considéré comme un pinailleux: les classes n'héritent pas des interfaces, elles implémentent .

.NET ne prend pas en charge l'héritage multiple, donc garder les termes droits peut aider à la communication. Une classe peut hériter d'une superclasse et implémenter autant d'interfaces qu'elle le souhaite.

En réponse au commentaire d'Eric ... j'ai eu une discussion avec un autre développeur sur la question de savoir si les interfaces "héritent", "implémentent", "exigent" ou "apportent" des interfaces avec une déclaration comme:

public interface ITwo : IOne

La réponse technique est que ITwocela hérite IOnepour plusieurs raisons:

• Les interfaces n'ont jamais d'implémentation, donc en soutenant que ITwo implémente IOne sont complètement faux
• ITwohérite des IOneméthodes, s'il MethodOne()existe surIOne il est également accessible depuis ITwo. ie: ((ITwo)someObject).MethodOne())est valide, même si ITwone contient pas explicitement de définition pourMethodOne()
• ... parce que le runtime le dit! typeof(IOne).IsAssignableFrom(typeof(ITwo))Retourtrue

Nous avons finalement convenu que les interfaces prennent en charge l'héritage vrai / complet. Les fonctionnalités d'héritage manquantes (telles que les remplacements, les accesseurs abstraits / virtuels, etc.) sont absentes des interfaces, pas de l'héritage d'interface. Cela ne rend toujours pas le concept simple ou clair, mais cela aide à comprendre ce qui se passe vraiment sous le capot dans le monde d'Eric :-)

J'ai trouvé la réponse à la deuxième partie de mes questions. Oui, une classe peut implémenter une interface qui est dans une classe différente tant que l'interface est déclarée comme publique.