DEV Community: ahmedmohamedhussein

Enhancing SignalR with `HubFilter`: A Deep Dive into Custom Logic for Real-Time Applications*

ahmedmohamedhussein — Wed, 16 Apr 2025 07:15:24 +0000

SignalR has become one of the most popular libraries for real-time web communication in .NET. Whether you're building a chat application, a real-time dashboard, or a live notification system, SignalR enables efficient and scalable communication between clients and servers. However, as your SignalR application grows, you may want to introduce cross-cutting concerns like logging, authorization, or validation across your SignalR Hub methods.

In this article, we'll explore the power of HubFilter—an essential tool in SignalR that allows you to inject custom logic into your Hub method invocations. We'll walk you through how to set up and use HubFilter, compare it to middleware, and explore real-world use cases for better application architecture.

What Is `HubFilter` in SignalR?

HubFilter is a feature in SignalR that lets you apply custom logic directly to SignalR Hub method invocations. It’s like middleware, but specifically designed for SignalR, and it operates before or after a SignalR Hub method is called.

Using HubFilter, you can easily inject behavior such as:

Authorization: Check if a user has the right permissions to call a method.
Logging: Log method calls, input parameters, and results without modifying each Hub method.
Validation: Validate inputs or conditions before proceeding with method execution.
Error Handling: Catch exceptions globally in SignalR hubs and handle them accordingly.

This custom filter logic lets you centralize and reuse code in a non-intrusive way, as it doesn’t require changing the individual methods of your Hub.

Why Use `HubFilter`?

Centralized Logic: Instead of adding authorization checks, logging, or validation to every individual Hub method, you can centralize the logic in one place (the HubFilter).
Clean and Reusable Code: Hub filters help you avoid redundant code across multiple Hub methods. You can implement cross-cutting concerns like logging and error handling in a structured way.
Granular Control: HubFilter allows you to control method execution at a granular level. You can decide whether a method should be executed or not, throw exceptions, or even modify the execution flow.
Maintainability: With HubFilter, you can manage your application's logic in a scalable and maintainable way, especially as your application grows.

Key Features of `HubFilter`

Pre- and Post-Execution Logic: You can add code to execute before a Hub method runs or after it completes.
Method-Level Logic: Unlike middleware, which operates at a global HTTP request level, HubFilter applies only to SignalR methods.
Customizability: You can easily customize it to meet your application's specific needs, such as logging or authentication.

How Does `HubFilter` Work?

In SignalR, a Hub is a class that allows clients to call methods on the server. Each method in the Hub can be intercepted with a HubFilter, which allows you to insert custom logic before and after the method call.

Here’s how it works:

Before Method Invocation: A HubFilter can perform actions, such as logging, validating the request, or checking the user’s permissions, before the SignalR method is invoked.
After Method Invocation: Once the SignalR method has been executed, the HubFilter can inspect or manipulate the response, log the outcome, or handle errors.

Example: Using `HubFilter` for Logging and Authorization

Let’s create a custom HubFilter to handle logging and authorization checks for SignalR Hub methods.

Step 1: Create a Custom `HubFilter`

public class LoggingAndAuthorizationHubFilter : IHubFilter
{
    private readonly ILogger<LoggingAndAuthorizationHubFilter> _logger;

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

    public async ValueTask InvokeAsync(HubInvocationContext invocationContext, HubDelegate next)
    {
        // Log before method execution
        _logger.LogInformation("Method {MethodName} called with parameters {Parameters} at {Time}",
            invocationContext.MethodName, string.Join(", ", invocationContext.Arguments), DateTime.UtcNow);

        // Check if user is authenticated (authorization check)
        if (invocationContext.Hub.Context.User.Identity.IsAuthenticated == false)
        {
            _logger.LogWarning("Unauthorized access attempt to method: {MethodName}", invocationContext.MethodName);
            throw new UnauthorizedAccessException("You must be authenticated to call this method.");
        }

        // Call the next filter or the actual Hub method
        await next(invocationContext);

        // Log after method execution
        _logger.LogInformation("Method {MethodName} completed successfully at {Time}", 
            invocationContext.MethodName, DateTime.UtcNow);
    }
}

Step 2: Register the `HubFilter` in `Program.cs`

Now, register the custom HubFilter in the SignalR pipeline.

public class Program
{
    public static void Main(string[] args)
    {
        var builder = WebApplication.CreateBuilder(args);

        // Register SignalR services
        builder.Services.AddSignalR();

        // Register the custom HubFilter
        builder.Services.AddSingleton<IHubFilter, LoggingAndAuthorizationHubFilter>();

        var app = builder.Build();

        // Configure routing for SignalR hubs
        app.UseRouting();
        app.MapHub<ChatHub>("/chat");

        app.Run();
    }
}

Step 3: Implement SignalR Hub Methods

Here's an example SignalR Hub where the custom filter is applied:

public class ChatHub : Hub
{
    private readonly ILogger<ChatHub> _logger;

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

    public async Task SendMessage(string message)
    {
        _logger.LogInformation("Sending message: {Message}", message);

        // Broadcast the message to all clients
        await Clients.All.SendAsync("ReceiveMessage", message);
    }
}

In this case, the LoggingAndAuthorizationHubFilter will log the method invocation, check if the user is authenticated, and then proceed with the execution of the SendMessage method.

Practical Use Cases for `HubFilter`

Authorization:
- Check if a user has the necessary permissions to invoke a specific SignalR method.
- Example: Prevent non-admin users from sending system-wide messages in a chat app.
Logging:
- Automatically log method calls, including input parameters, response status, and execution time.
- Example: Log messages sent by users in a chat app to track usage patterns or monitor activity.
Validation:
- Validate incoming data before it’s processed by the Hub method.
- Example: Ensure that a chat message meets certain criteria (e.g., no profanity, valid length).
Error Handling:
- Handle exceptions globally for all SignalR Hub methods.
- Example: Catch unhandled exceptions and send an appropriate message to the client.

`HubFilter` vs Middleware: What’s the Difference?

While both HubFilter and middleware are used to intercept requests and add logic, there are key differences:

Middleware operates at the HTTP request level and can be applied globally to all requests (including SignalR).
HubFilter is specific to SignalR Hubs and allows you to apply logic directly to Hub method calls, offering granular control over method invocation.

In short, use middleware for application-wide logic (like authentication, logging, etc.) and use HubFilter for SignalR-specific concerns.

Conclusion

The HubFilter is a powerful feature in SignalR that allows you to add custom behavior to your Hub methods in a clean and reusable way. Whether you’re looking to handle authorization, logging, validation, or error handling, HubFilter offers a flexible solution without cluttering the logic inside your Hub methods.

By implementing HubFilter, you can ensure that cross-cutting concerns are applied consistently across your SignalR Hubs, leading to a more maintainable and scalable real-time application.

Happy coding, and start leveraging the power of HubFilter in your next SignalR project!

Aggressive Inline in .NET: Boosting Performance or Over-Optimization?

ahmedmohamedhussein — Sat, 08 Mar 2025 08:35:11 +0000

In software development, performance is often a key factor in determining the success of an application. Optimizing performance can sometimes be challenging, especially when trying to balance between readability, maintainability, and execution speed. Aggressive Inline is one such optimization technique in .NET that promises to improve performance, but is it always beneficial? Let's dive into what Aggressive Inline is, when to use it, and how it affects performance with a hands-on example.

What is Aggressive Inline in .NET?

Aggressive Inline is a compiler feature in .NET that suggests to the compiler to insert the code of a method directly into the place where it’s called, rather than performing a traditional method call. This technique can be particularly useful in scenarios where you want to minimize the overhead associated with method calls, especially for small and frequently invoked methods.

For example, if you have a simple method like adding two numbers, inlining the method can eliminate the need for a jump to another part of the program, reducing execution time.

In .NET, you can use the [MethodImpl(MethodImplOptions.AggressiveInlining)] attribute to tell the compiler that you’d like the method to be inlined aggressively.

Why Should You Care About Aggressive Inline?

The main motivation behind using Aggressive Inline is performance. Here’s why you might consider using it:

Eliminating Method Call Overhead:
Every method call in a program involves some overhead. The program must jump to the method’s location in memory, execute the method, and then return. For small methods that are frequently called, this overhead can add up, especially in performance-critical areas like tight loops or real-time applications.
Smaller and More Efficient Code:
By inlining a method, you effectively remove the need for the call stack and the associated overhead, which can lead to a more compact and faster executing program.
Optimization for Hot Code Paths:
If your application has specific code paths that are executed repeatedly (e.g., in loops or frequently used functions), Aggressive Inline can be a powerful tool to optimize those paths, making them execute faster.

Potential Drawbacks of Aggressive Inline

While Aggressive Inline can improve performance, it's not without its caveats. Here are some potential drawbacks:

Code Bloat:
The most common issue with inlining is code bloat. When a method is inlined, the method’s code is duplicated at each call site. This can lead to larger binaries, which may hurt performance if too many methods are inlined or if the methods are complex and large.
Increased Compilation Time:
Inlining methods can increase the time it takes to compile your code. The compiler needs to analyze the method more extensively to insert it at every call site, which can slow down the build process, especially for large codebases.
Difficulty in Debugging:
With inlined methods, you lose the ability to step through method calls in a debugger easily. Instead of jumping to the method, the debugger will step into the inlined code, which can make it harder to follow the flow of execution.

When Should You Use Aggressive Inline?

Aggressive Inline is most beneficial in specific scenarios:

Small, Simple Methods: Methods that perform simple operations (like adding two numbers or returning a constant value) are prime candidates for inlining. The overhead saved by eliminating the method call can provide noticeable performance improvements.
Critical Code Paths: If you have parts of your code that are executed frequently (e.g., in a game loop or real-time processing), Aggressive Inline can provide performance gains by reducing unnecessary jumps in execution.
Performance-Intensive Applications: Applications that require fast execution, such as gaming engines, financial applications, or high-frequency trading systems, can benefit from the speed gains that come from inlining small, often-used methods.

Performance Example: Aggressive Inline in Action

To understand the real impact of Aggressive Inline, let's look at a performance comparison between regular method calls and methods that are aggressively inlined. We’ll use the BenchmarkDotNet library to measure the performance of both approaches.

Without Aggressive Inline:

public class BenchmarkExample
{
    public int Add(int a, int b)
    {
        return a + b;
    }
}

This is the traditional method, which will be called normally. Every time Add is called, it will incur the overhead of a method call.

With Aggressive Inline:

using System.Runtime.CompilerServices;

public class BenchmarkExample
{
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public int Add(int a, int b)
    {
        return a + b;
    }
}

Here, the method Add is inlined, and the compiler is instructed to insert the method’s body directly at each call site.

Benchmarking Code:

using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;

public class BenchmarkExample
{
    [Benchmark]
    public int AddWithoutInline(int a, int b)
    {
        return a + b;
    }

    [Benchmark]
    public int AddWithInline(int a, int b)
    {
        return a + b;
    }
}

public class Program
{
    public static void Main(string[] args)
    {
        var summary = BenchmarkRunner.Run<BenchmarkExample>();
    }
}

Expected Results:

When running this benchmark, the AddWithInline method (using Aggressive Inline) will likely outperform AddWithoutInline because it eliminates the overhead of the method call. The results will show that inlining the small method can result in a faster execution time.

For instance, you might observe results like:

AddWithoutInline takes 0.30 milliseconds per invocation.
AddWithInline takes 0.15 milliseconds per invocation.

These results would demonstrate a significant performance improvement for inlining simple methods, especially when they're called frequently in the application.

Conclusion: Should You Use Aggressive Inline?

Aggressive Inline is a useful optimization tool in .NET, but it should be used judiciously. It can lead to substantial performance improvements in specific scenarios, such as small, frequently called methods or performance-critical sections of your code. However, overusing it can result in code bloat and other potential issues like longer compilation times and harder debugging.

Before adopting Aggressive Inline in your project, make sure to test its impact on performance using tools like BenchmarkDotNet to ensure that it provides a meaningful performance benefit for your specific use case.

In summary, Aggressive Inline can boost performance when applied to the right methods, but like all optimizations, it should be used thoughtfully and with clear measurement of its impact.

Mastering `SelectMany` in EF Core: SQL Equivalents and Best Practices

ahmedmohamedhussein — Thu, 13 Feb 2025 06:22:47 +0000

Introduction

Entity Framework Core (EF Core) provides powerful LINQ methods for querying relational databases in an expressive and efficient way. One of the most useful methods, SelectMany, allows developers to flatten nested collections and retrieve related data seamlessly.

But how does SelectMany translate to SQL? And when should you use it? In this article, we’ll explore SelectMany with real-world examples, its SQL equivalents, and how to handle potential pitfalls such as null values.

Understanding `SelectMany` in EF Core

The SelectMany method is used when dealing with one-to-many or many-to-many relationships. It takes a collection and flattens it into a single sequence, which makes it particularly useful when working with related entities in EF Core.

Basic Syntax

context.Entities
    .SelectMany(entity => entity.CollectionProperty)
    .Where(condition)
    .Select(result => new { result.Property });

Why Use `SelectMany`?

✔ Flattens nested collections

✔ Reduces manual looping in memory

✔ Improves query readability and performance

Real-World Scenarios and SQL Equivalents

1. Retrieving All Orders from Customers

Scenario

Each Customer has multiple Orders. We need to retrieve a flat list of all orders across all customers.

EF Core Query

var allOrders = context.Customers
    .SelectMany(c => c.Orders)
    .ToList();

SQL Equivalent Using `INNER JOIN`

SELECT o.*
FROM Customers c
INNER JOIN Orders o ON c.Id = o.CustomerId;

✅ This query efficiently retrieves all orders without manually iterating over customers.

2. Filtering Data with `CASE WHEN` in SQL

Scenario

We want to categorize orders as "Expensive" (Price > $100) or "Affordable" (Price ≤ $100).

EF Core Query with `SelectMany`

var categorizedOrders = context.Customers
    .SelectMany(c => c.Orders, (c, order) => new
    {
        CustomerName = c.Name,
        OrderId = order.Id,
        Price = order.Price,
        Category = order.Price > 100 ? "Expensive" : "Affordable"
    })
    .ToList();

SQL Equivalent Using `CASE WHEN`

SELECT 
    c.Name AS CustomerName,
    o.Id AS OrderId,
    o.Price,
    CASE 
        WHEN o.Price > 100 THEN 'Expensive'
        ELSE 'Affordable'
    END AS Category
FROM Customers c
INNER JOIN Orders o ON c.Id = o.CustomerId;

✅ This efficiently categorizes each order in SQL before fetching the data.

3. Using `SelectMany` with Enums in EF Core

Scenario

Each Employee can have multiple roles, stored as an enum. We need to retrieve all roles in a flat list and categorize them as Technical or Non-Technical.

Defining the Enum

public enum EmployeeRole
{
    Developer,
    Manager,
    HR,
    Tester
}

Entity Model

public class Employee
{
    public int Id { get; set; }
    public string Name { get; set; }
    public List<EmployeeRole> Roles { get; set; } = new();
}

EF Core Query with `SelectMany` and Conditional Mapping

var employeeRoles = context.Employees
    .SelectMany(e => e.Roles, (e, role) => new
    {
        EmployeeName = e.Name,
        Role = role.ToString(),
        Category = role == EmployeeRole.Developer || role == EmployeeRole.Tester 
            ? "Technical" 
            : "Non-Technical"
    })
    .ToList();

SQL Equivalent Using `CASE WHEN`

SELECT 
    e.Name AS EmployeeName,
    er.Role AS Role,
    CASE 
        WHEN er.Role IN ('Developer', 'Tester') THEN 'Technical'
        ELSE 'Non-Technical'
    END AS Category
FROM Employees e
INNER JOIN EmployeeRoles er ON e.Id = er.EmployeeId;

✅ This approach allows us to transform enum values into meaningful categories using CASE WHEN.

Handling Nullability with `SelectMany` Safely

A common mistake when using SelectMany is assuming that the related collection is never null. The null-forgiveness operator (!) does not prevent runtime exceptions—it only suppresses compiler warnings.

Example of a Potentially Unsafe Query

var roles = context.Employees
    .SelectMany(e => e.Toles!) // Might cause an exception if Toles is null
    .ToList();

❌ Why does this throw an exception?

The ! operator does not change runtime behavior.
If Toles is null, SelectMany will still throw a NullReferenceException because it tries to iterate over null.

✅ Safe Approaches to Avoid Null Exceptions

1. Using `??` to Provide a Default Value

var roles = context.Employees
    .SelectMany(e => e.Toles ?? new List<Role>()) // Ensures no null exception
    .ToList();

🔹 If Toles is null, it defaults to an empty list instead of throwing an error.

2. Filtering Out Null Collections Before `SelectMany`

var roles = context.Employees
    .Where(e => e.Toles != null)  // Exclude employees with null Toles
    .SelectMany(e => e.Toles!)
    .ToList();

🔹 This prevents SelectMany from attempting to iterate over a null value.

Key Takeaways

SelectMany is essential for flattening one-to-many and many-to-many relationships in EF Core.
SQL INNER JOIN is the most common equivalent for SelectMany.
CASE WHEN in SQL is the best approach for categorizing data within queries.
Enums can be mapped to meaningful string values using SelectMany.
Always handle null values properly—the ! operator does not prevent runtime exceptions.
Use ?? or Where(e => e.Collection != null) to avoid null-related crashes.

Final Thoughts

EF Core’s SelectMany simplifies working with related collections, making queries more efficient and readable. By understanding its SQL translation and handling null values safely, you can write optimized queries that perform well in both LINQ and SQL.

Next time you're working with nested collections in EF Core, leverage SelectMany to make your queries cleaner and faster! 🚀

💡 What are your experiences with SelectMany in EF Core? Let me know in the comments!

Efficient Data Processing in EF Core with the `Chunk` Method in .NET 6+

ahmedmohamedhussein — Wed, 12 Feb 2025 16:10:39 +0000

Introduction

When working with large datasets in Entity Framework Core, performance is always a key concern. Fetching and processing a large number of records can lead to high memory usage and performance bottlenecks.

Thankfully, with .NET 6, the LINQ Chunk method simplifies batch processing by splitting collections into smaller chunks. This is particularly useful when handling large queries in EF Core, paginating data, or performing batch operations efficiently.

In this article, we’ll explore how the Chunk method works and how to use it in a real-world EF Core scenario to improve performance.

Understanding the `Chunk` Method

The Chunk method is available in System.Linq and allows you to split a collection into smaller chunks of a specified size.

Basic Usage of `Chunk`

var numbers = Enumerable.Range(1, 10);
var chunks = numbers.Chunk(3);

foreach (var chunk in chunks)
{
    Console.WriteLine(string.Join(", ", chunk));
}

Output:

Each chunk contains at most three items, except the last one, which contains the remaining items.

Using `Chunk` in EF Core for Batch Processing

Scenario: Bulk Processing Users in an EF Core Database

Imagine you have an application where you need to process thousands of user records in batches, instead of loading everything into memory at once.

Here’s how you can efficiently process users in chunks using EF Core and the Chunk method:

Step 1: Set Up the EF Core Context and Model

Assume we have a simple User entity:

public class User
{
    public int Id { get; set; }
    public string Name { get; set; }
    public bool IsActive { get; set; }
}

And our EF Core DbContext:

public class AppDbContext : DbContext
{
    public DbSet<User> Users { get; set; }

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        optionsBuilder.UseSqlServer("YourConnectionStringHere");
    }
}

Step 2: Fetch and Process Users in Chunks

Instead of loading all users into memory, we process them in batches:

using var context = new AppDbContext();

const int batchSize = 100;

// Fetch all active users and process them in chunks
var users = context.Users.Where(u => u.IsActive).AsEnumerable();

foreach (var chunk in users.Chunk(batchSize))
{
    ProcessUsers(chunk);
}

void ProcessUsers(IEnumerable<User> users)
{
    foreach (var user in users)
    {
        Console.WriteLine($"Processing User: {user.Name}");
    }
}

Why Use `AsEnumerable()`?

EF Core does not support Chunk directly in SQL queries because it's a LINQ method operating in-memory. We use .AsEnumerable() to retrieve only the necessary records from the database and then apply Chunk in-memory.

Alternative: Use `Skip` and `Take` for Large Datasets

For very large datasets, fetching everything into memory using AsEnumerable() might not be ideal. Instead, use Skip and Take to fetch records directly from the database in batches:

const int batchSize = 100;
int processed = 0;

using var context = new AppDbContext();

while (true)
{
    var users = context.Users
        .Where(u => u.IsActive)
        .OrderBy(u => u.Id)
        .Skip(processed)
        .Take(batchSize)
        .ToList();

    if (!users.Any())
        break;

    ProcessUsers(users);
    processed += users.Count;
}

Why Use `Skip` and `Take`?

Unlike Chunk, this method ensures that the database only retrieves a subset of records per query, reducing memory usage.

Conclusion

The Chunk method is a powerful tool introduced in .NET 6 that simplifies batch processing in-memory collections. When working with EF Core, you can use it for efficient processing, but for extremely large datasets, consider Skip and Take to avoid memory overload.

Key Takeaways:

✅ Use Chunk when dealing with moderately sized datasets that fit in memory.

✅ Use AsEnumerable().Chunk() when working with filtered EF Core queries.

✅ Prefer Skip & Take for very large datasets to avoid memory issues.

By leveraging these approaches, you can optimize performance and improve scalability in your EF Core applications.

What are your thoughts on using Chunk in EF Core? Have you used it in your projects? Let’s discuss in the comments!

The Ultimate Guide to Distributed Tracing and Its Importance in Distributed Systems

ahmedmohamedhussein — Tue, 11 Feb 2025 05:07:03 +0000

Introduction

In modern applications, microservices architecture has become the norm, making debugging and performance analysis more complex. This is where Distributed Tracing comes in—it helps track requests as they travel across different services and analyze bottlenecks or delays in the system.

What is Distributed Tracing?

Distributed Tracing is a technique that allows you to monitor requests as they flow through various microservices in a system. It collects traces for each request, providing a clear view of the execution path, including response times for each service and any performance bottlenecks.

How Does It Work?

When a request is received from the client, a Trace ID is assigned to it, and Span IDs are attached to each part of the process as the request moves between services. These details are then recorded in a Tracing Backend like Jaeger or Zipkin, allowing for in-depth performance analysis.

Key Components:

Trace – Represents the entire journey of a request through the system.
Span – A smaller unit within a trace, defining a specific operation inside a service.

3. Context Propagation – The process of passing the Trace ID and Span IDs between services to maintain the full tracing chain.

Why Do We Need Distributed Tracing?

Performance Analysis – Identifies bottlenecks within the system.
Error Detection – Makes it easier to trace the source of failures.
User Experience Improvement – Reduces response times by optimizing internal processes.

4. Data Flow Visibility – Provides a clear overview of how data moves between microservices.

Popular Tools for Distributed Tracing

Jaeger – An open-source tracing system that supports OpenTelemetry.
Zipkin – A simple tool for collecting and analyzing traces.

3. AWS X-Ray – Ideal for AWS-based applications, offering cloud monitoring capabilities.

How to Implement Distributed Tracing in .NET?

In .NET Core, you can use OpenTelemetry to add Distributed Tracing easily:

Install the required packages:

  dotnet add package OpenTelemetry.Extensions.Hosting
  dotnet add package OpenTelemetry.Instrumentation.AspNetCore
  dotnet add package OpenTelemetry.Instrumentation.Http
  dotnet add package OpenTelemetry.Exporter.Jaeger

Configure tracing in Program.cs:

  using OpenTelemetry.Trace;
  var builder = WebApplication.CreateBuilder(args);
  builder.Services.AddOpenTelemetryTracing(tracerProviderBuilder =>
  {
      tracerProviderBuilder
          .AddAspNetCoreInstrumentation()
          .AddHttpClientInstrumentation()
          .AddJaegerExporter(options =>
          {
              options.AgentHost = "localhost";
              options.AgentPort = 6831;
          });
  });
  var app = builder.Build();
  app.MapGet("/", () => "Hello, Tracing!");
  app.Run();

Conclusion

Distributed Tracing is a powerful tool for microservices-based systems, offering deep insights into performance and data flow. By using tools like Jaeger and OpenTelemetry, you can easily enhance system monitoring, ultimately improving performance and user experience.

Leverage Thread-Safe Efficiency: Unveiling the Power of ConcurrentDictionary in Real-Time Applications

ahmedmohamedhussein — Tue, 28 Jan 2025 04:23:10 +0000

Introduction

In today's fast-paced programming world, applications requiring real-time responsiveness and high performance in multi-threaded environments have become indispensable. Having the right tools to manage concurrency makes a significant difference. One such tool in C# is the ConcurrentDictionary. In this article, we'll explore the capabilities of ConcurrentDictionary and how it contributes to efficient concurrent operations with practical examples like SignalR-based systems.

Introduction to Dictionaries in 'C#'

A Dictionary in C# is a data structure that allows you to store key-value pairs. It's like a real-life dictionary where you look up a word (key) to find its meaning (value). Dictionaries are part of the System.Collections.Generic namespace and provide fast lookups, additions, and deletions, making them an essential tool in most C# applications.

However, when you have multiple threads accessing or modifying a dictionary simultaneously, you can run into issues such as race conditions or data corruption. To solve this, we use the ConcurrentDictionary.

What is a ConcurrentDictionary?

The ConcurrentDictionary is a thread-safe collection designed specifically for handling scenarios where multiple threads might read from or write to the dictionary simultaneously. It’s part of the System.Collections.Concurrent namespace.

Unlike a regular Dictionary, the ConcurrentDictionary uses internal locking mechanisms to ensure data integrity while maintaining high performance.

Key Features of ConcurrentDictionary

Thread Safety: You don’t need to manually add locks or other synchronization mechanisms.
High Performance: Optimized for scenarios with frequent read/write operations.
Specialized Methods: It provides methods like GetOrAdd and AddOrUpdate, which simplify operations in concurrent environments.

Example Code

Here’s how you can use a ConcurrentDictionary in C#:

using Microsoft.AspNetCore.SignalR;
using System.Collections.Concurrent;

public class ChatHub : Hub
{
    // Dictionary to store user connections
    private static ConcurrentDictionary<string, string> UserConnections = new ConcurrentDictionary<string, string>();

    // When a new user connects
    public override Task OnConnectedAsync()
    {
        string userId = Context.UserIdentifier; // Get user ID from the context
        string connectionId = Context.ConnectionId; // Get the connection ID

        // Add or update user connection
        UserConnections.AddOrUpdate(userId, connectionId, (key, oldValue) => connectionId);

        Console.WriteLine($"User Connected: {userId} with ConnectionId: {connectionId}");
        return base.OnConnectedAsync();
    }

    // When a user disconnects
    public override Task OnDisconnectedAsync(Exception exception)
    {
        string userId = Context.UserIdentifier;

        // Remove user connection
        UserConnections.TryRemove(userId, out _);

        Console.WriteLine($"User Disconnected: {userId}");
        return base.OnDisconnectedAsync(exception);
    }

    // Send message to a specific user
    public async Task SendMessageToUser(string userId, string message)
    {
        if (UserConnections.TryGetValue(userId, out string connectionId))
        {
            await Clients.Client(connectionId).SendAsync("ReceiveMessage", message);
        }
    }
}

Practical Applications

Caching: Store frequently accessed data.
Real-Time Tracking: Count or monitor resources in multi-threaded applications.
Logging: Maintain thread-safe logs.

The ConcurrentDictionary is a powerful tool when working in environments where thread safety and high performance are critical. It simplifies the complexity of managing data across multiple threads, making your code cleaner and more robust.

Ditch the 'If Else': Mastering Design Patterns for Cleaner, Scalable Code in C# (Arabic language)

ahmedmohamedhussein — Sat, 18 Jan 2025 09:23:40 +0000

في عالم تطوير البرمجيات، كتابة كود نظيف وقابل للصيانة أمر مهم جداً عشان تضمن إن التطبيقات بتاعتك تفضل فعالة وسهلة في التعديل على المدى الطويل. لكن من أكبر المشاكل اللي بتواجه المطورين هي الاستخدام المفرط لجمل if else. في البداية، الجمل دي ممكن تكون سريعة وسهلة، لكن مع الوقت، الكود بيتعقد بشكل رهيب وبيصعب فهمه وصيانته. في المقال ده هنستعرض مع بعض شوية أنماط تصميم (Design Patterns) هتساعدك تتجنب التعقيد اللي بيجي من جمل if else، وتخلي الكود بتاعك أنظف وأسهل في التطوير.

هنشرح خمس أنماط تصميم أساسية تقدر تستخدمها لتحسين كودك وتجنب "if else". كل نمط هنشرح فكرته بأمثلة واقعية بالكود باستخدام لغة C#.

1. Strategy Pattern: Choosing the Right Behavior at Runtime

الفكرة:
نمط الاستراتيجية بيسمح لك تحدد مجموعة من السلوكيات (أو الاستراتيجيات)، وتخزن كل واحدة منهم في كلاس منفصل، وبعد كده تختار الاستراتيجية المناسبة في وقت التشغيل. بدل ما تكتب if else طويل لاختيار السلوك الصحيح، تقدر تختار الاستراتيجية بسهولة.

مثال واقعي:
افترض عندك تطبيق دفع إلكتروني بيعرض عدة طرق دفع زي بطاقة ائتمان أو بايبال أو الدفع عند الاستلام. بدل ما تكتب if else لكل طريقة دفع، تقدر تستخدم Strategy Pattern لاختيار طريقة الدفع المناسبة في وقت التشغيل.

الكود:

public interface IPaymentStrategy
{
    void Pay(double amount);
}

public class CreditCardPayment : IPaymentStrategy
{
    public void Pay(double amount)
    {
        Console.WriteLine($"Paid {amount} using Credit Card");
    }
}

public class PayPalPayment : IPaymentStrategy
{
    public void Pay(double amount)
    {
        Console.WriteLine($"Paid {amount} using PayPal");
    }
}

public class PaymentContext
{
    private readonly IPaymentStrategy _paymentStrategy;

    public PaymentContext(IPaymentStrategy paymentStrategy)
    {
        _paymentStrategy = paymentStrategy;
    }

    public void ExecutePayment(double amount)
    {
        _paymentStrategy.Pay(amount);
    }
}

// الاستخدام
var paymentMethod = new PayPalPayment(); // دي ممكن تتغير حسب اختيار المستخدم
var paymentContext = new PaymentContext(paymentMethod);
paymentContext.ExecutePayment(100);

هنا بنستخدم Strategy Pattern عشان نحدد طريقة الدفع بدون الحاجة لجمل if else كثيرة.

2. Command Pattern: Encapsulating Requests as Objects

الفكرة:
نمط الأمر (Command Pattern) بيسمح لك بتغليف الطلبات (زي الأوامر أو العمليات) في كائنات. ده بيساعدك تفصل بين الشخص اللي بيطلب التنفيذ وبين الكود اللي بينفذ العمل، وبيخلي الكود أكثر مرونة وسهولة في التوسع.

مثال واقعي:
افترض إنك عندك نظام تحكم عن بُعد في البيت. ممكن يكون عندك أوامر زي "تشغيل الإضاءة"، "إيقاف المروحة"، وهكذا. بدل ما تكتب if else لكل أمر، تقدر تستخدم Command Pattern لتمثيل كل أمر ككائن منفصل.

الكود:

public interface ICommand
{
    void Execute();
}

public class TurnOnLightsCommand : ICommand
{
    public void Execute()
    {
        Console.WriteLine("Turning on the lights");
    }
}

public class TurnOffFanCommand : ICommand
{
    public void Execute()
    {
        Console.WriteLine("Turning off the fan");
    }
}

public class RemoteControl
{
    private ICommand _command;

    public void SetCommand(ICommand command)
    {
        _command = command;
    }

    public void PressButton()
    {
        _command.Execute();
    }
}

// الاستخدام
var remote = new RemoteControl();
var lightsOn = new TurnOnLightsCommand();
remote.SetCommand(lightsOn);
remote.PressButton();

var fanOff = new TurnOffFanCommand();
remote.SetCommand(fanOff);
remote.PressButton();

هنا، كل أمر بنمثله ككائن باستخدام Command Pattern، وده بيخلينا نتجنب تعقيد الكود بجمل if else.

3. State Pattern: Changing Behavior Based on State

الفكرة:
نمط الحالة (State Pattern) بيسمح للكائن إنه يغير سلوكه بناءً على حالته الداخلية. ده مفيد جدًا لو الكائن بيعمل حاجات مختلفة في حالات مختلفة، وبدل ما تكتب if else عشان تحدد الحالة، تقدر تستخدم النمط ده بشكل أسهل.

مثال واقعي:
افترض إن عندك مشغل فيديو بيكون في حالات مختلفة زي تشغيل، إيقاف مؤقت، وإيقاف. كل حالة ليها سلوك مختلف. بدل ما تكتب if else، تقدر تستخدم State Pattern لتغيير السلوك بناءً على الحالة.

الكود:

public interface IVideoPlayerState
{
    void Play();
    void Pause();
}

public class PlayingState : IVideoPlayerState
{
    public void Play()
    {
        Console.WriteLine("Video is already playing");
    }

    public void Pause()
    {
        Console.WriteLine("Pausing the video");
    }
}

public class PausedState : IVideoPlayerState
{
    public void Play()
    {
        Console.WriteLine("Resuming the video");
    }

    public void Pause()
    {
        Console.WriteLine("Video is already paused");
    }
}

public class VideoPlayer
{
    private IVideoPlayerState _state;

    public VideoPlayer()
    {
        _state = new PlayingState(); // الحالة الأولية
    }

    public void SetState(IVideoPlayerState state)
    {
        _state = state;
    }

    public void PressPlay()
    {
        _state.Play();
    }

    public void PressPause()
    {
        _state.Pause();
    }
}

// الاستخدام
var player = new VideoPlayer();
player.PressPause();

player.SetState(new PausedState());
player.PressPlay();

باستخدام State Pattern بنغير سلوك الفيديو بدون ما نستخدم if else.

4. Chain of Responsibility Pattern: Passing Requests Along a Chain of Handlers

الفكرة:
نمط سلسلة المسؤولية بيسمح لك بتمرير الطلبات عبر سلسلة من المعالجات. كل معالج بيقرر إذا كان هيحل المشكلة أو هيمررها للمعالج التالي. ده بيخلي الكود أكثر مرونة وبيساعد في تجنب if else طويل.

مثال واقعي:
افترض إنك عندك نظام دعم فني، وفيه مستويات مختلفة للدعم زي دعم المستوى 1، المستوى 2، و المستوى 3. كل مستوى ممكن يحل المشكلة أو يمررها للمستوى التالي.

الكود:

public abstract class SupportHandler
{
    protected SupportHandler _nextHandler;

    public void SetNextHandler(SupportHandler nextHandler)
    {
        _nextHandler = nextHandler;
    }

    public abstract void HandleRequest(string issue);
}

public class Level1Support : SupportHandler
{
    public override void HandleRequest(string issue)
    {
        if (issue == "simple issue")
        {
            Console.WriteLine("Level 1 solved the issue");
        }
        else
        {
            Console.WriteLine("Passing to Level 2");
            _nextHandler?.HandleRequest(issue);
        }
    }
}

public class Level2Support : SupportHandler
{
    public override void HandleRequest(string issue)
    {
        if (issue == "moderate issue")
        {
            Console.WriteLine("Level 2 solved the issue");
        }
        else
        {
            Console.WriteLine("Passing to Level 3");
            _nextHandler?.HandleRequest(issue);
        }
    }
}

public class Level3Support : SupportHandler
{
    public override void HandleRequest(string issue)
    {
        Console.WriteLine($"Level 3 solved the issue: {issue}");
    }
}

// الاستخدام
var level1 = new Level1Support();
var level2 = new Level2Support();
var level3 = new Level3Support();

level1.SetNextHandler(level2);
level2.SetNextHandler(level3);

level1.HandleRequest("simple issue");
level1.HandleRequest("moderate issue");
level1.HandleRequest("complex issue");

باستخدام Chain of Responsibility Pattern، بنمرر الطلبات عبر السلسلة بدون الحاجة لجمل if else.

5. Factory Pattern: Creating Objects Without Knowing Their Exact Class

الفكرة:
نمط المصنع بيسمح لك بإنشاء كائنات بدون ما تعرف بالضبط النوع اللي هتستخدمه. ده بيخلي عملية إنشاء الكائنات أكثر مرونة ويساعدك تتجنب كتابة if else لاختيار الكائن المناسب.

مثال واقعي:
افترض إنك عندك مصنع سيارات بينتج

أنواع مختلفة زي سيارات، دراجات نارية، و شاحنات. بدل ما تكتب if else عشان تختار النوع، تقدر تستخدم Factory Pattern.

الكود:

public abstract class Vehicle
{
    public abstract void Drive();
}

public class Car : Vehicle
{
    public override void Drive()
    {
        Console.WriteLine("Driving a car");
    }
}

public class Bike : Vehicle
{
    public override void Drive()
    {
        Console.WriteLine("Riding a bike");
    }
}

public class VehicleFactory
{
    public Vehicle CreateVehicle(string vehicleType)
    {
        if (vehicleType == "car")
            return new Car();
        else if (vehicleType == "bike")
            return new Bike();

        throw new ArgumentException("Invalid vehicle type");
    }
}

// الاستخدام
var factory = new VehicleFactory();
var car = factory.CreateVehicle("car");
car.Drive();

var bike = factory.CreateVehicle("bike");
bike.Drive();

في المثال ده، Factory Pattern بيساعدك تنشئ الكائنات بدون الحاجة لاستخدام if else.

الخلاصة

الأنماط دي زي Strategy, Command, State, Chain of Responsibility, و Factory هتخليك تكتب كود نظيف ومرن بعيد عن تعقيدات جمل if else. الأنماط دي مش بس بتسهل التوسعة في المستقبل، لكن كمان بتخلي الكود أكثر قابلية للصيانة. جرب الأنماط دي في مشاريعك الجاية عشان تحسن الكود وتجعل العمل أكثر فاعلية.

Ditch the 'if else': Mastering Design Patterns for Cleaner, Scalable Code

ahmedmohamedhussein — Sat, 18 Jan 2025 08:57:13 +0000

Introduction:

As a developer, you've probably faced the growing complexity of using too many if else statements in your code. While they work fine for simple conditions, when the number of conditions grows, your code quickly becomes hard to read, maintain, and scale. This is where Design Patterns come into play.

Design patterns are proven, reusable solutions to common design problems that software developers face. They allow you to write more flexible, maintainable, and scalable code by avoiding long chains of if else statements.

In this article, we’ll explore several design patterns that can help you avoid the messy if else logic and organize your code more effectively. Each design pattern will be illustrated with a real-world example to make the concept clear.

The Design Patterns We'll Cover:

Strategy Pattern
Command Pattern
State Pattern
Chain of Responsibility Pattern
Factory Pattern

1. Strategy Pattern: Choose Behavior Dynamically

The Strategy Pattern lets you define a family of algorithms, encapsulate each one, and make them interchangeable. This allows a client to choose the behavior it needs at runtime, without using a series of if else statements.

Real-World Example:

Imagine you're building a payment processing system where a user can choose from different payment methods: credit card, PayPal, or bank transfer. Instead of using if else statements to decide the payment method, you define each payment method as a separate strategy.

public interface IPaymentStrategy
{
    void Pay();
}

public class CreditCardPayment : IPaymentStrategy
{
    public void Pay() { Console.WriteLine("Paying with Credit Card"); }
}

public class PayPalPayment : IPaymentStrategy
{
    public void Pay() { Console.WriteLine("Paying with PayPal"); }
}

public class PaymentProcessor
{
    private readonly IPaymentStrategy _paymentStrategy;

    public PaymentProcessor(IPaymentStrategy paymentStrategy)
    {
        _paymentStrategy = paymentStrategy;
    }

    public void ProcessPayment() { _paymentStrategy.Pay(); }
}

class Program
{
    static void Main(string[] args)
    {
        var processor = new PaymentProcessor(new PayPalPayment());
        processor.ProcessPayment();  // Paying with PayPal
    }
}

Benefits:

Flexibility: You can easily add new payment methods without modifying the existing code.
Cleaner Code: Each payment method is encapsulated in its own class, making the code more readable.

2. Command Pattern: Encapsulate Requests as Objects

The Command Pattern allows you to encapsulate a request as an object, thereby separating the command from the object that executes it. This helps in reducing complex if else logic when handling various types of requests.

Real-World Example:

In a home automation system, you might have devices like lights, fans, and air conditioners, and you want to perform different actions like turning them on or off. Using the Command Pattern, each device action is encapsulated in its own command.

public interface ICommand
{
    void Execute();
}

public class TurnOnLightCommand : ICommand
{
    public void Execute() { Console.WriteLine("Turning on the light"); }
}

public class TurnOffFanCommand : ICommand
{
    public void Execute() { Console.WriteLine("Turning off the fan"); }
}

public class DeviceControl
{
    private readonly ICommand _command;

    public DeviceControl(ICommand command)
    {
        _command = command;
    }

    public void ExecuteCommand() { _command.Execute(); }
}

class Program
{
    static void Main(string[] args)
    {
        var control = new DeviceControl(new TurnOnLightCommand());
        control.ExecuteCommand();  // Turning on the light
    }
}

Benefits:

Separation of Concerns: The logic for the command is separated from the execution.
Extensibility: New commands can be added easily without modifying existing code.

3. State Pattern: Alter Behavior Based on State

The State Pattern is used when an object's behavior depends on its state. Instead of using if else to handle state transitions, each state is represented as a class and the object changes its behavior depending on the current state.

Real-World Example:

Imagine you’re designing a shopping cart where the order can be in various states: "Pending", "Shipped", and "Delivered". Each state has a different behavior, such as different methods of processing the order.

public interface IState
{
    void HandleRequest();
}

public class PendingState : IState
{
    public void HandleRequest() { Console.WriteLine("Processing pending order"); }
}

public class ShippedState : IState
{
    public void HandleRequest() { Console.WriteLine("Shipping the order"); }
}

public class DeliveredState : IState
{
    public void HandleRequest() { Console.WriteLine("Delivering the order"); }
}

public class OrderContext
{
    private IState _state;

    public OrderContext(IState state)
    {
        _state = state;
    }

    public void SetState(IState state) { _state = state; }

    public void ProcessRequest() { _state.HandleRequest(); }
}

class Program
{
    static void Main(string[] args)
    {
        var order = new OrderContext(new PendingState());
        order.ProcessRequest();  // Processing pending order

        order.SetState(new ShippedState());
        order.ProcessRequest();  // Shipping the order
    }
}

Benefits:

Behavioral Flexibility: The object’s behavior changes depending on its state.
Easier Maintenance: Each state is encapsulated in its own class, making it easier to manage and extend.

4. Chain of Responsibility Pattern: Pass Requests Along a Chain

The Chain of Responsibility Pattern allows a request to be passed along a chain of handlers. Each handler decides whether to process the request or pass it along to the next handler. This is particularly useful when handling different types of requests without a large if else block.

Real-World Example:

In a customer service system, you might have different departments handling specific types of requests, such as "Technical Support", "Billing", and "General Inquiry". Each department can handle the request or pass it to the next one in the chain.

public interface IRequestHandler
{
    void SetNextHandler(IRequestHandler handler);
    void HandleRequest(string request);
}

public class TechnicalSupportHandler : IRequestHandler
{
    private IRequestHandler _nextHandler;

    public void SetNextHandler(IRequestHandler handler) { _nextHandler = handler; }

    public void HandleRequest(string request)
    {
        if (request == "Technical Issue")
        {
            Console.WriteLine("Handling technical issue");
        }
        else if (_nextHandler != null)
        {
            _nextHandler.HandleRequest(request);
        }
        else
        {
            Console.WriteLine("Request not handled");
        }
    }
}

public class BillingHandler : IRequestHandler
{
    private IRequestHandler _nextHandler;

    public void SetNextHandler(IRequestHandler handler) { _nextHandler = handler; }

    public void HandleRequest(string request)
    {
        if (request == "Billing Issue")
        {
            Console.WriteLine("Handling billing issue");
        }
        else if (_nextHandler != null)
        {
            _nextHandler.HandleRequest(request);
        }
        else
        {
            Console.WriteLine("Request not handled");
        }
    }
}

class Program
{
    static void Main(string[] args)
    {
        IRequestHandler techSupport = new TechnicalSupportHandler();
        IRequestHandler billing = new BillingHandler();

        techSupport.SetNextHandler(billing);

        techSupport.HandleRequest("Technical Issue");  // Handling technical issue
        techSupport.HandleRequest("Billing Issue");  // Handling billing issue
        techSupport.HandleRequest("General Inquiry");  // Request not handled
    }
}

Benefits:

Decoupling: The request handling is decoupled from the request sender.
Extensibility: New handlers can be added to the chain without modifying the existing code.

5. Factory Pattern: Create Objects Based on Input

The Factory Pattern abstracts the creation of objects and lets you decide what type of object to create based on the input provided. This avoids the need for if else when choosing between different types of objects.

Real-World Example:

Imagine you're designing a car rental system, where customers can choose between different types of cars like "SUV", "Sedan", and "Truck". Instead of using if else to create the car objects, you use a factory to handle object creation.

public interface ICar
{
    void Drive();
}

public class Sedan : ICar
{
    public void Drive() { Console.WriteLine("Driving a Sedan car"); }
}

public class SUV : ICar
{
    public void Drive() { Console.WriteLine("Driving an SUV car"); }
}

public class CarFactory
{
    public ICar GetCar(string carType)
    {
        if (carType == "Sedan") return new Sedan();
        else if (carType == "SUV") return new SUV();
        else throw new ArgumentException("Unknown car type");
    }
}

class Program
{
    static void Main(string[] args)
    {
        var factory = new CarFactory();
        var car = factory.GetCar("SUV");
        car.D

rive();  // Driving an SUV car
    }
}

Benefits:

Simplified Object Creation: The factory handles the logic of creating objects, avoiding multiple if else statements.
Flexibility: You can easily modify or extend object creation logic without impacting other parts of the code.

Conclusion:

By using the right Design Patterns, you can avoid the messy, hard-to-maintain code created by excessive if else statements. Each pattern offers a different way to simplify decision-making in your code, making it more flexible, readable, and easier to extend in the future.

Whether you're handling different behaviors (Strategy), requests (Command), states (State), chains of responsibility (Chain of Responsibility), or object creation (Factory), these patterns give you clean and scalable solutions for real-world problems.

DEV Community: ahmedmohamedhussein

Enhancing SignalR with `HubFilter`: A Deep Dive into Custom Logic for Real-Time Applications*

What Is HubFilter in SignalR?

Why Use HubFilter?

Key Features of HubFilter

How Does HubFilter Work?

Example: Using HubFilter for Logging and Authorization

Step 1: Create a Custom HubFilter

Step 2: Register the HubFilter in Program.cs

Step 3: Implement SignalR Hub Methods

Practical Use Cases for HubFilter

HubFilter vs Middleware: What’s the Difference?

Conclusion

Aggressive Inline in .NET: Boosting Performance or Over-Optimization?

What is Aggressive Inline in .NET?

Why Should You Care About Aggressive Inline?

Potential Drawbacks of Aggressive Inline

When Should You Use Aggressive Inline?

Performance Example: Aggressive Inline in Action

Without Aggressive Inline:

With Aggressive Inline:

Benchmarking Code:

Expected Results:

Conclusion: Should You Use Aggressive Inline?

Mastering `SelectMany` in EF Core: SQL Equivalents and Best Practices

Introduction

Understanding SelectMany in EF Core

Basic Syntax

Why Use SelectMany?

Real-World Scenarios and SQL Equivalents

1. Retrieving All Orders from Customers

Scenario

EF Core Query

SQL Equivalent Using INNER JOIN

2. Filtering Data with CASE WHEN in SQL

Scenario

EF Core Query with SelectMany

SQL Equivalent Using CASE WHEN

3. Using SelectMany with Enums in EF Core

Scenario

Defining the Enum

Entity Model

EF Core Query with SelectMany and Conditional Mapping

SQL Equivalent Using CASE WHEN

Handling Nullability with SelectMany Safely

Example of a Potentially Unsafe Query

✅ Safe Approaches to Avoid Null Exceptions

1. Using ?? to Provide a Default Value

2. Filtering Out Null Collections Before SelectMany

Key Takeaways

Final Thoughts

Efficient Data Processing in EF Core with the `Chunk` Method in .NET 6+

Introduction

Understanding the Chunk Method

Basic Usage of Chunk

Output:

Using Chunk in EF Core for Batch Processing

Scenario: Bulk Processing Users in an EF Core Database

Step 1: Set Up the EF Core Context and Model

Step 2: Fetch and Process Users in Chunks

Why Use AsEnumerable()?

Alternative: Use Skip and Take for Large Datasets

Why Use Skip and Take?

Conclusion

Key Takeaways:

The Ultimate Guide to Distributed Tracing and Its Importance in Distributed Systems

Introduction

In modern applications, microservices architecture has become the norm, making debugging and performance analysis more complex. This is where Distributed Tracing comes in—it helps track requests as they travel across different services and analyze bottlenecks or delays in the system.

What is Distributed Tracing?

Distributed Tracing is a technique that allows you to monitor requests as they flow through various microservices in a system. It collects traces for each request, providing a clear view of the execution path, including response times for each service and any performance bottlenecks.

How Does It Work?

Key Components:

3. Context Propagation – The process of passing the Trace ID and Span IDs between services to maintain the full tracing chain.

Why Do We Need Distributed Tracing?

4. Data Flow Visibility – Provides a clear overview of how data moves between microservices.

Popular Tools for Distributed Tracing

3. AWS X-Ray – Ideal for AWS-based applications, offering cloud monitoring capabilities.

How to Implement Distributed Tracing in .NET?

Conclusion

Leverage Thread-Safe Efficiency: Unveiling the Power of ConcurrentDictionary in Real-Time Applications

What Is `HubFilter` in SignalR?

Why Use `HubFilter`?

Key Features of `HubFilter`

How Does `HubFilter` Work?

Example: Using `HubFilter` for Logging and Authorization

Step 1: Create a Custom `HubFilter`

Step 2: Register the `HubFilter` in `Program.cs`

Practical Use Cases for `HubFilter`

`HubFilter` vs Middleware: What’s the Difference?

Understanding `SelectMany` in EF Core

Why Use `SelectMany`?

SQL Equivalent Using `INNER JOIN`

2. Filtering Data with `CASE WHEN` in SQL

EF Core Query with `SelectMany`

SQL Equivalent Using `CASE WHEN`

3. Using `SelectMany` with Enums in EF Core

EF Core Query with `SelectMany` and Conditional Mapping

SQL Equivalent Using `CASE WHEN`

Handling Nullability with `SelectMany` Safely

1. Using `??` to Provide a Default Value

2. Filtering Out Null Collections Before `SelectMany`

Understanding the `Chunk` Method

Basic Usage of `Chunk`

Using `Chunk` in EF Core for Batch Processing

Why Use `AsEnumerable()`?

Alternative: Use `Skip` and `Take` for Large Datasets

Why Use `Skip` and `Take`?