DEV Community: Ali Shahriari (MasterPars)

Mastering EF Core Interceptors: A Practical Guide

Ali Shahriari (MasterPars) — Mon, 03 Nov 2025 09:54:40 +0000

Entity Framework Core Interceptors are one of the most powerful yet underused features in EF Core. They allow you to hook into EF's pipeline and execute custom logic whenever EF performs certain operations — such as executing queries, saving data, or connecting to the database.

In this article, we'll explore:

✅ What EF Core Interceptors are
✅ When you should use them
✅ Real production-ready examples
✅ Audit & Soft Delete implementations
✅ Logging SQL queries Let's dive in and see how EF Interceptors level up your application!

🔥 Why Use EF Core Interceptors?
EF Core Interceptors help you:

Automatically modify database operations
Track changes without touching business logic
Enforce global rules
Log SQL queries
Apply cross‑cutting concerns (audit, soft delete, multi‑tenancy)

They're like ASP.NET middleware — but for EF Core.

🧠 Types of Interceptors in EF Core

IDbCommandInterceptor => Log or modify SQL commands
ISaveChangesInterceptor => Audit, Soft Delete, Validation
IConnectionInterceptor => Track DB connectivity events

✅ SQL Logging Interceptor Example
Logs SQL commands executed by EF Core (useful for debugging & production observability)

using Microsoft.EntityFrameworkCore.Diagnostics;
using System.Data.Common;
using Microsoft.Extensions.Logging;


public class SqlLoggingInterceptor : DbCommandInterceptor
{
    private readonly ILogger<SqlLoggingInterceptor> _logger;


    public SqlLoggingInterceptor(ILogger<SqlLoggingInterceptor> logger)
    {
     _logger = logger;
    }


    public override InterceptionResult<DbDataReader> ReaderExecuting(
    DbCommand command,
    CommandEventData eventData,
    InterceptionResult<DbDataReader> result)
    {
     _logger.LogInformation("EF SQL: {Sql}", command.CommandText);
     return base.ReaderExecuting(command, eventData, result);
    }
}

✅ Register in Program.cs

builder.Services.AddDbContext<AppDbContext>((sp, options) =>
 {
options.UseSqlServer(builder.Configuration.GetConnectionString("Default"));
options.AddInterceptors(sp.GetRequiredService<SqlLoggingInterceptor>());
});


builder.Services.AddScoped<SqlLoggingInterceptor>();

✅ Soft Delete Interceptor
Instead of removing row → mark as deleted.

Soft‑Delete Entity Base Class

public abstract class SoftDeletableEntity
{
    public bool IsDeleted { get; set; }
    public DateTime? DeletedAt { get; set; }
}

User Provider
We need a service to get the current authenticated user:

public interface ICurrentUserService
{
string? GetUserId();
}


public class HttpCurrentUserService : ICurrentUserService
{
private readonly IHttpContextAccessor _context;
public HttpCurrentUserService(IHttpContextAccessor context) => _context = context;


public string? GetUserId()
=> _context.HttpContext?.User?.FindFirst("sub")?.Value // JWT `sub`
?? _context.HttpContext?.User?.Identity?.Name;
}

Interceptor (Audit + User)

using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Diagnostics;


public class SoftDeleteInterceptor : SaveChangesInterceptor
{
public override ValueTask<InterceptionResult<int>> SavingChangesAsync(
DbContextEventData eventData,
InterceptionResult<int> result,
CancellationToken cancellationToken = default)
{
var context = eventData.Context;


foreach (var entry in context.ChangeTracker.Entries<SoftDeletableEntity>())
{
if (entry.State == EntityState.Deleted)
{
entry.State = EntityState.Modified;
entry.Entity.IsDeleted = true;
entry.Entity.DeletedAt = DateTime.UtcNow;
}
}


return base.SavingChangesAsync(eventData, result, cancellationToken);
}
}

Global Query Filter

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
modelBuilder.Entity<Post>().HasQueryFilter(x => !x.IsDeleted);
}

✅ Advanced Audit Interceptor (CreatedAt, UpdatedAt, UserId)
Tracking who created and updated records is essential in enterprise systems. With EF Core Interceptors, you can automatically populate:

CreatedAt
UpdatedAt
UserId (current authenticated user)

Automatically fill audit fields.

Base Entity (Auditable)
We extend the base entity to include UserId.

public abstract class AuditableEntity
{
public DateTime CreatedAt { get; set; }
public DateTime UpdatedAt { get; set; }
public string UserId { get; set; } // Creator / last modifier
}
{
public DateTime CreatedAt { get; set; }
public DateTime UpdatedAt { get; set; }
}

Interceptor

public class AuditInterceptor : SaveChangesInterceptor
{
private readonly ICurrentUserService _currentUser;
public AuditInterceptor(ICurrentUserService currentUser) => _currentUser = currentUser;


public override ValueTask<InterceptionResult<int>> SavingChangesAsync(
DbContextEventData eventData,
InterceptionResult<int> result,
CancellationToken cancellationToken = default)
{
var context = eventData.Context;
var utcNow = DateTime.UtcNow;
var userId = _currentUser.GetUserId() ?? "system";


foreach (var entry in context.ChangeTracker.Entries<AuditableEntity>())
{
if (entry.State == EntityState.Added)
{
entry.Entity.CreatedAt = utcNow;
entry.Entity.UpdatedAt = utcNow;
entry.Entity.UserId = userId;
}
else if (entry.State == EntityState.Modified)
{
entry.Property(x => x.CreatedAt).IsModified = false;
entry.Property(x => x.UserId).IsModified = false;
entry.Entity.UpdatedAt = utcNow;
entry.Entity.UserId = userId;
}
}


return base.SavingChangesAsync(eventData, result, cancellationToken);
}
} : SaveChangesInterceptor
{
public override ValueTask<InterceptionResult<int>> SavingChangesAsync(
DbContextEventData eventData,
InterceptionResult<int> result,
CancellationToken cancellationToken = default)
{
var context = eventData.Context;
var utcNow = DateTime.UtcNow;


foreach (var entry in context.ChangeTracker.Entries<AuditableEntity>())
{
if (entry.State == EntityState.Added)
{
entry.Entity.CreatedAt = utcNow;
entry.Entity.UpdatedAt = utcNow;
}
else if (entry.State == EntityState.Modified)
{
entry.Property(x => x.CreatedAt).IsModified = false;
entry.Entity.UpdatedAt = utcNow;
}
}


return base.SavingChangesAsync(eventData, result, cancellationToken);
}
}

Register Interceptors

builder.Services.AddScoped<SoftDeleteInterceptor>();
builder.Services.AddScoped<AuditInterceptor>();


builder.Services.AddDbContext<AppDbContext>((sp, options) =>
{
options.UseSqlServer(builder.Configuration.GetConnectionString("Default"));
options.AddInterceptors(
sp.GetRequiredService<SoftDeleteInterceptor>(),
sp.GetRequiredService<AuditInterceptor>()
);
});

🎯 Final Thoughts
EF Core Interceptors let you apply enterprise‑grade data rules without scattering logic across your application.
Use them for:

Logging SQL
Audit metadata
Soft delete
Multi‑tenancy
Security rules If you're building serious systems — start using interceptors today.

🚀 Improving Performance with Cursor Pagination in EF Core

Ali Shahriari (MasterPars) — Mon, 14 Jul 2025 08:40:32 +0000

🧠 Why Pagination Matters

In modern applications, especially dashboards and APIs with potentially large datasets (think millions of records), effective pagination isn't just a UI concern — it's a performance-critical backend feature. Poor pagination techniques can cause memory pressure, increased latency, and even database timeouts.

While Offset-based pagination (using Skip() and Take()) is the go-to solution, it's far from efficient at scale. This is where Cursor Pagination comes in.

⛔️ The Problem with Offset Pagination

Let's consider this classic example using EF Core:

var page = 1000;
var pageSize = 20;
var result = db.Posts
    .OrderBy(p => p.CreatedAt)
    .Skip(page * pageSize)
    .Take(pageSize)
    .ToList();

Here’s why this is a performance killer:

Skip is costly: SQL Server still reads through the previous 20,000 rows.
Inconsistent results: New inserts or deletes between pages cause missing or duplicate data.
Index inefficiency: Even if CreatedAt is indexed, Skip breaks the seek pattern.

✅ Enter Cursor Pagination

Cursor pagination uses a stable reference (like a timestamp or ID) instead of offsets. You only fetch rows after or before a known record.

var pageSize = 20;
var cursor = lastSeenCreatedAt; // usually from client

var result = db.Posts
    .Where(p => p.CreatedAt > cursor)
    .OrderBy(p => p.CreatedAt)
    .Take(pageSize)
    .ToList();

Now, instead of scanning from the beginning, EF Core (and ultimately SQL Server) jumps directly to the cursor point using an index seek.

🔬 Real Benchmark: Offset vs Cursor

I benchmarked both strategies over a table with 1,000,000 records using EF Core 8 + SQL Server 2022. Here’s what I found when paginating to record ~page 1000 (offset 20,000):

Strategy	Query Time (ms)	CPU (%)	Memory (MB)	IO Reads
Offset Pagination	420ms	38%	102MB	High
Cursor Pagination	12ms	2%	7MB	Very Low

⚠ Offset pagination consumed 10x more CPU and 14x more memory, while delivering the same data.

💡 Tips for Using Cursor Pagination in EF Core

Use indexed columns as cursor anchors (e.g., CreatedAt, Id).
Order consistently — always use OrderBy on the cursor column.
Use composite cursors if needed: e.g., CreatedAt + Idto ensure uniqueness.
Base64-encode cursor values for API endpoints to keep URLs clean.

🧪 Sample API Implementation (Minimal API)

app.MapGet("/posts", async (DateTime? after, AppDbContext db) =>
{
    var query = db.Posts.AsQueryable();

    if (after.HasValue)
        query = query.Where(p => p.CreatedAt > after.Value);

    var results = await query
        .OrderBy(p => p.CreatedAt)
        .Take(20)
        .ToListAsync();

    return Results.Ok(results);
});

✨ When NOT to Use Cursor Pagination

When strict page numbers are needed (e.g., jumping to page 500).
When sorting by non-unique or non-indexed fields.
For static datasets that rarely change.

🚀 TL;DR

Pagination Type	Performance	Stable Ordering	Suitable for APIs
Offset Pagination	❌ Poor	❌ No	✅ Basic cases
Cursor Pagination	✅ Great	✅ Yes	✅ Highly recommended

💬 Final Thoughts

Cursor pagination is a powerful tool in the hands of performance-conscious developers. With minimal refactoring, you can greatly improve data access speed, scalability, and UX. As always, profile your queries — every millisecond counts.

Understanding the Decorator Pattern Through a MacBook Customization Example in C#

Ali Shahriari (MasterPars) — Tue, 10 Jun 2025 07:48:28 +0000

The Decorator Pattern is a powerful structural design pattern that enables adding new behavior to objects dynamically without modifying their original code. This is especially useful when you want to extend functionalities without creating a complex hierarchy of subclasses.

In this article, I’ll explain the Decorator Pattern using a practical example: customizing a MacBook with different configurations like upgrading RAM, SSD, and adding AppleCare protection.

What is the Decorator Pattern?

The Decorator Pattern allows you to "wrap" an object with additional features or responsibilities at runtime. Instead of creating many subclasses for every possible combination, decorators let you compose behaviors dynamically by stacking objects.

The MacBook Example Overview

We start with a base MacBook configuration:

16GB RAM
256GB SSD
Base price
Using decorators, we can:
Upgrade RAM to 24GB
Upgrade SSD to 512GB
Add AppleCare protection

Each decorator modifies the price and relevant specs accordingly.

Core Components

The Interface IMacBook
Defines the contract with methods like:

GetDescription()
GetPrice()
GetRamSize()
GetSSDSize()

The Base Class BaseMacBook16Ram256SSD

Implements IMacBook and represents the default MacBook configuration.

The Abstract Decorator MackBookDecorator

This class implements IMacBook and wraps another IMacBook instance. It delegates calls to the wrapped instance but can be extended to add or override behavior.

Concrete Decorators

MacBookWithAppleCare: Adds AppleCare price and description.
MacBook512SSD: Adds extra SSD storage and price.
MacBook24RAM: Adds extra RAM and price.

How to Use It

You can compose different MacBook configurations by wrapping the base object with decorators like this:

IMacBook macBook16Ram256SSD = new BaseMacBook16Ram256SSD();
IMacBook macBook16Ram512Sdd = new MacBook512SSD(macBook16Ram256SSD);
IMacBook macBook24Ram512Sdd = new MacBook24RAM(macBook16Ram512Sdd);
IMacBook macBook24Ram512SddWithAppleCare = new MacBookWithAppleCare(macBook24Ram512Sdd);

Console.WriteLine(macBook16Ram256SSD);
Console.WriteLine(macBook16Ram512Sdd);
Console.WriteLine(macBook24Ram512Sdd);
Console.WriteLine(macBook24Ram512SddWithAppleCare);

Each line creates a new configuration by decorating the previous one.

Why Use the Decorator Pattern?

Open/Closed Principle: Extend object behavior without changing existing code.
Flexibility: Combine decorators in any order to create new behaviors.
Avoids Class Explosion: No need to create a subclass for every combination.

Real-World Applications

The Decorator Pattern is widely used in software development:

Adding scrollbars or borders in UI frameworks.
Enhancing functionalities like logging, caching, or security by wrapping services.
Customizing product configurations dynamically, just like our MacBook example.

Conclusion

The Decorator Pattern is an elegant way to add responsibilities to objects dynamically and flexibly. Using this pattern, you keep your codebase maintainable and avoid unnecessary class proliferation.

You can find the full source code for this example on my GitHub repository: DecoratorPattern

Observer Pattern Explained: How It Helps Build Flexible and Scalable Systems

Ali Shahriari (MasterPars) — Sun, 01 Jun 2025 06:30:42 +0000

Design patterns are proven solutions to common software design problems. Among them, the Observer Pattern stands out as a powerful tool for managing communication between objects in a loosely coupled way.

In this article, we'll explore the Observer Pattern in depth and use a simple but effective example — a smart home temperature monitoring system — to demonstrate why this pattern is so useful.

What is the Observer Pattern?

The Observer Pattern defines a one-to-many relationship between objects: one subject (also called observable) maintains a list of its dependents, called observers, and automatically notifies them of any state changes, usually by calling one of their methods.

This pattern is especially helpful when:

You want to decouple objects so that changes in one object are automatically reflected in others without tight integration.
You need dynamic subscription, where observers can be added or removed at runtime.
You want to implement event-driven or reactive systems cleanly.

Key Components of Observer Pattern

Subject (Observable): The object that holds the data or state and notifies observers about changes.
Observers: The objects that want to be informed about changes in the subject.
Registration Methods: Observers can subscribe or unsubscribe to the subject’s notifications.
Notification Method: The subject notifies all registered observers about state changes.

Why Use Observer Pattern?

Consider a system where many parts need to react to changes in a central data source. Without this pattern, you might end up with:

Tight coupling: Each dependent object needs explicit knowledge of others.
Complex code: Manual updates, hard-coded logic, and difficulty in maintenance.
Limited flexibility: Adding/removing observers requires changing core logic.

Observer Pattern solves these issues by promoting loose coupling and separation of concerns.

A Practical Example: Smart Home Temperature Monitoring

Let's imagine a smart home system where a Temperature Sensor monitors the current temperature. Multiple devices depend on this information:

Thermostat: Adjusts heating or cooling based on temperature.
Smart Window: Opens or closes depending on how hot or cold it is.
Notification System: Sends alerts if temperature goes outside safe limits.

How Observer Pattern Fits Here

The Temperature Sensor is the Subject. It holds the temperature state and notifies all registered observers when the temperature changes.

Each device implements an Observer interface with an update method that the sensor calls whenever the temperature changes.

This means:

The sensor doesn’t need to know details about devices.
Devices can be added or removed without modifying the sensor.
The system is extendable and maintainable.

Code Walkthrough (C#)

// Observer Interface
public interface IObserver
{
    void Update(float temperature);
}

// Subject Interface
public interface ISubject
{
    void RegisterObserver(IObserver observer);
    void RemoveObserver(IObserver observer);
    void NotifyObservers();
}

// Concrete Subject
public class TemperatureSensor : ISubject
{
    private List<IObserver> observers = new List<IObserver>();
    private float temperature;

    public void RegisterObserver(IObserver observer) => observers.Add(observer);
    public void RemoveObserver(IObserver observer) => observers.Remove(observer);

    public void NotifyObservers()
    {
        foreach (var observer in observers)
        {
            observer.Update(temperature);
        }
    }

    public void SetTemperature(float newTemperature)
    {
        temperature = newTemperature;
        NotifyObservers();
    }
}

// Concrete Observers
public class Thermostat : IObserver
{
    public void Update(float temperature)
    {
        if (temperature < 20)
            Console.WriteLine("Thermostat: Heating ON.");
        else if (temperature > 25)
            Console.WriteLine("Thermostat: Cooling ON.");
        else
            Console.WriteLine("Thermostat: System OFF.");
    }
}

public class SmartWindow : IObserver
{
    public void Update(float temperature)
    {
        if (temperature > 27)
            Console.WriteLine("SmartWindow: Opening window.");
        else
            Console.WriteLine("SmartWindow: Closing window.");
    }
}

public class NotificationSystem : IObserver
{
    public void Update(float temperature)
    {
        if (temperature > 30 || temperature < 10)
            Console.WriteLine("Notification: Temperature out of safe range!");
    }
}

Benefits of Using Observer Pattern

Loose Coupling: The subject and observers interact via interfaces, reducing dependencies.
Extensibility: Adding new observers requires no change to the subject.
Dynamic Subscription: Observers can register/unregister at runtime.
Improved Maintainability: Separation of concerns makes the system easier to manage.

When to Use the Observer Pattern?

You have an object whose state changes and many other objects need to react to these changes.
You want to avoid tight coupling between objects.
You need a scalable, event-driven architecture.

Conclusion

The Observer Pattern is a powerful and flexible design pattern that helps you build scalable, maintainable software. Using the smart home temperature monitoring example, we see how a subject (temperature sensor) can notify multiple observers (devices) efficiently and cleanly.

By applying this pattern, you make your code easier to extend, test, and maintain — essential qualities for any real-world software system.

🎯 A Clean Way to Inject Strategy Pattern in C# Using Factory and DI Dictionary

Ali Shahriari (MasterPars) — Tue, 27 May 2025 06:20:49 +0000

When implementing multiple behaviors like discount strategies, the common trap is hardcoding logic into service classes or bloating factories with switchstatements. Let’s explore a cleaner, extensible way using:

✅ Strategy Pattern
✅ Factory Pattern
✅ Dependency Injection via Dictionary<Enum, Func<T>>

This approach is minimal, testable, and elegant—especially if you want to add more strategies later with zero friction.

🧠 The Scenario

Suppose you're building an e-commerce platform that supports various discount types:

Percentage-based discount (e.g., 20% off)
Fixed amount discount (e.g., $10 off)
Buy One Get One Free (BOGO)

Each of these follows different logic, but they all return the final price.

🧱 Step 1: Define the Strategy Interface

public interface IDiscountStrategy
{
    decimal ApplyDiscount(decimal unitPrice, int quantity);
}

🛠 Step 2: Implement Each Strategy

PercentageDiscount:

public class PercentageDiscount : IDiscountStrategy
{
    private readonly decimal _percentage = 0.2m;

    public decimal ApplyDiscount(decimal unitPrice, int quantity)
    {
        var total = unitPrice * quantity;
        return total - (total * _percentage);
    }
}

FixedAmountDiscount:

public class FixedAmountDiscount : IDiscountStrategy
{
    private readonly decimal _amount = 10m;

    public decimal ApplyDiscount(decimal unitPrice, int quantity)
    {
        var total = unitPrice * quantity;
        return total - _amount;
    }
}

BuyOneGetOneDiscount:

public class BuyOneGetOneDiscount : IDiscountStrategy
{
    public decimal ApplyDiscount(decimal unitPrice, int quantity)
    {
        var payableQuantity = (quantity / 2) + (quantity % 2);
        return unitPrice * payableQuantity;
    }
}

🏭 Step 4: Implement the Factory

Instead of injecting IServiceProvider, we inject a dictionary of factory functions. This keeps your factory clean and testable.

IDiscountFactory:

public interface IDiscountFactory
{
    IDiscountStrategy GetStrategy(DiscountType type);
}

DiscountFactory (with DI Dictionary)

public class DiscountFactory : IDiscountFactory
{
    private readonly IReadOnlyDictionary<DiscountType, Func<IDiscountStrategy>> _strategyResolvers;

    public DiscountFactory(IReadOnlyDictionary<DiscountType, Func<IDiscountStrategy>> strategyResolvers)
    {
        _strategyResolvers = strategyResolvers;
    }

    public IDiscountStrategy GetStrategy(DiscountType type)
    {
        if (_strategyResolvers.TryGetValue(type, out var resolver))
        {
            return resolver();
        }

        throw new ArgumentOutOfRangeException(nameof(type), $"Unsupported discount type: {type}");
    }
}

💼 Step 5: Define the Purchase Service Interface

public interface IPurchaseService
{
    decimal CalculateFinalPrice(decimal unitPrice, int quantity, DiscountType discountType);
}

💳 Step 6: Implement PurchaseService Using the Factory

public class PurchaseService : IPurchaseService
{
    private readonly IDiscountFactory _discountFactory;

    public PurchaseService(IDiscountFactory discountFactory)
    {
        _discountFactory = discountFactory;
    }

    public decimal CalculateFinalPrice(decimal unitPrice, int quantity, DiscountType discountType)
    {
        var strategy = _discountFactory.GetStrategy(discountType);
        return strategy.ApplyDiscount(unitPrice, quantity);
    }
}

🧩 Step 7: Register Everything in Program.cs

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddScoped<PercentageDiscount>();
builder.Services.AddScoped<FixedAmountDiscount>();
builder.Services.AddScoped<BuyOneGetOneDiscount>();

builder.Services.AddScoped<IReadOnlyDictionary<DiscountType, Func<IDiscountStrategy>>>(sp =>
    new Dictionary<DiscountType, Func<IDiscountStrategy>>
    {
        [DiscountType.Percentage] = () => sp.GetRequiredService<PercentageDiscount>(),
        [DiscountType.FixedAmount] = () => sp.GetRequiredService<FixedAmountDiscount>(),
        [DiscountType.BuyOneGetOne] = () => sp.GetRequiredService<BuyOneGetOneDiscount>()
    });

builder.Services.AddScoped<IDiscountFactory, DiscountFactory>();
builder.Services.AddScoped<IPurchaseService, PurchaseService>();

var app = builder.Build();

🧪 Step 8: Real-World Usage (e.g., Controller or Console Output)

Let’s demonstrate this in Program.cs using console output (ideal for early testing or debugging):

using var scope = app.Services.CreateScope();
var purchaseService = scope.ServiceProvider.GetRequiredService<IPurchaseService>();

Console.WriteLine("=== DISCOUNT CALCULATOR ===");

var price = purchaseService.CalculateFinalPrice(100m, 3, DiscountType.BuyOneGetOne);
Console.WriteLine($"Buy 3 items at $100 each with BOGO => Final price: {price:C}");

price = purchaseService.CalculateFinalPrice(100m, 3, DiscountType.Percentage);
Console.WriteLine($"Buy 3 items at $100 each with 20% discount => Final price: {price:C}");

price = purchaseService.CalculateFinalPrice(100m, 3, DiscountType.FixedAmount);
Console.WriteLine($"Buy 3 items at $100 each with $10 off => Final price: {price:C}");

app.Run();

✅ Final Thoughts

This architecture blends clean code, testability, and maintainability. You gain the flexibility to plug in new discount logic without touching the core business service or polluting the factory with conditionals.

You can extend this pattern to other domains like:

Shipping methods
Tax strategies
Report generators
Notification channels

Building Resilient .NET 10 Applications with Polly

Ali Shahriari (MasterPars) — Tue, 20 May 2025 03:47:08 +0000

In modern distributed systems and microservices, failure is inevitable. Building resilient applications that can gracefully handle failures and recover quickly is critical. In .NET 10, Polly provides a powerful way to implement resilience patterns like Retry, Circuit Breaker, Timeout, and Fallback.

🚧 Why Resilience Matters

Network instability
Timeouts from external APIs
Temporary unavailability of services
Slow downstream services

Without resilience strategies, your application may crash or degrade badly under such conditions.

🛠 Introduction to Polly

Polly is a .NET resilience and transient-fault-handling library that allows developers to express policies such as:

Retry
Circuit Breaker
Timeout
Fallback
Bulkhead Isolation

It works seamlessly with HttpClientFactory and the new features in .NET 10.

🔁 Retry Policy

Retries a failed operation a specified number of times before throwing an exception.

var retryPolicy = Policy
    .Handle<HttpRequestException>()
    .RetryAsync(3);

⚡ Circuit Breaker Policy

Prevents your system from overwhelming failing services. Opens the circuit after a number of failures.

var circuitBreakerPolicy = Policy
    .Handle<HttpRequestException>()
    .CircuitBreakerAsync(
        handledEventsAllowedBeforeBreaking: 5,
        durationOfBreak: TimeSpan.FromSeconds(30));

⏳ Timeout Policy

Cancels requests that take longer than a specified time.

var timeoutPolicy = Policy
    .TimeoutAsync<HttpResponseMessage>(5); // seconds

🧰 Fallback Policy

Provides a default value or alternative logic when a request fails.

var fallbackPolicy = Policy<HttpResponseMessage>
    .Handle<Exception>()
    .FallbackAsync(new HttpResponseMessage(HttpStatusCode.OK)
    {
        Content = new StringContent("Fallback response")
    });

🧪 Combining Policies

You can chain multiple policies for more robust control.

var policyWrap = Policy.WrapAsync(retryPolicy, circuitBreakerPolicy, timeoutPolicy);

🌐 Using Polly with HttpClientFactory in .NET 10

builder.Services.AddHttpClient("ResilientClient")
    .AddPolicyHandler(policyWrap);

📌 Best Practices

Use policy logging for observability
Avoid retrying non-transient faults
Tune thresholds based on your system’s behavior
Combine policies wisely to avoid over-complexity

✅ Conclusion

Resilience is not a luxury—it's a necessity in distributed applications. With Pollyand .NET 10, you can build applications that are robust, responsive, and reliable even in the face of failure. Start small, test often, and tune gradually to create truly resilient systems.

New Features in EF Core 10

Ali Shahriari (MasterPars) — Mon, 19 May 2025 14:32:53 +0000

Entity Framework Core 10 (EF10) introduces several powerful features aimed at enhancing performance, flexibility, and integration capabilities with modern data systems. In this article, we will explore the key features introduced in EF Core 10 and how they can be leveraged to optimize application development.

🌐 Azure Cosmos DB for NoSQL

One of the major enhancements in EF10 is the improved support for Azure Cosmos DB for NoSQL, enabling efficient database operations and powerful new capabilities:

1- Full-text search support:

Allows high-performance text search directly on Cosmos DB documents.
Supports functions like FullTextContains, FullTextContainsAll, and FullTextContainsAny.

Example:

var results = await context.Blogs.Where(x => EF.Functions.FullTextContains(x.Content, "EF Core 10"))
                                .ToListAsync();

2- Hybrid search with Vector Similarity:

EF10 now supports Reciprocal Rank Fusion (RRF), combining vector similarity and full-text search for hybrid queries.

Example:

float[] myVector = {0.1f, 0.2f, 0.3f};
var results = await context.Blogs.OrderBy(x => EF.Functions.Rrf(
    EF.Functions.FullTextScore(x.Content, "database"),
    EF.Functions.VectorDistance(x.Vector, myVector)))
.Take(10)
.ToListAsync();

🔍 LINQ and SQL Translation Enhancements

EF Core 10 introduces native support for new LINQ operators introduced in .NET 10:

1- LeftJoin and RightJoin Support:

Simplifies complex join queries in LINQ.

Example:

var query = context.Students
    .LeftJoin(context.Departments,
             student => student.DepartmentID,
             department => department.ID,
             (student, department) => new
             {
                 student.FirstName,
                 student.LastName,
                 Department = department.Name ?? "[NONE]"
             });

⚡ ExecuteUpdateAsync Enhancements

ExecuteUpdateAsync now supports regular, non-expression lambdas, simplifying update logic:

Example:

await context.Blogs.ExecuteUpdateAsync(s =>
{
    s.SetProperty(b => b.Views, 100);
    s.SetProperty(b => b.Name, "Updated Blog Name");
});

This change eliminates the complexity of building expression trees manually, making bulk updates more readable and maintainable.

📌 Conclusion

EF Core 10 brings substantial improvements to database interactions, LINQ translations, and Cosmos DB integration. These new capabilities not only streamline development but also enhance performance and scalability for modern applications. Developers leveraging EF10 can build more efficient, data-driven applications with less code and improved readability.

Advanced C# Performance Tuning Techniques

Ali Shahriari (MasterPars) — Mon, 19 May 2025 06:39:39 +0000

Optimizing performance in C# applications is crucial for building high-performance and scalable software solutions. This article dives deep into advanced performance tuning techniques that every C# developer should know.

🚀 Garbage Collection (GC) Optimization

The .NET runtime uses Garbage Collection (GC) to manage memory automatically. However, improper handling can lead to performance bottlenecks.

Best Practices:

1- Avoid Large Object Heap (LOH) fragmentation:

Use ArrayPool<T> for large arrays to minimize memory fragmentation.

2- Minimize Boxing and Unboxing:

Avoid unnecessary conversions between value types and reference types.

3- Manual GC Control:

Use GC.Collect() cautiously to force garbage collection when you know there is a memory spike.

Example:

// Avoid manual GC.Collect() unless absolutely necessary
GC.Collect(); // Forces garbage collection - use with caution

⚡ Efficient Memory Management

Memory management is crucial for high-performance applications. Techniques such as pooling, spans, and stack allocation can significantly improve memory usage.

Techniques:

1- Object Pooling:

Reuse objects instead of creating new instances. This is particularly effective for expensive-to-create objects.

2- Span and Memory:

Use Span<T> for stack-allocated memory to avoid heap allocation.

Example:

Span<int> numbers = stackalloc int[5] { 1, 2, 3, 4, 5 };

foreach (var number in numbers)
{
    Console.WriteLine(number);
}

3- Avoiding Finalizers:

Classes with finalizers (~ClassName) are slower to collect. Avoid them when possible.

🔄 Asynchronous Programming Optimization

Asynchronous operations can greatly improve performance if used correctly.

Techniques:

1- Use ConfigureAwait(false):

Prevents unnecessary context switching, speeding up asynchronous calls.

2- Avoid Async Void:

Use async Task instead of async void to enable proper error handling.

3- Task.WhenAll:

Run multiple tasks concurrently to speed up operations.

Example:

await Task.WhenAll(Task1(), Task2(), Task3());

🔍 LINQ Optimization

LINQ is powerful but can be inefficient if not optimized.

Techniques:

1- Avoid Multiple Enumerations:

Do not iterate over the same LINQ query multiple times.

2- Use .ToList() or .ToArray() wisely:

Prevent multiple database calls by materializing the query results once.

3- Filter Early:

Apply .Where() before .Select() to minimize processing.

Example:

var filteredData = data.Where(d => d.IsActive).Select(d => d.Name).ToList();

📌 Conclusion

Mastering advanced performance tuning techniques in C# helps in building efficient, scalable, and maintainable applications. By understanding memory management, garbage collection, asynchronous operations, and LINQ optimization, developers can significantly improve the performance of their software.

Understanding the Key Differences Between IQueryable and IEnumerable

Ali Shahriari (MasterPars) — Sun, 18 May 2025 07:29:09 +0000

In the world of .NET development, understanding the differences between IQueryable and IEnumerable is crucial for optimizing application performance and ensuring efficient data querying. In this article, we will explore the fundamental differences, their use cases, and best practices for leveraging each interface effectively.

🔍 What is IEnumerable?

IEnumerable is an interface that allows you to iterate over a collection of objects. It is defined in the System.Collections namespace and works best with in-memory data collections like lists or arrays.

Key Characteristics:

1- In-memory Processing: All operations with IEnumerable are performed in memory.

2- Deferred Execution: It supports deferred execution, meaning the query is only executed when you iterate over it (e.g., with foreach).

3- Client-side Filtering: All filtering operations (Where, Select, etc.) are performed on the client side after the data is loaded into memory.

4- Single Direction Iteration: It only supports forward iteration over the collection.

Example:

List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
IEnumerable<int> evenNumbers = numbers.Where(x => x % 2 == 0);

// Iterating over the collection
foreach (var number in evenNumbers)
{
    Console.WriteLine(number);
}

🔄 What is IQueryable?

IQueryable is an interface that allows LINQ-to-SQL queries to be translated and executed on a database server. It is defined in the System.Linq namespace and is best used for querying data from a database.

Key Characteristics:

1- Remote Query Execution: Queries are executed on the database server, not in memory.

2- Deferred Execution: Similar to IEnumerable, execution is deferred until you enumerate over it.

3- Efficient Data Fetching: Only the necessary data is fetched from the database, which improves performance.

4- Supports Expression Trees: It builds an expression tree that is converted into SQL commands, allowing database-level operations.

Example:

using (var context = new ApplicationDbContext())
{
    IQueryable<User> users = context.Users.Where(u => u.IsActive);

    foreach (var user in users)
    {
        Console.WriteLine(user.Name);
    }
}

In this example, only the filtered data (IsActive users) is fetched from the database, optimizing memory usage and execution time.

🚀 Key Differences Between IEnumerable and IQueryable

✅ Best Practices

1- Use IQueryable for Database Queries:

If you are querying from a database, prefer IQueryable to avoid unnecessary data loading into memory.

2- Avoid Multiple Iterations:

Iterating multiple times over an IQueryable query will re-execute the database query each time.

3- Minimize Client-side Operations on IQueryable:

Avoid calling methods like .ToList() or .AsEnumerable() too early; it triggers data loading.

4- Use IEnumerable for In-memory Collections:

When working with collections already in memory, IEnumerable is sufficient and avoids extra overhead.

5- Combine When Necessary:

If you need to perform additional client-side operations, use .AsEnumerable() on an IQueryable to switch context.

var result = context.Users.Where(u => u.IsActive).AsEnumerable()
                          .Where(u => u.Age > 30);

❌ Common Mistakes to Avoid

1- Eager Conversion to List:

Calling .ToList() too soon forces all records to be fetched before further filtering.

2- Multiple Enumerations:

Avoid iterating over the query multiple times; use .ToList() if you must enumerate it multiple times.

3- Ignoring Deferred Execution:

Be mindful that queries are not executed until enumeration; changes to the query expression will be reflected in execution.

4- Incorrect Usage for In-memory Collections:

Using IQueryable for in-memory operations adds unnecessary overhead and complexity.

Conclusion

Understanding the differences and best practices for IEnumerable and IQueryable can greatly improve the performance and maintainability of your .NET applications. Choose the right interface based on your data source and query requirements.

Top .NET Interview Questions for 2024-2025

Ali Shahriari (MasterPars) — Sat, 17 May 2025 07:36:21 +0000

This article compiles the most frequently asked technical interview questions for .NET developers during 2024 and 2025. These questions are based on real-world experiences and trusted sources to help you better prepare for your upcoming technical interviews.

🧠 .NET Basics and Architecture

1. What is the difference between .NET Framework and .NET Core?

.NET Framework is designed for Windows applications, whereas .NET Core is a cross-platform, open-source version suitable for Windows, Linux, and macOS. From .NET 5 onwards, both are unified into a single platform known as .NET.

2. What is CLR and what are its responsibilities?

CLR (Common Language Runtime) is the execution environment for .NET applications, responsible for memory management, garbage collection, exception handling, and type safety.

3. What are Assemblies in .NET?

Assemblies are executable (.exe) or library (.dll) files that contain compiled code and metadata required for .NET applications. They play a crucial role in versioning, security, and deployment.

💡 Advanced C# and OOP Concepts

4. What is the difference between a Class and an Interface?

Classes can have implementation, fields, and properties, while Interfaces only define method signatures and properties without implementation.

5. What is the difference between an Abstract Class and an Interface?

Abstract classes can have both defined and undefined methods, whereas Interfaces only contain method signatures.

6. What is the difference between ref and out parameters?

ref parameters must be initialized before being passed, while out parameters do not require initialization and are used for returning values from methods.

7. What is LINQ and what are its benefits?

LINQ (Language Integrated Query) allows developers to write queries directly in C# for collections, databases, and XML, making code more readable and maintainable.

🧩 Advanced Concepts and Optimization

8. What is the difference between IEnumerable and IQueryable?

IEnumerable is suitable for in-memory collections and executes queries in memory, while IQueryable is designed for database operations and executes queries at the database level.

9. What is Dependency Injection and its benefits?

Dependency Injection (DI) is a design pattern that injects dependencies into classes, improving testability and maintainability. ASP.NET Core has built-in support for DI.

10. What is the difference between Task and Thread?

Thread is a basic unit of execution, while Task is a higher-level abstraction for asynchronous programming that manages resources more efficiently.

11. What is the role of async and await in C#?

These keywords simplify asynchronous programming, allowing long-running operations without blocking the main thread.

🛠️ ASP.NET Core and Web API

12. How does the MVC pattern work in ASP.NET?

MVC (Model-View-Controller) divides an application into three interconnected components to separate business logic from UI.

13. How do you implement a RESTful API in .NET?

Using ASP.NET Core Web API, developers define controllers with specific routes, create data models, and leverage Dependency Injection for service management.

14. How do you secure a Web API?

Using JWT for authentication, enabling HTTPS, and applying authorization policies and filters in ASP.NET Core.

🗃️ Database and Entity Framework

15. What is Entity Framework and its advantages?

Entity Framework (EF) is an ORM (Object-Relational Mapper) that allows developers to interact with databases using .NET objects instead of SQL queries.

16. What is the difference between Lazy Loading and Eager Loading?

Lazy Loading loads data only when it is accessed, while Eager Loading fetches all related data along with the main entity.

17. What is the difference between Clustered and Non-Clustered Indexes in SQL Server?

A Clustered Index sorts and stores data rows in the table, while a Non-Clustered Index maintains a separate structure pointing to the actual data.

🧰 Tools and Best Practices

18. What is NuGet and its purpose?

NuGet is a package manager for .NET that allows developers to add libraries and dependencies to their projects easily.

19. How do you optimize the performance of a .NET application?

By caching data, reducing database queries, using asynchronous programming, and managing resources efficiently.

20. What are common design patterns in .NET?

Patterns like Singleton, Repository, and Factory are used for resource management, data abstraction, and object creation without exposing the instantiation logic.

Discover What's New in EF Core 10

Ali Shahriari (MasterPars) — Sat, 17 May 2025 06:40:43 +0000

Entity Framework Core 10 (EF10) is the latest evolution of Microsoft's ORM, bringing significant enhancements to database interactions, especially with Azure Cosmos DB, LINQ translations, and update operations. In this article, we’ll explore the key features that make EF10 a game-changer for .NET developers.

Enhanced Azure Cosmos DB Support

EF10 introduces new capabilities for Azure Cosmos DB:

Full-Text Search Integration : Cosmos DB now supports full-text search, allowing for efficient querying of text content directly in EF10. This is especially useful for AI-driven applications where relevance and search optimization are crucial.

 public class Blog
{
    public string Contents { get; set; }
}

public class BloggingContext : DbContext
{
    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Blog>(b =>
        {
            b.Property(x => x.Contents).EnableFullTextSearch();
            b.HasIndex(x => x.Contents).IsFullTextIndex();
        });
    }
}

var results = await context.Blogs.Where(x => EF.Functions.FullTextContains(x.Contents, "cosmos")).ToListAsync();

Hybrid Search Capabilities : Leveraging RRF (Reciprocal Rank Fusion), EF10 now enables hybrid search, blending full-text search with vector-based searches for more accurate results.

 float[] myVector = /* vector data */;
var hybridResults = await context.Blogs.OrderBy(x => EF.Functions.Rrf(
    EF.Functions.FullTextScore(x.Contents, "database"),
    EF.Functions.VectorDistance(x.Vector, myVector)
)).Take(10).ToListAsync();

Vector Similarity Search Maturity : The experimental vector search feature from EF9 is now fully supported in EF10, with improvements for owned reference entities.

New LINQ Operators for Joins

.NET 10 simplifies LINQ joins with native LeftJoin and RightJoin methods. Previously, these joins required complex combinations of SelectMany and GroupJoin. Now, they are much more intuitive:

 var query = context.Students
    .LeftJoin(
        context.Departments,
        student => student.DepartmentID,
        department => department.ID,
        (student, department) => new
        {
            student.FirstName,
            student.LastName,
            Department = department.Name ?? "[NONE]"
        });

Simplified Update Operations

EF10 introduces an easier way to perform updates with ExecuteUpdateAsync, supporting lambda expressions directly:

 await context.Blogs.ExecuteUpdateAsync(s =>
{
    s.SetProperty(b => b.Views, 8);
    if (nameChanged)
    {
        s.SetProperty(b => b.Name, "Updated Blog Name");
    }
});

This eliminates the need for cumbersome expression trees, making code cleaner and more maintainable.

Final Thoughts

EF Core 10 is set to make database interactions smoother and more efficient. Its enhancements in Cosmos DB support, LINQ simplifications, and update handling will undoubtedly be welcomed by .NET developers. Stay tuned for deeper dives into each of these features in upcoming tutorials.