Princípios SOLID através de exemplos

PRINCÍPIOS SOLID

Single responsibility principle
Open closed principle
Liskov substitution principle
Interface segregation principle
Dependency inversion principle

Single Responsibility Principle

Um objecto, uma responsabilidade

class Customer
    {
        private FileLogger obj = new FileLogger();

        public virtual void Add()
        {
            try
            {
                // Código de acesso à base de dados
            }
            catch (Exception ex)
            {
                obj.Handle(ex.ToString());
            }
        }
    }

class FileLogger
    {
        public void Handle(string error)
        {
            System.IO.File.WriteAllText(@"c:\Error.txt", error);
        }
    }

Open Closed Principle

As componentes devem de estar abertas para a sua extensão e fechadas para a sua modificação

class Customer
{
        public virtual double getDiscount(double TotalSales)
        {
            return TotalSales;
        }
}

  class SilverCustomer : Customer
    {
        public override double getDiscount(double TotalSales)
        {
            return base.getDiscount(TotalSales) - 50;
        }
    }

  class GoldCustomer : Customer
    {
        public override double getDiscount(double TotalSales)
        {
            return base.getDiscount(TotalSales) - 100;
        }
    }

Liskov Substitution Principle

Este princípio diz que o pai deveria facilmente substituir o filho.
Os objectos de um programa devem de ser substituidos por instâncias dos seus subtipos sem alterar o correcto funcionamento do programa. (Desenho por contrato)

interface IDiscount
{
        double getDiscount(double TotalSales);
}


interface IDatabase
{
        void Add();
}

class Customer : IDiscount, IDatabase
   {


       private FileLogger obj = new FileLogger();

       public virtual void Add()
       {
           try
           {
               // Código de acesso à base de dados
           }
           catch (Exception ex)
           {
               obj.Handle(ex.Message.ToString());
           }
       }

       public virtual double getDiscount(double TotalSales)
       {
           return TotalSales;
       }
   }

class Enquiry : IDiscount
    {
        public  double getDiscount(double TotalSales)
        {
            return TotalSales - 5;
        }
    }

Interface Segregation Principle

É melhor várias interfaces cliente específicas do que uma interface geral

interface IDatabaseV1 : IDatabase // Obtem o método Add
{
 Void Read();
}

class CustomerwithRead : IDatabase, IDatabaseV1
{

    public void Add()
    {
 Customer obj = new Customer();
        obj.Add();
    }

    public void Read()
    {
 // Implementação da nova lógica
    }
}

IDatabase i = new Customer(); // 1000 antigos clientes felizes e contentes
i.Add();

IDatabaseV1 iv1 = new CustomerWithread(); // novos clientes
Iv1.Read();

Dependency Inversion Principle

Depender de abstrações, não depender de implementações (Dependency Injection)

interface ILogger
{
        void Handle(string error);
}

class FileLogger : ILogger
    {
        public void Handle(string error)
        {
            System.IO.File.WriteAllText(@"c:\Error.txt", error);
        }
    }

Implementação

class Customer : IDiscount, IDatabase
 {
        private Ilogger obj;
        public Customer(ILogger i)
        {
            obj = i;
        }
}

Invocação

IDatabase i = new Customer(new EmailLogger());

fonte: SOLID architecture principles using simple C# examples, SOLID Principle with C# Example

Licença CC BY-SA 4.0 Silvia Pinhão Lopes, 23.5.17