views:

527

answers:

4

I want to know if a class can inherit from a class and and interface. The example code below doesn't work but I think it conveys what I want to do. Does anyone have any recommendations??? The reason that I want to do this is because at my company we make USB, serial, Ethernet, etc device. I am trying to develop a generic component/interface that I can use to write programs for all our devices that will help keep the common things (like connecting, disconnecting, getting firmware) the same for all of our applications... Any suggestions would be appriciated!

To Add to this question: If GenericDevice is in different project, can I put the IOurDevices interface in that project then then make the USBDevice class implement the interface if I add a reference to the first project?? Because would like to just reference one project and then implement different interfaces depending on what the device is...

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;
   }
}
+15  A: 

Yes. Try:

class USBDevice : GenericDevice, IOurDevice

Note that the base class, if specified, should come before the list of interface names. Of course, you'll still need to implement all the members that the interfaces define. However, if the base class contains a member that matches an interface member, the base class member can work as the implementation of the interface member and you are not required to manually implement it again.

Mehrdad Afshari
Yup this works! Why didn't I think of that!And to the comments below. Thank you for clearing me up on that (Classes don't inherit interfaces, the IMPLEMENT interfaces)
Jordan S
You avoid the need for that explanation in my view if you get the terminology right.
David M
@Jordan, also note that the base class and the list of interfaces being inherited are separated by commas after the initial colon (@Mehrdad's example).
JMD
to expand just a little: if your base class implements the interface then your derived class automatically implements that interface--even without `USBDevice : IOurDevice`. Adding the implementation explicitly does not impact the base class, but it can help put emphasis on the interface.
STW
@David, while you're not wrong, it wasn't terminology that was preventing @Jordan's code from working. It was incorrect syntax.
JMD
Yoooder - If I did that, wouldn't my base class then have to know exactly how a USBDevice works?
Jordan S
@Jordan S: If the base class can be used as the base class for things that don't implement `IOurDevice`, then it shouldn't implement it and the current design is OK. If all `GenericDevice` instances are also `IOurDevice`, you should move the interface implementation to the base class. Depending on the use case, one might be more desirable. Of course, if the base class implements the interface directly, it should provide implementation for all of its members too (or declare them as `abstract`, but that's another story).
Mehrdad Afshari
+7  A: 

No, not exactly. But it can inherit from a class and implement one or more interfaces.

Clear terminology is important when discussing concepts like this. One of the things that you'll see mark out Jon Skeet's writing, for example, both here and in print, is that he is always precise in the way he decribes things.

David M
Or Eric Lippert, whose writing is very accurate.
Mathias
+4  A: 

Unrelated to the question (Mehrdad's answer should get you going), and I hope this isn't taken as nitpicky: classes don't inherit interfaces, they implement them.

.NET does not support multiple-inheritance, so keeping the terms straight can help in communication. A class can inherit from one superclass and can implement as many interfaces as it wishes.


In response to Eric's comment... I had a discussion with another developer about whether or not interfaces "inherit", "implement", "require", or "bring along" interfaces with a declaration like:

public interface ITwo : IOne

The technical answer is that ITwo does inherit IOne for a few reasons:

  • Interfaces never have an implementation, so arguing that ITwo implements IOne is flat wrong
  • ITwo inherits IOne methods, if MethodOne() exists on IOne then it is also accesible from ITwo. i.e: ((ITwo)someObject).MethodOne()) is valid, even though ITwo does not explicitly contain a definition for MethodOne()
  • ...because the runtime says so! typeof(IOne).IsAssignableFrom(typeof(ITwo)) returns true

We finally agreed that interfaces support true/full inheritance. The missing inheritance features (such as overrides, abstract/virtual accessors, etc) are missing from interfaces, not from interface inheritance. It still doesn't make the concept simple or clear, but it helps understand what's really going on under the hood in Eric's world :-)

STW
Though, unfortunately, interfaces *inherit* other interfaces. I find that choice of words unfortunate, but we're stuck with it now. I prefer to think of interfaces as *requiring* other interfaces. That is, when you say "interface IFoo : IBar" that means "an implementor of IFoo is required to also implement IBar".
Eric Lippert
@Eric I agree it's an unclear term and debated it with a colleague a while back. In the end we decided that saying "ITwo inherits IOne". I'll update my answer with a couple small reasons (just because they won't fit clearly in a comment).
STW
Sure; if you define "A inherits from B" as meaning "members of B are all members of A", then interfaces do "inherit" from base interfaces. This is a reasonable definition. But I prefer to think of "inheritance" as being more strictly about not just sharing the abstract, unimplemented members, but rather, being about inheriting *implementations*. Since interfaces have no implementations, I find it somewhat disquieting to think of interfaces as inheriting from anything. It's a subtle and debatable point.
Eric Lippert
Another term I like is "extend". So you could read "interface IFoo : IBar" to mean that IFoo extends IBar's requirements.
jasonh
@Eric totally in agreement about it being a moot point to argue... thinking about whether or not the base class has an implementation would put abstract classes or methods in the same ballpark as interfaces
STW
@Jason to me "extends" is the java keyword for inheritance, although I do like the implied sense that extending something doesn't mean overriding--so it is perhaps a better term for interface inheritance since a subinterface can't override methods in the superinterface (not that overriding a non-implementation would have any effect).
STW
Yeah, I don't want to introduce confusion, but I think the concept communicates the meaning perfectly.
jasonh
@Eric: I always hear the same word inheriting for interfaces at work for C# like "DataList inherits IEnumerable", but I always correct them by saying "DataList implements IEnumerable". Is it not accurate? I thought a class can inherit from only a single class, but can implement multiple interfaces.
Joan Venge
@Joan: you are correct that *classes* implement (and cannot inherit) interfaces. The point Eric makes is that *interfaces* can inherit other interfaces--which can be somewhat hard to digest given that interfaces are only "specifications" rather than implementations.
STW
Thanks Yooder. I got it now.
Joan Venge
+1  A: 

I found the answer to the second part of my questions. Yes, a class can implement an interface that is in a different class as long that the interface is declared as public.

Jordan S