Skip to main content

Abstract Factory Pattern

ABSTRACT FACTORY PATTERN

           Provide an interface for creating families of related or dependent objects without specifying their
concrete classes.
                         Casual Implementation                             Factory Pattern Implementation
 Usual Code Block
 Factory Pattern

Parent Class

public class CheckBook
{
    protected decimal _Amount;
    public decimal getExpense()
    {
      return _Amount;
    }
}

These below child classes is derived from CheckBook base class.

public class Health : CheckBook
{
    public Health()
    {
        _Amount = 5000;//Could be any logic to calculate health amount
        Console.WriteLine("Your Health Expense: {0}", _Amount.ToString());
    }
}
public class Travel : CheckBook
{
    public Travel()
    {
        _Amount = 10000;//Could be any logic to calculate travel amount
        Console.WriteLine("Your Travel Expense: {0}", _Amount.ToString());
    }
}

public class Personal : CheckBook
{
    public Personal()
    {
        _Amount = 15000;//Could be any logic to calculate personal amount
        Console.WriteLine("Your Personal Expense: {0}", _Amount.ToString());
    }
}
public class CheckFactory
{
    public CheckFactory() { }

    public CheckBook chooseExpense(int o)
    {
        switch (o)
        {
            case 1:
                return new Personal();
            case 2:
                return new Travel();
            default:
                return new Health();
        }
    }
}




class Program
{
    static void Main(string[] args)
    {
        string input = Console.ReadLine();
        CheckFactory objCheckFactory = new CheckFactory();
        CheckBook currentExpense = objCheckFactory.chooseExpense(int.Parse(input));
        Console.WriteLine("From main class " + currentExpense.getExpense());
        Console.Read();
    }
}

Labels

Labels:

Comments

Post a Comment

Popular posts from this blog

C# IEnumerable and IQueryable

The first important point to remember is IQueryable interface inherits from IEnumerable, so whatever IEnumerable can do, IQueryable can also do.   There are many differences but let us discuss about the one big difference which makes the biggest difference. IEnumerable interface is useful when your collection is loaded using LINQ or Entity framework and you want to apply filter on the collection. Consider the below simple code which uses IEnumerable with entity framework. It’s using a Wherefilter to get records whose EmpId is 2. EmpEntities ent = new EmpEntities(); IEnumerable<Employee> emp = ent.Employees;  IEnumerable<Employee> temp = emp.Where(x => x.Empid == 2).ToList<Employee>(); This where filter is executed on the client side where the IEnumerable code is. In other words all the data is fetched from the database and then at the client its scans and gets the record with EmpId is 2.   But now see the below code we have...
Post a Comment
Read more

Asp.Net MVC Life Cycle

MVC Life Cycle: 1. Routing -         Routing is the first step in ASP.NET MVC pipeline. Typically, it is a pattern matching system that matches the incoming request to the registered URL patterns in the Route Table. The UrlRoutingModule(System.Web.Routing.UrlRoutingModule) is a class which matches an incoming HTTP request to a registered route pattern in the RouteTable(System.Web.Routing.RouteTable). 2.Controller Initialization -        The MvcHandler initiates the real processing inside ASP.NET MVC pipeline by using ProcessRequest method. This method uses the IControllerFactory instance (default is System.Web.Mvc.DefaultControllerFactory) to create corresponding controller. 3. Action Execution – Action execution occurs in the following steps:        When the controller is initialized, the controller calls its own InvokeAction() method by passing the details of the chosen action method. This is han...
Post a Comment
Read more