Qual è la differenza tra Bridge e Factory Pattern in C #?

Naviga le tue risposte
2

Qual è la differenza tra Bridge e Factory Pattern? entrambi i pattern sembrano instanitare la classe a seconda della logica dal lato client.

Modello di fabbrica 

interface IFactory {
        void GetProduct();
    }
    class Germany : IFactory {
        public void GetProduct() {
            Console.WriteLine("germany");
        }
    }
    class Russia : IFactory {
        public void GetProduct() {
            Console.WriteLine("Russia");
        }
    }
    class Canada : IFactory {
        public void GetProduct() {
            Console.WriteLine("Canada");
        }
    }
    class Component {
        IFactory factory;
        public Component(IFactory component) {
            this.factory = component;
        }
        public void BuyProduct() {
            factory.GetProduct();
        }
    }
    class Client {
        static void Main() {
            Component component = new Component(new Canada());
            component.BuyProduct();

            Console.Read();
        }
    }

Modello di ponte 

 interface IBridge
    {
        void print();
    }
    class ImplementationA : IBridge
    {
        public void print()
        {
            Console.WriteLine("implementation A");
        }
    }
    class ImplementationB : IBridge
    {
        public void print()
        {
            Console.WriteLine("implementation A");
        }
    }
    class Abstraction
    {
        IBridge bridge;
        public Abstraction(IBridge bridge)
        {
            this.bridge = bridge;
        }
        public void caller()
        {
            bridge.print();
        }
    }
    class Client
    {
        static void Main()
        {
            new Abstraction(new ImplementationA()).caller();
        }
    }

in entrambi i pattern Factory e Bridge possiamo vedere che la classe è istanziata dal client su qualche logica. Non è sia il codice che fa la stessa cosa. In Factory pattern, la logica dei client decide quale classe deve essere istanziata, che è lo stesso caso con Bridge Pattern.

quindi, qual è il cambiamento, per favore aiutami a capirlo

    
posta Lijin Durairaj 15.11.2016 - 21:23
fonte

3 risposte

2

Questo dovrebbe aiutare

Il Bridge Separa l'interfaccia di un oggetto dalla sua implementazione

Il Metodo di fabbrica - Crea un'istanza di diverse classi derivate

    
risposta data 15.11.2016 - 21:30
fonte
3

Un modello di fabbrica (astratto) è un modello creativo. È responsabile della creazione di istanze di altri oggetti.

Il bridge è un modello strutturale. Risolve un problema riguardante la struttura del tuo codice. Bridge è responsabile del disaccoppiamento di un'astrazione da un'implementazione. Bridge consente di avere più implementazioni di un'astrazione senza dover ereditare più classi dalla stessa classe base. Infatti, con Bridge, esistono più gerarchie di classi separate: una gerarchia di classi che rappresenta l'astrazione e una gerarchia di classi che ne rappresenta l'implementazione.

Bridge e Factory possono funzionare insieme però: puoi utilizzare una factory per creare un'istanza dell'implementazione (specifica) per il tuo bridge.

    
risposta data 15.11.2016 - 21:47
fonte
1

Nell'esempio fornito per il modello di fabbrica, la classe di fabbrica e il metodo non sono corretti. Deve decidere quale oggetto sottoclasse da istanziare dipende da qualsiasi condizione fornita dalla classe client durante la chiamata al metodo factory. E la classe client deve avere IFactory factory = null; non in Component nel tuo caso. Hai cambiato solo i nomi dei metodi, entrambi hanno lo stesso aspetto.

Il codice per la classe factory (Component) deve essere come segue: 

class Component {        
        public GetComponent(int flag) {
            IFactory factory=null;
            if(flag==1)
              factory = new Germany();
            else if(flag==2)
              factory=new Russia();
            else
              factory=new Canada();
        }            
    }

class Client {
        static void Main() {
            IFactory factory=null;
            factory= new GetComponent(1);
            factory.GetProduct();

            Console.Read();
        }
    }

Differenza:

Modello di ponte : separa l'astrazione dall'implementazione, quindi entrambe possono essere modificate indipendentemente.

Modello di fabbrica : è un modo di creare oggetti ma lasciare che le sottoclassi decidano quale classe istanziare.

    
risposta data 19.04.2017 - 05:55
fonte

Leggi altre domande sui tag

Esiste un modo non soggettivo per misurare le capacità di programmazione al fine di soddisfare i test di programmazione? La complessità temporale di questa funzione è (n)? Può essere ottimizzato ulteriormente?