Design Patterns � State � Parte 4

Vamos continuar com a s�rie Design Patterns apresentando o padr�o State, n�o � um padr�o com um grau de dificuldade alta mais n�o � t�o simples como o singleton exibido no ultimo artigo. O padr�o state permite que um objeto altere o seu comportamento quando o seu estado interno muda. O objeto parecer� ter mudado de classe.

O padr�o encapsula os estados em classes separadas e delega as tarefas para o objeto que representa o estado atual, n�s sabemos que os comportamentos mudam juntamento com o estado interno.

A seguir temos o diagrama de classe:

Obs: Diagrama resumido para termos s� o necess�rio para representaç�o e ficar f�cil o entendimento. Vamos analisar o diagrama.

O contexto � a classe que pode ter v�rios estados internos diferentes.

A interface estado define uma interface comum para todos os estados concretos. Como s�o intervambiaveis, todos devem implementar a mesma interface.

Os estado concretos (podemos ter v�rios estados concretos) lidam com as solicitaç�es provenientes do contexto. Cada estado concreto fornece a sua pr�pria implementaç�o de uma solicitaç�o. Assim, quando o contexto muda de estado, seu comportamento tamb�m muda.

Sempre que uma solicitaç�o() � feita ao contexto, ela � delegada ao estado apropriado para ser processado.

Agora vamos imaginar um cen�rio, vamos imaginar uma conta corrente bem simples com opç�o de depositar e sacar dinheiro e j� imaginamos os estado que essa conta pode estar saldopositivo, saldonegativo e bloqueado.

Vou exibir uma implementaç�o sem utilizar o padr�o state para mostrar o quanto ficamos amarrados em ifs e cases deixando a nossa manutenç�o um pouco complicado pois voc� pode alterar algo e atrapalhar o funcionamento de tudo o que j� estava funcionando e at� mesmo validado.


nbsp;,saldoatualRnbsp;.",valor,this.Saldo);
if(this.Saldo&gt;0)
this.MeuEstado=ContaState.saldoNegativo;
break;
caseContaState.saldoNegativo:
this.Saldo-=valor;
Console.WriteLine("RetiradoRnbsp;,saldoatualRnbsp;.",valor,this.Saldo);

if(this.Saldo&lt;-100.00)
{
this.MeuEstado=ContaState.bloqueado;
}
break;
caseContaState.bloqueado:
Console.WriteLine("Contabloqueada,saquecancelado,saldoatualRnbsp;.",valor,this.Saldo);
break;
default:
break;
}
Console.WriteLine("Estadodaconta:\n",this.MeuEstado.ToString());
}

publicvoidDeposito(Doublevalor)
{
this.Saldo+=valor;
if(this.Saldo&lt;=-100.00)
this.MeuEstado=ContaState.bloqueado;
elseif(this.Saldo&gt;=0)
this.MeuEstado=ContaState.saldoPositivo;
else
this.MeuEstado=ContaState.saldoNegativo;

Console.WriteLine("FoidepositadoRnbsp;,saldoatualR


public enum ContaState
{
saldoPositivo,
saldoNegativo,
bloqueado
}

public class Conta
{
public Conta()
{
  this.Saldo = 0;
  this.MeuEstado = ContaState.saldoPositivo;
}

public Conta(Double valor)
{
  this.Deposito(valor);
}

public Double Saldo { get; set; }
public ContaState MeuEstado { get; set; }

public void Saque(Double valor)
{
  switch (MeuEstado)
  {
      case ContaState.saldoPositivo:
          this.Saldo -= valor;
          Console.WriteLine("Retirado Rnbsp;",valor,this.Saldo);
          Console.WriteLine("Estadodaconta:\n",this.MeuEstado.ToString());
  }
}

Agora vamos aplicar toda teoria que vimos sobre state, vamos encapsular cada estado em uma classe, e para a alteraç�o o estado da classe contexto vamos ter uma aç�o invocada (Saque ou Deposito), veja o fluxo geral do estou dizendo:

E como implementaremos isso? Primeiro vamos ter que criar uma interface para os estados:


public interface IContaState
{
  void Saque(Double valor);
  void Deposito(Double valor);
}

Teremos s� dois m�todos: saque e deposito. Vamos implementar tr�s estados fazendo um contrato com a interface IContaState. Voc� se lembra do enum (saldoPositivo, saldoNegativo, bloqueado) criado no exemplo sem o padr�o? Pois bem, vamos ter uma classe para cada uma daquelas opç�es.


public class saldoPositivo : IContaState
{
  private Conta _conta;

  public saldoPositivo(Conta PConta)
  {
      this._conta = PConta;
  }

  #region [IContaState Members]
  public void Saque(double valor)
  {
      this._conta.Saldo -= valor;
      Console.WriteLine("Retirado Rnbsp;,
      saldoatualRnbsp;.",valor,this._conta.Saldo);
      if(this._conta.Saldo&lt;0)
      if(this._conta.Saldo&lt;-100.00)
      this._conta.MeuEstado=newbloqueado(this._conta);
      else
      this._conta.MeuEstado=newsaldoNegativo(this._conta);
    }

      publicvoidDeposito(doublevalor)
      {
        this._conta.Saldo+=valor;
      Console.WriteLine("FoidepositadoRnbsp;,
      saldoatualRnbsp;",valor,this._conta.Saldo);
      if(this._conta.Saldo&lt;0)
      if(this._conta.Saldo&lt;-100.00)
      this._conta.MeuEstado=newbloqueado(this._conta);
      else
      this._conta.MeuEstado=newsaldoNegativo(this._conta);
    }
      #endregion
    }

      publicclasssaldoNegativo:IContaState
      {
        privateConta_conta;

      publicsaldoNegativo(ContaPConta)
      {
        this._conta=PConta;
    }

      #region[IContaStateMembers]
      publicvoidSaque(doublevalor)
      {
        this._conta.Saldo-=valor;
      Console.WriteLine("RetiradoRnbsp;,
      saldoatualRnbsp;.",valor,this._conta.Saldo);

      if(this._conta.Saldo&lt;-100.00)
      this._conta.MeuEstado=newbloqueado(this._conta);
    }

      publicvoidDeposito(doublevalor)
      {
        this._conta.Saldo+=valor;
      Console.WriteLine("FoidepositadoRnbsp;,
      saldoatualRnbsp;",valor,this._conta.Saldo);
      if(this._conta.Saldo&gt;=-100.00)
      if(this._conta.Saldo&lt;0)
      this._conta.MeuEstado=newsaldoNegativo(this._conta);
      else
      this._conta.MeuEstado=newsaldoPositivo(this._conta);
    }
      #endregion
    }

      publicclassbloqueado:IContaState
      {
        privateConta_conta;

      publicbloqueado(ContaPConta)
      {
        this._conta=PConta;
    }

      #region[IContaStateMembers]
      publicvoidSaque(doublevalor)
      {
        Console.WriteLine("Contabloqueada,saquecancelado,
        saldoatualRnbsp;.",valor,this._conta.Saldo);
    }

      publicvoidDeposito(doublevalor)
      {
        this._conta.Saldo+=valor;
      Console.WriteLine("FoidepositadoRnbsp;,saldoatualRnbsp;",valor,this._conta.Saldo);
      if(this._conta.Saldo&lt;0)
      {
        if(this._conta.Saldo&lt;-100.00)
      this._conta.MeuEstado=newbloqueado(this._conta);
    }
      else
      {
        this._conta.MeuEstado=newsaldoPositivo(this._conta);
  }
}
#endregion
}

Os pontos importantes que devemos observar s�o:

A vari�vel privada da classe Conta (vamos ver ela daquipouco);
Os construtores que recebem como par�metro um objeto da classe Conta.
A vari�vel _conta representar nossa classe contexto dentro do estado e vai ser utilizado para todas as alteraç�es e consulta de valores da Conta.

Os construtores recebem a pr�pria classe contexto para a criaç�o do estado.

Como todas as classes que v�o representar um poss�vel estado para nossa classe contexto tem um contrato com a interface IContaState podemos criar uma vari�vel na nossa classe a partir dessa interface para representar o estado.

Vamos ver como fica nossa classe Conta (contexto):


public class Conta
{
    public Conta()
    {
        this.Saldo = 0;
    }
 
    public Conta(Double valor)
    {
        this.MeuEstado = new saldoPositivo(this);
        this.Deposito(valor);
    }
 
    public Double Saldo { get; set; }
    public IContaState MeuEstado;
 
    public void Saque(Double valor)
    {
        this.MeuEstado.Saque(valor);
        Console.WriteLine("Estado da conta: \n", this.MeuEstado.ToString());
    }
 
    public void Deposito(Double valor)
    {
        this.MeuEstado.Deposito(valor);
        Console.WriteLine("Estado da conta: \n", this.MeuEstado.ToString());
    }
}

Em comparaç�o a classe criada sem o padr�o, temos uma classe menor e mais simples, uma vez que a decis�o de qual estado ele vai estar depois da chamada dos m�todos n�o cabe mais a classe contexto e sim a cada classe encapsulada que representa um estado do mesmo modo que a execuç�o do m�todo que esta sendo delegado ao estado atual. Devemos observar tamb�m que para setarmos qualquer estado estamos utilizamos �MeuEstado = new [EstadoConcreto]([Contexto])� isso ocorre tanto na criaç�o da classe contexto quanto nas alteraç�es dos estados.

Em ambas implementaç�es com ou sem design pattern o resultado � o mesmo, ent�o voc�s est�o se perguntando, por que eu irei ter um trabalho maior para chegar ao mesmo resultado?

A resposta � simples, no primeiro se voc� precisar de mais um estado vai ter que alterar sua classe Conta podendo alterar um bloco de c�digo de forma errada causando transtornos, uma vez que a classe conta � a classe principal, agora se estiver no padr�o n�o necessitaremos de alterar nada na classe conta, e sim na classe do estado especifico da alteraç�o deixando da forma que estava as demais classes dos estado, e se necess�rio criar outra classe para estado as alteraç�es ser�o pequenas.

Design Patterns � State � Parte 4

Vamos continuar com a série Design Patterns apresentando o padrão State, não é um padrão com um grau de dificuldade alta mais não é tão simples como o singleton exibido no último artigo.

Artigos relacionados