Question

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.