Adding new functions to an interface

Question

Hi,

I need to create overloads for functions on an existing interface without affecting any components that currently implement or make use of the interface (ideally).

I figure I have a couple of options:

Simplified Original interface:

public interface IServerComponent
{
    bool Add(int a, int b);
}

I can add the new overloaded functions to the interface and force every class that implements the interface to implement the new functions.

public interface IServerComponent
{
    bool Add(int a, int b);
    bool Add(int a, int b, int c);
}

Or I can create a new interface that implements the original interface. Then other classes that make use of the original won't need to change and any new classes can implement the new interface...

public interface IServerComponent2 : IServerComponent
{
    bool Add(int a, int b, int c);
}

What is the best practice is this situation? Are there any other options available?

Thanks

Answer 1

If the new methods can be expressed in terms of the old methods, you can use extension methods:

// Original interface
public interface IServerComponent 
{ 
  bool Add(int a, int b, int c); 
} 

// New overload
public static class MyServerMethods
{
  public static bool Add(this IServerComponent component, int a, int b)
  {
    return component.Add(a, b, 0);
  }
}

If the methods can't be expressed like that (i.e., they really need to be implemented by the components themselves), then I'd recommend defining a new interface. This approach has maximum backwards compatibility.

Answer 2

If your IServerComponent interface hasn't shipped yet or is an internal interface that is only implemented by your own classes, and the new interface members make sense for all existing classes implementing the interface, change the existing interface.

Otherwise, create an IServerComponent2 interface that extends IServerComponent. IIRC this is what the Framework Design Guidelines recommend. An example of this can be found in the .NET Framework in form of the X509Certificate2 class.

However, if the new members can be implemented in terms of the original members, you could also use extension methods:

public interface IServerComponent
{
    bool Add(int a, int b);
}

public static class ServerComponentExtensions
{
    public static bool Add(this IServerComponent isc, int a, int b, int c)
    {
        return isc.Add(a, b) && isc.Add(b, c) && isc.Add(c, a);
    }
}

Answer 3

It depends on the context - if there are many classes that implement the original interface, or if its published, then the only practical way is to introduce the new one. On the other hand having only one interface is much cleaner in the long run, so I would say refactor the existing one if you can afford it.

Answer 4

If you don't need or want to change the classes (now or in the future) that already implement the old interface, you should just create a second interface. However, it feels more like a hack, and might give you less intuitive code.

Plus, postponing a refactoring is never a good idea in my experience. So if you suspect you will need to implement the interface later, you might as well just alter the existing one and spare yourself some headache. It definately the cleaner way to do it.

Answer 5

I think maintaining a single interface is easier but the second approach with 2 interface is better because not every class needs to implement bool Add(int a, int b, int c);

Answer 6

I realize your example is contrived but I want to give you a contrived answer that is different from what you are expressing so that maybe you can think about it in a different way. Instead of having your interface method operate on something concrete it might make sense to it instead work on something abstract.

For example

public interface IAddableThings
{
  int a;
  int b;
}

public interface IOtherAddableThings : IAddableThings
{
  int a;
  int b;
}

public interface IServerComponent
{
    bool Add(IAddableThings things);
}

If this really is an Add then I think this makes a lot more sense, but if it is really more like Calculate(), you would then want to move some or all of that methods operation down to the IAddableThings objects.

public interface IAddableThings
{
  int a;
  int b;
  bool CalculateMe();
}