Tech Journey With Gagan: February 2025

Tuesday, February 25, 2025

Efficient Parallel Processing in .NET: Using Parallel.ForEach, IServiceScopeFactory, and ConcurrentBag

Parallel processing in .NET can significantly improve performance when dealing with large collections. However, when working with scoped dependencies and thread-safe collections, managing them properly is crucial. This blog explores how to use Parallel.ForEach, IServiceScopeFactory, and ConcurrentBag efficiently.

Why Use Parallel.ForEach?
Parallel.ForEach executes iterations in parallel, utilizing multiple CPU cores to improve performance. However, it does not automatically handle scoped dependencies from IServiceScopeFactory, which is essential when working with services like DbContext in ASP.NET Core.

Why IServiceScopeFactory?
Since DbContext and other scoped services should not be shared across multiple threads, using IServiceScopeFactory ensures each thread gets its own service scope.

Why ConcurrentBag?
When dealing with concurrent operations, ConcurrentBag is a thread-safe collection that allows multiple threads to add or retrieve items without conflicts.

Example:

Code Snippet

public class ParallelProcessingService
{
    private readonly IServiceScopeFactory _scopeFactory;

    public ParallelProcessingService(IServiceScopeFactory scopeFactory)
    {
        _scopeFactory = scopeFactory;
    }

    public async Task ProcessDataAsync(List<int> dataList)
    {
        var results = new ConcurrentBag<string>();

        await Task.Run(() =>
        {
            Parallel.ForEach(dataList, data =>
            {
                using var scope = _scopeFactory.CreateScope();
                var myService = scope.ServiceProvider.GetRequiredService<IMyService>();

                // Simulated processing
                string result = myService.ProcessData(data);
                results.Add(result);
            });
        });

        Console.WriteLine($"Processed {results.Count} items.");
    }
}

Key Takeaways
- Use Parallel.ForEach for performance gains when processing large collections.
- Utilize IServiceScopeFactory to create scoped services inside parallel loops.
- Store results in ConcurrentBag to ensure thread safety when collecting data.
This approach ensures efficient parallel execution while maintaining the integrity of scoped services in .NET. 🚀

Friday, February 14, 2025

🚀 Oops! Pushed to develop by Mistake? Here’s a Quick Fix! 🚀

🚀 Oops! Pushed to develop by Mistake? Here’s a Quick Fix! 🚀
We've all been there—accidentally pushing changes to the develop branch instead of a feature branch. Before you panic, there's a simple way to undo it gracefully using Git.

🔄 The Quick Fix
If you've mistakenly pushed your latest commit to develop, run the following command: 1️⃣ Save the commit/changes

Code Snippet

 git reset --soft HEAD~1

🔹 What does this do?
✅ Moves the latest commit to staged changes without deleting it.
✅ Allows you to fix things before re-committing or switching branches.

2️⃣ Discard the Commit Completely
If you want to undo the commit entirely (⚠️ This will remove all changes!):

Discard the Last Commit

 git reset --hard HEAD~1

🔄 Next Steps
Switch to the Correct Branch and Recommit
If you meant to push the changes to a different branch:

Move Changes to Correct Branch

 
  git checkout -b my-feature-branch 
  git commit -m "Moved changes to the correct branch"
  git push origin my-feature-branch

😊Like that we can revert our mistake😊

Wednesday, February 12, 2025

How to handle when code push accidently in deleted branch

Have you ever pushed your code, only to realize the branch was deleted? 😱 No worries—your work isn't lost! Git keeps a history of all commits, and you can easily recover your code.
🚀 Steps to Recover Your Deleted Branch
1️⃣ Check Your Git Log Even if a branch is deleted, the commits still exist. Run:

Code Snippet

git log --all --oneline

This will show a list of commit hashes with their messages.
2️⃣ Find Your Last Commit Look for the commit related to your deleted branch
3️⃣ Restore Your Branch Once you have the commit hash, recreate the branch:

Code Snippet

git checkout -b recovered-branch abc1234

Note : Instead of "abc1234" write "your hashcode" and "recovered-branch" write your "new branch name"

😊Now you can push your code in that branch and you can able to create PR.😊

Sunday, February 9, 2025

How to Implement In Memory Caching in .net

Introduction

In modern web applications, performance is key. Fetching data repeatedly from a database can lead to increased response times and higher server load. One effective way to optimize performance is by using in-memory caching to store frequently accessed data. In this blog, we will explore how to integrate IMemoryCache in an ASP.NET Core Web API project to efficiently handle CRUD operations for a Student entity.

What is In-Memory Caching?

In-memory caching is a mechanism that temporarily stores frequently accessed data in memory, reducing the need to retrieve it from the database each time. ASP.NET Core provides IMemoryCache, which is a simple, high-performance, and thread-safe cache.

Setting Up the Project

To demonstrate in-memory caching, let’s build an ASP.NET Core Web API with a StudentController that performs CRUD operations using Entity Framework Core.

1. Install Required Dependencies

Ensure you have the necessary NuGet packages installed in your ASP.NET Core project:

2. Add Model and AppDb Context file

Student Model

namespace InMemoryCachePOC.Models
{
    public class Student
    {
        public int Id { get; set; }

        public string Name { get; set; }
        
        public string Department { get; set; }

        public string City { get; set; }
    }
}

AppDb Context File

using Microsoft.EntityFrameworkCore;

namespace InMemoryCachePOC.Models
{
    // 
    public class AppDb: DbContext
    {
        public AppDb( DbContextOptions<AppDb> options) : base(options)
        {
                
        }

        public DbSet<Student> Students { get; set; }
    }
}

3. Add in Appsettings.json just below of AllowedHosts by put comma

Connection String

  "ConnectionStrings": {
    "DefaultConnection": "Server=.;Database=InMemoryCachePOC;Trusted_Connection=True;TrustServerCertificate=True;"
  }

4. Add Settings

Program.cs

builder.Services.AddMemoryCache();
    
builder.Services.AddDbContext<AppDb>(o=>o.UseSqlServer(builder.Configuration.GetConnectionString("DefaultConnection")));

5. Add-Migration and Update-database run two commands

6. add Controller with name Student

Student Controller

using InMemoryCachePOC.Models;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Caching.Memory;

namespace InMemoryCachePOC.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class StudentController : ControllerBase
    {
        private readonly AppDb _context;
        private readonly IMemoryCache _cache;
        private readonly ILogger<StudentController> _logger;
        private readonly SemaphoreSlim _semaphore = new SemaphoreSlim(1, 1);
        private const string CacheKey = "students_cache"; // Cache Key Constant

        public StudentController(AppDb context, IMemoryCache cache, ILogger<StudentController> logger)
        {
            _context = context;
            _cache = cache;
            _logger = logger;
        }

        /// <summary>
        /// Fetch all students with caching
        /// </summary>
        [HttpGet]
        public async Task<IActionResult> GetAll()
        {
            if (_cache.TryGetValue(CacheKey, out List<Student>? students))
            {
                _logger.LogInformation("Data retrieved from cache.");
                return Ok(students);
            }

            try
            {
                await _semaphore.WaitAsync();

                // Check cache again after acquiring lock to prevent multiple DB calls
                if (_cache.TryGetValue(CacheKey, out students))
                {
                    _logger.LogInformation("Data retrieved from cache after acquiring lock.");
                    return Ok(students);
                }

                _logger.LogInformation("Fetching data from database.");
                students = await _context.Students.AsNoTracking().ToListAsync();

                // Set cache options
                var cacheOptions = new MemoryCacheEntryOptions()
                    .SetSlidingExpiration(TimeSpan.FromMinutes(10))
                    .SetAbsoluteExpiration(TimeSpan.FromHours(1))
                    .SetPriority(CacheItemPriority.High);

                _cache.Set(CacheKey, students, cacheOptions);
                _logger.LogInformation("Data cached successfully.");
            }
            finally
            {
                _semaphore.Release();
            }

            return Ok(students);
        }

        /// <summary>
        /// Fetch student by ID with caching
        /// </summary>
        [HttpGet("{id}")]
        public async Task<IActionResult> GetById(int id)
        {
            var students = await GetCachedStudents();
            var student = students.FirstOrDefault(s => s.Id == id);

            if (student == null)
            {
                _logger.LogWarning($"Student with ID {id} not found.");
                return NotFound("Student not found.");
            }

            return Ok(student);
        }

        /// <summary>
        /// Create a new student and update cache
        /// </summary>
        [HttpPost]
        public async Task<IActionResult> Create([FromBody] Student student)
        {
            if (student == null) return BadRequest("Invalid data.");

            await _context.Students.AddAsync(student);
            await _context.SaveChangesAsync();
            _logger.LogInformation($"Student {student.Name} added successfully.");

            // Update cache
            await UpdateCache();
            return CreatedAtAction(nameof(GetById), new { id = student.Id }, student);
        }

        /// <summary>
        /// Update an existing student and refresh cache
        /// </summary>
        [HttpPut("{id}")]
        public async Task<IActionResult> Update(int id, [FromBody] Student student)
        {
            if (student == null) return BadRequest("Invalid data.");

            var existingStudent = await _context.Students.FindAsync(id);
            if (existingStudent == null) return NotFound("Student not found.");

            existingStudent.Name = student.Name;
            existingStudent.Department = student.Department;
            existingStudent.City = student.City;

            _context.Students.Update(existingStudent);
            await _context.SaveChangesAsync();
            _logger.LogInformation($"Student with ID {id} updated successfully.");

            // Update cache
            await UpdateCache();
            return Ok(existingStudent);
        }

        /// <summary>
        /// Delete a student and refresh cache
        /// </summary>
        [HttpDelete("{id}")]
        public async Task<IActionResult> Delete(int id)
        {
            var student = await _context.Students.FindAsync(id);
            if (student == null) return NotFound("Student not found.");

            _context.Students.Remove(student);
            await _context.SaveChangesAsync();
            _logger.LogInformation($"Student with ID {id} deleted successfully.");

            // Update cache
            await UpdateCache();
            return NoContent();
        }

        /// <summary>
        /// Get cached students
        /// </summary>
        private async Task<List<Student>> GetCachedStudents()
        {
            if (_cache.TryGetValue(CacheKey, out List<Student>? students))
            {
                return students!;
            }

            students = await _context.Students.AsNoTracking().ToListAsync();

            var cacheOptions = new MemoryCacheEntryOptions()
                .SetSlidingExpiration(TimeSpan.FromMinutes(10))// it expires after 10 minutes of inactivity 
                .SetAbsoluteExpiration(TimeSpan.FromHours(1))// it expires after 1 hour
                .SetPriority(CacheItemPriority.High);

            _cache.Set(CacheKey, students, cacheOptions);
            return students;
        }

        /// <summary>
        /// Update cache after any CRUD operation
        /// </summary>
        private async Task UpdateCache()
        {
            _cache.Remove(CacheKey);
            var students = await _context.Students.AsNoTracking().ToListAsync();
            var cacheOptions = new MemoryCacheEntryOptions()
                .SetSlidingExpiration(TimeSpan.FromMinutes(10))
                .SetAbsoluteExpiration(TimeSpan.FromHours(1))
                .SetPriority(CacheItemPriority.High);

            _cache.Set(CacheKey, students, cacheOptions);
            _logger.LogInformation("Cache updated after CRUD operation.");
        }
    }
}

6. SetSlidingExpiration: refreseh if no activity in 10 min
SetAbsoluteExpiration : always refresh after 1 hour

Expalin memory Cache options

var cacheOptions = new MemoryCacheEntryOptions()
                .SetSlidingExpiration(TimeSpan.FromMinutes(10)) // refreseh if no activity in 10 min
                .SetAbsoluteExpiration(TimeSpan.FromHours(1)) // always refresh after 1 hour
                .SetPriority(CacheItemPriority.High);

Note: In this i used semaphoreslim for single process optimised the in memory cache. I am updating the in memory cache when add and update and delete. also this approch is helpfull for single server or small level applications. for multiserver or high level application we should go with distributed cache technique like redis so our ram not effected to much.

Clone this poc:InMemoryCachePOC

Semaphore Vs Semaphore Slim

Semaphore vs SemaphoreSlim in C#

What is a Semaphore?

A Semaphore is a synchronization primitive used to control access to a shared resource by multiple threads. It works by maintaining a count that represents the number of available slots for accessing the resource. When a thread enters, the count decreases, and when it leaves, the count increases.

What is SemaphoreSlim?

SemaphoreSlim is a lightweight, managed implementation of Semaphore, introduced in .NET Framework 4. It provides better performance and is optimized for cases where a semaphore is needed within a single process.

Why Use Semaphore and SemaphoreSlim?

To limit concurrent access to a resource
Example: Controlling access to a database connection pool or an API rate limit.
To prevent race conditions
Example: Ensuring that only a limited number of threads can modify a shared collection at a time.

To manage multi-threaded access in an efficient way
Example: Restricting simultaneous file writes to avoid corruption.

Semaphore vs SemaphoreSlim - Key Differences 🚀

Feature	Semaphore 🏢	SemaphoreSlim 🚀
Scope	Works across multiple processes	Works within a single process
Implementation	Uses OS-level (kernel-based) synchronization	Uses user-mode synchronization (managed by .NET)
Performance	Slower due to kernel transitions	Faster as it avoids kernel overhead
Async Support	❌ Does not support async/await	✅ Supports async/await for better responsiveness
Use Case	Inter-process synchronization (e.g., shared system resources)	Within-process synchronization (e.g., limiting concurrent API calls, database access)
Blocking vs Non-Blocking	Blocks threads while waiting	Uses async wait, avoiding thread blocking
Wait Handle Support	✅ Supports `WaitOne()`, `WaitAll()`	❌ Does not support `WaitHandle` methods

When to Use?

✅ Use Semaphore when you need to synchronize across different applications (e.g., OS-wide named semaphores).
✅ Use Semaphore Slim when you need a lightweight, high-performance synchronization within a single process, especially with async/await.

Note: semaphore slim I used in in memory caching for single process so save dB calls and we give users to fast response.
while semaphore is used for allow or control to multiple processes like if we have to run only two than we can control with that
InMemory caching: In Memory Caching in .Net

Wednesday, February 5, 2025

How .NET API Uses RAM?

✅ Application Start: Code and dependencies are loaded into RAM.

✅ CLR Loads Assemblies: JIT compiles and stores DLLs in RAM.

✅ Memory Allocation: Stack (method calls) & Heap (objects, DI, cache).

✅ Caching (Boosts Speed!): Frequently accessed data is stored in RAM.

✅ Handling HTTP Requests: Kestrel/IIS processes requests in memory.

✅ Garbage Collection: Frees up unused objects, optimizing RAM.

✅ (Optional) In-Memory Database: Uses RAM for high-speed transactions.

🔹 Complete Process in a Simple Diagram!

+----------------------------------------------------+

| 🟢 APPLICATION START (Loaded in RAM) |

| - Run API: (dotnet run / IIS / Kestrel) |

| - .NET Runtime (CLR) loads code into RAM |

+----------------------------------------------------+

| 🔄 CLR LOADS ASSEMBLIES (Stored in RAM) |

| - JIT (Just-In-Time) compiles code |

| - Dependencies & DLLs loaded into memory (RAM) |

+----------------------------------------------------+

| 💾 MEMORY ALLOCATION (RAM Usage) |

| - Stack: Stores method calls, local variables |

| - Heap: Stores objects, services, cache data |

| - DI Container: Manages service lifetimes |

+----------------------------------------------------+

| ⚡ CACHING (Improves Speed, Uses RAM) |

| - In-Memory Cache (MemoryCache, Singleton) |

| - Distributed Cache (Redis, NCache) (Optional) |

| - Reduces Database Calls, Increases Performance |

+----------------------------------------------------+

| 🌐 HANDLING HTTP REQUESTS |

| - Kestrel/IIS Listens for Requests |

| - Middleware (Auth, Logging, Compression) |

| - Controllers Execute Business Logic |

+----------------------------------------------------+

| 🗑️ GARBAGE COLLECTION (Frees RAM) |

| - Gen 0: Short-lived objects (frequent cleanup) |

| - Gen 1 & 2: Long-lived objects (less cleanup) |

| - Optimizes RAM usage, prevents memory leaks |

+----------------------------------------------------+

| 🛢️ (OPTIONAL) IN-MEMORY DATABASE |

| - EF Core In-Memory / SQLite (Stored in RAM) |

| - Fast Reads/Writes, No Disk I/O |

+----------------------------------------------------+

💡 Why This Matters?

🔹 Faster performance with in-memory caching.

🔹 Reduced database calls, improving scalability.

🔹 Optimized RAM usage via Garbage Collection.

Saturday, February 1, 2025

Struct Vs Union in c#

In C#, both struct and union are used to create value types, but they are different significantly in memory allocation and usage. ________________________________________

1. struct in C# A struct in C# is a value type that contains multiple fields, where each field gets its own memory space. Structs are useful for representing small data structures that do not require reference semantics.

Memory Allocation in struct Each field inside the struct has its own memory. The size of a struct is the sum of its field sizes (considering padding and alignment).

Example of struct

Code Snippet

struct Employee
{
    public int Id;       // 4 bytes
    public double Salary; // 8 bytes
}

class Program
{
    static void Main()
    {
        Employee emp;
        emp.Id = 101;
        emp.Salary = 50000.50;

        Console.WriteLine($"Id: {emp.Id}, Salary: {emp.Salary}");
    }
}

Memory Layout

Field Type Size Id int 4 bytes Salary double 8 bytes Total 12 bytes (or more with padding)

When to Use struct?

✔️ Small, lightweight data structures

✔️ When no need for inheritance

✔️ When working with performance-sensitive applications (to avoid heap allocations) ________________________________________

2. union in C# (Using StructLayout and FieldOffset) C# does not have a direct union like C/C++, but you can create a union-like structure using [StructLayout(LayoutKind.Explicit)] and [FieldOffset] attributes.

How Does a union Work?

• All fields share the same memory.

• The size of the union is equal to the size of the largest field.

• Writing to one field overwrites the other. Example of union in C#

Code Snippet

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Explicit)]
struct MyUnion
{
    [FieldOffset(0)]
    public int intValue;  // 4 bytes

    [FieldOffset(0)]
    public float floatValue; // 4 bytes (overlapping memory with intValue)

    [FieldOffset(0)]
    public char charValue;  // 2 bytes (overlapping with both)
}

class Program
{
    static void Main()
    {
        MyUnion u;
        u.intValue = 100;
        Console.WriteLine($"intValue: {u.intValue}, floatValue: {u.floatValue}, charValue: {u.charValue}");

        u.floatValue = 9.5f;
        Console.WriteLine($"intValue: {u.intValue}, floatValue: {u.floatValue}, charValue: {u.charValue}");

        u.charValue = 'A';
        Console.WriteLine($"intValue: {u.intValue}, floatValue: {u.floatValue}, charValue: {u.charValue}");
    }
}

Output (may vary due to memory representation)

intValue: 100, floatValue: 1.401298E-43, charValue: d

intValue: 1091567616, floatValue: 9.5, charValue: e

intValue: 65, floatValue: 9.10844E-44, charValue: A

   Why does this happen?
·        When intValue = 100, the same memory is interpreted as a float and a char.
·        When floatValue = 9.5f, the same memory gets rewritten.
·        When charValue = 'A', it affects the integer and float values.

Memory Layout of a union

Field	Type	Size (bytes)
intValue	int	4
floatValue	float	4 (shared)
charValue	char	2 (shared within 4 bytes)
Total Memory Used	4 bytes (size of the largest field)

When to Use a union?
✔️ Memory-efficient storage (especially useful for low-level programming)
✔️ Interop with unmanaged C/C++ code (e.g., working with hardware, binary data)
✔️ Working with bitwise operations
🚨 Caution: Accessing a different field than the last written one may produce undefined behavior.

🚀 Key Differences Between struct and union in C#

Feature	struct	union (via FieldOffset)
Memory Allocation	Each field gets separate memory	All fields share the same memory
Size	Sum of all field sizes (considering alignment)	Size of the largest field
Usage	When fields hold independent values	When only one field is used at a time
Performance	Faster but consumes more memory	Memory-efficient but risky
Common Use Cases	Small objects, lightweight data storage	Interoperability with unmanaged code, memory optimization

Conclusion
· Use struct when you need a lightweight data type where each field has its own storage.
· Use union (via StructLayout + FieldOffset) when you need memory-efficient structures where fields share the same memory.

Tech Journey With Gagan

Tuesday, February 25, 2025

Efficient Parallel Processing in .NET: Using Parallel.ForEach, IServiceScopeFactory, and ConcurrentBag

Code Snippet

Friday, February 14, 2025

🚀 Oops! Pushed to develop by Mistake? Here’s a Quick Fix! 🚀

Code Snippet

Discard the Last Commit

Move Changes to Correct Branch

Wednesday, February 12, 2025

How to handle when code push accidently in deleted branch

Code Snippet

Code Snippet

Sunday, February 9, 2025

How to Implement In Memory Caching in .net

Introduction

What is In-Memory Caching?

Setting Up the Project

1. Install Required Dependencies

Student Model

AppDb Context File

Connection String

Program.cs

Student Controller

Expalin memory Cache options

Semaphore Vs Semaphore Slim

Semaphore vs SemaphoreSlim in C#

What is a Semaphore?

What is SemaphoreSlim?

Why Use Semaphore and SemaphoreSlim?

Semaphore vs SemaphoreSlim - Key Differences 🚀

When to Use?

Wednesday, February 5, 2025

How .NET API Uses RAM?

Saturday, February 1, 2025

Struct Vs Union in c#

Code Snippet

Code Snippet

How to Do Cross-Browser Testing on Windows — Including Safari via Playwright

Labels