Novo site

Olá, como vai? Decidi criar um outro site, contendo novos assuntos e mais atualizado. Para isso, basta acessar site oficial Rodrigo Macedo.

Introdução ao Projeto Mono

Mono é um projeto open-source liderado pela Novell e pela comunidade cujo objetivo é levar à distribuições Linux, a plataforma .Net. Apesar de o grande foco ser o ambiente em Linux, o Mono também possui plataformas no próprio Microsoft Windows, Mac OS X, BSD, and Sun Solaris, Nintendo Wii, Sony PlayStation 3 e Apple iPhone.

O objetivo do Mono é possibilitar que aplicações.NET, criadas em ambiente Windows , possam ser levadas a plataformas não - Microsoft, com poucos ajustes de código. Além de possibilitar cross-plataform, também pode-se escrever no Linux, com ferramentas específicas, como um compilador próprio para o ambiente, e uma IDE chamada MonoDeveloper. Enquanto o MonoDevelop oferece um caminho para se programar no Linux, os desenvolvedores para Windows tendem a abraçar o Visual Studio, apesar de haver soluções livres como o SharpDeveloper.

Mono tem permitido que desenvolvedores .NET possam também criar aplicações em ambientes Windows desde 2004, e há n projetos sobre a plataforma, inclusive o Wikipedia, que utiliza .NET na engine de procura/indexação de páginas, rodando sobre Mono.

Aceitação da Comunidade Linux

Quem me conhece, sabe o que eu penso sobre tecnologia: não é religião, ou time de futebol, embora não tenha ambos. São apenas ferramentas. Ferramentas que devem ser utilizadas de acordo com necessidades. Mesmo assim, há pessoas que encaram isso como uma filosofia de vida, o que não considero lá a pior das tristezas, mas é ruim que se deixa de aproveitar muita coisa boa, por um motivo aparentemente revolucionário. Acompanhe o texto abaixo:

“Every line of code that is written to our standards is a small victory; every line of code that is written to any other standard, is a small defeat. Total victory [...] is the universal adoption of our standards by developers, as this is an important step towards total victory for Microsoft itself: “A computer on every desk and in every home, running Microsoft software.”"
–Microsoft, internal document

fonte: http://boycottnovell.com/2009/01/22/mono-excludes-gnu-linux/

Isso realmente soa uma ameaça? Sinceramente, para mim não... mas alguns consideram textos como esse como uma verdadeira ameaça à liberdade, e a fonte de toda miséria humana. Se fosse da antiga Sun/Borland, imagino que a repercussão seria diferente.

Inclusive, eu convido algum espírito livre, a me informar os reais motivos para banir o Mono do Linux, com base no respeito, logicamente. Esse como outros movimentos “livres” (pois é, livres de que?) que apóiam isso. Mas, grupos como esses já são discriminados internamente.
Ferramentas

1. MonoDevelop

Nascida em 2003, feita por alguns desenvolvedores da comunidade Mono, com o objetivo de levar o SharpDeveloper para ambientes não-Windows, o MonoDevelop é uma IDE gratuita e open-source projetada para usar qualquer linguagem .NET disponível até o framework 3.0 (como C#, VB.NET, Boo, Nemerle) e Java (pelo IKVM.NET, que é a implementação de Java , que é interpretado pela runtime do Mono). Também há outros projetos, como PHP4Mono, que traduz a linguagem PHP, para a CIL (Common Intermediate Language).

2. Migration Analyzer (MoMA)

O Mono Migration Analyzer (MoMA) é uma ferramenta que identifica potenciais problemas que você pode ter portanto sua aplicação para o Mono. Identifica, por exemplo, uso de recursos de P/Invoke, que é específico do Windows, e outras áreas não suportadas pelo Mono.

Vamos para melhor parte do artigo, vamos construir uma aplicação em c# e rodá-lo no Linux, usando o Mono.

1) Criando uma Console Application

Clique em Arquivo, New Solution, ou se preferir (CTRL + SHIFT + N) (essa atalho também funciona no Visual Studio). A IDE nos facilitou muito trabalho, afinal de contas. Já temos um código com o nada-usual “Hello World”.

2) Criando uma Aplicação com Interface (baseado em WinForm)

Vá em “Adicione um Container à interface”. Este container é um agrupador de objetos.
Instancie uma Label e uma Textbox. Na janela de Propriedades, modifique as propriedades “Rótulo” e “Nome do Widget” do objeto para “uxlblNome” e “Nome:” da Label, e para o Textbox, as propriedades Name e Nome do Widget para “uxtxtNome”.

Para programar o evento de clique do botão, vá para aba Signals, vá em “Button Signals”. Clique duas vezes no evento Clicked. Automaticamente, o método será criado no Codebehind, e associado o evento do botão ao método. Feito isso, retorne para o code-behind e escreva o seguinte código. Recompile. Escreva no evento do botão, o código abaixo:


protected virtual void OnUxbtnOkClicked (object sender, System.EventArgs e)
{
uxlblResultado.Text = this.uxtxtNome.Text + ", seja bem vindo ao projeto Mono";
}

Execute a aplicação apertando F5.

Pronto, terminamos uma aplicação simples em C# e rodamos no Linux. O que eu quero enfatizar aqui, é a facilidade de utilizar o Mono. Há algumas facilidades “herdadas” do Visual Studio, o que facilita muito um desenvolvedor trabalhar com o MonoDeveloper.

Para finalizar este artigo, estou utilizando Ubuntu como Sistema Operacional e OpenOffice como editor de Texto, ambos sistemas open-source.


Referências

http://en.wikipedia.org/wiki/MonoDevelop
http://mono-project.com/Mono_Basics
http://www.vivaolinux.com.br/artigo/Mono-Por-que-usalo?pagina=2
http://www.vivaolinux.com.br/artigo/Mono-e-C-%28parte-1%29/

Dev in Rio

O evento acontecerá no próximo dia 14 de setembro no Centro de Convenções SulAmérica, no Rio de Janeiro!


Evento sobre sobre Métodos Ágeis, Ruby e Ruby on Rails, Python, Java, Django, Open Source, Joomla!, com a participação de nomes como Vinícius Manhães Teles, Guilherme Silveira, Fabio Akita, Jacob Kaplan-Moss, Ryan Ozimek entre outros.

Mais informações: http://www.devinrio.com.br/

Função Javascript para Reload em um intervalo de Tempo.

Este artigo mostra como atualizar uma página, de tempos em tempos
por javascript e como manipular este objeto de tempo no evento de um botão. Ou se você preferir, no OnClick de qualquer objeto HTML.

Usei um algoritmo parecido para resolver uma questão de uma funcionalidade do sistema em que atualmente trabalho. Como não encontrei muita coisa na internet de como fazer isso especificamente, resolvi postar aqui.

<html>
<head>
    <script language="javascript">
        // Variável global do objeto temporizador.
        var timer;

        function parar() { 
          window.clearTimeout(this.timer);
        }

        function comecarReload() {
         timer = window.setTimeout("location.reload()", 700);
        }
    </script>

</head>
<body onload="comecarReload();">
    <input type="button" onclick="comecarReload();" value="Iniciar Reloads" />
    <input type="button" onclick="parar();" value="Parar" />
</body>
</html>

Espero que possa ser útil. Abraços.

DOT NET NUKE (.NET NUKE)

No momento estou pensando em utilizar um CMS (Content Management System) para uma aplicação pessoal. Investiguei na internet alguns casos de sucesso do DotNetNuke, e no site do projeto encontrei alguns casos nacionais como Musical Carioca e GAP RJ.

Para quem não conhece, o DotNetNuke é uma iniciativa open source de Content Management Framework, baseado em tecnologia .NET. É um framework desenvolvido em VB.NET, e atualmente se encontra na versão 5.1. Provavelmente vou usá-lo.

Microsoft abre o código do Windows 7 para fabricantes de computadores

A Microsoft se pronunciou na última quarta, afirmando que irá abrir o código do Windows 7 para os fabricantes de computadores. Isso pode trazer alguns benefícios interessantes, como hardwares específicos que interagem com o sistema e implementação de drivers de modo mais seguro.

Atualmente, o Windows 7 está na versão release candidate. O release final está previsto para o dia 22 de outubro.

Workshop Lua - Rio de Janeiro

O Lua Workshop 2009 será realizado na PUC-Rio nos dias 6 e 7 de outubro de 2009, antecedendo o SBGames 2009 e o SIBGRAPI 2009. As atividades do dia 7 serão dedicadas ao uso de Lua em jogos e farão parte do Lua Games 2009, um pré-evento do SBGames 2009.

O workshop é aberto a todas as pessoas interessadas em Lua. Como há limite de espaço, é pedido a pré-inscrição pelo link ao lado.

Infelizmente não poderei ir, apesar de trabalhar do lado da Gávea. O workshop cai bem no meu horário comercial. Imagino que não devo ser o único com esse problema. O time do Lua poderia ter trabalhado nisso, mas creio que eles devem ter um bom motivo para o evento bem no meio da semana.

Engraçado é que esses dias, eu vi com um amigo, um exemplo de um sistema em c# que consumia classes do LUA e a possibilidade de integrá-lo com um sistema que nós estamos construindo.

Também fiz contato com a equipe de organização sugerindo a gravação a reunião (ou parte dela). Seria interessante para divulgar a linguagem, que apesar de estar desde 1993 (se não me engano) não tem sua visibilidade merecida.

Uma Microsof 2.0 - Constribuição da Microsoft para o Kernel do Linux

Além de termos conhecimento de projetos open-source/livres como o ASP.NET MVC, Sandcastle, e mais especificamente, o projeto Mono, que é liderado pela Novell e apoiado pela Microsoft, é a primeira vez que a Microsoft desenvolve diretamente para o kernel do Linux. No dia 20 de Julho de 2009, a Microsoft anuncia sua contribuição a comunidade Linux.

Sobre licensa GPL, foram liberados mais 20.000 linhas de código. Mas o código apenas favorece aos interesses da própria Microsoft. A contribuição visa melhorar a performance do Hyper V, que é a plataforma de virtualização da Microsoft. Definitivamente, a Microsoft tem olhado com outros olhos a tecnologia que há em sua volta, finalmente. O que é muito bom para nós, tanto para os entusiastas de Linux quanto os usuários de Windows, pois nos acrescenta mais um item em nossa caixa de ferramentas.

ASP.NET MVC

Ultimamente, estou tentando encontrar tempo pra estudar a fundo o asp.net mvc. Eu ando meio enrolado estudando métodos ageis, sobretudo XP e SCRUM. Mas peguei alguns livros pra me guiar no estudo.



O que estou lendo neste momento é o Professional ASP.NET MVC 1.0. Foi feito pela própria equipe do framework, e pelo que consegui acompanhar me parece ser bastante didático e conciso.

O primeiro capitulo do livro pode ser encontrado gratuitamente aqui.

Ele mostra um tutorial passo-a-passo de como criar uma aplicação completa sobre o framework utilizando a separação de camadas proposta.

Boa leitura.

A Imortalidade

Pois é... outro dos nossos se vai hoje. A morte é um dos grandes erros da vida... daí eu vos pergunto: já não era hora de termos vencido?

Visão Geral da 70-528

Bom, meu nome é Rodrigo Macedo, e neste tópico falarei de maneira breve sobre o exame 70-528. Pretendo dar algumas dicas para aqueles que estão se preparando para a prova.



1. Visão do Exame
São 45 questões que você deve responder em até 2h30min. Você pode escolher uma linguagem, entre C# e Visual Basic que ficará no code-behind das questões. Caso esta avaliação sendo seu primeiro exame, você ganha o título de MCP (Microsoft Certified Professional). Com o exame 70-536 (Fundamentos), você adquire o título de MCTS (Microsoft Tecnology Specialist) em ASP.NET. As questões baseiam-se nos tópicos abaixo:

• Desenvolver e publicar uma aplicação web
  
• Integrar dados em uma aplicação web utilizando ADO.NET, XML, e Data-Bound Controls
  
• Desenvolver controles Web personalizados
  
• Monitorar, configurar e instalar aplicações
  
• Customizar e personalizar uma aplicação web
  
• Implementar autenticação e autorização em uma aplicação web
  
• Desenvolver aplicações web ASP.NET móveis
  

Para agendar o exame, você deve ir ao site da Prometric (http://www.prometric.com). É um site de baixa acessibilidade, infelizmente, mas é o único caminho que você tem para conseguir o voucher. A prova custa em torno do $80. Periodicamente, a Microsoft fornece o Second Shot, que é a possibilidade de refazer o teste caso não passe, gratuitamente. Como não é regular, caso tenha interesse é necessário visitar com frequencia o site da Microsoft para saber se a promoção é válida.

2. Guia de Estudo

Eu aconselho utilizar o Training Kit do exame 70-528 e a biblioteca do MSDN. Ao estudar, tenha em mente, fixar os conceitos e as classes que participam do contexto.
Claro que como tudo na vida, há mais de uma maneira de se realizar algo, mas tenha foco nas melhores práticas, no menor esforço e na melhor legibilidade de código. Reserve algum tempo para ler e reproduzir exemplos de artigos de internet. Há alguns bem esclarecedores. São úteis porque muitas vezes não compreendemos muito bem determinado assunto, ou por falta de prática ou por não entender como o autor discutiu determinado conceito, daí é fundamental o interesse e iniciativa de buscar novas fontes de estudo. Um dos sites que complementou meus estudos foi o ASpnet Tutorials (http://www.aspnettutorials.com/). Ele possui um bom material e recomendo a consulta.


3. Sobre a prova
Conteúdo suspenso.

Comunidade .Net é insular?

Hoje, li uma discursão no grupo .Net Architects que me chamou muito atenção. Foi uma discursão sobre a comunidade de desenvolvedores Microsoft, iniciado pelo meu xará Rodrigo Vieira. O título era: A Comunidade .net

Segundo o dictionary.com:

In-su-lar

–adjective
1.     of or pertaining to an island or islands: insular possessions.
2.     dwelling or situated on an island.
3.     forming an island: insular rocks.
4.     detached; standing alone; isolated.
5.     of, pertaining to, or characteristic of islanders.
6.     narrow-minded or illiberal; provincial: insular attitudes toward foreigners.
7.     Pathology. occurring in or characterized by one or more isolated spots, patches, or the like.
8.     Anatomy. pertaining to an island of cells or tissue, as the islets of Langerhans.

Desde quando iniciei minha carreira, venho acompanhando os desenvolvedores Microsoft, e posso afirmar que há uma cultura de isolar o que não é Microsoft, simplesmente porque não herda o Nome. Isso significa: ignorar cegamente todos os projetos open-sources, deificando apenas tecnologias Microsoft e criticando sem fundamentos outras linguagens. Mas a questão é: que tipo de profissional nos tornamos com esse tipo de comportamento?

Este cenário não é apenas do nosso país. Acabamos por dividir as tecnologias, e por conseqüência adaptar nosso estilo de vida para acomodar uma plataforma. De um lado, linguagens como Python, Ruby, bancos como MySql, e do outro a Microsoft, sozinha. Ao invés de termos a tecnologia como uma ferramenta, nós deixamos que a tecnologia nos escravizasse. Diariamente, encontro profissionais que se limitam e recriminam outros por usar o Firefox ou o Opera como navegador principal ao invés do Internet Explorer.

Antes de trabalhar com .Net, passei por algumas linguagens como Java, Delphi e etc. Antes de começar na plataforma, eu senti um certo preconceito. Porque há preconceito do outro lado. E posso adivinhar o porquê. Há um problema cultural em comunidades de tecnologia, não só em .Net, mas nas comunidades Java, Ruby, Boo. Cada grupo, por conveniência, levanta a bandeira da própria linguagem, e conseqüência, os produtos que os criadores da linguagem apóiam/criam. Há um certo “companheirismo” entre grupos não vinculados a Microsoft, pois há um certo modismo em ser contra a Microsoft. Não creio que toda resistência contra o Windows seja simplesmente porque os requisitos do SO não atendam esses usuários especiais ou porque o código simplesmente é uma caixa-preta para usuários comuns, mas claro, há sim quem use o Linux e goste. Eu sou um deles também.

Não acho sustentável como profissional de tecnologia tal tipo de postura. Além de me cheirar como fanatismo religioso de pior espécie, isso impede o crescimento e compacta a visão do profissional. Conhecer mais a fundo um framework específico de Java, por exemplo, pode trazer novas idéias e implementações. Um bom exemplo é o caso do Log4N e o NHibernate, que surgiram primeiro no Java, e vieram pra .Net com apoio da comunidade. Em falar em Hibernate, o surgimento de ferramentas ORM da Microsoft vieram como uma verdadeira novidade. Eu inclusive lembro-me de um artigo cujo autor trata o release como uma verdadeira revolução, um acontecimento inédito da história, sendo que isso já existe há anos em outras plataformas, e inclusive já disponível ao .net, mantido pela nata mais ativa da comunidade Microsoft.

Pode parecer absurdo, mas já vi gente comemorando até quando o servidor do Google cai.

O que é fato, é que a Microsoft vêm acompanhando outras tecnologias de perto, e a maior prova disso é o release do framework MVC logo após do boom do Ruby on Rails, que é inteiramente MVC. Outro bom exemplo é que a Microsoft usa Java Applet na transmissão ao vivo de webcast pelo navegador, e Adobe Flash, ao invés do Silverlight, em algumas páginas comerciais. Isso demonstra alguma fraqueza? Absolutamente não. Demonstra maturidade por parte dos líderes, pois nem a Microsoft se fecha em sua própria tecnologia.

Devemos questionar a postura cômoda de estudar apenas uma tecnologia, e estudar mais de uma. Mesmo que seja o NAint, o NHibernate próprios para uso do Framework. O .Net Architects, que é uma comunidade .Net para arquitetos, propôs uma discursão sobre Ruby on Rails. Isso os fez menos capazes? Eles migraram seus sistemas para RoR? Muito provavelmente não. Mas agora possuem conhecimento e prática de um novo framework. E isso pode ser aproveitado.

Precisamos limpar nossas mentes para aprender dos dois lados. Mesmo que não planejamos implementar em tal linguagem, porque não estudá-la simplesmente para conhecê-la? O Python, por exemplo, vem sendo discutido e sendo amplamente usado em diversos setores e industrias, inclusive pela própria NASA e pelo Google, e pelo que li até agora, é digna de uma atenção especial. Como um profissional .net, continuo estudando o framework e as novidades que vem surgindo, afinal é a linguagem que eu escolhi. Mas isso não impede que eu descontinue minha curiosidade.

Número de série de celulares

Todo aparelho celular possui um número serial de 15 algarismos. Para descobrir o número, digite *#06#. Escreva este número e o guarde. Caso seu aparelho seja furtado, você pode telefonar para operadora e informar este código. O seu celular será completamente bloqueado, mesmo que troquem o cartão SIM.

Isso invalida o aparelho, reduzindo o valor do aparelho, que poderá ser comercializado apenas algumas peças. Se todos tomassem essa precaução, o roubo de celulares seria inútil.

Como dinamicamente traduzir uma Página Web em ASP.NET

Com a globalização, nossas aplicações, além de fazerem o usual impossível, devem estar preparadas para serem multi-linguagem. Isso significa, que um cliente deve acessar sua aplicação na língua familiar. Como muitos de nós, várias soluções a esses problemas foram dadas. Poderíamos, simplesmente, colocar diversos campos no banco de dados e consumir de acordo com a língua, mas sabemos que isso, além de uma solução não muito simples (leia MANUTENÇÃO) não é a mais agradável.

No ASP.NET, temos o conceito de LocalResources, que são arquivos em formatação XML, que armazenam valores-chaves. Dessa forma, podemos sem muito esforço, abstrair a interface de usuário dos textos exibidos. Isso nos dá flexibilidade linguistica, uma vez que podemos ter uma aplicação que suporte mais de uma língua, sem criar diretamente um único trecho de código.

Para exemplificar, criei uma aplicação com as seguintes itens:


Neste momento com a página renderizada, eu tenho duas formas de criar o LocalResource. A primeira forma, é criar o elemento XML , ou utilizando o notepad, ou a interface do VS para criação de LocalResources. A segunda é deixar que a IDE faça o trabalho. Naturalmente, preferi a segunda opção. Na página, vá em Tools -> Generate Local Resource.


Com isso, temos um dicionário de chave/valor. Neste momento, nossa página ASPX possui a referência a este arquivo XML. Agora, nossa aplicação web possui uma lingua-padrão porém independe da camada de interface para textos. Estamos no caminho certo. Para suportar mais de uma língua, copie o arquivo gerado e entitule-o como "(nomedaPagina).aspx.en-US.resx". Altere os valores que estão em português para o idioma.



Provavelmente, sua aplicação está em português. Isso deve-se a personalização do seu navegador. Para alterar o idioma de preferência, vá Languages e adicione a linguagem "English-en-US". E mude a posição de modo que o idioma inglês fique como prioridade. Salve, e execute a página novamente.



Agora, sua página está preparada para falar em outras línguas e dar boas vindas (mesmo que atrasadas) ao mundo globalizado.

Como debugar Javascript em ASP.NET

Javascript (anteriormente chamado de Livescript) surgiu por volta de 1995 no navegador chamado Netscape, principal concorrente na corrida do monopólio de browsers na época. Hoje em dia, é incomum ver uma aplicação web sem qualquer uso de scripts em Javascript. Hoje irei demostrar como depurar (debugar) uma aplicação em ASP.NET com o Visual Studio 2008. Você pode utilizar a versão 2005 também.

O Internet Explorer oferece um programa de depuração chamado Microsoft Script Debugger, próprio para depuração de Scripts. Há também um plugin (que é muito bom, diga-se de passagem) para o Mozilla Firefox. Em outro momento, abordaremos como utiliza-lo. Voltando para o Internet Explorer, para torna-lo ativo, você precisa ir em Tools -> Internet Options -> Advanced e desmarcar a opção "Disable Script Debug (Internet Explorer)".



No Javascript, acrescente a palavra "debugger;" no ponto onde você deseja começar a depuração.

<script language="JavaScript">
function resultado() {
 debugger; 
var somaValores = parseFloat(document.all('parcela1').value) + parseFloat(document.all('parcela2').value);
document.all('total').value = eval(somaValores)
}
</script>

Dessa forma, você conseguirá debugar facilmente seu javascript, sem fazer um "chinês" mental.



O exemplo na íntegra se encontra abaixo:

<%@ Page Language="C#" AutoEventWireup="true" CodeFile="Default.aspx.cs" Inherits="_Default" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
<title>Untitled Page</title>

<script language="JavaScript">

function resultado() {
debugger;
var somaValores = parseFloat(document.all('parcela1').value) + parseFloat(document.all('parcela2').value);
document.all('total').value = eval(somaValores)
}
</script>

</head>
<body>
<form id="form1" runat="server">
<div>
   <form name="calc">
   <input type="text" name="parcela1" size="20" maxlength="30" class="disp">+
   <input type="text" name="parcela2" size="20" maxlength="30" class="disp">=
   <input type="text" name="total" size="20" maxlength="30" class="disp">
   <input type="button" name="closeprth" value="OK" class="btswhite" onclick="resultado()">
   </form>
</div>
</form>
</body>
</html>

Singleton

Dar a responsabilidade a uma classe de controlar a própria instância, e fornecer um método de acesso a mesma de forma global. Utilize o padrão quando for necessário apenas uma instância em toda aplicação.

1. Diagrama de Classes


2. Benefícios x Desvantagens

Controle da instância: possui total controle da instância, já que a mesma controla o processo de instancialização.

3. Código

C#

using System;
using System.Collections.Generic;
using System.Text;

namespace SingletonTest
{
    class Program
    {
        static void Main(string[] args)
        {
            ServerList serverList = ServerList.GetInstance();
        }
    }

    /// 

    /// Singleton
    /// 
    sealed class ServerList
    {
        private static readonly ServerList _instance = new ServerList();
        private IDictionary _serverList = new Dictionary();

        private ServerList()
        {
            PopulateServerList();
        }

        /// 

        /// Popula lista para o exemplo.
        /// 
        private void PopulateServerList()
        {
            this._serverList.Add("DarthVader", "192.168.0.1");
            this._serverList.Add("Luke Skywalker", "192.168.0.2");
            this._serverList.Add("Obi-wan", "192.168.0.3");
        }

        /// 

        /// Retorna a instancia de ServerList.
        /// 
        public static ServerList GetInstance()
        {
            return _instance;
        }
    }
}

VB.NET

Imports System
Imports System.Collections.Generic
Imports System.Text

Namespace SingletonTest
    Class Program
        Private Shared Sub Main(ByVal args As String())
            Dim serverList__1 As ServerList = ServerList.GetInstance()
        End Sub
    End Class
    
    ''' 

    ''' Singleton
    ''' 
    NotInheritable Class ServerList
        Private Shared ReadOnly _instance As New ServerList()
        Private _serverList As IDictionary(Of String, String) = New Dictionary(Of String, String)()
        
        Private Sub New()
            PopulateServerList()
        End Sub
        
        ''' 

        ''' Popula lista para o exemplo.
        ''' 
        Private Sub PopulateServerList()
            Me._serverList.Add("DarthVader", "192.168.0.1")
            Me._serverList.Add("Luke Skywalker", "192.168.0.2")
            Me._serverList.Add("Obi-wan", "192.168.0.3")
        End Sub
        
        ''' 

        ''' Retorna a instancia de ServerList.
        ''' 
        Public Shared Function GetInstance() As ServerList
            Return _instance
        End Function
    End Class
End Namespace

Prototype

Especifica os tipos de objetos a serem criados usando uma instância-protótipo e cria novos objetos a partir do mesmo. É recomendado usar este padrão para evitar o crescimento de classes no sistema.

O Prototype e os padrões fábricas são similares em sua intenção. Ambos são criacionais. A principal diferença entre eles é o modo que são construídos. Nas fábricas, pode-se construir objetos usando os parâmetros de cada vez. Há uma similaridade entre eles. O Prototype, é usado para clonar qualquer objeto dado.

1. Diagrama de Classes


2. Considerações Importantes

Provavelmente, o mais complexo deste padrão é o método clone. Ela pode ser difícil quando a clone faz o uso de referências. Para algumas linguagens mais dinâmicas, como nosso c# ou Java, há uma implementação genérica por reflection. O nome da técnica usada é shallow clone. Naturalmente, você pode implementar seu próprio método-clone, programaticamente (chama-se deep copy).

3. Benefícios x Desvantagens

Acrescenta e remove produtos em tempo de execução: permite que incorporar uma nova classe concreta apenas registrando uma instância prototype com o cliente, deixando flexível instalar e remover em tempo de execução.

Reduz o número de subclasses: evita uma explosão de classes, pois permite clonar em vez de criar um novo objeto. Você pode especificar novos objetos a partir da variação da estrutura interna.

4. Código

C#

using System;
using System.Collections.Generic;
using System.Text;

namespace Prototype
{
    class Program
    {

        static void Main(string[] args)
        {
            Prototype p1 = new ConcretePrototype1("ID");
            Prototype c1 = p1.Clone();
            Console.WriteLine("Real: {0} - Clone: {1}", p1.ToString(), c1.ToString());
        }
    }


    public abstract class Prototype
    {

        private string _id;


        public string ID
        {
            get { return _id; }
            set { _id = value; }
        }


        public Prototype(string id)
        {
            this.ID = id;
        }


        public override string ToString()
        {
            return ID;
        }

        public abstract Prototype Clone();
    }


 
    public class ConcretePrototype1 : Prototype
    {

        public ConcretePrototype1(string id) :base(id)
        {
        }



        public override Prototype Clone()
        {
            return (Prototype)this.MemberwiseClone();
        }
    }


    public class ConcretePrototype2 : Prototype
    {
        public ConcretePrototype2(string id) : base(id)
        {
        }

        public override Prototype Clone()
        {
            return (Prototype)this.MemberwiseClone();
        }
    }
}

VB.NET

Imports System
Imports System.Collections.Generic
Imports System.Text

Namespace Prototype
    Class Program
        
        Private Shared Sub Main(ByVal args As String())
            Dim p1 As Prototype = New ConcretePrototype1("ID")
            Dim c1 As Prototype = p1.Clone()
            Console.WriteLine("Real: {0} - Clone: {1}", p1.ToString(), c1.ToString())
        End Sub
    End Class
    
    
    Public MustInherit Class Prototype
        
        Private _id As String
        
        
        Public Property ID() As String
            Get
                Return _id
            End Get
            Set(ByVal value As String)
                _id = value
            End Set
        End Property
        
        
        Public Sub New(ByVal id As String)
            Me.ID = id
        End Sub
        
        
        Public Overloads Overrides Function ToString() As String
            Return ID
        End Function
        
        Public MustOverride Function Clone() As Prototype
    End Class
    
    
    
    Public Class ConcretePrototype1
        Inherits Prototype
        
        Public Sub New(ByVal id As String)
            MyBase.New(id)
        End Sub
        
        
        
        Public Overloads Overrides Function Clone() As Prototype
            Return DirectCast(Me.MemberwiseClone(), Prototype)
        End Function
    End Class
    
    
    Public Class ConcretePrototype2
        Inherits Prototype
        Public Sub New(ByVal id As String)
            MyBase.New(id)
        End Sub
        
        Public Overloads Overrides Function Clone() As Prototype
            Return DirectCast(Me.MemberwiseClone(), Prototype)
        End Function
    End Class
End Namespace

Builder

Separa a construção de um objeto complexo de sua representação para que o processo de construção seja criado diferentemente da suas representações.

1. Diagrama de Classes

2. Participantes

Builder: especifica a interface abstrata para criação de partes de um objeto-builder.
BuilderConcreto: constrói as partes do produto, define e mantém a representação que cria.
Diretor: constrói um objeto apartir da interface do builder.
Produto: representa o objeto complexo que será construído.

3. Vantagens e Desvantagens

Permite variar a representação interna de um produto. O objeto builder fornece ao produtor/diretor apenas a sua abstração. Ou seja, o mesmo tem apenas a assinatura dos métodos para controlar a produção.

O cliente não precisa saber como é o processo interno do método. Apenas é de responsabilidade dele delegar aos métodos da abstração.

4. Padrões com a mesma finalidade

A diferença do padrão Builder para o Abstract Factory é o domínio da fabricação do objeto, pois cria o objeto final passo-a-passo.

5. Código

C#

using System;
using System.Collections.Generic;
using System.Text;

namespace BuilderTest
{
    class Program
    {
        static void Main(string[] args)
        {
            Director director = new Director();

            Builder b1 = new ConcreteBuilder1();
            Builder b2 = new ConcreteBuilder2();

            director.Construct(b1);
            BuilderTest.ConcreteBuilder2.Product p1 = b1.GetResult();

            p1.Show();
            Console.ReadKey();
        }
    }

    class Director
    {
        public void Construct(Builder builder)
        {
            builder.BuildPartA();
            builder.BuildPartB();
        }
    }
    abstract class Builder
    {
        public abstract void BuildPartA();
        public abstract void BuildPartB();
        public abstract BuilderTest.ConcreteBuilder2.Product GetResult();
    }

    class ConcreteBuilder1 : Builder
    {
        private BuilderTest.ConcreteBuilder2.Product _product = new BuilderTest.ConcreteBuilder2.Product();

        public override void BuildPartA()
        {
            _product.Add("PartA");
        }

        public override void BuildPartB()
        {
            _product.Add("PartB");
        }

        public override BuilderTest.ConcreteBuilder2.Product GetResult()
        {
            return _product;
        }
    }

    class ConcreteBuilder2 : Builder
    {
        private Product _product = new Product();

        public override void BuildPartA()
        {
            _product.Add("PartX");
        }

        public override void BuildPartB()
        {
            _product.Add("PartY");
        }

        public override Product GetResult()
        {
            return _product;
        }


        public class Product
        {
            private IList _parts = new List();

            public void Add(string part)
            {
                _parts.Add(part);
            }

            public void Show()
            {
                Console.WriteLine("\n Product Parts");

                foreach (string part in _parts)
                {
                    Console.WriteLine(part);
                }

            }
        }
    }
}

VB.NET

Imports System
Imports System.Collections.Generic
Imports System.Text

Namespace BuilderTest
    Class Program
        Private Shared Sub Main(ByVal args As String())
            Dim director As New Director()
            
            Dim b1 As Builder = New ConcreteBuilder1()
            Dim b2 As Builder = New ConcreteBuilder2()
            
            director.Construct(b1)
            Dim p1 As BuilderTest.ConcreteBuilder2.Product = b1.GetResult()
            
            p1.Show()
            Console.ReadKey()
        End Sub
    End Class
    
    Class Director
        Public Sub Construct(ByVal builder As Builder)
            builder.BuildPartA()
            builder.BuildPartB()
        End Sub
    End Class
    MustInherit Class Builder
        Public MustOverride Sub BuildPartA()
        Public MustOverride Sub BuildPartB()
        Public MustOverride Function GetResult() As BuilderTest.ConcreteBuilder2.Product
    End Class
    
    Class ConcreteBuilder1
        Inherits Builder
        Private _product As New BuilderTest.ConcreteBuilder2.Product()
        
        Public Overloads Overrides Sub BuildPartA()
            _product.Add("PartA")
        End Sub
        
        Public Overloads Overrides Sub BuildPartB()
            _product.Add("PartB")
        End Sub
        
        Public Overloads Overrides Function GetResult() As BuilderTest.ConcreteBuilder2.Product
            Return _product
        End Function
    End Class
    
    Class ConcreteBuilder2
        Inherits Builder
        Private _product As New Product()
        
        Public Overloads Overrides Sub BuildPartA()
            _product.Add("PartX")
        End Sub
        
        Public Overloads Overrides Sub BuildPartB()
            _product.Add("PartY")
        End Sub
        
        Public Overloads Overrides Function GetResult() As Product
            Return _product
        End Function
        
        
        Public Class Product
            Private _parts As IList(Of String) = New List(Of String)()
            
            Public Sub Add(ByVal part As String)
                _parts.Add(part)
            End Sub
            
            Public Sub Show()
                Console.WriteLine(vbLf & " Product Parts")
                
                For Each part As String In _parts
                    Console.WriteLine(part)
                    
                Next
            End Sub
        End Class
    End Class
End Namespace

Abstract Factory

A intenção do padrão é criar um objeto-fábrica que orquestra a instância dos objetos que serão produzidos, fornecendo uma interface comum para estes objetos.

1. Diagrama de Classes

2. Desvantagens x Benefícios

• Por isolar as classes concretas, o cliente controla o componente apenas a partir da assinatura da abstração da classe.
• Facilidade na troca de família de objetos, uma vez que a família implementa a mesma abstração e a fábrica é montada apenas na instancialização do objeto.
• Dificuldade em extensão da família. Estender uma classe pode acarretar dificuldades, pois deve se alterar a assinatura da fábrica e todas as classes herdadas.
• Há um senso harmônico entre os objetos produzidos. Todos possuem a mesma característica de sua abstração. E ainda há a possibilidade de fabricação de objetos apenas uma vez de cada vez.

3. Código

C#

using System;
using System.Collections.Generic;
using System.Text;

namespace AbstractFactoryTest
{
    class Program
    {
        static void Main(string[] args)
        {

            // Cria celulares da Companhia A.
            CellphoneFactory factoryOne = new CompanyACellphoneFactory();
            Industry industryOne = new Industry(factoryOne);
            industryOne.Produce();

            // Cria celulares da Companhia B.
            CellphoneFactory factoryTwo = new CompanyBCellphoneFactory();

            Industry industryTwo = new Industry(factoryTwo);
            industryTwo.Produce();

            Console.ReadKey();

        }
    }

    #region ProductsFromACompany


    public class CompanyATouchedScreenCellphone : AbstractCellphoneWithTouchedScreen
    {
        public override string ToString()
        {
            return "Um celular touch screen da empresa A";
        }
    }

    public class CompanyARegularCellphone : AbstractRegularCellphone
    {
        public override string ToString()
        {
            return "Um celular comum da empresa A";
        }
    }

    #endregion


    #region ProductsFromBCompany


    public class CompanyBTouchedScreenCellphone : AbstractCellphoneWithTouchedScreen
    {

        public override string ToString()
        {

            return "Cellphone touch screen da empresa B";

        }
    }


    public class CompanyBRegularCellphone : AbstractRegularCellphone
    {
        public override string ToString()
        {
            return "Um celular comum da empresa B";
        }
    }

    #endregion

    #region Abstracoes dos Produtos


    public abstract class AbstractCellphoneWithTouchedScreen
    {
        public abstract override string ToString();
    }


    public abstract class AbstractRegularCellphone
    {
        public abstract override string ToString();
    }

    #endregion


    abstract class CellphoneFactory
    {
        public abstract AbstractCellphoneWithTouchedScreen CreateCellphoneA();
        public abstract AbstractRegularCellphone CreateCellphoneB();
    }

    class CompanyACellphoneFactory : CellphoneFactory
    {

        public override AbstractCellphoneWithTouchedScreen CreateCellphoneA()
        {
            return new CompanyATouchedScreenCellphone();
        }


        public override AbstractRegularCellphone CreateCellphoneB()
        {
            return new CompanyARegularCellphone();
        }
    }


    class CompanyBCellphoneFactory : CellphoneFactory
    {
        public override AbstractCellphoneWithTouchedScreen CreateCellphoneA()
        {
            return new CompanyBTouchedScreenCellphone();
        }



        public override AbstractRegularCellphone CreateCellphoneB()
        {
            return new CompanyBRegularCellphone();
        }
    }

    class Industry
    {
        private AbstractCellphoneWithTouchedScreen cellphoneOne;
        private AbstractRegularCellphone cellphoneTwo;


        public Industry(CellphoneFactory cellphoneFactory)
        {
            this.cellphoneOne =cellphoneFactory.CreateCellphoneA();
            this.cellphoneTwo = cellphoneFactory.CreateCellphoneB();
        }

        public void Produce()
        {
            Console.WriteLine("Construção do celular: {0}. ", this.cellphoneOne.ToString());
            Console.WriteLine("Construção do celular: {0}. ", this.cellphoneTwo.ToString());

        }
    }
}

VB.NET

Imports System
Imports System.Collections.Generic
Imports System.Text

Namespace AbstractFactoryTest
    Class Program
        Private Shared Sub Main(ByVal args As String())
            
            ' Cria celulares da Companhia A.
            Dim factoryOne As CellphoneFactory = New CompanyACellphoneFactory()
            Dim industryOne As New Industry(factoryOne)
            industryOne.Produce()
            
            ' Cria celulares da Companhia B.
            Dim factoryTwo As CellphoneFactory = New CompanyBCellphoneFactory()
            
            Dim industryTwo As New Industry(factoryTwo)
            industryTwo.Produce()
            
                
            Console.ReadKey()
        End Sub
    End Class
    
    #Region "ProductsFromACompany"
    
    
    Public Class CompanyATouchedScreenCellphone
        Inherits AbstractCellphoneWithTouchedScreen
        Public Overloads Overrides Function ToString() As String
            Return "Um celular touch screen da empresa A"
        End Function
    End Class
    
    Public Class CompanyARegularCellphone
        Inherits AbstractRegularCellphone
        Public Overloads Overrides Function ToString() As String
            Return "Um celular comum da empresa A"
        End Function
    End Class
    
    #End Region
    
    
    #Region "ProductsFromBCompany"
    
    
    Public Class CompanyBTouchedScreenCellphone
        Inherits AbstractCellphoneWithTouchedScreen
        
        Public Overloads Overrides Function ToString() As String
            
                
            Return "Cellphone touch screen da empresa B"
        End Function
    End Class
    
    
    Public Class CompanyBRegularCellphone
        Inherits AbstractRegularCellphone
        Public Overloads Overrides Function ToString() As String
            Return "Um celular comum da empresa B"
        End Function
    End Class
    
    #End Region
    
    #Region "Abstracoes dos Produtos"
    
    
    Public MustInherit Class AbstractCellphoneWithTouchedScreen
        Public MustOverride Overloads Overrides Function ToString() As String
    End Class
    
    
    Public MustInherit Class AbstractRegularCellphone
        Public MustOverride Overloads Overrides Function ToString() As String
    End Class
    
    #End Region
    
    
    MustInherit Class CellphoneFactory
        Public MustOverride Function CreateCellphoneA() As AbstractCellphoneWithTouchedScreen
        Public MustOverride Function CreateCellphoneB() As AbstractRegularCellphone
    End Class
    
    Class CompanyACellphoneFactory
        Inherits CellphoneFactory
        
        Public Overloads Overrides Function CreateCellphoneA() As AbstractCellphoneWithTouchedScreen
            Return New CompanyATouchedScreenCellphone()
        End Function
        
        
        Public Overloads Overrides Function CreateCellphoneB() As AbstractRegularCellphone
            Return New CompanyARegularCellphone()
        End Function
    End Class
    
    
    Class CompanyBCellphoneFactory
        Inherits CellphoneFactory
        Public Overloads Overrides Function CreateCellphoneA() As AbstractCellphoneWithTouchedScreen
            Return New CompanyBTouchedScreenCellphone()
        End Function
        
        
        
        Public Overloads Overrides Function CreateCellphoneB() As AbstractRegularCellphone
            Return New CompanyBRegularCellphone()
        End Function
    End Class
    
    Class Industry
        Private cellphoneOne As AbstractCellphoneWithTouchedScreen
        Private cellphoneTwo As AbstractRegularCellphone
        
        
        Public Sub New(ByVal cellphoneFactory As CellphoneFactory)
            Me.cellphoneOne = cellphoneFactory.CreateCellphoneA()
            Me.cellphoneTwo = cellphoneFactory.CreateCellphoneB()
        End Sub
        
        Public Sub Produce()
            Console.WriteLine("Construção do celular: {0}. ", Me.cellphoneOne.ToString())
                
            Console.WriteLine("Construção do celular: {0}. ", Me.cellphoneTwo.ToString())
        End Sub
    End Class
End Namespace

Introdução aos Padrões de Criação

Os padrões de criação são os padrões de projeto que abstraem o processo de instanciação das classes, ajudando o sistema ser independe dos objetos concretos criados.

Para o sistema, tudo o que se sabe é que suas classes são definidas por classes abstratas. Isso facilita muito expansão do sistema no futuro. Iremos analisar os cinco padrões de criação escritos pela gangue dos quatro (GoF).

Abstract Factory	criar um objeto-fábrica que orquestra a instância dos objetos que serão produzidos.
Builder	Separa a construção de um objeto complexo de sua representação.
Prototype	Especifica os tipos de objetos a serem criados usando uma instância-protótipo e cria novos objetos a partir do mesmo.
Singleton	Dar a responsabilidade a uma classe de controlar a própria instância.