O padrão Observer é usado para notificar automaticamente múltiplos objetos quando o estado de outro objeto muda. Ele define uma relação “um-para-muitos” entre objetos, onde quando um objeto (o sujeito) muda, todos os seus observadores são notificados. É útil em situações onde várias partes do sistema precisam reagir às mudanças de um objeto, como em sistemas de eventos ou notificações.
Exemplo de Código em C#:
// Interface do Observador
public interface IObservador
{
void Atualizar(string estado);
}
// Interface do Sujeito
public interface ISujeito
{
void AdicionarObservador(IObservador observador);
void RemoverObservador(IObservador observador);
void NotificarObservadores();
}
// Implementação do Sujeito
public class SujeitoConcreto : ISujeito
{
private List<IObservador> _observadores = new List<IObservador>();
private string _estado;
public string Estado
{
get { return _estado; }
set
{
_estado = value;
NotificarObservadores();
}
}
public void AdicionarObservador(IObservador observador)
{
_observadores.Add(observador);
}
public void RemoverObservador(IObservador observador)
{
_observadores.Remove(observador);
}
public void NotificarObservadores()
{
foreach (var observador in _observadores)
{
observador.Atualizar(_estado);
}
}
}
// Implementação de Observadores
public class ObservadorConcreto1 : IObservador
{
public void Atualizar(string estado)
{
Console.WriteLine($"Observador 1 foi notificado. Novo estado: {estado}");
}
}
public class ObservadorConcreto2 : IObservador
{
public void Atualizar(string estado)
{
Console.WriteLine($"Observador 2 foi notificado. Novo estado: {estado}");
}
}
class Program
{
static void Main(string[] args)
{
// Criar o sujeito
SujeitoConcreto sujeito = new SujeitoConcreto();
// Criar e adicionar observadores
ObservadorConcreto1 observador1 = new ObservadorConcreto1();
ObservadorConcreto2 observador2 = new ObservadorConcreto2();
sujeito.AdicionarObservador(observador1);
sujeito.AdicionarObservador(observador2);
// Alterar o estado do sujeito
sujeito.Estado = "Estado A";
sujeito.Estado = "Estado B";
// Remover um observador e alterar o estado
sujeito.RemoverObservador(observador1);
sujeito.Estado = "Estado C";
}
}
Explicação do Código:
Neste exemplo, a classe SujeitoConcreto mantém uma lista de observadores e notifica todos os observadores registrados quando o estado muda. O método NotificarObservadores percorre a lista de observadores e chama o método Atualizar em cada um. Os observadores ObservadorConcreto1 e ObservadorConcreto2 reagem às mudanças de estado do sujeito.
Conclusão:
O padrão Observer é útil quando várias partes do sistema precisam ser informadas automaticamente sobre mudanças no estado de um objeto. Ele reduz o acoplamento entre o sujeito e os observadores, tornando o sistema mais flexível.
Código fonte: GitHub
Source link
lol
