.net 实现之间的名称空间差异是否可以通用化/抽象化/重构？

下面是该接口的三个实现。实现

1

和实现

2

之间的唯一区别是包含

ItemWrapper

的命名空间。可以使用泛化或其他方法重构吗

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);
    }
}

---

从您的描述中，我了解到在类

SomeNamespace.ItemWrapper

和

OtherNamespace.ItemWrapper

中有静态方法，它们没有实现

IItemProvider

接口。你想把那些静态方法变成实例方法，但你不知道怎么做

如果类

SomeNamespace.ItemWrapper

和

OtherNamespace.ItemWrapper

不是静态的，则可以显式实现

IItemProvider

：

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);
        }
    }
}

如果它们必须保持静态或出于任何原因您无法访问代码，我建议您采用一些功能性方法：

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);
    }
}

在这两种解决方案中，都不需要为每个名称空间创建更多的类，例如

SomeNamespaceProvider

您在第一个位置拥有的类。

这里有一种方法：

abstract class ItemWrapper {
    public abstract object GetItem(Item item);
}

class OtherNamespaceItemWrapper : ItemWrapper {
    public override object GetItem(Item item) {
        return OtherNamespace.ItemWrapper.GetItem(item);
    }
}

class SomeNamespaceItemWrapper : ItemWrapper {
    public override object GetItem(Item item) {
        return SomeNamespace.ItemWrapper.GetItem(item);
    }
}

然后：

class NamespaceProvider，其中T:ItemWrapper，new（）{
私有只读项目包装器；
公共名称空间提供程序（）{
this.itemWrapper=new T（）；
}
公共对象GetItem（项）{
返回此.GetItem（item）；
}
}

以及：

class SomeNamespaceProvider:NamespaceProvider{}
类OtherNamespaceProvider:NamespaceProvider{}

对于每个名称空间，这仍然需要一个包装类，对吗？如果您坚持像现在这样使用静态方法，是的。或者你可以使用反射，但这是肮脏的，气味难闻。是的。您需要为每个命名空间创建从NamespaceProvider继承的包装器。你最终会上很多课。例如，您将需要（名称空间x2）类。在我的oppinion事件中，像SomeNamespaceProvider这样的简单类增加了项目的复杂性。

abstract class ItemWrapper {
    public abstract object GetItem(Item item);
}

class OtherNamespaceItemWrapper : ItemWrapper {
    public override object GetItem(Item item) {
        return OtherNamespace.ItemWrapper.GetItem(item);
    }
}

class SomeNamespaceItemWrapper : ItemWrapper {
    public override object GetItem(Item item) {
        return SomeNamespace.ItemWrapper.GetItem(item);
    }
}

class NamespaceProvider<T> where T : ItemWrapper, new() {
    private readonly ItemWrapper itemWrapper;
    public NamespaceProvider() {
        this.itemWrapper = new T();
    }

    public object GetItem(Item item) {
        return this.GetItem(item);
    }
}

class SomeNamespaceProvider : NamespaceProvider<SomeNamespaceItemWrapper> { }
class OtherNamespaceProvider : NamespaceProvider<OtherNamespaceItemWrapper> { }