Prototype Design Pattern in .NET

The Prototype pattern is used to clone an existing object rather than creating a new instance from scratch. It provides a way to copy objects while maintaining performance, especially when object creation is expensive or complex.

 

Purpose

To reduce the cost and complexity of creating new objects by copying an existing one instead of building it step by step or with multiple dependencies.

 

Key Characteristics

  • Cloning existing objects using a Clone or Copy method
  • Typically involves deep or shallow copying
  • Useful when object construction is expensive or slow

 

Pros

  • Reduces object creation overhead
  • Simplifies duplicating complex objects
  • Adds flexibility by allowing modifications to a clone

 

Cons

  • Cloning may be complex for deep object graphs
  • Requires careful management of mutable shared references

 

Use Cases

  • Cloning template-based documents, reports, or invoices
  • Creating a copy of a pre-configured loan application, user profile, or form
  • Duplicating investment portfolios or asset allocation strategies

 

Real-Time Finance Example: Cloning a Pre-Filled Loan Template

You want to allow users to duplicate a previous loan application or use a pre-filled template with some default values. The Prototype pattern helps clone and customize it.

 

1. Define the Prototype Interface

public interface IPrototype<T>

{

    T Clone();

}

 

2. Implement the Prototype in a Class

public class LoanTemplate : IPrototype<LoanTemplate>

{

    public string LoanType { get; set; }

    public decimal DefaultAmount { get; set; }

    public int TenureMonths { get; set; }

    public decimal InterestRate { get; set; }

 

    public LoanTemplate Clone()

    {

        return (LoanTemplate)this.MemberwiseClone(); // shallow copy

    }

 

    public void Show()

    {

        Console.WriteLine($"Loan Type: {LoanType}");

        Console.WriteLine($"Amount: ₹{DefaultAmount}");

        Console.WriteLine($"Tenure: {TenureMonths} months");

        Console.WriteLine($"Interest Rate: {InterestRate}%");

    }

}

 

3. Client Code Usage

class Program

{

    static void Main()

    {

        // Original template for Home Loan

        var homeLoanTemplate = new LoanTemplate

        {

            LoanType = "Home Loan",

            DefaultAmount = 2500000,

            TenureMonths = 240,

            InterestRate = 7.5m

        };

 

        // Clone the template for another customer

        var clonedLoan = homeLoanTemplate.Clone();

        clonedLoan.DefaultAmount = 3000000; // customize if needed

 

        Console.WriteLine("Original Loan Template:");

        homeLoanTemplate.Show();

 

        Console.WriteLine();

 

        Console.WriteLine("Cloned & Customized Loan:");

        clonedLoan.Show();

    }

}

 

Output

Original Loan Template:

Loan Type: Home Loan

Amount: ₹2500000

Tenure: 240 months

Interest Rate: 7.5%

 

Cloned & Customized Loan:

Loan Type: Home Loan

Amount: ₹3000000

Tenure: 240 months

Interest Rate: 7.5%

 

Summary

  • The Prototype pattern is perfect for scenarios where object creation is expensive or standardized
  • In finance applications, it's ideal for duplicating forms, applications, configurations, or templates
  • It helps you avoid repetitive setup and allows quick customization

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