Question

Let’s say you have two different C# classes A and B that while not deriving from the same base class do share some of the same names for methods. For example, both classes have a connect and a disconnect method, as well as several others. I want to be able to write code once that will work with both types.

Here is a simplified example of what I would like to do:

public void make_connection(Object x)
{
  x.connect() ;
  // Do some more stuff...
  x.disconnect() ;
  return ;
}

Of course, this does not compile as the Object class does not have a connect or disconnect method.

Is there a way to do this?

UPDATE. I should have made this clear from the start: I only have the DLLs for A and B and not the source.

Answer 1

You can use an interface to accomplish what you want to do.

interface IConnectable
{
    void Connect();

    void Disconnect();
}

Both A and B should implement IConnectable. Then use IConnectable instead of Object as the parameter type for your method and you should be all set.

public void MakeConnection(IConnectable connectable)
{
    connectable.Connect();

    // Do some more stuff...

    connectable.Disconnect();
}

Edit: Since you don’t have the source code, you have a couple of options:

1. Use Max’s solution of using the dynamic keyword, (if you are using .NET 4.0)
2. Use Steve’s solution of using casting and if/else statements
3. Create wrapper classes for A and B and have them implement the interface (or use common abstract base class for them)

For example:

class AWrapper : IConnectable
{
    private A obj;

    public AWrapper(A obj)
    {
        this.obj = obj;
    }

    public void Connect()
    {
        this.obj.Connect();
    }

    public void Disconnect()
    {
        this.obj.Disconnect();
    }

    // other methods as necessary
}

(BWrapper would be similar, just using B instead of A)

Then you could create the wrappers and pass them into MakeConnection. It’s up to you how you want to do it. Depending on your situation, one method may be easier than the others.