Design Pattern - Abstract pattern Factory e Aperto Chiuso Principle

Question

Sono un principiante in modelli di progettazione.

Sto cercando di usare Abstract Factory -. Modello pur mantenendo aperto-chiuso Principle

Plz guardare il seguente codice:

public interface IAbstractFormFactory
    {
        void ShowOSName();        
    }

public class VistaForm : IAbstractFormFactory
    {
        public void ShowOSName()
        {
            Console.WriteLine("Vista");
        }
    }

public class WinXpForm : IAbstractFormFactory
    {
        public void ShowOSName()
        {
            Console.WriteLine("Win XP");
        }
    }

public static class Application
    {
        public static void Run(IAbstractFormFactory factory)
        {
            factory.ShowOSName();
        }
    }

public class Program 
    {
        public static void Main() 
        {
            IAbstractFormFactory form;

            int sys = 0;

            if (sys == 0) 
            {
                form = new WinXpForm();
            } 
            else 
            {
                form = new VistaForm();
            }

            Application.Run(form);

            Console.ReadLine();
        }
    }

può essere un esempio di pattern Abstract Factory?

Se sì, come posso refactoring che incorpora il concetto di Open-Closed Principle?

Answer 1

L'esempio che hai dato non è una fabbrica di astratto. Astratti fabbriche hanno metodi di fabbrica (cioè metodi che creano e restituiscono gli oggetti).

Per quanto riguarda il principio aperto / chiuso, l'Abstract Factory facilita intrinsecamente questo. Il codice è "chiuso" nel senso che non deve essere modificato se si aggiunge un nuovo stabilimento (perché si sta utilizzando l'iniezione di dipendenza), ed è "aperto" in quanto è possibile estendere le funzionalità scrivendo un nuovo stabilimento astratto .

UPDATE: Ecco il codice di esempio nella questione modificato per mostrare una fabbrica di astratto:

public interface IForm
{
    void ShowFormName();
}

public interface IAbstractFormFactory
{
    IForm MakeForm();        
}

public class VistaForm : IForm
{
    public void ShowFormName()
    {
        Console.WriteLine("Vista Form");
    }
}

public class VistaFormFactory : IAbstractFormFactory
{
    public IForm MakeForm()
    {
        return new VistaForm();
    }
}

public class WinXpForm : IForm
{
    public void ShowFormName()
    {
        Console.WriteLine("WinXP Form");
    }
}

public class WinXpFormFactory : IAbstractFormFactory
{
    public IForm MakeForm()
    {
        return new WinXpForm();
    }
}

public static class Application
{
    public static void Run(IAbstractFormFactory factory)
    {
        IForm form = factory.MakeForm();
        form.ShowFormName();
    }
}

public class Program 
{
    public static void Main() 
    {
        IAbstractFormFactory factory;

        int sys = 0;

        if (sys == 0) 
        {
            factory = new WinXpFormFactory();
        } 
        else 
        {
            factory = new VistaFormFactory();
        }

        Application.Run(factory);

        Console.ReadLine();
    }
}

Answer 2

Dei tre modelli di fabbrica unica fabbrica semplice non è secondo principio aperto-chiuso. Metodo Factory e Abstract Factory, se attuato correttamente devono essere chiusi per la modifica e aperto per l'estensione. L'articolo design Patterns di fabbrica e aperto-chiuso Principle (OCP), la 'O' in SOLID pubblicato nel Globinch java Forum- dà una spiegazione più corretta per questo. L'articolo spiega anche come tweak semplice fabbrica di obbedire principio chiuso aperto.

Answer 3

aperto-chiuso Principle significa "Open" per l'estensione "Chiuso" per le modifiche. Facendo affidamento sull'interfaccia e l'iniezione di questo per il metodo Application.Run (), la classe Application risponda a tali principi. È possibile estenderlo, fornendo una nuova implementazione di IAbstractFormFactory, senza dover apportare modifiche.

Answer 4

questo per esempio di implementazione di Abstract Factory (soprattutto vedere la vera codice di esempio mondo).