Abstract Factory Design Pattern

Abstract Factory Pattern

The Abstract Factory Pattern is a software creational design pattern that provides a way to encapsulate a group of individual factories that have a common theme without specifying the concrete classes. The client does not know (or care) which concrete objects it gets from each of these internal factories, since it uses only the generic interface of their products. This pattern separates the details of implementation of a set of objects from their general usage and relies on object composition, since object creation is implemented in methods exposed in the factory interface.

Abstract-Pattern-1.jpg

AbstractCarFactory: declares an interface for operations that create abstract products

public abstract class AbstractCarFactory
{
   //public CarFeatures();
    public abstract IEnumerable<AbstractVehicleSaleProduct> GetVehicleSale();
    public abstract IEnumerable<AbstractVehicleRentProduct> GetVehicleRent();
}

FordFactory: implements the operations to create concrete product objects relevant to Ford.

    public class FordFactory : AbstractCarFactory
    {
        string name;
        public FordFactory(string modelName)
        {
            name = modelName;
        }
 
        public override IEnumerable<AbstractVehicleSaleProduct> GetVehicleSale()
       
        {
            //Ford has 4x4, car only
            List<AbstractVehicleSaleProduct> myList = new List<AbstractVehicleSaleProduct>();
            myList =(List<AbstractVehicleSaleProduct>) ReturnList();                        return myList;              
        }
        IEnumerable<Object> ReturnList()
        {
            List<Object> myList = new List<Object>();
            AbstractVehicleSaleProduct vehicleProduct = new carRentroduct(name);
            myList.Add(vehicleProduct);
            vehicleProduct = new fourbyfourRentProduct(name);
            myList.Add(vehicleProduct);
            //vehicleProduct = new JeepRentProduct(name);
            //myList.Add(vehicleProduct);
            return myList;
        }
        public override IEnumerable<AbstractVehicleRentProduct> GetVehicleRent()
 
        {
            List<AbstractVehicleRentProduct> myList = new List<AbstractVehicleRentProduct>();
            myList = (List<AbstractVehicleRentProduct>)ReturnList();
             return myList;
       }
    }

NissanFactory: implements the operations to create concrete product objects relevant to Nissan.

    public class NissanFactory : AbstractCarFactory
    {
        string name;
        public NissanFactory(string modelName)
        {
            name = modelName;
        }
        public override IEnumerable<AbstractVehicleSaleProduct> GetVehicleSale()
        {
            //Nissan has  car & jeep only
           // List<AbstractVehicleSaleProduct> myList = new List<AbstractVehicleSaleProduct>();
            List<AbstractVehicleSaleProduct> myList = new List<AbstractVehicleSaleProduct>();
            AbstractVehicleSaleProduct vehicleProduct = new carSaleProduct(name);
            myList.Add(vehicleProduct);
            //vehicleProduct = new fourbyfourRentProduct(name);
            //myList.Add(vehicleProduct);
            vehicleProduct = new JeepRentProduct(name);
            myList.Add(vehicleProduct);
             return myList;
        }     

        public override IEnumerable<AbstractVehicleRentProduct> GetVehicleRent()
        {

            List<AbstractVehicleRentProduct> myList = new List<AbstractVehicleRentProduct>();
            AbstractVehicleRentProduct vehicleProduct = new carRentroduct(name);
            vehicleProduct.VehicleFeatures();
            vehicleProduct.VehicleSpecification();
            myList.Add(vehicleProduct);
            //vehicleProduct = new fourbyfourRentProduct(name);
            //myList.Add(vehicleProduct);
            vehicleProduct = new JeepRentProduct(name);
            myList.Add(vehicleProduct); 
            return myList;
        }
    }

VauxhallFactory: implements the operations to create concrete product objects

relevant to Vauxhall.

    public class VauxhallFactory : AbstractCarFactory
    {
        string name;
        public VauxhallFactory(string modelName)
        {
            name = modelName;

       
        }
        public override IEnumerable<AbstractVehicleSaleProduct> GetVehicleSale()
        {
            //Ford has all items
            List<AbstractVehicleSaleProduct> myList = new List<AbstractVehicleSaleProduct>();
            myList = (List<AbstractVehicleSaleProduct>)ReturnList();
 
            return myList; 
        }

        IEnumerable<Object> ReturnList()
        {
            List<Object> myList = new List<Object>();
            AbstractVehicleSaleProduct vehicleProduct = new carRentroduct(name);
            myList.Add(vehicleProduct);
            vehicleProduct = new fourbyfourRentProduct(name);
            myList.Add(vehicleProduct);
            vehicleProduct = new JeepRentProduct(name);
            myList.Add(vehicleProduct);
            return myList;
        }

        public override IEnumerable<AbstractVehicleRentProduct> GetVehicleRent()
        {

            List<AbstractVehicleRentProduct> myList = new List<AbstractVehicleRentProduct>();
            myList = (List<AbstractVehicleRentProduct>)ReturnList();
             return myList; 
        }
    }

AbstractVehicleRentProduct: declares an interface for a type of product object for VehicleRent

    public abstract class AbstractVehicleRentProduct : AbstractVehicleSaleProduct
    {     
       public abstract RegistrationDetails CarRegistration();
    }

 

AbstractVehicleSaleProduct: declares an interface for a type of product object for VehicleSale

    public abstract class AbstractVehicleSaleProduct
    {
       public  abstract Features VehicleFeatures();
       public  abstract Specification VehicleSpecification(); 

    }

CarRentalProduct: defines a car rental object to be created by the corresponding concrete factory and implements the "AbstractVehicleRent" interface

    public class carRentroduct:AbstractVehicleRentProduct
    {
        string carModel;
        public carRentroduct(string ModelName)
        {
            carModel = ModelName;
        }
 
        public override Features VehicleFeatures()
        {
            Features f = new Features();
            return f;
        }
        public override Specification VehicleSpecification() {

            Specification f = new Specification(carModel);
            return f;
        }

        public override RegistrationDetails CarRegistration()\        {

            RegistrationDetails r = new RegistrationDetails()

            return r;
        }

    }

FourbyFourRentalProduct: defines a 4x4 rental object to be created by the corresponding concrete factory and implements the  "AbstractVehicleRent" interface

    public class fourbyfourRentProduct : AbstractVehicleRentProduct
    {
          string carModel;
          public fourbyfourRentProduct(string ModelName)
        {
            carModel = ModelName;
        }
        public override Features VehicleFeatures()
        {
            //return items using repository pattern
            Features f = new Features();
            return f;        }

        public override RegistrationDetails CarRegistration()
        {
            RegistrationDetails r = new RegistrationDetails();
            return r;
        }
        public override Specification VehicleSpecification()
        {

            //return items using repository pattern
            Specification f = new Specification(carModel);
            return f;
        }
    }

JeepRentalProduct: defines a car rental object to be created by the corresponding concrete factory and implements the  "AbstractVehicleRent" interface

    public class JeepRentProduct : AbstractVehicleRentProduct
    {
          string carModel;
          public JeepRentProduct(string ModelName)
        {
            carModel = ModelName;
        }
        public override Features VehicleFeatures()
        {
            Features f = new Features();
            return f;
        }
        public override Specification VehicleSpecification()
        {
            Specification f = new Specification(carModel);
            return f;
        }
        public override  RegistrationDetails CarRegistration()
        {
            RegistrationDetails r = new RegistrationDetails();
            return r;
        }
    }

CarSaleProduct: defines a car sales object to be created by the corresponding concrete factory and implements the  "AbstractVehicleRent" interface

    public class carSaleProduct:AbstractVehicleSaleProduct
    {
          string carModel;
          Features myfutures = new Features();
 
          public carSaleProduct(string ModelName)
          {
            carModel = ModelName;
        
              myfutures= VehicleFeatures();

            VehicleSpecification();
        }
        public override Features VehicleFeatures()
        {//need to replace by querying using the model name
            List<string> color = new List<string>() { "Red", "Gold", "Silver", "white" };
            IEnumerable<string> colors = color.AsEnumerable();
            Features f = new Features() { DoorNumbers = 4, Color = color, Seats = 5 };
            return f;        }
            public override Specification VehicleSpecification() {
            Specification f = new Specification(carModel) { IsAutomaticAvailable = true, IsDieselAvailable = false, EndPrice=90000, StartingPrice=3000 };
            return f;
        }
    }

FourbyFourSaleProduct: defines a 4x4 sales object to be created by the corresponding concrete factory and implements the "AbstractVehicleRent" interface 

    public class fourbyfourSaleProduct : AbstractVehicleSaleProduct
 
   {

           string carModel;
            public fourbyfourSaleProduct(string ModelName)
        {
            carModel = ModelName;
        }
        public override Features VehicleFeatures()
        {
            Features f = new Features();
            return f;
        }
        public override Specification VehicleSpecification()
        {|            Specification f = new Specification(carModel);      
         return f;

        }    

JeepSaleProduct: defines a Jeep sales object to be created by the corresponding concrete factory and implements the "AbstractVehicleRent" interface

    public class JeepSaleProduct : AbstractVehicleSaleProduct
    {
             string carModel;
        public JeepSaleProduct(string ModelName)
        {
         carModel = ModelName;|       
    }
        public override Features

        ehicleFeatures()
        {
            Features f = new Features();
            return f;
        }

        public override Specification VehicleSpecification()
        {
            Specification f = new Specification(carModel);
            return f;
        }
    }

Client: uses interfaces declared by the "AbstractCarFactory" , "AbstractVehicleRent" and "AbstractVehicleSale" classes

    public class Client
    {
 
        private IEnumerable<AbstractVehicleSaleProduct> AbstractProductA;
        private IEnumerable<AbstractVehicleRentProduct> AbstractProductB;
 
        // Constructor
        public Client(AbstractCarFactory factory)
        {
            AbstractProductB = factory.GetVehicleRent();
            AbstractProductA = factory.GetVehicleSale();
        }

//useful to pass vehicle name to main function

public static class StaticCarModels
{
   public  enum Nissan
    {
        Almera,
        Micro,
        BludBird
    }

   public enum Ford
   {
       Pinto,
       Fiesta,
       Focus
   }

   public enum Vauxhall
   {
       Corsa,
       Belmont,
       Tigra
   }
}

//Main function

private void invokeme()
{
bstractCarFactory Micro = new NissanFactory(StaticCarModels.Nissan.Micro.ToString());
lient
c1 = new Client(Micro);
}

Up Next
    Ebook Download
    View all

    css

    Read by 0 people
    Download Now!
    Learn
    View all