Nachteil der Verwendung von Abstract Factory und welches Muster adressieren es

Question

Ich habe folgende Frage im Interview konfrontiert, für die ich keine Lösung auf Google oder Stack-Überlauf finden konnte. Ich weiß nicht, ob es wirklich eine gültige Frage ist (da mir kein Zusammenhang gegeben wurde. In welchem ​​Zusammenhang sprach er davon) ??

Ich wurde gebeten zu sagen, was ist das bekannte Problem mit dem Abstract Factory-Muster und welche Muster dieses Problem beheben.

So jemand könnte mir helfen, was genau herauszufinden, ist, dass Problem (Secret)

What are disadvantages of Abstract factory design pattern?

ich über diesen Link war, aber konnte nicht herausfinden, welche andere Muster Adresse Nachteile der Abstract Factory .

Answer 1

von „Design Patterns“ von GoF (Art Programmierer Bibel) Zitiert: "neue Arten von Produkten zu unterstützen, ist schwierig abstrakte Fabriken erweitern neue Arten von Produkten zu erzeugen, ist nicht einfach Das ist, weil die Abstrakte Schnittstelle Behebungen.. die Menge der Produkte, die erstellt werden können. die Unterstützung neuer Arten von Produkten erfordert die Fabrik Schnittstelle erstreckt, die die Abstrakte Klasse und alle ihre Unterklassen ändert sich bringt.

Answer 2

einen Blick auf sourcemaking Artikel auf abstrakte Fabrik.

Manchmal sind schöpferische Muster Konkurrenten: Es gibt Fälle, in denen entweder Prototype oder Abstract Factory könnte gewinnbringend verwendet werden. Zu anderen Zeiten sind sie komplementär.

Oft Designs beginnen mit Factory Method (weniger kompliziert, anpassbarer, Subklassen proliferieren) und entwickeln sich in Richtung Abstract Factory, Prototype oder Builder (flexibler, complex) als der Designer entdeckt, wo mehr Flexibilität benötigt wird.

Für den Aufbau eines komplexen Objekts ist Builder die richtige Wahl, die mehr Flexibilität bietet. Vielleicht ist Ihr Interviewer auf der Suche nach dieser Art von Antwort.

Answer 3

Wie @o_weisman sagt; Der Hauptnachteil von AF ist die Erweiterbarkeit, aber wenn es eine Technik gibt, um dieses Problem zu behandeln, wäre dies in einer Entwurfsmusterart (allgemeine wiederverwendbare Lösung für ein häufig auftretendes Problem) standardmäßig Teil von AF. Also ich denke, dass diese Frage ohne Kontext keine gültige Frage ist.

Eine Technik zur Vermeidung von Schnittstellenänderungen und damit zum Brechen des Clients verwendet nur eine Create-Methode zum Erstellen aller Elemente. Aber ich bezweifle, dass dies ein Muster mit einem offiziellen Namen ist.

dh auf C#:

namespace ConsoleApplication1 
{ 
    public enum Appearance 
    { 
    Win, 
    OSX 
    } 
    interface IButton 
    { 
    void Paint(); 
    } 

    interface ITextBox 
    { 
    void Paint(); 
    } 

    interface IGUIFactory 
    { 
    TElement CreateGUIElement<TElement>() where TElement : class; 
    } 

    class GUIFactory 
    { 
    public static IGUIFactory Create(Appearance lookAndFeel) { 

     if (lookAndFeel == Appearance.Win) { return new WinFactory(); } 
     if (lookAndFeel == Appearance.OSX) { return new OSXFactory(); } 
     throw new NotImplementedException(); 
    } 
    } 

    abstract class AGUIFactory : IGUIFactory 
    { 
    public TElement CreateGUIElement<TElement>() where TElement : class 
    { 
     if (typeof(IButton) == typeof(TElement)) { return CreateButton() as TElement; } 
     if (typeof(ITextBox) == typeof(TElement)) { return CreateTextBox() as TElement; } 
     throw new NotImplementedException(); 
    } 

    protected abstract IButton CreateButton(); 
    protected abstract ITextBox CreateTextBox(); 
    } 


    class WinFactory : AGUIFactory 
    { 
    protected override IButton CreateButton() 
    { 
     return new WinButton(); 
    } 

    protected override ITextBox CreateTextBox() 
    { 
     return new WinTextBox(); 
    } 
    } 

    class OSXFactory : AGUIFactory 
    { 
    protected override IButton CreateButton() 
    { 
     return new OSXButton(); 
    } 

    protected override ITextBox CreateTextBox() 
    { 
     return new OSXTextBox(); 
    } 
    } 

    class WinButton : IButton 
    { 
    public void Paint() 
    { 
     Console.WriteLine("Windown button paint"); 
    } 
    } 

    class OSXButton : IButton 
    { 
    public void Paint() 
    { 
     Console.WriteLine("OSX button paint"); 
    } 
    } 

    class WinTextBox : ITextBox 
    { 
    public void Paint() 
    { 
     Console.WriteLine("Windown TextBox paint"); 
    } 
    } 

    class OSXTextBox : ITextBox 
    { 
    public void Paint() 
    { 
     Console.WriteLine("OSX TextBox paint"); 
    } 
    } 


    class Program 
    { 
    static void Main() 
    { 
     IGUIFactory factory; 
     IButton btn; 
     ITextBox txb; 

     factory = GUIFactory.Create(Appearance.Win); //UserSettings.LookAndFeel 
     btn = factory.CreateGUIElement<IButton>(); 
     txb = factory.CreateGUIElement<ITextBox>(); 
     btn.Paint(); 
     txb.Paint(); 

     factory = GUIFactory.Create(Appearance.OSX); 
     btn = factory.CreateGUIElement<IButton>(); 
     txb = factory.CreateGUIElement<ITextBox>(); 
     btn.Paint(); 
     txb.Paint(); 

     Console.ReadLine(); 
    } 
    } 

}