DEV Community: mohamed Tayel

Welcome to the Distributed Systems World — The Challenges Nobody Warned You About

mohamed Tayel — Tue, 19 May 2026 10:33:05 +0000

tags: distributedsystems, beginners, architecture, webdev
series: Fundamentals of Distributed Systems
cover_image:

You built a small web app. It runs on one machine. It works.

Then traffic grows. Or you hear someone in a meeting say "microservices." Or your boss talks about scaling. And suddenly there's a whole new world of words: replication, sharding, consensus, CAP theorem.

This series is for that moment. We'll go through it slowly, with simple pictures and everyday examples — no fancy terms, no scary code. By the end you'll understand what people mean by "distributed systems" and why everyone makes such a big deal about them.

🙏 Credit where it's due — This series is my attempt to internalize and share what I learned from Mahmoud Youssef's excellent course, Fundamentals of Distributed Systems on Udemy. The course material, structure, and topic flow are his work; the explanations, code examples, and diagrams in these articles are my own rewrite in my own words. If you find this useful, please consider taking the course — it goes much deeper than these articles can.

This first article is the map: what changes when you go from one machine to many, and the six big challenges you'll meet along the way.

Let's start.

So… what is a distributed system?

Here's the simple version:

A distributed system is a group of computers working together so the user thinks it's just one computer.

That's it. That's the whole idea.

Think about ordering food on an app. You tap a button. Two hundred milliseconds later you see "Order placed."

In those 200 milliseconds, a lot happened:

A server picked you out of millions of users
A payment system charged your card (maybe from a different country)
The order was saved on multiple computers
The restaurant's screen got a notification
Your phone got a confirmation

Many machines just had a tiny conversation to make your single tap work. That conversation is the hard part.

Why bother with multiple machines?

One machine is simpler. So why does anyone leave?

1. Growth. Every machine has a limit. The best CPU, the most RAM — there's always a ceiling. When your traffic passes that ceiling, you have no choice but to add more machines.

2. Safety. Machines die. Hard drives fail, power goes out, someone trips on a cable. If everything lives on one machine, when it dies, your app dies. With many machines, the others keep going.

3. Speed for everyone. A user in Japan asking a server in the US waits a long time — light takes time to travel. To feel "instant" worldwide, you need machines close to people.

That's the trade-off. You get growth, safety, and speed. In return, you inherit every problem we're about to talk about. Going distributed is not free.

Now, the six challenges.

Challenge 1: The network can't be trusted

Inside one computer, calling code is like talking to someone in the same room. You speak, they hear. Simple.

The moment two computers need to talk over a network, it's like texting. And texts can:

Get lost — never arrive at all
Arrive late — 5 seconds after you gave up waiting
Arrive twice — the same message appears two times
Arrive in the wrong order — your second message reaches them first

This isn't theoretical. There's actually a famous puzzle called the Two Generals Problem that proves something brutal: when two parties talk over an unreliable channel, neither can ever be 100% sure the other got the message. Not "hard" — actually impossible.

So when your code talks to another machine, you have to plan for the network lying to you. Every time.

Challenge 2: Many copies, one truth

When you have many machines, you usually have many copies of the same data. That's good — if one machine dies, the others still have it.

But it creates a new problem: how do you make sure all the copies agree?

Imagine a teacher saying "everyone write X equals 5 in your notebook." If one student is daydreaming, their notebook is wrong. Now whoever reads from that student gets the wrong answer.

The standard trick is simple:

One machine is the boss. Everybody listens to the boss.
The boss sends the change to everyone else.
The boss waits until most of them confirm they got it.
Only then does the boss say "done."

That "most of them" rule (called a majority or quorum) is the magic. It guarantees that even if some machines crash or miss the message, the system still knows what the truth is.

You're already using this without knowing — every modern database does it.

Challenge 3: How do you grow?

When traffic grows, you have two choices.

Option A: Make the machine bigger. Stronger CPU, more memory, faster disk. Your code doesn't change at all. Easy.

The problem? There's a biggest machine on Earth, and one day you'll hit it. Plus, it's still one machine — when it dies, everything dies with it.

Option B: Add more machines. Split the work across many.

The good news: almost no limit. One machine dies? The others keep going.

The bad news: now your code has to deal with all the headaches from this article. Coordination, copying data, splitting work, network problems — they all become real.

Most real systems do a bit of both: bigger machines where it makes sense, more machines for everything else.

Challenge 4: Some parts get hammered, others nap

When your data outgrows one machine, you split it across many. This is called partitioning (or sharding — same thing, different name).

It works beautifully — until traffic isn't evenly spread.

Imagine a supermarket with three cashiers. Sounds great, right? Now imagine every customer for some reason chose Cashier #2. Cashier #1 is reading a book. Cashier #3 is looking at the ceiling. Cashier #2 has a line out the door.

The total work isn't too much. It's just stuck in one place.

This is super common in real systems. One viral post, one huge customer, one trending topic — and suddenly one machine is melting while the rest are bored. The problem isn't more traffic. It's uneven traffic.

Fixing it is its own art — we'll spend a whole article on it later.

Challenge 5: Testing is genuinely harder

In a small app, when something breaks, you can usually figure it out. Open the logs, find the error, fix it.

In a distributed system, bugs are sneaky. They hide. They show up:

Only when many users hit the app at once
Only on one specific machine
Only at 3 AM during a holiday
Only when the network is slow that day

To catch them before they reach real users, we test on three levels:

Many small tests that check tiny pieces of code. Cheap and fast.
Some medium tests that check whether pieces work together. A bit slower.
A few big tests that try the whole app like a real user would. Slow and expensive.

The trick is having lots of small ones and very few big ones. The opposite (lots of big tests) makes everything slow and people stop running them.

Challenge 6: You can't fix what you can't see

Writing code is half the work. The other half is keeping it running 24/7 across all those machines.

For that, you need three things:

Logs — a written record of what happened. "User clicked button," "Database returned error," "Payment failed." Like a diary.

Numbers — how the system is doing right now. How fast? How busy? How many errors? Like a car dashboard.

Alerts — a phone call when something breaks. Because if nobody's watching, the numbers don't matter.

The basic rule of running things: if you can't see it, you can't fix it.

Quick recap

Six challenges. None go away, all are solvable.

#	Challenge	The short version
1	Network	Messages can be lost, late, doubled, or out of order.
2	Copies	Many copies of data must agree.
3	Growth	Bigger machine vs. more machines.
4	Uneven load	Splitting only works if traffic splits evenly too.
5	Testing	Bugs hide in timing. Use small, medium, and big tests.
6	Watching	You need logs, numbers, and alerts.

The honest truth: distributed systems aren't magic. They're a list of trade-offs. Once you see the trade-offs clearly, the choices start making sense.

What's next

Next article we'll dig into the first piece of the puzzle: how services talk to each other. Sometimes they wait for an answer (like a phone call). Sometimes they leave a message and move on (like a voicemail). When to use which? That's part 2.

After that: how data is stored, what "eventually consistent" means, how to keep things running when machines fail, and how to actually watch all of this in real time.

If anything here felt unclear — perfect. That means we have something good to dig into next. Drop a comment with what you want explored first.

See you in part 2. 👋

Follow the series — every article is simple language, lots of pictures, no scary code.

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!

DEV Community: mohamed Tayel

Welcome to the Distributed Systems World — The Challenges Nobody Warned You About

So… what is a distributed system?

Why bother with multiple machines?

Challenge 1: The network can't be trusted

Challenge 2: Many copies, one truth

Challenge 3: How do you grow?

Challenge 4: Some parts get hammered, others nap

Challenge 5: Testing is genuinely harder

Challenge 6: You can't fix what you can't see

Quick recap

What's next

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 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`: