Como implementar o Design Pattern Observer no .NET

Os padr�es de projeto comportamentais t�m por benef�cio a reutilizaç�o de c�digos, permitindo que os desenvolvedores concentrem esforços no desenvolvimento do neg�cio e n�o na linguagem de programaç�o que est�o utilizando, ajudando assim a minimizar os erros de reduzir os prazos de entrega.

Existem tr�s tipos b�sicos de padr�es: criacionais, comportamentais e estruturais que, respectivamente, tratam da criaç�o, interaç�o e organizaç�o das interaç�es e divis�es de responsabilidades entre as classes ou objetos.

Existem diversos designer patterns conhecidos e implementados pelos arquitetos e desenvolvedores mais experientes e, pensando nisso, o framework .NET fornece algumas classes que podem ser utilizadas para a implementaç�o destes patterns. Neste artigo iremos aprender sobre o pattern Observer, mostrando algumas formas de implementaç�o, incluindo delegates, interfaces e algumas classes que o framework .NET nos fornece.

O pattern observer define a depend�ncia de um para muitos (1 para n) entre objetos para que, quando um objeto mude de estados, todos os seus dependentes sejam avisados e atualizados automaticamente. Al�m disso, podemos usar quando uma abstraç�o tiver dois aspectos que dependem um do outro, assim, quando precisarmos us�-los, podemos fazer de forma independente.

O Projeto

Imagine uma situaç�o em que precisamos comunicar algo a um grupo de objetos sobre um acontecimento: o padr�o observer ajuda a implementar uma soluç�o eficaz para este problema.

Vamos pensar na seguinte situaç�o: A empresa Xpto resolveu criar um sistema de e-mail marketing sobre promoç�es do site. Os analistas da empresa discutiram algum tempo e chegaram nos seguintes requisitos:

Somente os usu�rios que se cadastraram no newsletter do site ser�o avisados das promoç�es;
O usu�rio pode cancelar o envio das promoç�es quando quiser;
Alguns grupos de usu�rio podem ser tratados de forma diferenciada.

Para este problema temos v�rias soluç�es diferentes e elas s�o: usando o modelo tradicional, usando delegates e usando as classes do .NET framework. Veremos as tr�s soluç�es a seguir.

Modo comum de implementar o padr�o Observer

Primeiro vamos criar a interface ISubject que cont�m os m�todos de registro, remoç�o do usu�rio e o m�todo que envia os e-mails para os usu�rios registrados, como mostra a Listagem 1. Para isso, abra o Visual Studio e em File > New > Project (ou clique Ctrl+Shift+N) escolha o template Console Application.


public interface ISubject   
{
  void Registrar(IObserver observer);
  void Remover(IObserver observer);
  void EnviarEmail();
}

Listagem 1. Interface ISubject

Tamb�m temos a interface IObserver que cont�m o m�todo de envio dos e-mails, conforme demonstrado na Listagem 2.


public interface IObserver
{
   void ReceberEmail();
}

Listagem 2. Interface IObserver

Por fim, vamos implementar as interfaces citadas conforme mostra a Listagem 3.


public class ControladorEmail : ISubject
{
    private readonly List<IObserver> _usuarios;
  
       public ControladorEmail()
       {
           _usuarios = new List<IObserver>();
       }
   
       public void Registrar(IObserver observer)
       {
           _usuarios.Add(observer);
       }
   
       public void Remover(IObserver observer)
       {
           _usuarios.Remove(observer);
       }
   
       public void EnviarEmail()
       {
           foreach (var usuario in _usuarios)
           {
               usuario.ReceberEmail();
           }
    }
}

Listagem 3. Implementando as interfaces das Listagens 1 e 2

Note que a classe ControladorEmail herda de ISubject e cont�m uma lista de IObserver. Al�m disso, no m�todo de registro apenas inserimos um observer na lista, e para remover basta remover o objeto observer da lista. Por fim, para notificar os usu�rios basta executar o m�todo �Receberemail� para todos os observers contidos na lista.

Agora iremos implementar os usu�rios que ser�o notificados pela classe Subject, como mostra a Listagem 4.


public class UsuarioA : IObserver
      {
          public void ReceberEmail()
          {
              Console.WriteLine("Email Recebido pelo usu�rio A");
          }
      }
     
  public class UsuarioB : IObserver
      {
          public void ReceberEmail()
          {
              Console.WriteLine("Email Recebido pelo usuario B");
          }
      }
   
  public class UsuarioC : IObserver
      {
          public void ReceberEmail()
          {
              Console.WriteLine("Email Recebido pelo usuario C");
          }
}

Listagem 4. Classe Subject

Note que cada usu�rio implementa a interface IObserver de forma diferente, por�m, como estamos trabalhando com interfaces, a classe ISubject executar� cada observer de forma diferenciada.

Para o m�todo main temos o c�digo da Listagem 5.


class Program
{
   static void Main(string[] args)
   {
       ISubject controladorEmail = new ControladorEmail();
             
       var usuarioA = new UsuarioA();
       var usuarioB = new UsuarioB();
       var usuarioC = new UsuarioC();
   
       controladorEmail.Registrar(usuarioA);
       controladorEmail.Registrar(usuarioB);
       controladorEmail.Registrar(usuarioC);
   
       Console.WriteLine("Os usuarios A, B e C cadastraram-se para receber as promoç�es. 
       \n");
       Console.WriteLine("Enviando os emails para os usuarios assinados 
       (usu�rios cadastrados).\n");
   
       controladorEmail.EnviarEmail();
   
       Console.WriteLine("\nO usu�rio A resolveu concancelar a 
       assinatura e n�o ir� receber mais emails.\n");
       controladorEmail.Remover(usuarioA);
   
       Console.WriteLine("Enviando os emails para os usuarios assinados.\n");
       controladorEmail.EnviarEmail();
   
       Console.ReadKey();
              
       Console.ReadKey();
  }
}

Listagem 5. M�todo Main

Podemos ver a execuç�o do projeto na Figura 1.

Figura 1. Execuç�o do exemplo 1

Usando Delegates

Podemos ter o mesmo recurso de avisar as classes assinantes utilizando delegates. O procedimento � parecido com o que fizemos anteriormente e a principal mudança � a forma de assinatura do delegate.

Crie um novo projeto do tipo Console Application e nele vamos criar a classe ControladorEmail, que ir� delegar o Action ProcessarEmail para a classe que assinar o delegate ProcessarEmail, como mostra a Listagem 6.


public class ControladorEmail {
      public Action ProcessarEmail;
   
      public void EnviarEmail()
      {
          ProcessarEmail();
      }
}

Listagem 6. Classe ControladorEmail

Agora iremos construir as classes que ir�o receber o e-mail, como mostra a Listagem 7Logo. , ir�o assinar o delegate da classe ControladorEmail.


public class UsuarioA
{
          public void Assinar(ControladorEmail controlador)
          {
              controlador.ProcessarEmail += ProcessarEmail;
          }
          public void ProcessarEmail()
          {
              Console.WriteLine("Email Recebido pelo usu�rio A");
          }
   
          public void CancelarAssinatura(ControladorEmail controlador)
          {
              controlador.ProcessarEmail -= ProcessarEmail;
          }
}
public class UsuarioB
{
          public void Assinar(ControladorEmail controlador)
          {
              controlador.ProcessarEmail += ProcessarEmail;
          }
          public void ProcessarEmail()
          {
              Console.WriteLine("Email Recebido pelo usu�rio B");
          }
          public void CancelarAssinatura(ControladorEmail controlador)
          {
              controlador.ProcessarEmail -= ProcessarEmail;
          }
}
   
public class UsuarioC
{
          public void Assinar(ControladorEmail controlador)
          {
              controlador.ProcessarEmail += ProcessarEmail;
          }
          public void ProcessarEmail()
          {
              Console.WriteLine("Email Recebido pelo usu�rio C");
          }
          public void CancelarAssinatura(ControladorEmail controlador)
          {
              controlador.ProcessarEmail -= ProcessarEmail;
          }
}

Listagem 7. Classes dos tipos de usu�rios que receberam os e-mails

Para o m�todo Main deste programa usaremos o c�digo da Listagem 8.


static void Main(string[] args)
{
 
    ControladorEmail controlador = new ControladorEmail();
    var usuarioA = new UsuarioA();
    var usuarioB = new UsuarioB();
    var usuarioC = new UsuarioC();
 
    Console.WriteLine("Os usuarios A, B e C cadastraram-se para 
    receber as promoç�es. \n");
       usuarioA.Assinar(controlador);            
     usuarioB.Assinar(controlador);            
     usuarioC.Assinar(controlador);
 
     Console.WriteLine("Enviando os emails para os usuarios assinados 
     (usu�rios cadastrados).\n");
       controlador.EnviarEmail();
 
     Console.WriteLine("\nO usu�rio A resolveu concancelar a assinatura e 
     n�o ir� receber mais emails.\n");
     usuarioA.CancelarAssinatura(controlador);
 
 
     Console.WriteLine("Enviando os emails para os usuarios assinados.\n");
     controlador.EnviarEmail();
 
     Console.ReadKey();
 
 }

Listagem 8. M�todo Main do exemplo 2

O resultado desse exemplo pode ser visto na Figura 2.

Figura 2. Execuç�o do exemplo 2

Usando as interfaces do .net Framework

Pensando neste padr�o, o framework .NET disponibiliza duas interfaces que fornecem um mecanismo generalizado para notificaç�o baseada em envio,que s�o:

IObservable, que � o provedor para notificaç�o de envio;
IObserver, que fornece um mecanismo para receber as notificaç�es de envio.

Para explicar o uso destas interfaces vamos realizar o mesmo exemplo feito anteriormente. Primeiramente, vamos criar uma classe que herda de IObservable, sendo que, para o nosso exemplo, T ser� um email, mas poderia ser uma string tamb�m.

Definimos a classe Email como:


  public class Email
  {
      public string Descricao { get; set; }
}

Assim, a classe ControladorEmail ficar� como mostra o c�digo da Listagem 9.


// Poderiamos apenas herdar de IObservable<string> tambem.
public class ControladorEmail : IObservable<Email>
{
  public List<IObserver<Email>> _usuarios;
  public Email _email;

  public ControladorEmail(Email email)
  {
      _usuarios = new List<IObserver<Email>>();
      _email = email;
  }

  public IDisposable Subscribe(IObserver<Email> usuario)
  {
      if (!_usuarios.Contains(usuario))
          _usuarios.Add(usuario);

      return new Disposer(_usuarios, usuario);
  }

  public void EnviarEmail()
  {
      _email.Descricao = "Email Enviado para o usu�rio";

      foreach (IObserver<Email> usuario in _usuarios)
      {
          usuario.OnNext(_email);
      }
  }
}

Listagem 9. Classe ControladorEmail

Note que esta classe cont�m uma lista de IObserver, que poder� ser usada no m�todo EnviarEmail, que � o m�todo usado para notificar os usu�rios. Esta classe tamb�m implementa o m�todo Subscribe, que retorna um IDisposable. Esse retorno ser� capaz de fazer o cancelamento da assinatura do usu�rio, como visto no m�todo da Listagem 10.


public class Disposer : IDisposable
{
       private List<IObserver<Email>> _usuarios;
       private IObserver<Email> _usuario;
   
public Disposer(List<IObserver<Email>> usuarios, 
IObserver<Email> usuario)
{
    _usuarios = usuarios;
    _usuario = usuario;
}
 
public void Dispose()
{
    if (_usuarios.Contains(_usuario))
        _usuarios.Remove(_usuario);
}
}

Listagem 10. M�todo Disposable

Note que o m�todo Dispose, usado para remover a assinatura, retira um IObserver da lista.

Por fim, iremos construir as classes que ir�o receber o e-mail e, para este fim, elas ter�o que herdar a classe IObserver, que cont�m os seguintes m�todos:

OnCompleted() � Notifica aos observadores que o provider terminou de enviar todas as notificaç�es. Assim, quando implementado, pode chamar, opcionalmente, o m�todo Dispose do objeto IDisposable, que foi devolvido ao observador quando chamou o m�todo IObservable ;
OnError(Exception error) � M�todo utilizado para informar aos observadores que algum erro ocorreu.
OnNext(T value) � fornece um novo valor aos observadores (usaremos somente este item).

Parece um pouco complicado, mas com o exemplo da Listagem 11 ficar� mais claro. Observe as seguintes classes.


public class UsuarioA : IObserver<Email>
     {
      private IDisposable _disposer;

      public UsuarioA(IObservable<Email> controladorEmail)
      {
          _disposer = controladorEmail.Subscribe(this);
      }

      public void OnCompleted()
      {
          throw new NotImplementedException();
      }

      public void OnError(Exception error)
      {
          throw new NotImplementedException();
      }

      public void OnNext(Email value)
      {
          Console.WriteLine(value.Descricao + "A");   
      }

      public void Dispose()
      {
          _disposer.Dispose();
      }
}
 
public class UsuarioB : IObserver<Email>
  {
      private IDisposable _disposer;
      public UsuarioB(IObservable<Email> controladorEmail)
      {
          _disposer = controladorEmail.Subscribe(this);
      }
      public void OnCompleted()
      {
          throw new NotImplementedException();
      }

      public void OnError(Exception error)
      {
          throw new NotImplementedException();
      }

      public void OnNext(Email value)
      {
          Console.WriteLine(value.Descricao + "B");
      }
           
      public void Dispose()
      {
          _disposer.Dispose();
      }    
  }
public class UsuarioC : IObserver<Email>
  {
      private IDisposable _disposer;

      public UsuarioC(IObservable<Email> controladorEmail)
      {
          _disposer = controladorEmail.Subscribe(this);
      }
      public void OnCompleted()
      {
          throw new NotImplementedException();
      }

      public void OnError(Exception error)
      {
          throw new NotImplementedException();
      }

      public void OnNext(Email value)
      {
          Console.WriteLine(value.Descricao + "C");
      }
           
      public void Dispose()
      {
          _disposer.Dispose();
      }
}

Listagem 11. Implementaç�o dos m�todos da classe IObserver

Note que no construtor de cada classe cont�m um IObservable respons�vel por registrar os usu�rios a serem notificados. J� o m�todo next � a implementaç�o de como o cada usu�rio ser� noticiado.

Para o m�todo Main do programa temos o c�digo da Listagem 12.


static void Main(string[] args)
{
   var email = new Email();

   var controladorEmail = new ControladorEmail(email);

   Console.WriteLine("Os usuarios A, B e C cadastraram-se para 
   receber as promoç�es. \n");

   var usuarioA = new UsuarioA(controladorEmail);
   var usuarioB = new UsuarioB(controladorEmail);
   var usuarioC = new UsuarioC(controladorEmail);

   Console.WriteLine("Enviando os emails para os usu�rios assinados 
   (usu�rios cadastrados).\n");  

   controladorEmail.EnviarEmail();

   Console.WriteLine("\nO usu�rio A resolveu cancelar a assinatura e 
   n�o ir� receber mais emails.\n");

   usuarioA.Dispose();

   Console.WriteLine("Enviando os emails para os usu�rios 
   assinados.\n");
   controladorEmail.EnviarEmail();

   Console.ReadKey();
    
}

Listagem 12. M�todo Main do exemplo 3

Analisando o c�digo da Listagem 12, note que foi instanciada a classe controladorEmail e as classes de usu�rio, sendo que, para cada usu�rio, a classe controladorEmail � passada via construtor. Logo, quando executamos o m�todo EnviarEmail, todos os usu�rios ser�o informados e, caso um usu�rio n�o queira ser mais notificado, basta executar o m�todo Dispose.

Como resultado, temos a tela de execuç�o da Figura 3.

Figura 3. Execuç�o do exemplo 3

Veja que n�o � dif�cil de implementar o padr�o de projeto Observer. Como � uma boa pr�tica, o framework .NET deixa o mesmo pronto para usarmos.

Links:

Como implementar o Design Pattern Observer no .NET

Veja nesse artigo como implementar uma solução de envio de emails usando o padrão de projeto Observer no .NET.

O Projeto

Modo comum de implementar o padr�o Observer

Usando Delegates

Usando as interfaces do .net Framework

Artigos relacionados