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); }