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();
    }
}

Comments

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...