Forem: mohamed Tayel

Key Components of Semantic Kernel

mohamed Tayel — Wed, 10 Sep 2025 11:15:50 +0000

Now that we know what Semantic Kernel is all about, it’s time to explore its key components. The Semantic Kernel library is built around several building blocks that can be used independently or in combination, depending on your application’s needs.

At a high level, the components include:

The Kernel
Services
Plugins
Functions
Prompts and prompt templates
Memory
Filters

Let’s go step by step.

1. The Kernel – The Orchestrator

As the name suggests, the kernel is the central component of Semantic Kernel. It acts as an orchestrator between your application and AI models.

Key responsibilities include:

Managing services and plugins – AI models, logging mechanisms, and other integrations are registered here.
Dependency injection container – The kernel holds everything your app needs (services, plugins, utilities) and makes them accessible at runtime.
Orchestrating tasks – Whether it’s a prompt execution, API call, or workflow, the kernel ensures the right components are available and used efficiently.

Getting started with the kernel is straightforward:

Install the NuGet package – Since Semantic Kernel is a .NET library, you can add it via NuGet.
Choose an AI model – It supports OpenAI GPT, Azure OpenAI, and other providers. Depending on your use case, you might need text completion, chat models, or image generation.
Configure API keys – Each provider requires authentication. Your API key ensures secure communication between your app and the AI service.

Once the kernel is set up, you’re ready to extend it with services and plugins.

2. Services – Beyond Just AI Models

Services represent the capabilities your kernel can use.

AI models – Examples include chat completion, text generation, image creation, or speech-to-text.
Utilities – Logging, HTTP clients, or custom application services.

This design follows the .NET service provider pattern, making Semantic Kernel feel natural for developers already familiar with dependency injection.

3. Plugins – Extending Functionality

While services bring in external capabilities, plugins allow you to extend Semantic Kernel’s functionality with custom logic.

Examples include:

Fetching live data from an external API.
Retrieving records from a database.
Triggering workflows inside your application.

With plugins, Semantic Kernel becomes more than just a bridge to AI—it becomes a hub where AI and business logic meet.

4. Functions, Prompts, and Templates

A function in Semantic Kernel represents a single task—like asking an LLM to summarize text or translate a sentence. Functions can be packaged into plugins or used standalone.

To power these functions, we rely on prompts and prompt templates:

Prompts: Natural language instructions given to the model.
Prompt templates: Reusable structures where parameters can be dynamically inserted.

This modularity makes prompts flexible, reusable, and maintainable across your application.

5. Memory

Semantic Kernel includes memory components, allowing you to persist context between interactions. This enables experiences like:

Personalized conversations.
Context-aware responses.
Long-term knowledge retention.

6. Filters

Filters act as middleware for AI operations. They allow you to inspect, validate, or transform requests and responses before they are executed or returned.

Putting It All Together – Example

Once you initialize the kernel, you can register services like this:

var kernel = Kernel.CreateBuilder()
    .AddOpenAIChatCompletion("gpt-4", apiKey)
    .Build();

Now, you can build a simple console chatbot:

while (true)
{
    Console.Write("User: ");
    var input = Console.ReadLine();

    var response = await kernel.InvokePromptAsync(input);
    Console.WriteLine("AI: " + response);
}

This tiny app shows the power of Semantic Kernel: a few lines of code, and you have a working AI-powered chatbot.

And remember—you’re not limited to text. Semantic Kernel can integrate:

Text-to-image: Generate images from descriptions.
Image-to-text: Describe images (e.g., anomaly detection).
Text-to-audio: Turn text into speech.
Audio-to-text: Transcribe speech into text.

Conclusion

The key components of Semantic Kernel—kernel, services, plugins, functions, prompts, memory, and filters—work together to make AI integration into .NET apps both powerful and flexible.

By combining these elements, you can build applications that not only interact with AI but also integrate seamlessly with your business logic, external systems, and real-world workflows.

This is only the beginning. As you continue exploring, you’ll see how these components unlock new possibilities in AI-powered application design.

Understanding Semantic Kernel

mohamed Tayel — Wed, 10 Sep 2025 10:26:01 +0000

Artificial Intelligence (AI) is no longer optional—it’s becoming a core part of modern applications. From natural language chat to image generation, developers are looking for ways to seamlessly integrate AI into their apps. But if you’ve tried, you probably know how challenging it can be.

Different AI providers (OpenAI, Azure AI, Anthropic’s Claude, and others) all have their own APIs, request formats, authentication rules, and response handling. Switching between providers often means rewriting large parts of your codebase.

That’s where Semantic Kernel comes in.

What Is Semantic Kernel?

Semantic Kernel is an open-source SDK created by Microsoft that makes it easier to embed AI into your .NET applications. At its core, it’s a middleware library that abstracts away the complexities of working with different AI models.

Think of it as a bridge between your app and modern AI providers. Instead of learning each API separately, you only need to learn Semantic Kernel once—and you’ll be able to plug in multiple AI services with minimal changes.

And here’s the best part: while Semantic Kernel is primarily designed for C# and .NET, it also supports Java and Python, giving teams flexibility across different tech stacks.

Why Semantic Kernel Matters

Without Semantic Kernel:

Each AI provider requires custom integration.
Switching providers means rewriting code.
Your app becomes tightly coupled to one AI service.

With Semantic Kernel:

You interact with AI models in a standardized way.
Switching from OpenAI to Claude (or vice versa) takes just a configuration change.
You can extend and customize easily through plugins.

Core Features of Semantic Kernel

Semantic Kernel provides out-of-the-box support for many AI-powered tasks:

Text Generation – Create summaries, content, or natural language output.
Chat Completion – Power chatbots and conversational apps.
Image Generation – Generate or edit images through AI models.
Plugins – Extend functionality with custom logic.
Memory and Logging – Manage contextual memory and monitor execution.

These features are all available through a unified API, so you don’t need to worry about provider-specific details.

The Three Big Benefits

When you start working with Semantic Kernel, three advantages quickly become clear:

Abstraction

You don’t need to learn every AI provider’s quirks.
Semantic Kernel gives you a higher-level, unified way to work with models.

Integration

Core AI tasks like text, chat, and images are already supported.
You can start building quickly without reinventing the wheel.

Extensibility

Add your own plugins or connect new AI services.
Designed to grow with future AI advancements.

A Practical Path

The best way to get started with Semantic Kernel is simple:

Begin with basic console applications to learn the principles.
Explore its core functionalities like text, chat, and plugins.
Move on to real applications and advanced concepts like agents, memory, and logging.

By the end of that journey, you’ll have a solid understanding of Semantic Kernel and how to integrate it effectively into your .NET projects.

Wrapping Up

Semantic Kernel provides a powerful, flexible, and extensible foundation for bringing AI into your .NET applications. Whether you’re building intelligent chatbots, automating workflows, or experimenting with image generation, this library makes integration faster and easier—while keeping your options open for the future.

With abstraction, integration, and extensibility at its core, Semantic Kernel lets you focus on building great apps instead of wrestling with provider-specific details.

If you’re ready to explore the future of AI-powered .NET development, Semantic Kernel is the perfect place to start.

Generative AI: What It Is, How It Works, and Why It Matters

mohamed Tayel — Mon, 19 May 2025 12:08:46 +0000

📌 Introduction: The Shocking Microsoft Decision

In a surprising move, Microsoft announced the layoff of thousands of employees across different departments, stating that many tasks previously performed by humans could now be handled more efficiently using generative AI technologies.

This wasn't just a cost-cutting measure—it signaled a major shift in how companies around the world are thinking: how can modern technology be used to reduce expenses and boost productivity?

This event made me ask a simple but important question:

"What exactly is AI? And can it really replace humans?"

In this article, I’ll walk you through the answers in a simple, clear way, and explain:

What AI is and its types
How it works
Why it’s both powerful and risky

🤖 What’s the Difference Between AI and AGI?

AI (Artificial Intelligence) is any system that can perform "intelligent" tasks such as analyzing data, generating content, or understanding speech.
AGI (Artificial General Intelligence) is the dream of many scientists: a system that can think, learn, and act like a human across various domains.

Right now, what we have is narrow AI, such as:

ChatGPT (understands and responds to questions)
DALL·E (generates images)
Copilot (assists in writing code)

AGI doesn’t exist yet.

🧠 How Does AI Work?

Traditional programming uses explicit instructions: “If X happens, do Y.”

But with Machine Learning, we teach the computer using data and examples.

Example:
If you want a program to recognize the handwritten number 3, you don’t write all the rules manually. Instead, you provide thousands of examples of the number 3, and the model learns the pattern and applies it to new images.

That’s how most modern AI learns—by example.

🎨 What Is Generative AI?

Generative AI is the type of AI that creates new content like text, images, or even code.

Popular tools include:

ChatGPT → generates text
DALL·E → creates images
Copilot → suggests code

It works like a massively advanced version of autocomplete.

Example:
"It’s going to be a beautiful..." → it likely predicts "day" based on the most common usage in its training data.

But this also leads to a big problem...

⚠️ What Are AI Hallucinations?

Sometimes AI makes up facts that sound believable but are entirely false.

Example:
I asked ChatGPT to write a blog post about the metaverse, and it mentioned a device called the “DreamView XR‑2023” with detailed specs.
That device doesn’t exist!

This is called a "hallucination"—the model creates content based on patterns, not facts.

That’s why you should always:

Verify important information
Never rely solely on AI for critical facts

✍️ How to Write Better Prompts (Prompt Engineering)

AI responds based on your input.

Instead of saying:
"Write me a thank-you email."

Say:
"Write a short, friendly thank-you email to my manager after a successful project."

The more specific you are, the better the results.

⚖️ Who’s Responsible? The Ethics of AI

Models can learn biases from old data (e.g., favoring men in hiring)
Some models give results without clear reasoning (the “black box” issue)
Deepfake technology can create dangerously realistic fake videos

This raises serious questions:

Who is accountable when AI gets it wrong?
How can we ensure transparency?

That’s why organizations like:

OpenAI
IEEE Ethics
Partnership on AI

...are working to establish ethical guidelines for AI.

🧭 Are We Ready?

AI isn’t coming—it’s already here.
And Microsoft won’t be the last to make bold decisions based on it.

The future belongs to those who:

Understand AI
Know how to use it wisely
And know how to protect themselves from its risks

Start today. Learn. Be ready for what’s next.

Singleton vs. Monostate in C#: Understand the Difference with a Real-World Story and Code Examples

mohamed Tayel — Tue, 06 May 2025 11:27:10 +0000

Learn the difference between Singleton and Monostate design patterns in C# through a simple real-world story. Discover when to use each, how they work, and see full code examples to help you write cleaner, more maintainable code.

When designing applications in C#, we sometimes need to ensure that a class behaves in a global or shared way — whether that means only one instance exists, or that all instances share the same state.

Two popular design patterns for this are the Singleton and the Monostate. They might seem similar at first, but they’re actually quite different under the hood. Let’s explore both using a story you’ll never forget.

🏢 The Singleton Story: "One Manager for the Entire Office"

Imagine you work in a big company. There’s only one office manager, and her name is Sarah.

Everyone in the company talks to Sarah when they need:

Time off approvals
Issue resolutions
General help

It doesn’t matter if you’re on the first or tenth floor — there’s just one Sarah, and she’s the only one you deal with. Even if someone tries to "create a new manager," the system will always redirect to the same Sarah.

That’s how the Singleton Pattern works in C#.

✅ Singleton Characteristics

Only one instance exists across the entire application.
Controlled through a static property.
Used when only one shared object is needed (like configuration, logging, etc.).

🧪 Singleton in C\

public class OfficeManager
{
    private static readonly OfficeManager _instance = new OfficeManager();

    private OfficeManager() { }

    public static OfficeManager Instance => _instance;

    public void ApproveLeave() => Console.WriteLine("Leave approved by Sarah.");
}

Usage:

OfficeManager.Instance.ApproveLeave();

🏠 The Monostate Story: "Many Receptionists, One Phone Line"

Now picture a different scenario: A company has many receptionists at different desks.

Here’s the catch: They all share the same internal phone line.

So even if you speak to Receptionist A or Receptionist B, your message will go through the same shared communication system. It’s like they all have different faces, but the same brain for phone handling.

That’s the Monostate Pattern.

✅ Monostate Characteristics

You can create multiple instances, but they all share the same state.
Achieved using static fields in the class.
Looks like a normal class, but behaves like a Singleton.

🧪 Monostate in C\

public class Receptionist
{
    private static string _sharedPhoneLine;

    public string PhoneLine
    {
        get => _sharedPhoneLine;
        set => _sharedPhoneLine = value;
    }
}

Usage:

var receptionist1 = new Receptionist();
receptionist1.PhoneLine = "Extension 101";

var receptionist2 = new Receptionist();
Console.WriteLine(receptionist2.PhoneLine); // Output: Extension 101

Even though receptionist2 is a different instance, it sees the same phone line!

📊 Singleton vs. Monostate: Key Differences

Feature	Singleton	Monostate
Instance Count	Only one instance	Multiple instances
State Sharing	Instance-level	Shared static state
Flexibility	Rigid (can't inherit or test easily)	More flexible and test-friendly
Appearance	Feels like a global service	Feels like a regular object
Use Case	Configs, Logging, Caching	Shared state without limiting instances

🎯 When to Use Each?

✅ Use Singleton when:
- You want a single, global object (like a logger or configuration manager).
- You need to enforce that only one instance can ever exist.
✅ Use Monostate when:
- You want multiple instances that share the same state.
- You care about testability, inheritance, or flexibility.

🧠 Final Thoughts

Both Singleton and Monostate aim to provide shared behavior — but they approach it differently.

If you like to control instance creation, Singleton is your choice.

If you prefer to keep the illusion of multiple objects, while maintaining shared state, Monostate fits the bill.

Specification Pattern P3

mohamed Tayel — Sun, 02 Feb 2025 20:38:21 +0000

🔹 Why Use the Specification Pattern?

❌ Problem Without It

Our Generic Repository is limited to basic CRUD.
We cannot filter products dynamically (e.g., Get all Nike products).
We cannot sort (e.g., Order by Price).
We cannot paginate (e.g., 10 products per page).

✅ Solution: Use the Specification Pattern

The Specification Pattern allows us to encapsulate filtering logic in reusable objects.
It makes our repository flexible, reusable, and scalable.
It avoids repository bloat by keeping filtering logic separate.

📌 Step 3.1: Create `ISpecification<T>` (Defines the Contract)

📂 Core/Specifications/ISpecification.cs

using System;
using System.Collections.Generic;
using System.Linq.Expressions;

namespace Core.Specifications
{
    public interface ISpecification<T>
    {
        Expression<Func<T, bool>>? Criteria { get; }
        List<Expression<Func<T, object>>> Includes { get; }
        Expression<Func<T, object>>? OrderBy { get; }
        Expression<Func<T, object>>? OrderByDescending { get; }
        int? Take { get; }
        int? Skip { get; }
        bool IsPagingEnabled { get; }
    }
}

🔹 What This Does

✔ Defines filtering (Criteria), sorting (OrderBy), and pagination (Skip, Take).

✔ Includes related entities (Includes) for eager loading.

📌 Step 3.2: Create `BaseSpecification<T>` (Stores Filtering Logic)

📂 Core/Specifications/BaseSpecification.cs

using System;
using System.Collections.Generic;
using System.Linq.Expressions;

namespace Core.Specifications
{
    public class BaseSpecification<T> : ISpecification<T>
    {
        public Expression<Func<T, bool>>? Criteria { get; }
        public List<Expression<Func<T, object>>> Includes { get; } = new();
        public Expression<Func<T, object>>? OrderBy { get; private set; }
        public Expression<Func<T, object>>? OrderByDescending { get; private set; }
        public int? Take { get; private set; }
        public int? Skip { get; private set; }
        public bool IsPagingEnabled { get; private set; }

        public BaseSpecification(Expression<Func<T, bool>>? criteria = null)
        {
            Criteria = criteria;
        }

        public void AddInclude(Expression<Func<T, object>> includeExpression)
        {
            Includes.Add(includeExpression);
        }

        public void ApplyPaging(int skip, int take)
        {
            Skip = skip;
            Take = take;
            IsPagingEnabled = true;
        }

        public void ApplyOrderBy(Expression<Func<T, object>> orderByExpression)
        {
            OrderBy = orderByExpression;
        }

        public void ApplyOrderByDescending(Expression<Func<T, object>> orderByDescExpression)
        {
            OrderByDescending = orderByDescExpression;
        }
    }
}

🔹 What This Does

✔ Stores filtering conditions dynamically.

✔ Supports sorting, eager loading, and pagination.

📌 Step 3.3: Create `SpecificationEvaluator<T>` (Applies the Specification)

📂 Infrastructure/Data/SpecificationEvaluator.cs

using System.Linq;
using Core.Specifications;
using Microsoft.EntityFrameworkCore;

namespace Infrastructure.Data
{
    public class SpecificationEvaluator<T> where T : class
    {
        public static IQueryable<T> GetQuery(IQueryable<T> inputQuery, ISpecification<T> spec)
        {
            var query = inputQuery;

            // Apply Filtering
            if (spec.Criteria != null)
            {
                query = query.Where(spec.Criteria);
            }

            // Apply Sorting
            if (spec.OrderBy != null)
            {
                query = query.OrderBy(spec.OrderBy);
            }
            else if (spec.OrderByDescending != null)
            {
                query = query.OrderByDescending(spec.OrderByDescending);
            }

            // Apply Pagination
            if (spec.IsPagingEnabled)
            {
                query = query.Skip(spec.Skip!.Value).Take(spec.Take!.Value);
            }

            // Apply Includes (Eager Loading)
            query = spec.Includes.Aggregate(query, (current, include) => current.Include(include));

            return query;
        }
    }
}

🔹 What This Does

✔ Applies filtering (Where).

✔ Applies sorting (OrderBy, OrderByDescending).

✔ Applies pagination (Skip, Take).

✔ Applies eager loading (Include).

📌 Step 3.4: Modify `GenericRepository<T>` to Support Specifications

📂 Infrastructure/Data/GenericRepository.cs

using System.Collections.Generic;
using System.Threading.Tasks;
using Core.Entities;
using Core.Interfaces;
using Core.Specifications;
using Microsoft.EntityFrameworkCore;

namespace Infrastructure.Data
{
    public class GenericRepository<T> : IGenericRepository<T> where T : BaseEntity
    {
        private readonly StoreContext _context;

        public GenericRepository(StoreContext context)
        {
            _context = context;
        }

        public async Task<T?> GetByIdAsync(int id)
        {
            return await _context.Set<T>().FindAsync(id);
        }

        public async Task<IReadOnlyList<T>> ListAllAsync()
        {
            return await _context.Set<T>().ToListAsync();
        }

        public async Task<IReadOnlyList<T>> ListAsync(ISpecification<T> spec)
        {
            return await ApplySpecification(spec).ToListAsync();
        }

        public async Task<T?> GetEntityWithSpec(ISpecification<T> spec)
        {
            return await ApplySpecification(spec).FirstOrDefaultAsync();
        }

        private IQueryable<T> ApplySpecification(ISpecification<T> spec)
        {
            return SpecificationEvaluator<T>.GetQuery(_context.Set<T>().AsQueryable(), spec);
        }

        public void Add(T entity)
        {
            _context.Set<T>().Add(entity);
        }

        public void Update(T entity)
        {
            _context.Set<T>().Attach(entity);
            _context.Entry(entity).State = EntityState.Modified;
        }

        public void Remove(T entity)
        {
            _context.Set<T>().Remove(entity);
        }

        public async Task<bool> SaveAllAsync()
        {
            return await _context.SaveChangesAsync() > 0;
        }
    }
}

🔹 What This Does

✔ Supports filtering, sorting, and pagination via Specifications.

✔ No need to modify the repository for future queries.

📌 Step 3.5: Create `ProductsWithFiltersSpecification`

📂 Core/Specifications/ProductsWithFiltersSpecification.cs

namespace Core.Specifications
{
    public class ProductsWithFiltersSpecification : BaseSpecification<Product>
    {
        public ProductsWithFiltersSpecification(string? brand, string? type)
            : base(x =>
                (string.IsNullOrEmpty(brand) || x.Brand == brand) &&
                (string.IsNullOrEmpty(type) || x.Type == type))
        {
        }
    }
}

🔹 What This Does

✔ Filters products dynamically based on Brand & Type.

📌 Step 3.6: Use the Specification in the Controller

📂 API/Controllers/ProductsController.cs

[HttpGet]
public async Task<ActionResult<List<Product>>> GetProducts(string? brand, string? type)
{
    var spec = new ProductsWithFiltersSpecification(brand, type);
    var products = await _repo.ListAsync(spec);
    return Ok(products);
}

✔ Dynamically filters products based on request parameters.

🚀 Step 3 Complete!

✅ We implemented the Specification Pattern step by step.

✅ Now, our repository supports dynamic filtering, sorting, and pagination.

✅ The API can filter products by brand & type dynamically.

🔹 Next Steps

🚀 Extend the Specification Pattern to support sorting & pagination.

🚀 Test the API to confirm the Specification Pattern is working.

❓ Need More Clarification?

Let me know if any step needs more explanation! 😊

Specification Pattern P2

mohamed Tayel — Sun, 02 Feb 2025 20:28:52 +0000

🚀 Step 2: Implementing a Generic Repository (Introducing Category Repository)

💡 Goal:

In this article, we will refactor our Product Repository by implementing a Generic Repository Pattern. Additionally, we will introduce the Category Repository, demonstrating how the Generic Repository improves code reusability and maintainability.

📂 Updated Project Structure (With Generic Repository)

📂 ProductApp
 ├── 📂 Core                 # Domain Layer
 │    ├── 📂 Entities
 │    │    ├── BaseEntity.cs
 │    │    ├── Product.cs
 │    │    ├── Category.cs
 │    ├── 📂 Interfaces
 │    │    ├── IRepository.cs  # Generic Repository Interface
 │    │    ├── IProductRepository.cs
 │    │    ├── ICategoryRepository.cs
 │
 ├── 📂 Infrastructure       # Data Access Layer
 │    ├── 📂 Data
 │    │    ├── Repository.cs  # Generic Repository Implementation
 │    │    ├── ProductRepository.cs
 │    │    ├── CategoryRepository.cs
 │    │    ├── StoreContext.cs
 │
 ├── 📂 API                  # Presentation Layer
 │    ├── 📂 Controllers
 │    │    ├── ProductsController.cs
 │    │    ├── CategoriesController.cs
 │    ├── 📂 DTOs
 │    │    ├── ProductDto.cs
 │    │    ├── CategoryDto.cs

1️⃣ Define the Base Entity

📂 Core/Entities/BaseEntity.cs

namespace Core.Entities
{
    public abstract class BaseEntity
    {
        public int Id { get; set; }
    }
}

2️⃣ Define the Generic Repository Interface

📂 Core/Interfaces/IRepository.cs

using System.Collections.Generic;
using System.Threading.Tasks;

namespace Core.Interfaces
{
    public interface IRepository<T> where T : BaseEntity
    {
        Task<T?> GetByIdAsync(int id);
        Task<List<T>> ListAllAsync();
        void Add(T entity);
        void Update(T entity);
        void Remove(T entity);
        Task<bool> SaveAllAsync();
    }
}

3️⃣ Implement the Generic Repository

📂 Infrastructure/Data/Repository.cs

using System.Collections.Generic;
using System.Threading.Tasks;
using Core.Entities;
using Core.Interfaces;
using Microsoft.EntityFrameworkCore;

namespace Infrastructure.Data
{
    public class Repository<T> : IRepository<T> where T : BaseEntity
    {
        private readonly StoreContext _context;
        private readonly DbSet<T> _dbSet;

        public Repository(StoreContext context)
        {
            _context = context;
            _dbSet = _context.Set<T>();
        }

        public async Task<T?> GetByIdAsync(int id)
        {
            return await _dbSet.FindAsync(id);
        }

        public async Task<List<T>> ListAllAsync()
        {
            return await _dbSet.ToListAsync();
        }

        public void Add(T entity)
        {
            _dbSet.Add(entity);
        }

        public void Update(T entity)
        {
            _dbSet.Update(entity);
        }

        public void Remove(T entity)
        {
            _dbSet.Remove(entity);
        }

        public async Task<bool> SaveAllAsync()
        {
            return await _context.SaveChangesAsync() > 0;
        }
    }
}

4️⃣ Define the `Category` Entity

📂 Core/Entities/Category.cs

namespace Core.Entities
{
    public class Category : BaseEntity
    {
        public string Name { get; set; } = string.Empty;
    }
}

5️⃣ Implement the `ICategoryRepository` Interface

📂 Core/Interfaces/ICategoryRepository.cs

using Core.Entities;

namespace Core.Interfaces
{
    public interface ICategoryRepository : IRepository<Category>
    {
    }
}

6️⃣ Implement the `CategoryRepository`

📂 Infrastructure/Data/CategoryRepository.cs

using Core.Entities;
using Core.Interfaces;

namespace Infrastructure.Data
{
    public class CategoryRepository : Repository<Category>, ICategoryRepository
    {
        public CategoryRepository(StoreContext context) : base(context) { }
    }
}

7️⃣ Register the Repositories in `Program.cs`

📂 API/Program.cs

using Infrastructure.Data;
using Microsoft.EntityFrameworkCore;

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.
builder.Services.AddControllers();
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

// Register StoreContext with Dependency Injection
builder.Services.AddDbContext<StoreContext>(options =>
    options.UseSqlServer(builder.Configuration.GetConnectionString("DefaultConnection")));

// Register Repositories
builder.Services.AddScoped(typeof(IRepository<>), typeof(Repository<>));
builder.Services.AddScoped<IProductRepository, ProductRepository>();
builder.Services.AddScoped<ICategoryRepository, CategoryRepository>();

var app = builder.Build();

// Apply Migrations Automatically (Optional: Good for development)
using var scope = app.Services.CreateScope();
var services = scope.ServiceProvider;
var context = services.GetRequiredService<StoreContext>();
context.Database.Migrate();

app.UseSwagger();
app.UseSwaggerUI();
app.UseHttpsRedirection();
app.UseAuthorization();
app.MapControllers();
app.Run();

8️⃣ Create and Apply Migrations

Run the following commands in the API project folder:

# Create a Migration
dPM> dotnet ef migrations add AddCategoryEntity
No project was found. Change the current working directory or use the --project option.
# Apply the Migration to Update the Database
dotnet ef database update

🚀 Step 2 is Complete

✔ We refactored the Product Repository using a Generic Repository.\
✔ We introduced the Category Repository, demonstrating reusability.\
✔ The Generic Repository now enables easy expansion for future entities.\
✔ We added and applied migrations to update the database.

🔜 What’s Next?

In the next article, we will introduce the Specification Pattern to handle complex queries efficiently. This will allow filtering, sorting, and pagination without cluttering our repositories.

Stay tuned! 🚀

Specification Pattern P1

mohamed Tayel — Sun, 02 Feb 2025 20:23:02 +0000

🚀 Step 1: Case Study Without Generic Repository & Specification Pattern

💡 Goal: Implement a simple Product API using a separate repository for products.

📂 Project Structure (Without Generic Repository & Specification Pattern)

📂 ProductApp
 ├── 📂 Core                 # Domain Layer
 │    ├── 📂 Entities
 │    │    ├── Product.cs
 │    ├── 📂 Interfaces
 │    │    ├── IProductRepository.cs
 │
 ├── 📂 Infrastructure       # Data Access Layer
 │    ├── 📂 Data
 │    │    ├── ProductRepository.cs
 │    │    ├── StoreContext.cs
 │
 ├── 📂 API                  # Presentation Layer
 │    ├── 📂 Controllers
 │    │    ├── ProductsController.cs
 │    ├── 📂 DTOs
 │    │    ├── ProductDto.cs

1️⃣ Install Required NuGet Packages

Before proceeding, install the necessary NuGet packages for Entity Framework Core and SQL Server support:

dotnet add package Microsoft.EntityFrameworkCore.SqlServer
dotnet add package Microsoft.EntityFrameworkCore.Design
dotnet add package Microsoft.EntityFrameworkCore.Tools

2️⃣ Create the `Product` Entity

📂 Core/Entities/Product.cs

namespace Core.Entities
{
    public class Product
    {
        public int Id { get; set; }
        public string Name { get; set; } = string.Empty;
        public string Brand { get; set; } = string.Empty;
        public string Type { get; set; } = string.Empty;
        public decimal Price { get; set; }
    }
}

3️⃣ Create the `ProductDto` for API Response

📂 API/DTOs/ProductDto.cs

namespace API.DTOs
{
    public class ProductDto
    {
        public int Id { get; set; }
        public string Name { get; set; } = string.Empty;
        public string Brand { get; set; } = string.Empty;
        public string Type { get; set; } = string.Empty;
        public decimal Price { get; set; }
    }
}

4️⃣ Create the `IProductRepository` Interface

📂 Core/Interfaces/IProductRepository.cs

using System.Collections.Generic;
using System.Threading.Tasks;
using Core.Entities;

namespace Core.Interfaces
{
    public interface IProductRepository
    {
        Task<Product?> GetByIdAsync(int id);
        Task<List<Product>> ListAllAsync();
        void Add(Product product);
        void Update(Product product);
        void Remove(Product product);
        Task<bool> SaveAllAsync();
    }
}

5️⃣ Implement the `ProductRepository`

📂 Infrastructure/Data/ProductRepository.cs

using System.Collections.Generic;
using System.Threading.Tasks;
using Core.Entities;
using Core.Interfaces;
using Microsoft.EntityFrameworkCore;

namespace Infrastructure.Data
{
    public class ProductRepository : IProductRepository
    {
        private readonly StoreContext _context;

        public ProductRepository(StoreContext context)
        {
            _context = context;
        }

        public async Task<Product?> GetByIdAsync(int id)
        {
            return await _context.Products.FindAsync(id);
        }

        public async Task<List<Product>> ListAllAsync()
        {
            return await _context.Products.ToListAsync();
        }

        public void Add(Product product)
        {
            _context.Products.Add(product);
        }

        public void Update(Product product)
        {
            _context.Products.Update(product);
        }

        public void Remove(Product product)
        {
            _context.Products.Remove(product);
        }

        public async Task<bool> SaveAllAsync()
        {
            return await _context.SaveChangesAsync() > 0;
        }
    }
}

6️⃣ Create the `StoreContext` (DbContext)

📂 Infrastructure/Data/StoreContext.cs

using Core.Entities;
using Microsoft.EntityFrameworkCore;

namespace Infrastructure.Data
{
    public class StoreContext : DbContext
    {
        public StoreContext(DbContextOptions<StoreContext> options) : base(options) { }

        public DbSet<Product> Products { get; set; }
    }
}

7️⃣ Create the API Controller: `ProductsController`

📂 API/Controllers/ProductsController.cs

using API.DTOs;
using Core.Entities;
using Core.Interfaces;
using Microsoft.AspNetCore.Mvc;

namespace API.Controllers
{
    [ApiController]
    [Route("api/[controller]")]
    public class ProductsController : ControllerBase
    {
        private readonly IProductRepository _productRepository;

        public ProductsController(IProductRepository productRepository)
        {
            _productRepository = productRepository;
        }

        [HttpGet]
        public async Task<ActionResult<IEnumerable<ProductDto>>> GetProducts()
        {
            var products = await _productRepository.ListAllAsync();
            return Ok(products.Select(p => new ProductDto
            {
                Id = p.Id,
                Name = p.Name,
                Brand = p.Brand,
                Type = p.Type,
                Price = p.Price
            }));
        }

        [HttpGet("{id}")]
        public async Task<ActionResult<ProductDto>> GetProduct(int id)
        {
            var product = await _productRepository.GetByIdAsync(id);
            if (product == null) return NotFound();

            return Ok(new ProductDto
            {
                Id = product.Id,
                Name = product.Name,
                Brand = product.Brand,
                Type = product.Type,
                Price = product.Price
            });
        }

        [HttpPost]
        public async Task<ActionResult<ProductDto>> CreateProduct(ProductDto productDto)
        {
            var product = new Product
            {
                Name = productDto.Name,
                Brand = productDto.Brand,
                Type = productDto.Type,
                Price = productDto.Price
            };

            _productRepository.Add(product);
            await _productRepository.SaveAllAsync();

            return CreatedAtAction(nameof(GetProduct), new { id = product.Id }, productDto);
        }

        [HttpPut("{id}")]
        public async Task<IActionResult> UpdateProduct(int id, ProductDto productDto)
        {
            var product = await _productRepository.GetByIdAsync(id);
            if (product == null) return NotFound();

            product.Name = productDto.Name;
            product.Brand = productDto.Brand;
            product.Type = productDto.Type;
            product.Price = productDto.Price;

            _productRepository.Update(product);
            await _productRepository.SaveAllAsync();

            return NoContent();
        }

        [HttpDelete("{id}")]
        public async Task<IActionResult> DeleteProduct(int id)
        {
            var product = await _productRepository.GetByIdAsync(id);
            if (product == null) return NotFound();

            _productRepository.Remove(product);
            await _productRepository.SaveAllAsync();

            return NoContent();
        }
    }
}

8️⃣ Register `StoreContext` in `Program.cs`

📂 API/Program.cs

using Infrastructure.Data;
using Microsoft.EntityFrameworkCore;

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.
builder.Services.AddControllers();
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

// Register StoreContext with Dependency Injection
builder.Services.AddDbContext<StoreContext>(options =>
    options.UseSqlServer(builder.Configuration.GetConnectionString("DefaultConnection")));

// Register Repository
builder.Services.AddScoped<IProductRepository, ProductRepository>();

var app = builder.Build();

app.UseSwagger();
app.UseSwaggerUI();
app.UseHttpsRedirection();
app.UseAuthorization();
app.MapControllers();
app.Run();

🎯 Final Steps: Running the API

Run the following commands to apply migrations:

dotnet ef migrations add InitialCreate --project ../Infrastructure/Data.csproj --startup-project API/ProductAPI.csproj
dotnet ef database update --project ../Infrastructure/Data.csproj --startup-project API/ProductAPI.csproj

Start the API:

dotnet run

Open Swagger UI at https://localhost:5001/swagger to test the endpoints.

🚀 Step 1 is Complete

✔ We implemented a Product API using a traditional repository.

✔ The API can Create, Read, Update, and Delete (CRUD) products.

Next Steps: Implement the Generic Repository to improve code reusability. 🚀

Using a Custom Type as a Dictionary Key in C#

mohamed Tayel — Sun, 02 Feb 2025 08:47:30 +0000

In C#, dictionaries rely on keys behaving correctly when it comes to equality and hashing. Standard types like string, int, and float work seamlessly as dictionary keys because Microsoft has ensured they implement proper equality comparison and hashing. However, when using a custom type as a key, you need to manually define how equality and hashing should work.

In this article, we will:

Create a custom type (CountryCode) and use it as a dictionary key.
Understand why overriding Equals and GetHashCode is necessary.
Implement a console application that demonstrates these concepts.

1. Creating a Custom Type as a Dictionary Key

Let's assume we want to store country details in a dictionary where the key is a custom type (CountryCode) instead of a string. The CountryCode type will wrap a string representing a country's ISO code (e.g., "USA", "FRA", "DZA").

Defining the CountryCode Class

using System;
using System.Collections.Generic;

public class CountryCode
{
    public string Code { get; }

    public CountryCode(string code)
    {
        if (string.IsNullOrWhiteSpace(code) || code.Length != 3)
        {
            throw new ArgumentException("Country code must be exactly 3 characters.", nameof(code));
        }

        Code = code.ToUpper(); // Normalize case
    }

    public override string ToString() => Code;

    // Override Equals for value comparison
    public override bool Equals(object obj)
    {
        if (obj is CountryCode other)
        {
            return string.Equals(this.Code, other.Code, StringComparison.OrdinalIgnoreCase);
        }
        return false;
    }

    // Override GetHashCode to match Equals behavior
    public override int GetHashCode()
    {
        return StringComparer.OrdinalIgnoreCase.GetHashCode(Code);
    }

    // Overload == and != for consistency
    public static bool operator ==(CountryCode left, CountryCode right)
    {
        if (left is null) return right is null;
        return left.Equals(right);
    }

    public static bool operator !=(CountryCode left, CountryCode right)
    {
        return !(left == right);
    }
}

Key Takeaways:

Constructor validation: Ensures the country code is always 3 characters long.
Overriding ToString(): Makes CountryCode display its value properly.
Overriding Equals(): Compares values instead of object references.
Overriding GetHashCode(): Ensures correct dictionary behavior.
Overloading == and !=: Makes equality checks consistent.

2. Using CountryCode as a Dictionary Key

Now, let's define a dictionary that maps country codes to country names.

Defining the Country Class

public class Country
{
    public string Name { get; }
    public CountryCode Code { get; }

    public Country(string name, string code)
    {
        Name = name;
        Code = new CountryCode(code);
    }

    public override string ToString() => $"{Name} ({Code})";
}

This class represents a country with a name and an ISO country code.

3. Implementing a Dictionary with Custom Keys

Now, we will create a dictionary where the key is CountryCode and the value is a Country object.

Building the Dictionary

class Program
{
    static void Main()
    {
        // Dictionary with CountryCode as the key
        Dictionary<CountryCode, Country> countries = new Dictionary<CountryCode, Country>
        {
            { new CountryCode("USA"), new Country("United States", "USA") },
            { new CountryCode("FRA"), new Country("France", "FRA") },
            { new CountryCode("DZA"), new Country("Algeria", "DZA") }
        };

        Console.Write("Enter a country code: ");
        string userInput = Console.ReadLine();

        // Convert user input to CountryCode
        CountryCode inputCode = new CountryCode(userInput);

        // Lookup country
        if (countries.TryGetValue(inputCode, out Country foundCountry))
        {
            Console.WriteLine($"Country found: {foundCountry}");
        }
        else
        {
            Console.WriteLine("Country not found.");
        }
    }
}

4. Testing the Application

Example Run:

Enter a country code: dza
Country found: Algeria (DZA)

This works even though we entered "dza" in lowercase because our Equals method ignores case.

What Happens if We Don't Override `Equals` and `GetHashCode`?

If we remove these overrides, the dictionary lookup will fail. The dictionary won't recognize "dza" and "DZA" as the same key, even though they contain the same value.

5. Summary

Why Use a Custom Type as a Key?
- Provides better control over data validation and formatting.
- Helps prevent accidental mistakes (e.g., using "USA " instead of "USA").
What Issues Can Occur?
- Dictionaries compare keys using Equals() and GetHashCode().
- Reference types compare object instances by default, not values.
How to Fix These Issues?
- Override Equals() to compare values.
- Override GetHashCode() to ensure hashing is consistent.
- Use a case-insensitive StringComparer to handle input variations.
- Overload == and != to ensure equality checks work properly.

By following these steps, we ensure that our dictionary functions correctly even when using custom types as keys.

Understanding Dictionary Enumeration and Sorting in C#

mohamed Tayel — Sun, 02 Feb 2025 08:39:38 +0000

Introduction

Dictionaries in C# are widely used for key-value storage and fast lookups. However, one common mistake developers make is assuming that dictionaries maintain a fixed order when enumerating. In this article, we will explore:

How dictionary enumeration works.
The limitations of relying on dictionary order.
How SortedDictionary<TKey, TValue> and SortedList<TKey, TValue> help maintain sorted order.
The best approach to sorting a dictionary by a custom property.
A complete console application demonstrating these concepts step by step.

1. Dictionary Enumeration: The Problem

A Dictionary<TKey, TValue> does not guarantee order when enumerating items. Let’s demonstrate this behavior with a simple example:

Step 1: Create a Console Application and Define a Dictionary

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        Dictionary<string, string> countries = new Dictionary<string, string>
        {
            { "US", "United States" },
            { "GB", "United Kingdom" },
            { "DE", "Germany" },
            { "FR", "France" },
            { "JP", "Japan" }
        };

        Console.WriteLine("Enumerating Dictionary:");
        foreach (var kvp in countries)
        {
            Console.WriteLine($"{kvp.Key}: {kvp.Value}");
        }
    }
}

Expected Output (Order May Vary)

Enumerating Dictionary:
GB: United Kingdom
US: United States
JP: Japan
DE: Germany
FR: France

The order of enumeration is not guaranteed and may change across different runs. This is because Dictionary<TKey, TValue> is optimized for fast lookups, not ordering.

2. Using SortedDictionary

If we need to maintain a sorted order, we can use SortedDictionary<TKey, TValue>. This collection automatically sorts its items by key.

Step 2: Replace Dictionary with SortedDictionary

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        SortedDictionary<string, string> sortedCountries = new SortedDictionary<string, string>
        {
            { "US", "United States" },
            { "GB", "United Kingdom" },
            { "DE", "Germany" },
            { "FR", "France" },
            { "JP", "Japan" }
        };

        Console.WriteLine("\nEnumerating SortedDictionary:");
        foreach (var kvp in sortedCountries)
        {
            Console.WriteLine($"{kvp.Key}: {kvp.Value}");
        }
    }
}

Output (Always Sorted by Key)

Enumerating SortedDictionary:
DE: Germany
FR: France
GB: United Kingdom
JP: Japan
US: United States

Key Takeaway:

✅ SortedDictionary automatically maintains key-based sorting.

❌ However, if we need sorting based on values (e.g., country names), SortedDictionary won’t help.

3. Using SortedList

Another option is SortedList<TKey, TValue>. It functions similarly to SortedDictionary, but stores data in an internal array instead of a balanced tree.

Step 3: Replace SortedDictionary with SortedList

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        SortedList<string, string> sortedListCountries = new SortedList<string, string>
        {
            { "US", "United States" },
            { "GB", "United Kingdom" },
            { "DE", "Germany" },
            { "FR", "France" },
            { "JP", "Japan" }
        };

        Console.WriteLine("\nEnumerating SortedList:");
        foreach (var kvp in sortedListCountries)
        {
            Console.WriteLine($"{kvp.Key}: {kvp.Value}");
        }
    }
}

Output (Always Sorted by Key)

Enumerating SortedList:
DE: Germany
FR: France
GB: United Kingdom
JP: Japan
US: United States

Comparison Between SortedDictionary and SortedList

| Feature | SortedDictionary | SortedList |
|---------|-----------------|------------|
| Sorting | By key (auto) | By key (auto) |
| Memory Usage | Higher (tree structure) | Lower (array-based) |
| Insert/Delete Performance | Faster for frequent changes | Slower for frequent changes |
| Lookup Speed | O(log n) | O(log n) |

Key Takeaway:

✅ SortedList uses less memory but performs worse when inserting/removing items frequently.

✅ SortedDictionary is better for frequent modifications but uses more memory.

4. Sorting by a Custom Property (Best Approach)

If we want to sort by country name (value) instead of the key, we cannot rely on SortedDictionary or SortedList. Instead, we should sort a list manually.

Step 4: Sorting by Country Name

using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    static void Main()
    {
        Dictionary<string, string> countries = new Dictionary<string, string>
        {
            { "US", "United States" },
            { "GB", "United Kingdom" },
            { "DE", "Germany" },
            { "FR", "France" },
            { "JP", "Japan" }
        };

        Console.WriteLine("\nSorting by Country Name:");
        var sortedByValue = countries.OrderBy(kvp => kvp.Value).ToList();

        foreach (var kvp in sortedByValue)
        {
            Console.WriteLine($"{kvp.Key}: {kvp.Value}");
        }
    }
}

Output (Sorted by Country Name)

Sorting by Country Name:
DE: Germany
FR: France
GB: United Kingdom
JP: Japan
US: United States

Key Takeaway:

✅ Sorting a list manually using OrderBy(kvp => kvp.Value) is the best way to sort dictionaries by value.

❌ SortedDictionary and SortedList only sort by key, not value.

Conclusion

Dictionary<TKey, TValue> does not guarantee order when enumerating.
SortedDictionary<TKey, TValue> and SortedList<TKey, TValue> maintain sorted order, but only by key.
If sorting by value is needed, use LINQ’s OrderBy on a list.
SortedDictionary vs. SortedList:
- SortedDictionary is better for frequent insertions/deletions.
- SortedList is more memory-efficient but slower for updates.

Final Thoughts

✅ Use Dictionary<TKey, TValue> for fast lookups.

✅ Use SortedDictionary<TKey, TValue> for ordered keys.

✅ Use OrderBy(kvp => kvp.Value) when sorting by values.

Optimizing Lookups in C# Dictionaries with Case-Insensitive Keys

mohamed Tayel — Sun, 02 Feb 2025 08:24:51 +0000

When working with collections in C#, dictionaries provide an efficient way to store and retrieve data using keys. However, one common issue is case sensitivity in dictionary lookups. By default, dictionaries in C# use case-sensitive key comparisons, which can lead to failed lookups when keys are entered in a different case.

In this article, we'll explore how to solve this problem by using StringComparer.OrdinalIgnoreCase, making dictionary lookups case-insensitive.

Why Use a Dictionary Instead of a List?

Initially, we might store countries in a List<Country>, but searching through a list has a linear time complexity of O(n). As the dataset grows, lookups become slower.

A dictionary (Dictionary<TKey, TValue>) improves lookup efficiency by providing O(1) time complexity, meaning searches remain fast even with large datasets.

Example Scenario: Storing and Looking Up Countries by Code

Let's assume we have a Country class that stores country information:

public class Country
{
    public string Code { get; }
    public string Name { get; }

    public Country(string code, string name)
    {
        Code = code;
        Name = name;
    }
}

Now, we need a way to store and retrieve countries by their country code efficiently.

Step 1: Using a Dictionary for Quick Lookups

Instead of using a List<Country>, we can store the data in a dictionary for fast lookups.

public class AppData
{
    public Dictionary<string, Country> AllCountriesByKey { get; private set; }

    public void Initialize()
    {
        var allCountries = new List<Country>
        {
            new Country("AUS", "Australia"),
            new Country("USA", "United States"),
            new Country("CAN", "Canada")
        };

        // Convert List to Dictionary
        AllCountriesByKey = allCountries.ToDictionary(country => country.Code);
    }
}

How It Works:

We create a list of Country objects.
We use ToDictionary to convert the list into a dictionary.
The country code (Code) is used as the key.

This allows us to look up a country in O(1) time instead of scanning a list.

Step 2: Implementing a Lookup Method

Now, let's implement a method to retrieve a country by its code.

public Country GetCountryWithCode(string code)
{
    AllCountriesByKey.TryGetValue(code, out var country);
    return country; // Returns null if the key is not found
}

Why Use `TryGetValue` Instead of Square Brackets?

Using square brackets (AllCountriesByKey[code]) would throw an exception if the key does not exist. Instead, TryGetValue:
✔ Prevents exceptions

✔ Returns null if the key is missing

✔ Runs in O(1) time complexity

Step 3: Handling Case Sensitivity

Right now, our dictionary is case-sensitive. If a user enters "aus" instead of "AUS", the lookup fails because "aus" is not the same as "AUS".

To fix this, we must make the dictionary case-insensitive when it is created:

public void Initialize()
{
    var allCountries = new List<Country>
    {
        new Country("AUS", "Australia"),
        new Country("USA", "United States"),
        new Country("CAN", "Canada")
    };

    // Convert list to dictionary with case-insensitive keys
    AllCountriesByKey = allCountries.ToDictionary(
        country => country.Code, 
        StringComparer.OrdinalIgnoreCase  // Enables case-insensitive lookups
    );
}

How Does This Fix Case Sensitivity?

The second argument to ToDictionary is StringComparer.OrdinalIgnoreCase, which:
- Ignores case differences ("AUS" == "aus" == "Aus")
- Optimizes lookups internally

Now, our lookups will work regardless of case.

Step 4: Testing Case-Insensitive Lookups

Now, let's test our updated method:

static void Main()
{
    var appData = new AppData();
    appData.Initialize();

    Console.WriteLine(appData.GetCountryWithCode("AUS")?.Name ?? "Not Found");  // Australia
    Console.WriteLine(appData.GetCountryWithCode("aus")?.Name ?? "Not Found");  // Australia
    Console.WriteLine(appData.GetCountryWithCode("Usa")?.Name ?? "Not Found");  // United States
    Console.WriteLine(appData.GetCountryWithCode("xyz")?.Name ?? "Not Found");  // Not Found
}

Expected Output

Australia
Australia
United States
Not Found

✔ Now, aus, AUS, and Aus all return Australia.

✔ The lookup remains O(1) in performance.

✔ If a country code is not found, it safely returns "Not Found".

Bonus: Trimming Whitespace

What if a user enters " AUS " with spaces? We can trim the input before lookup:

public Country GetCountryWithCode(string code)
{
    AllCountriesByKey.TryGetValue(code.Trim(), out var country);
    return country;
}

✔ Handles extra spaces automatically

✔ Ensures cleaner input before searching

Conclusion

By switching from List<T>.Find() to a dictionary with TryGetValue, we:

Improved lookup efficiency from O(n) to O(1).
Handled case-insensitive keys using StringComparer.OrdinalIgnoreCase.
Made our method safer by avoiding exceptions.
Added whitespace trimming for a better user experience.

This approach ensures that country lookups are fast, reliable, and user-friendly! 🚀

Optimizing Collection Operations in C#: Importing, Searching, and Sorting

mohamed Tayel — Sun, 26 Jan 2025 04:46:29 +0000

Introduction

Working with collections efficiently is a cornerstone of C# development. This article demonstrates practical ways to handle importing, searching, and sorting data while considering performance optimizations. Instead of relying on external dependencies like CSV files or frameworks like WPF, we’ll focus purely on the logic and concepts of working with collections.

We’ll use a simple example: managing a list of countries. Let’s walk through setting up the data, searching for specific countries, sorting them, and optimizing performance.

Step 1: Define the Data Model

To start, we need a Country class to represent the data. It will have three properties: the country’s name, code, and continent. Additionally, we’ll override the ToString method to provide a readable format for display.

public class Country
{
    public string Name { get; set; }
    public string Code { get; set; }
    public string Continent { get; set; }

    public override string ToString()
    {
        return $"{Name} ({Code}) - {Continent}";
    }
}

Step 2: Populate the Collection

Instead of importing data from an external file, we’ll create a hardcoded list of countries for simplicity.

var countries = new List<Country>
{
    new Country { Name = "Germany", Code = "DEU", Continent = "Europe" },
    new Country { Name = "United States", Code = "USA", Continent = "North America" },
    new Country { Name = "India", Code = "IND", Continent = "Asia" },
    new Country { Name = "Malta", Code = "MLT", Continent = "Europe" },
    new Country { Name = "Japan", Code = "JPN", Continent = "Asia" }
};

Why hardcode the data?
- This keeps the focus on the collection operations themselves without introducing complexities from external file handling.

Step 3: Searching for a Country

Using Linear Search (O(n))

A common approach is to use the List<T>.Find method, which performs a linear search through the list.

public static Country GetCountryWithCode(string code, List<Country> countries)
{
    if (code.Length != 3) return null; // Validate input length

    return countries.Find(c => c.Code.Equals(code, StringComparison.OrdinalIgnoreCase));
}

Usage Example:

var country = GetCountryWithCode("IND", countries);
if (country != null)
{
    Console.WriteLine($"Found: {country}");
}
else
{
    Console.WriteLine("Country not found.");
}

Performance Insight:
- Find performs a linear search with O(n) complexity. This works fine for small datasets but can slow down for larger collections.

Step 4: Optimizing Search with a Dictionary

To improve search performance, use a Dictionary<TKey, TValue> for constant-time lookups (O(1)).

var countryDict = countries.ToDictionary(c => c.Code);

public static Country GetCountryWithCode(string code, Dictionary<string, Country> countryDict)
{
    countryDict.TryGetValue(code.ToUpper(), out var country);
    return country;
}

Usage Example:

var optimizedCountry = GetCountryWithCode("USA", countryDict);
if (optimizedCountry != null)
{
    Console.WriteLine($"Found: {optimizedCountry}");
}
else
{
    Console.WriteLine("Country not found.");
}

Performance Benefit:
- Using a dictionary drastically reduces search time, making it ideal for large datasets or frequent lookups.

Step 5: Sorting the Collection

Using LINQ’s `OrderBy`:

For sorting, LINQ provides a clean and simple solution with the OrderBy method.

var sortedCountries = countries.OrderBy(c => c.Name).ToList();

Usage Example:

Console.WriteLine("Sorted Countries:");
foreach (var country in sortedCountries)
{
    Console.WriteLine(country);
}

Performance Insight:
- Sorting algorithms like the one used in OrderBy typically have O(n log n) complexity, which is efficient for most scenarios.
- While List.Sort is faster, the readability and simplicity of LINQ make OrderBy a great choice for one-time operations.

Step 6: Putting It All Together

Here’s the complete example code, combining everything:

using System;
using System.Collections.Generic;
using System.Linq;

public class Country
{
    public string Name { get; set; }
    public string Code { get; set; }
    public string Continent { get; set; }

    public override string ToString()
    {
        return $"{Name} ({Code}) - {Continent}";
    }
}

class Program
{
    static void Main()
    {
        // Step 2: Populate the collection
        var countries = new List<Country>
        {
            new Country { Name = "Germany", Code = "DEU", Continent = "Europe" },
            new Country { Name = "United States", Code = "USA", Continent = "North America" },
            new Country { Name = "India", Code = "IND", Continent = "Asia" },
            new Country { Name = "Malta", Code = "MLT", Continent = "Europe" },
            new Country { Name = "Japan", Code = "JPN", Continent = "Asia" }
        };

        // Step 3: Search with linear search
        var country = GetCountryWithCode("IND", countries);
        Console.WriteLine(country != null ? $"Found: {country}" : "Country not found.");

        // Step 4: Optimize search with dictionary
        var countryDict = countries.ToDictionary(c => c.Code);
        var optimizedCountry = GetCountryWithCode("USA", countryDict);
        Console.WriteLine(optimizedCountry != null ? $"Found: {optimizedCountry}" : "Country not found.");

        // Step 5: Sort the collection
        var sortedCountries = countries.OrderBy(c => c.Name).ToList();
        Console.WriteLine("Sorted Countries:");
        foreach (var sortedCountry in sortedCountries)
        {
            Console.WriteLine(sortedCountry);
        }
    }

    public static Country GetCountryWithCode(string code, List<Country> countries)
    {
        if (code.Length != 3) return null;
        return countries.Find(c => c.Code.Equals(code, StringComparison.OrdinalIgnoreCase));
    }

    public static Country GetCountryWithCode(string code, Dictionary<string, Country> countryDict)
    {
        countryDict.TryGetValue(code.ToUpper(), out var country);
        return country;
    }
}

Conclusion

In this article, we covered:

How to define and populate a collection with a simple Country class.
Searching for elements using both List<T>.Find and Dictionary<TKey, TValue>.
Sorting collections using LINQ’s OrderBy.

By focusing on performance and clean code, you can handle collections effectively in your applications. Experiment with these techniques to optimize your projects and gain a deeper understanding of C# collections!

Understanding String Interning in C#

mohamed Tayel — Sat, 14 Dec 2024 18:02:20 +0000

Meta Description:

Learn what string interning is in C#, why it's used, how it optimizes memory usage, and how to work with it effectively. Includes a complete example to demonstrate the concept.

Introduction

Strings are widely used in applications, but they can also be memory-intensive if not handled carefully. To optimize memory usage and improve performance, .NET introduces a feature called string interning. In this article, we'll explore how string interning works, why it’s useful, and how to leverage it effectively with clear examples.

What is String Interning?

String interning is a process where .NET stores only one instance of each unique string literal in a special memory pool called the string intern pool. When the same string is used multiple times in an application, the runtime references the existing instance from the intern pool rather than creating a new object.

How String Interning Works

When a string literal is created, .NET checks if it already exists in the intern pool.
- If it exists, the runtime reuses the existing string instance.
- If it doesn’t exist, the runtime adds it to the pool.
This applies only to string literals; dynamically created strings are not automatically interned.

Benefits of String Interning

Memory Optimization: Reduces memory usage by reusing string instances.
Faster Comparisons: Comparing interned strings is faster since it compares references rather than characters.

Example: String Interning in Action

Here’s a practical example that demonstrates string interning:

using System;

class Program
{
    static void Main()
    {
        // String literals (automatically interned)
        string literal1 = "hello";
        string literal2 = "hello";

        // Dynamically created string (not automatically interned)
        string dynamicString = new string("hello".ToCharArray());

        // Explicitly intern the dynamic string
        string internedString = string.Intern(dynamicString);

        // Comparing references
        Console.WriteLine(Object.ReferenceEquals(literal1, literal2)); // True (same instance)
        Console.WriteLine(Object.ReferenceEquals(literal1, dynamicString)); // False (different instances)
        Console.WriteLine(Object.ReferenceEquals(literal1, internedString)); // True (interned matches the pool)
    }
}

Explanation of the Code

Literals:
- literal1 and literal2 are string literals, so they are automatically interned and share the same reference.
Dynamic String:
- dynamicString is created at runtime, so it is not automatically interned and has a different reference.
Interning Manually:
- string.Intern(dynamicString) adds the dynamic string to the intern pool or retrieves the existing reference.

When Not to Use String Interning

While string interning is helpful, it’s not always the best choice:

Large Dynamic Strings: Interning large or frequently changing strings can increase memory usage because interned strings stay in memory for the application’s lifetime.
Short-Lived Strings: If strings are temporary, interning adds unnecessary overhead.

Best Practices for Using String Interning

Let the Compiler Handle Literals: String literals are interned automatically; you don’t need to do anything extra.
Manually Intern Sparingly: Use String.Intern only when you are sure it improves performance or saves memory.
Avoid Interning Large Strings: It can lead to high memory usage since interned strings cannot be garbage collected until the application exits.

Can String Interning Work Across Applications?

No, string interning does not work across applications. The reason lies in how .NET is designed. Each application runs in its own AppDomain with isolated memory space, including its own string intern pool. This ensures application independence, security, and stability.

For example:

Application A and Application B on the same server can create the string "Hello", but each application will have its own copy of the string in memory, stored in their respective string intern pools.
This isolation prevents sharing string references directly between applications.

Conclusion

String interning is a powerful feature in C# for optimizing memory usage and improving performance, especially for applications that use many repeated strings. By understanding how it works and using it wisely, you can write more efficient code. Experiment with the provided example to see how string interning affects your applications, and always consider the trade-offs when using this feature.

Forem: mohamed Tayel

Key Components of Semantic Kernel

1. The Kernel – The Orchestrator

2. Services – Beyond Just AI Models

3. Plugins – Extending Functionality

4. Functions, Prompts, and Templates

5. Memory

6. Filters

Putting It All Together – Example

Conclusion

Understanding Semantic Kernel

What Is Semantic Kernel?

Why Semantic Kernel Matters

Core Features of Semantic Kernel

The Three Big Benefits

A Practical Path

Wrapping Up

Generative AI: What It Is, How It Works, and Why It Matters

📌 Introduction: The Shocking Microsoft Decision

🤖 What’s the Difference Between AI and AGI?

🧠 How Does AI Work?

🎨 What Is Generative AI?

⚠️ What Are AI Hallucinations?

✍️ How to Write Better Prompts (Prompt Engineering)

⚖️ Who’s Responsible? The Ethics of AI

🧭 Are We Ready?

Singleton vs. Monostate in C#: Understand the Difference with a Real-World Story and Code Examples

🏢 The Singleton Story: "One Manager for the Entire Office"

✅ Singleton Characteristics

🧪 Singleton in C\

🏠 The Monostate Story: "Many Receptionists, One Phone Line"

✅ Monostate Characteristics

🧪 Monostate in C\

📊 Singleton vs. Monostate: Key Differences

🎯 When to Use Each?

🧠 Final Thoughts

Specification Pattern P3

🔹 Why Use the Specification Pattern?

❌ Problem Without It

✅ Solution: Use the Specification Pattern

📌 Step 3.1: Create ISpecification<T> (Defines the Contract)

🔹 What This Does

📌 Step 3.2: Create BaseSpecification<T> (Stores Filtering Logic)

🔹 What This Does

📌 Step 3.3: Create SpecificationEvaluator<T> (Applies the Specification)

🔹 What This Does

📌 Step 3.4: Modify GenericRepository<T> to Support Specifications

🔹 What This Does

📌 Step 3.5: Create ProductsWithFiltersSpecification

🔹 What This Does

📌 Step 3.6: Use the Specification in the Controller

🚀 Step 3 Complete!

🔹 Next Steps

❓ Need More Clarification?

Specification Pattern P2

🚀 Step 2: Implementing a Generic Repository (Introducing Category Repository)

💡 Goal:

📂 Updated Project Structure (With Generic Repository)

1️⃣ Define the Base Entity

2️⃣ Define the Generic Repository Interface

3️⃣ Implement the Generic Repository

4️⃣ Define the **Category**** Entity**

5️⃣ Implement the **ICategoryRepository**** Interface**

6️⃣ Implement the **CategoryRepository**

7️⃣ Register the Repositories in **Program.cs**

8️⃣ Create and Apply Migrations

🚀 Step 2 is Complete

🔜 What’s Next?

Specification Pattern P1

🚀 Step 1: Case Study Without Generic Repository & Specification Pattern

📂 Project Structure (Without Generic Repository & Specification Pattern)

1️⃣ Install Required NuGet Packages

2️⃣ Create the Product Entity

3️⃣ Create the ProductDto for API Response

4️⃣ Create the IProductRepository Interface

5️⃣ Implement the ProductRepository

6️⃣ Create the StoreContext (DbContext)

7️⃣ Create the API Controller: ProductsController

8️⃣ Register StoreContext in Program.cs

🎯 Final Steps: Running the API

📌 Step 3.1: Create `ISpecification<T>` (Defines the Contract)

📌 Step 3.2: Create `BaseSpecification<T>` (Stores Filtering Logic)

📌 Step 3.3: Create `SpecificationEvaluator<T>` (Applies the Specification)

📌 Step 3.4: Modify `GenericRepository<T>` to Support Specifications

📌 Step 3.5: Create `ProductsWithFiltersSpecification`

4️⃣ Define the `Category` Entity

5️⃣ Implement the `ICategoryRepository` Interface

6️⃣ Implement the `CategoryRepository`

7️⃣ Register the Repositories in `Program.cs`

2️⃣ Create the `Product` Entity

3️⃣ Create the `ProductDto` for API Response

4️⃣ Create the `IProductRepository` Interface

5️⃣ Implement the `ProductRepository`

6️⃣ Create the `StoreContext` (DbContext)

7️⃣ Create the API Controller: `ProductsController`

8️⃣ Register `StoreContext` in `Program.cs`

What Happens if We Don't Override `Equals` and `GetHashCode`?

Why Use `TryGetValue` Instead of Square Brackets?

Using LINQ’s `OrderBy`: