Forem: AllCoderThings

Working with Data in C#: Arrays

AllCoderThings — Tue, 07 Apr 2026 06:33:22 +0000

Originally published at https://allcoderthings.com/en/article/csharp-arrays

In C#, arrays are used to store multiple values of the same type consecutively in memory. Indexing provides fast access to elements. This article provides a detailed introduction from array declarations to multi-dimensional arrays, as well as practical examples using Array class methods.

What is an Array?

An array is a structure where data of the same type is stored in consecutive memory cells. Each element is accessed using an index number. Indexes start at 0.

int[] numbers = new int[5]; // an int array with 5 elements

Declaring Arrays and Default Values

When declaring an array, its size is specified. If no values are assigned, default values are used:

int → 0
bool → false
string → null

string[] names = new string[3];
Console.WriteLine(names[0]); // null

Assigning and Accessing Array Elements (Indexing)

Elements are accessed by index. Since indexes start at 0, the last element is located at Length - 1.

int[] grades = new int[5];
grades[0] = 85;
grades[1] = 90;
grades[2] = 70;
grades[3] = 75;
grades[4] = 60;

Console.WriteLine(grades[1]); // 90
Console.WriteLine(grades[^1]); // 60, This will give last element (Length - 1)

int[] sub_grades = grades[1..4]; // A sub array: 90, 70, 75

grades[5] = 100; // This will throw IndexOutOfRangeException

Assigning or accessing indices outside the array size throws an IndexOutOfRangeException. For example, in array[4], valid indices are 0, 1, 2, 3. Values like -1, 4, or 5 will cause an error. The first element is always accessed with index 0.

Array Initialization Shortcuts

You can assign values directly while creating an array.

int[] numbers = { 10, 20, 30 };
var letters = new char[] { 'A', 'B', 'C' };

Iterating Over Arrays with Loops

for and foreach loops are used to access array elements.

int[] numbers = { 3, 6, 9 };

// with for
for (int i = 0; i < numbers.Length; i++)
    Console.WriteLine(numbers[i]);

// with foreach
foreach (var n in numbers)
    Console.WriteLine(n);

Multi-Dimensional Arrays (2D, 3D)

Multi-dimensional arrays are used to store data in table or matrix form. Elements can be accessed using indexes or iterated with nested loops.

int[,] matrix = new int[2, 3]
{
    {1, 2, 3},
    {4, 5, 6}
};

Console.WriteLine(matrix[1, 2]); // 6

// Iterating with nested for loops
for (int i = 0; i < matrix.GetLength(0); i++) // rows
{
    for (int j = 0; j < matrix.GetLength(1); j++) // columns
    {
        Console.Write(matrix[i, j] + " ");
    }
    Console.WriteLine();
}

// Output:
6
1 2 3 
4 5 6

Jagged Arrays

In jagged arrays, each row can have a different length. This is different from matrices.

int[][] jagged = new int[3][];
jagged[0] = new int[] {1, 2};
jagged[1] = new int[] {3, 4, 5};
jagged[2] = new int[] {6};

Console.WriteLine(jagged[1][2]); // 5

The Array Class and Useful Methods

In C#, all arrays derive from the Array class. Commonly used methods include:

int[] numbers = { 5, 2, 9, 1, 7 };

Array.Sort(numbers);    // Sorting
Array.Reverse(numbers); // Reversing
int index = Array.IndexOf(numbers, 9); // Searching for element

Console.WriteLine(index);

Sample Application: Student Grades

In the following example, students' grades are stored in an array and their average is calculated.

int[] grades = { 80, 70, 95, 60, 100 };

int total = 0;
foreach (var g in grades)
    total += g;

double average = (double)total / grades.Length;
Console.WriteLine($"Average: {average}");

TL;DR

Arrays store values of the same type consecutively in memory.

Indexes start at 0; default values are the type's default.

You can iterate through arrays with for and foreach.

Multi-dimensional and jagged arrays are supported.

The Array class provides useful array methods.

Design Patterns in C# (Factory, Singleton, Repository, Observer)

AllCoderThings — Wed, 01 Apr 2026 22:05:25 +0000

Originally published at https://allcoderthings.com/en/article/csharp-design-patterns-factory-singleton-repository-observer

Design Patterns provide standard and proven solutions for recurring problems in software development. Commonly used patterns in C# include Factory, Singleton, Repository, Observer, Strategy, Adapter, and Decorator. This article explores the core concepts of these patterns, their use cases, and C# examples.

Factory Pattern

The Factory pattern centralizes object creation. Instead of using new everywhere, the responsibility of creating objects is delegated to a factory class.

public interface IProduct { void DoWork(); }

public class ProductA : IProduct
{
    public void DoWork() => Console.WriteLine("Product A");
}

public class ProductB : IProduct
{
    public void DoWork() => Console.WriteLine("Product B");
}

public static class ProductFactory
{
    public static IProduct Create(string type) => type switch
    {
        "A" => new ProductA(),
        "B" => new ProductB(),
        _ => throw new ArgumentException("Invalid type")
    };
}

Singleton Pattern

The Singleton pattern ensures that only a single instance of a class is created. It is commonly used for logging, caching, or configuration objects.

public class Singleton
{
    private static Singleton? _instance;
    private static readonly object _lock = new();

    private Singleton() { }

    public static Singleton Instance
    {
        get
        {
            lock (_lock)
                return _instance ??= new Singleton();
        }
    }
}

Repository Pattern

The Repository pattern abstracts the data access layer. This way, the business logic layer becomes independent of database details.

public class Product { public int Id; public string Name = ""; }

public interface IProductRepository
{
    void Add(Product p);
    Product? GetById(int id);
}

public class InMemoryProductRepository : IProductRepository
{
    private readonly List<Product> _list = new();
    public void Add(Product p) => _list.Add(p);
    public Product? GetById(int id) => _list.FirstOrDefault(x => x.Id == id);
}

Observer Pattern

The Observer pattern establishes a publisher–subscriber relationship. When an object changes, all subscribers are notified. In C#, this is implemented with the event/delegate mechanism.

public class NewsAgency
{
    public event EventHandler<string>? NewsPublished;
    public void Publish(string news)
    {
        Console.WriteLine($"News: {news}");
        NewsPublished?.Invoke(this, news);
    }
}

Strategy Pattern

The Strategy pattern encapsulates algorithms in a way that allows them to be interchangeable. The client class does not need to know which algorithm is being used; the strategy is provided externally.

public interface IPaymentStrategy { void Pay(decimal amount); }

public class CreditCardPayment : IPaymentStrategy
{
    public void Pay(decimal amount) => Console.WriteLine($"{amount} USD paid by credit card.");
}

public class PayPalPayment : IPaymentStrategy
{
    public void Pay(decimal amount) => Console.WriteLine($"{amount} USD paid via PayPal.");
}

public class Checkout
{
    private readonly IPaymentStrategy _strategy;
    public Checkout(IPaymentStrategy strategy) => _strategy = strategy;
    public void ProcessOrder(decimal total) => _strategy.Pay(total);
}

Adapter Pattern

The Adapter pattern allows two incompatible classes to work together. It is often used to integrate legacy libraries or APIs into new systems.

// Old system
public class LegacyPrinter { public void PrintText(string t) => Console.WriteLine(t); }

// New interface
public interface IPrinter { void Print(string text); }

// Adapter
public class PrinterAdapter : IPrinter
{
    private readonly LegacyPrinter _legacy;
    public PrinterAdapter(LegacyPrinter legacy) => _legacy = legacy;
    public void Print(string text) => _legacy.PrintText(text);
}

Decorator Pattern

The Decorator pattern allows adding new behaviors dynamically to existing objects. This is a composition-based approach rather than inheritance.

public interface IMessage { string GetText(); }

public class SimpleMessage : IMessage
{
    private readonly string _text;
    public SimpleMessage(string text) => _text = text;
    public string GetText() => _text;
}

// Decorator
public class EncryptedMessage : IMessage
{
    private readonly IMessage _inner;
    public EncryptedMessage(IMessage inner) => _inner = inner;
    public string GetText() => Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes(_inner.GetText()));
}

Advantages

Factory: Abstracts object creation, increases flexibility.
Singleton: Manages shared resources with a single instance guarantee.
Repository: Abstracts data access, improves testability.
Observer: Establishes publisher–subscriber relationships, ensuring loose coupling.
Strategy: Makes algorithms interchangeable.
Adapter: Integrates incompatible systems.
Decorator: Allows adding new behavior dynamically.

TL;DR

Factory: Abstracts object creation.

Singleton: Guarantees a single instance.

Repository: Abstracts data access.

Observer: Notifies subscribers of changes.

Strategy: Algorithms can be easily switched.

Adapter: Adapts incompatible classes.

Decorator: Dynamically adds features.

Example: Product Creation, Listing, Order Flow, and Logging

The sample below demonstrates product creation (Factory), listing (Repository), order creation and status updates (Observer), payment (Strategy), receipt printing (Adapter), and message processing (Decorator) together. It uses safe singleton configuration with Lazy, an enum-based factory, custom EventArgs, and culture-aware currency formatting.

using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text;

// =======================
//  DOMAIN (Small model)
// =======================

// Express product types with an enum instead of strings to reduce errors.
public enum ProductType { Book, Phone }

// Simple data carrier (immutable) record type
public record Product(int Id, string Name, decimal Price);

// =======================
//  REPOSITORY (Storage)
// =======================

public interface IProductRepository
{
    void Add(Product p);
    Product? GetById(int id);
    IEnumerable<Product> GetAll(); // Expose IEnumerable; don't expose the inner list.
}

public class InMemoryProductRepository : IProductRepository
{
    private readonly List<Product> _list = new();

    public void Add(Product p) => _list.Add(p);

    public Product? GetById(int id) => _list.FirstOrDefault(x => x.Id == id);

    // If you want to return a protective copy: return _list.ToList();
    public IEnumerable<Product> GetAll() => _list;
}

// =======================
//  FACTORY (Product creation)
// =======================

public static class ProductFactory
{
    // Centralized creation: when adding a new type, just extend the switch.
    public static Product Create(ProductType type, int id)
        => type switch
        {
            ProductType.Book  => new Product(id, $"Book-{id}",   29.90m),
            ProductType.Phone => new Product(id, $"Phone-{id}", 599.00m),
            _ => throw new ArgumentOutOfRangeException(nameof(type))
        };
}

// =======================
//  SINGLETON SETTINGS
// =======================

// Thread-safe, lazy-loaded, simple Singleton via Lazy<T>.
public sealed class AppSettings
{
    private static readonly Lazy<AppSettings> _lazy = new(() => new AppSettings());
    public static AppSettings Instance => _lazy.Value;

    private AppSettings() { }

    public string StoreName { get; init; } = "My Store";
}

// =======================
//  OBSERVER (Event Model)
// =======================

// Custom EventArgs: a structure that is extensible instead of plain string.
public sealed class OrderStatusChangedEventArgs : EventArgs
{
    public string Status { get; }
    public DateTime When { get; }
    public OrderStatusChangedEventArgs(string status, DateTime when)
    {
        Status = status;
        When = when;
    }
}

public class Order
{
    public event EventHandler<OrderStatusChangedEventArgs>? StatusChanged;

    public int Id { get; }
    public Product Product { get; }

    public Order(int id, Product product)
    {
        Id = id;
        Product = product;
    }

    public void UpdateStatus(string status)
    {
        Console.WriteLine($"Order {Id} status: {status}");
        StatusChanged?.Invoke(this, new OrderStatusChangedEventArgs(status, DateTime.Now));
    }
}

// Event listeners (subscribers)
public class EmailNotifier
{
    public void OnOrderStatusChanged(object? sender, OrderStatusChangedEventArgs e)
        => Console.WriteLine($"[Email] Notification sent to customer: {e.Status} ({e.When:T})");
}

public class SmsNotifier
{
    public void OnOrderStatusChanged(object? sender, OrderStatusChangedEventArgs e)
        => Console.WriteLine($"[SMS] Notification sent to customer: {e.Status} ({e.When:T})");
}

// =======================
//  STRATEGY (Payment)
// =======================

public interface IPaymentStrategy
{
    void Pay(decimal amount);
}

public class CreditCardPayment : IPaymentStrategy
{
    public void Pay(decimal amount) => Console.WriteLine($"{amount:0.00} paid by credit card.");
}

public class PayPalPayment : IPaymentStrategy
{
    public void Pay(decimal amount) => Console.WriteLine($"{amount:0.00} paid via PayPal.");
}

// =======================
//  ADAPTER (Receipt Printing)
// =======================

// Legacy API
public class LegacyPrinter
{
    public void PrintText(string t) => Console.WriteLine("[LegacyPrinter] " + t);
}

// New interface
public interface IPrinter
{
    void Print(string text);
}

// Adapter: Connects the new interface to the legacy API.
public class PrinterAdapter : IPrinter
{
    private readonly LegacyPrinter _legacy;
    public PrinterAdapter(LegacyPrinter legacy) => _legacy = legacy;
    public void Print(string text) => _legacy.PrintText(text);
}

// =======================
//  DECORATOR (Message)
// =======================

public interface IMessage
{
    string GetText();
}

public class SimpleMessage : IMessage
{
    private readonly string _text;
    public SimpleMessage(string text) => _text = text;
    public string GetText() => _text;
}

// Decorator that logs the message
public class LoggedMessageDecorator : IMessage
{
    private readonly IMessage _inner;
    public LoggedMessageDecorator(IMessage inner) => _inner = inner;

    public string GetText()
    {
        var text = _inner.GetText();
        var preview = text.Length > 60 ? text.Substring(0, 60) + "..." : text;
        Console.WriteLine("[Log] Message created (preview): " + preview);
        return text;
    }
}

// Simple decorator that "encrypts" the message with Base64
public class EncryptedMessageDecorator : IMessage
{
    private readonly IMessage _inner;
    public EncryptedMessageDecorator(IMessage inner) => _inner = inner;

    public string GetText()
    {
        var raw = _inner.GetText();
        return Convert.ToBase64String(Encoding.UTF8.GetBytes(raw));
    }
}

// =======================
//  APPLICATION (Demo Flow)
// =======================

class Program
{
    static void Main()
    {
        // Currency formatting with en-US culture
        var enUS = new CultureInfo("en-US");

        Console.WriteLine($"Welcome to: {AppSettings.Instance.StoreName}");
        Console.WriteLine();

        // Add products via Repository + Factory
        IProductRepository repo = new InMemoryProductRepository();
        var p1 = ProductFactory.Create(ProductType.Book,  1);
        var p2 = ProductFactory.Create(ProductType.Phone, 2);
        repo.Add(p1);
        repo.Add(p2);

        // List products (culture-aware price)
        Console.WriteLine("Products in stock:");
        foreach (var p in repo.GetAll())
            Console.WriteLine($"- {p.Id}: {p.Name} {p.Price.ToString("C", enUS)}");
        Console.WriteLine();

        // Create order and subscribe to events
        var order = new Order(1001, p1);
        var email = new EmailNotifier();
        var sms   = new SmsNotifier();

        // Add listeners to events
        order.StatusChanged += email.OnOrderStatusChanged;
        order.StatusChanged += sms.OnOrderStatusChanged;

        // Payment (Strategy)
        IPaymentStrategy payment = new CreditCardPayment();
        Console.WriteLine("Processing payment:");
        payment.Pay(order.Product.Price);
        Console.WriteLine();

        // Order lifecycle (Observer gets triggered)
        order.UpdateStatus("Approved");
        order.UpdateStatus("Shipped");

        // (Optional) Unsubscribe SMS listener
        order.StatusChanged -= sms.OnOrderStatusChanged;
        order.UpdateStatus("Delivered");
        Console.WriteLine();

        // Print receipt (use legacy printer API through Adapter)
        IPrinter printer = new PrinterAdapter(new LegacyPrinter());
        printer.Print($"Receipt for Order #{order.Id}: {order.Product.Name} - {order.Product.Price.ToString("C", enUS)}");
        Console.WriteLine();

        // Message processing (Decorator)
        // Goal: Log plain text, then encrypt it before storing/sending.
        // Therefore, chain Logged first, then Encrypted decorator.
        IMessage msg = new SimpleMessage($"Thank you for your purchase: {order.Product.Name}!");
        msg = new LoggedMessageDecorator(msg);      // 1) Log: LOG THE PLAIN TEXT
        msg = new EncryptedMessageDecorator(msg);   // 2) Encrypt: Output encrypted text

        var finalText = msg.GetText();
        Console.WriteLine("Final message to store/send (Base64):");
        Console.WriteLine(finalText);
        Console.WriteLine();

        // Switch strategy at runtime
        payment = new PayPalPayment();
        Console.WriteLine("Second payment with a different strategy:");
        payment.Pay(199.99m);

        Console.WriteLine("\nDemo completed.");
    }
}

SOLID Principles with C#

AllCoderThings — Fri, 06 Mar 2026 17:34:51 +0000

Originally published at https://allcoderthings.com/en/article/csharp-solid-principles

In software development, the SOLID principles, defined by Robert C. Martin, are five fundamental guidelines aimed at creating more flexible, readable, and maintainable systems in object-oriented programming (OOP). In C#, these principles are widely applied as guiding rules in class design.

1. Single Responsibility Principle (SRP)

A class should have only one responsibility. In other words, it should have only one reason to change. If a class performs multiple tasks (e.g., saving data + generating reports), it becomes harder to maintain and more prone to errors.

// Wrong: Handles both saving orders and printing invoices
public class OrderManager
{
    public void SaveOrder(Order order) { /* save */ }
    public void PrintInvoice(Order order) { /* print */ }
}

// Correct: Each class has a single responsibility
public class OrderRepository
{
    public void Save(Order order) { /* save */ }
}

public class InvoicePrinter
{
    public void Print(Order order) { /* print */ }
}

2. Open/Closed Principle (OCP)

Classes should be open for extension, but closed for modification. That means new behavior should be added without changing existing class code. This is usually achieved by using abstract classes or interfaces.

// Wrong: Adding a new payment method requires modifying the class
public class PaymentService
{
    public void Pay(string type)
    {
        if (type == "CreditCard") { /* ... */ }
        else if (type == "PayPal") { /* ... */ }
    }
}

// Correct: Adding a new method requires creating a new class
public interface IPayment
{
    void Pay();
}

public class CreditCardPayment : IPayment
{
    public void Pay() { /* ... */ }
}

public class PayPalPayment : IPayment
{
    public void Pay() { /* ... */ }
}

3. Liskov Substitution Principle (LSP)

Derived classes must be substitutable for their base classes. In other words, a subclass should work correctly wherever its base class is expected. A subclass must not break the contract of its base class.

public abstract class Bird
{
    public abstract void Fly();
}

public class Sparrow : Bird
{
    public override void Fly() { Console.WriteLine("Sparrow is flying"); }
}

// Wrong: Penguins cannot fly, but Fly() is forced
public class Penguin : Bird
{
    public override void Fly() { throw new NotImplementedException(); }
}

Here, the Penguin class violates LSP. Because the Bird abstract class imposes the assumption that "all birds can fly". Instead, separate interfaces like IFlyingBird and INonFlyingBird should be defined.

4. Interface Segregation Principle (ISP)

A class should not be forced to implement large interfaces containing methods it does not need. Instead, smaller, more focused interfaces should be preferred.

// Wrong: All animals are forced to walk, fly, and swim
public interface IAnimal
{
    void Walk();
    void Fly();
    void Swim();
}

// Correct: Split into smaller interfaces
public interface IWalkable { void Walk(); }
public interface IFlyable { void Fly(); }
public interface ISwimmable { void Swim(); }

public class Dog : IWalkable, ISwimmable
{
    public void Walk() { /* ... */ }
    public void Swim() { /* ... */ }
}

5. Dependency Inversion Principle (DIP)

High-level classes should not depend directly on low-level classes. Both should depend on abstractions (interfaces or abstract classes). This principle forms the basis of Dependency Injection.

// Wrong: Service depends directly on ConsoleLogger
public class Service
{
    private readonly ConsoleLogger _logger = new ConsoleLogger();
}

// Correct: Depends on abstraction
public interface ILogger
{
    void Log(string msg);
}

public class ConsoleLogger : ILogger
{
    public void Log(string msg) => Console.WriteLine(msg);
}

public class Service
{
    private readonly ILogger _logger;
    public Service(ILogger logger) { _logger = logger; }
}

Advantages

Improves code readability and maintainability.
Provides an architecture more resistant to changes.
Makes unit testing easier.
Reduces code duplication and increases reusability.

TL;DR

SRP: A class should have only one responsibility.

OCP: Open for extension, closed for modification.

LSP: Subclasses should be substitutable for base classes.

ISP: Prefer small, focused interfaces over large ones.

DIP: Depend on abstractions, not concrete classes.

Dependency Injection Basics in C#

AllCoderThings — Fri, 27 Feb 2026 13:18:04 +0000

Originally published at https://allcoderthings.com/en/article/csharp-dependency-injection-basics

In software development, Dependency Injection (DI) is an important design pattern used to manage dependencies. With DI, classes receive the objects they need from the outside instead of creating them internally. This makes code more flexible, testable, and maintainable. In the C# and .NET Core ecosystem, DI is supported out of the box.

What is a Dependency?

A class depends on another class when it requires its functionality. For example, an OrderService may need an ILogger instance when creating an order. If OrderService directly uses new Logger(), it becomes tightly coupled to the Logger class.

public class OrderService
{
    private readonly Logger _logger = new Logger();

    public void CreateOrder(string product)
    {
        _logger.Log($"Order created: {product}");
    }
}

public class Logger
{
    public void Log(string message) => Console.WriteLine(message);
}

In this approach, the Logger cannot be replaced. If you want to use a different logging system, you must modify the OrderService code. This is where Dependency Injection comes into play.

Solution with Dependency Injection

When DI is used, dependencies are abstracted and provided from the outside (via constructor or method parameter). This way, OrderService depends on the ILogger interface, and the external world decides which logger to use.

public interface ILogger
{
    void Log(string message);
}

public class ConsoleLogger : ILogger
{
    public void Log(string message) => Console.WriteLine("[Console] " + message);
}

public class FileLogger : ILogger
{
    public void Log(string message) => 
        System.IO.File.AppendAllText("log.txt", message + "\n");
}

public class OrderService
{
    private readonly ILogger _logger;

    // Constructor Injection
    public OrderService(ILogger logger)
    {
        _logger = logger;
    }

    public void CreateOrder(string product)
    {
        _logger.Log($"Order created: {product}");
    }
}

class Program
{
    static void Main()
    {
        // Different loggers can be selected
        ILogger logger = new ConsoleLogger();
        var service = new OrderService(logger);

        service.CreateOrder("Laptop");
    }
}

In this example, OrderService is no longer tied to a specific Logger class; it only depends on the ILogger interface. Therefore, ConsoleLogger or FileLogger can be easily swapped.

Types of Dependency Injection

Constructor Injection: Dependencies are provided through the constructor (most common method).
Property Injection: Dependencies are assigned through public properties.
Method Injection: Dependencies are passed via method parameters.

Using DI in .NET Core

In .NET Core applications, a built-in DI container is available. Services are registered in Program.cs or Startup.cs, and they are automatically injected into classes where needed.

var builder = WebApplication.CreateBuilder(args);

// Register services
builder.Services.AddScoped<ILogger, ConsoleLogger>();
builder.Services.AddScoped<OrderService>();

var app = builder.Build();

app.MapGet("/order", (OrderService service) =>
{
    service.CreateOrder("Phone");
    return "Order processed.";
});

app.Run();

Here, the DI container automatically creates and injects a ConsoleLogger instance for OrderService.

Service Lifetimes (Service Lifecycles)

When registering services in the .NET Core DI container, you must choose a lifetime. The lifetime determines how long a service instance lives and how often a new instance is created.

Transient: A new instance is created every time it is requested.
Scoped: A single instance is created per HTTP request. The same instance is reused within that request.
Singleton: A single instance is created when the application starts and reused for the entire lifetime of the application.

// Transient
builder.Services.AddTransient<ILogger, ConsoleLogger>();

// Scoped
builder.Services.AddScoped<ILogger, ConsoleLogger>();

// Singleton
builder.Services.AddSingleton<ILogger, ConsoleLogger>();

Use Transient for lightweight, stateless services.

Use Scoped for request-based services (e.g., DbContext).

Use Singleton for shared, application-wide services.

Advantages

Loose Coupling: Classes depend on interfaces rather than specific implementations.
Testability: Unit testing is easier with mock or fake objects.
Flexibility: Different implementations can be swapped easily.
Maintainability: Dependencies are managed centrally, improving readability and maintainability.

TL;DR

Dependency Injection: Classes receive the objects they need from outside.

Constructor Injection: The most common approach; dependencies are passed via constructors.

.NET Core: Provides a built-in DI container.

Benefits: Enables more flexible, testable, and maintainable architecture.

Extension Methods in C#

AllCoderThings — Tue, 24 Feb 2026 11:34:53 +0000

Originally published at https://allcoderthings.com/en/article/csharp-extension-methods

In C#, extension methods provide a way to add new methods to existing classes or structs without modifying their source code. These methods are actually defined inside a static class, and their first parameter specifies the extended type with the this keyword. Extension methods enhance functionality while keeping original types intact.

Basic Syntax

An extension method must always be defined inside a static class. Its first parameter is marked with this to specify the type it extends.

// Definition of an extension method
public static class StringExtensions
{
    public static bool IsNullOrEmpty(this string? text)
    {
        return string.IsNullOrEmpty(text);
    }
}

class Program
{
    static void Main()
    {
        string s1 = null;
        string s2 = "Hello";

        Console.WriteLine(s1.IsNullOrEmpty()); // True
        Console.WriteLine(s2.IsNullOrEmpty()); // False
    }
}

Here, the IsNullOrEmpty method is defined inside StringExtensions, but it can be used as if it were part of the string type.

Use Cases for Extension Methods

Add new functionality to existing classes (e.g., string, DateTime).
Call common helper methods with a more natural syntax.
Simplify fluent coding patterns such as LINQ.

Practical Examples

Extension methods make common operations more readable and convenient in daily coding.

// Extension methods for integers
public static class IntExtensions
{
    // Is the number even?
    public static bool IsEven(this int number) => number % 2 == 0;
    // Is the number odd?
    public static bool IsOdd(this int number) => number % 2 != 0;
}

class Program
{
    static void Main()
    {
        int x = 10;
        Console.WriteLine(x.IsEven()); // True
        Console.WriteLine(x.IsOdd());  // False
    }
}

Here, IsEven and IsOdd are defined as if they belonged to the int type. Any int variable can directly use these methods.

// Extension method for DateTime
public static class DateTimeExtensions
{
    // Checks whether the given date falls on a weekend
    public static bool IsWeekend(this DateTime dt)
        => dt.DayOfWeek == DayOfWeek.Saturday || dt.DayOfWeek == DayOfWeek.Sunday;
}

class Program
{
    static void Main()
    {
        DateTime today = DateTime.Now;
        Console.WriteLine(today.IsWeekend() ? "Weekend" : "Weekday");
    }
}

LINQ and Extension Methods

All LINQ methods are defined as extension methods. For example, Where, Select, and OrderBy are extension methods implemented for IEnumerable<T>.

var numbers = new List<int> { 1, 2, 3, 4, 5, 6 };

// Where is actually an extension method
var evens = numbers.Where(n => n % 2 == 0);

Console.WriteLine(string.Join(", ", evens)); // 2, 4, 6

Example: String Manipulation

Let’s define extension methods for performing checks and formatting on strings.

public static class TextExtensions
{
    // Converts a string into title case (capitalize each word)
    public static string ToTitleCase(this string text)
    {
        if (string.IsNullOrWhiteSpace(text)) return string.Empty;

        return string.Join(" ",
            text.Split(' ', StringSplitOptions.RemoveEmptyEntries)
                .Select(w => char.ToUpper(w[0]) + w.Substring(1).ToLower()));
    }

    // Checks whether a string contains any digits
    public static bool ContainsDigit(this string text)
    {
        return text.Any(char.IsDigit);
    }
}

class Program
{
    static void Main()
    {
        string input = "hello world 2025";

        Console.WriteLine(input.ToTitleCase());   // "Hello World 2025"
        Console.WriteLine(input.ContainsDigit()); // True
    }
}

Advantages

Improves readability with natural syntax.
Allows reusing existing classes without creating new ones.
Adds new features without altering existing types.
Centralizes helper methods in a single place.

TL;DR

Extension methods are a way to add new functionality to existing classes.

They are defined inside a static class; the first parameter with this specifies the extended type.

LINQ methods are the most common examples of extension methods.

They improve code readability and flexibility.

Lambda Expressions in C#

AllCoderThings — Sat, 21 Feb 2026 20:25:59 +0000

Originally published at https://allcoderthings.com/en/article/csharp-lambda-expressions

In C#, lambda expressions allow writing anonymous (unnamed) methods in a short and readable way. They are defined using the => (lambda operator). Lambda expressions are especially common in LINQ queries, event subscriptions, and functional programming styles.

Basic Lambda Syntax

A lambda expression consists of a parameter list and a body. For simple expressions, curly braces are not required; when using a multi-line body, braces and return can be written.

// Single parameter, single-line expression
Func<int, int> square = x => x * x;
Console.WriteLine(square(5)); // 25

// Lambda with multiple parameters
Func<int, int, int> add = (a, b) => a + b;
Console.WriteLine(add(3, 4)); // 7

// Multi-line lambda
Func<int, int, int> multiply = (a, b) =>
{
    Console.WriteLine($"Multiplying: {a} * {b}");
    return a * b;
};
Console.WriteLine(multiply(2, 6)); // 12

Lambda with Action and Func

Lambda expressions are commonly used with Action and Func types:

Action: Represents methods that do not return a value.
Func: Represents methods that return a result.

Action greet = () => Console.WriteLine("Hello!");
greet(); // Hello!

Func<string, int> length = s => s.Length;
Console.WriteLine(length("Lambda")); // 6

Lambda and LINQ

Lambda expressions are most widely used in LINQ queries. They make it easy to filter, sort, and project collections.

var numbers = new List<int> { 1, 2, 3, 4, 5, 6 };

// Filter even numbers
var evens = numbers.Where(x => x % 2 == 0);

Console.WriteLine(string.Join(", ", evens)); // 2, 4, 6

// Calculate squares
var squares = numbers.Select(x => x * x);
Console.WriteLine(string.Join(", ", squares)); // 1, 4, 9, 16, 25, 36

Using Lambda with Events

Lambda expressions provide a practical way to handle events. This allows capturing an event concisely without defining a separate method.

public class Button
{
    public event EventHandler? Click;

    public void SimulateClick()
    {
        Console.WriteLine("Button clicked!");
        Click?.Invoke(this, EventArgs.Empty);
    }
}

class Program
{
    static void Main()
    {
        var btn = new Button();

        // Capture event with a lambda
        btn.Click += (s, e) => Console.WriteLine("Event: Button was clicked.");

        btn.SimulateClick();
    }
}

Closure and Variable Capture

Lambda expressions can access variables in their defining scope. This is called a closure.

int counter = 0;

Action increment = () =>
{
    counter++;
    Console.WriteLine($"Counter: {counter}");
};

increment(); // Counter: 1
increment(); // Counter: 2

Here, the lambda expression “captures” the outer counter variable and continues operating on it.

Example: Filtering and Reporting

In a store application, lambda expressions can be used to filter products by price and generate reports.

public class Product
{
    public string Name { get; set; } = string.Empty;
    public decimal Price { get; set; }
}

class Program
{
    static void Main()
    {
        var products = new List<Product>
        {
            new Product { Name = "Laptop", Price = 25000m },
            new Product { Name = "Mouse", Price = 300m },
            new Product { Name = "Keyboard", Price = 600m },
            new Product { Name = "Monitor", Price = 4500m }
        };

        // Find products above 1000
        var expensiveProducts = products.Where(p => p.Price > 1000);

        foreach (var p in expensiveProducts)
        {
            Console.WriteLine($"{p.Name} - {p.Price} USD");
        }

        // Calculate average price
        var avg = products.Average(p => p.Price);
        Console.WriteLine($"Average price: {avg:0.00} USD");
    }
}

TL;DR

Short, anonymous methods are defined with the => operator.

Commonly used with Action and Func.

Indispensable in LINQ for filtering, selecting, and ordering.

Can be used in event subscriptions without extra boilerplate.

Supports closures, allowing access to external variables.

Delegates and Events in C#

AllCoderThings — Tue, 17 Feb 2026 11:20:39 +0000

Originally published at https://allcoderthings.com/en/article/csharp-delegates-and-events

In C#, delegates and events are the foundation of event-driven programming. A delegate is a type-safe reference that can point to a method. An event allows a class to notify the outside world that “a certain action has occurred.” These mechanisms enable loosely coupled architectures and make it possible to dynamically execute different methods.

What is a Delegate?

A delegate is a type that holds references to methods with a specific signature (parameters and return type). In other words, it allows methods to be treated like variables.

A delegate variable can point to a compatible method and invoke it dynamically. This enables flexible and loosely coupled code.

// A delegate definition
public delegate void Notify(string message);

class Program
{
    static void SendEmail(string message)
    {
        Console.WriteLine("Email sent: " + message);
    }

    static void Main()
    {
        Notify notifyHandler;

        // Assign a method to the delegate
        notifyHandler = SendEmail;

        notifyHandler("Meeting is at 10:00 AM.");
    }
}

In this example, the notifyHandler delegate references the SendEmail method and invokes it.

Multicast Delegates

A multicast delegate is a delegate that can reference multiple methods at the same time. In C#, delegates are multicast by default when you combine them using +=.

When you invoke a multicast delegate, it calls each subscribed method in the invocation list in the order they were added. This is especially useful for broadcasting a notification to multiple listeners.

Example

using System;

class Program
{
    delegate void Notify(string message);

    static void Main()
    {
        Notify notifier = LogToConsole;
        notifier += LogToFile;
        notifier += SendEmail;

        notifier("Build completed.");
    }

    static void LogToConsole(string message)
    {
        Console.WriteLine("[Console] " + message);
    }

    static void LogToFile(string message)
    {
        Console.WriteLine("[File] " + message);
    }

    static void SendEmail(string message)
    {
        Console.WriteLine("[Email] " + message);
    }
}

You can remove a method from the invocation list using -=:

notifier -= SendEmail;

Multicast delegates are commonly used behind the scenes in events.

If one handler throws an exception, invocation stops and the remaining handlers are not executed.

If the delegate has a return type, only the result of the last method is returned.

Return Value Behavior

If a multicast delegate has a return type, each method in the invocation list is executed, but only the result of the last method is returned.

using System;

class Program
{
    delegate int Calculate(int x);

    static void Main()
    {
        Calculate calc = Square;
        calc += Double;

        int result = calc(5);

        Console.WriteLine(result); 
        // Output: 10 (result of the last method: Double)
    }

    static int Square(int x)
    {
        Console.WriteLine("Square called");
        return x * x;
    }

    static int Double(int x)
    {
        Console.WriteLine("Double called");
        return x * 2;
    }
}

Even though both Square and Double are executed, the delegate returns the result of Double, because it was the last method added to the invocation list.

All methods in the invocation list are executed in order.

Only the return value of the last method is preserved.

For this reason, multicast delegates are typically used with void return types (like events).

What is an Event?

An event is a mechanism that signals when an action has occurred. Events are built on top of delegates and provide controlled access to them. The event keyword is used for declaration, and it can only be accessed externally using += (subscribe) or -= (unsubscribe).

This ensures that:

The event can only be triggered inside the declaring class.
External code cannot overwrite the invocation list.
Encapsulation is preserved.

public class Button
{
    // Event definition (EventHandler is a standard delegate type)
    public event EventHandler? Click;

    public void SimulateClick()
    {
        Console.WriteLine("Button clicked!");

        // Trigger the event
        Click?.Invoke(this, EventArgs.Empty);
    }
}

class Program
{
    static void Main()
    {
        var btn = new Button();

        // Subscribe to the event
        btn.Click += (s, e) => Console.WriteLine("Event: Button was clicked.");

        btn.SimulateClick();
    }
}

The null-conditional operator (?.) ensures that the event is only invoked if there are subscribers, preventing a NullReferenceException.

Here, the Button class publishes a Click event. The subscribed lambda expression executes when the event is triggered. This pattern is widely used in UI frameworks such as WinForms and WPF.

EventHandler and EventArgs

In C#, the most commonly used standard delegate for events is EventHandler. It follows the conventional event pattern: (object sender, EventArgs e).

By deriving from EventArgs, you can pass additional data related to the event. This follows the official .NET event design guidelines.

public class OrderEventArgs : EventArgs
{
    public int OrderId { get; }
    public decimal Amount { get; }

    public OrderEventArgs(int orderId, decimal amount)
    {
        OrderId = orderId;
        Amount = amount;
    }
}

public class OrderService
{
    public event EventHandler<OrderEventArgs>? OrderCreated;

    public void CreateOrder(int id, decimal amount)
    {
        Console.WriteLine($"Order created (ID={id}, Amount={amount})");

        // Trigger the event
        OrderCreated?.Invoke(this, new OrderEventArgs(id, amount));
    }
}

class Program
{
    static void Main()
    {
        var service = new OrderService();

        service.OrderCreated += (s, e) =>
        {
            Console.WriteLine($"Notification: Order received (#{e.OrderId}, {e.Amount} USD)");
        };

        service.CreateOrder(101, 250m);
    }
}

In this example, the OrderService class raises the OrderCreated event whenever a new order is created. The subscriber receives the order details through the custom OrderEventArgs class.

This approach ensures type safety and makes event-driven communication clear and structured.

Delegate vs Event (Encapsulation)

Although events are built on top of delegates, they are not the same thing. The key difference lies in encapsulation and access control.

A delegate field can be modified freely from outside the class, while an event restricts external access and protects the invocation list.

Delegate Example

public class Publisher
{
    public Action? OnChange;
}

Because OnChange is a delegate field:

External code can assign it using =.
All existing subscribers can be removed accidentally.
It can even be set to null.
External code can invoke it directly.

publisher.OnChange = null;      // Clears all subscribers
publisher.OnChange = SomeMethod; // Replaces invocation list
publisher.OnChange?.Invoke();   // Can be triggered externally

Event Example

public class Publisher
{
    public event Action? OnChange;
}

Because OnChange is declared as an event:

External code can only use += and -=.
It cannot overwrite the invocation list using =.
It cannot invoke the event directly.
The event can only be triggered inside the declaring class.

Delegates provide flexibility.

Events provide controlled access and encapsulation.

For public notifications, events should almost always be preferred over delegate fields.

Modern Alternatives: Action & Func

In modern C#, defining custom delegate types is often unnecessary. Instead, you can use the built-in generic delegates Action and Func.

These delegates are flexible, concise, and widely used in the .NET ecosystem (including LINQ, async programming, and task-based APIs).

Action

Action represents a method that does not return a value. It can accept zero or more parameters.

Action log = message => Console.WriteLine(message);

log("Application started.");

Func

Func<T, TResult> represents a method that returns a value. The last generic parameter always represents the return type.

Func add = (a, b) => a + b;

int result = add(5, 3); // 8

Action is used when no return value is needed.

Func is used when a return value is required.

Using these built-in delegates reduces boilerplate code.

Most modern C# codebases prefer Action and Func over custom delegate definitions.

Unsubscribing & Memory Leaks

One important aspect of working with events is unsubscribing. If you subscribe to an event but never unsubscribe, it may lead to unexpected memory leaks.

Events maintain a strong reference to their subscribers. As long as the publisher object is alive, the subscriber cannot be garbage collected.

Why This Can Be a Problem

Consider a long-lived publisher (for example, a service or singleton) and a short-lived subscriber (for example, a UI component). If the subscriber does not unsubscribe, it will remain in memory even after it is no longer needed.

public class Publisher
{
    public event Action? OnChange;

    public void Raise()
    {
        OnChange?.Invoke();
    }
}

public class Subscriber
{
    private readonly Publisher _publisher;

    public Subscriber(Publisher publisher)
    {
        _publisher = publisher;
        _publisher.OnChange += HandleChange;
    }

    private void HandleChange()
    {
        Console.WriteLine("Change detected.");
    }

    public void Dispose()
    {
        // Important: unsubscribe!
        _publisher.OnChange -= HandleChange;
    }
}

If Dispose is never called, the Subscriber instance remains referenced by the event and cannot be garbage collected.

Always unsubscribe from events when the subscriber’s lifetime ends.

This is especially important in UI frameworks (WinForms, WPF, Blazor, etc.).

Long-lived publishers + short-lived subscribers = potential memory leak.

Implementing IDisposable is a common solution for safe unsubscription.

Thread Safety & Best Practices

When working with events in multi-threaded environments, thread safety becomes important. A common issue occurs when checking for null before invoking an event.

Potential Race Condition

if (OnChange != null)
{
    OnChange(this, EventArgs.Empty);
}

Between the null check and the invocation, another thread could unsubscribe from the event. This may result in a NullReferenceException.

Safe Invocation Pattern

To avoid this race condition, copy the delegate reference to a local variable before invoking it:

var handler = OnChange;
handler?.Invoke(this, EventArgs.Empty);

This ensures that the invocation list cannot change between the null check and the method call.

Modern Syntax

In most cases, the null-conditional operator provides a concise and safe way to invoke events:

OnChange?.Invoke(this, EventArgs.Empty);

Always use safe invocation patterns in multi-threaded scenarios.

Prefer ?.Invoke for clean and modern syntax.

Events are multicast delegates — one failing handler can stop execution.

Consider isolating handler calls with try/catch if reliability is critical.

When to Use Delegates and Events?

Delegates: Use when passing methods as parameters, implementing callbacks, or creating flexible execution pipelines. Prefer Action and Func in modern C# code.
Events: Use when exposing notifications from a class while preserving encapsulation. Events are ideal for UI interactions, domain events, and state changes.
Best Practice: Use events for public notifications and avoid exposing raw delegate fields. Always unsubscribe when necessary and follow safe invocation patterns.

TL;DR

delegate: Type-safe references that point to methods and support multicast invocation.

event: A controlled delegate that allows subscription but preserves encapsulation.

EventHandler and EventArgs: Follow the standard .NET event pattern for passing data.

Action and Func: Modern alternatives to custom delegate definitions.

throw; and safe invocation patterns help maintain reliability and debugging clarity.

Always unsubscribe from events when needed to prevent memory leaks.

Use events for notifications; use delegates (or Action/Func) for callbacks and execution flow.

Interfaces and Abstract Classes in C#

AllCoderThings — Sat, 14 Feb 2026 17:36:35 +0000

Originally published at https://allcoderthings.com/en/article/csharp-interface-and-abstract-class

In C#, abstract classes and interfaces are used to build flexible and extensible object-oriented architectures. Both help define common behaviors, but there are important differences. An abstract class can provide partial implementation (method bodies), whereas an interface only declares signatures and leaves the implementation entirely to derived classes.

Abstract Class

An abstract class is defined with the abstract keyword and cannot be instantiated directly. It defines common properties and methods, but some methods can be marked as abstract to force subclasses to implement them. Abstract classes may also include regular methods—i.e., partially implemented behavior.

public abstract class Shape
{
    public string Color { get; set; } = "Black";

    // Must be implemented by subclasses
    public abstract double GetArea();

    // A common method
    public void PrintColor()
    {
        Console.WriteLine($"Color: {Color}");
    }
}

public class Circle : Shape
{
    public double Radius { get; set; }

    public override double GetArea()
    {
        return Math.PI * Radius * Radius;
    }
}

Here, the Shape abstract class provides a common Color property, but leaves GetArea() to subclasses. The Circle class implements it in its own way.

Interface

An interface is defined with the interface keyword. It contains only method and property signatures and no bodies (prior to C# 8). A class can implement multiple interfaces (enabling a form of multiple inheritance). This establishes a “common contract” among different classes.

public interface ILogger
{
    void Log(string message);
}

public class FileLogger : ILogger
{
    public void Log(string message)
    {
        Console.WriteLine($"Logged to file: {message}");
    }
}

public class DbLogger : ILogger
{
    public void Log(string message)
    {
        Console.WriteLine($"Logged to database: {message}");
    }
}

Classes implementing ILogger perform logging in different ways, but they must all expose the same method signature: Log(string).

Abstract Class vs Interface

Key differences:

Abstract Class: Can define common behavior and required behavior. Can contain property and method bodies.
Interface: Declares signatures only. Supports multiple implementation.
Abstract Class: A class can inherit from only one abstract (base) class.
Interface: A class can implement multiple interfaces.
Abstract Class: Can contain shared state, fields, and a constructor.
Interface: Does not contain fields or a constructor.

Real-World Scenario: Production Line (Interface + Abstract Class)

In the example below, we define an IProduct interface to model a product manufacturing flow and an abstract class (ProductBase) that partially implements it. IProduct declares the common contract (properties + method signatures), while ProductBase provides the shared flow (template method: Production()) and partial implementation. MetalProduct, WoodProduct, and PlasticProduct customize this structure. We use an enum (SizeOption) for consistent size values like “S/M/L,” and a simple quality-check interface IQualityCheck that products implement.


using System;
using System.Collections.Generic;

// Enum for standardizing sizes
public enum SizeOption
{
    Small,
    Medium,
    Large
}

// Common contract: properties and behaviors all products must have
public interface IProduct
{
    string Name { get; set; }
    string SKU { get; set; }
    SizeOption Size { get; set; }
    decimal UnitCost { get; set; } // Unit cost
    int Stock { get; set; }        // Units in stock

    // Production flow and cost calculation
    void Production();
    decimal CalculateCost(int quantity);
    string GetSpecs();
}

// Simple quality-check contract
public interface IQualityCheck
{
    bool QualityCheck(out string reason);
}

// ABSTRACT CLASS: Partial implementation + shared flow (Template Method Pattern)
public abstract class ProductBase : IProduct, IQualityCheck
{
    public string Name { get; set; } = string.Empty;
    public string SKU { get; set; } = string.Empty;
    public SizeOption Size { get; set; }
    public decimal UnitCost { get; set; }
    public int Stock { get; set; }

    // Material-based multiplier (subclasses can override)
    protected virtual decimal MaterialFactor => 1.00m;

    // Template method: runs production steps in a fixed flow
    public void Production()
    {
        LogStep($"Production started: {Name} ({SKU})");
        PrepareMaterials();
        Assemble();
        Finish();
        LogStep("Production completed.\n");
    }

    // Base cost calculation (subclasses can override if needed)
    public virtual decimal CalculateCost(int quantity)
    {
        if (quantity <= 0) return 0m;

        // Simple model: unit cost * quantity * material factor * overhead (10%)
        decimal baseCost = UnitCost * quantity * MaterialFactor;
        decimal overhead = baseCost * 0.10m;
        return baseCost + overhead;
    }

    // Common technical specification output
    public virtual string GetSpecs()
        => $"SKU: {SKU}, Size: {Size}, Unit Cost: {UnitCost:0.00} USD, Stock: {Stock}";

    // Default quality check: is cost and stock sensible?
    public virtual bool QualityCheck(out string reason)
    {
        if (UnitCost <= 0) { reason = "Unit cost cannot be zero/negative."; return false; }
        if (Stock < 0)     { reason = "Stock cannot be negative.";          return false; }
        reason = "OK";
        return true;
    }

    // Steps that subclasses must implement
    protected abstract void PrepareMaterials();
    protected abstract void Assemble();
    protected virtual void Finish()
    {
        LogStep("General quality check and packaging");
    }

    protected void LogStep(string message) => Console.WriteLine($" - {message}");
}

// METAL PRODUCT
public class MetalProduct : ProductBase
{
    public string Alloy { get; set; } = "Steel 304L";
    public bool RequiresHeatTreatment { get; set; } = true;

    protected override decimal MaterialFactor => 1.45m; // metal processing is costlier

    protected override void PrepareMaterials()
    {
        LogStep($"Preparing metal sheet/billet (Alloy: {Alloy})");
        if (RequiresHeatTreatment) LogStep("Preparing furnace for heat treatment");
    }

    protected override void Assemble()
    {
        LogStep("Cutting, bending, welding, and surface grinding");
        if (RequiresHeatTreatment) LogStep("Applying heat treatment (hardening)");
    }

    protected override void Finish()
    {
        LogStep("Corrosion protection and surface coating");
        base.Finish();
    }

    public override string GetSpecs()
        => $"[Metal] {Name} | {base.GetSpecs()} | Alloy: {Alloy} | Heat treatment: {(RequiresHeatTreatment ? "Yes" : "No")}";

    public override bool QualityCheck(out string reason)
    {
        if (!base.QualityCheck(out reason)) return false;
        // Extra rule for metal: alloy name must not be empty
        if (string.IsNullOrWhiteSpace(Alloy)) { reason = "Alloy information cannot be empty."; return false; }
        return true;
    }
}

// WOOD PRODUCT
public class WoodProduct : ProductBase
{
    public string WoodType { get; set; } = "Oak";
    public bool IsVarnished { get; set; } = true;

    protected override decimal MaterialFactor => 1.20m;

    protected override void PrepareMaterials()
    {
        LogStep($"Selecting and drying lumber (Type: {WoodType})");
        LogStep("Cutting and sanding");
    }

    protected override void Assemble()
    {
        LogStep("Joinery: mortise/dowel and glue");
    }

    protected override void Finish()
    {
        LogStep(IsVarnished ? "Applying varnish" : "Applying oil/protective finish");
        base.Finish();
    }

    public override string GetSpecs()
        => $"[Wood] {Name} | {base.GetSpecs()} | Wood type: {WoodType} | Varnish: {(IsVarnished ? "Yes" : "No")}";
}

// PLASTIC PRODUCT
public class PlasticProduct : ProductBase
{
    public string Polymer { get; set; } = "PP";
    public bool Recyclable { get; set; } = true;

    protected override decimal MaterialFactor => 0.95m; // plastics often cost less

    protected override void PrepareMaterials()
    {
        LogStep($"Preparing granule feedstock (Polymer: {Polymer})");
        LogStep("Mixing color masterbatch");
    }

    protected override void Assemble()
    {
        LogStep("Injection molding and trimming");
    }

    protected override void Finish()
    {
        LogStep("Surface inspection and labeling");
        base.Finish();
    }

    public override string GetSpecs()
        => $"[Plastic] {Name} | {base.GetSpecs()} | Polymer: {Polymer} | Recyclable: {(Recyclable ? "Yes" : "No")}";
}

// DEMO
class Program
{
    static void Main()
    {
        var items = new List<IProduct>
        {
            new MetalProduct
            {
                Name = "Steel Shelf",
                SKU = "M-SH-001",
                Size = SizeOption.Large,
                UnitCost = 500m,
                Stock = 40,
                Alloy = "304L",
                RequiresHeatTreatment = true
            },
            new WoodProduct
            {
                Name = "Wooden Table",
                SKU = "W-TB-002",
                Size = SizeOption.Medium,
                UnitCost = 350m,
                Stock = 12,
                WoodType = "Oak",
                IsVarnished = true
            },
            new PlasticProduct
            {
                Name = "Plastic Crate",
                SKU = "P-CR-003",
                Size = SizeOption.Small,
                UnitCost = 80m,
                Stock = 200,
                Polymer = "PP",
                Recyclable = true
            }
        };

        const int qty = 10;

        foreach (var p in items)
        {
            Console.WriteLine($"\n=== {p.Name} ===");
            Console.WriteLine(p.GetSpecs());
            p.Production();

            Console.WriteLine($"Total cost ({qty} units): {p.CalculateCost(qty):0.00} USD");

            if (p is IQualityCheck qc)
            {
                Console.WriteLine(qc.QualityCheck(out var reason)
                    ? "Quality Check: OK"
                    : $"Quality Check: FAIL - {reason}");
            }
        }
    }
}

Summary: The IProduct interface provides a common contract for different product types. The ProductBase abstract class partially implements this contract and standardizes the production flow (template method). The subclasses (Metal/Wood/Plastic) customize material-specific steps and cost assumptions. By combining interface + abstract class, you get both flexibility and reusability.

Advantages

Interface: Flexibility thanks to multiple implementation.
Abstract Class: Reduces code duplication with shared state and partial implementation.
Both: Reduce coupling and increase testability.

TL;DR

abstract class: Defines common + required behavior; can include method bodies.

interface: Declares signatures only; supports multiple implementation.

A class can inherit from only one abstract/base class but can implement multiple interfaces.

Encapsulation, Inheritance, and Polymorphism in C#

AllCoderThings — Wed, 11 Feb 2026 09:36:41 +0000

Originally published at https://allcoderthings.com/en/article/csharp-encapsulation-inheritance-polymorphism

Object-Oriented Programming (OOP) is an approach developed to write reusable, maintainable, and understandable code in software development. The three main pillars of OOP are:

Encapsulation: Hiding data and providing controlled access
Inheritance: Passing common behaviors down to subclasses
Polymorphism: The same method behaving differently in different objects

When these three features are used together, a solid architecture can be built in software projects. Let’s now examine each of them individually.

Encapsulation

Encapsulation hides the internal structure of a class from the outside world, exposing only what is necessary. This prevents direct manipulation of data, reduces errors, and ensures that internal logic changes do not affect external code. In C#, it is implemented using access modifiers such as private, protected, internal, and public. Typically, fields are hidden, and controlled access is provided through properties or methods.

public class BankAccount
{
    private decimal _balance; // direct access restricted

    public decimal Balance 
    { 
        get => _balance; 
        private set => _balance = value; 
    }

    public void Deposit(decimal amount)
    {
        if (amount <= 0)
            throw new ArgumentException("Amount must be greater than zero.");
        Balance += amount;
    }

    public void Withdraw(decimal amount)
    {
        if (amount > Balance)
            throw new InvalidOperationException("Insufficient funds.");
        Balance -= amount;
    }
}

In this example, the balance (_balance) cannot be modified directly. The user can only interact with it via Deposit and Withdraw methods. This prevents misuse and ensures data safety.

Inheritance

Inheritance allows a class to derive properties and behaviors from another class. This way, common code is centralized and becomes reusable. The base class defines general behaviors, while derived classes add specialized ones.

public class Animal
{
    public string Name { get; set; } = string.Empty;

    public void Eat()
    {
        Console.WriteLine($"{Name} is eating.");
    }
}

public class Dog : Animal
{
    public void Bark()
    {
        Console.WriteLine($"{Name} is barking.");
    }
}

public class Cat : Animal
{
    public void Meow()
    {
        Console.WriteLine($"{Name} is meowing.");
    }
}

class Program
{
    static void Main()
    {
        Dog d = new Dog { Name = "Buddy" };
        d.Eat();  // inherited from Animal
        d.Bark(); // Dog-specific

        Cat c = new Cat { Name = "Misty" };
        c.Eat();  // inherited from Animal
        c.Meow(); // Cat-specific
    }
}

Here, both Dog and Cat inherit from Animal. The shared behavior Eat() is written only once but is available in all subclasses.

Polymorphism

Polymorphism means the same method can behave differently depending on the object. There are two main types of polymorphism:

Compile-time Polymorphism: Achieved with method overloading.
Runtime Polymorphism: Achieved with virtual methods and override.

public class Animal
{
    public string Name { get; set; } = string.Empty;

    public virtual void Speak()
    {
        Console.WriteLine($"{Name} makes a sound.");
    }
}

public class Dog : Animal
{
    public override void Speak()
    {
        Console.WriteLine($"{Name} barks.");
    }
}

public class Cat : Animal
{
    public override void Speak()
    {
        Console.WriteLine($"{Name} meows.");
    }
}

class Program
{
    static void Main()
    {
        Animal a1 = new Dog { Name = "Buddy" };
        Animal a2 = new Cat { Name = "Misty" };

        a1.Speak(); // Buddy barks.
        a2.Speak(); // Misty meows.
    }
}

The same Speak() call produces different output depending on the object type. This flexibility is one of the strongest features of OOP.

Example: Book Types

Let’s model books in a library application. Shared properties are defined in the Book class, while each subclass adds its own information or overrides the PrintInfo() method. Additionally, Author and Publisher classes are used to hold related information in separate objects. This demonstrates how inheritance and polymorphism can be combined.

public class Author
{
    public string Name { get; set; } = string.Empty;
    public string Country { get; set; } = string.Empty;
}

public class Publisher
{
    public string Name { get; set; } = string.Empty;
    public string Address { get; set; } = string.Empty;
}

public abstract class Book
{
    public string Title { get; set; } = string.Empty;
    public Author BookAuthor { get; set; } = new Author();
    public Publisher BookPublisher { get; set; } = new Publisher();
    public int Pages { get; set; }
    public string ISBN { get; set; } = string.Empty;
    public int Year { get; set; }

    // To be customized in subclasses
    public abstract void PrintInfo();
}

public class ScienceBook : Book
{
    public string Field { get; set; } = string.Empty; // Physics, Chemistry, Biology

    public override void PrintInfo()
    {
        Console.WriteLine($"[Science Book] {Title} - {BookAuthor.Name}, {Pages} pages");
        Console.WriteLine($"Field: {Field}, ISBN: {ISBN}, Publisher: {BookPublisher.Name}");
    }
}

public class HistoryBook : Book
{
    public string Period { get; set; } = string.Empty; // Ancient, Medieval, etc.

    public override void PrintInfo()
    {
        Console.WriteLine($"[History Book] {Title} - {BookAuthor.Name}, {Pages} pages");
        Console.WriteLine($"Period: {Period}, ISBN: {ISBN}, Publisher: {BookPublisher.Name}");
    }
}

class Program
{
    static void Main()
    {
        var publisher = new Publisher { Name = "Knowledge Press", Address = "New York" };
        var author1 = new Author { Name = "Albert Einstein", Country = "Germany" };
        var author2 = new Author { Name = "Halil Inalcik", Country = "Turkey" };

        Book b1 = new ScienceBook
        {
            Title = "Theory of Relativity",
            BookAuthor = author1,
            BookPublisher = publisher,
            Pages = 250,
            ISBN = "123-456-789",
            Year = 1920,
            Field = "Physics"
        };

        Book b2 = new HistoryBook
        {
            Title = "The Ottoman Empire",
            BookAuthor = author2,
            BookPublisher = publisher,
            Pages = 500,
            ISBN = "987-654-321",
            Year = 1973,
            Period = "Ottoman Era"
        };

        b1.PrintInfo();
        Console.WriteLine();
        b2.PrintInfo();
    }
}

Advantages

Encapsulation: Provides data security, prevents misuse.
Inheritance: Reduces code duplication, establishes a hierarchical structure.
Polymorphism: Creates a flexible and extensible architecture.

TL;DR

Encapsulation: Hides internal data and provides controlled access.

Inheritance: Properties and behaviors of a base class are passed to subclasses.

Polymorphism: The same method can behave differently in different subclasses.

Constructors, Destructors and this in C#

AllCoderThings — Sun, 08 Feb 2026 19:43:07 +0000

Originally published at https://allcoderthings.com/en/article/csharp-constructor-destructor-and-this

In C#, classes and structs have special methods that define how objects are created and destroyed. A constructor runs when an object is created and assigns initial values. A destructor is called just before an object is removed from memory. The this keyword refers to the current instance of the class and is especially useful with parameters of the same name or for method chaining.

Constructor

A constructor is a special method with the same name as the class. It is executed automatically when a new object is created and is commonly used to assign initial values. It can take parameters and can be overloaded. If no constructor is defined, C# provides a default (parameterless) constructor.


public class Product
{
    public string Name { get; set; }
    public decimal Price { get; set; }

    // Parameterless constructor
    public Product()
    {
        Name = "Unknown";
        Price = 0;
    }

    // Parameterized constructor
    public Product(string name, decimal price)
    {
        Name = name;
        Price = price;
    }

    public void Print()
    {
        Console.WriteLine($"{Name} - {Price:0.00} USD");
    }
}

class Program
{
    static void Main()
    {
        var p1 = new Product(); // parameterless
        var p2 = new Product("Notebook", 45m); // with parameters

        p1.Print(); // Unknown - 0.00 USD
        p2.Print(); // Notebook - 45.00 USD
    }
}

Destructor

A destructor is defined by prefixing the class name with ~ and it cannot take parameters. It is called right before an object is cleaned up from memory by the Garbage Collector. While it can be used for cleanup operations like closing files or releasing memory, the .NET Garbage Collector usually makes manual destructors unnecessary.

public class Logger
{
    public Logger()
    {
        Console.WriteLine("Logger started.");
    }

    ~Logger()
    {
        Console.WriteLine("Logger cleaned up from memory.");
    }
}

class Program
{
    static void Main()
    {
        var log = new Logger();
        log = null;

        // Trigger Garbage Collector
        GC.Collect();
        GC.WaitForPendingFinalizers();
    }
}

The this Keyword

this refers to the current instance of a class. It is used to distinguish between parameters and properties with the same name, for method chaining, or to call another constructor within the same class.

public class Customer
{
    public string Name { get; set; }
    public string Email { get; set; }

    // Constructor with parameter names same as property names
    public Customer(string name, string email)
    {
        this.Name = name;   // assignment using this
        this.Email = email;
    }

    // Method chaining
    public Customer SetName(string name)
    {
        this.Name = name;
        return this;
    }

    public Customer SetEmail(string email)
    {
        this.Email = email;
        return this;
    }

    public void Print()
    {
        Console.WriteLine($"{Name} - {Email}");
    }
}

class Program
{
    static void Main()
    {
        var c = new Customer("John", "john@example.com")
                    .SetName("Michael")
                    .SetEmail("michael@example.com");

        c.Print(); // Michael - michael@example.com
    }
}

Calling a Constructor with this

You can call one constructor from another within the same class using this(...). This approach reduces repetitive code and centralizes shared initialization logic.

public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }

    public Person(string name) : this(name, 0) // calls another constructor
    {
    }

    public Person(string name, int age)
    {
        Name = name;
        Age = age;
    }

    public void Print()
    {
        Console.WriteLine($"{Name} ({Age})");
    }
}

class Program
{
    static void Main()
    {
        var p1 = new Person("Alice");
        var p2 = new Person("Mary", 25);

        p1.Print(); // Alice (0)
        p2.Print(); // Mary (25)
    }
}

TL;DR

Constructor: Runs when an object is created and assigns initial values.

Destructor: Runs before an object is removed from memory; rarely needed since GC handles cleanup.

this: Refers to the current object; used for distinguishing parameters, method chaining, and calling constructors.

Class, Object, Property and Methods in C#

AllCoderThings — Fri, 06 Feb 2026 18:15:48 +0000

Originally published at https://allcoderthings.com/en/article/csharp-class-object-property-method

In Object-Oriented Programming (OOP), a class is a template that gathers the data (properties) and behaviors (methods) of a particular concept under one structure. Instances created from this template are called objects. Properties are used for data access, while methods are used to define behaviors.

What is a Class?

A class is a template used to model a concept or entity in software. It defines properties, fields, and methods. For example, a Product class can store data like the product’s name and price, while also including behaviors such as “print information”.

public class Product
{
    private decimal _price;

    public string Name { get; set; } = string.Empty;

    public decimal Price
    {
        get => _price;
        set => _price = value < 0 ? 0 : value; // negative price prevented
    }

    public void PrintInfo()
    {
        Console.WriteLine($"{Name} - {Price:0.00} USD");
    }
}```
{% endraw %}


---

## Creating an Object
To create a real instance (object) from a class, the {% raw %}`new`{% endraw %} keyword is used. This operation creates an object in memory according to the class definition. Properties can be assigned, and methods can be invoked on the object.
{% raw %}


```csharp
var notebook = new Product();
notebook.Name = "Notebook";
notebook.Price = 45m;
notebook.PrintInfo();

// Output:
Notebook - 45.00 USD

Objects can also be initialized more concisely using an object initializer:

var pen = new Product { Name = "Pen", Price = 12.5m };
pen.PrintInfo();

Property Types

Properties provide controlled access to the data inside a class. Instead of directly exposing fields, using properties allows for validation and business rules to be applied.

Auto-properties: The most practical choice when no extra logic is needed.

public class Customer
{
    public int Id { get; set; }
    public string FullName { get; set; } = string.Empty;
}

Property with a backing field: Provides control through a private field.

public class Temperature
{
    private double _celsius;

    public double Celsius
    {
        get => _celsius;
        set => _celsius = value;
    }

    public double Fahrenheit => (_celsius * 9 / 5) + 32; // read-only
}

Init-only property (C# 9+): Can only be set during object initialization, not afterwards.

public class User
{
    public string Username { get; init; } = string.Empty;
    public string Email { get; init; } = string.Empty;
}

var u = new User { Username = "john", Email = "j@example.com" };
// u.Username = "michael"; // error: init-only property

Methods

Methods define the operations an object can perform. They may accept parameters and return values. Multiple methods with the same name but different signatures can be defined (overloading).

public class MathUtil
{
    public static int Sum(int a, int b) => a + b;
    public static int Sum(int a, int b, int c) => a + b + c; // overload
}

int x = MathUtil.Sum(2, 3);     // 5
int y = MathUtil.Sum(1, 2, 3);  // 6

Instance methods are called on an object, while static methods are called directly on the class.

Access Modifiers

In C#, the visibility of classes and their members is controlled by access modifiers such as public, private, protected, and internal:

Access modifiers define from which parts of the program a class or its members (properties, methods, fields) can be accessed. For example, private members are only accessible within the class they are defined in, preventing external interference and ensuring data safety. public members are accessible from anywhere, representing the controlled interface a class exposes to the outside world. protected members are accessible in the class itself and in derived classes, allowing flexibility in inheritance scenarios. internal members are accessible within the same assembly, but not from other projects. This mechanism answers the question “which information should be exposed and which should stay encapsulated,” helping to reduce dependencies between classes, apply the encapsulation principle, and build a secure, understandable architecture.

public: Accessible from anywhere.
private: Accessible only inside the class where defined.
protected: Accessible within the class and its derived classes.
internal: Accessible by all classes in the same assembly.

public class Account
{
    private decimal _balance; // accessible only inside the class

    public decimal Balance { get; private set; } // read-only outside

    protected string Owner { get; set; } = string.Empty; // usable in derived classes

    internal string? Tag { get; set; } // accessible within the same project

    public void Deposit(decimal amount)
    {
        if (amount <= 0) return;
        Balance += amount;
    }
}

Example: Simple Library System

In the following example, a Book class and a managing LibraryService class are defined. This demonstrates how objects are created, stored, and processed.

public class Book
{
    public int Id { get; init; }
    public string Title { get; set; } = string.Empty;
    public string Author { get; set; } = string.Empty;

    public void Print() => Console.WriteLine($"{Id} - {Title} ({Author})");
}

public class LibraryService
{
    private readonly List<Book> _books = new();

    public void Add(Book b) => _books.Add(b);

    public Book? FindById(int id) => _books.FirstOrDefault(b => b.Id == id);

    public void PrintAll()
    {
        if (_books.Count == 0)
        {
            Console.WriteLine("Library is empty.");
            return;
        }
        foreach (var b in _books) b.Print();
    }
}

// Usage
var lib = new LibraryService();
lib.Add(new Book { Id = 1, Title = "Clean Code", Author = "Robert C. Martin" });
lib.Add(new Book { Id = 2, Title = "CLR via C#", Author = "Jeffrey Richter" });
lib.PrintAll();

TL;DR

Class: A template defining data + behavior.

Object: A concrete instance created from a class.

Property: Provides controlled access to data (encapsulation).

Method: Defines what an object can do (instance or static).

Access modifiers: Visibility controlled by public, private, protected, internal.

Example: Company Information and Validation

In this example, the Company class not only stores user input but also validates it with a Validate() method. The validation result is returned using a custom ValidationResult enum. This way, the reason for an error can be clearly checked.

public enum ValidationResult
{
    Success,
    NameMissing,
    PhoneMissing,
    PhoneInvalid,
    AddressMissing
}

public class Company
{
    public string Name { get; set; } = string.Empty;
    public string Phone { get; set; } = string.Empty;
    public string Address { get; set; } = string.Empty;
    public string Sector { get; set; } = string.Empty;

    public void PrintInfo()
    {
        Console.WriteLine("=== Company Information ===");
        Console.WriteLine($"Name    : {Name}");
        Console.WriteLine($"Phone   : {Phone}");
        Console.WriteLine($"Address : {Address}");
        Console.WriteLine($"Sector  : {Sector}");
    }

    public ValidationResult Validate()
    {
        if (string.IsNullOrWhiteSpace(Name))
            return ValidationResult.NameMissing;

        if (string.IsNullOrWhiteSpace(Phone))
            return ValidationResult.PhoneMissing;

        if (!Phone.All(char.IsDigit))
            return ValidationResult.PhoneInvalid;

        if (string.IsNullOrWhiteSpace(Address))
            return ValidationResult.AddressMissing;

        return ValidationResult.Success;
    }
}

class Program
{
    static void Main()
    {
        var company = new Company();

        Console.Write("Enter company name: ");
        company.Name = Console.ReadLine();

        Console.Write("Enter phone: ");
        company.Phone = Console.ReadLine();

        Console.Write("Enter address: ");
        company.Address = Console.ReadLine();

        Console.Write("Enter sector: ");
        company.Sector = Console.ReadLine();

        var result = company.Validate();

        if (result == ValidationResult.Success)
        {
            Console.WriteLine();
            company.PrintInfo();
        }
        else
        {
            Console.WriteLine($"Error: {result}");
        }
    }
}

In this example, the Validate() method checks whether the entered data is valid and returns an enum. Instead of simply returning true/false, it specifies the exact reason for the failure. For instance, if the company name is missing, the phone number is empty, or the phone contains non-digit characters, different values are returned. This approach makes error handling more readable and easier to maintain.

NameMissing: Company name was left empty.

PhoneMissing: Phone number was not provided.

PhoneInvalid: Phone number contains non-digit characters.

AddressMissing: Address was left empty.

Success: All validations passed, and the data is correct.

Methods and Parameter Usage in C#

AllCoderThings — Mon, 02 Feb 2026 18:33:10 +0000

Originally published at https://allcoderthings.com/en/article/csharp-methods-and-parameter-usage

In C#, methods are used to organize and reuse repetitive code. A method performs a specific task and can be called many times within a program. This helps avoid code duplication and improves readability.

Defining and Calling Methods

A method is defined with a return type, a name, and optional parameters. For example, the following method prints a simple message:

static void Greet()
{
    Console.WriteLine("Hello!");
}

static void Main()
{
    Greet(); // method call
}

// Output:
Hello!

Methods with Parameters

Methods can receive values from outside. These are called parameters. In the example below, a name parameter is taken and the greeting message is personalized:

static void Greet(string name)
{
    Console.WriteLine("Hello " + name + "!");
}

static void Main()
{
    Greet("Alice");
    Greet("Bob");
}

// Output:
Hello Alice!
Hello Bob!

Default Parameters

Parameters can have default values. If no value is passed during the call, the default value is used:

static void PrintMessage(string text = "Default message")
{
    Console.WriteLine(text);
}

static void Main()
{
    PrintMessage("Hello world!");
    PrintMessage();
}

// Output:
Hello world!
Default message

Parameter vs Argument

A parameter is the name used in the method definition. An argument is the actual value passed when calling the method.

static void Square(int number) // parameter: number
{
    Console.WriteLine(number * number);
}

static void Main()
{
    Square(4); // argument: 4
}

// Output:
16

Overloading

Methods with the same name but different numbers or types of parameters can be defined. This is called method overloading:

static int Multiply(int a, int b)
{
    return a * b;
}

static int Multiply(int a, int b, int c)
{
    return a * b * c;
}

static void Main()
{
    Console.WriteLine(Multiply(3, 4));
    Console.WriteLine(Multiply(2, 3, 4));
}

// Output:
12
24

Recursion

When a method calls itself, it is called recursion. Each recursion must have a base case; otherwise, the loop will continue infinitely.

static int Factorial(int n)
{
    if (n <= 1)
        return 1; // base case
    return n * Factorial(n - 1); // recursive call
}

static void Main()
{
    Console.WriteLine(Factorial(5)); // 120
}

ref and out Parameters

In C#, the ref and out keywords allow parameters to be passed by reference. This means changes made inside the method are reflected outside.

// ref example
static void Increment(ref int number)
{
    number++;
}

// out example
static void ReadValue(out int result)
{
    result = 42;
}

static void Main()
{
    int x = 5;
    Increment(ref x);
    Console.WriteLine(x); // 6

    int y;
    ReadValue(out y);
    Console.WriteLine(y); // 42
}

Multiple Parameters with params

The params keyword allows methods to take a variable number of parameters. You can pass either an array or individual values.

Example: Summing Numbers

static int Add(params int[] numbers)
{
    int sum = 0;
    foreach (int n in numbers)
        sum += n;
    return sum;
}

static void Main()
{
    Console.WriteLine(Add(1, 2, 3));       // 6
    Console.WriteLine(Add(5, 10, 15, 20)); // 50
}

Example: Joining Strings

static string JoinWords(params string[] words)
{
    return string.Join(" ", words);
}

static void Main()
{
    Console.WriteLine(JoinWords("C#", "is", "a", "powerful", "language."));
    // Output: C# is a powerful language.
}

Local Functions

Starting from C# 7.0, methods can be defined inside another method. These are called local functions. They help write cleaner and more organized code.

static void Main()
{
    int Multiply(int a, int b) // local function
    {
        return a * b;
    }

    Console.WriteLine(Multiply(3, 4)); // 12
}

-Methods are reusable blocks of code.
-Parameters are used to pass data into methods.
-return is used to return a value.
-Default parameters make code flexible.
-Overloading allows defining methods with the same name but different parameters.
-ref and out parameters allow modifying values by reference.
-params enables variable numbers of parameters.
-Local functions are helper methods defined inside another method.
-Recursion means a method calling itself to solve a problem.