Factory Method Design Pattern in .NET — Real-Time Finance Example

The Factory Method design pattern is a classic solution to a recurring problem in software design — object creation without exposing the instantiation logic. Instead of using new directly in client code, the Factory Method delegates the creation responsibility to a method that returns an object implementing a common interface or abstract class.

 

What is the Factory Method Pattern?

The Factory Method pattern defines an interface or abstract method for creating an object but allows subclasses or implementers to decide which class to instantiate. It hides object creation logic from the client and promotes loose coupling.

 

Purpose

To encapsulate object creation, so the code using the object does not depend on specific implementations. This promotes better maintainability and extensibility, especially when new types need to be introduced.

 

Key Characteristics

  • Defines a common interface or abstract class for object creation
  • Lets subclasses or factory methods decide which class to instantiate
  • Promotes polymorphism and loose coupling

 

Pros

  • Decouples client code from concrete object types
  • Supports the Open/Closed Principle
  • Makes the codebase more flexible and maintainable

 

Cons

  • Adds complexity with additional classes and interfaces
  • Overkill for simple object creation

 

Use Cases

  • Creating different types of transactions (NEFT, IMPS, RTGS) in a banking system
  • Generating reports in different formats (PDF, Excel, CSV)
  • Creating notification services (Email, SMS, Push)

 

Real-Time Finance Example: Bank Transaction Processing

In a banking system, you may need to process various types of transactions. Instead of hardcoding each type, the Factory Method can be used to create the transaction dynamically based on input.

 

1. Create a Common Interface

public interface IBankTransaction

{

    void Process(decimal amount);

}

 

2. Implement Concrete Classes

public class NEFTTransaction : IBankTransaction

{

    public void Process(decimal amount)

    {

        Console.WriteLine($"Processing NEFT transaction of ₹{amount}");

    }

}

 

public class IMPOSTransaction : IBankTransaction

{

    public void Process(decimal amount)

    {

        Console.WriteLine($"Processing IMPS transaction of ₹{amount}");

    }

}

 

public class RTGSTransaction : IBankTransaction

{

    public void Process(decimal amount)

    {

        Console.WriteLine($"Processing RTGS transaction of ₹{amount}");

    }

}

 

3. Create a Factory

public static class TransactionFactory

{

    public static IBankTransaction CreateTransaction(string type)

    {

        return type switch

        {

            "NEFT" => new NEFTTransaction(),

            "IMPS" => new IMPOSTransaction(),

            "RTGS" => new RTGSTransaction(),

            _ => throw new ArgumentException("Invalid transaction type"),

        };

    }

}

 

4. Client Code Usage

class Program

{

    static void Main()

    {

        string transactionType = "IMPS";

        decimal amount = 5000;

 

        IBankTransaction transaction = TransactionFactory.CreateTransaction(transactionType);

        transaction.Process(amount);

    }

}

 

Benefits in This Scenario

  • Client code does not need to know the concrete class name
  • Adding a new transaction type like UPI requires only a new class and a factory entry
  • Promotes extensibility, loose coupling, and single responsibility

 

Summary

  • Factory Method is ideal when object creation should depend on configuration, input, or conditions
  • In finance applications, this pattern handles the dynamic creation of components like transactions, reports, or notifications
  • It improves scalability and maintainability, especially in large systems with changing requirements

Comments

Post a Comment

Popular posts from this blog

Multiline to singleline IN C# - CODING

Multiline to singleline IN C# - CODING using System; using System.Linq; class Program {     static void Main(string[] args)     {         string input = @"This is                  multiline";                  // Split the input into lines, trim each line, and filter out empty lines         string result = string.Join(" ", input.Split(new[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries)                                                .Select(line => line.Trim()));         Console.WriteLine(result);     } } Output: This is  multiline
Read more

EF Core interview questions for beginners

1. What is Entity Framework Core (EF Core)? EF Core is an open-source Object-Relational Mapper (ORM) that enables .NET developers to work with databases using .NET objects. It allows you to interact with a database using strongly typed classes and LINQ queries, rather than writing raw SQL queries. EF Core supports various database providers, such as SQL Server, SQLite, PostgreSQL, MySQL, and more. 2. What are the advantages of using EF Core over traditional ADO.NET? Productivity:  EF Core allows you to work with databases using high-level objects, reducing the amount of boilerplate code you need to write. Cross-platform:  EF Core supports multiple databases and works on Windows, Linux, and macOS. LINQ Support:  You can query the database using LINQ, which is more type-safe and easier to maintain than raw SQL queries. Code-First & Database-First:  EF Core supports both approaches to model databases. Change Tra...
Read more

EF Core interview questions for experienced

EF Core interview questions for experienced 1. What are the main differences between Entity Framework (EF) and Entity Framework Core (EF Core)? EF Core is a complete rewrite of EF. Unlike EF, EF Core supports cross-platform development, improved performance, LINQ query translation, and has a more modular architecture. EF Core does not support all features that EF 6 does (like lazy loading and some database providers). 2. How does EF Core handle migrations, and what are some common pitfalls? EF Core uses migrations to update the database schema based on model changes. Common pitfalls include not applying migrations correctly, misalignment between model and database state, or missing/overwriting migrations during collaboration in a team environment. 3. Explain the difference between Add and Attach methods in EF Core. Add method is used to add a new entity to the context and mark it as Added , while Attach attaches an existing entity to the context with no changes. The Attach meth...
Read more