C# Generika in Schnittstelle, generische Algorithmus schreiben

Question

Ich muss ein Programm erstellen, das mehrere Algorithmen verwendet, um zufällige Labyrinthe zu erstellen. Ich habe die folgende Klasse definiert: (Es ist ein Datentyp, den die Algorithmen verwenden, und T ist der Typ in einer bestimmten Implementierung verwendet, zum Beispiel wenn ich 2D-Matrix zu Labyrinth, T wird ein 2D-Punkt)

class Entry<T> 
{ 
    private T elem; //the data saved in each entry 
    public T Elem 
    { 
     get { return elem; } 
     set { this.elem = value; } 
    } 

    public Entry(T elem) 
    { 
     Elem = elem; 
    } 

    public override int GetHashCode() 
    { 
     return Elem.GetHashCode(); 
    } 
} 

Und die folgenden Schnittstellen:

interface IRandomGeneretableMaze<T> 
{ 
    void SetRandomEntrance(); 
    void SetRandomExit(); 
    List<Entry<T>> GetNextPossibleEntries(Entry<T> entry); 
    void MakePath(Entry<T> entry1, Entry<T> entry2); 
    void RemovePath(Entry<T> entry1, Entry<T> entry2); 
} 

Es definiert ein Verhalten ein zufällig generatble Labyrinth liefern muß.

interface IMaze<T> 
{ 
    Entry<T> GetEntrance(); 
    Entry<T> GetExit(); 
    List<Entry<T>> GetNextMoves(Entry<T> entry); 
} 

Es definiert einige allgemeine Methoden Labyrinthe arbeiten mit. (Die Labyrinthe werden auf verschiedene Weise implementieren)

interface IRandomMazeGenerator<T> 
{ 
    IMaze<T> Generate(Type t); 
} 

Es definiert nur einen Labyrinth-Generator, wird jeder Algorithmus unterschiedlich umgesetzt werden, während t nur die Art von Labyrinth geschaffen werden. (1 für die Matrix-Basisimplementierung, 2 für die graphenbasierte Implementierung usw.) Nehmen wir an, ich habe die folgenden Klassen aus:

class MatrixMaze : IMaze<Point2D>, IRandomGeneratable<Point2D> {...} 
class GraphMaze : IMaze<Node>, IRandomGeneratable<Node> {...} 

Mein Problem ist, wenn ich versuche, das Verfahren zu implementieren erzeugen, Compiler mich fragen Sie nach einem konkreten T, während die Algorithmen sind nicht (und sollte nicht) abhängig von T, und ich möchte nicht denselben Algorithmus schreiben, nur für verschiedene T's. Gibt es eine Möglichkeit, ein einzelnes Stück Code zu schreiben, das unabhängig von T funktioniert?

Answer 1

sollten Sie die API-Labyrinth-Generator leicht ändern, so dass es jede Art von Labyrinth produzieren können:

public interface IRandomMazeGenerator<TMaze,T> where TMaze: IMaze<T>, new(){ 
    TMaze Generate(); 
} 
public class MatrixMaze : IMaze<Point2D>{public MatrixMaze(){..}} 
public class EmptyMazeGenerator<TMaze,T> : IMazeGenerator<TMaze,T> where T: IMaze<T>,new(){ 
    public TMaze Generate(){ 
     return new TMaze(); 
    } 
} 

Alternativ, wenn Sie auf IMaze<T> eine Einschränkung nicht hinzufügen möchten einen Standardkonstruktor haben, ein Pass Func<IMaze<T>> zum Generator - Sie haben dann eine Builder, die mit einem Factory funktioniert (es nachschlagen in der Gang Of Four Patterns)

public interface IRandomMazeGenerator<T>{ 
    IMaze<T> Generate(Func<IMaze<T>factory); 
} 

public class EmptyMazeGenerator<T> : IMazeGenerator<T>{ 
    public IMaze<T> Generate(Func<IMaze<T>factory){ 
     return factory(); 
    } 
}