Generische Schnittstellenimplementierung: Generischer Rückgabetyp und generischer Eingabetyp

Question

Ich möchte ein Klassensystem erstellen, um die Daten aus einer bestimmten Datenquelle zu generalisieren und zu veröffentlichen. Ich habe zwei Methoden: GetData und PostData. Beide Methoden sollten eine Art von Eingabe haben, und GetData sollte auch Rückgabetyp haben. Ich habe versucht, generische Schnittstelle zu schreiben und es in „DatabaseSource“ Klasse zu implementieren:

public class QueryParameter 
{ 
    public QueryParameter() 
    { 
     this.Direction = ParameterDirection.Input; 
    } 

    public string Name { get; set; } 
    public object Value { get; set; } 
    public ParameterDirection Direction { get; set; } 
} 

public class InputBase 
{ 
    public InputBase() 
    { 
     ResultMapping = new Dictionary<string, string>(); 
     Parameters = new List<QueryParameter>(); 
    } 
    public Dictionary<string, string> ResultMapping { get; set; } 
    public List<QueryParameter> Parameters { get; set; } 
} 
public class DatabaseInput: InputBase 
    { 
     public string Query { get; set; } 
     public DatabaseCommandType CommandType { get; set; } 
    } 

public interface IDataSource<I> where I: InputBase 
{ 
    IEnumerable<T> GetData<T>(I input); 
    void PostData(I Input); 
} 

Jetzt i-Schnittstelle wie dies umzusetzen versuche:

public class DatabaseDataSource: IDataSource<DatabaseInput> 
{ 
    public IEnumerable<T> GetData<T>(DatabaseInput Input) 
    { 
     //implementation 
    } 

    public void PostData(DatabaseInput Input) 
    { 
     //implementation 
    } 
} 

Aber ich habe ein Problem, wenn ich versuche, Daten zu instanziieren Quelle wie folgt aus:

IDataSource<InputBase> dataSource = new DatabaseDataSource(); 

ich Database nicht, weil dieser Code in einer Art Factory-Methode ist, und ich sollte in der Lage zu instanziiert andere IDataSource Implementierungen verwenden können.

Kurz gesagt, ich möchte Eingabe und Ausgabe als generische Typen haben und Constraint-Eingabe, um konkrete IDataSource-Implementierung zu entsprechen.

Answer 1

Sie können die Where-Einschränkung verwenden, indem Sie auf here klicken, um weitere Informationen zu Constraints zu erhalten.

where T : class //The type argument must be a reference type; this applies also to any class, interface, delegate, or array type. 

where T : <interface name> //The type argument must be or implement the specified interface. Multiple interface constraints can be specified. The constraining interface can also be generic. 

Answer 2

Check out Kovarianz und Kontravarianz. https://msdn.microsoft.com/en-us/library/mt654055.aspx

Answer 3

Wenn ich das richtig zu verstehen (und es ist zwar nicht 100% klar für mich), muss die Datenquelle sowohl den Eingang und die Ausgabe definieren. Wenn Sie dies tun:

public IEnumerable<T> GetData<T>(DatabaseInput Input) 

Dann wird die tatsächliche Umsetzung dieser Methode könnte erheblich variieren je nachdem, was T ist. Sie möchten kein Szenario dieser Methode, bei dem Sie den Typ T untersuchen und Ihren Code entsprechend verzweigen.

Vielleicht, was Sie wollen, ist so etwas wie dieses:

public interface IDataSource<TInput, TOutput> where TInput: InputBase 
{ 
    IEnumerable<TOutput> GetData(TOutput input); 
    void PostData(TInput Input); 
} 

Aber selbst dann haben Sie eine Schnittstelle erhalten haben, die zwei scheinbar nicht miteinander verbundenen Operationen ist zu definieren. (. Es scheint unwahrscheinlich, dass TInput kann sowohl als Abfrage verwendet werden, um Daten abzurufen und als Befehlsdaten zu schreiben/ändern)

Also vielleicht könnte man es brechen weiter unten:

public interface IDataSource<TInput, TOutput> where TInput: InputBase 
{ 
    IEnumerable<TOutput> GetData(TOutput input); 
} 

public interface IDataCommand<TInput> where TInput:InputBase 
{ 
    void PostData(TInput Input); 
} 

es zu instanziieren Sie könnten eine abstrakte Fabrik verwenden:

public interface IDataSourceFactory<TInput, TOutput> 
{ 
    IDataSource<TInput, TOutput> Create(); 
    void Release(IDataSource<TInput, TOutput> created); 
} 

der Grund dafür ist, weil es die Notwendigkeit für Ihre Klasse var dataSource = new [whatever]. anrufen vermeidet Wenn Sie das tun, dann besiegt er etwas den Zweck eine Schnittstelle zu implementieren. Unabhängig davon, welche Schnittstelle Sie implementieren, sobald Sie new explizit aufrufen und einen bestimmten Typ erstellen, ist Ihre Klasse an , Typ, nicht an die Schnittstelle gekoppelt.

Das verschiebt das ursprüngliche Problem. Was ist die Umsetzung der abstrakten Fabrik? Die gute Nachricht ist, dass die Klasse, die von der Fabrik abhängt, sich nicht um die Umsetzung der Fabrik kümmert. Aber du brauchst noch eins.Eine Möglichkeit, dies zu tun, ist die Verwendung eines DI-Containers. Windsor ist hilfreich, da es ein Muster für die Erstellung abstrakter Fabriken bietet. This blog post beschreibt, wie man das genauer macht.