Is it possible to superimpose an interface on an external class in C#?

Question

In order to hide the concrete implementation of a class behind an interface, for example for dependency injection, I find it is useful to extract an interface with the methods and properties I am interested in. Even for generated classes I can usually make a partial class which implements the extracted interface.

But if I want to extract an interface for an external class, e.g. from a .dll, I can't find any way to do this. Is it even possible?

Answer 1

The simplest approach is usually to wrap the class to implement the adapter pattern. So if we start with:

public class NastyExternalClass
{
    public void Foo() { ... }
}

We add:

public interface IFooable
{
    void Foo();
}

public sealed class NastyExternalClassWrapper : IFooable
{
    private readonly NastyExternalClass original;

    public NastyExternalClassWrapper(NastyExternalClass original)
    {
        this.original = original;
    }

    public void Foo()
    {
        original.Foo();
    }
}

It's tedious - although it could be automated, and I wouldn't be surprised if R# or similar tools already supported this - but it generally works.

It becomes more of a problem if multiple objects need to know about each other, and use the original API... or if the original API adds callbacks which then bypass the wrapper etc. In those cases you need to be more inventive or just live with the imperfection :(

Answer 2

It sounds like you want to use the adapter pattern, to allow an implementation of your interface in a type you define which delegates calls to the third party library.