Proxy Design Pattern in .NET

The Proxy pattern provides a placeholder or surrogate for another object. It controls access to the real object and can add extra behavior like caching, logging, lazy initialization, or security.

 

Purpose

To control access to another object. It can be used to defer resource-heavy operations, restrict access, or wrap remote calls and security logic.

 

Key Characteristics

  • Implements the same interface as the real object
  • Delegates requests to the actual object
  • Can add extra logic (e.g., access control, logging)

 

Pros

  • Adds control, performance optimizations, or protection
  • Supports lazy loading or remote access
  • Keeps real object usage transparent to the client

 

Cons

  • Introduces additional layers
  • Can increase complexity
  • Misuse may lead to tight coupling

 

Use Cases

  • Security proxies for sensitive financial operations
  • Virtual proxies to delay expensive report generation
  • Caching proxies for frequent balance or interest rate checks
  • Remote proxies for microservice/API gateways

 

Real-Time Finance Example: Secure Access to Account Details

You want to protect access to sensitive account data. Instead of letting users directly query the service, you use a proxy that checks if the user has permission.

 

1. Define the Interface

public interface IAccountService

{

    void ShowAccountDetails(string user);

}

 

2. Implement the Real Service

public class RealAccountService : IAccountService

{

    public void ShowAccountDetails(string user)

    {

        Console.WriteLine($"Showing account details for: {user}");

    }

}

 

3. Implement the Proxy

public class AccountProxy : IAccountService

{

    private readonly RealAccountService _realService = new();

 

    private readonly List<string> _authorizedUsers = new() { "Priya", "Admin" };

 

    public void ShowAccountDetails(string user)

    {

        if (_authorizedUsers.Contains(user))

        {

            Console.WriteLine("Access granted.");

            _realService.ShowAccountDetails(user);

        }

        else

        {

            Console.WriteLine("Access denied.");

        }

    }

}

 

4. Client Code Usage

class Program

{

    static void Main()

    {

        IAccountService accountService = new AccountProxy();

 

        accountService.ShowAccountDetails("Priya");     // Allowed

        Console.WriteLine();

        accountService.ShowAccountDetails("UnknownUser"); // Denied

    }

}

 

Output

Access granted.

Showing account details for: Priya

 

Access denied.

 

Summary

  • Proxy Pattern is ideal when access to the real object must be controlled, delayed, or enhanced
  • In finance, it's great for access control, audit logging, lazy-loaded services, or external API gateways
  • Keeps client interaction simple, while protecting and managing the real object

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