Superamento del principio Open-Closed

Question

Ho un semplice programma che disegna figure geometriche basate su dati del mouse forniti dall'utente. Ho una classe che gestisce il tracciamento del mouse (ottiene la lista con la cronologia dei movimenti del mouse) e una classe astratta chiamata Shape. Da questa classe deraglio alcune forme extra, come Circle, Rectangle, ecc. - e ognuna di esse sovrascrive la funzione Abstract Draw().

Funziona tutto bene, ma il problema si presenta quando voglio che l'utente sia in grado di cambiare manualmente la forma desiderata . Ottengo i dati del mouse e so quale forma dovrei disegnare. Il problema è come fare in modo che il codice "sappia" quale oggetto dovrebbe creare e passare i parametri appropriati per il costruttore al parametro . A questo punto è anche impossibile aggiungere nuovi derivati ​​di forma, che è assolutamente sbagliato.

mi obiously non voglio uscire con un codice simile:

List<Shape> Shapes = new List<Shape>(); 
// somwhere later 

if(CurrentShape == "polyline"){ 
    Shapes.Add(new Polyline(Points)); 
} 
else if (CurrentShape == "rectangle"){ 
    Shapes.Add(new Rectangle(BeginPoint, EndPoint)); 
} 
// and so on. 

Il codice di cui sopra chiaramente vilates Open-Closed Principle. Il problema è che non ho alcuna idea su come superarlo. Il problema principale è che le diverse forme hanno costruttori con parametri diversi, il che rende molto più problematico.

Sono abbastanza sicuro che questo è un problema comune, ma non so come superarlo. Hai un'idea?

Answer 1

Chiede una fabbrica, ma non solo la fabbrica ma la fabbrica con i lavoratori iniettabili.

public class Context { 
    public Point BeginPoint; 
    public Point EndPoint; 
    public List Points; 

    whatever else 
} 

public class ShapeFactory { 

    List<FactoryWorker> workers; 

    public Shape CreateShape(string ShapeName, Context context) 
    { 
     foreach (FactoryWorker worker in workers) 
     if (worker.Accepts(ShapeName)) 
      return worker.CreateShape(context); 
    } 

    public void AddWorker(FactoryWorker worker) { 
     workers.Add(worker); 
    } 
} 

public abstract class FactortWorker { 
    public abstract bool Accepts(string ShapeName); 
    puboic Shape CreateShape(Context context); 
} 

public class PolyLineFactoryWorker : FactoryWorker { 

    public override bool Accepts(string ShapeName) { 
     return ShapeName == "polyline"; 
    } 

    public Shape CreateShape(Context context) { ... } 

} 

In questo modo il codice è aperto per le estensioni: i nuovi operai possono essere creati liberamente e aggiunti alla fabbrica.

Answer 2

Quando è necessario creare oggetti che derivano tutti da una singola classe o implementare la stessa interfaccia, un approccio comune consiste nell'utilizzare uno factory. Nel tuo caso, tuttavia, una fabbrica semplice potrebbe non essere sufficiente, perché la fabbrica stessa deve essere estensibile.

Un modo per implementare è la seguente:

interface IShapeMaker { 
    IShape Make(IList<Point> points); 
} 
class RectMaker : IShapeMaker { 
    public Make(IList<Point> points) { 
     // Check if the points are good to make a rectangle 
     ... 
     if (pointsAreGoodForRectangle) { 
      return new Rectangle(...); 
     } 
     return null; // Cannot make a rectangle 
    } 
} 
class PolylineMaker : IShapeMaker { 
    public Make(IList<Point> points) { 
     // Check if the points are good to make a polyline 
     ... 
     if (pointsAreGoodForPolyline) { 
      return new Polyline(...); 
     } 
     return null; // Cannot make a polyline 
    } 
} 

Con queste Maker classi in mano, si può fare un registro di produttori (un semplice List<IShapeMaker>) passare attraverso i creatori passando loro i punti, e l'arresto quando torni una forma non nulla.

Questo sistema rimane estensibile, perché è possibile aggiungere un paio di NewShape e NewShapeMaker, e "loro collegare" in quadro esistente: una volta NewShapeMaker ottiene nel Registro di sistema, il resto del sistema diventa subito pronto a riconoscere e utilizzare il tuo NewShape.