Schnittstelle, die einen Objekttyp deklariert

Question

Dies kann eine Frage über das grundlegende Design sein.

Ich möchte eine Operation auf einem Mystery-Objekt durchführen, solange es meine Schnittstelle IMyInterface implementiert. Und ich möchte eine der Methoden, die von der interace definiert eine Instanz des Geheimnisses Objekt zurückzukehren so ...

IMyInterface 
    { 
    object GetInstance(); 
    } 

public class MysteryObject : IMYInterface 
} 
    public object GetInstance() 
    { 
     MysteryObject instance = new MysteryObject(); 
     return instance; 
    } 
} 

aber dies führt zu unnötigen ‚Objekt‘ Typen und den Overhead mit jenen verbunden. C# tötet speziell diesen Overhead mit der Verwendung von generischen Typen. Es wäre ideal, so etwas zu tun:

IMyInterface 
    { 
    T GetInstance<T>(); 
    } 

public class MysteryObject : IMYInterface 
} 
    public MysteryObject GetInstance<MysteryObject>() 
    { 
     MysteryObject instance = new MysteryObject(); 
     return instance; 
    } 
} 

Ich weiß, dass dieses zweite Beispiel nicht funktioniert. Ich weiß, dass die Syntax falsch ist. ..aber ich frage mich, ob es eine bessere Möglichkeit gibt, zu verlangen, dass ein Objekt, das IMyInterface implementiert, eine Instanz seines eigenen Typs zurückgibt.

Meine Beispiele ein wenig seltsam, aber ich denke, die meisten werden das Gefühl verstehen. Seltsamerweise habe ich sehr kleine Beispiele oder Fragen dazu gefunden.

Answer 1

können Sie machen nur den Rückgabetyp IMyInterface:

public interface IMyInterface 
{ 
    IMyInterface GetInstance(); 
} 

public class MysteryObject : IMyInterface 
{ 
    public IMyInterface GetInstance() 
    { 
     MysteryObject instance = new MysteryObject(); 
     return instance; 
    } 
} 

Oder mit Generika:

public interface IMyInterface<T> 
{ 
    T GetInstance(); 
} 

public class MysteryObject : IMyInterface<MysteryObject> 
{ 
    public MysteryObject GetInstance() 
    { 
     MysteryObject instance = new MysteryObject(); 
     return instance; 
    } 
} 

Wenn Sie das generische Argument wollen vom Typ sein IMyInterface Sie Einschränkung wie folgt hinzu:

Aktualisieren

Hier sind einige Beispiele für den Gebrauch, um zu sehen, was der Unterschied zwischen diesen zwei Versionen:

1. Schnittstelle IMyInterface Rückkehr: von der Schnittstelle

   IMyInterface a = new MysteryObject().GetInstance(); // valid 
   MysteryObject b = new MysteryObject().GetInstance();// invalid 
   MysteryObject b = (MysteryObject)new MysteryObject().GetInstance(); // valid 
   

2. Rückkehr der gattungs Argument:

   IMyInterface<MysteryObject> a = new MysteryObject().GetInstance(); //valid 
   MysteryObject b = new MysteryObject().GetInstance(); //valid 
   

Answer 2

Sie fast haben es. Sie müssen die gesamte Schnittstelle generisch machen: