Ereditarietà da interfacce generiche

Question

Non so come risolvere un problema con interfacce generiche.

Interfaccia generica rappresenta fabbrica per gli oggetti:

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

interfaccia rappresenta fabbrica per i computer (Classe computer) specyfing fabbrica generale:

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

Interfaccia generica rappresenta fabbrica speciale per gli oggetti, che sono clonabile (implementa l'interfaccia System.ICloneable):

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

Class rappresenta fabbrica per i computer (Classe computer) e oggetti clonabile:

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

    } 

vengono visualizzati messaggi di errore del compilatore in classe 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'. 

Answer 1

Non sono sicuro se questo è un errore di battitura, ma questo dovrebbe:

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

sono stato veramente

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

Davvero, credo che questo è probabilmente quello che stai cercando di fare:

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

vivo esempio: http://rextester.com/ENLPO67010

Answer 2

Prova questo blocco di questo codice:

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

    } 

Answer 3

immagino la tua definizione di ISpecialFactory<T> non è corretto. Cambiarlo in:

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

È forse non vogliono il tipo T implementare IFactory<T>!