The Importance of Design Patterns in .NET Core Development

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

// Models
public class Product
{
    public int Id { get; set; }
    public string Name { get; set; }
    public decimal Price { get; set; }
}

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

public class Order
{
    public int Id { get; set; }
    public int CustomerId { get; set; }
    public int ProductId { get; set; }
    public DateTime OrderDate { get; set; }
}

// Repository Interfaces
public interface IProductRepository
{
    Product GetById(int id);
    IEnumerable<Product> GetAll();
    void Add(Product product);
    void Update(Product product);
    void Delete(int id);
}

public interface ICustomerRepository
{
    Customer GetById(int id);
    IEnumerable<Customer> GetAll();
    void Add(Customer customer);
    void Update(Customer customer);
    void Delete(int id);
}

public interface IOrderRepository
{
    Order GetById(int id);
    IEnumerable<Order> GetAll();
    void Add(Order order);
    void Update(Order order);
    void Delete(int id);
}

// Repository Implementations
public class ProductRepository : IProductRepository
{
    private readonly ApplicationDbContext _context;

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

    public Product GetById(int id) => _context.Products.FirstOrDefault(p => p.Id == id);
    public IEnumerable<Product> GetAll() => _context.Products;
    public void Add(Product product) => _context.Products.Add(product);
    public void Update(Product product)
    {
        var existingProduct = _context.Products.FirstOrDefault(p => p.Id == product.Id);
        if (existingProduct != null)
        {
            existingProduct.Name = product.Name;
            existingProduct.Price = product.Price;
        }
    }
    public void Delete(int id)
    {
        var product = _context.Products.FirstOrDefault(p => p.Id == id);
        if (product != null)
        {
            _context.Products.Remove(product);
        }
    }
}

public class CustomerRepository : ICustomerRepository
{
    private readonly ApplicationDbContext _context;

    public CustomerRepository(ApplicationDbContext context)
    {
        _context = context;
    }

    public Customer GetById(int id) => _context.Customers.FirstOrDefault(c => c.Id == id);
    public IEnumerable<Customer> GetAll() => _context.Customers;
    public void Add(Customer customer) => _context.Customers.Add(customer);
    public void Update(Customer customer)
    {
        var existingCustomer = _context.Customers.FirstOrDefault(c => c.Id == customer.Id);
        if (existingCustomer != null)
        {
            existingCustomer.Name = customer.Name;
            existingCustomer.Email = customer.Email;
        }
    }
    public void Delete(int id)
    {
        var customer = _context.Customers.FirstOrDefault(c => c.Id == id);
        if (customer != null)
        {
            _context.Customers.Remove(customer);
        }
    }
}

public class OrderRepository : IOrderRepository
{
    private readonly ApplicationDbContext _context;

    public OrderRepository(ApplicationDbContext context)
    {
        _context = context;
    }

    public Order GetById(int id) => _context.Orders.FirstOrDefault(o => o.Id == id);
    public IEnumerable<Order> GetAll() => _context.Orders;
    public void Add(Order order) => _context.Orders.Add(order);
    public void Update(Order order)
    {
        var existingOrder = _context.Orders.FirstOrDefault(o => o.Id == order.Id);
        if (existingOrder != null)
        {
            existingOrder.CustomerId = order.CustomerId;
            existingOrder.ProductId = order.ProductId;
            existingOrder.OrderDate = order.OrderDate;
        }
    }
    public void Delete(int id)
    {
        var order = _context.Orders.FirstOrDefault(o => o.Id == id);
        if (order != null)
        {
            _context.Orders.Remove(order);
        }
    }
}

// ApplicationDbContext - Simulating a database context
public class ApplicationDbContext
{
    public List<Product> Products { get; set; } = new List<Product>();
    public List<Customer> Customers { get; set; } = new List<Customer>();
    public List<Order> Orders { get; set; } = new List<Order>();

    public ApplicationDbContext()
    {
        // Seed data
        Products.Add(new Product { Id = 1, Name = "Laptop", Price = 1000 });
        Products.Add(new Product { Id = 2, Name = "Smartphone", Price = 500 });

        Customers.Add(new Customer { Id = 1, Name = "Gopal", Email = "[email protected]" });
        Customers.Add(new Customer { Id = 2, Name = "Uday", Email = "[email protected]" });

        Orders.Add(new Order { Id = 1, CustomerId = 1, ProductId = 2, OrderDate = DateTime.Now.AddDays(-2) });
        Orders.Add(new Order { Id = 2, CustomerId = 2, ProductId = 1, OrderDate = DateTime.Now.AddDays(-1) });
    }
}

// Main Program
class Program
{
    static void Main(string[] args)
    {
        var dbContext = new ApplicationDbContext();

        IProductRepository productRepo = new ProductRepository(dbContext);
        ICustomerRepository customerRepo = new CustomerRepository(dbContext);
        IOrderRepository orderRepo = new OrderRepository(dbContext);

        // Display all products
        Console.WriteLine("All Products:");
        foreach (var product in productRepo.GetAll())
        {
            Console.WriteLine($"ID: {product.Id}, Name: {product.Name}, Price: {product.Price}");
        }

        // Display all customers
        Console.WriteLine("\nAll Customers:");
        foreach (var customer in customerRepo.GetAll())
        {
            Console.WriteLine($"ID: {customer.Id}, Name: {customer.Name}, Email: {customer.Email}");
        }

        // Display all orders
        Console.WriteLine("\nAll Orders:");
        foreach (var order in orderRepo.GetAll())
        {
            var customer = customerRepo.GetById(order.CustomerId);
            var product = productRepo.GetById(order.ProductId);
            Console.WriteLine($"Order ID: {order.Id}, Customer: {customer.Name}, Product: {product.Name}, Date: {order.OrderDate}");
        }

        // Add a new product
        var newProduct = new Product { Id = 3, Name = "Tablet", Price = 300 };
        productRepo.Add(newProduct);
        Console.WriteLine("\nAdded New Product:");
        Console.WriteLine($"ID: {newProduct.Id}, Name: {newProduct.Name}, Price: {newProduct.Price}");

        // Update an existing customer
        var customerToUpdate = customerRepo.GetById(1);
        customerToUpdate.Email = "[email protected]";
        customerRepo.Update(customerToUpdate);
        Console.WriteLine("\nUpdated Customer:");
        Console.WriteLine($"ID: {customerToUpdate.Id}, Name: {customerToUpdate.Name}, New Email: {customerToUpdate.Email}");

        // Delete an order
        orderRepo.Delete(2);
        Console.WriteLine("\nDeleted Order with ID: 2");

        // Display remaining orders
        Console.WriteLine("\nRemaining Orders:");
        foreach (var order in orderRepo.GetAll())
        {
            var customer = customerRepo.GetById(order.CustomerId);
            var product = productRepo.GetById(order.ProductId);
            Console.WriteLine($"Order ID: {order.Id}, Customer: {customer.Name}, Product: {product.Name}, Date: {order.OrderDate}");
        }
    }
}

Output

Real-Life Example: Think of the Repository Pattern as a librarian who manages access to a library’s collection. Instead of interacting directly with the library’s inventory system, you interact with the librarian, who handles all the details for you. Similarly, the repository abstracts the complexities of data access from the rest of your application.

Summary

Design patterns are indispensable in .NET Core development, providing solutions that enhance consistency, scalability, maintainability, and flexibility. By leveraging patterns such as Repository, Unit of Work, and Singleton, developers can create robust applications that adhere to best practices and are easier to manage and extend.

In this article, we discussed the importance of design patterns in .NET Core and highlighted key patterns that can be applied to various development scenarios. Understanding and implementing these patterns will lead to more effective and maintainable code.

Next Steps

In the next article, we will explore "Categorizing Design Patterns: Creational, Structural, and Behavioral." We'll break down these three main types of design patterns, explaining their distinct roles and how they can be applied to improve software design. This categorization will help you understand which pattern to use for different design challenges and how to implement them effectively.

If you find this article valuable, please consider liking it and sharing your thoughts in the comments.

Thank you, and happy coding.