Question

Below are three implementation of the interface. The only difference between implementation 1 and implementation 2 is the namespace containing the ItemWrapper. Can this be refactored using generalization or something else perhaps?

interface IItemProvider {
    object GetItem(Item item);
}

//1
class SomeNamespaceProvider : IItemProvider {
    object GetItem(Item item) {
        return SomeNamespace.ItemWrapper.GetItem(item);
    }
}

//2
class OtherNamespaceProvider : IItemProvider {
    object GetItem(Item item) {
        return OtherNamespace.ItemWrapper.GetItem(item);
    }
}

//3
class TotallyDifferentProvider : IItemProvider {
    object GetItem(Item item) {
        return DifferentItemRetriever(item);
    }
}

Answer 1

From your description I understand that you have static methods in classes SomeNamespace.ItemWrapper and OtherNamespace.ItemWrapper and they don’t implement IItemProvider interface. You want to turn those static methods to instance methods and you don’t know how to do it.

If classes SomeNamespace.ItemWrapper and OtherNamespace.ItemWrapper aren’t static you could implement IItemProvider explicitly:

namespace SomeNamespace
{
    public class ItemWrapper: IItemProvider
    {
        public static object GetItem(TaskRunProcessor.Test.Item item)
        {
            return null;
        }

        object IItemProvider.GetItem(Item item)
        {
            return ItemWrapper.GetItem(item);
        }
    }
}

If they have to stay static or for any reason you don’t have access to the code I would recommend some functional approach:

public class GenericProvider : IItemProvider
{
    private Func<Item, object> m_Retriever;

    public GenericProvider(Func<Item,object> retriever)
    {
        if (retriever == null) throw new ArgumentNullException("retriever");
        m_Retriever = retriever;
    }
    object GetItem(Item item)
    {
        return m_Retriever(item);
    }
}

Then you sould be able to use `GenericItemProvider’ like that:

public class ItemProvderClient
{
    public void Use()
    {
        IItemProvider provider1 = new GenericProvider(SomeNamespace.ItemWrapper.GetItem);
        IItemProvider provider2 = new GenericProvider(OtherNamespace.ItemWrapper.GetItem);

        provider1.GetItem(null);
        provider2.GetItem(null);
    }
}

In both solution there is no need to create more classes for evey namespace like SomeNamespaceProvider class you had in the firs place.