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.

Introdução aos Padrões de Projeto

Design pattern (ou padrão de projetos) foi originado pela gangue dos quatro (Gang of Four). Décadas depois, padrões de projeto costuma ser uma novidade para programadores. Além de aumentar a qualidade de software com sua unificação de linha lógica de raciocínio, pode também aumentar a produtividade e qualidade do desenvolvimento de software.

A motivação dos padrões de projeto não é deixar os conjuntos de classes menores, mas sim mais flexíveis. Isso facilita muito expansão do sistema no futuro, uma vez 70% do tempo gasto no sistema são de manutenção e extensão. E nos dá o conceito de escalabilidade, que está ligada a capacidade de um sistema de crescer e evoluir.

Podemos resumir o conceito como elementos de códigos que são implementados de acordo com as necessidades que temos no decorrer dos nossos dias como desenvolvedores.

Naturalmente, dividimos os padrões de projeto em três grupos: os padrões criacionais, os estruturais e os comportamentais.

Criacionais : tem a responsabilidade de controlar a instância do objeto, abstraindo e deixando-as independentes de suas classes concretas.

Estruturais : tem a responsabilidade de planejar a estrutura da classe que se está construindo, aumentando a possibilidade de extensão das mesmas sem alteração grandes esforços.

Comportamentais : tem a responsabilidade de controlar comportamentos em tempo de execução.

Nos próximos artigos iremos falar sobre cada um desses tipos e seus padrões. Até a próxima.

Bibliografia:
[GoF] Gamma, Helm, Johnson, Vlissides. Prototype Pattern. Design Patterns — Elements of Reusable Object-Oriented Software, 1995.

Do Factory! - http://www.dofactory.com/

Indiana possui sua certificação aos 9 anos

Para você que estudou no exame para se tornar um MCP, ou pra você que pensa em realizar a prova. Uma indiana, de 9 anos, conseguiu passar o teste, batendo o recorde mundial de um outro garoto de 10 anos.

Configuração de uma aplicação em ASP.NET

Este artigo se trata de uma visão geral dos arquivos de configuração usados pelo ASP.NET. Pretendo dar uma introdução sobre os arquivos de configuração do ASP.NET e expor algumas funcionalidades interessantes do framework.


1. Introdução

Arquivos de configuração são usados para setar dados iniciais em um sistema. São usados nas mais diversas aplicações, nos dá a flexibilidade de alterar propriedades sem auxílio de um compilador. E isso pode nos ser útil. Imagine o seguinte cenário: você acaba de desenvolver uma ferramenta que auxilia o gerenciamento de usuários de uma pequena rede e o administrador deverá escolher quais grupos tem permissões. Você tem três opções: a primeira era forçar o administrador a dizer quais permissões pertencem a quais grupos todas as vezes que rodar o programa, a segunda é criar propriedades por código e fazer com que o administrador aprenda a sintaxe para altere os campos, ou ter um arquivo fácil de ser manipulado e de leve curva de aprendizado, da qual deixaria o administrador mais motivado.

A importância de um arquivo de configuração no ASP.Net é essencial para um bom desenvolvimento. Você pode controlar sua aplicação com praticamente todos as funcionalidades do ASP.NET. Trata-se de um conjunto poderoso de especificações que são guardadas em cachê, disponíveis globalmente para sua aplicação.

Os arquivos de configuração se comportam de maneira hierárquica, ou seja, as configurações de um arquivo “inferior” podem ser substituídas. Há dois arquivos de configuração:

• Machine.Config – Este arquivo se encontra no topo hierárquico. Contém configurações que serão aplicadas em todas as aplicações.NET. Nas versões anteriores à 3.0, se encontra em “C:\WINDOWS\Microsoft.NET\Framework\vx.x.xxxx\CONFIG".

• Web.Config – Este arquivo se encontra em uma aplicação específica, de acordo com as necessidades da mesma. Cada aplicação pode conter um web.config. Esse arquivo de configuração é opcional.

Como o arquivo “Web.Config” é mais específico, ele tende a substituir as configurações do “Machine.Config” por padrão. Caso não seja desejado, o atributo allowOverride na tag deve ser setado como false.

2. Usando uma interface gráfica para configuração

Para administradores, há uma preferência por uma interface para gerenciar a configuração. O ASP.NET provê uma interface chamada Web Site Administrator Tool, que permite editar configurações de diversos tipos como segurança e habilitar/desabilitar opções de tracing. Você encontra na opção WebSite -> ASP.NET Configuration, .


Figure 1: Interface para o Web.Config (Web Site Administrator).


3. Definindo variáveis globais a sua aplicação

A tag appSettings provê uma definição de variáveis estáticas, que podem ser usadas em toda aplicação. Isso nos dá a capacidade de configurar nossa aplicação em um único arquivo, modificando apenas os parâmetros. Sem precisar de que um desenvolvedor faça o trabalho.

   1:  <configuration>

   2:    <appSettings>

   3:      <add key="initialRow" value="15"/>

   4:      <add key="finalRow" value="55"/>

   5:    </appSettings>

   6:    </configuration>

//Primeiro Método:

   1:  ApplicationStarter.InitialNumber = (int) ConfigurationSettings.AppSettings["initialRow];

//Segundo Método:

   1:  ConfigurationManager.AppSettings["initialRow”];

O primeiro método se encontra depreciado. Isso significa que você pode usá-lo, mas o framework parou de fazer manutenção neste método. Apenas para fins didáticos.


4. Fornecendo suporte com a tag

A tag permite configurar a aplicação para responder diferentes opções de codificação, garantindo assim o tipo de codificação correta da cada país. Por padrão, o requestEnconding dentro do arquivo machine.config é utf-8.

requestEnconding - Especifica a codificação assumida para as requisições que chegarem.
responseEnconding - Especificação de resposta
fileEnconding - Especifica a codificação para análise de arquivos asmx, aspx e asax.
Culture - Especifica a cultura padrão para processar as requisições que chegam
uiCulture - Especifica a cultura padrão para processar pesquisas de recurso do local.

   1:  <configuration>

   2:    <system.web>

   3:      <globalization requestEncoding="Shift-JIS" responseEncoding="Shift-JIS"/>

   4:    </system.web>

   5:   </configuration>

5. Usando a tag identity para criar uma identidade de usuário

A tag identity nos permite criar uma identidade de usuário para aplicação. É uma tag útil para definir o nome de usuário e senha de uma base de dados.

   1:  <configuration>

   2:   <system.web>

   3:    <!-- 

   4:              Set compilation debug="true" to insert debugging 

   5:              symbols into the compiled page. Because this 

   6:              affects performance, set this value to true only 

   7:              during development.

   8:          -->

   9:      <identity userName="rmacedo" password="passwrd445"/>

  10:   </system.web>

  11:  </configuration>

6. Atribuindo especificações com a tag

A tag nos permite definir aspectos de cada página, como o uso de Viewstates e buffering. Mudando essas características, você automaticamente muda em todas as páginas de sua aplicação.

Buffer - Especifica se sua página aceita o uso de buffer.
enableSessionState - Especifica se o SessionState está ativado. Recebe valor booleano.
enableViewState - Especifica se o ViewState está ativado. Recebe valor booleano.
userControlBaseType - Permite especificar uma classe de code-behind seja herdade por uma página aspx.
autoEventWireup - Especifica se os eventos de página são ativados. Recebe valor booleano.


Você também pode definir especificamente para cada página através da diretiva que se encontra no topo de cada página aspx.


7. Ativando o rastreamento (trace)

Na engenharia de software, trace é a capacidade de obter informações de enquanto sua aplicação está em execução. Pode nos ajudar a encontrar bugs e outras falhas. Podemos especificar facilmente as funcionalidades de tracing com as propriedades abaixo:


Enabled - Especifica se o trace está ligado.

localOnly - Especifica se o trace apenas pode estar lgiado se for local ou acessado remotamente. É útil, caso se esqueça de trocar o enabled para falso antes de publicar a aplicação. Por este motivo, o padrão deste atributo está setado como true.
pageOutput - Especifica se o resultado está disponível através de um utilitário de rastreamento. O padrão é false, ou seja, aparecerá no final de cada página.

requestLimit - Valor que limita o número de requisições de tracing armazenadas no servidor. Por padrão, o número é 10.
traceMode - Especifica se o resultado do tracing deve ser classificado por hora ou por categoria.

   1:  <configuration>

   2:   <system.web>

   3:    <!-- 

   4:              Set compilation debug="true" to insert debugging 

   5:              symbols into the compiled page. Because this 

   6:              affects performance, set this value to true only 

   7:              during development.

   8:          -->

   9:   

  10:      <trace enabled="true" localOnly ="true" pageOutput="false" traceMode="SortByCategory"/>

  11:      

  12:   </system.web>

  13:  </configuration>

8. Definindo exceções personalizadas.

O uso da tag customErros pode gerenciar exceções não-tratadas, redirecionando ao cliente uma página mais amigável. A sub tag error de customError especifica erros, como veremos no exemplo a seguir.

   1:   <configuration>

   2:   <system.web>

   3:    <!-- 

   4:              Set compilation debug="true" to insert debugging 

   5:              symbols into the compiled page. Because this 

   6:              affects performance, set this value to true only 

   7:              during development.

   8:          -->

   9:   

  10:      <customErrors defaultRedirect="errorpage.aspx" mode="RemoteOnly"></customErrors>

  11:      

  12:   </system.web>

  13:  </configuration>

9. Autenticando usuários
São raras as aplicações que não usam uma forma de autenticar usuários. Usamos a tag authentication para autenticar usuários por questões de segurança. Abaixo seguem as opções do atribute mode:

Windows - Especifica o modo de autenticação Windows/IIS
Forms - Especifica um modo de autenticação baseado nos formulários Asp.Net
Passport - Especifica o uso de autenticação através do passport da Microsoft.
None - Nenhuma autenticação especificada.



Referências
ASP.NET Guia do Desenvolvedor.
MCTS Self-Paced Training Kit : Microsoft Web Based Client.

Para refletir: Conselhos de Bill Gates

Discurso de Bill Gates em uma escola, aconselhando os alunos sobre coisas que a instituição não ensina. Como eu sempre falo, há um longo percurso entre o ensino de uma faculdade e a vivência profissional.

Bill Gates falou por menos de cinco minutos, e foi aplaudido por mais de cinco minutos sem parar. Agradeceu e foi embora em seu helicóptero.

1. A vida não é fácil, acostume-se com isso.

2. O mundo não está preocupado com sua auto-estima. O mundo espera que você faça alguma coisa útil por ele antes de sentir-se bem com você mesmo.

3. Você não ganhará vinte milhões por mês assim que sair da escola. Você não será vice-presidente de uma empresa com carro e telefone à sua disposição antes que você tenha conseguido comprar seu próprio carro e telefone.

4. Se você acha seu professor rude, espere até ter um chefe. Ele não terá pena de você.

5. Vender jornal velho ou trabalhar durante as férias não está abaixo de sua posição social. Seus avós têm uma palavra diferente para isso: eles chamam de oportunidade.

6. Se você fracassar, não é culpa de seus pais. Então não lamente seus erros, aprenda com eles.

7. Antes de você nascer seus pais não eram tão críticos como agora. Eles só ficaram assim por pagar suas contas, lavar suas roupas e ouvir você dizer que eles são "ridículos". Então antes de salvar o planeta para a próxima geração, querendo consertar os erros da geração de seus pais, tente limpar seu próprio quarto.

8. Sua escola pode ter eliminado a distinção entre vencedores e perdedores, mas a vida NÃO é assim. Em algumas escolas você não repete mais de ano e tem quantas chances precisar até acertar. Isto não se parece com absolutamente NADA na vida real. Se pisar na bola, está despedido, Rua! Faça certo da primeira vez!

9. A vida não é dividida em semestres. Você não terá sempre os verões livres e é pouco provável que outros empregados o ajudem a cumprir suas tarefas no fim de cada período.

10. Televisão NÃO é vida real. Na vida real, as pessoas têm que deixar o barzinho ou boate e ir trabalhar.

11. Seja legal com os CDFs ou Nerds - aqueles estudantes que os demais julgam que são uns babacas - Existe uma grande probabilidade de você vir a trabalhar para um deles.

Fonte: http://www.larsoft.com.br/

Visão Geral sobre o Exame 70-536

Meu objetivo aqui é auxiliar, ou se preferirem, dar um empurrão (nada como um bom usuário agressivo!) para os que desejam realizar o exame 70-536 (Microsoft .NET Framework 2.0 Application Development Foundation). Para melhoria dos próximos, gostaria muito do seu feedback sobre este artigo. Bom, vamos lá!

1. Visão do Exame

A prova foi designada para profissionais que tenham ao menos dois ou três anos de experiência em desenvolvimento Web, ou Windows, ou em serviços, claro, teoricamente. Já vi alguns profissionais que conseguiram com bem menos do que isso passar. Você deve conhecer pelo menos uma linguagem. Antigamente, você precisava conhecer as duas linguagens e suas características. Há uma coisa que gostaria de destacar: passando neste exame, prova que você tem bons conhecimentos do .NET Framework, mas não mostra que você é um bom desenvolvedor. Para isso, dedique-se também a UML, padrões de projetos, e também investindo em seus próprios frameworks, e acima de tudo, corra atrás de sua experiência. Para não fugir do foco, basicamente as questões do exame referem-se aos itens abaixo:

• System types and collections: desenvolvendo aplicações que usam classes do Framework e coleções.

• Services, threading and application domains: implementando serviços (basicamente Windows Services), multithread e Application Domain.

• Configuration, diagnostic, management, and installation: implementando objetos de configuração, diagnóstico, e classes de instalação.

• Serialization and input / output: implementando serialização e deserialização.

• Security: desenvolvimento de classes de criptografia e característica de segurança do .Net Framework.

• Interoperability, Reflection, and Mailing: implementando interoperabilidade entre componentes COM, Reflection, e funcionalidade de e-mail.

• Globalization, Drawing, and Text manipulation: implementando classes como RegionInfo, CultureInfo, a parte de desenhos (Drawing), e manipulação de textos.

Você pode agendar sua prova através do site da Prometric (http://www.prometric.com). A Prometric é uma empresa de grande peso no mercado para provas de certificação, não apenas da Microsoft, mas também de diversas empresas de tecnologia. A prova em questão custa em torno de $80 (oitenta dolares). Está disponível nas línguas: Inglês, Francês, Alemão e Japonês. Antes de efetuar o teste, você também pode escolher em qual linguagem em que o teste se basea: C++, C# ou VB.NET.

Após concluir o exame e passar, a Microsoft envia um certificado, um broche e um cartão de identificação. Seu certificado virá com a assinatura do Steve Ballmer, em até quatro semanas. Sem falar no reconhecimento profissional que você ganha ao concluir.

2. Programa de Estudo

Eu aconselho os interessados em estudar usando o livro MCTS Self-Paced Training Kit (Exam 70-536), anotando as classes usadas e testando-as. É um livro bastante conciso, sem redundâncias, o que é muito bom. Com ele, você tem a certeza que terá uma boa base para certificação, pois o mesmo é focado no exame. Ao estudar, tenha como principal objetivo fixar os conceitos, as responsabilidades de cada classe, conhecer as diferenças entre os métodos e suas assinaturas.

Para ganhar mais de experiência e familiaridade com os temas, após terminar de ler o livro, procure ler artigos relacionados ao exame. Também tenha interesse por revistas técnicas. Eles te darão o mesmo conteúdo sob uma outra perspectiva, provavelmente mais focado nos problemas reais do dia-a-dia. Destaco os seguintes artigos:
• Todos artigos do Israel Aéce (Por Dentro da Base Class Library): http://www.linhadecodigo.com.br/Artigo.aspx?id=2148
• .NET Tutorials : http://www.beansoftware.com/NET-Tutorials/

Também sugiro o livro CLR via C Second Edition Pro Developer. É um livro, que inclusive, é referenciado no MCTS Self-Paced Training Kit. É útil para ter um conhecimento mais forte sobre plataforma, recomendo para aqueles que tem tempo sobrando para lê-lo.

Depois, com a base sólida, responder questões de simulados. O melhor jeito de fixar pontos é trabalhando com eles. Os testes sugeridos pela Microsoft são:
• MeasureUp (Measureup.com)
• Self Test Software (Selftestsoftware.com)

Há também o polêmico Testking. Há preconceito quanto a esse simulado. Como muito de vocês já sabem, o Testking é conhecido por ter questões semelhantes às do exame real. Custa aproximadamente $70. Não tenho conhecimento sobre a opinião oficial da Microsoft a respeito da empresa.

3. Visão geral as questões
Conteúdo suspenso.


4. Na hora do Exame

Faça um lanche reforçado, descanse bem e vá à luta! A Prometric pede para que o candidato chegue com meia hora de antecedência. É preciso ter duas formas de identificação, pode ser tanto sua identidade quanto sua carteira de motorista. Uma obrigatoriamente, precisa ter sua foto.

Chegando ao local, não fique tímido pelas câmeras que estarão te filmando. Há uma grande introdução ao exame, mas nada do que você já não saiba. Também será pedido qualquer aparelho eletrônico que você possua, como celulares e players. Você tem aproximadamente duas horas para completar o exame de 40 questões. Leia atentamente as questões. Observe que há uma Checkbox no campo “Mark for Review” no campo esquerdo superior, use-a para marcar as questões que tem dúvida e focar nelas após o exame.

Nunca deixe de revisar as questões! É de extrema importância, ao revisar uma questão você estará mais apto a identificar os detalhes relevantes para resolução do problema.

Preste atenção nas questões deixadas para atrás. Há uma coisa muito chata (e que me tirou do sério) foi o fato de que clicar em alguns lugares fora das alternativas pode retirar a opção marcada. Certifique-se que todas as questões foram preenchidas. Antes finalizar o exame, o sistema mostra um grid com as questões deixadas em branco e as que foram marcadas para revisar. Há também uma calculadora caso você precise fazer algum cálculo.

O principal é manter a calma, ler a questão se necessário mais de uma vez. E gastar tempo pensando e observando os detalhes. Sobrou tempo? Gaste o tempo revisando! Afinal, você não ganhará nada terminando mais cedo que seus amigos, e isso pode te salvar teu pescoço.

Espero que este artigo tenha ajudado, qualquer dúvida fique a vontade para entrar em contato comigo. Um forte abraço a todos e boa sorte em seus exames!

Referências:
http://www.microsoft.com/learning/en/us/exams/70-536.aspx