使用泛型实现显式接口成员

Question

我有一个通用类组的非通用接口。我有一个方法，它使用协方差返回从非泛型类组的抽象实现派生的类中的强类型实例。

因此，基本上通过此设置，我有许多类，例如 ActualThing1 和 ActualThing2。这些类有一个 Clone 方法，该方法返回它们自身的强类型克隆。

下面是我如何构建界面和类。我不确定这是否正确。 通常，我根本不会有非泛型抽象类。但这是必要的，因为在某些情况下我必须对子对象执行某些操作，引用内部方法_SomethingNeededInternally。这不能使用接口来完成，因为它是受保护的，也不能从泛型类内部完成，因为子类可能不是同一类型（它们可能是从接口派生的不同类型）。因此非泛型基类Something。

这可行，但对我来说不太有意义的是我的抽象 Something 类中需要的 ISomething.Clone 的显式实现。它必须在那里，但不应该被实现，因为我希望该实现推迟到从它派生的泛型类。但是没有像abstract ISomething ISomething.Clone()这样的语法。

但是该代码（抛出异常的地方）永远无法执行，不是吗，因为我没有该对象的任何非通用实现？

我想我想知道是否有更好的方法来做到这一点，因为这似乎不对。也就是说，我依赖于这样一个事实：非泛型类永远不会从接口创建，这听起来很有趣。

public interface ISomething
{
    // ...
    ISomething Clone();
}

public abstract class Something: ISomething 
{
    ISomething ISomething.Clone()
    {
        throw new Exception("This should not be happening");
    }
    protected int _SomethingNeededInternally;
}

public abstract class Something<T>: Something, ISomething where T: ISomething, new()
{
    public abstract T Clone();

    ISomething ISomething.Clone()
    {
        return Clone();
    }
}

public interface IActualThing {} // this could be any interface

public class ActualThing: Something<ActualThing>, IActualThing
{
    public override ActualThing Clone() 
    {
        return new ActualThing(); // do cloning here
    }
}

Answer 1

添加所需的方法作为 Clone 的实现对您有用吗？
（我仍然不确定你的整个问题是什么，这只会解决抽象显式接口实现的语法。）

public abstract class Something: ISomething  
{ 
    ISomething ISomething.Clone() 
    { 
        return CloneYouMust();
    } 
    abstract ISomething CloneYouMust();
}

Answer 2

我认为这可能会更好：

public interface ISomething
{
    ISomething Clone();
}

public abstract class Something : ISomething 
{
    protected abstract ISomething CloneInternal();

    ISomething ISomething.Clone()
    {
        return CloneInternal();
    }
}

public abstract class Something<T>: Something, ISomething where T: ISomething, new()
{
    protected override ISomething CloneInternal()
    {
        return Clone();
    }

    public abstract T Clone();
}

public class ActualThing: Something<ActualThing>, IActualThing
{
    public override ActualThing Clone() 
    {
    }
}

Answer 3

您对 abstract ISomething ISomething.Clone 的投诉是有效的，但接口中没有任何内容表明您必须显式声明它们。下面的代码显示了一个工作示例，并删除了对泛型类的要求。

interface Igloo
{
    Igloo Clone();
}

abstract class Alpha : Igloo
{
    public abstract Igloo Clone();
}

class Bravo : Alpha
{
    public override Igloo Clone()
    {
        /* implement */
        return null;
    }
}

Answer 4

首先，我认为 Something中有两个 Clone() 方法。是多余的。既然您已经将 T 限制为 ISomething 和 new()，为什么不这样做：

public abstract class Something<T>: Something, ISomething 
       where T: ISomething, new() 
{     
    public override ISomething Clone()    
    {
        return new T().Clone(); 

        //alternatively may have to use Activator.CreateInstance() here
    }     
} 

其次，我不完全清楚 _SomethingNeededInternally 是否需要是抽象的或虚拟的，但它也没有标记。我的解释是它应该是虚拟的，但也许你需要调整它。无论如何，这是一个对我来说似乎很有效并且最有意义的总体方案。请注意，我能够在抽象类“Something”中使 Clone() 方法抽象：

public interface IActualThing
{
}

public interface ISomething 
{    
    ISomething Clone(); 
}  

public abstract class Something: ISomething  
{
    public abstract ISomething Clone();

    protected virtual void _SomethingNeededInternally()
    {
        throw new NotImplementedException(); 
    }
}  

public abstract class Something<T>: Something, ISomething where T: ISomething, new()
{    
    public override ISomething Clone()    
    {
        return new T().Clone(); 
    } 
}  

public class ActualThing: Something<ActualThing>, IActualThing 
{     
    public override ISomething Clone()      
    {
        throw new NotImplementedException(); 
    }
} 

另请注意，您需要在最终的“ActualThing”类中将返回类型标记为 ISomething。当然，实际上您会返回一个“ActualThing”，但该方法仍然需要符合接口。

Answer 5

我建议您定义并实现接口 ISelf（包含 T 类型的单个 Self 属性）和 ICloneable（派生自 ISelf，具有类型 T 的方法 Clone()）。然后是一个类它实现了 ICloneable可以用返回ItsOwnType的方法来实现它；该方法应该调用一个虚拟的InternalClone方法来完成实际的工作（否则，在基类型的变量上调用Clone可能最终会调用基类型的Clone方法而不是派生的方法）。