Refactoring duplicate code when the only difference is the type of one variable?

Question

I have to be able to connect to two different versions of the an API (1.4 and 1.5), lets call it the Foo API. And my code that connects to the API and processes the results is substantially duplicated - the only difference is the data types returned from the two APIs. How can I refactor this to remove duplication?

In Foo14Connector.cs (my own class that calls the 1.4 API)

public class Foo14Connector
{
    public void GetAllCustomers() 
    {
        var _foo = new Foo14WebReference.FooService();
        Foo14WebReference.customerEntity[] customers = _foo.getCustomerList;
        foreach (Foo14WebReference.customerEntity customer in customers)
        {
            GetSingleCustomer(customer);
        }
    }
    public void GetSingleCustomer(Foo14WebReference.customerEntity customer)
    {
        var id = customer.foo_id;
        // etc 
    }
}

And in the almost exact duplicate class Foo15Connector.cs (my own class that calls the 1.5 API)

public class Foo15Connector
{
    public void GetAllCustomers() 
    {
        var _foo = new Foo15WebReference.FooService();
        Foo15WebReference.customerEntity[] customers = _foo.getCustomerList;
        foreach (Foo15WebReference.customerEntity customer in customers)
        {
            GetSingleCustomer(customer);
        }
    }
    public void GetSingleCustomer(Foo15WebReference.customerEntity customer)
    {
        var id = customer.foo_id;
        // etc 
    }
}

Note that I have to have two different connectors because one single method call (out of hundreds) on the API has a new parameter in 1.5.

Both classes Foo14WebReference.customerEntity and Foo15WebReference.customerEntity have identical properties.

Answer 1

If the connectors are in different projects, this is an easy situation to solve:

Add a new class file, call it ConnectorCommon and copy all of the common code, but with the namespaces removed. Make this class a partial class and rename the class (not the file) to something like Connector.

You will need to add a link to this to each project.

Next, remove all of the code from your current connector classes, rename the class (not necessarily the file) to the same as the partial class, and add a using statement that references the namespace.

This should get what you are looking for.

So, when you are done you will have:

File ConnectorCommon:

public partial class Connector
{
    public void GetAllCustomers() 
    {
        var _foo = new FooService();
        customerEntity[] customers = _foo.getCustomerList;
        foreach (customerEntity customer in customers)
        {
            GetSingleCustomer(customer);
        }
    }
    public void GetSingleCustomer(customerEntity customer)
    {
        var id = customer.foo_id;
        // etc 
    }
}

File Magento15Connector

using Foo15WebReference;

partial class Connector
{
}

File Magento14Connector

using Foo14WebReference;

partial class Connector
{
}

Update

This process can be a little confusing at first.

To clarify, you are sharing source code in a common file between two projects.

The actual classes are the specific classes with the namespaces in each project. You use the partial keyword to cause the common file to be combined with the actual project file (i.e. Magneto14) in each project to create the full class within that project at compile time.

The trickiest part is adding the common file to both projects.

To do this, select the Add Existing Item... menu in the second project, navigate to the common file and click the right-arrow next to the Add button.

From the dropdown menu, select Add as link. This will add a reference to the file to the second project. The source code will be included in both projects and any changes to the common file will be automatically available in both projects.

Update 2

I sometimes forget how easy VB makes tasks like this, since that is my ordinary programming environment.

In order to make this work in C#, there is one more trick that has to be employed: Conditional compilation symbols. It makes the start of the common code a little more verbose than I would like, but it still ensures that you can work with a single set of common code.

To employ this trick, add a conditional compilation symbol to each project (ensure that it is set for All Configurations). For example, in the Magento14 project, add Ver14 and in the Magento15 project add Ver15.

Then in the common file, replace the namespace with a structure similar to the following:

#if Ver14
using Magneto14;
namespace Magento14Project

#elif Ver15
using Magneto15;
namespace Magento15Project

#endif

This will ensure that the proper namespace and usings are included based on the project the common code is being compiled into.

Note that all common using statements should be retained in the common file (i.e., enough to get it to compile).

Answer 2

If the FooConnectors are not sealed and you are in control to create new instances, then you can derive your own connectors and implement interfaces at the same time. In c# you can implement members by simply inheriting them from a base class!

public IFooConnector {
    void GetAllCustomers();
}

public MyFoo14Connector : Foo14Connector, IFooConnector
{
    // No need to put any code in here!
}

and then

IFooConnector connector = new MyFoo14Connector();
connector.GetAllCustomers();

Answer 3

You should introduce an interface that is common to both of the implementations. If the projects are written in the same language and are in different projects, you can introduce a common project that both projects reference. You are then making a move towards having dependencies only on your interface which should allow you to swap in different implementations behind the scenes somewhere using inversion of control (google, dependency injection or service locator or factory pattern).

Difficulties for you could be:

1) Public static methods in the implementations are not able to be exposed staticly via an interface 2) Potentially have code in one implementation class ie Foo14Connector or Foo15Connector that doesnt make sense to put into a generic interface