C# 从泛型接口继承

我不知道如何解决通用接口的问题

通用接口表示对象的工厂：

interface IFactory<T>
{
    // get created object
    T Get();    
}

接口IFactory
{
//获取创建对象
T Get（）；
}

接口表示计算机（计算机类）规格的工厂（通用工厂）：

interface IComputerFactory<T> : IFactory<T> where T : Computer
{
    // get created computer
    new Computer Get();
}

接口I计算机工厂：I工厂，其中T:计算机
{
//创建计算机
新计算机Get（）；
}

通用接口表示对象的特殊工厂，这些对象是可克隆的（实现接口系统.ICloneable）：

接口是一个特殊的工厂，其中T:iClonable，IFactory
{
//获取创建对象
T Get（）；
}

类表示计算机（计算机类）和可克隆对象的工厂：

class MyFactory<T> : IComputerFactory<Computer>, ISpecialFactory<T>
{

}

类MyFactory:IComputerFactory、ISpecialFactory
{
}

我在MyFactory类中收到编译器错误消息：

The type 'T' cannot be used as type parameter 'T' in the generic type or method 'exer.ISpecialFactory<T>'. There is no boxing conversion or type parameter conversion from 'T' to 'exer.IFactory<T>'.   

The type 'T' cannot be used as type parameter 'T' in the generic type or method 'exer.ISpecialFactory<T>'. There is no boxing conversion or type parameter conversion from 'T' to 'System.ICloneable'.  

类型“T”不能用作泛型类型或方法“exer.isSpecialFactory”中的类型参数“T”。没有从“T”到“exer.IFactory”的装箱转换或类型参数转换。
类型“T”不能用作泛型类型或方法“exer.isSpecialFactory”中的类型参数“T”。没有从“T”到“System.ICloneable”的装箱转换或类型参数转换。

不确定这是否是打字错误，但应：

interface ISpecialFactory<T>
        where T : ICloneable, IFactory<T>

接口是专业工厂
其中T:iClonable，IFactory

真的

interface ISpecialFactory<T> : IFactory<T>
        where T : ICloneable

接口是专用工厂：IFactory
T:ICloneable在哪里

真的，我想这可能就是你想要做的：

public class Computer : ICloneable
{ 
    public object Clone(){ return new Computer(); }
}

public interface IFactory<T>
{
    T Get();    
}

public interface IComputerFactory : IFactory<Computer>
{
    Computer Get();
}

public interface ISpecialFactory<T>: IFactory<T>
    where T : ICloneable
{
    T Get();
}

public class MyFactory : IComputerFactory, ISpecialFactory<Computer>
{
    public Computer Get()
    {
        return new Computer();
    }
}

公共级计算机：iClonable
{ 
公共对象克隆（）{返回新计算机（）；}
}
公共接口工厂
{
T Get（）；
}
公共接口IComputerFactory:IFactory
{
计算机获取（）；
}
公共接口是专用工厂：IFactory
T:ICloneable在哪里
{
T Get（）；
}
公共类MyFactory:IComputerFactory、ISpecialFactory
{
公共计算机Get（）
{
返回新计算机（）；
}
}

---

实时示例：

尝试以下代码块：

class MyFactory<T> : IComputerFactory<Computer>, ISpecialFactory<T>
    where T: ICloneable, IFactory<T>
    {

    }

类MyFactory:IComputerFactory、ISpecialFactory
其中T:iClonable，IFactory
{
}

我想你对

ISpecialFactory

的定义是不正确的。将其更改为：

interface ISpecialFactory<T> : IFactory<T>
    where T : ICloneable
{
    // get created object
    T Get();
}

接口是专用工厂：IFactory
T:ICloneable在哪里
{
//获取创建对象
T Get（）；
}

---

您可能不希望

t

类型实现

IFactory

谢谢你的回答，但这并不是我想要的。你能不能改变一下，让我的工厂生产所有可克隆的对象，而不仅仅是“计算机”对象？@Matt-对不起，这没有多大意义。如果工厂没有混凝土，它怎么知道如何建造东西？即使是在您最初发布的

MyFactory

中实现的

IComputerFactory

。如果工厂没有具体化，它如何知道如何建造一些东西？我想用泛型。Im my original posts MyFactory实现了IComputerFactory接口和ISpecialFactory接口。这意味着MyFactory不仅能够生成计算机类的实例，而且能够生成所有可克隆类的实例。我认为在myFactory类中使用新方法是可能的，比如public T Get{return new T（）}。我不知道这是否可能…所以你想

MyFactory

既构造

计算机

，又构造任何

可克隆的

？看起来有点奇怪，但好吧，让我再看看我的答案是的，没错。我知道，这很奇怪。我想知道这是否可能。

interface ISpecialFactory<T> : IFactory<T>
    where T : ICloneable
{
    // get created object
    T Get();
}