Tech Journey With Gagan: 2025

Friday, August 1, 2025

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

Friday, July 18, 2025

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.

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);
    }
  }

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.

Tuesday, July 1, 2025

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'"

Thursday, June 26, 2025

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

Wednesday, June 11, 2025

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

Wednesday, May 28, 2025

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

Friday, May 2, 2025

🧹 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!

Saturday, March 29, 2025

🚀 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

Open SQL Server Management Studio (SSMS).
Right-click your source database → Tasks → Export Data-tier Application.
Choose "Save to local disk", then pick a file path and name (YourDatabase.bacpac).
Click Next through the wizard and generate the .bacpac file.

Step 2: Import into Target Server

In SSMS, right-click Databases → Import Data-tier Application.
Select the .bacpac file you exported.
Give the new database a name.
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.

Friday, March 14, 2025

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

Friday, March 7, 2025

😮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

📌 GitHub Repository Viewer

Git Hub Repo Link Here

Thursday, March 6, 2025

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:

Domain Layer → Contains core business logic and entities
Application Layer → Contains CQRS commands, queries, and interfaces
Infrastructure Layer → Handles database, repository pattern, and external integrations
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

📌 GitHub Repository Viewer

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.

Friday, August 1, 2025

commands

package.json

browser.test.ts

Friday, July 18, 2025

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

Step 1: Directive Code

Step 2: Template Code

Tuesday, July 1, 2025

Code Of Search Filter Pipe

Code Snippet

Thursday, June 26, 2025

Code Snippet

Code Snippet

Code Snippet

Code Snippet

Code Snippet

Wednesday, June 11, 2025

Code Snippet

Wednesday, May 28, 2025

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

child.component.ts

child.component.html

✅ Step 2: Create a Parent Component That Extends Child

parent.component.ts

parent.component.html

✅ Final Output

Friday, May 2, 2025

Saturday, March 29, 2025

Step 1: Export the Source Database

Step 2: Import into Target Server

🧩 Diagram

Why Use This?

Friday, March 14, 2025

Declare function

For run

Friday, March 7, 2025

📌 GitHub Repository Viewer

Thursday, March 6, 2025

Introduction

Why Use Onion Architecture?

Tech Stack

📌 Project Structure

Architecture Snippet

Model Snippet

✅ Command to Create a Student

Code Snippet

Code Snippet

Step 3: Implement Repository (Infrastructure Layer)

Code Snippet

Code Snippet

Code Snippet

Conclusion

🚀 Download Full ProjectGithub

📌 GitHub Repository Viewer

Tuesday, February 25, 2025

Code Snippet

Friday, February 14, 2025

Code Snippet

Discard the Last Commit

Move Changes to Correct Branch

Wednesday, February 12, 2025

Code Snippet

Code Snippet

Sunday, February 9, 2025

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 SemaphoreSlim in C#

What is a Semaphore?

What is SemaphoreSlim?

Why Use Semaphore and SemaphoreSlim?

Semaphore vs SemaphoreSlim - Key Differences 🚀

🚀 Download Full Project
Github