/*

Design patterns are all about reusable solutions to common problems in software designing that occur in real-world application development.

​

FACTORY DESIGN PATTERN  :

​

    Factory Method is a creational design pattern that provides an interface for creating objects in a superclass,

     but allows subclasses to alter the type of objects that will be created.

​

​

    Factory Defines Interface for Creating Object

    But,let classes Implement The Interface Decide Which class is To Instantiate 

    Factory Pattern Instantiate to subclass

WHY-->

         At present, most of your code is coupled to the Logistic ByRoad class.

         Adding LogisticByAir into the app would require making changes to the entire codebase. 

         Moreover, if later you decide to add another type of transportation to the app,

         you will probably need to make all of these changes again.

​

WHERE-->        

            clients needs to specify the classname While creating the object 

            To Resolve This.....

​

Product - Logistic

ConcreteProduct- LogisticByRoad, LogisticByWater

Creator- FactoryLogistic

ConcreteCreator- FactoryLogisticByRoad, FactoryLogisticByRoad

​

​

-->Product

                This defines the interface of objects the factory method creates

-->ConcreteProduct

                This is a class which implements the Product interface.

-->Creator

            --  This is an abstract class and declares the factory method, which returns an object of type Product.

                This may also define a default implementation of the factory method that returns a default ConcreteProduct object.

                This may call the factory method to create a Product object.

            --  The Creator class declares the factory method that returns new product objects.

                It’s important that the return type of this method matches the product interface.

                You can declare the factory method as abstract to force all subclasses to implement their own versions of the method. 

                As an alternative, the base factory method can return some default product type.

​

-->ConcreteCreator

                This is a class which implements the Creator class and overrides the factory method to return an instance of a ConcreteProduct.

​

​

​

​

​

 Applicability

         Use the Factory Method when you don’t know beforehand the exact types and dependencies of the objects your code should work with.

​

        Use the Factory Method when you want to provide users of your library or framework with a way to extend its internal components.

        Use the Factory Method when you want to save system resources by reusing existing objects instead of rebuilding them each time.         

​

​

*/              

​

​

using System; 

// PRODUCT--  This defines the interface of objects the factory method creates

abstract class Logistic{

 public abstract String LogisticType{get;}

 public abstract int LogisticRange{get;set;}

 public abstract int LogisticCost{get;set;}

}

​

​

//CONCRETEPRODUCT--this is a class which implements the Product interface.

class LogisticByRoad : Logistic

{

    private readonly String _LogisticType;

    private int _LogisticRange;

    private int _LogisticCost;

    public LogisticByRoad(int LogisticRange,int LogisticCost)

    {

        _LogisticType="road";

        _LogisticRange=LogisticRange;

        _LogisticCost=LogisticCost;

        Console.WriteLine("**** step 3  : object of  LogisticByRoad created and called the Constructor of LogisticByRoad");

    }

    public override String LogisticType

    {

        get 

        {

            return _LogisticType;    

        }

    }

    public override int LogisticRange

    {

        get

        {

            return _LogisticRange;

        }

        set

        {

            _LogisticRange=value;

        }

    }

     public override int LogisticCost

    {

        get

        {

            return _LogisticCost;

        }

        set

        {

            _LogisticCost=value;

        }

    }

}

//CONCRETEPRODUCT--

class LogisticByWater : Logistic

{

    private readonly String _LogisticType;

    private int _LogisticRange;

    private int _LogisticCost;

    public LogisticByWater(int LogisticRange,int LogisticCost)

    {

        _LogisticType="water";

        _LogisticRange=LogisticRange;

        _LogisticCost=LogisticCost;

    }

    public override String LogisticType

    {

        get 

        {

            return _LogisticType;    

        }

    }

    public override int LogisticRange

    {

        get

        {

            return _LogisticRange;

        }

        set

        {

            _LogisticRange=value;

        }

    }

    public override int LogisticCost

    {

        get

        {

            return _LogisticCost;

        }

        set

        {

            _LogisticCost=value;

        }

    }

}

​

//   CREATOR

​

/*

This is an abstract class and declares the factory method, which returns an object of type Product.

​

This may also define a default implementation of the factory method that returns a default ConcreteProduct object.

​

This may call the factory method to create a Product object.

*/

​

​

abstract class LogisticFactory

{

    public abstract  Logistic getLogistic();

}

​

// CONCRETE_CREATOR  --  This is a class which implements the Creator class and overrides the factory method to return an instance of a ConcreteProduct.

 class LogisticByRoadFactory : LogisticFactory

{

    private int _LogisticRange;

    private int _LogisticCost;

    public LogisticByRoadFactory(int LogisticRange,int LogisticCost)

    {

        Console.WriteLine("\n**** step 1  :Constructor of LogisticByRoadFactory called");

        _LogisticRange=LogisticRange;

        _LogisticCost=LogisticCost;

    }

    public override Logistic getLogistic(){

        Console.WriteLine("\n**** step 2  :getLogistic create the object of  LogisticByRoad ");

        return new LogisticByRoad(_LogisticRange,_LogisticCost);

        //this method will create an object of LogiticByRoad 

   }

}

​

// CONCRETE_CREATOR

 class LogisticByWaterFactory : LogisticFactory

{

    private int _LogisticRange;

    private int _LogisticCost;

    public LogisticByWaterFactory(int LogisticRange,int LogisticCost)

    {

        _LogisticRange=LogisticRange;

        _LogisticCost=LogisticCost;

    }

    public override Logistic getLogistic(){

        return new LogisticByWater(_LogisticRange,_LogisticCost);

        //this method will create an object of LogiticByRoad 

    }

}

​

public class Program

{

    public static void Main()

    {

        Console.WriteLine("Hello....");

        Console.WriteLine("\nTypes of Transport \n Road and Water");

        LogisticFactory factory=null;

        Console.Write("\nEnter The Transport Type You Would Like To   :");

        string trans=Console.ReadLine();

        switch(trans.ToLower())

        {  

                case "road":  

                    factory = new LogisticByRoadFactory(2000, 3000);  

                // here we create object of  LogisticByRoadFactory 

                    break;  

                case "water":  

                    factory = new LogisticByWaterFactory(100, 500);

                // here we create object of  LogisticByWaterFactory 

                    break;  

                default:  

                    break;  

        } 

        Console.WriteLine("\n#####before calling getLogistic"); 

        Logistic logistic=factory.getLogistic();    

        //after creating object it calls the method getlogistic

        Console.WriteLine("\n#####after calling getLogistic "); 

        //getlogistic will return the object of related clsss 

        Console.WriteLine("\nYour Transoprt details are below : \n");  

            Console.WriteLine("\nTransport Type: {0}\nTransport  Limit: {1}\nTransport Cost: {2}",  

                logistic.LogisticType, logistic.LogisticRange, logistic.LogisticCost);  

    }

}