Question

I have an application which we intend to makes use of an external library. This external library is one of many that provides the same (or similar) functionality.

Take a zip library as an example, there are many libraries out there that does basically the same thing, extract and compress zip files.

However, each library will implement their public classes / interface slightly differently from one another, even if the internal compression algorithm is the same e.g

namespace AmazingZipLibrary
{
    public class Archive
    {
        public Zip Add()
        {
          //Create a zip file
        }
    }
}

namespace YetAnotherAmazingZipLibrary
{
    public class Zip
    {
        public object Compress()
        {
          //create a zip file
        }
    }
}

How can one make use of libraries interchangeably without breaking the main application each time we want to swap or use another library? I think the main reason for such requirements is for evaluation and testing purposes. But it’s also possible that a new bad ass zip library comes along that we want to adopt (hypothetically speaking).

What design patterns can help with this situation?

Answer 1

Create your own interface with the required methods.

Implement this interface for each library, wrapping the library functionality with your calls.

interface ICompress
{
  void Create();
}

public class AmazingCompressor : ICompress
{
   public void Create()
   {
      // Call AmazingZipLibrary.Add
   }
}

public class YetAnotherAmazingCompressor : ICompress
{
   public void Create()
   {
      // Call YetAnotherAmazingZipLibrary.Compress
   }
}

In your code, only refer to ICompress.

This is known as the bridge pattern.