3.1 Single Responsibility Principle (SRP)

Setiap kelas harus memiliki satu alasan untuk berubah, artinya kelas hanya memiliki satu tanggung jawab.

public class InvoicePrinter
{
    public void Print(Invoice invoice)
    {
        // Logika cetak invoice
    }
}

public class InvoiceRepository
{
    public void Save(Invoice invoice)
    {
        // Logika simpan invoice ke database
    }
}
        

3.2 Open/Closed Principle (OCP)

Kelas harus terbuka untuk ekstensi, tapi tertutup untuk modifikasi.

public abstract class Shape
{
    public abstract double Area();
}

public class Rectangle : Shape
{
    public double Width { get; set; }
    public double Height { get; set; }
    public override double Area() => Width * Height;
}

public class Circle : Shape
{
    public double Radius { get; set; }
    public override double Area() => Math.PI * Radius * Radius;
}
        

3.3 Liskov Substitution Principle (LSP)

Objek dari superclass harus bisa digantikan dengan objek subclass tanpa mengubah keakuratan program.

public class Bird
{
    public virtual void Fly() { }
}

public class Sparrow : Bird
{
    public override void Fly()
    {
        // Implementasi terbang
    }
}

public class Ostrich : Bird
{
    public override void Fly()
    {
        throw new NotSupportedException("Ostrich tidak bisa terbang");
    }
}
        

Contoh di atas melanggar LSP karena Ostrich tidak bisa menggantikan Bird secara sempurna.

3.4 Interface Segregation Principle (ISP)

Banyak interface khusus lebih baik daripada satu interface umum yang besar.

public interface IPrinter
{
    void Print();
}

public interface IScanner
{
    void Scan();
}

public class MultiFunctionPrinter : IPrinter, IScanner
{
    public void Print() { /* ... */ }
    public void Scan() { /* ... */ }
}
        

5.1 Interface dan Model

namespace SolidAspNetApp.Models
{
    public class Product
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public decimal Price { get; set; }
    }
}

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

5.2 Repository Implementation (SRP & DIP)

using SolidAspNetApp.Interfaces;
using SolidAspNetApp.Models;
using System.Collections.Generic;
using System.Linq;

namespace SolidAspNetApp.Repositories
{
    public class ProductRepository : IProductRepository
    {
        private readonly List<Product> _products = new();

        public IEnumerable<Product> GetAll() => _products;

        public Product GetById(int id) => _products.FirstOrDefault(p => p.Id == id);

        public void Add(Product product)
        {
            _products.Add(product);
        }

        public void Update(Product product)
        {
            var existing = GetById(product.Id);
            if (existing != null)
            {
                existing.Name = product.Name;
                existing.Price = product.Price;
            }
        }

        public void Delete(int id)
        {
            var product = GetById(id);
            if (product != null)
            {
                _products.Remove(product);
            }
        }
    }
}
        

5.3 Service Layer (OCP & DIP)

using SolidAspNetApp.Interfaces;
using SolidAspNetApp.Models;
using System.Collections.Generic;

namespace SolidAspNetApp.Services
{
    public class ProductService
    {
        private readonly IProductRepository _repository;

        public ProductService(IProductRepository repository)
        {
            _repository = repository;
        }

        public IEnumerable<Product> GetAllProducts() => _repository.GetAll();

        public Product GetProductById(int id) => _repository.GetById(id);

        public void CreateProduct(Product product) => _repository.Add(product);

        public void UpdateProduct(Product product) => _repository.Update(product);

        public void DeleteProduct(int id) => _repository.Delete(id);
    }
}
        

5.4 Controller (ISP & DIP)

using Microsoft.AspNetCore.Mvc;
using SolidAspNetApp.Models;
using SolidAspNetApp.Services;
using System.Collections.Generic;

namespace SolidAspNetApp.Controllers
{
    [ApiController]
    [Route("api/[controller]")]
    public class ProductsController : ControllerBase
    {
        private readonly ProductService _service;

        public ProductsController(ProductService service)
        {
            _service = service;
        }

        [HttpGet]
        public IEnumerable<Product> Get() => _service.GetAllProducts();

        [HttpGet("{id}")]
        public ActionResult<Product> Get(int id)
        {
            var product = _service.GetProductById(id);
            if (product == null) return NotFound();
            return product;
        }

        [HttpPost]
        public IActionResult Post([FromBody] Product product)
        {
            _service.CreateProduct(product);
            return CreatedAtAction(nameof(Get), new { id = product.Id }, product);
        }

        [HttpPut("{id}")]
        public IActionResult Put(int id, [FromBody] Product product)
        {
            var existing = _service.GetProductById(id);
            if (existing == null) return NotFound();
            product.Id = id;
            _service.UpdateProduct(product);
            return NoContent();
        }

        [HttpDelete("{id}")]
        public IActionResult Delete(int id)
        {
            var existing = _service.GetProductById(id);
            if (existing == null) return NotFound();
            _service.DeleteProduct(id);
            return NoContent();
        }
    }
}