Forem: Rahul Kumar Jha

Extract Structured Data from Car Listings Using AI in .NET 10

Rahul Kumar Jha — Tue, 10 Mar 2026 05:23:06 +0000

🚗 From Chaos to Structure: Extracting Car Listings with AI

Ever struggled with parsing messy car listings from different sources? Imagine turning this:

"Check out this stylish Honda City 2018 model for sale, clocked only 30,000 km! Single owner, showroom condition, insurance valid. Yours for just ₹6.5 lakh."

Into this:

{
  "Make": "Honda",
  "Model": "City",
  "Year": 2018,
  "Mileage": 30000,
  "Price": 6.5,
  "AvailabilityType": "Sale",
  "Features": ["Single owner", "Showroom condition", "Insurance valid"],
  "OwnerCount": 1
}

Let me show you how to build this in under 100 lines of C# using GitHub Models API! 🚀

🎯 The Problem

Car listings come in all shapes and sizes. Whether you're building a price comparison site, marketplace aggregator, or inventory management system, you need to:

Extract key details (make, model, year, mileage, price)
Handle different formats (sale, lease, rent)
Deal with missing information gracefully
Process data at scale

Manually parsing this is tedious. Let AI do the heavy lifting! 💪

🛠️ The Solution

We'll use:

GitHub Models - Free access to powerful AI models
Microsoft.Extensions.AI - Unified AI abstraction for .NET
.NET 10 - Latest and greatest

📦 Quick Setup

First, grab your free GitHub token from GitHub Models (no credit card needed!).

Create a new console app:

dotnet new console -n TextExtraction
cd TextExtraction
dotnet add package Microsoft.Extensions.AI.OpenAI
dotnet add package Microsoft.Extensions.Configuration.UserSecrets

Store your token securely:

dotnet user-secrets init
dotnet user-secrets set "GitHubModels:Token" "your-github-token"

🎨 Building the Model

Create a CarDetails.cs class to define what we want to extract:

using System.Text.Json.Serialization;

[JsonConverter(typeof(JsonStringEnumConverter))]
public enum AvailabilityType
{
    Sale,
    Lease,
    Rent
}

public class CarDetails
{
    public string Make { get; set; } = string.Empty;
    public string Model { get; set; } = string.Empty;
    public int? Year { get; set; }
    public double? Mileage { get; set; }
    public double? Price { get; set; }
    public AvailabilityType? AvailabilityType { get; set; }
    public double? PricePerMonth { get; set; }
    public double? PricePerDay { get; set; }
    public string[]? Features { get; set; }
    public string? Location { get; set; }
    public string ShortSummary { get; set; } = string.Empty;
    public int? OwnerCount { get; set; }
}

Notice the nullable types? That's how we handle missing data elegantly! ✨

🧠 The Magic: AI-Powered Extraction

Here's the core extraction logic in Program.cs:

using Microsoft.Extensions.AI;
using OpenAI;
using System.ClientModel;

// Configure the client
var configuration = new ConfigurationBuilder()
    .AddUserSecrets<Program>()
    .Build();

var credential = new ApiKeyCredential(
    configuration["GitHubModels:Token"] ?? 
    throw new InvalidOperationException("Token not found")
);

IChatClient chatClient = new OpenAIClient(credential, new OpenAIClientOptions
{
    Endpoint = new Uri("https://models.inference.ai.azure.com")
}).GetChatClient("gpt-4o-mini")
  .AsIChatClient();

// Define extraction schema
var prompt = @"Extract the following details from the car listing and return ONLY a valid JSON object:
{
  ""Make"": ""string - car manufacturer/brand"",
  ""Model"": ""string - car model name"",
  ""Year"": number - manufacturing year,
  ""Mileage"": number - kilometers driven,
  ""Price"": number - price in lakhs,
  ""AvailabilityType"": ""string - one of: Sale, Lease, Rent"",
  ""Features"": ""array of strings - notable features"",
  ""ShortSummary"": ""string - brief summary in 10-15 words"",
  ""OwnerCount"": number - previous owners (null if not mentioned)
}
Return only the JSON object, no additional text.";

// Sample car listings
var carListings = new List<string>
{
    "Honda City 2018 for sale, only 30,000 km! Single owner, showroom condition. ₹6.5 lakh.",
    "Hyundai Creta SX 2020 — premium SUV with sunroof. Monthly lease at ₹22,000.",
    "Toyota Innova Crysta 2019 — spacious 7-seater, 40,000 km, rent at ₹2,500/day."
};

// Process each listing
foreach (var listing in carListings)
{
    var response = await chatClient.GetResponseAsync<CarDetails>(
        $"{prompt}\n\nCar Listing:\n{listing}"
    );

    if (response.TryGetResult(out CarDetails? carDetails) && carDetails != null)
    {
        Console.WriteLine($"✅ Extracted: {carDetails.Make} {carDetails.Model}");
        Console.WriteLine(JsonSerializer.Serialize(carDetails, 
            new JsonSerializerOptions { WriteIndented = true }));
    }
}

🎬 Run It!

dotnet run

Output:

Processing car listings...

✅ Extracted: Honda City
{
  "Make": "Honda",
  "Model": "City",
  "Year": 2018,
  "Mileage": 30000,
  "Price": 6.5,
  "AvailabilityType": "Sale",
  "Features": ["Single owner", "Showroom condition"],
  "OwnerCount": 1
}

✅ Extracted: Hyundai Creta
{
  "Make": "Hyundai",
  "Model": "Creta SX",
  "Year": 2020,
  "AvailabilityType": "Lease",
  "PricePerMonth": 22000,
  "Features": ["Premium SUV", "Sunroof"]
}

🚀 Level Up: Customization Ideas

1. Extract Different Fields

Add fuel type, transmission, color:

public string? FuelType { get; set; }  // Petrol/Diesel/Electric
public string? Transmission { get; set; }  // Manual/Automatic
public string? Color { get; set; }

2. Process Real-Time Data

Connect to web scraping APIs or RSS feeds:

var listings = await FetchListingsFromApi("https://api.carmarket.com/listings");

3. Add Validation

if (carDetails.Year < 1900 || carDetails.Year > DateTime.Now.Year)
{
    Console.WriteLine("⚠️ Invalid year detected");
}

4. Export to Database

await dbContext.CarListings.AddAsync(carDetails);
await dbContext.SaveChangesAsync();

5. Use a Better Model

For higher accuracy, switch to GPT-4o:

.GetChatClient("gpt-4o")  // More capable, slightly slower

💡 Pro Tips

Keep temperature low (default is good) for consistent extraction
Be specific in prompts - define exact format you want
Use nullable types - not all listings have all fields
Batch process - handle multiple listings efficiently
Monitor token usage - track costs with response.Usage

🎯 Real-World Applications

🏪 Marketplace Aggregation: Consolidate listings from multiple sources
💰 Price Intelligence: Track pricing trends across markets
📊 Analytics Dashboards: Build insights from unstructured data
🤖 Chatbots: Power car recommendation bots
📱 Mobile Apps: Parse user-submitted listings

🔗 Get the Full Code

Grab the complete working example from GitHub:

👉 genai-dotnet-basic_llm_tasks/TextExtraction

The repo includes:

✅ Full source code with comments
✅ 9 example car listings
✅ Configuration setup guide
✅ Detailed README

🎓 What You Learned

Using GitHub Models API in .NET
Strongly-typed AI responses with GetResponseAsync<T>
Schema-based extraction with AI
Handling unstructured data gracefully
Building production-ready text extraction

🤔 What's Next?

Try extracting:

📄 Resume data (name, skills, experience)
🧾 Invoices (vendor, amounts, dates)
📧 Emails (sender, subject, key points)
🏠 Real estate listings
🍕 Restaurant menus (dishes, prices, ingredients)

The same pattern works for ANY text extraction task!

💬 Let's Connect!

What will you build with text extraction? Drop a comment below! 👇

Found this helpful? Give it a ❤️ and follow for more .NET + AI content!

Tags: #dotnet #ai #machinelearning #csharp #github #opensource #textextraction #nlp #automation

GitHub Repo: https://github.com/Rahul1994jh/genai-dotnet-basic_llm_tasks

4 Essential LLM Tasks in .NET 10 Using GitHub Models 🚀

Rahul Kumar Jha — Mon, 09 Mar 2026 07:31:52 +0000

4 Essential LLM Tasks in .NET 10 Using GitHub Models 🚀

Ever wondered how to integrate AI into your .NET applications? In this post, I'll show you 4 fundamental LLM tasks that you can implement in .NET 10 using GitHub Models - and the best part? It's surprisingly simple!

🎯 What We'll Build

💬 Chat Completion - Interactive AI conversations
🏷️ Text Classification - Automatic categorization of user feedback
📝 Text Summarization - Condensing long articles into bullet points
😊 Sentiment Analysis - Understanding customer emotions from reviews

💡 All code is available on GitHub: genai-dotnet-basic_llm_tasks

🔧 Prerequisites

Before we dive in, make sure you have:

✅ .NET 10 SDK installed
✅ Visual Studio 2022 or VS Code
✅ GitHub Personal Access Token with access to GitHub Models

Getting Started with GitHub Models

GitHub Models provides free access to powerful AI models! Here's how to get started:

Get a GitHub PAT (Personal Access Token)
- Go to GitHub Settings → Developer Settings → Tokens
- Generate a token with repo access
- Save it securely!
Configure User Secrets (Keep your token safe!)

cd YourProject
dotnet user-secrets set "GitHubModels:Token" "your-github-token-here"

📚 Learn more: Check out the official GitHub Models documentation for detailed setup instructions.

1️⃣ Chat Completion - Your AI Assistant 💬

Let's start with the basics: having a conversation with AI. This project demonstrates both non-streaming (get complete response) and streaming (real-time, token-by-token) responses.

Architecture at a Glance

Configuration → Authentication → AI Client → Chat Response

The Code

using Microsoft.Extensions.AI;
using Microsoft.Extensions.Configuration;
using OpenAI;
using System.ClientModel;

// Load configuration
IConfigurationRoot configuration = new ConfigurationBuilder()
    .SetBasePath(Directory.GetCurrentDirectory())
    .AddJsonFile("appsettings.json", optional: false)
    .AddUserSecrets<Program>()
    .Build();

// Authenticate with GitHub Models
ApiKeyCredential credential = new ApiKeyCredential(
    configuration["GitHubModels:Token"] 
    ?? throw new InvalidOperationException("Token not found!"));

// Initialize AI client
IChatClient chatClient = new OpenAIClient(credential, new OpenAIClientOptions
{
    Endpoint = new Uri("https://models.inference.ai.azure.com")
})
.GetChatClient("gpt-4o-mini")
.AsIChatClient();

// Get streaming response
var responseStream = chatClient.GetStreamingResponseAsync(
    "Explain quantum computing in simple terms", 
    new ChatOptions { Temperature = 0.7f, MaxOutputTokens = 300 }
);

Console.Write("AI: ");
await foreach (var message in responseStream)
{
    Console.Write(message.Text);
}

🎨 What Makes It Cool?

Real-time streaming for better UX
Token usage tracking for cost management
Configurable temperature (0.0 = focused, 1.0 = creative)

Use cases: Chatbots, Q&A systems, code assistants

2️⃣ Text Classification - Smart Categorization 🏷️

Automatically categorize user feedback into Complaint, Suggestion, Praise, or Other. Perfect for customer support automation!

The Magic Prompt

var classificationPrompt = @"Classify the text into one category: 
Complaint, Suggestion, Praise, or Other.
Respond with only the category name.
Text: '{0}'";

var userFeedback = "The app keeps crashing when I upload photos!";

var response = await chatClient.GetResponseAsync(
    string.Format(classificationPrompt, userFeedback),
    new ChatOptions 
    { 
        Temperature = 0.1f,  // Low temp for consistency
        MaxOutputTokens = 50 
    }
);

Console.WriteLine($"Classification: {response.Text}");
// Output: Complaint

💡 Pro Tips

Use low temperature (0.1) for consistent classifications
Keep MaxOutputTokens minimal since you only need one word
Perfect for routing support tickets!

Real-world impact: Route 1000s of customer messages automatically 📮

3️⃣ Text Summarization - TL;DR Generator 📝

Turn lengthy articles into concise bullet points. Save reading time and improve information accessibility!

Quick Example

var summaryPrompt = @"Summarize the following text as bullet points.
Provide 2-5 key points.
Text: '{0}'";

var longText = @"The quarterly earnings report shows our company 
exceeded expectations with a 15% revenue increase. Growth was driven 
by Asia-Pacific sales and new product launches. Profit margin 
improved from 12% to 14%, and the board approved a 5% dividend increase.";

var summary = await chatClient.GetResponseAsync(
    string.Format(summaryPrompt, longText),
    new ChatOptions { Temperature = 0.1f, MaxOutputTokens = 150 }
);

Console.WriteLine($"Summary:\n{summary.Text}");

Output

• Company revenue increased 15% year-over-year, beating expectations
• Growth driven by Asia-Pacific sales and new product launches  
• Profit margin improved from 12% to 14%
• Board approved 5% dividend increase for shareholders

Use cases: News aggregation, document processing, meeting notes

4️⃣ Sentiment Analysis - Understand Customer Emotions 😊

Go beyond simple positive/negative! This returns structured JSON with sentiment breakdown, positive/negative aspects, and emotional tone.

The Smart Prompt

var sentimentPrompt = @"Analyze the sentiment of this product review.
Return as JSON with this structure:
{
  ""overallSentiment"": ""Positive/Negative/Neutral/Mixed"",
  ""positiveAspects"": [""list of good things""],
  ""negativeAspects"": [""list of bad things""],
  ""emotionalTone"": ""description of tone""
}
Review: '{0}'";

var review = @"This laptop is amazing! Battery lasts all day, 
screen is crystal clear. Best purchase this year!";

var analysis = await chatClient.GetResponseAsync(
    string.Format(sentimentPrompt, review),
    new ChatOptions { Temperature = 0.1f, MaxOutputTokens = 200 }
);

Console.WriteLine($"Analysis:\n{analysis.Text}");

Sample Output

{
  "overallSentiment": "Positive",
  "positiveAspects": [
    "Excellent battery life lasting all day",
    "Crystal clear screen quality",
    "Overall satisfaction with purchase"
  ],
  "negativeAspects": [],
  "emotionalTone": "Enthusiastic and highly satisfied"
}

🎯 Why JSON?

Easy to parse programmatically
Structured data for dashboards
Multi-dimensional insights in one request

Business value: Build customer sentiment dashboards, track product issues, identify improvement areas 📊

🚀 Getting Started

Ready to try it yourself?

# Clone the repo
git clone https://github.com/Rahul1994jh/genai-dotnet-basic_llm_tasks
cd genai-dotnet-basic_llm_tasks

# Setup your GitHub token
dotnet user-secrets set "GitHubModels:Token" "your-token-here"

# Run any project
dotnet run --project TextCompletion
dotnet run --project Classification
dotnet run --project Summarization
dotnet run --project SentimentAnalysis

Each project has a detailed README with:

Architecture diagrams
Customization guides
Troubleshooting tips
Best practices

🎓 Key Takeaways

Task	Best For	Temperature	Model
Chat Completion	Conversations, Q&A	0.7	gpt-4o-mini
Classification	Categorization	0.1	gpt-4o-mini
Summarization	Content condensing	0.1	gpt-4o-mini
Sentiment Analysis	Emotion detection	0.1	gpt-4o-mini

💰 Cost Optimization Tips

Use gpt-4o-mini for general tasks (10x cheaper!)
Set MaxOutputTokens appropriately
Use low temperature for predictable tasks
Monitor token usage in production

🔐 Security Best Practices

✅ DO:

Store tokens in User Secrets (development)
Use Azure Key Vault (production)
Use .gitignore for secrets
Rotate tokens regularly

❌ DON'T:

Hardcode API keys in code
Commit secrets to Git
Share tokens publicly

🎯 What's Next?

Now that you've mastered the basics, here are some ideas to level up:

Combine tasks: Classify → Analyze Sentiment → Summarize
Add conversation history for multi-turn chats
Build a web API with ASP.NET Core
Create a Blazor UI for interactive demos
Add function calling for tool integration

📚 Resources

📦 GitHub Repo: genai-dotnet-basic_llm_tasks
🤖 GitHub Models: Official Documentation
🔧 Microsoft.Extensions.AI: NuGet Package
📖 .NET 10: What's New

💬 Let's Connect!

Found this helpful? Have questions or ideas?

⭐ Star the repo on GitHub
💬 Drop a comment below
🐦 Share with your network

Happy coding! 🎉

Built with ❤️ using .NET 10, Microsoft.Extensions.AI, and GitHub Models

dotnet #ai #machinelearning #csharp #github #llm #artificialintelligence #programming

Building a Multi-Provider AI Chat Application with .NET 10 - A Complete Guide

Rahul Kumar Jha — Sat, 28 Feb 2026 08:34:27 +0000

Building a Multi-Provider AI Chat Application with .NET 10 🤖

Have you ever wanted to build an AI application but felt locked into a single provider? What if you could switch between GitHub Models, Azure OpenAI, OpenAI, or even local models with just a configuration change?

In this comprehensive tutorial, I'll show you how I built a production-ready AI chat application using .NET 10 that supports multiple AI providers through a unified interface. By the end, you'll understand:

✅ How to use Microsoft.Extensions.AI for provider-agnostic code
✅ Implementing Provider and Factory design patterns
✅ Secure secrets management with User Secrets
✅ Building interactive console applications
✅ Working with 4 different AI providers

🔗 Complete Source Code: github.com/Rahul1994jh/genai_with_dotnet

🎯 The Problem

When building AI applications, you typically face these challenges:

// ❌ The problem: Different APIs for different providers
if (provider == "Azure") {
    var response = await azureClient.GetChatCompletionsAsync(...);
} else if (provider == "OpenAI") {
    var response = await openAiClient.CreateChatCompletionAsync(...);
} else if (provider == "GitHub") {
    var response = await githubClient.Complete(...);
}
// ... more providers, more complexity

This approach leads to:

❌ Hard-coded provider logic scattered everywhere
❌ Difficult to test and maintain
❌ Impossible to switch providers at runtime
❌ Code duplication for similar operations

💡 The Solution

Enter Microsoft.Extensions.AI - Microsoft's official abstraction layer for AI services:

// ✅ The solution: One interface for all providers
IChatClient client = GetClient(provider);
var response = await client.CompleteAsync(messages, options);

By using the Provider Pattern with a Factory, we can:

✅ Switch providers with a configuration change
✅ Add new providers without touching existing code
✅ Test with mock providers easily
✅ Keep code clean and maintainable

🏗️ Architecture Overview

Let me show you the architecture we'll build:

┌─────────────────────────────────────────────────────┐
│  Console Application (Interactive Menus)            │
└────────────────┬────────────────────────────────────┘
                 │
┌────────────────▼────────────────────────────────────┐
│  SimpleChat.cs (Main Orchestrator)                  │
│  • Provider Selection                               │
│  • Chat Options Configuration                       │
│  • Chat Loop                                        │
└────────┬────────────────┬────────────────┬──────────┘
         │                │                │
    ┌────▼────┐      ┌────▼────┐     ┌────▼────┐
    │ Config  │      │ Factory │     │IChatClient│
    │ Manager │      │ Pattern │     │(MS Ext AI)│
    └─────────┘      └────┬────┘     └───────────┘
                          │
            ┌─────────────┼─────────────┬─────────┐
            │             │             │         │
        ┌───▼───┐     ┌───▼───┐    ┌───▼───┐ ┌───▼───┐
        │GitHub │     │Azure  │    │OpenAI │ │Local  │
        │Models │     │OpenAI │    │  API  │ │Models │
        └───────┘     └───────┘    └───────┘ └───────┘

📚 Design Patterns in Action

1. Provider Pattern (Strategy Pattern)

The Provider Pattern allows us to define a family of algorithms (providers) and make them interchangeable:

// All providers implement this interface
public interface IModelProvider
{
    string ProviderName { get; }
    string ModelName { get; }
    IChatClient CreateChatClient();
}

// Each provider has its own implementation
public class GitHubModelProvider : IModelProvider
{
    public string ProviderName => "GitHub Models";
    public string ModelName => _settings.ModelName;

    public IChatClient CreateChatClient()
    {
        var credential = new AzureKeyCredential(_token);
        return new ChatCompletionsClient(
            new Uri(_settings.EndpointUrl), 
            credential
        ).AsIChatClient(_settings.ModelName);
    }
}

Why this matters:

Adding a new provider? Just implement IModelProvider
No changes to existing code
Easy to test with mock implementations

2. Factory Pattern

The Factory Pattern centralizes object creation:

public static class ModelProviderFactory
{
    public static IModelProvider CreateProvider(
        string providerType,
        ProviderSettings settings,
        IConfiguration configuration)
    {
        var token = GetTokenIfNeeded(settings.TokenConfigKey, configuration);

        return providerType.ToLower() switch
        {
            "github" => new GitHubModelProvider(settings, token),
            "azure" => new AzureOpenAIProvider(settings, token),
            "openai" => new OpenAIProvider(settings, token),
            "local" => new LocalModelProvider(settings),
            _ => throw new NotSupportedException(
                $"Provider '{providerType}' not supported")
        };
    }
}

Benefits:

One place to manage provider creation
Easy to add new providers (just add a case)
Encapsulates complex initialization logic

🚀 Building the Application - Step by Step

Let's build this application from scratch!

Step 1: Create the Project

dotnet new console -n AIChat -f net10.0
cd AIChat

Step 2: Add Required Packages

dotnet add package Microsoft.Extensions.AI
dotnet add package Microsoft.Extensions.AI.AzureAIInference
dotnet add package Microsoft.Extensions.AI.OpenAI
dotnet add package Azure.AI.Inference
dotnet add package Azure.AI.OpenAI
dotnet add package Microsoft.Extensions.Configuration
dotnet add package Microsoft.Extensions.Configuration.Json
dotnet add package Microsoft.Extensions.Configuration.Binder
dotnet add package Microsoft.Extensions.Configuration.UserSecrets

Step 3: Define the Provider Interface

Create Providers/IModelProvider.cs:

using Microsoft.Extensions.AI;

namespace AIChat.Providers
{
    public interface IModelProvider
    {
        string ProviderName { get; }
        string ModelName { get; }
        IChatClient CreateChatClient();
    }
}

Step 4: Implement GitHub Models Provider

Create Providers/GitHubModelProvider.cs:

using Azure;
using Azure.AI.Inference;
using Microsoft.Extensions.AI;

namespace AIChat.Providers
{
    public class GitHubModelProvider : IModelProvider
    {
        private readonly ProviderSettings _settings;
        private readonly string _token;

        public string ProviderName => "GitHub Models";
        public string ModelName => _settings.ModelName;

        public GitHubModelProvider(ProviderSettings settings, string token)
        {
            _settings = settings;
            _token = token;
        }

        public IChatClient CreateChatClient()
        {
            var credential = new AzureKeyCredential(_token);

            return new ChatCompletionsClient(
                new Uri(_settings.EndpointUrl), 
                credential
            ).AsIChatClient(_settings.ModelName);
        }
    }
}

Step 5: Create Configuration Classes

Create AppSettings.cs:

namespace AIChat
{
    public class AppSettings
    {
        public string SelectedProvider { get; set; } = "GitHub";
        public Dictionary<string, ProviderSettings> Providers { get; set; } = new();
        public ChatOptionsSettings ChatOptions { get; set; } = new();
        public UiSettings UI { get; set; } = new();
    }

    public class ProviderSettings
    {
        public string EndpointUrl { get; set; } = string.Empty;
        public string ModelName { get; set; } = string.Empty;
        public string TokenConfigKey { get; set; } = string.Empty;
        public string DeploymentName { get; set; } = string.Empty;
    }

    public class ChatOptionsSettings
    {
        public int MaxOutputTokens { get; set; }
        public float Temperature { get; set; }
    }

    public class UiSettings
    {
        public string WelcomeTitle { get; set; } = string.Empty;
        public string ExitMessage { get; set; } = string.Empty;
    }
}

Step 6: Create Configuration File

Create appsettings.json:

{
  "SelectedProvider": "GitHub",
  "Providers": {
    "GitHub": {
      "EndpointUrl": "https://models.github.ai/inference",
      "ModelName": "mistral-ai/Ministral-3B",
      "TokenConfigKey": "GitHub:Token"
    },
    "Azure": {
      "EndpointUrl": "https://your-resource.openai.azure.com",
      "ModelName": "gpt-4",
      "DeploymentName": "gpt-4",
      "TokenConfigKey": "Azure:ApiKey"
    },
    "OpenAI": {
      "ModelName": "gpt-4",
      "TokenConfigKey": "OpenAI:ApiKey"
    },
    "Local": {
      "EndpointUrl": "http://localhost:11434",
      "ModelName": "llama2",
      "TokenConfigKey": ""
    }
  },
  "ChatOptions": {
    "MaxOutputTokens": 300,
    "Temperature": 0.2
  },
  "UI": {
    "WelcomeTitle": "Welcome to AI Chat Assistant",
    "ExitMessage": "Goodbye! 👋"
  }
}

Don't forget to set it to copy to output directory in your .csproj:

<ItemGroup>
  <None Update="appsettings.json">
    <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
  </None>
</ItemGroup>

Step 7: Build the Factory

Create Providers/ModelProviderFactory.cs:

using Microsoft.Extensions.Configuration;

namespace AIChat.Providers
{
    public class ModelProviderFactory
    {
        public static IModelProvider CreateProvider(
            string providerType,
            ProviderSettings settings,
            IConfiguration configuration)
        {
            // Get token from user secrets if needed
            var token = string.Empty;
            if (!string.IsNullOrEmpty(settings.TokenConfigKey))
            {
                token = configuration[settings.TokenConfigKey];
                if (string.IsNullOrEmpty(token))
                {
                    throw new InvalidOperationException(
                        $"Token not found for provider '{providerType}'. " +
                        $"Please set '{settings.TokenConfigKey}' in user secrets.");
                }
            }

            return providerType.ToLower() switch
            {
                "github" => new GitHubModelProvider(settings, token),
                "azure" => new AzureOpenAIProvider(settings, token),
                "openai" => new OpenAIProvider(settings, token),
                "local" => new LocalModelProvider(settings),
                _ => throw new NotSupportedException(
                    $"Provider '{providerType}' is not supported.")
            };
        }
    }
}

Step 8: Create the Main Application

Create SimpleChat.cs:

using Microsoft.Extensions.AI;
using Microsoft.Extensions.Configuration;
using AIChat.Providers;

namespace AIChat
{
    internal class SimpleChat
    {
        public static async Task RunAsync()
        {
            // Load configuration
            var configuration = BuildConfiguration();
            var settings = LoadSettings(configuration);

            // Display provider selection menu
            var selectedProvider = DisplayProviderSelectionMenu(settings);

            // Get provider settings
            if (!settings.Providers.TryGetValue(
                selectedProvider, out var providerSettings))
            {
                Console.ForegroundColor = ConsoleColor.Red;
                Console.WriteLine(
                    $"❌ Error: Provider '{selectedProvider}' not found.");
                Console.ResetColor();
                return;
            }

            // Create provider
            IModelProvider provider;
            try
            {
                provider = ModelProviderFactory.CreateProvider(
                    selectedProvider, 
                    providerSettings, 
                    configuration);
            }
            catch (Exception ex)
            {
                Console.ForegroundColor = ConsoleColor.Red;
                Console.WriteLine($"❌ Error: {ex.Message}");
                Console.ResetColor();
                return;
            }

            // Get chat client
            IChatClient client = provider.CreateChatClient();

            var chatOptions = new ChatOptions
            {
                MaxOutputTokens = settings.ChatOptions.MaxOutputTokens,
                Temperature = settings.ChatOptions.Temperature
            };

            // Display welcome
            Console.Clear();
            Console.ForegroundColor = ConsoleColor.Cyan;
            Console.WriteLine("╔════════════════════════════════════════╗");
            Console.WriteLine($"║  {settings.UI.WelcomeTitle.PadRight(38)}║");
            Console.WriteLine("╚════════════════════════════════════════╝");
            Console.ResetColor();
            Console.WriteLine($"\nProvider: {provider.ProviderName}");
            Console.WriteLine($"Model: {provider.ModelName}\n");

            // Chat loop
            while (true)
            {
                Console.ForegroundColor = ConsoleColor.Green;
                Console.Write("You: ");
                Console.ResetColor();
                var userQuestion = Console.ReadLine();

                if (string.IsNullOrWhiteSpace(userQuestion) ||
                    userQuestion.Equals("exit", StringComparison.OrdinalIgnoreCase))
                {
                    Console.ForegroundColor = ConsoleColor.Yellow;
                    Console.WriteLine($"\n{settings.UI.ExitMessage}");
                    Console.ResetColor();
                    break;
                }

                try
                {
                    var messages = BuildMessages(userQuestion);

                    Console.ForegroundColor = ConsoleColor.Blue;
                    Console.Write("\nAssistant: ");
                    Console.ResetColor();

                    var response = await client.CompleteAsync(messages, chatOptions);
                    Console.WriteLine(response.Message.Text);
                    Console.WriteLine();
                }
                catch (Exception ex)
                {
                    Console.ForegroundColor = ConsoleColor.Red;
                    Console.WriteLine($"\n❌ Error: {ex.Message}");
                    Console.ResetColor();
                    Console.WriteLine();
                }
            }
        }

        private static IConfiguration BuildConfiguration() =>
            new ConfigurationBuilder()
                .SetBasePath(Directory.GetCurrentDirectory())
                .AddJsonFile("appsettings.json", optional: false)
                .AddUserSecrets<Program>()
                .Build();

        private static AppSettings LoadSettings(IConfiguration configuration)
        {
            var settings = new AppSettings();
            configuration.Bind(settings);
            return settings;
        }

        private static string DisplayProviderSelectionMenu(AppSettings settings)
        {
            Console.Clear();
            Console.ForegroundColor = ConsoleColor.Cyan;
            Console.WriteLine("╔════════════════════════════════════════╗");
            Console.WriteLine("║     Select AI Model Provider          ║");
            Console.WriteLine("╚════════════════════════════════════════╝");
            Console.ResetColor();
            Console.WriteLine();

            var providers = settings.Providers.ToList();

            for (int i = 0; i < providers.Count; i++)
            {
                var provider = providers[i];
                Console.ForegroundColor = ConsoleColor.White;
                Console.WriteLine($"  [{i + 1}] {provider.Key} - {provider.Value.ModelName}");
                Console.ResetColor();
            }

            Console.WriteLine();
            Console.ForegroundColor = ConsoleColor.Green;
            Console.Write($"Enter choice [1-{providers.Count}] (or Enter for default): ");
            Console.ResetColor();

            var input = Console.ReadLine();

            if (string.IsNullOrWhiteSpace(input))
                return settings.SelectedProvider;

            if (int.TryParse(input, out int choice) && 
                choice >= 1 && choice <= providers.Count)
            {
                return providers[choice - 1].Key;
            }

            return settings.SelectedProvider;
        }

        private static IEnumerable<ChatMessage> BuildMessages(string userQuestion) =>
            new List<ChatMessage>
            {
                new(ChatRole.System,
                    "You are a helpful, knowledgeable assistant. " +
                    "Provide clear and concise answers."),
                new(ChatRole.User, userQuestion)
            };
    }
}

Step 9: Update Program.cs

using AIChat;

await SimpleChat.RunAsync();

🔒 Setting Up User Secrets

User Secrets is a .NET feature for storing sensitive data securely during development.

Initialize User Secrets

dotnet user-secrets init

This adds a UserSecretsId to your .csproj:

<PropertyGroup>
  <UserSecretsId>your-unique-id-here</UserSecretsId>
</PropertyGroup>

Store Your GitHub Token

First, get a token from GitHub Settings:

Click "Generate new token (classic)"
No scopes needed for GitHub Models
Copy the token (you won't see it again!)

Then store it:

dotnet user-secrets set "GitHub:Token" "ghp_your_token_here"

Verify:

dotnet user-secrets list

🎨 Understanding Microsoft.Extensions.AI

Microsoft.Extensions.AI provides a unified abstraction layer for AI services. Here are the key concepts:

IChatClient Interface

The main interface for chat operations:

public interface IChatClient
{
    Task<ChatCompletion> CompleteAsync(
        IEnumerable<ChatMessage> messages,
        ChatOptions? options = null,
        CancellationToken cancellationToken = default);
}

ChatMessage

Represents a message in a conversation:

new ChatMessage(ChatRole.System, "You are a helpful assistant")
new ChatMessage(ChatRole.User, "What is AI?")
new ChatMessage(ChatRole.Assistant, "AI stands for...")

Roles explained:

System: Instructions to the AI (sets behavior)
User: Your questions/prompts
Assistant: AI's responses (for conversation history)

ChatOptions

Configuration for the chat request:

new ChatOptions
{
    Temperature = 0.7f,        // 0.0-2.0: creativity level
    MaxOutputTokens = 500,     // Maximum response length
    TopP = 0.9f,              // Nucleus sampling
    FrequencyPenalty = 0.0f,  // Reduce repetition
    PresencePenalty = 0.0f    // Encourage new topics
}

Understanding Temperature

Temperature controls randomness in responses:

0.0 ═══════════ 0.7 ═══════════ 1.5 ═══════════ 2.0
Focused        Balanced      Creative       Chaotic

Examples:

Temperature = 0.0 (Deterministic)

Q: What is 2+2?
A: 4
A: 4  (always same)
A: 4

Temperature = 0.7 (Balanced)

Q: Describe a sunset
A: "The sky fills with warm orange and pink hues..."
A: "Golden rays paint the horizon as day fades..."
A: "Vibrant colors dance across the evening sky..."

Temperature = 1.5 (Very Creative)

Q: Describe a sunset
A: "Celestial fire dances with liquid gold..."
A: "The sun whispers farewell in a symphony of light..."
A: "Time melts into an amber ocean..."

🎯 Adding More Providers

Want to add Azure OpenAI? Here's the complete implementation:

AzureOpenAIProvider.cs

using Azure;
using Azure.AI.OpenAI;
using Microsoft.Extensions.AI;

namespace AIChat.Providers
{
    public class AzureOpenAIProvider : IModelProvider
    {
        private readonly ProviderSettings _settings;
        private readonly string _token;

        public string ProviderName => "Azure OpenAI";
        public string ModelName => _settings.ModelName;

        public AzureOpenAIProvider(ProviderSettings settings, string token)
        {
            _settings = settings;
            _token = token;
        }

        public IChatClient CreateChatClient()
        {
            var credential = new AzureKeyCredential(_token);
            var client = new AzureOpenAIClient(
                new Uri(_settings.EndpointUrl), 
                credential);

            var chatClient = client.GetChatClient(_settings.DeploymentName);
            return chatClient.AsIChatClient();
        }
    }
}

That's it! No changes to existing code needed. Just:

Add the provider class
Update the factory with a new case
Add configuration to appsettings.json
Set the API key in user secrets

🧪 Testing Your Application

Run with GitHub Models

# Set token
dotnet user-secrets set "GitHub:Token" "ghp_your_token"

# Run
dotnet run

Try Different Models

Edit appsettings.json:

"ModelName": "openai/gpt-4o-mini"  // Switch to GPT-4o mini

Available GitHub models:

mistral-ai/Ministral-3B - Fast and efficient
meta-llama/Llama-3.2-3B-Instruct - Great for instructions
microsoft/Phi-3-mini-4k-instruct - Excellent for code
openai/gpt-4o-mini - Best quality

Browse all: GitHub Models Marketplace

💡 Key Learnings

1. Provider Pattern Makes Code Flexible

By abstracting providers behind an interface:

✅ Easy to add new providers
✅ Easy to test (mock providers)
✅ Easy to maintain (separation of concerns)

2. Factory Pattern Centralizes Creation

Having one place to create providers:

✅ Consistent initialization
✅ Easier to debug
✅ Single source of truth

3. Configuration-Driven Development

Using appsettings.json and User Secrets:

✅ No hardcoded values
✅ Environment-specific configs
✅ Secure secret management

4. Microsoft.Extensions.AI Abstractions

Using official abstractions:

✅ Future-proof code
✅ Community support
✅ Consistent APIs

🚀 Enhancing the Application

Want to take this further? Here are some ideas:

1. Add Streaming Responses

await foreach (var update in client.CompleteStreamingAsync(messages, options))
{
    Console.Write(update.Text);
}

2. Add Conversation History

private static List<ChatMessage> _conversationHistory = new();

// Add to history after each exchange
_conversationHistory.Add(new ChatMessage(ChatRole.User, userInput));
_conversationHistory.Add(new ChatMessage(ChatRole.Assistant, response));

// Use history in next request
var allMessages = _conversationHistory.Concat(newMessages);

3. Add Function Calling

var tools = new List<ChatTool>
{
    ChatTool.CreateFunctionTool(
        "get_weather",
        "Get the current weather",
        // ... parameters
    )
};

var options = new ChatOptions { Tools = tools };

4. Add RAG (Retrieval Augmented Generation)

// 1. Search your documents
var relevantDocs = await SearchDocuments(userQuestion);

// 2. Add context to system message
var context = string.Join("\n", relevantDocs);
var systemMessage = new ChatMessage(ChatRole.System,
    $"Use this context to answer questions:\n{context}");

🎓 What You've Learned

In this tutorial, you've learned:

✅ Design Patterns - Provider and Factory patterns in action
✅ Microsoft.Extensions.AI - Official .NET AI abstractions
✅ Multi-Provider Support - Work with 4 different AI services
✅ User Secrets - Secure credential management
✅ Clean Architecture - Separation of concerns
✅ Configuration Management - appsettings.json best practices

📊 Performance Considerations

Token Usage

Different providers have different costs:

Provider	Input (1K tokens)	Output (1K tokens)
GitHub Models	FREE	FREE
OpenAI GPT-4	$0.03	$0.06
OpenAI GPT-3.5	$0.002	$0.002
Azure	Similar to OpenAI	Similar to OpenAI
Local (Ollama)	FREE	FREE

Speed Comparison

From my testing:

Provider	Average Response Time
Local Models	⚡ 1-2 seconds
GitHub Models	⚡⚡ 2-3 seconds
OpenAI GPT-3.5	⚡⚡ 2-4 seconds
OpenAI GPT-4	⚡⚡⚡ 5-10 seconds
Azure OpenAI	⚡⚡ 2-5 seconds

🔧 Troubleshooting

"Token not found" Error

# Check if secret is set
dotnet user-secrets list

# Set it if missing
dotnet user-secrets set "GitHub:Token" "ghp_your_token"

HTTP 401 (Unauthorized)

Verify token format (GitHub: ghp_..., OpenAI: sk-...)
Check token hasn't expired
Regenerate token if needed

"Provider not found" Error

Check SelectedProvider spelling in appsettings.json
Ensure provider exists in Providers section
Provider names are case-sensitive

🌟 Next Steps

Want to explore more? Check out:

Build a Web UI - Convert to ASP.NET Core
Add Authentication - Secure your application
Deploy to Azure - Host in the cloud
Add Monitoring - Application Insights
Build a Mobile App - .NET MAUI frontend

📦 Complete Source Code

The complete source code for this project is available on GitHub:

Repository: Rahul1994jh/genai_with_dotnet

⭐ Please star the repository if you find it helpful!

Clone and run:

git clone https://github.com/Rahul1994jh/genai_with_dotnet.git
cd genai_with_dotnet/genai_with_dotnet/01_SimpleChat
dotnet restore
dotnet user-secrets set "GitHub:Token" "your_token"
dotnet run

🤝 Contributing

Found a bug or want to add a feature? Contributions are welcome!

Fork the repository
Create a feature branch
Submit a pull request

💬 Let's Discuss!

What do you think about this approach? Have you used Microsoft.Extensions.AI? What AI provider do you prefer?

Drop a comment below! 👇

📚 Resources

If you found this helpful, please:

⭐ Star the GitHub repository
🔄 Share this post
💬 Drop a comment
👥 Follow me for more .NET content

Happy coding! 🚀

This is part of my **Building AI Apps with .NET* series. Stay tuned for more posts on advanced topics like RAG, function calling, and building production-ready AI applications!*

dotnet #csharp #ai #machinelearning #tutorial #programming #softwaredevelopment #technology #github #azure #openai

const with Object or Array in Javascript

Rahul Kumar Jha — Thu, 05 Feb 2026 06:47:19 +0000

Intro

When you use const to declare objects or arrays in JavaScript, you’re making the variable binding (the reference) immutable — not the contents themselves.

This means you cannot assign a new array or object to that variable, but you can still change the data inside the object or array.

For example:

const c = [1, 2]; // c is bound to a specific array

If you try to reassign c to a new array:

c = [3, 4]; // This will cause an error: Assignment to constant variable
The error occurs because const prevents changing what c points to.

However, you can modify the elements within the array:

c[0] = 5; // Allowed: changes the value at index 0 console.log(c); // Output: [5, 2]

This works because const only protects the binding (the reference to the array), not the array’s contents.

Summary

Declaring an array or object with const means the variable must always point to the same array or object. However, you are free to update, add, or remove items within that array or object. The reference stays constant, but the internal data can change.

Don’t Overlook the Basics: Understanding Type in C#

Rahul Kumar Jha — Mon, 02 Feb 2026 07:31:35 +0000

Intro

Understanding types is one of the most important basics in C#. Every type, no matter what, is ultimately connected to a “big boss” type called System.Object. This means that, behind the scenes, all types share some common features.

For example:

// This class automatically inherits from System.Object
class Music { }

// This is the same as above, just written out
class Opera : System.Object { }

No matter what you create, it all starts with System.Object. This gives you useful methods like ToString() and GetHashCode() for every object.

Types in C#: The Basics

In C#, types are grouped into two main categories:

Value Types
Reference Types

There’s also a special group called primitive types, which are the most basic built-in types.

Let’s break these down!

Primitive Types

Primitive types are the simplest types built into C#. They are easy for the compiler to use and map directly to types in the .NET framework.

Examples: int, double, bool, char, byte, short, long, float, decimal

Primitive types are a subset of value types.
They have default values (int is 0, bool is false, etc.).
They are fast and efficient.

int count = 5;    // int is a primitive type
bool isOn = true; // bool is a primitive type

Value Types

Value types hold their actual data. They’re stored in a quick-access area called the *stack *, When you assign a value type to another, it copies the value.

Examples: All primitive types, struct, enum

Value types always have a value, even if you don’t set one.
They can’t be null (unless you use a nullable type).
Assignment copies the value—not just a reference.
All value types (structs, enums, primitive types) inherit from System.ValueType.

int number = 10;    // Value type, default is 0 if not set
int copy = number;  // Copies the value (10)

All value types in C# (such as structs, enums, and primitive types like int) are sealed. This means you cannot inherit from a value type, nor can you use a value type as a base for another struct or class.

So, for example, it’s not possible to define any new types using Boolean, Char, Int32, UInt64, Single, Double, Decimal, and so on as base types. A value type can implement one or more interfaces if you choose

Why Are Value Types Sealed?

Immutability of Layout: Value types have a specific memory layout, and allowing inheritance would make their size and structure unpredictable.
Performance: The sealed nature allows the .NET runtime to optimize how value types are stored and accessed.
Simplicity: Inheriting value types would complicate assignment, boxing, and unboxing.

The following code will not compile:

struct BasePoint { public int X, Y; }

// Error! Cannot derive from a sealed type
struct DerivedPoint : BasePoint { public int Z; }

You also cannot use a value type as a base for a reference type:

struct BaseStruct { }

// Error! Cannot derive from a value type
class MyClass : BaseStruct { }

How to Create Your Own Value Type?

Using struct

A struct is a user-defined value type. Here’s how you might create a simple value type to represent a 2D point:

public struct Point
{
    public int X;
    public int Y;

    public Point(int x, int y)
    {
        X = x;
        Y = y;
    }
}

Now you can use Point as a value type:

Point a = new Point(1, 2);
Point b = a; // This copies the value (not a reference)
b.X = 10;

// a.X is still 1, b.X is 10

Using enum

All enumerations in .NET inherit from the abstract System.Enum type, which itself is a subclass of System.ValueType. The Common Language Runtime (CLR) and programming languages provide special handling for enumerations to support their unique behavior and usage.

An enum is another kind of value type you can create:

public enum DayOfWeek
{
    Sunday,
    Monday,
    Tuesday,
    Wednesday,
    Thursday,
    Friday,
    Saturday
}

Structs and enums are the only ways to create custom value types.
Value types are stored on the stack (or inline in objects) and behave differently from reference types (classes).
You cannot inherit from a struct or enum, nor can they inherit from anything except System.ValueType.

Nullable Value Types

Sometimes, you want a value type to be able to hold null (for example, when the value isn’t set yet). In C#, you can do this with a “nullable” type:

int? score = null; // 'score' can now be null

if (score == null)
{
    Console.WriteLine("No score yet!");
}

Reference Types

Reference types store a reference (address) to their data. The actual data lives in the “heap,” and the variable simply points to it. When you assign a reference type to another variable, it copies the reference, not the actual data.

Examples: class, string, array, delegate, interface, object

Reference types can be null (they may not point to any object).
If you use a reference type before setting it up, you get a NullReferenceException.
Assignment copies the reference (address), not the data.

string name; // This is null by default

// Using 'name' before assigning a value causes an error
// Console.WriteLine(name.Length); // NullReferenceException!

How Memory Is Allocated: Value vs Reference Types

One of the most important differences between value and reference types is how and where they are stored in memory.

Value Types: Stored on the Stack

Value types are usually stored on the stack—a fast, simple part of memory. When you create a value type variable, the data lives right there in the variable.

Example:

int number = 5;
int age = 20;

Each variable holds its value directly.

Reference Types: Reference and Object Locations

Reference types are a little different. The actual object data is always stored on the heap, but where the reference itself (the variable that points to the object) is stored depends on how you declare it:

If the variable is declared inside a method (a local variable), the reference itself lives on the stack.
If the variable is a field of a class (or a struct), the reference lives inside that object—usually on the heap.
If the variable is static, the reference lives in a special static memory area.
No matter where the reference is stored, it always points to the object data on the heap.

class Pet { public string Name; }
class Person { public Pet pet; }

void Example() {
    Person p = new Person(); // 'p' is a local variable (reference stored on stack)
    p.pet = new Pet();       // 'pet' is a field (reference stored inside the Person object on the heap)
}

Here, p (the reference to the Person object) lives on the stack (since it’s a local variable).
The Person object itself is on the heap.
Inside the Person object, the pet field (a reference) points to another object (Pet) on the heap.

What Happens When You Copy?

Value Type Copy

int a = 10;
int b = a; // b gets its own copy of the value (10)

Reference Type Copy

Person p1 = new Person();
Person p2 = p1; // p2 points to the same object as p1

Both p1 and p2 point to the same object in memory. If you change the object using either variable, both see the change!

Summary

Primitive types are basic built-in value types, like int and bool.
Value types hold actual values and live on the stack.
Reference types hold references (addresses) that may be stored on the stack, heap, or static area, but the actual object data always lives on the heap.
Assigning value types copies the data; assigning reference types copies the address.
All types in C# ultimately come from System.Object.

Extra Tips for Beginners

If you get a NullReferenceException, it means you tried to use a reference type that wasn’t set up yet.
Use nullable types (int?, double?) when you need a value type that can also be null.
Passing value types to methods copies their value; passing reference types copies the reference.

Grasping these fundamentals will enable you to write safer and higher-quality C# code. I strongly recommend reading the book CLR via C# by Jeffrey Richter to gain a deeper understanding of the language's features.

Weird JS

Rahul Kumar Jha — Thu, 29 Jan 2026 06:28:30 +0000

null vs undefined in JavaScript

1. undefined: Variable declared but not assigned.
2. null: Variable intentionally set to no value.

let a;
console.log(a); // undefined

let b = null;
console.log(b); // null

Summary:
undefined = automatic (I haven't given a value yet)
null = intentional (I specifically have no value)

var vs let

Scope

In JavaScript:

var is function-scoped. This means that a variable declared with var is accessible anywhere within the function in which it is declared, regardless of block boundaries (like { ... }).
let is block-scoped. This means that a variable declared with let is only accessible within the block (e.g., inside { ... }) where it is defined.

Example:

function hi() {
  {
    let a = 10;
    var b = 20; // 'b' is function-scoped, not block-scoped
  }

  console.log(b); // 20 - accessible, because 'b' is function-scoped
  console.log(a); // ReferenceError: a is not defined - 'a' is block-scoped
}

hi();

b is accessible outside the block because var ignores the block and only cares about the function scope.
a is not accessible outside the block because let restricts its visibility to the block where it is defined.

Hoisting

Both var and let are hoisted to the top of their scope. However, var is initialized with undefined during hoisting, so you can reference it before its declaration (but its value will be undefined).
let is not initialized during hoisting. If you try to access it before its declaration, you get a ReferenceError due to the "temporal dead zone."

Example:

console.log(a); // undefined - 'a' is hoisted and initialized
console.log(b); // ReferenceError: Cannot access 'b' before initialization

var a = 1;
let b = 2;

Redeclaration

var can be redeclared within the same scope without error.
let cannot be redeclared within the same scope. Attempting to do so results in a SyntaxError.

let a = 2;
let a = 3; // SyntaxError: Identifier 'a' has already been declared

var b = 2;
var b = 3; // No error, 'b' is simply reassigned

Summary:

var is function-scoped.
let is block-scoped.
Variables declared with var inside a block are still accessible anywhere in the function.
Variables declared with let inside a block are only accessible within that block.
var is hoisted and initialized as undefined.
let is hoisted but not initialized; accessing it before declaration throws a ReferenceError due to the temporal dead zone.
var: can be redeclared in the same scope
let: cannot be redeclared in the same scope (will throw a SyntaxError)

Using let leads to safer, clearer, and more maintainable code compared to var.

Weird Implicit Conversion (Type Coercion)

JavaScript uses implicit type coercion to automatically convert between strings and numbers during operations, which can lead to unexpected results—especially with +, -, or *. To avoid surprises, use explicit type coercion to control how your values are converted.

const a = "3";
const b = 2;

console.log(a + b); // "32"  (implicit coercion: string concatenation)
console.log(a - b); // 1     (implicit coercion: numeric subtraction)
console.log(a * b); // 6     (implicit coercion: numeric multiplication)

// Avoid surprises with explicit type coercion:
console.log(parseInt(a) + b);      // 5 (explicit coercion: numeric addition)
console.log(a + b.toString());     // "32" (explicit coercion: string concatenation)

Tip:
Use parseInt() or Number() for explicit numeric conversion, and toString() for explicit string conversion, so your results are always clear and predictable.

What the Heck is NaN in JavaScript?

Ever seen NaN in JavaScript? It stands for "Not-a-Number"—but it’s actually a special value of type number!

const a = "hello";
const b = parseInt(a); // NaN

console.log(typeof NaN); // "number" (wait, what?)
console.log(NaN == NaN); // false (seriously?)

NaN means a failed numeric conversion.
Weirdly, NaN is a number, but it’s not equal to itself!

How do you check for NaN?

console.log(isNaN(b)); // true

Tip:
Always use isNaN() to check for NaN—it’s the only reliable way!

Equality and Type Coercion (== vs === or != vs !==) in JavaScript

In JavaScript, == and != compare values with type coercion, converting types if needed. === and !== compare both value and type, so no conversion happens.

// Equality
console.log(0 == false);    // true
console.log(0 === false);   // false

console.log("" == 0);       // true
console.log("" === 0);      // false

console.log("" == false);   // true
console.log("" === false);  // false

console.log("1" == 1);      // true
console.log("1" === 1);     // false

// Not Equality
console.log(0 != false);    // false
console.log(0 !== false);   // true

console.log("" != 0);       // false
console.log("" !== 0);      // true

console.log("" != false);   // false
console.log("" !== false);  // true

console.log("1" != 1);      // false
console.log("1" !== 1);     // true

Tip:
Prefer === and !== for clear and predictable comparisons.

Hoisting in JavaScript

Rahul Kumar Jha — Thu, 29 Jan 2026 06:26:21 +0000

Hoisting is JavaScript’s behavior of moving declarations (not initializations) to the top of their containing scope—either a function or the global scope. This process happens during the compilation phase, before any code is executed.

Function Declarations

In JavaScript, function declarations are fully hoisted. This means that both the function’s name and its implementation are moved to the top of their scope. As a result, you can call a function before it appears in your code. This is similar to languages like C#, where you can call class methods from anywhere within the class, regardless of their order.

Example:

sayHi("rahul");
sum(1, 2);

function sayHi(name) {
  console.log(name);
}

function sum(a, b) {
  console.log(a + b);
}

Here, both sayHi and sum are called before their definitions. This is possible because JavaScript hoists the entire function declarations, so the engine knows about these functions before any code is executed.

Variable Declarations with let and const

Variable declarations using let and const are also hoisted, but only the declaration is moved—not the initialization. These variables are placed in the temporal dead zone (TDZ) from the start of their scope until the line where they are initialized. During this period, the variable exists but cannot be accessed.

Example:

console.log(b); // ReferenceError: Cannot access 'b' before initialization
let b = 2;

In this case, JavaScript knows about the variable b due to hoisting, but it hasn’t been initialized yet. Trying to access b before its declaration results in a ReferenceError. This behavior helps prevent bugs that might occur when variables are used before they are ready.

Function Expressions and Arrow Functions

When you define a function using a function expression (including arrow functions) and assign it to a variable declared with let or const, only the variable declaration is hoisted—not the function assignment. This means the variable is also in the temporal dead zone until it is initialized.

Example:

sayHi("rahul");
const sayHi = (name) => console.log(name);

Here, JavaScript hoists the declaration of sayHi, but the function is not assigned until that line is executed. If you try to call sayHi before the assignment, you’ll get a ReferenceError:

ReferenceError: Cannot access 'sayHi' before initialization

This happens because, unlike function declarations, function expressions assigned to variables behave just like any other variable declared with let or const.

Hoisting Inside Functions

Just as with the global scope, variable and function declarations inside a function are hoisted to the top of that function's local scope. This means you can reference them anywhere within the function, even before their actual declaration in the code.

Key Points:

Only the declarations are hoisted, not the initializations.
For variables declared with var, the variable is initialized to undefined at the top of the function scope.
For let and const, the variable is hoisted but not initialized (temporal dead zone applies).
Function declarations are fully hoisted and can be called anywhere within the function.

Example:

function demoHoisting() {
  // Uncommenting the next line will cause a ReferenceError
  // console.log(a); // ReferenceError: Cannot access 'a' before initialization
  let a = 10;
  console.log(a); // 10

  // Uncommenting the next line will cause a ReferenceError
  // console.log(b); // ReferenceError: Cannot access 'b' before initialization
  const b = 20;
  console.log(b); // 20

  sayHello(); // "Hello!"

  function sayHello() {
    console.log("Hello!");
  }
}

demoHoisting();

let a and const b are hoisted but not initialized, so accessing them before their declaration results in a ReferenceError.
The function declaration sayHello is hoisted, so it can be called before its definition.

Summary

Function declarations are fully hoisted; you can call them before their definition in the code.
Variables declared with let or const are hoisted, but not initialized, and are in the temporal dead zone until their assignment line.
Function expressions (including arrow functions) assigned to let or const variables are not available before their initialization, just like any other variable.
Inside functions, the same rules apply: variables and function declarations are hoisted to the top of the function’s local scope.

Understanding hoisting is key to avoiding bugs and writing predictable, robust JavaScript code.
If you’d like to explore this concept even further, I recommend searching the web for more articles, tutorials, and documentation on JavaScript hoisting to gain a deeper understanding!