public void Iniciar()
{
_state = true;
WriterMessages.AmarzenaMSG(this, "Balanço iniciado...");
// notifica os observadores
Notify();
}
/*
* Sua intenção é definir uma família de algoritmos, encapsular cada uma delas e torná-las intercambiáveis.
*
* Participantes:
* Strategy - define uma interface comum para todos os algoritmos suportados. Context usa esta interface para chamar o algoritmo definido por uma ConcreteStrategy;
* ConcreteStrategy - implementa o algoritmo usando a interface Strategy;
* Contex - mantém uma referência para um objeto Strategy; pode definir uma interface que permite a Strategy acessar seus dados
*
*/
//Client
public void Strategy()
{
// cria um array com 20 números randomizados
long[] inputArray = new long[20];
Random rnd = new Random();
for (int i = 0; i < inputArray.Length; i++)
{
inputArray[i] = rnd.Next(100);
}
// mostra os números desordenados
WriterMessages.AmarzenaMSG(this, "Números originais:");
foreach (var number in inputArray)
{
WriterMessages.AmarzenaMSG(this, number.ToString());
}
// usando a estratégia para ordenar...
Context ctx = new Context(new InsertionSort());
ctx.ContextInterface(inputArray);
// mostra números ordenados
WriterMessages.AmarzenaMSG(this, "*******************************<br><span style='color:red'>Números ordenados: </span>");
foreach (var number in inputArray)
{
WriterMessages.AmarzenaMSG(this, number.ToString());
}
Response.Write(WriterMessages.GetAllMessages());
}
public void Finalizar()
{
_state = false;
WriterMessages.AmarzenaMSG(this, "Balanço finalizado...");
// notifica os observadores
Notify();
}
/*
* -Parecido com strategy
*
* Sua intenção é permitir que um objeto altere seu comportamento quando seu estado interno muda. O padrão pode ser aplicado quando o comportamento de um objeto
* depende do seu estado e ele pode mudar seu comportamento em tempo de execução, dependendo desse estado; operações têm comandos condicionais grandes, de várias
* alternativas, que dependem do estado do objeto. Esse estado é normalmente representando por uma ou mais constantes enumeradas. ,
*
* Participantes:
* Context - define uma interface de interesse para os clientes; mantém uma instancia de uma subclassse ConcreteState que define o estado corrente
* State - define uma interface para o encapsulamento associado com um determinado estado do Context;
* ConcreteState Subclasses - cada subclasse implementa um comportamento associado com um estado do Context.
*/
public void State()
{
Connection con = new Connection(new ConnectionOpened());
con.Open();
con.Close();
Response.Write(WriterMessages.GetAllMessages());
}
/*
* padrão Private Class Data, que tem por intenção separar os atributos de uma classe do seu comportamento, tornando estes uma classe separada de dados (data class).
* A classe de origem então tem uma associação com esta classe de dados, inicializando seus atributos por construção.
*/
public void PrivateClassData()
{
var cli = new Cliente(1, "guz", "123", "*****@*****.**", "99999999");
cli.MostrarCliente();
cli.MostrarContatoCliente();
Response.Write(WriterMessages.GetAllMessages());
}
/*
*
* Este padrão tem por objetivo definir o esqueleto de um algoritmo em uma operação, postergando alguns passos para as subclasses. Template Method
* permite que as subclasses redefinam certos passos de um algoritmo sem mudar a estrutura do mesmo.
*
* Participantes:
* AbstractClass - define as operacoes primitivas abstratas que as subclasses concretas definem para implementar passos de um algoritmo; implementa um
* método-template que define o esqueleto de um algoritmo;
* ConcreteClass - implementa as operações primitivas para executar os passos específicos invariantes do algoritmo
*
*/
public void TemplateMethod()
{
Correcao prova = new CorrecaoProva();
prova.Processar();
Correcao redacao = new CorrecaoRedacao();
redacao.Processar();
Response.Write(WriterMessages.GetAllMessages());
}
public void Iniciar()
{
// state = true se balanco foi iniciado
if (!_state)
{
WriterMessages.AmarzenaMSG(this, "Venda iniciada...");
}
else
{
WriterMessages.AmarzenaMSG(this, "Não posso iniciar venda pois balanço está em andamento");
}
}
public void ObserverFesta()
{ //observers
var namorada = new NamoradaAniversariante();
var mae = new MaeAniversariante();
var avo = new AvoAniversariante();
//subject
var porteiro = new Porteiro();
porteiro.AddChegadaAniversarianteObserver(namorada);
porteiro.AddChegadaAniversarianteObserver(mae);
porteiro.AddChegadaAniversarianteObserver(avo);
porteiro.VerificarSeOMoradorEOAniversariante();
Response.Write(WriterMessages.GetAllMessages());
}
/*
* A intenção do padrão Observe é definir uma dependência um-para-muitos entre objetos de modo que quando um objeto muda de estado, todos os seus dependentes
* são notificados e atualizados automaticamente. ".
*
* Participantes:
* Subject - conhece os seus observadores. Um número qualquer de objetos Observer pode observar um Subject;
* Observer - define uma interface de atualização para objetos que deveriam ser notificados sobre mudanças em um Subject;
* ConcreteSubject - armazena estados de interesse para obetos ConcreteObserver; envia uma notificação para os seus observadores quando seu estado muda;
* ConcreteObserver - mantém uma refêrencia para um objeto ConcreteSubject; armazena estados que deveriam permanecer consistentes com os do Subject. implementa
* a interface de atualização de Observer, para mater seus estados consistente com o do Subject;
*
*/
public void Observer()
{
// Concrete Subject
Balanco balanco = new Balanco();
// Concrete Observer
Venda venda = new Venda(balanco);
// adicionar os observadores
balanco.AdionaObservador(venda);
//processo...
balanco.Iniciar();
//balanco.Finalizar();
// pode vender?
venda.Iniciar();
Response.Write(WriterMessages.GetAllMessages());
}
/*
* Visitor permite definir uma nova operação sem mudar as classes dos elementos sobre as quais opera Entre os principais benefícios podemos citar a facilidade na
* adição de novas operações que dependem de objetos complexos, reduzindo assim o acoplamento e fazendo com que o desenvolvimento foque na programação com abstrações.
*
* Participantes:
* Visitor - declara uma operação Visit para cada ConcreteElement na estrutura do objeto; O visitante pode acessar o elemento diretamente através da interface específica.
* ConcreteVisitor - implementa cada operação (fragmento do algoritmo) declarada por Visitor;
* Element - define a operação Accept que aceita o visitante;
* ConcreteElement - implementa a operação Accept;
* ObjectStructure - pode enumerar seus elementos;
*
*/
public void Visitor()
{
// configurar a estrutura
ObjectStrutcture obj = new ObjectStrutcture();
obj.Attach(new ConcreteElementA());
obj.Attach(new ConcreteElementB());
// criar os visitors
ConcreteVisitor1 v1 = new ConcreteVisitor1();
ConcreteVisitor2 v2 = new ConcreteVisitor2();
// estrutura aceitar visitors
obj.Accept(v1);
obj.Accept(v2);
Response.Write(WriterMessages.GetAllMessages());
}
public void Chegou(ChegadaAniversarianteEvent evento)
{
WriterMessages.AmarzenaMSG(this, "Apagar Luzes");
WriterMessages.AmarzenaMSG(this, "Fazer silencio");
WriterMessages.AmarzenaMSG(this, "Surpresa!");
}
public void Chegou(ChegadaAniversarianteEvent evento)
{
WriterMessages.AmarzenaMSG(this, "Parabéns neto!");
}
public override void Interpret(Context context)
{
WriterMessages.AmarzenaMSG(this, "Chamado método NonterminalExpression.Interpret()");
}
public void Pagar(double valor)
{
// simulando pagamento via boleto
WriterMessages.AmarzenaMSG(this, "Pago boleto no valor de " + valor);
}
public void Pagar(double valor)
{
// simulando pagamento via cartão
WriterMessages.AmarzenaMSG(this, "Debitado valor no cartão " + valor);
}
public void Pagar(double valor)
{
// simulando pagamento via cartão
WriterMessages.AmarzenaMSG(this, "Cheque assinado no valor de " + valor);
}
public override void Iniciar()
{
WriterMessages.AmarzenaMSG(this, "Iniciando correção de Redação...");
}
public override void VisitConcreteElementB(ConcreteElementB concreteElementB)
{
WriterMessages.AmarzenaMSG(this, string.Format("{0} visitado por {1}", concreteElementB.GetType().Name, this.GetType().Name));
}
public override void Corrigir()
{
WriterMessages.AmarzenaMSG(this, "Corrigindo redação...");
}
public override void VerificarPrerequisitos()
{
WriterMessages.AmarzenaMSG(this, "Verificando pré-requisitos...");
}
public void MostrarCliente()
{
WriterMessages.AmarzenaMSG(this, _clienteData.Nome);
}
public override void LimparCorrecoesAnteriores()
{
WriterMessages.AmarzenaMSG(this, "Limpando dados anteriores do BD...");
}
public override void EnviarDadosParaBancoDeDados()
{
WriterMessages.AmarzenaMSG(this, "Enviando dados para o BD...");
}
public void MostrarContatoCliente()
{
WriterMessages.AmarzenaMSG(this, _clienteData.Contato);
}
public void Visualizar()
{
WriterMessages.AmarzenaMSG(this, "Visualizando foto " + Nome);
}
