How to make Scheduler with Azure Queue using .net

I created Two methods one for schedule and log in db and second method is related to reschedule message.

1.

Schedule and Reschedule Message

public async Task ScheduleAndLogEmailAsync( NotificationRequest notificationRequest, ScheduleType type, DateTime triggerTime, DateTime? auctionTime, CancellationToken cancellationToken = default) { var MessageId = Guid.NewGuid(); var sender = _serviceBusClient.CreateSender(_serviceBusConfig.EmailNotificationQueue); notificationRequest.MessageId = MessageId.ToString(); var messageBody = JsonConvert.SerializeObject(notificationRequest); var serviceBusMessage = new ServiceBusMessage(messageBody); // Schedule the message and get its sequence number long sequenceNumber = 0; try { sequenceNumber = await sender.ScheduleMessageAsync(serviceBusMessage, triggerTime, cancellationToken); } catch (Exception ex) { //TODO console error log here; var e = ex; } // Log the scheduled message in DB using var scope = _serviceScopeFactory.CreateScope(); var dbContext = scope.ServiceProvider.GetRequiredService<DbContext>(); var scheduledMessage = new ScheduleMessage { TypeId = type, MessageId = MessageId, AzureSequenceQueueId = sequenceNumber.ToString(), TriggerTime = triggerTime, AuctionTime = auctionTime, IsProcessed = false, NotificationRequestJson = messageBody }; dbContext.ScheduleMessages.Add(scheduledMessage); await dbContext.SaveChangesAsync(cancellationToken); } public async Task ReschedulePendingMessagesAsync(ScheduleType scheduleType, TimeSpan newOffset, CancellationToken cancellationToken = default) { using var scope = _serviceScopeFactory.CreateScope(); var dbContext = scope.ServiceProvider.GetRequiredService<DbContext>(); var sender = _serviceBusClient.CreateSender(_serviceBusConfig.EmailNotificationQueue); var now = DateTime.UtcNow; var pendingMessages = await dbContext.ScheduleMessages .Where(x => x.TypeId == scheduleType && !x.IsProcessed && x.Time.HasValue && x.TriggerTime > now) .ToListAsync(cancellationToken); foreach (var message in pendingMessages) { var newTriggerTime = message.Time.Value - newOffset; // Skip if new trigger time is in the past if (newTriggerTime <= DateTime.UtcNow) continue; // Cancel old scheduled message if (long.TryParse(message.AzureSequenceQueueId, out long oldSequenceId)) { try { await sender.CancelScheduledMessageAsync(oldSequenceId, cancellationToken); } catch (Exception ex) { // If already executed or cannot be cancelled, continue silently Console.WriteLine($"[Reschedule] Failed to cancel scheduled message with SequenceId: {oldSequenceId}. Reason: {ex.Message}"); } } // Reschedule with new trigger time var serviceBusMessage = new ServiceBusMessage(message.NotificationRequestJson); var newSequenceId = await sender.ScheduleMessageAsync(serviceBusMessage, newTriggerTime, cancellationToken); // Update DB message.AzureSequenceQueueId = newSequenceId.ToString(); message.TriggerTime = newTriggerTime; } await dbContext.SaveChangesAsync(cancellationToken); }

2. While Process=>

Code Snippet

private async Task ProcessMessageAsync(ProcessMessageEventArgs args) { var sequenceId = args.Message.SequenceNumber.ToString(); if (!string.IsNullOrEmpty(notificationRequest.MessageId)) { // Convert string to Guid Guid messageIdGuid; if (Guid.TryParse(notificationRequest.MessageId, out messageIdGuid)) { var scheduledRecord = await dbContext.ScheduleMessages .FirstOrDefaultAsync(m => m.MessageId == messageIdGuid); if (scheduledRecord != null) { scheduledRecord.AzureSequenceQueueId = sequenceId; scheduledRecord.IsProcessed = true; dbContext.ScheduleMessages.Update(scheduledRecord); await dbContext.SaveChangesAsync(); } } else { Console.WriteLine("Invalid MessageId format."); } } } <br>

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

To test follow few steps:

Step 1. Install node
Step 2. create Folder and run these commands

commands

1. npm init -y 2. npm install playwright 3. npx playwright install 4. npx playwright open -b webkit

Step 3. update package.json 's scripts

package.json

"scripts": { "test:chrome": "npx playwright test --headed --browser=chromium", "test:firefox": "npx playwright test --headed --browser=firefox", "test:safari": "npx playwright test --headed --browser=webkit" }

Step 4. create Test folder in above folder and create file with name browser.test.ts and add below code

browser.test.ts

import { test } from '@playwright/test' test.use({ ignoreHTTPSErrors: true, }); test('test browser', async ({ page }) => { // point this to wherever you want await page.goto('http://localhost:4200/') // keep browser open await page.pause() })

Step 5. run command npm run test:safari

How to Highlight a Link of Side Nav When It Has Multiple Child Links in Angular

🔗 How to Highlight a Link When It Has Multiple Child Links in Angular

When building a sidebar in Angular, you might want to highlight a parent link when any of its child routes are active. Angular’s routerLinkActive only works for single routes — so here’s a quick 2-step solution using a custom directive.

1. Step 1: Create a custom directive
   Write a directive that checks the current URL against a list of child links and adds an active class if any match.

Step 1: Directive Code

import { Directive, ElementRef, Input, OnDestroy, OnInit, Renderer2 } from '@angular/core'; import { NavigationEnd, Router } from '@angular/router'; import { Subscription } from 'rxjs'; import { filter } from 'rxjs/operators'; @Directive({ selector: '[activeLinks]' }) export class ActiveLinksDirective implements OnInit, OnDestroy { @Input() activeLinks: string[] = []; @Input() activeClass = 'active'; private sub!: Subscription; constructor( private router: Router, private el: ElementRef, private renderer: Renderer2 ) {} ngOnInit(): void { // Subscribe to router events this.sub = this.router.events .pipe(filter(event => event instanceof NavigationEnd)) .subscribe((event) => { this.updateActiveClass(); }); // Initial check this.updateActiveClass(); } ngOnDestroy(): void { if (this.sub) { this.sub.unsubscribe(); } } private updateActiveClass(): void { if (!this.activeLinks || this.activeLinks.length === 0) { return; } const currentUrl = this.router.url; let isActive = false; // Check each active link for exact match for (const link of this.activeLinks) { // Exact match (including query parameters) if (currentUrl === link) { isActive = true; break; } // Decoded exact match (in case of encoded URLs) const decodedCurrentUrl = decodeURIComponent(currentUrl); const decodedLink = decodeURIComponent(link); if (decodedCurrentUrl === decodedLink) { isActive = true; break; } } // Apply or remove the active class if (isActive) { this.renderer.addClass(this.el.nativeElement, this.activeClass); } else { this.renderer.removeClass(this.el.nativeElement, this.activeClass); } }

2. Step 2: Use it in your template
   On your parent menu link, pass the list of child URLs to the directive.

Step 2: Template Code

<a mat-list-item routerLink="/dashboard/add-product" [activeLinks]="['/dashboard/add-product', '/dashboard/product?productType=1', '/dashboard/product?productType=2', '/dashboard/product?productType=3' ]" > <span class="material-symbols-outlined">calendar_add_on</span> <span *ngIf="sideBarOpen">Add Product</span> </a>

✅ Works with multiple child links, query parameters, and is easy to reuse.

✅ This blog is written by TechJourney with Gagan, sharing practical Angular tips for developers.

Create Search Functionality using 2 steps using pipe in Angular

To Implement Search Functionality without writing code in ts file

Step1: Create a Pipe using below code.

Code Of Search Filter Pipe

import { Pipe, PipeTransform } from '@angular/core'; @Pipe({ name: 'searchByFilter' }) export class SearchByFilterPipe implements PipeTransform { transform(items: any[], searchText: string, fieldName: string): any[] { if (!items) return []; if (!searchText) return items; searchText = searchText.toLowerCase(); return items.filter(item => item[fieldName]?.toLowerCase().includes(searchText)); } }

Step2: write below code where you want to implement search like in drop down.

Code Snippet

<div> <mat-label class="font-semibold">Select Company*</mat-label> <mat-form-field class="w-1/3"> <mat-select formControlName="companyId" (selectionChange)="onOrganizationChange($event.value)" placeholder="Select Company"> <mat-form-field > <input matInput placeholder="Search Company" #searchInput /> </mat-form-field> <mat-option *ngFor="let org of organizationsData | searchByFilter:searchInput.value:'organizationName'" [value]="org.organizationId"> {{ org.organizationName }} </mat-option> </mat-select> </mat-form-field> </div>

In above code we use just

<input matInput  placeholder="Search Company" #searchInput /><br> 
based on referece variable we took input and pass to pipe | searchByFilter:searchInput.value:'organizationName'"

🧩 Implementing a Lightweight Query Handler in .NET using GMediator fully free for commerical use

In modern .NET applications, maintaining clean architecture is critical — and that’s where the Mediator pattern shines. It decouples the request/response flow and promotes separation of concerns.

While libraries like MediatR are popular, sometimes you want something even lighter — with zero dependencies.

Enter: GMediator, a custom lightweight mediator implementation.

🚀 What We’ll Build
In this blog, we’ll create a simple GET API using GMediator that returns a list of products stored in an in-memory store — no database, no ORM — just the core pattern in action.
🧱 Step 1: Define the Product Model

Code Snippet

public class Product { public Guid Id { get; set; } = Guid.NewGuid(); public string Name { get; set; } public decimal Price { get; set; } }

💾 Step 2: Create an In-Memory Store

Code Snippet

public static class ProductStore { public static List<Product> Products { get; set; } = new() { new Product { Name = "Laptop", Price = 1200 }, new Product { Name = "Mouse", Price = 20 }, new Product { Name = "Keyboard", Price = 45 } }; }

📬 Step 3: Create the Query Request

Code Snippet

using GMediator.Interfaces; public class GetAllProducts : IRequest<List<Pro>> { } public class Pro { public Guid Id { get; set; } = Guid.NewGuid(); public string Name { get; set; } public decimal Price { get; set; } } 🧠 Step 4: Implement the Query Handler using GMediator.Interfaces; public class GetAllProductsHandler : IRequestHandler<GetAllProducts, List<Pro>> { public Task<List<Pro>> Handle(GetAllProducts request, CancellationToken cancellationToken) { var products = ProductStore.Products .Select(x => new Pro { Id = x.Id, Name = x.Name, Price = x.Price }) .ToList(); // Important: convert to List<Pro> return Task.FromResult(products); } }

🎯 Step 5: Create the Controller

Code Snippet

[ApiController] [Route("api/[controller]")] public class ProductsController : ControllerBase { private readonly IMediator _mediator; public ProductsController(IMediator mediator) { _mediator = mediator; } [HttpGet] public async Task<IActionResult> Get() { var products = await _mediator.Send(new GetAllProducts()); return Ok(products); } }

🧪 Step 6: Register GMediator in Program.cs

Code Snippet

builder.Services.AddGMediator(); // Register your custom GMediator

💡 Final Thoughts
GMediator is a great option for internal projects, low-dependency APIs, or learning the Mediator pattern hands-on.
You can extend this by adding Create, Update, Delete, or integrating with a real database like SQLite or SQL Server.

Building a Scalable .NET Backend Using Clean Architecture (With Optional Layers) in just an second

If you're building a new .NET backend, Clean Architecture is the best way to keep your code organized, scalable, and future-proof.
🧱 What is Clean Architecture?
It's a way to structure your project into layers:
Domain – core business models
Application – commands, queries, interfaces
Infrastructure – external services (API, logging, etc.)
Persistence – database (EF Core, SQL)
API – controllers
Tests – optional unit/integration tests
⚙️ Script-Based Setup
You can auto-generate this structure using a simple CMD script.
✅ You choose what to include:
Want Infrastructure? Type y
Need Tests? Type n
Want to skip Persistence? Type n




Steps To use:

1. use notepad save below code as setup-architecture.cmd

Code Snippet

@echo off SETLOCAL ENABLEEXTENSIONS :: Prompt for solution name set /p SOLUTION_NAME=Enter your solution name (e.g., ResumeAI.Optimizer): :: Prompt for optional layers set /p ADD_TESTS=Do you want to add a Tests project? (y/n): set /p ADD_PERSISTENCE=Do you want to add a Persistence layer? (y/n): set /p ADD_INFRASTRUCTURE=Do you want to add an Infrastructure layer? (y/n): :: Create Solution echo Creating solution... dotnet new sln -n %SOLUTION_NAME% :: Create Base Projects dotnet new webapi -n %SOLUTION_NAME%.API dotnet new classlib -n %SOLUTION_NAME%.Application dotnet new classlib -n %SOLUTION_NAME%.Domain :: Optional Projects if /i "%ADD_INFRASTRUCTURE%"=="y" ( dotnet new classlib -n %SOLUTION_NAME%.Infrastructure ) if /i "%ADD_PERSISTENCE%"=="y" ( dotnet new classlib -n %SOLUTION_NAME%.Persistence ) if /i "%ADD_TESTS%"=="y" ( dotnet new xunit -n %SOLUTION_NAME%.Tests ) :: Add Projects to Solution echo Adding projects to solution... dotnet sln add .\%SOLUTION_NAME%.API\%SOLUTION_NAME%.API.csproj dotnet sln add .\%SOLUTION_NAME%.Application\%SOLUTION_NAME%.Application.csproj dotnet sln add .\%SOLUTION_NAME%.Domain\%SOLUTION_NAME%.Domain.csproj if /i "%ADD_INFRASTRUCTURE%"=="y" ( dotnet sln add .\%SOLUTION_NAME%.Infrastructure\%SOLUTION_NAME%.Infrastructure.csproj ) if /i "%ADD_PERSISTENCE%"=="y" ( dotnet sln add .\%SOLUTION_NAME%.Persistence\%SOLUTION_NAME%.Persistence.csproj ) if /i "%ADD_TESTS%"=="y" ( dotnet sln add .\%SOLUTION_NAME%.Tests\%SOLUTION_NAME%.Tests.csproj ) :: Add Project References echo Adding project references... :: API references dotnet add .\%SOLUTION_NAME%.API\%SOLUTION_NAME%.API.csproj reference ^ .\%SOLUTION_NAME%.Application\%SOLUTION_NAME%.Application.csproj ^ .\%SOLUTION_NAME%.Domain\%SOLUTION_NAME%.Domain.csproj if /i "%ADD_INFRASTRUCTURE%"=="y" ( dotnet add .\%SOLUTION_NAME%.API\%SOLUTION_NAME%.API.csproj reference .\%SOLUTION_NAME%.Infrastructure\%SOLUTION_NAME%.Infrastructure.csproj ) if /i "%ADD_PERSISTENCE%"=="y" ( dotnet add .\%SOLUTION_NAME%.API\%SOLUTION_NAME%.API.csproj reference .\%SOLUTION_NAME%.Persistence\%SOLUTION_NAME%.Persistence.csproj ) :: Application references Domain dotnet add .\%SOLUTION_NAME%.Application\%SOLUTION_NAME%.Application.csproj reference .\%SOLUTION_NAME%.Domain\%SOLUTION_NAME%.Domain.csproj :: Infrastructure and Persistence references if /i "%ADD_INFRASTRUCTURE%"=="y" ( dotnet add .\%SOLUTION_NAME%.Infrastructure\%SOLUTION_NAME%.Infrastructure.csproj reference ^ .\%SOLUTION_NAME%.Application\%SOLUTION_NAME%.Application.csproj ^ .\%SOLUTION_NAME%.Domain\%SOLUTION_NAME%.Domain.csproj ) if /i "%ADD_PERSISTENCE%"=="y" ( dotnet add .\%SOLUTION_NAME%.Persistence\%SOLUTION_NAME%.Persistence.csproj reference ^ .\%SOLUTION_NAME%.Application\%SOLUTION_NAME%.Application.csproj ^ .\%SOLUTION_NAME%.Domain\%SOLUTION_NAME%.Domain.csproj ) :: Test references if /i "%ADD_TESTS%"=="y" ( dotnet add .\%SOLUTION_NAME%.Tests\%SOLUTION_NAME%.Tests.csproj reference ^ .\%SOLUTION_NAME%.Application\%SOLUTION_NAME%.Application.csproj ) echo. echo ✅ Clean Architecture setup completed for %SOLUTION_NAME%! echo. ENDLOCAL pause

2. save this file in respective folder where u want your project files
3. open cmd at this location and run this script by just type its name only that is setup-architecture.cmd

🔄 How to Extend Component Logic and Template in Angular (Simple Guide) => use of extends and ngTemplateOutlet

When building Angular apps, you might have common logic or reusable layouts across components. Instead of duplicating code, you can use extends in TypeScript and ng-template + ngTemplateOutlet in HTML.

Let’s walk through a simple example with 2 components where one extends logic and also injects custom HTML.

---

✅ Step 1: Create a Child Component (as base layout)

This is the reusable component that contains a common layout and logic.

child.component.ts

import { Component, Input, TemplateRef } from '@angular/core'; @Component({ selector: 'app-child', templateUrl: './child.component.html', }) export class ChildComponent { @Input() title: string = 'Base Title'; @Input() contentTemplate?: TemplateRef<any>; getTitle(): string { return this.title; } }

child.component.html

<div class="card"> <h2>{{ getTitle() }}</h2> <ng-container *ngIf="contentTemplate; else defaultContent"> <ng-container *ngTemplateOutlet="contentTemplate"></ng-container> </ng-container> <ng-template #defaultContent> <p>This is default content from ChildComponent.</p> </ng-template> </div>

• ✅ Layout and logic are defined here.
• ✅ Accepts external HTML through contentTemplate.

---

✅ Step 2: Create a Parent Component That Extends Child

This component inherits logic from ChildComponent and injects its own template content.

parent.component.ts

import { Component, TemplateRef, ViewChild } from '@angular/core'; import { ChildComponent } from './child.component'; @Component({ selector: 'app-parent', templateUrl: './parent.component.html', }) export class ParentComponent extends ChildComponent { @ViewChild('customHtml', { static: true }) customHtml!: TemplateRef<any>; override title = 'Title from ParentComponent'; ngOnInit() { this.contentTemplate = this.customHtml; } }

parent.component.html

<ng-template #customHtml> <p>This is custom HTML from <strong>ParentComponent</strong>.</p> </ng-template> <app-child [title]="title" [contentTemplate]="contentTemplate"></app-child>

• ✅ Inherits logic like title and getTitle() from ChildComponent.
• ✅ Injects its own content via ng-template.

---

✅ Final Output

• ChildComponent provides the reusable layout.
• ParentComponent injects dynamic HTML and extends the logic.
• This keeps your code DRY, clean, and scalable.

Use Cases: shared card layouts, reusable modal structures, dashboards, etc.

🧹 How to Remove SSR (Server Side Rendering) from an Angular 19 Project

Sometimes you add Angular SSR using @angular/ssr, but later want to return to a clean client-side app. Here's how to fully remove SSR (Server-Side Rendering) from your Angular project. 🔥 Step 1: Delete SSR Files Remove these files from the src/ folder: main.server.ts app.server.module.ts server.ts Any .server.ts files like: app.routes.server.ts app.config.server.ts 🛠️ Step 2: Update angular.json Inside "architect > build > options", remove the following: "server": "src/main.server.ts", "outputMode": "server", "ssr": { "entry": "src/server.ts" } Also remove the entire "server" block from angular.json if it exists. 🧾 Step 3: Clean Up TypeScript Config ❌ Delete: tsconfig.server.json ✅ Edit tsconfig.app.json like this: { "extends": "./tsconfig.json", "compilerOptions": { "outDir": "./out-tsc/app", "types": [] }, "files": [], "include": ["src/**/*.ts"] } 🧹 Step 4: Uninstall SSR Dependencies 🖥️ Run in Terminal / PowerShell / CMD: npm uninstall @angular/platform-server @nguniversal/express-engine express 🚀 Step 5: Clean & Serve PowerShell (Windows): Remove-Item -Recurse -Force node_modules, dist, .angular npm install ng serve Mac/Linux terminal: rm -rf node_modules dist .angular npm install ng serve ✅ Done! Your Angular app is now SSR-free and runs entirely with Client-Side Rendering (CSR) — faster dev, fewer headaches!

🚀 How to Copy a SQL Server Database Using a .bacpac File (Schema + Data) || Clone DB

#Clone Database 
Need to duplicate a full SQL Server database — including tables, views, stored procedures and data — without writing complex scripts?

Let me show you a simple, reliable method: Exporting and Importing a Data-tier Application (.bacpac). It’s perfect for backups, migrations, and creating dev/test clones.

---

 Step 1: Export the Source Database

1. Open SQL Server Management Studio (SSMS).

2. Right-click your source database → Tasks → Export Data-tier Application.

3. Choose "Save to local disk", then pick a file path and name (YourDatabase.bacpac).

4. Click Next through the wizard and generate the .bacpac file.

---

 Step 2: Import into Target Server

1. In SSMS, right-click Databases → Import Data-tier Application.

2. Select the .bacpac file you exported.

3. Give the new database a name.

4. Complete the wizard. 🎉 Done!

---

🧩 Diagram

[ Source DB ]
     |
     |  Export as .bacpac
     ↓
[ YourFile.bacpac ]
     |
     |  Import on Target Server
     ↓
[ New DB Clone ]

 Why Use This?
🔄 Migrate databases between environments (dev, staging, prod).
🛠️ Create dev/test clones without risking production.
📦 Archive snapshots with both schema and data.

Run ai model in python code with ollama

 First download and install ollama By this blog:
Tech Journey With Gagan: Run Any AI Model with ollama in windows

For Use AI model in python:
1. run this script
Note: this example for mistral ai model please change acording to your model

Declare function

import requests def ai_generate(prompt): response = requests.post('http://localhost:11434/api/generate', json={ 'model': 'mistral', 'prompt': prompt, 'stream': False }) return response.json().get('response', 'Error: No response from AI.')

For run

print(ai_generate("hello"))

it is work like this

Option 2: 

Run server explicitly 

1. Click on Quit Ollama

2. run server with ollama serve mean in cmd type "ollama serve".

Run Any AI Model with ollama in windows

Steps for install Any model with ollama in local : 
1. Download Olama  and install 

2.  open cmd and run "ollama" command to verify that ollama installed or not.

3. Install models  
    a. find your model and click on it.

   b. copy command and paste into terminal

                      press Enter now your model installed 

Note :Later on same command run your model will run automatically this time it is not downloading it just run 

How To work python with ollama: Run AI Model with Python

😮Create Task Scheduler app using AI Agent in just before 2 min 😮

Steps to create :
1. use Cline Agent extention in vs code.
2. use api of AI models like.
3. Give prompt to Cline.
4. Work automatically give you clean app.
Note: No need to create any file it will do automatically.

📌 GitHub Repository Viewer

Loading...

Git Hub Repo Link Here

Building a C# Web API with Onion Architecture, CQRS, MediatR & Quartz.NET CRON Jobs

 

Introduction

In modern C# applications, clean architecture plays a crucial role in maintaining scalability and maintainability. In this blog, we will build a C# Web API using Onion Architecture, CQRS, MediatR, and Quartz.NET for scheduling background jobs. This guide will walk you through structuring a project with best practices and SOLID principles.

Why Use Onion Architecture?

Onion Architecture provides a clear separation of concerns by organizing the application into different layers:

1. Domain Layer → Contains core business logic and entities

2. Application Layer → Contains CQRS commands, queries, and interfaces

3. Infrastructure Layer → Handles database, repository pattern, and external integrations

4. Presentation Layer (API Layer) → Exposes the application as an API

Tech Stack

• ASP.NET Core Web API for building RESTful APIs

• Entity Framework Core for database operations

• CQRS Pattern for separating read & write operations

• MediatR for in-memory messaging

• Quartz.NET for CRON Job scheduling

• SOLID Principles to make the application scalable
  
  

  📌 Project Structure

  Your project will be structured as follows:
  
  

  Architecture Snippet

  Solution 'OnionArchitectureCQRS' │── Onion.Application (Application Layer) │ ├── Features/ │ │ ├── Students/ │ │ │ ├── Commands/ │ │ │ │ ├── CreateStudentCommand.cs │ │ │ ├── Queries/ │ │ │ │ ├── GetAllStudentsQuery.cs │ │ │ ├── Handlers/ │ │ │ │ ├── CreateStudentCommandHandler.cs │ │ │ │ ├── GetAllStudentsQueryHandler.cs │ ├── Interfaces/ │ │ ├── IStudentRepository.cs │── Onion.Domain (Domain Layer) │ ├── Models/ │ │ ├── Student.cs │── Onion.Infrastructure (Infrastructure Layer) │ ├── Repositories/ │ │ ├── StudentRepository.cs │ ├── Scheduler/ │ │ ├── CronJobService.cs │── Onion.API (Presentation Layer - Web API) │ ├── Controllers/ │ │ ├── StudentsController.cs │ ├── Program.cs
  Step 1: Create the Student Model (Domain Layer)

  📍 Location: Onion.Domain/Models/Student.cs


  Model Snippet

  public class Student { public int Id { get; set; } public string Name { get; set; } public string Description { get; set; } public DateTime CreatedOn { get; set; } }
  Step 2: Create CQRS Commands & Queries (Application Layer)

  ✅ Command to Create a Student

  📍 Location: Onion.Application/Features/Students/Commands/CreateStudentCommand.cs


  Code Snippet

  using MediatR; public class CreateStudentCommand : IRequest<int> { public string Name { get; set; } public string Description { get; set; } }
  ✅ Query to Get All Students

  📍 Location: Onion.Application/Features/Students/Queries/GetAllStudentsQuery.cs



  Code Snippet

  using Onion.Domain.Models; using MediatR; using System.Collections.Generic; public class GetAllStudentsQuery : IRequest<List<Student>> { }

  Step 3: Implement Repository (Infrastructure Layer)

  📍 Location: Onion.Infrastructure/Repositories/StudentRepository.cs


  Code Snippet

  using Onion.Domain.Models; using Microsoft.EntityFrameworkCore; using System.Collections.Generic; using System.Threading.Tasks; public class StudentRepository : IStudentRepository { private readonly AppDbContext _context; public StudentRepository(AppDbContext context) { _context = context; } public async Task<int> AddStudentAsync(Student student) { _context.Students.Add(student); await _context.SaveChangesAsync(); return student.Id; } }
  Step 4: Implement CRON Job Using Quartz.NET

  📍 Location: Onion.Infrastructure/Scheduler/CronJobService.cs


  Code Snippet

  using Quartz; using System; using System.Threading; using System.Threading.Tasks; public class CronJobService : IHostedService { private readonly IScheduler _scheduler; public CronJobService(IScheduler scheduler) { _scheduler = scheduler; } public async Task StartAsync(CancellationToken cancellationToken) { await _scheduler.Start(); var job = JobBuilder.Create<AddStudentsJob>() .WithIdentity("AddStudentsJob") .Build(); var trigger = TriggerBuilder.Create() .WithIdentity("AddStudentsTrigger") .WithCronSchedule("*/30 * * * * ?") // ✅ Every 30 seconds .Build(); await _scheduler.ScheduleJob(job, trigger); } public async Task StopAsync(CancellationToken cancellationToken) { if (_scheduler != null) { await _scheduler.Shutdown(); } } }
  Step 5: Register Everything in Program.cs (API Layer)

  📍 Location: Onion.API/Program.cs


  Code Snippet

  builder.Services.AddMediatR(cfg => cfg.RegisterServicesFromAssembly(typeof(CreateStudentCommand).Assembly)); builder.Services.AddSingleton<ISchedulerFactory, StdSchedulerFactory>(); builder.Services.AddSingleton(provider => provider.GetRequiredService<ISchedulerFactory>().GetScheduler().Result); builder.Services.AddHostedService<CronJobService>();

  Conclusion

  By following this guide, you have successfully built a C# Web API with Onion Architecture, CQRS, MediatR, and Quartz.NET CRON Jobs.
  This approach ensures:
  ✅Scalability using Onion Architecture
  ✅Separation of Concerns (SoC)
  ✅Background Job Execution with Quartz.NET
  ✅Better Maintainability with CQRS & MediatR
  

  🚀 Download Full Project
  Github
  

🔥 "Building a C# Web API with Onion Architecture, CQRS, MediatR & Quartz.NET CRON Jobs Project" 🚀

Cover In this:
✅ Onion Architecture ka Overview
✅ CQRS Pattern + MediatR used
✅ Quartz.NET ke sath CRON Jobs
✅ Dependency Injection & SOLID
✅ GitHub :https://github.com/gaganmanakpuria/AddStudentCronJobWithOnionArchitectureWithSOLID

📌 GitHub Repository Viewer

Loading...

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. 🚀

🚀 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😊

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.😊

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?

1. To limit concurrent access to a resource
   Example: Controlling access to a database connection pool or an API rate limit.

2. To prevent race conditions
   Example: Ensuring that only a limited number of threads can modify a shared collection at a time.

3. 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

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 |

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

|

v

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

| 🔄 CLR LOADS ASSEMBLIES (Stored in RAM) |

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

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

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

|

v

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

| 💾 MEMORY ALLOCATION (RAM Usage) |

| - Stack: Stores method calls, local variables |

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

| - DI Container: Manages service lifetimes |

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

|

v

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

| ⚡ CACHING (Improves Speed, Uses RAM) |

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

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

| - Reduces Database Calls, Increases Performance |

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

|

v

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

| 🌐 HANDLING HTTP REQUESTS |

| - Kestrel/IIS Listens for Requests |

| - Middleware (Auth, Logging, Compression) |

| - Controllers Execute Business Logic |

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

|

v

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

| 🗑️ 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 |

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

|

v

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

| 🛢️ (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.