Pesquisar

30 de dez de 2007

Covariância e Contravariância em C#, Parte Um

Vou escrever sobre uma série de artigos do Eric Lippert sobre Covariância e Contravariância. Pretendo dividir os artigos em partes como foi feito no original, pra deixar as coisas mais organizadas e fazer mudanças que forem necessárias pra um melhor entendimento.

Nesta primeira parte vamos entender alguns conceitos sobre tipos.

Primeiramente temos que entender que para dois tipos X e Y, pelo menos uma das seguintes afirmações é verdadeira: 
X é maior do que Y.
X é menor do que Y.
X é igual a Y. 
X não tem nenhuma relação com Y.

Considere uma hierarquia constituída de: Animal, Mamífero, Reptil, Girafa, Tigre, Cobra e Tartaruga, com seus relacionamentos (Mamífero é uma subclasse de Animal, etc). Mamífero é maior do que Girafa, menor que Animal, e, evidentemente, é igual à Mamífero. Mas Mamífero não é nem maior, nem menor, nem igual a Reptil, é apenas diferente.

Imagine que você tenha uma variável, toda variável tem um tipo que lhe é associado. Em runtime você pode armazenar um objeto que é uma instância de um tipo igual ou menor, ou seja, uma variável do tipo Mamífero pode ter uma instância de Girafa armazenados nela, mas não uma Tartaruga.

Esta idéia de armazenamento de um objeto em um local tipado é um exemplo específico de um princípio mais geral chamado de "princípio da substituição". Isto é, em muitos contextos, podemos substituir uma instância de um tipo "menor" por um "maior".

Agora podemos falar de variância. Considere uma "operação", que manipula tipos. Se o resultado da operação aplicada a qualquer X e Y e sempre resulta em dois tipos X' e Y' com o mesmo relacionamento X e Y a operação é considerada covariante. Se a operação inverte a "grandeza" e a "pequeneza" sobre os seus resultados, mas mantém a igualdade e independência, a operação é considerada "contravariante".

Isso é totalmente imaginário e provavelmente não muito claro. Na próxima parte vamos analisar como o C# implementa variância.

Continua na parte dois: Covariância e Contravariância em C#, Parte Dois: Covariância de Array

26 de dez de 2007

MSDN Magazine - Janeiro 2008

Está disponível a edição de Janeiro da MSDN Magazine. Assuntos de capa:

• IIS 7.0: Aprimore seu aplicativo com o pipeline integrado do ASP.NET
Mike Volodarsky

• World Ready: Uma volta ao mundo com aplicativos ASP.NET AJAX
Guy Smith-Ferrier

• WCF Syndication: Programação HTTP com WCF e o .NET Framework 3.5
Justin Smith

• SQL Server: Encontrar dados ocultos para otimizar o desempenho do aplicativo
Ian Stirk

• Look It Up: Gerenciando entidades de segurança de diretório no .NET Framework 3.5
Joe Kaplan e Ethan Wilansky

Download - Download dos Códigos

14 de dez de 2007

Novos recursos no C#3.0

Vou falar sobre alguns novos recursos que vieram na nova versão do C#.

Começando pelas Propriedades Automáticas.
Antigamente quando a gente criava as propriedades das nossas classes, faziamos um código como esse:

    7 public class Carro

    8 {

    9     private string _modelo;

   10     private string _marca;

   11     private int _ano;

   12     private string _cor;

   13 

   14     public string Modelo

   15     {

   16         get { return _modelo; }

   17         set { _modelo = value; }

   18     }

   19 

   20     public string Marca

   21     {

   22         get { return _marca; }

   23         set { _marca = value; }

   24     }

   25 

   26     public int Ano

   27     {

   28         get { return _ano; }

   29         set { _ano = value; }

   30     }

   31 

   32     public string Cor

   33     {

   34         get { return _cor; }

   35         set { _cor = value; }

   36     }

   37 }

Como você pode notar, as propriedades não tem nenhum tratamento lógico, servindo como se fosse um acesso direto aos campos. Então porque não expor os campos diretamente? Basicamente porque no futuro você pode querer implementar algum tratamento, assim se você tiver usado propriedades, as classes que usam suas propriedades não precisarão ser recompiladas.

Sendo muito comum o uso de propriedades como as que vimos acima, no C#3.0 foi implementado as Propriedades Automáticas, que substituem esse código "padrão". O código anterior ficaria assim:

    7 public class Carro

    8 {

    9     public string Modelo { get; set; }

   10     public string Marca { get; set; }

   11     public int Ano { get; set; }

   12     public string Cor { get; set; }

   13 }

Quando o compilador encontrar um get/set vazio como estes, ele automáticamente criará os campos privados para a classe e implementará as propriedades públicas get/set.

Diferentemente de criar campos públicos, poderemos no futuro criar as implementações lógicas, sem ter que mudar nenhum componente externo que referencia nossa classe.

Inicializadores de Objetos

Usamos muitas propriedades quando estamos programando e é muito comum códigos como esse:


   13 Carro car = new Carro();

   14 car.Modelo = "Punto";

   15 car.Marca = "Fiat";

   16 car.Ano = 2007;

   17 car.Cor = "Azul";

Agora podemos escrever isso de outra forma, mais simples e concisa, usando os "object Initializers". Seu código pode ser escrito assim:


 Carro car = new Carro { Modelo = "Punto", Marca = "Fiat", Ano = 2007, Cor = "Azul" };


E o compilador irá se encarregar de instanciar a classe e setar as propriedades.

É interessante que podemos inicializar objetos aninhados, como mostrado:


Carro car = new Carro { Modelo = "Punto", Marca = "Fiat", Ano = 2007, Cor = "Azul", Fabric = new Fabricante { Nome = "Industria Metal", CNPJ = "12312" } };

Inicializadores de Coleção

Os inicializadores de objeto também facilitam a maneira como adicionamos itens a uma coleção. Se quisermos adicionar objetos Carro a uma List devemos escrever o seguinte código:



   14 List<Carro> Carros = new List<Carro>();

   15 

   16 Carros.Add(new Carro { Modelo = "Punto", Marca = "Fiat", Ano = 2007, Cor = "Azul" });

   17 Carros.Add(new Carro { Modelo = "Punto", Marca = "Fiat", Ano = 2007, Cor = "Vermelho" });

   18 Carros.Add(new Carro { Modelo = "Punto", Marca = "Fiat", Ano = 2007, Cor = "Preto" });


Economizando muitas linhas de código. E podemos diminuir ainda mais, usando Inicializadores de coleção, não precisamos escrever vários métodos Add:


   14 List<Carro> Carros = new List<Carro>{           

   15     new Carro { Modelo = "Punto", Marca = "Fiat", Ano = 2007, Cor = "Azul" },

   16     new Carro { Modelo = "Punto", Marca = "Fiat", Ano = 2007, Cor = "Vermelho" },

   17     new Carro { Modelo = "Punto", Marca = "Fiat", Ano = 2007, Cor = "Preto" }

   18 };

12 de dez de 2007

LINQ to Object

Agora com o Visual Studio 2008 estou fazendo alguns testes com os novos recursos do Framework 3.0 e 3.5.

Vou colocar aqui um exemplo de página que mostra os números pares, usando o LINQ e como fonte de dados um array.

Crie um novo WebSite, sem esquecer de usar o Framework 3.5:

Adicione um Button e um Label:

De dois cliques no Button para gerar o método do evento Click. Dentro do método insira o seguinte código(usei comentários para explicar o código): 

   21 //Nossa fonte de dados

   22 int[] numeros = { 1, 2, 3, 4, 5, 6 };

   23 

   24 //Query do Linq, depois da keyword in, especificamos a fonte de dados

   25 //Usamos where para filtrar os resultados

   26 //retornando só os que tiverem resto da divisão por 2 igual à 0

   27 //o select serve para o Linq saber o que deve retornar

   28 //daqueles que passarem pelo filtro

   29 //no caso o proprio numero, mas poderiamos

   30 //por exemplo retornar num.ToString()

   31 var query = from num in numeros

   32             where num % 2 == 0

   33             select num;

   34 

   35 //Passa cada numero retornado pro Label

   36 //Perceba que a variavel query é definida como IEnumerable<int>

   37 //var é um novo recurso do Framework 3.5

   38 //O tipo da variável é definido na compilação

   39 //A variavel continua sendo tipada

   40 foreach (var numero in query)

   41 {

   42     lblResultado.Text += numero.ToString() + "<br>";

   43 }

Agora tecle F5 para abrir o website e clique no Button, vai aparecer os números 2, 4 e 6:

10 de dez de 2007

Passei no Exame!!!!!!!

Depois de meses estudando, consegui passar! Aproveitei que tinha 30% de desconto e direito a segunda chance, mas passei de primeira, apesar de nem eu acreditar que conseguiria.

Agora começa a maratona de estudos pro 70-526 que é uma especialização para windows. 

Caso alguém queira saber o que usei como estudo foi só o livro Self-Paced Training Kit pro exame 70-536, que infelizmente é em inglês, mas  é bem fácil de entender,  exige apenas inglês técnico. Antes também li o C# How to Program, mas ele não foca em certificação, serve mais como base.

9 de dez de 2007

Usando CopySourceAsHtml no Visual Studio 2008

Esta ferramente é muito interessante pra quem costuma inserir trechos de códigos no blog ou site.

Infelizmente o instalador dele só está preparado para o VS2005, mas você pode usá-lo no VS2008.

Para isso faça o download desse arquivo zip.

Extraia os 3 arquivos na pasta C:\Documents and Settings\<USUARIO>\Meus documentos\Visual Studio 2008\Addins
Talvez a pasta Addins não exista, então você deve cria-la.

Depois de extraidos ele já está pronto pra usar. Só para confirmar, clique em Tools -> Add-in Manager e verifique se o CopySourceAsHtml está marcado.

Agora é só selecionar o trecho desejado e clicar em Copy As Html...

E o resultado é muito bom:


   19 NumberFormatInfo NumberInfo = new NumberFormatInfo();


   20 NumberInfo.CurrencySymbol = "@";


   21 NumberInfo.CurrencyDecimalDigits = 4;


   22 DemoBuilder.NumberFormat = NumberInfo;



Aqui no blog não vai sair muito bem por causa do pequeno espaço horizontal, mas o html gerado fica com o visual perfeitamente igual Visual Studio.

8 de dez de 2007

Segunda-feira, o dia do exame

Consegui marcar um exame 70-536 pra MCTS na segunda-feita, dia 10, depois de muitos problemas em achar um cartão internacional....que era a única forma de fazer o exame em Santos.

Fiz vários simulados do Training Kit e acerto sempre mais de 70%, mas é pouco =/ vou estudar esse fim de semana pra quem sabe passar de primeira, preciso de 80%.

Ainda bem que peguei a promoção segunda chance, assim posso ver como me saio no primeiro exame e saber onde estudar mais.

Alem  da segunda chance também ganhei 30% de desconto =). Foram 56 dólares pelo exame com segunda chance! A Microsoft ta facilitando bastante no quesito financeiro.

Se você também ta querendo fazer o exame, pode entrar no site da promoção: http://www.microsoft.com/brasil/certifique/certiseguro/ e pegar um voucher, é simples, só clicar no link correspondente ao mês que quer fazer a prova, Dezembro da direito à 30% e Janeiro à 20%.

Pra mim uma certificação MCTS vale mais que a própria faculdade, que não significa nada, pois pra ter um diploma, basta pagar a mensalidade e empurrar com a barriga, a escolha é sua se está lá pra aprender, ou pra agradar seu pai....ou quem sabe ter direito a uma cela especial heheh.

Depois posto o resultado, estou confiante, mas não tenho certeza se passo de primeira. Boa sorte pra mim.

4 de dez de 2007

Criando um assembly em tempo de execução

Vou explicar os passos básicos de como criar um pequeno assembly em tempo de execução, usando Reflection. Usando esses recursos seria possível criar um compilador para IL.

Os assemblies são feitos de: Assembly Metadata, Type Metadata, Code (IL) e Resources

  • O Assembly Metadata define propriedades como Nome e Versão do assembly
  • Type Metadata define todas as descrições de um tipo, como métodos, propriedades, nome de classe, etc
  • Code(IL) é o próprio código
  • Resources são imagens, strings, arquivos, etc

Cada assembly deve conter pelo menos um Modulo. Os módulos são uma espécie de caixa que guarda as informações sobre os Tipos.

Então vamos seguir a seguinte ordem, criamos um assembly, um modulo e um tipo, e já teremos o básico.

//namespaces necessarios
    6 using System.Reflection;
    7 using System.Reflection.Emit;


   15 //Criamos um AssemblyName

   16 AssemblyName AsyNome = new AssemblyName("MeuAssembly");

   17 //Então definimos  um novo assembly no atual AppDomain, não é possível criar um assembly a partir do próprio construtor

   18 AssemblyBuilder AsyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(AsyNome, AssemblyBuilderAccess.RunAndSave);

   19 //AssemblyBuilderAccess.RunAndSave quer dizer que podemos tanto executar esse assembly, quanto salva-lo

   20 

   21 //Criamos o modulo a partir do assembly

   22 ModuleBuilder ModBuilder = AsyBuilder.DefineDynamicModule("MeuModulo", "modulo.dll");

   23 //E um tipo a partir do modulo. Este tipo é publico e serializável, você pode atribuir várias propriedades com o operador |

   24 TypeBuilder TipoBuilder = ModBuilder.DefineType("Meutipo", TypeAttributes.Public | TypeAttributes.Serializable);

   25 

   26 

   27 //Agora podemos definir os membros do tipo, como construtores, métodos, propriedades, etc

   28 //Vamos criar um campo

   29 FieldBuilder CampoBuilder = TipoBuilder.DefineField("Campo", typeof(int), FieldAttributes.Public);

   30 

   31 //Podemos tambem salvar o assembly para uso posterior

   32 AsyBuilder.Save("modulo.dll");


Neste exemplo foi usado somente o FieldBuilder, mas  você pode criar qualquer outro membro usando os: ConstructorBuilder para construtor, EnumBuilder para enum, EventBuilder para eventos, etc

Você pode usar esse recurso para criar um software que aceite plug-ins por exemplo.