simulating multiple inheritance in C#

Question

so i saw this example from stackoverflow to implement multiple inheritance by using interfaces.

interface ILARGESimulator
{
}

interface IUDPClient
{
}

class UDPClient : IUDPClient
{
}

class LargeSimulator : ILARGESimulator
{
}

class RemoteLargeSimulatorClient : IUDPClient, ILargeSimulator
{
    private IUDPClient client = new UDPClient();
    private ILARGESimulator simulator = new LARGESimulator();

}

The guy said "Unfortunately you will need to write wrapper methods to the members. Multiple inheritance in C# does not exist. You can however implement multiple interfaces."

Why do we inherit from both interfaces anyway?

class RemoteLargeSimulatorClient : IUDPClient, ILargeSimulator

If you are having a has-a relationship and calling the base objects on the derived class, why do even have to write :IUDP, ILargeSimulator? wouldn't it be simply

class RemoteLargeSimulatorClient 
{

is good?

I've learned to [prefer composition (encapsulation) and interfaces over inheritence](http://stackoverflow.com/questions/49002/prefer-composition-over-inheritance). — Jonathon Reinhart, Dec 03 '13 at 02:56

score 1 · Answer 1 · answered Dec 03 '13 at 03:43

If you don't base the class on the interfaces then you can't pass it as a IUDPClient or ILargeSimulator to other code. When he said you need to add the implentations manually he was basically suggesting you do this:

interface ILargeSimulator
{
    void Simulator_Method_1();
    void Simulator_Method_2();
}

public class UDPClient : IUDPClient
    {
    public void UDPClient_Method_1() { /* do something here */ }
    public void UDPClient_Method_2() { /* do something here */ }
}

interface IUDPClient
{
    void UDPClient_Method_1();
    void UDPClient_Method_2();
}

public class LargeSimulator : ILargeSimulator
{
    public void Simulator_Method_1() { /* do something here */ }
    public void Simulator_Method_2() { /* do something here */ }
}

public class RemoteLargeSimulatorClient : IUDPClient, ILargeSimulator
{
    private IUDPClient client = new UDPClient();
    private ILargeSimulator large = new LargeSimulator();

    public void Simulator_Method_1() { this.large.Simulator_Method_1(); }
    public void Simulator_Method_2() { this.large.Simulator_Method_2(); }
    public void UDPClient_Method_1() { this.client.UDPClient_Method_1(); }
    public void UDPClient_Method_2() { this.client.UDPClient_Method_2(); }
}

Then you can create an object instance of RemoteLargeSimulatorClient and use it as either a ILargeSimulator or IUDPClient:

static void DoSomethingWithClient(IUDPClient client) { /* etc */ }
static void DoSomethingWithSimulator(ILargeSimulator simulator) { /* etc */ }

static void Main(string[] args)
{
    RemoteLargeSimulatorClient foo = new RemoteLargeSimulatorClient();
    DoSomethingWithClient(foo);
    DoSomethingWithSimulator(foo);
}

Thank you for your answer. The question now becomes: Why do you declare private IUDPClient client = new UDPClient(); private ILargeSimulator large = new LargeSimulator(); why not just private UDPCClient client = new UDPCClient() private LargeSimulator large = new LargeSimulator() public void Simulator_Method_1() { large.Simulator_Method_1();} and so on. — Jack Smother, Dec 03 '13 at 04:19
Because in a real-world application you wouldn't create those objects here, you would either pass IUDPClient and ILargeSimulator variables into the constructor or have a dependency injection framework initialize them for you. That way you can set it up so that UDPClient gets passed into the class in your commercial application but some other class (e.g. UDPDummyClient) gets passed in when you run unit test frameworks to check that your code works. In unit testing the UDPDummyClient class would pretend to be a IUDPClient to your code but wouldn't actually send anything over a real network. — Mark Feldman, Dec 03 '13 at 08:41
Just to clarify, he was trying to demonstrate how multiple-inheritence can be faked (albeit not very well because it's messy and bug-prone) by redirecting calls to implementation objects. He didn't properly demonstrate how they are created in the first place, that's a whole different topic. — Mark Feldman, Dec 03 '13 at 08:43

score 0 · Answer 2 · edited Apr 12 '17 at 07:31

0

Multiple class inheritance does not exist in C#. Otherwise can be inherit from multiple interfaces. Your example is try solve multiple class inheritance.

First you full understand an Interface. Why are interfaces useful

edited Apr 12 '17 at 07:31

Community

1
1

answered Dec 03 '13 at 03:20

ebattulga

10,774
20
78
116

simulating multiple inheritance in C#

2 Answers2