In C#, una classe può ereditare da un'altra classe e un'interfaccia?

Question

Voglio sapere se una classe può ereditare da una classe e un'interfaccia. Il codice di esempio qui sotto non funziona, ma penso che trasmetta ciò che voglio fare. Il motivo per cui voglio farlo è perché nella mia azienda realizziamo dispositivi USB, seriali, Ethernet, ecc. Sto cercando di sviluppare un componente/interfaccia generico che possa essere utilizzato per scrivere programmi per tutti i nostri dispositivi che contribuirà a mantenere le stesse cose comuni (come la connessione, la disconnessione, il recupero del firmware) per tutte le nostre applicazioni.

Per aggiungere a questa domanda: Se GenericDevice si trova in un progetto diverso, posso inserire l'interfaccia IOurDevices in quel progetto, quindi rendere la classe USBDevice implementare l'interfaccia se aggiungo un riferimento al primo progetto? Perché vorrebbe solo fare riferimento a un progetto e quindi implementare interfacce diverse a seconda del dispositivo.

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; 
    } 
} 

Answer 1

Sì. Prova:

class USBDevice : GenericDevice, IOurDevice 

Nota: classe La base dovrebbe venire prima l'elenco dei nomi di interfaccia.

Naturalmente, sarà comunque necessario implementare tutti i membri definiti dalle interfacce. Tuttavia, se la classe base contiene un membro che corrisponde a un membro dell'interfaccia, il membro della classe base può funzionare come implementazione del membro dell'interfaccia e non è necessario implementarlo nuovamente manualmente.

Answer 2

No, non esattamente. Ma può ereditare da una classe e implementare una o più interfacce.

La terminologia chiara è importante quando si discutono concetti come questo. Una delle cose che vedrai segnare la sceneggiatura di Jon Skeet, ad esempio, sia qui che in stampa, è che è sempre preciso nel modo in cui decifra le cose.

Answer 3

estraneo alla domanda (risposta di Mehrdad dovrebbe farti andare), e spero che questo non è preso come nitpicky: classi non erediti interfacce, che implementano loro.

.NET non supporta l'ereditarietà multipla, quindi mantenere i termini può aiutare nella comunicazione. Una classe può ereditare da una superclasse e può implementare tutte le interfacce che desidera.

---

In risposta al commento di Eric ...Ho avuto una discussione con un altro sviluppatore circa o meno interfacce "ereditano", "attuare", "richiede", o "portare" le interfacce con una dichiarazione del tipo:

public interface ITwo : IOne 

La risposta tecnica è che ITwo fa ereditano IOne per alcuni motivi:

• Interfacce mai hanno un'implementazione, in modo sostenendo che ITwoimplementaIOne è FL a torto
• ITwo eredita IOne metodi, se MethodOne() esiste su IOne, allora è anche accessibile da ITwo. vale: ((ITwo)someObject).MethodOne()) è valido, anche se ITwo non contiene esplicitamente una definizione per MethodOne()
• ... perché il runtime lo dice! typeof(IOne).IsAssignableFrom(typeof(ITwo)) rendimenti true

Abbiamo finalmente convenuto che supportano interfacce vera eredità/pieno. Le caratteristiche di ereditarietà mancanti (come override, accessors astratti/virtuali, ecc.) Mancano dalle interfacce, non dall'ereditarietà dell'interfaccia. Ancora non rende il concetto semplice o chiaro, ma aiuta a capire cosa sta veramente succedendo nel mondo di Eric :-)

Answer 4

Ho trovato la risposta alla seconda parte delle mie domande. Sì, una classe può implementare un'interfaccia che si trova in una classe diversa finché l'interfaccia è dichiarata pubblica.