Forem: Hardik Jariwala

🚀 Redis Caching in .NET (Memurai on Windows + Docker Recommended)

Hardik Jariwala — Tue, 24 Mar 2026 16:55:43 +0000

Caching is essential for improving performance and scalability in modern applications. This guide shows how to use Redis caching in .NET, including how to run it on Windows using Memurai (without Docker).

🔴 What is Redis?

Redis is an in-memory data store used to cache frequently accessed data, making applications faster by reducing database calls. It serves data instantly on a cache hit and stores new data on a cache miss, improving performance and scalability.

Why use it?
⚡ Fast (RAM-based)
📉 Reduces DB load
🌍 Works across multiple servers
⏱ Supports expiration (TTL)

🧠 How It Works (Cache Aside Pattern)

Request → Check Cache → Return (if found) 
                     ↓ 
                  DB → Save in Cache → Return

📦 Required Packages (.NET)

dotnet add package Microsoft.Extensions.Caching.StackExchangeRedis 
dotnet add package Newtonsoft.Json

⚙️ Redis Configuration

builder.Services.AddStackExchangeRedisCache(options => 
{ 
     options.Configuration = "localhost:6379"; 
     options.InstanceName =  "MyApp:";
});

🔥 Caching Implementation (Service Layer)

public class ProductService 
{ 
     private readonly IDistributedCache _cache; 
     public ProductService(IDistributedCache cache) 
     { 
          _cache = cache; 
     } 
     public async Task<List<Product>> GetProducts() 
     { 
         string cacheKey = "product_list"; 
         var cacheData = await _cache.GetStringAsync(cacheKey);
         if (cacheData != null) 
         { 
             Console.WriteLine("Data from Redis");
             return JsonConvert.DeserializeObject<List<Product>>   
(cacheData);
         } 
         Console.WriteLine("Data from DB"); 
         var data = FakeDb.GetProducts(); // Replace with real DB 
         var options = new DistributedCacheEntryOptions 
         { 
             AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(5) 
         }; 
         await _cache.SetStringAsync( cacheKey, JsonConvert.SerializeObject(data), options ); 
          return data; 
     } 
}

Run Redis WITHOUT Docker (Windows)

Use Memurai:

Install Memurai
Start service:

Win + R → services.msc → Start "Memurai"

Verify:

memurai-cli ping
Output: `PONG`

Runs on:localhost:6379

🐳 Recommended: Use Docker

Docker (best for production)

docker run -d -p 6379:6379 redis

🔄 Cache Invalidation (Important)

Remove cache manually:

await _cache.RemoveAsync("product_list");

Use expiration:

AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(5)

Clear all cache (dev):

memurai-cli flushall

🧠 Best Practices With...

Always set expiry
Use meaningful keys (product_101)
Invalidate cache on update/delete
Avoid caching sensitive data

📡 Real-Time Communication with SignalR in ASP.NET Core Complete Setup Guide

Hardik Jariwala — Tue, 27 May 2025 18:06:14 +0000

Want to build a real-time chat app or push live notifications? In this blog, I’ll walk you through setting up SignalR from scratch using ASP.NET Core and a .NET console client. Perfect for beginners or those revisiting SignalR.

🔧 Step 1: Create the SignalR Server Project

Create an ASP.NET Core Web API project and add package

dotnet add package Microsoft.AspNetCore.SignalR

🧠 Step 2: Create a SignalR Hub

Create a new class ChatHub.cs inside the project:

using Microsoft.AspNetCore.SignalR;

public class ChatHub : Hub
{
    public async Task SendMessage(string user, string message)
    {
        await Clients.All.SendAsync("ReceiveMessage", user, message);
    }
}

🌐 Step 3: Configure the SignalR Hub in `Program.cs`

Update Program.cs to register the SignalR service and endpoint:

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddSignalR();
builder.Services.AddControllers();
var app = builder.Build();

app.UseHttpsRedirection();
app.UseAuthorization();
app.MapControllers();

// Add this line to map the hub
app.MapHub<ChatHub>("/chatHub");

app.Run();

🧪 Step 4: Run the Server

dotnet run

📥 Step 5: Create a .NET Console Client

Create a new console app and add SignalR client package

dotnet add package Microsoft.AspNetCore.SignalR.Client

🧑‍💻 Step 6: Build the Client Logic

Replace Program.cs content with:

using Microsoft.AspNetCore.SignalR.Client;

var connection = new HubConnectionBuilder()
    .WithUrl("https://<your localhost>/chatHub") your server
    .WithAutomaticReconnect()
    .Build();

// Receive messages
connection.On<string, string>("ReceiveMessage", (user, message) =>
{
    Console.WriteLine($"{user}: {message}");
});

try
{
    await connection.StartAsync();
    Console.WriteLine("Connected to SignalR Hub.");
}
catch (Exception ex)
{
    Console.WriteLine($"Connection failed: {ex.Message}");
    return;
}

// Sending messages
while (true)
{
    Console.Write("Enter your name: ");
    var user = Console.ReadLine();

    Console.Write("Enter your message: ");
    var message = Console.ReadLine();

    try
    {
        await connection.InvokeAsync("SendMessage", user, message);
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Error sending message: {ex.Message}");
    }
}

✅ Step 7: Test the Communication

Run the server project:

cd ../SignalRServer
dotnet run

Run the client project in a new terminal:

cd ../SignalRClient
dotnet run

Type your name and message in the console. If everything is set up correctly, you’ll see the message echoed back from the hub.

🧪 Test Multiple Clients

Open two terminals and run the client in each. You’ll see real-time communication between both.

🐳 Dockerize Your Angular App: A Beginner’s Guide

Hardik Jariwala — Sun, 20 Apr 2025 07:24:35 +0000

What is Docker?🧠

Imagine shipping your entire application including its OS, environment, dependencies, and code as one neatly packaged box. That’s Docker in a nutshell.
Docker is a platform that allows you to create, deploy, and run applications in isolated environments called containers. These containers ensure your app works the same across development, testing, staging, and production regardless of the host OS.

Why Docker for Angular?📦

No more “but it works on my machine!” bugs
Clean, reproducible dev environments
Easy deployment to cloud platforms
Lightweight and fast compared to VMs(Virtual Machines)

Getting Started with Docker🚀

✅ Install Docker

Make sure Docker is installed and running on your machine.
Install Docker Desktop
Verify via terminal:

docker --version

Essential Docker Commands🛠️

docker build -t your-app-name .
docker run -p 3000:3000 your-app-name
docker ps        # list running containers
docker stop <container-id>

Dockerizing an Angular 17+ Project 🧑‍💻

Step 1: Build Your Angular App 🏗️

ng build --configuration production

Output will go to: dist/your-app-name/browser

Step 2: Create a Dockerfile 📁

# Build stage
FROM node:18 AS build

WORKDIR /app

# Copy package.json and package-lock.json to leverage Docker cache
COPY package*.json ./

# Install dependencies
RUN npm install --legacy-peer-deps 

# Install additional dependencies
RUN npm install ngx-bootstrap google-libphonenumber --legacy-peer-deps

# Copy project files
COPY . .

# Build the Angular application with production configuration
RUN npm run build -- --configuration production

# Serve stage
FROM node:18-slim

# Install a lightweight static server
RUN npm install -g serve

WORKDIR /app/dist/your-app-name/browser

# Copy the built Angular app from the previous stage
COPY --from=build /app/dist/your-app-name/browser .

# Expose the default serve port
EXPOSE 3000

# Run the app with serve
CMD ["serve", "-s", ".", "-l", "3000"]

🔁 Replace your-app-name with the actual folder name inside dist.

Step 3: Build and Run the Container 🚀

Build the Docker image

docker build -t angular-demo .

Run the container

docker run -p 3000:3000 angular-demo

Open in browser

Go to 👉 http://localhost:3000

Bonus: Docker for Development (Optional) 🎁

Want live-reloading while developing?
Mount your project folder as a volume
Use Angular CLI inside the container
Use ng serve --host 0.0.0.0

Conclusion 🧾

Docker and Angular make a powerful combo for modern web development. Whether you're deploying to the cloud or just keeping your local dev environment tidy, containers are the way to go. With Angular 17’s new standalone module system and enhanced performance, it's the perfect time to containerize your app and scale your skills.

🚀 Mastering Angular 17+ Fundamentals : A Dev’s Guide to Modern Angular

Hardik Jariwala — Wed, 16 Apr 2025 17:18:39 +0000

Angular has evolved into a powerful and modern framework for building scalable web applications. With the advent of standalone components, reactive primitives, and deferrable views, Angular is more streamlined than ever.

In this post, we’ll walk through core Angular concepts every modern developer should know, complete with theory and code examples. Whether you’re a beginner or brushing up, this guide is your Angular fundamentals crash course.

Table of Contents📚

Routing
Standalone Components
Forms
Property Binding
Event Handling
Conditional Rendering
For Loops in Angular
Passing Data Between Components
Deferrable Views

Routing🧭

Routing lets you navigate between views and components in Angular apps.

// app.routes.ts
import { Routes } from '@angular/router';
import { HomeComponent } from './home.component';
import { AboutComponent } from './about.component';

export const routes: Routes = [
  { path: '', component: HomeComponent },
  { path: 'about', component: AboutComponent },
];

// main.ts
bootstrapApplication(AppComponent, {
  providers: [provideRouter(routes)],
});

Standalone Components🧩

Standalone components don’t need an NgModule. They promote simpler architecture.

@Component({
  standalone: true,
  selector: 'app-hello',
  template: `<h1>Hello, Angular!</h1>`,
})
export class HelloComponent {}

Forms📝

Angular supports template-driven and reactive forms.
Template-driven Form:

<form #form="ngForm" (ngSubmit)="submit(form.value)">
  <input name="username" ngModel />
  <button type="submit">Submit</button>
</form>

Property Binding🔗

Bind values from component to template using [property].

<img [src]="imageUrl" alt="Dynamic Image" />

Event Handling🖱️

Use (event) to listen for DOM events

<button (click)="handleClick()">Click Me</button>

handleClick() {
  console.log('Button clicked!');
}

Conditional Rendering🔄

Show/hide elements with *ngIf.

<p *ngIf="isLoggedIn">Welcome back!</p>

isLoggedIn = true;

For Loops in Angular🔁

Use *ngFor to loop through lists.

<ul>
  <li *ngFor="let user of users">{{ user.name }}</li>
</ul>

users = [{ name: 'Alice' }, { name: 'Bob' }];

Passing Data Between Components🔄

Use @Input and @Output to communicate.

Parent to Child:

<app-user [name]="userName"></app-user>

@Input() name!: string;

Child to Parent:

<app-user (notify)="onNotify()"></app-user>

@Output() notify = new EventEmitter<void>();

Deferrable Views💤

Optimize performance by deferring part of the UI until needed.

<ng-container *ngIf="isLoaded(); else loading">
  <app-heavy-component />
</ng-container>
<ng-template #loading>
  <p>Loading...</p>
</ng-template>

Final Thoughts🧠

Angular’s modernization journey with features like standalone components and signals makes it more intuitive, reactive, and leaner than ever. Mastering these fundamentals sets you up for building robust, scalable applications.

Feel free to share your thoughts or ask questions in the comments. Happy coding! 🔥