23547287 Livro de NET Israel Aece

Captulo 1 Tipos de dados e InterfacesCapitulo 1 Tipos de dados e Interfaces Introduo

1

O .NET Framework 2.0 fornece uma poro de tipos predefinidos que so necessrios para a criao dos mais diversos tipos de aplicaes que o mesmo fornece para ns desenvolvedores. Esses tipos so utilizados constantemente nas aplicaes, para armazenar valores, bem como uma estrutura extensvel para que voc crie seus prprios tipos. Neste captulo voc entender como funciona a arquitetura de tipos do .NET Framework 2.0, ver tambm sobre os tipos intrnsicos disponveis. Alm disso, vamos abordar um assunto fortemente ligado aos tipos: tipos-valor e tipos-referncia e, para complementar, analisaremos o boxing e unboxing, que um grande vilo em termos de performance das aplicaes .NET-based. Para finalizar a parte sobre tipos, temos ainda alguns tipos especiais que precisam ser examinados: Generics, Nullable Types, Exceptions e Attributes. Na segunda parte do captulo, vamos analisar as Interfaces que so disponveis dentro do .NET Framework 2.0 e tambm veremos como criar suas prprias Interfaces para utilizar no seu cdigo ou, se desejar, expor esta para que consumidores de seu componente consigam implement-la, criando uma espcie de contrato que teus componentes exigem para poderem trabalhar. Examinando a arquitetura e os tipos CTS Common Type System Como todos sabem, os tipos so pea fundamental em qualquer tipo de linguagem de programao, seja para a criao de componentes ou para tipos de aplicaes que interajam com o usurio (Windows ou Web). Como a idia da Microsoft tornar tudo o mais integrado possvel, ela criou uma especificao de tipos chamada Common Type System (CTS), que descreve como os tipos so definidos e como se comportam. Esses tipos so compartilhados entre todas as linguagens .NET. Sendo assim, voc pode criar um componente em Visual C# e consumir este mesmo componente em uma aplicao cliente escrita em Visual Basic .NET sem nenhum problema, j que o tipo esperado ou o tipo a ser devolvido so de conhecimento de ambas. Voc tambm ouvir o termo cross-language integration para essa mesma explicao. Alm disso, um outro ponto importante do CTS que tambm especfica as regras de visibilidade de tipos para acesso aos membros do mesmo. Atualmente temos os seguintes modificadores de acesso disponveis: 1

Israel Aece | http://www.projetando.net

Captulo 1 Tipos de dados e InterfacesModificador VB.NET Modificador C# Private private Protected Friend Friend Protected Public protected internal internal protected public

2

Descrio Pode ser acessado por outros mtodos somente dentro do mesmo tipo (classe). Pode ser acessado por outros mtodos dentro do mesmo tipo e tambm por tipos derivados. Pode ser chamado de qualquer local desde que seja dentro do mesmo Assembly. Pode ser acessado por outros mtodos dentro do mesmo tipo e tambm por tipos derivados dentro do mesmo Assembly. Pode ser chamado de qualquer local.

Para finalizar essa introduo sobre o CTS, h ainda uma das principais e mais importantes regras definidas por ele: todos os tipos devem herdar direta ou indiretamente de um tipo predefinido: System.Object. Este a raiz de todos os tipos dentro do .NET Framework e, conseqentemente, ser tambm a raiz para os tipos customizados por voc dentro da sua aplicao e, sendo assim, ele fornece um conjunto mnimo de comportamentos: Representao em uma string do estado do objeto Consultar o tipo verdadeiro da instncia Extrair o cdigo hash para a instncia Comparar duas instncias quanto igualdade Realizar uma cpia da instncia

CLS Common Language Specification Graas um ambiente de execuo comum e informaes em metadados, a CLR (Common Language Runtime) integra as linguagem e permitem que estas compartilhem os tipos criados em uma linguagem sejam tratado de forma igual na outra. Essa integrao fantstica, mas muitas linguagens so bem diferentes entre si, ou seja, algumas fazem distino entre maisculas e minsculas, outras no oferecem sobrecargas de operadores, etc.. Se algum desejar criar um determinado tipo que seja compatvel com qualquer outra linguagem .NET, voc ter que utilizar somente os recursos que obrigatoriamente estejam tambm nas outras linguagens. Para isso, a Microsoft criou o Common Language Specification (CLS), que especifica o conjunto mnimo de recursos que devem ser suportados se desejam gerar cdigo para o CLR. Geralmente empresas que esto criando seus compiladores para .NET, devem seguir rigorosamente estas especificaes. Para assegurar que o componente que est desenvolvendo seja compatvel com qualquer linguagem .NET, voc pode incluir um atributo chmado CLSCompliant no arquivo AssemblyInfo que instrui o compilador a se certificar que um tipo pblico que est sendo Israel Aece | http://www.projetando.net

2

Captulo 1 Tipos de dados e Interfaces

3

disponibilizado no contenha nenhuma construo que evite de ser acessado a partir de outra linguagem. O cdigo abaixo exemplifica o uso deste atributo:VB.NET C# [Assembly:CLSCompliant(true)]

Abaixo, a imagem ilustra o conjunto de tudo que vimos at o momento:

Imagem 1.1 Uma exibio em forma de conjunto para entermos a relao entre elas. Tipos fornecidos pelo .NET Framework Dentro do .NET Framework 2.0, vrias funcionalidades so encapsuladas dentro de objetos e estes, por sua vez, so instncias de tipos fornecidos pelo sistema. O .NET Framework j traz internamente vrios tipos predefinidos, quais so conhecidos como tipos bsicos, ou base system types. Um exemplo tpico disso um controle Button. Internamente ele possui uma poro de membros que expem ou recebem tipos de dados como strings, inteiros, decimais ou at mesmo outros tipos/objetos. H alguns tipos de dados que so muito comuns em vrias linguagens de programao. Podemos citar vrios deles: inteiros, strings, doubles, etc.. So to comuns que grande parte dos compiladores permitem utilizarmos um cdigo que manipule esses tipos de Israel Aece | http://www.projetando.net

3


4

forma simples, um atalho. Se esse atalho no existisse, teramos que fazer algo mais ou menos como:VB.NET Dim codigo As New System.Int32() C# System.Int32 codigo = new System.Int32();

Apesar de funcionar sem nenhum problema, isso no nada cmodo, justamente pela freqencia com qual utilizamos esses tipos. Felizmente tanto o Visual Basic .NET quanto o Visual C# fornecem vrias keywords que o compilador faz o trabalho de mapear diretamente para o tipo correspondente dentro do .NET Framework Class Library (FCL). Esses tipos de dados que o compilador suporta diretamente so chamados de tipos primitivos. Com isso, o cdigo acima ficaria muito mais produtivo se utilizssemos uma sintaxe semelhante a mostrada logo abaixo:VB.NET Dim codigo As Integer C# int codigo = 0;

Tipos valor e tipos referncia O Common Language Runtime (CLR) suporta duas espcies de tipos: tipos-valor (value types) e tipos-referncia (reference types). Os tipos-valor so variveis que diretamente contm seu prprio valor, sendo assim, cada varivel mantm a cpia de seus dados e, conseqentemente, operaes que utilizam essa varivel no afetar o seu valor. Tipos-valor so dividos em dois tipos: built-in e user-defined types. O primeiro trata-se de valores que so fornecidos com o prprio .NET Framework, como o caso de inteiros, floats, etc.. J o segundo, so tipos que definimos dentro de nossos componentes ou aplicaes. Geralmente esses tipos so estruturas de dados ou enumeradores. As estruturas de dados so bem semelhantes a uma classe e podem conter membros para armazenar os dados e tambm funes para desempenhar algum trabalho. J os enumeradores so constantes que fixam a escolha de algums dos valores fornecidos por ele, o que impossibilita o consumidor de passar algo diferente do que espera, ou melhor, de passar algum valor que seu mtodo/classe no saiba trabalhar.

4



5

J os tipos-referncia contm ao invs do valor, uma referncia para os dados e, sendo assim, possvel termos duas variveis apontando para o mesmo lugar na memria, ou melhor, para o mesmo objeto. Como os tipos-referncia apontam para o mesmo local, uma operao poder alterar o contedo desta varivel, j que o mesmo est compartilhado. Geralmente todos os objetos dentro do .NET, sejam eles intrnsicos ao Framework ou os objetos customizados, so tipos-referncia. Os tipos-referncia tambm so divididos em built-in e user-defined types assim como os tipos-valor. Para exemplificar, built-in type podemos a classe Form (Windows Forms) e a classe Page (Web Forms), entre muitos outros. Para built-in types temos os tipos/objetos que criamos para a aplicao/componente que estamos desenvolvendo. Apesar da imaginao ser o limite, temos alguns exemplos: Cliente, LeitorCNAB, etc.. A hierarquia dos tipos ilustrada atravs da imagem 1.2:

Imagem 1.2 Hierarquia dos tipos do .NET Framework. Alm desta grande diferena entre os dois tipos, ainda h uma separao quando falamos em nvel de memria. Cada um dos tipos so armazenados em regies completamente diferentes. Os tipo-valor so armazenados na Stack e os tipo-referncia na Heap. A memria Stack um bloco de memria alocado para cada programa em runtime. Durante a vida de execuo, quando uma funo invocada, todas as variveis que ela utiliza so colocadas na Stack. Assim que a funo retornada ou o escopo de um bloco finalizado, o mais breve possvel os valores ali colocados sero descartados, liberando assim, a memria que estava sendo ocupada. Como falamos anteriormente, quando uma varivel do tipo-valor passada de uma funo, uma cpia do valor passado e, se esta funo alterar este valor, no refletir no valor original. Como os tipos de dados dentro do .NET Framework so uma estrutura, eles so tambm armazenados na Stack. Israel Aece | http://www.projetando.net

5


6

No caso de tipos-referncia, os dados so armazenados na memria Heap, enquanto a referncia do mesmo colocado na mmoria Stack. Isso acontece quando utilizando o operador new (New em VB.NET) no cdigo, que retornar o endereo de memrio do objeto. Isso acontece quando precisamos criar efetivamente o objeto para utiliz-lo. Para entender melhor esse processo, vamos analisar o cdigo abaixo:VB.NET Dim cliente1 As Cliente() Dim cliente2 As Cliente = cliente1 C# Cliente cliente1 = new Cliente(); Cliente cliente2 = cliente1;

Quando atribumos o cliente1 ao cliente2 recm criado, voc est copiando a referncia ao objeto que, por sua vez, aponta para uma determinada seo na memria Heap. No cdigo acima, quando voc efetuar uma mudana, seja ela no objeto cliente1 ou cliente2, refletir no mesmo objeto da memria Heap. Atravs da imagem 1.2, podemos visualizar as memrias (Stack e Heap) em conjunto quando armazenam tipos-referncia:

Imagem 1.3 Memria Stack e Heap armazenando tipos-referncia. Como j falamos anteriormente, todas os objetos so tipos-referncia. Alm deles, ainda temos as Interfaces que tambm operam em modelo tipo-referncia. As Interfaces contm mtodos e propriedades em seu interior mas no possui nenhuma implementao concreta. Elas devem ser implementadas em classes para implementar a sua funcionalidade. As Interfaces sero discutidas mais detalhadamente ainda neste captulo. Nota Importante: Todos os tipos em .NET so, em ltima instncia, derivados de System.Object. Como dito anteriormente, todos os tipos do .NET sejam eles intrnsicos ao Framework ou sejam objetos customizados, so tipos-referncia. Mas e quanto aos tipos-valor? No vimos que inteiros, floats so tipo-valor? Sim, mas a questo que a Microsoft se preocupou com isso e criou uma possibilidade de diferenciar um de outro. Se analisar atentamente a documentao do .NET Framework, ver que a maioria dos tipos-valor, por exemplo integer, decimal, datetime so representados atravs de Israel Aece | http://www.projetando.net

6


7

estruturas de dados: System.Int32, System.Decimal e System.DateTime respectivamente. Toda e qualquer estrutura derivada de System.ValueType e esta, por sua vez, herda de System.Object. Alm da classe System.ValueType fornecer toda a estrutura bsica para todos os tipos-valor do .NET ela tambm tratada de forma diferente pelo runtime, j que seus tipos derivados devem ser colocados na memria Stack. Estrutura de dados e enumeradores herdam de System.ValueType. Essa distino entre tipos-valor e tipos-referncia deve existir, pois o desempenho de uma aplicao poderia seriamente ser comprometida, pois imagine se a utilizao de um simples inteiro, tivssemos que alocar memria para isso. Os tipos valores so considerados peso-leve e, como vimos acima, so alocados na Stack da Thread. As melhorias em termos de performance no param por a. Esses valores mais volteis no ficam sob inspeo do Garbage Collector e fora do Heap, o que reduz o nmero de passagens do coletor. Boxing e Unboxing Como vimos na seo anterior, os tipos-valor so muito mais leves que tipos-referncia porque no so alocados no Heap e, conseqentemente, no sofrem coleta de lixo atravs do Garbage Collector e no so referenciados por ponteiros. Mas imagine uma situao onde voc precisa obter uma referncia a uma instncia do tipo valor. Um caso tpico para exemplificar so o uso de colees. H dentro do .NET Framework um objeto chamado ArrayList (System.Collections) que, permite-nos criar uma coleo de qualquer tipo. Como ele pode armazenar qualquer tipo, ele aceita nos parmetros de seus mtodos um System.Object (tipos-referncia). Como tudo em .NET , direta ou indiretamente, um tipo de System.Object, posso adicionar nesta coleo qualquer tipo, mesmo sendo um tipo-valor. Mas e se quisermos adicionar um tipo-valor nesta coleo, como por exemplo, uma coleo de inteiros? Para isso, basta simplesmente fazermos:VB.NET Dim colecao As New ArrayList(); colecao.Add(1) colecao.Add(2) C# ArrayList colecao = new ArrayList(); colecao.Add(1); colecao.Add(2);

O mtodo Add recebe um tipo-referncia (System.Object). Isso quer dizer que o mtodo Add exige uma refncia (ponteiro) para um objeto no Heap. Mas no cdigo acima, Israel Aece | http://www.projetando.net

7


8

adicionanado um inteiro e tipo-valor no possui ponteiros para o Heap, j que so armazenados na Stack. Isso s possvel graas ao boxing. Boxing na maioria dos casos ocorre implicitamente. Abaixo o que acontece nos bastidores quando boxing ocorre: 1. A quantidade de memria alocada no Heap de acordo com o tamanho do tipovalor e qualquer overhead a mais, se for o caso. 2. Os campos do tipo-valor so copiados para a Heap que foi previamente alocada. 3. O endereo com a referncia retornado. Felizmente compiladores das linguagens como Visual Basic .NET e Visual C# produzem automaticamente o cdigo necessrio para realizar o boxing. Isso perfeitamente notvel no cdigo acima, pois no precisamos escrever nada mais do que precisaramos no caso de adicionarmos um tipo-referncia. O unboxing o contrrio do boxing, mas considere sendo uma operao mais fcil em relao ao boxing. Unboxing apenas obter o ponteiro para tipo-valor bruto contido dentro de um objeto e, neste caso, no necessrio copiar nenhum tipo de dado na memria. Obviamente que boxing e unboxing comprometem a performance da aplicao em termos de velocidade como de memria. Felizmente no .NET Framework 2.0, foi introduzido o conceito de Generics Collections que elimina completamente estes problemas. Veremos sobre Generics Collections no Captulo 2. Examinando tipos especiais Generics Generics um novo conceito introduzido na verso 2.0 do .NET Framework. Generics permitem termos classes, mtodos, propriedades, delegates e Interfaces que trabalhem com um tipo no especificado. Esse tipo no especificado quer dizer que estes membros trabalharo com os tipos que voc especificar em sua construo. O melhor entendimento deste conceito provavelmente ser quando estiver aprendendo sobre Generics Collections, que ser abordado no Captulo 2. Como vimos anteriormente, o ArrayList permite adicionarmos qualquer tipo dentro dele. Mas e se quisssemos apenas adicionar valores inteiros, ou somente strings? Isso no seria possvel pois o mtodo Add aceito um System.Object. Com Generics, possvel criar colees de um determinado tipo, o que permitir que o usurio (outro desenvolvedor) somente adicione variveis do mesmo tipo e, se por acaso ele quiser adicionar algo incompatvel, o erro j detectado em design-time. O .NET Framework 2.0 fornece uma poro de colees utilizando Generics que veremos mais detalhadamente no Captulo 2 deste curso. Classes genricas oferecem vrias vantagens, entre elas: Israel Aece | http://www.projetando.net

8


9

1. Reusabilidade: Um simples tipo genrico pode ser utilizado em diversos cenrios. Um exemplo uma classe que fornece um mtodo para somar dois nmeros. S que estes nmeros podem ser do tipo Integer, Double ou Decimal. Utilizando o conceito de Generics, no precisaramos de overloads do mtodo Somar(...). Bastaria criar um nico mtodo com parmetros genricos e a especificao do tipo a ser somado fica a cargo do consumidor. 2. Type-safety: Generics fornecem uma melhor segurana, mais especificamente em colees. Quando criamos uma coleo genrica e especificamos em seu tipo uma string, somente podemos adicionar strings, ao contrrio do ArrayList. 3. Performance: Fornecem uma melhor performance, j que no h mais o boxing e unboxing. Alm disso, o nmero de converses cai drasticamente, j que tudo passa a trabalhar com um tipo especificado, o que evita transformarmos em outro tipo para termos acesso a suas propriedades, mtodos e eventos. Classes genricas Uma classe que aceita um tipo em sua declarao pode trabalhar internamente com este tipo. Isso quer dizer que os mtodos podem aceitar em seus parmetros objetos do tipo especificado na criao da classe, retornar esses tipos em propriedades, etc.. Para exemplificarmos, vejamos uma classe que aceita um valor genrico, o que quer dizer, que ela pode trabalhar (fortemente tipada) com qualquer tipo. Atravs do exemplo abaixo T identifica o tipo genrico que, j pode ser acessado internamente pela classe.VB.NET Public Class ClasseGenerica(Of T) Private _valor As T Public Property Valor() As T Get Return Me._valor End Get Set(ByVal value As T) Me._valor = value End Set End Property End Class Utilizao: Dim classe1 As New ClasseGenerica(Of String) classe1.Valor = .NET

9


Captulo 1 Tipos de dados e InterfacesDim classe2 As New ClasseGenerica(Of Integer) classe2.Valor = 123 C# public class ClasseGenerica { private T _valor; public T Valor { get { return this._valor; } set { this._valor = value; } }

10

}

//Utilizao: ClasseGenerica classe1 = new ClasseGenerica(); classe1.Valor = .NET; ClasseGenerica classe2 = new ClasseGenerica(); classe2.Valor = 123;

O que diferencia uma classe normal de uma classe genrica o tipo que devemos especificamos durante a criao da mesma. O valor T pode ser substituido por qualquer palavra que voc achar mais conveniente para a situao e, quando quiser referenciar o tipo genrico em qualquer parte da classe, poder acess-lo como um tipo qualquer, como um Integer e felizmente, o Intellisense d suporte completo a Generics. Digamos que sua classe somente trabalhar com Streams, ento poderia definir T como TStream (se assim desejar):VB.NET Public Class ClasseGenerica(Of TStream) End Class C# public class ClasseGenerica

{ }

10

//



11

Como podemos notar no exemplo, a classe1 trabalha somente com valores do tipo string. J a classe2 somente trabalha com valores do tipo inteiro. Mesmo que quiser adicionar um tipo incompatvel, o erro j informado em design-time. Nota: O Visual C# disponibiliza uma keyword bastante til chamada default. Ela utilizada em classes genricas para inicializar um tipo qualquer, pois o Visual C# temos obrigatoriamente que definir um valor default para qualquer tipo, esta vem para suprir esta necessidade. Em casos de tipos-referncia, retornado um valor nulo. J em casos de valores numricos, 0 retornado. Quando o tipo uma estrutura, retornado para cada membro desta, 0 ou nulo, dependendo do tipo de cada um. O cdigo abaixo exemplifica o uso desta keyword:C# public class Lista where T : IComparable { public void Add(T item) { T temp = default(T); // .... } }

Tipos e Termos Para o entendimento completo de Generics necessrio conhecermos alguns termos que so utilizados durante o uso de Generics. Inicialmente temos dois termos a serem analisados: type parameters e type arguments. O primeiro deles refere-se ao parmetro que utilizado na criao do tipo genrico. J os type arguments referem-se aos tipos que substituem os type parameters. O cdigo abaixo exemplifica essa diferena:VB.NET Public Class ClasseGenerica(Of T) T = type parameter ... End Class Utilizao Dim c As New ClasseGenerica(Of String) String = type argument C# public class ClasseGenerica //T = type parameter { //... }

11


Captulo 1 Tipos de dados e Interfaces//Utilizao ClasseGenerica c = new ClasseGenerica(); //string = type argument

12

Classes genricas so tambm chamadas de open types. Levam essa definio porque permitem construirmos uma nica classe utilizando diversos tipos. Para ela ser encarada como um open type necessrio que a classe tenha, no mnimo, um tipo a ser especificado. Baseando-se no exemplo acima, a classe ClasseGenerica trata-se de uma open type porque permite, atravs do type parameter T, especificarmos um tipo que a classe ir manipular. As instncias de classes open types so consideradas constructed types. Alm disso, ainda temos mais duas formas de tipos genricos: open constructed type e close constructed type. A primeira forma, open constructed type, criado quando, no mnimo, um type argument no especificado, continuando aberto para uma definio futura. Para transformar essa explicao em cdigo, temos o seguinte exemplo:VB.NET Public Class ClasseGenerica(Of T) ... End Class Public Class Derivada(Of T) Inherits ClasseGenerica(Of T) End Class C# public class ClasseGenerica { //... } public class Derivada : ClasseGenerica { //... }

Como podemos notar, o tipo ainda continua aberto para que se possa fazer a definio efetiva do tipo mais tarde. Finalmente, temos o close constructed type, que criado especificando todos os type arguments, no permitindo deix-lo aberto para uma futura definio. O exemplo abaixo ilustra o close constructed type:VB.NET

12


Captulo 1 Tipos de dados e InterfacesPublic Class ClasseGenerica(Of K, T) ... End Class Public Class Derivada Inherits ClasseGenerica(Of String, Cliente) End Class C# public class ClasseGenerica { //... } public class Derivada : ClasseGenerica { //... }

13

Mas Generics no param por aqui. Existem muitas outras possibilidades para tornarmos os Generics ainda mais poderosos, como por exemplo critrios (constraints), criao de mtodos genricos, delegates, Interfaces, entre outros, quais veremos a seguir. Mtodos genricos Quando criamos uma classe genrica, informamos o seu tipo logo na construo da mesma. Isso nos habilita a possibilidade de utilizar esse tipo genrico no inteiror da classe em qualquer outro membro. O exemplo abaixo exibe como construir esse metdo:VB.NET Public Class ClasseGenerica(Of T) Public Function RetornaValor(value As T) As T Return value End Function End Class C# public class ClasseGenerica

{

}

public T RetornaValor(T value) { return value; }

13



14

Como pode notar, quando informamos na construo da classe que ela uma classe genrica, podemos utilizar o tipo T em toda a classe. O mtodo RetornaValor recebe esse tipo e o retorna. Quando instanciamos a classe e especificamos o tipo, como por exemplo uma String, todos os membros que utilizam T passaro a utilizar String. Felizmente a verificao de tipos feito em design-time, o que significa que se tentar passar um nmero inteiro, ele j acusar o erro, sem a necessidade de executar o cdigo para descobrir a possvel falha. Atravs da imagem 1.4 podemos certificar que ao definir o tipo, a classe e o mtodo somente permitir trabalhar com ele (onde for definido):

Imagem 1.4 Intellisense dando suporte total a Generics. Se definirmos o tipo da classe como qualquer outro tipo durante a criao do objeto, onde o T estiver especificado ser substituido por ele. S que existem situaes onde a classe no genrica, mas sim somente um mtodo de uma classe qualquer deve suportar parmetros genricos. Para isso, h a possibilidade de criarmos mtodos genricos. So basicamente como as classes: definimos o tipo em sua construo e pode-se utilizar tal tipo no interior do respectivo mtodo, seja nos parmetros ou no retorno do mesmo. Um exemplo da construo de mtodos genricos exibido abaixo:VB.NET Public Class Classe Public Function RetornaValor(Of T)(ByVal value As T) As T Return value End Function End Class C# public class Classe { public T RetornaValor(T value) { return value; }

14


Captulo 1 Tipos de dados e Interfaces}

15

Para criarmos um mtodo genrico que independe de um tipo especificado na criao da classe, devemos colocar logo aps o nome do mesmo o tipo genrico que dever ser especificado pelo desenvolvedor que o est consumindo. Neste caso, o escopo de utilizao de T (tipo genrico) passa a ser somente o mtodo. Abaixo mostrado como utiliz-lo:VB.NET Dim generic As New Classe() Dim id As Integer = generic.RetornaValor(Of Integer)(12) Dim nome As String = generic.RetornaValor(Of String)("Jos") C# Classe generic = new Classe(); int id = generic.RetornaValor(12); string nome = generic.RetornaValor("Jos");

Propriedades genricas As propriedades no tem nada de especial. Elas apenas podem retornar um tipo genrico especificado na criao da classe ou Interface. Um exemplo de sua utilizao est no primeiro trecho de cdigo desta seo, que a propriedade Valor da classe ClasseGenerica. Ela devolve um tipo T que especificado na criao da classe. Interfaces genricas Assim como as classes, as Interfaces tambm suportam tipos genricos. A forma de criao tambm idntica a especificao de tipo genrico da classe e, podemos em seu inteiror, utilizar este tipo. Dentro do .NET Framework 2.0 existem vrias Interfaces genricas e estudaremos algumas delas quando estivermos falando sobre colees genricas, no Captulo 2. J o exemplo de sua criao e implementao mostrada atravs do cdigo abaixo:VB.NET Public Interface ITest(Of T) Property Valor() As T Sub Adicionar(ByVal value As T)

15


Captulo 1 Tipos de dados e InterfacesEnd Interface Public Class ClasseConcreta Implements ITest(Of String) Public Sub Adicionar(ByVal value As String) _ Implements ITest(Of String).Adicionar End Sub Public Property Valor() As String _ Implements ITest(Of String).Valor Get End Get Set(ByVal value As String) End Set End Property End Class C# public interface ITest { T Valor { get;set; } void Adicionar(T value); } public class ClasseConcreta : ITest { public string Valor { get { } set { } } public void Adicionar(string value) { }

16

}

Obviamente que quando implementamos a Interface ITest em uma classe qualquer, obrigatoriamente devemos definir o tipo que a Interface ir trabalhar e, neste caso, o tipo String. Com isso, todos os tipos genricos especificados na Interface sero implementados utilizando o tipo String para esta classe. Israel Aece | http://www.projetando.net

16


17

Nada impede voc de implementar esta mesma Interface em uma outra classe com um tipo diferente, ou ainda, implementar a mesma Interface com tipos diferentes. A nica considerao a fazer quando implementamos a mesma Interface em uma classe, pois neste caso, as Intefaces so implementadas explicitamente. Veremos a implementao explcitas de Interfaces ainda neste captulo. Delegates genricos Assim como os membros que vimos at o momento, os delegates tambm permitem serem criados de forma genrica. Basicamente levam tambm o tipo a ser especificado, o que conseqentemente, somente permitir apontar para um membro que obrigatoriamente atende aquele tipo. O exemplo abaixo cria um delegate genrico que aceita um tipo a ser especificado durante a sua criao. Esse delegate poder ser utilizado para qualquer funo que contenha o mesmo nmero de parmetros, independentemente do tipo:VB.NET Public Delegate Sub Del(Of T)(ByVal item As T) Sub Main() Dim delInteger As New Del(Of Integer)(AddressOf WriteInteger) Dim delString As New Del(Of String)(AddressOf WriteString) delInteger(123) delString("Jos") End Sub Public Sub WriteInteger(ByVal i As Integer) Console.WriteLine(i) End Sub Public Sub WriteString(ByVal str As String) Console.WriteLine(str) End Sub C# public delegate void Del(T item); static void Main(string[] args) { Del delInteger = new Del(WriteInteger); Del delString = new Del(WriteString); delInteger(123); delString("Jos");

17


Captulo 1 Tipos de dados e Interfaces} public static void WriteInteger(int i) { Console.WriteLine(i); } public static void WriteString(string str) { Console.WriteLine(str); }

18

O Visual C# ainda tem alguns atalhos para o cdigo acima. O primeiro deles o chamado de method group conversion que permite definir o delegate genrico sem a necessidade de instanci-lo. Sendo assim, o cdigo em C# que faz a definio do mtodo a ser executado quando o delegate for disparado, poderia ser alterado para:C# public delegate void Del(T item); static void Main(string[] args) { Del delInteger = WriteInteger; Del delString = WriteString; delInteger(123); delString("Jos");

}

//Mtodos ocultados

Para finalizar, o Visual C# ainda tem um forma de tornar mais simples ainda o processo que so os metdos annimos. Os mtodos annimos so uma novidade do Visual C# 2.0 e permitem que o desenvolvedor defina o cdigo a ser executado pelo delegate diretamente, sem a necessidade de criar um procedimento para isso. Abaixo temos o cdigo em Visual C# modificado que faz o mesmo que vimos anteriormente, mas agora com o uso dos mtodos annimos:C# public delegate void Del(T item); static void Main(string[] args) {

18



19

Del delString = new Del(delegate(string str) { Console.WriteLine(str); }); Del delInteger = new Del(delegate(int i) { Console.WriteLine(i); }); delInteger(123); delString("Jos");

}

Estruturas genricas Assim como as classes e Interfaces, as estruturas tambm podem ser genricas e seguem exatamente as mesmas regras para Generics. Um exemplo tpico de estrutura genrica a Nullable, discutida na prxima seo, ainda neste captulo. Constraints Vimos at o momento como criar classes, mtodos, Interfaces e delegates genricos. Eles permitem que o consumidor possa definir qualquer tipo. Mas e se quisermos restringir quais tipos podem ser especificados na criao dos Generics? neste momento que entra em ao as constraints. As constraints so regras que aplicamos aos tipos genricos para espeficarmos o que o consumidor pode ou no definir como tipo. Atualmente existem seis tipos de constraints: Constraint where T : struct where T : class where T : new() where T : Base Class where T : interface where T : U Descrio O tipo especificado dever ser um value-type, mas precisamente uma estrutura. Mais uma vez, a estrutura Nullable um exemplo. O tipo especificado dever ser uma reference-type, como classe, Interface, delegate ou Array. O tipo especificado dever ter um construtor pblico sem nenhum parmetro. Se for utilizado com outras constraints, ento esta dever ser a ltima. O tipo especificado dever derivar da classe informada. O tipo especificado dever implementar a Interface informada, podendo inclusive, definir vrias constraints desse tipo, o que indica que o tipo dever obrigatoriamente implementar todas elas. Quando h mais de um tipo especificado, podemos definir a constraint onde onde obrigatoriamente dever herdar do outro.

19



20

As constraints so bastante teis, pois apesar de garantir a integridade do seu tipo, ou seja, o consumidor no poder passar um tipo que possa violar a constraint. Alm disso, voc j notificado pelo compilador se isso acontecer, que no permite compilar a aplicao com a falha. Para criar as constraints, voc utiliza a keyword where (no caso do Visual C#). No Visual Basic .NET, a keyword As, listando constraint ao lado de constraint para a definio do tipo genrico. Abaixo vamos exemplificar como definir cada uma das constraints disponveis: where T : structVB.NET Public Structure Nullable(Of T As Structure) C# public struct Nullable where T : struct

where T : classVB.NET Public Class Util(Of T As Class) C# public class Util where T : class

where T : new()VB.NET Public Class Util(Of T As New()) C# public class Util where T : new()

where T : Base ClassVB.NET Public Class Util(Of T As BaseReader) C#

20


Captulo 1 Tipos de dados e Interfacespublic class Util where T : BaseReader

21

where T : InterfaceVB.NET Public Class Util(Of T As IReader) C# public class Util where T : IReader

where T : UVB.NET Public Class Util(Of T, U As T) C# public class Util where T : U

Finalmente, se desejar definir vrias constraints em um determinado tipo, basta ir enfileirando uma ao lado da outra, como mostrado logo abaixo. Somente atente-se para o Visual Basic .NET que, neste caso, exige que voc envolva as constraints entre chaves {}:VB.NET Public Class Util(Of T As {IComparable, IReader, New}) C# public class Util where T : IComparable, IReader, new()

NullableTypes Qualquer tipo-valor em .NET possui sempre um valor padro. Isso quer dizer que ele nunca poder ter um valor nulo e mesmo que tentar, definindo nulo (Nothing em VB.NET e null em C#) para o tipo-valor, o compilador atirar uma exceo. Um exemplo o DateTime. Ele tem um valor padro que 01/01/0001 00:00:00. Apesar de estranha, uma data vlida. Muitas vezes um tipo pode ter uma data no informada, como por exemplo, imagine um objeto Funcionario que tem uma propriedade chamada DataDemissao. S que este Israel Aece | http://www.projetando.net

21


22

funcionario no foi demitido. Ento como conseguimos distingir se essa data vlida ou no? Pois bem, o .NET Framework 2.0 fornece o que chamamos de Nullable Types. System.Nullable uma estrutura de dados genrica que aceita como tipo qualquer outro tipo, desde que esse tipo seja uma outra estrutura, como por exemplo: Int32, Double, DateTime, etc.. Atravs deste tipo especial podemos definir valores nulos para ele, como por exemplo:VB.NET Dim dataDemissao As Nullable(Of DateTime) dataDemissao = Nothing C# Nullable dataDemissao = null;

A estrutura genrica Nullable fornece tambm uma propriedade chamada HasValue do tipo booleana que retorna um valor indicando se existe ou no um valor definido. E note que a estrutura Nullable trata-se de uma estrutura genrica, onde o tipo a ser definido obrigatoriamente deve tambm ser uma estrutura, devido a constraint que obriga isso. Isso pode ser facilmente notado na documentao:VB.NET Public Structure Nullable(Of T As Structure) C# public struct Nullable where T : struct

Esses tipos so ideais para utiliz-los junto com registros retornados de uma base de dados qualquer. Apesar de no ter uma grande integrao, ajuda imensamente, para conseguirmos mapear as colunas do result-set para as propriedades dos objetos da aplicao que permitem valores nulos. Exceptions Essa uma das partes mais elegantes do .NET Framework: Excees e o tratamento delas. Mas afinal, o que uma exceo: Exceo uma violao de alguma suposio da interface do seu tipo. Por exemplo, ao projetar um determinado tipo, voc imagina as mais diversas situaes em que seu tipo ser utilizado, difinindo tambm seus campos, propriedades, mtodos e eventos. Como j sabemos, a maneira como voc define esses membros, torna-se a interface do seu tipo.

22



23

Assim sendo, dado um mtodo chamado TransferenciaValores, que recebe como parmetro dois objetos do tipo Conta e um determinado valor (do tipo Double) que deve ser transferido entre elas, precisamos valid-los para que a transferncia possa ser efetuada com xito. O desenvolvedor da classe precisar ter conhecimento suficiente para implementar essa tal validao e, no esquecer do mais importante: documentar claramente para que os utilizadores deste componente possam implementar o cdigo que far a chamada ao mtodo da maneira mais eficiente possvel, poupando ao mximo que surpresas ocorram em tempo de execuo.VB.NET Public Shared Sub TransferenciaValores(de Conta, valor As Double) ... End Sub C# public static void double valor){ //... }

As

Conta,

para

As

TransferenciaValores(Conta

de,

Conta

para,

Dentro deste nosso cenrio, vamos analisar algumas suposies (validaes) que devemos fazer para que o mtodo acima possa ser executado da forma esperada: Certificar que de e para no so nulos Certificar que de e para no referenciam a mesma conta Se o valor for maior que zero Se o valor maior que o saldo disponvel

Necessitamos agora informar ao chamador que alguma dessas regras foi violada e, como fazemos isso? Atirando uma exceo. Como dissemos logo no comeo desta seo, ter uma exceo nem sempre algo negativo na aplicao, pois o tratamento de excees permite capturar a exceo, trat-la e a aplicao continuar correndo normalmente. O tratamento delas d se de forma estrutura, utilizando o Try/Catch/Finally. Mas nem sempre necessrio ter o overhead desta estrutura, pois h algumas formas de assegurar que o cdigo no dar erros com outros mtodos, tambm fornecidos pelo .NET Framework. Para exemplificar, vamos comparar dois cdigos: o primeiro, apesar de resolver o problema, no a melhor forma; j o segundo pode ser a melhor alternativa para a resoluo, ou melhor, para evitar um possvel problema:C#

23


Captulo 1 Tipos de dados e Interfaces//Cdigo ruim try {

24

} catch { Console.WriteLine(Tipo incompatvel.); } try {

IReader reader = (IReader)e.Data; reader.ExecuteOperation();

} catch { Console.WriteLine(Id invlido.); } //Cdigo reformulado IReader reader = (IReader)e.Data as IReader; if(reader != null) { reader.ExecuteOperation(); } else { Console.WriteLine(Tipo incompatvel.); } string tempId = 12; int id = 0; if(int.TryParse(tempId, out id)) { this.BindForm(id); } else { Console.WriteLine(Id invlido.); }

string tempId = 12; int id = Convert.ToInt32(tempId); this.BindForm(id);

24VB.NET


Captulo 1 Tipos de dados e InterfacesCdigo ruim Try Dim reader As IReader = CType(e.Data, IReader) reader.ExecuteOperation() Catch Console.WriteLine(Tipo incompatvel.) End Try Try Dim tempId As String = 12 Dim id As Integer = Convert.ToInt32(tempId) Me.BindForm(id) Catch Console.WriteLine(Id invlido.) End Try Cdigo reformulado Dim reader As IReader = TryCast(e.Data, IReader) If Not IsNothing(reader) Then reader.ExecuteOperation() Else Response.Write(Tipo incompatvel.) End if Dim tempId As String = 12 Dim id As Integer = 0 If Integer.TryParse(tempId, id) Then Me.BindForm(id) Else Console.WriteLine(Id invlido.) End if

25

Veremos mais tarde, ainda neste captulo, sobre os operadores de converso. Atributos Os atributos so tags declarativas quais podemos decorar nossos membros (assemblies, classes, mtodos, propriedades, etc.) de acordo com a necessidade e com a caracterstica do atributo. Esses atributos so armazenados junto aos metadados do elemento e fornecem informaes para o runtime que o utilizar para extrair informaes em relao ao membro em que aplicado. Dentro do .NET Framework existem uma poro de atributos, como o caso do CLSCompliant que vimos no incio deste captulo e tambm do atributo WebMethod que utilizado para expor um mtodo via WebService. H a possibilidade de Israel Aece | http://www.projetando.net 25


26

configurarmos inteiramente a segurana de um componente atravs da forma declarativa, que justamente utilizando atributos. Para que voc possa criar o teu prprio atributo, voc obrigatoriamente deve derivar da classe base chamada System.Attribute. Imagine que voc tenha uma classe chamada Cliente. Essa classe possui vrias propriedades e, entre elas, a propriedade Nome. Voc cria uma coleo de clientes e a popula com todos os clientes da sua empresa. Em um segundo momento, voc cria um atributo chamado ReportAttribute que pode ser aplicado exclusivamente em propriedades. Esse atributo indica quais propriedades devem fazer parte de um relatrio qualquer. Para exemplificar apenas o uso do atributo em conjunto com a propriedade, analise o cdigo a seguir:VB.NET _ Public Class ReportAttribute Inherits Attribute End Class Public Class Cliente Private _nome As String _ Public Property Nome() As String Get Return Me._nome End Get Set(ByVal value As String) Me._nome = value End Set End Property outras propriedades End Class C# [AttributeUsage(AttributeTargets.Property)] public class ReportAttribute : Attribute { } public class Cliente { private string _nome; [Report]

26


Captulo 1 Tipos de dados e Interfacespublic string Nome { get { return this._nome; } set { this._nome = value; } } } // outras propriedades

27

Como podemos reparar, na criao da classe ReportAttribute herdamos diretamente da classe Attribute. Denotamos esse atributo customizado com um outro atributo fornecido pelo .NET Framework que o AttributeUsage que permite especificamos em qual tipo de membro podemos aplicar o atributo. Para o nosso cenrio, vamos pode aplic-lo somente em propriedades. Depois dele pronto, basta simplesmente aplicar o mesmo nas propriedades que qualquer objetos customizado. Claro que precisaramos ainda de uma funo que extrai esses atributos via reflexo (System.Reflection) para assim tomarmos uma deciso baseandose no atributo. Vale lembrar tambm que perfeitamente possvel termos propriedades nos atributos customizados para assim passarmos mais informaes extras a nvel de metadados ou at mesmo informaes de regras de negcios. Para finalizar, qualquer membro pode suportar um ou vrios atributos. Trabalhando com Interfaces O que so Interfaces? Uma Interface se assemelha a uma classe. Ela pode conter mtodos, propriedades e eventos, mas sem qualquer implementao de cdigo, ou seja, somente contm a assinatura dos membros. As Interfaces so implementadas em classes e estas, por sua vez, implementam todo o cdigo para os membros abstratos da Interface, colocando ali o cdigo especfico para a classe que a implementa. As Interfaces so teis para arquiteturas de softwares que exigem um ambiente plug-andplay. Isso quer dizer que uma Interface pode referenciar armazenar uma instncia de uma classe concreta desde que esta instncia seja um tipo da Interface. Enteda-se por ser um tipo de uma classe que implementa a Interface em questo. As Interfaces podem ser implementadas em vrias e classes e uma classe pode implementar vrias Interfaces. Quando uma classe implementa uma Interface qualquer, Israel Aece | http://www.projetando.net

27


28

isso assegurar que o classe fornece exatamente os mesmos membros especificados na Interface implementada de forma pblica. A Interface uma forma de contrato, j que deixa explcito exatamente os membros que a classe dever implementar. O .NET Framework usa Interfaces por toda sua arquitetura e nos permite criar nossas prprias Interfaces. Alm disso, o .NET Framework tambm expe Interfaces que nos fornecem o contrato para implementarmos em nossos objetos para garantir que eles implementem exatamente os membros que so necessrios para outros tipos poderem manuse-lo. Entre as inmeros Interfaces fornecidas, vamos analisar algumas delas, as mais teis ao nosso dia--dia e entender como e quando implement-las. Quando falamos de implementao de Interfaces, h dois tipos: 1. Normal: Esta opo a mais tradicional, pois implementamos a Interface em uma classe qualquer e os mtodos, propriedades e eventos definidos pela Interface so publicamente disponibilizados tambm pela classe. 2. Explcita: A opo implcita permite-nos implementar vrias Interfaces com membros com o mesmo nome em um determinado objeto. Isso um caso comum, pois h situaes onde a Interface tem um mtodo comum com outra Interface mas ambas precisam ser implementadas. A implementao explcita so suportadas tanto no Visual Basic .NET quanto no Visual C#, mas h uma pequena diferena: o Visual C# prefixa o nome do mtodo com o nome da Interface correspondente; j o Visual Basic .NET cria nomes diferentes para o mtodo, mas permite invoc-lo atravs da Interface. Alm disso, o Visual Basic .NET ainda permite que se invoque os mtodos atravs da instncia da classe o que no permitido no Visual C#. Abaixo exibido um exemplo deste cenrio:VB.NET Public Interface IReader Sub Start() End Interface Public Interface IWriter Sub Start() End Interface Public Class Process Implements IReader Implements IWriter Public Sub Start() Implements IReader.Start Console.WriteLine("IReader.Start") End Sub Public Sub Start1() Implements IWriter.Start

28


Captulo 1 Tipos de dados e InterfacesConsole.WriteLine("IWriter.Start") End Sub End Class C# public interface IReader { void Start(); } public interface IWriter { void Start(); } public class Process : IReader, IWriter { void IReader.Start() { Console.WriteLine("IReader.Start"); } void IWriter.Start() { Console.WriteLine("IWriter.Start"); }

29

}

Como podemos ver, as Interfaces IReader e IWriter possui um mesmo mtodo chamado Start. A nica observao que no caso do Visual Basic .NET ele necessariamente precisa ter um nome diferente na classe concreta Process. No caso do Visual C#, o prefixo do mtodo, que o nome da Interface, garante a distino entre elas. As diferenas no param a. No caso do Visual C# esses mtodos somente so acessveis se forem invocados atravs da prpria Interface. Isso quer dizer que, atravs da instncia da classe Process no est disponvel e, se reparar, o Intellisense tambm no suporta. Isso j possvel no Visual Basic .NET. O cdigo abaixo mostra a utilizao da classe Process:VB.NET Dim p As New Process Dim reader As IReader = p Dim writer As IWriter = p reader.Start() writer.Start() Mas tambm possvel fazer: p.Start() p.Start1()

29


Captulo 1 Tipos de dados e InterfacesC# Process p = new Process(); IReader reader = (IReader)p; IWriter writer = (IWriter)p; reader.Start(); writer.Start();

30

Esse tipo de implementao somente se faz necessria quando h necessidade de implementar duas Interfaces em um objeto que contm exatamente um mesmo membro. Um exemplo disso dentro do .NET Framework so as estruturas de dados, como por exemplo: Int32, Double, etc., elas implementam explicitamente a Interface IConvertible. Converso de tipos utilizando IConvertible Imagine que esteja desenvolvendo uma aplicao em que contm uma classe chamada CalculoDeMedicoesPredio e dentro dela toda a lgica para calcular as medies de uma construo qualquer. Agora, voc precisa deste valor para gerar outras informaes para o usurio, como por exemplo relatrios ou at mesmo grficos. Geralmente, os mdulos que esperam esses valores (que talvez no seja nem a sua aplicao, pode ser um componente de terceiros) exigem que os valores estejam em um determinado tipo. Sendo assim, como eu fao para converter meu tipo complexo (CalculoDeMedicoesPredio) em um tipo esperado pelo mdulo para gerao de relatrios e grficos? O .NET Framework fornece uma Interface chamada IConvertible que permite-nos implement-la em nossos objetos. Essa Interface possuiu uma srie de mtodos que permitem converter um objeto em um tipo fornecedido pelo .NET Framework, a saber: Boolean, SByte, Byte, Int16, UInt16, Int32, UInt32, Int64, UInt64, Single, Double, Decimal, DateTime, Char, e String. Os nomes dos mtodos da Interface em questo so basicamente os mesmos, apenas prefixados com To. Exemplo: ToBoolean, ToDateTime, ToString, etc.. Como j devem desconficar, implementando a Interface IConvertible em seu tipo, poder utiliz-lo passando para o mtodo correspondente a converso que quer fazer para a classe Convert. Um ponto importante aqui que voc precisa antentar-se para quais tipos o seu objeto pode ser convertido. No caso acima, no faz sentindo convertermos a classe CalculoDeMedicoesPredio para Boolean. Nos tipos incompatveis o ideal sempre voc atirar uma exceo do tipo InvalidCastException para no permitem converses no suportadas. Atravs do cdigo abaixo possvel analisar como implementar a Interace IConvertible:

30


Captulo 1 Tipos de dados e InterfacesVB.NET Public Class CalculoDeMedicoesPredio Implements IConvertible Private _altura As Double Private _largura As Double Public Sub New(ByVal largura As Double, _ ByVal altura As Double) Me._altura = altura Me._largura = largura End Sub

31

Public Function ToBoolean(ByVal provider As IFormatProvider) As Boolean Implements IConvertible.ToBoolean Throw New InvalidCastException End Function Public Function ToDouble(ByVal provider As IFormatProvider) As Double Implements IConvertible.ToDouble Return Me._altura * Me._largura End Function 'demais mtodos End Class Utilizao: Dim calculo As New CalculoDeMedicoesPredio(10, 30) Dim area As Double = Convert.ToDouble(calculo) Console.WriteLine(area) C# public class CalculoDeMedicoesPredio : IConvertible { private double _largura; private double _altura; public CalculoDeMedicoesPredio(double largura, double altura) { this._altura = altura; this._largura = largura; } public bool ToBoolean(IFormatProvider provider) { throw new InvalidCastException;

31


Captulo 1 Tipos de dados e Interfaces} public double ToDouble(IFormatProvider provider) { return this._altura * this._largura; } } // demais mtodos

32

//Utilizao: CalculoDeMedicoesPredio calculo = new CalculoDeMedicoesPredio(10, 30); double area = Convert.ToDouble(calculo); Console.WriteLine(area);

IComparer, IComparable e IEquatable Geralmente quando estamos trabalhando com objetos customizados dentro da aplicao, muito normal querermos exibir tais objetos para o usurio. Para exemplificar, teremos um objeto do tipo Usuario que possui uma propriedade do tipo Nome. Imagine que voc tenha uma lista de usurios com nomes aleatrios, ou seja, sem uma ordenao especfica. Essa lista conter objetos do tipo Usuario com o seu respectivo nome. A aplicao se encarrega de carregar essa lista e chega o nomento em que voc precisa exib-la em um controle qualquer e, necessrio que essa lista seja exibida aplicando uma ordenao alfabtica na mesma. Como proceder para customizar a ordenao? Pois bem, vrias colees no .NET Framework, como por exemplo List, ArrayList, etc., fornecem um mtodo chamado Sort. S que apenas invocar este mtodo para ordenar a lista no o suficiente. necessrio que voc implemente as Interfaces IComparer (IComparer) e IComparable (IComparable) para isso. A primeira delas, IComparer, customiza a forma de como ordenar a coleo; j a segunda, IComparable, utilizada como definir como a ordenao realizada em uma classe especfica. Inicialmente iremos analisar a Interface IComparable. Ela fornece um mtodo chamado CompareTo, que permite comparar a instncia da uma classe onde esta Interface est sendo implementando com um objeto (do mesmo tipo) que passado para o mtodo. Com a verso 2.0 do .NET Framework foi criada uma verso nova desta mesma Interface IComparable, que a IComparable. A diferena em relao a IComparable que permite trabalharmos com Generics, o que melhora muito a performance, j que no necessrio efetuarmos a converso de System.Object para a classe que estamos utilizando e, somente depois disso, compararmos. Israel Aece | http://www.projetando.net

32


33

Com todos os conceitos definidos, resta-nos partir para a implementao concreta para analisarmos:VB.NET Public Class Usuario Implements IComparable(Of Usuario) Private _nome As String Public Sub New(ByVal nome As String) Me._nome = nome End Sub Public Property Nome() As String Get Return Me._nome End Get Set(ByVal value As String) Me._nome = value End Set End Property Public Function CompareTo(ByVal other As Usuario) As _ Integer Implements IComparable(Of Usuario).CompareTo Return Me.Nome.CompareTo(other.Nome) End Function End Class C# public class Usuario : IComparable { private string _nome; public Usuario(string nome) { this._nome = nome; } public string Nome { get { return _nome; } set { _nome = value; } } public int CompareTo(Usuario other) { return this.Nome.CompareTo(other.Nome);

33


Captulo 1 Tipos de dados e Interfaces}

34

}

Ao especificar a implementao da Interface IComparable, j definimos que esta Interface dever trabalhar com o tipo Usuario, que justamente a classe onde estamos implementando-a. Dentro do mtodo CompareTo fornecido por ela comparamos a propriedade Nome da instncia corrente com a propriedade Nome da instncia que vem como parmetro para mtodo. Reparem que utilizando a Interface genrica no necessrio efetuar a converso dentro do mtodo para, em seguinda, efetuar a comparao, pois o objeto j est com o tipo especificado na implementao da Interface. Ao exibir a coleo depois de invocar o mtodo Sort, o resultado ser o seguinte:VB.NET Dim list As New List(Of Usuario) list.Add(New Usuario("Virginia")) list.Add(New Usuario("Zuleika")) list.Add(New Usuario("Ana")) list.Add(New Usuario("Elisabeth")) list.Add(New Usuario("Tiago")) list.Add(New Usuario("Humberto")) list.Sort() Output Ana Elisabeth Humberto Tiago Virginia Zuleika C# List list = new List(); list.Add(new Usuario("Virginia")); list.Add(new Usuario("Zuleika")); list.Add(new Usuario("Ana")); list.Add(new Usuario("Elisabeth")); list.Add(new Usuario("Tiago")); list.Add(new Usuario("Humberto")); list.Sort(); //Output Ana Elisabeth Humberto Tiago

34


Captulo 1 Tipos de dados e InterfacesVirginia Zuleika

35

Um ponto bastante importante que deve ser comentado com relao ao cdigo acima que, ao invocar o mtodo Sort e o objeto especificado no implementar a Interface IComparable, uma exceo do tipo InvalidOperationException ser lanada. Como o exemplo um tanto quanto simples, pois tem apenas uma propriedade e, conseqentemente, um nico campo de ordenao, como ficaria se quisssemos disponibilizar vrias formas para ordenao? Exemplo: inicialmente a listagem exibida com os nomes em ordem alfabtica. Em seguida, gostaria de exibir a mesma listagem, mas agora ordenando por grupo. Para isso, devemos utilizar a Interface IComparer ou IComparer. Essa Interface fornece um mtodo denominado Compare, que compara dois objetos retornando um nmero inteiro indicando se um objeto menor, igual ou maior que o outro objeto. Esta Interface dever ser implementada em uma classe diferente da atual (Usuario), uma espcie de classe de utilidades para executar o seu trabalho. O primeiro passo ser a criao da classe que implementar a Interface IComparer e, sem seguida, codificar o mtodo Compare. Devemos ainda criar um enumerador para que o consumidor da classe possa escolher por qual campo ele deseja ordenar a listagem. A implementao exibida abaixo:VB.NET Public Class UsuarioSorting Implements IComparer(Of Usuario) Public Enum SortType Nome Grupo End Enum Private _sortType As SortType Public Sub New(ByVal sortType As SortType) Me._sortType = sortType End Sub Public Function Compare(ByVal x As Usuario, ByVal y Usuario) _ As Integer Implements IComparer(Of Usuario).Compare Select Case Me._sortType Case SortType.Grupo Return x.Grupo.CompareTo(y.Grupo) Case SortType.Nome As

35


Captulo 1 Tipos de dados e InterfacesReturn x.Nome.CompareTo(y.Nome) End Select Return 0 End Function End Class C# public class UsuarioSorting : IComparer { public enum SortType { Nome, Grupo } private SortType _sortType; public UsuarioSorting(SortType sortType) { this._sortType = sortType; } public int Compare(Usuario x, Usuario y) { switch (this._sortType) { case SortType.Grupo: return x.Grupo.CompareTo(y.Grupo); case SortType.Nome: return x.Nome.CompareTo(y.Nome); } } return 0;

36

}

A classe UsuarioSorting responsvel por receber qual o tipo de ordenao e, baseado nele ir determinar qual das propriedades devem ser comparadas para montar a ordenao. Finalmente, a utilizadao desta classe muda ligeiramente ao que vimos anteriormente durante o exemplo da Interface IComparable. A diferena resume a informar para um dos overloads do mtodo Sort da coleo um objeto que customiza o ordenao (que obrigatoriamente deve implementar a Interface IComparer):VB.NET ordenar por nome usuarios.Sort(New UsuarioSorting(UsuarioSorting.SortType.Nome))

36



37

ordenar por grupo usuarios.Sort(New UsuarioSorting(UsuarioSorting.SortType.Grupo)) C# //ordenar por nome usuarios.Sort(new UsuarioSorting(UsuarioSorting.SortType.Nome)); //ordenar por grupo usuarios.Sort(new UsuarioSorting(UsuarioSorting.SortType.Grupo));

Nota: Quando ambas Interfaces (IComparable e IComparer implementadas, somente a Interface IComparer utilizada.

so

Ainda temos a Interface IEquatable que compara dois objetos quanto igualdade, fazendo basicamente o que j faz o mtodo Equals de System.Object, mas assim como o IComparable, com uma vantagem: trabalha com o tipo especfico e no System.Object, o que evita o boxing/unboxing. Essa Interface tem um mtodo chamado Equals que recebe como parmetro um objeto do mesmo tipo especificado na declarao da Interface. A implementao da Interface exibida abaixo:VB.NET Public Class Usuario Implements IEquatable(Of Usuario) Private _nome As String Public Property Nome() As String Get Return Me._nome End Get Set(ByVal value As String) Me._nome = value End Set End Property Public Function Equals1(ByVal other As Usuario) As _ Boolean Implements IEquatable(Of Usuario).Equals If IsNothing(other) Then Return False Return Me.Nome = other.Nome End Function End Class C#

37


Captulo 1 Tipos de dados e Interfacespublic class Usuario : IEquatable { private string _nome; public Usuario(string nome) { this._nome = nome; } public string Nome { get { return _nome; } set { _nome = value; } } public bool Equals(Usuario other) { if(other == null) return false; return other.Nome == this.Nome; }

38

}

natural que ao utilizar a classe e chamar o mtodo Equals, ver que na lista de overloads aparecer duas verses do mesmo mtodo. Uma delas espera exatamente o tipo informado na Interface IEquatable, enquanto a outra espera um System.Object, que obviamente herda do tambm de System.Object. Copiando a referncia de um objeto utilizando ICloneable Quando falamos a respeito de tipos-referncia citamos que quando atribumos uma instncia de um objeto qualquer a um objeto do mesmo tipo recm criado, ambas passam a apontar (ter a mesma referncia) ao mesmo objeto na memria Heap. Sendo assim, qualquer mudana efetuada em algum dos objetos, ser imediatamente refletida no outro. Mas pode existir situaes onde ser necessrio criarmos uma cpia, ou melhor, um clone de objeto para que essa operao no interfira em seu original. Para assegurar isso, o Microsoft disponibilizou uma Interface chamada ICloneable que cria uma nova instncia do objeto em questo com os mesmo valores da instncia corrente. Esse processo chamado de clonar o objeto e, como j era de se esperar, a Interface fornece um mtodo chamado Clone para efetuarmos essa operao. Mas, quando falamos em clone, existem dois tipos: 1. Shallow-cloning: Este tipo de clone se resume a copiar apenas os valores, sem copiar qualquer referncia a outros objetos que existam internamente ao objeto.Com isso, tipos-referncia continuaram apontando para o mesmo local, mesmo no clone. Israel Aece | http://www.projetando.net 38


39

2. Deep-cloning: Este tipo de clone, alm de copiar os valores, tambm copia os membros que so tipo-referncias, criando assim um novo objeto completamente independente. Atravs das imagens abaixo conseguimos comparar as diferncias entre os tipos de clones suportados:

Imagem 1.5 Shallow-Clone Os tipos-referncia ainda continuam apontando para o mesmo local.

Imagem 1.6 Deep-Clone Uma cpia completa do objeto. A classe System.Object fornece um mtodo protegido (protected) chamado MemberwiseClone. Este mtodo retorna um clone no estilo Shallow, ou seja, copiar os valores e apenas as referncia para os membros tipo-referncia, se existirem. Dependendo do cenrio isso no muito interessante. Se desejar mesmo fazer um clone do tipo Deep-Clonning, ser necessrio implementar a Interface ICloneable e customizar o mtodo Clone. A implementao no complexa e podemos comprovar atravs do cdigo abaixo: 39


Captulo 1 Tipos de dados e InterfacesVB.NET Public Class Cliente Private _nome As String Public Sub New(ByVal nome As String) Me._nome = nome End Sub Public Property Nome() As String Get Return Me._nome End Get Set(ByVal value As String) Me._nome = value End Set End Property End Class Public Class Pedido Implements ICloneable Private _id As Integer Private _data As DateTime Private _cliente As Cliente

40

Public Sub New(ByVal id As Integer, ByVal data As DateTime) Me._data = data Me._id = id End Sub Public Property Cliente() As Cliente Get Return Me._cliente End Get Set(ByVal value As Cliente) Me._cliente = value End Set End Property Public Function Clone() As Object _ Implements System.ICloneable.Clone Dim pedidoClone As New Pedido(Me._id, Me._data) pedidoClone.Cliente = New Cliente(Me.Cliente.Nome) Return pedidoClone End Function

40


Captulo 1 Tipos de dados e InterfacesEnd Class Utilizao: Dim pedido1 As New Pedido(1, DateTime.Now) pedido1.Cliente = New Cliente("Jos Torres") Dim pedido2 As Pedido = DirectCast(pedido1.Clone(), Pedido) pedido2.Cliente.Nome = "Maria Torres" Console.WriteLine(pedido1.Cliente.Nome) Console.WriteLine(pedido2.Cliente.Nome) Output: Jos Torres Maria Torres C# public class Cliente { private string _nome; public Cliente(string nome) { this._nome = nome; } public string Nome { get { return this._nome; } set { this._nome = value; } }

41

}

public class Pedido : ICloneable { private int _id; private DateTime _data; private Cliente _cliente; public Pedido(int id, DateTime data) { this._data = data; this._id = id;

41


Captulo 1 Tipos de dados e Interfaces} public Cliente Cliente { get { return this._cliente; } set { this._cliente = value; } } public object Clone() { Pedido clone = new Pedido(this._id, this._data); clone.Cliente = new Cliente(this.Cliente.Nome); return clone; }

42

}

//Utilizao: Pedido pedido1 = new Pedido(1, DateTime.Now); pedido1.Cliente = new Cliente("Jos Torres"); Pedido pedido2 = (Pedido)pedido1.Clone(); pedido2.Cliente.Nome = "Maria Torres"; Console.WriteLine(pedido1.Cliente.Nome); Console.WriteLine(pedido2.Cliente.Nome); //Output: //Jos Torres //Maria Torres

Como podemos notar, o clone copiou na ntegra todos os valores do pedido1, mesmo os valores que so tipos-referncia. Agora, se apenas modificarmos a implementao do mtodo Clone retornando a chamada para o mtodo MemberwiseClone de System.Object, veremos que apenas a referncia para o objeto Cliente copiado e, sendo assim, ao alterar a propriedade Nome do pedido2 refletir tambm no pedido1. Formatando um tipo em uma string com IFormattable J vimos e utilizamos vrias vezes padres de formatao que so fornecidos intrinsicamente pela infraestrutura do .NET Framework desde a sua verso 1.x. Esses padres so comuns quando necessitamos formatar datas ou nmeros, para exibirmos ao Israel Aece | http://www.projetando.net 42


43

usurio um valor mais amigvel e, alguns exemplos tpicos esto neste artigo. Mas h situaes em que precisamos formatar o nosso objeto customizado e, felizmente, o .NET Framework fornece uma interface chamada IFormattable qual possui um nico mtodo denominado, ToString qual invocado automaticamente pelo runtime quando especificamos uma formatao. Para o nosso cenrio de exemplo, teremos dois objetos: Cliente e Cnpj. Cada cliente obrigatoriamente ter uma propriedade do tipo Cnpj. Este tipo por sua vez, implementar a interface IFormattable e dever fornecer dois tipos de formatao: DF e PR. O primeiro significa Documento Formatado e retornar o valor do CNPJ formatado; j a segunda opo significa Prefixo e, se o usurio optar por este tipo de formatao, ser retornado apenas o prefixo do CNPJ que, para quem no sabe, trata-se dos 9 primeiros dgitos. A arquitetura de classes que servir como exemplo:VB.NET Public Class Cliente Private _nome As String Private _cnpj As Cnpj Public Sub New(nome As String, cnpj As String) Me._nome = nome Me._cnpj = New Cnpj(cnpj) End Sub Public Property Nome() As String Get Return Me._nome End Get Set(Value As String) Me._nome = value End Set End Property Public Property Cnpj() As Cnpj Get Return Me._cnpj End Get Set(Value As Cnpj) Me._cnpj = value End Set End Property End Class Public Class Cnpj Implements IFormattable Private _numero As String

43


Captulo 1 Tipos de dados e InterfacesPublic Sub New(numero As String) Me._numero = numero End Sub Public Overloads Function ToString(format As String, _ formatProvider As IFormatProvider) As String _ Implements IFormattable.ToString

44

If format = "DF" Then Return Convert.ToDouble(Me._numero).ToString("000\.000\.000\/0000\-00") Else If format = "PR" Then Return Convert.ToDouble(Me._numero.Substring(0, 9)).ToString("000\.000\.000") End If Return Me._numero End Function Public Overrides Function ToString() As String Return Me.ToString(Nothing, Nothing) End Function End Class Utilizao: Dim c As New Cnpj("999999999999999") Response.Write(string.Format("O documento formatado {0:DF}.", c)) Response.Write(string.Format("O prefixo {0:PR}.", c)) Response.Write(string.Format("O documento {0}.", c)) ' Output: ' O documento formatado 999.999.999/9999-99. ' O prefixo 999.999.999. ' O documento 999999999999999. C# public class Cliente { private string _nome; private Cnpj _cnpj; public Cliente(string nome, string cnpj) { this._nome = nome; this._cnpj = new Cnpj(cnpj); }

44


Captulo 1 Tipos de dados e Interfacespublic string Nome { get { return this._nome; } set { this._nome = value; } } public Cnpj Cnpj { get { return this._cnpj; } set { this._cnpj = value; } }

45

}

public class Cnpj : IFormattable { private string _numero; public Cnpj(string numero) { this._numero = numero; } public string ToString(string formatProvider) { if (format == "DF") return format, IFormatProvider

Convert.ToDouble(this._numero).ToString(@"000\.000\.000\/0000\00"); else if (format == "PR") return Convert.ToDouble(this._numero.Substring(0, 9)).ToString(@"000\.000\.000"); } return this._numero;

45


Captulo 1 Tipos de dados e Interfacespublic override string ToString() { return this.ToString(null, null); }

46

}

//Utilizao: Cnpj c = new Cnpj("999999999999999"); Response.Write(string.Format("O documento formatado {0:DF}.", c)); Response.Write(string.Format("O prefixo {0:PR}.", c)); Response.Write(string.Format("O documento {0}.", c)); // Output: // O documento formatado 999.999.999/9999-99. // O prefixo 999.999.999. // O documento 999999999999999.

Como podemos reparar, a classe Cliente tem uma propriedade chamada Cnpj do tipo Cnpj. O objeto Cnpj implementa a Interface IFormattable e, dentro do mtodo ToString, verifica qual o formato est sendo passado para ele. Baseando-se neste formato que uma determinada formatao aplicada ao nmero do CNPJ e, caso nenhuma formatao especificada, somente o nmero retornado, sem nenhuma espcie de formatao. Esse tipo de formatao torna tudo muito flexvel e, podemos ainda especificar o tipo de formatao em controles DataBound, como por exemplo o GridView do ASP.NET, da mesma forma que fazemos para datas e nmeros. As imagens abaixo ilustram isso:

Imagem 1.7 Aplicando formatao em controles. Liberando referncias a objetos no gerenciados atravs da interface IDisposable 46



47

Utilizar o mtodo Finalize disponibilizado pela classe System.Object muito til, pois assegura que recursos no gerenciados no fiquem perdidos quando objetos gerenciados descartado. S que h um problema neste cenrio: no possvel saber quando o mtodo Finalize chamado e o fato deste mtodo no ser pblico, no h a possibilidade de invoc-lo explicitamente. Imagine o seguinte cenrio: a conexo com um banco de dados qualquer extremamente custosa e deixar ela aberta at que o runtime determine que ela seja descartada, podemos ter vrios danos, pois isso pode acontecer at alguns dias depois. Para termos a possibilidade de finalizar o objeto deterministicamente e, ali fecharmos conexes com bancos de dados e arquivos a Microsoft implementou um padro chamado Dispose. Atravs de uma Interface chamada IDisposable, que contm um nico mtodo chamado Dispose, voc pode implementar na sua classe de acesso a dados, arquivos, MessageQueue, entre outros recursos para que o recurso seja explicitamente fechado quando o processo finalizar, sem a necessidade de aguardar que o Garbage Collector decida fazer isso. Na maioria dos cenrio onde se utilizar o padro Dispose, dentro da implementao do mtodo invoca-se um outro mtodo chamado SuppressFinalize da classe GC (Garbage Collector). Teoricamente como todos os recursos so finalizados dentro do mtodo Dispose, no h necessidade do runtime invocar o mtodo Finalize, justamente porque no tem mais nada a fazer, pois o objeto j foi descartado. Abaixo podemos visualizar uma classe customizada que implementa o padro Dispose:VB.NET Public Class Reader Implements IDisposable Private _reader As StreamReader Private disposed As Boolean Public Sub New(ByVal filename As String) Me._reader = New StreamReader(filename) End Sub Protected Overridable Sub Dispose(ByVal disposing As Boolean) If Not Me.disposed Then If disposing Then If Not IsNothing(Me._reader) Then Me._reader.Dispose() End If End If Me.disposed = True End If

47


Captulo 1 Tipos de dados e InterfacesEnd Sub Public Sub Dispose() Implements IDisposable.Dispose Dispose(True) GC.SuppressFinalize(Me) End Sub End Class C# public class Reader : IDisposable { private StreamReader _reader; private bool disposed = false; public Reader(string filename) { this._reader = new StreamReader(filename); } protected virtual void Dispose(bool disposing) { if (!disposed) { if (disposing) { if (this._reader != null) { this._reader.Dispose(); } } } disposed = true;

48

}

}

public void Dispose() { Dispose(true); GC.SuppressFinalize(this); }

Analisando o cdigo acima, nota-se que existem dois mtodos Dispose. O mtodo que no tem nenhum parmetro o mtodo fornecido pela Interface IDisposable. Alm dele, criamos um mtodo protegido (protected) e que pode ser sobrescrito nas classes derivadas que faz a anlise dos recursos que devem ser descartados quando o mtodo pblico Dispose chamado. Israel Aece | http://www.projetando.net

48


49

Alm disso, termos uma classe que implementa IDisposable interessante porque podemos ainda utilizar em conjunto com o bloco using. Isso quer dizer que, ao utilizar o objeto dentro de um bloco using, o runtime se encarrega de invocar o mtodo Dispose mesmo que alguma exceo ocorra at o trmino da operao e sem termos o cdigo envolvido em blocos Try/Catch/Finally. Isso se d porque o compilar de encarrega de transformar o bloco using em um bloco envolvido por Try/Finally. Para finalizar, o cdigo abaixo exibe o consumo da classe Reader que foi construda acima com o padro IDisposable. A classe ser utilizada em conjunto com o bloco using. Isso far com que, ao chegar no trmino do bloco, o mtodo Dispose chamado automaticamente pelo runtime:VB.NET Using reader As New Reader("C:\Temp.txt") 'executa outras operaes End Using C# using (Reader reader = new Reader("C:\\Temp.txt")) { //executa outras operaes }

Casting Efetuando converses em tipos-referncia Uma das partes mais importantes do Common Language Runtime (CLR) a segurana de tipos. Em runtime, o CRL sempre sabe qual tipo o objeto realmente e, se em algum momento voc quiser saber, basta chamar o mtodo GetType. Cast (ou converso) algo que os desenvolvedores utilizam imensamente na aplicao, convertendo um objeto em vrios outros tipos diferentes (desde que suportados). Geralmente, o cast para o tipo base no exige nenhum tipo especial. Para citar um exemplo, voc poderia fazer atribuir a uma varivel do tipo System.Object a instncia de uma classe Cliente, podendo utilizar o seguinte cdigo:VB.NET Dim cliente As New Cliente() cliente.Nome = Jos Torres Dim obj As Object = cliente

49


Captulo 1 Tipos de dados e InterfacesC# Cliente cliente = new Cliente(); cliente.Nome = Jos Torres; object obj = cliente;

50

Para fazer o inverso, ou seja, extrair da varivel obj o Pedido que est dentro dela, necessrio efetuar o cast se estiver utilizando C#. O Visual Basic .NET no exige que voc faa isso explictamente, pois ele gera o cdigo necessrio para tal operao. No entanto sempre menos performtico fazer dessa forma e, alm disso, dificulta encontrarmos possveis problemas ainda em compile-time, ou seja, se o tipo no for compatvel, somente descobriremos isso quando a aplicao for executada e uma exceo for atirada. Para melhorar isso no Visual Basic .NET, v at as propriedades do projeto no Solution Explorer, em seguida na aba Compile e defina a opo Option Strict como On. Isso obrigar o desenvolvedor a fazer as converses explcitas no cdigo. Para extrair o pedido da varivel obj, o cdigo o seguinte:VB.NET Dim pedidoNovo As Pedido = DirectCast(obj, Pedido) C# Pedido pedidoNovo = (Pedido)obj;

O cdigo acima somente resultar com sucesso se o valor contido dentro da varivel obj for realmente um Pedido. Do contrrio, a aplicao retornar um exceo do tipo InvalidCastException, informando que no possvel converter o que est em obj para Pedido. Para evitar que problemas como este ocorra em tempo de execuo, tanto o Visual Basic .NET quando o Visual C# fornecem alguns operadores que permitem que a converso seja feita de forma mais segura, evitando assim, o problema que identificamos acima. Felizmente para ambas as linguagens temos um operador que, se a converso no for satisfeita, ao invs de atirar uma exceo, retornar uma valor nulo e, conseqentemente, voc deve tratar isso para dar continuidade na execuo do cdigo. Estamos falando do operador as para o Visual C# e o operador TryCast para o Visual Basic .NET. Para exemplificar o uso destes operadores, vamos transformar o exemplo que fizemos logo acima para utilizar os operadores em questo:VB.NET Dim pedidoNovo As Pedido = TryCast(obj, Pedido) If Not IsNothing(pedidoNovo) Then Console.WriteLine(pedidoNovo.Data)

50


Captulo 1 Tipos de dados e InterfacesEnd If C# Pedido pedidoNovo = obj as Pedido; if(pedidoNovo != null) { Console.WriteLine(pedidoNovo.Data); }

51

importante dizer que ao utilizar esses operadores, de nada vai adiantar se no verificar se est ou no nulo, pois se por algum motivo retornar nulo e voc invocar algum membro deste objeto, o runtime atirar uma exceo do tipo NullReferenceException.

51


Captulo 2 Trabalhando com ColeesCaptulo 2 Trabalhando com Colees Introduo

1

Desde a primeira verso do .NET Framework existem classes que possibilitam armazenarmos outros objetos e fornecem toda a funcionalidade para interagir com estes objetos. Essas colees obviamente foram mantidas, mas a Microsoft criou um novo subset de colees chamado Generics que possibilita ao desenvolvedor escrever um cdigo muito mais limpo e robusto. No decorrer deste artigo veremos as colees disponveis dentro do .NET Framework 2.0. O captulo comea mostrando as colees existentes desde a verso 1.0 do mesmo e, avanando um pouco mais, analisaremos as colees genricas disponveis na verso 2.0 que uma funcionalidade que trouxe uma grande flexibilidade e uma melhoria notvel em termos de performance e produtividade na escrita do cdigo. No veremos apenas as colees concretas, mas tambm vamos entender qual a arquitetura disponvel e as Interfaces necessrias e disponveis para a criao de colees customizadas. Ambas sees onde so abordados cada tipo de coleo, ser abordado as Interfaces disponveis para efetuarmos a comparao entre objetos. Depois de analisar as coleo primrias e as colees genricas, vamos abordar as colees especializadas, que so criadas para uma finalidade muito especfica e tambm classes que fornecem as funcionalidades bsicas para a criao de colees customizadas para uma determinado cenrio. O que so Colees? Colees so classes que armazenam em seu interior os mais diversos tipos de objetos. Elas so muito mais fcil de manipular em relao a Arrays, justamente porque colees fornecem uma infraestrutura completa para a manipulao de seus elementos. Para citar alguns de seus benefcios, podemos destacar: redimensionamento automtico; mtodo para inserir, remover e verificar se existe um determinado elemento; mtodos que permitem o usurio interceptar a insero ou a excluso de um elemento. As colees disponibilizadas pelo .NET Framework 2.0 e as Interfaces que so base para grande parte delas esto atualmente disponibilizadas em dois namespaces diferentes: System.Collections e System.Collections.Generics. O primeiro j existe desde a verso 1.0 do .NET Framework, mas o segundo uma novidade que foi incorporada na verso 2.0. Dentro destes namespaces, encontramos vrias classes e Interfaces para a criao dos mais diversos tipos de colees. As colees esto definidas em trs categorias: Colees Ordenadas, Colees Indexadas e Colees baseadas em "chave-e-valor". Veremos abaixo a finalidade de cada uma delas: Israel Aece | http://www.projetando.net 1

Captulo 2 Trabalhando com Colees

2

Colees Ordenadas: So colees que so distingidas apenas pela ordem de insero e assim controla a ordem em que os objetos podem ser recuperados da coleo. System.Collections.Stack e System.Collections.Queue so exemplos deste tipo de coleo. Colees Indexadas: So colees que so distingidas pelo fato de que seus valores e/ou objetos podem ser recuperados/acessados atravs de um ndice numrico (baseado em 0 (zero)). System.Collections.ArrayList um exemplo deste tipo de coleo. Colees "Chave-e-Valor": Como o prprio tipo diz, uma coleo que contm uma chave associado a algum tipo. Seus ndices so classificados no valor da chave e podem ser recuperados na ordem classificado pela enumerao. System.Collections.HashTable um exemplo deste tipo de coleo.

Nota: Para todos os tipos citados como exemplo para a descrio dos tipos de colees sempre haver um correspondente dentro do namespace System.Collections.Generics, que trabalhar de forma genrica. Colees Primrias Definimos como colees primrias todas as colees disponveis dentro do namespace System.Collections. Estas colees tambm so chamadas de colees fracamente tipadas ou colees no genricas. Essas colees, apesar de suportar grande partes das funcionalidades que so disponibilizadas pelo .NET Framework, h um grande problema, j que essas classes operam com tipos System.Object, o que causa problemas em termos de performance, pois se quiser fazer uma coleo de inteiros teremos que pagar pelo boxing e unboxing. Alm disso, ainda h a questo de no trabalhar efetivamente com um nico tipo, ou seja, o fato de possibilitar incluir um System.Object, est permitindo adicionar qualquer tipo de objeto dentro da coleo, o que pode causar problemas durante a execuo da aplicao. Para enterdemos a estrutura das colees primrias, vamos analisar todas as Interfaces que foram implementadas nas colees concretas e que tambm esto disponveis para que o desenvolvedor possa customizar seus prprias colees. A Imagem 2.1 exibe a hierarquia das Interfaces e a tabela a seguir detalha cada uma dessas Interfaces.

2



3

Imagem 2.1 Hierarquia das Interfaces do namespace System.Collections Interface ICollection Descrio a Interface base para todas as colees que esto contidas dentro do namespace System.Collections. Direta ou indiretamente essas classes a implementa. Ela por sua vez composta por trs propriedades (Count, IsSynchronized e SyncRoot) e um mtodo (CopyTo). Interfaces como IList e IDictionary derivam desta Interface ICollection, pois estas Interfaces so mais especializadas, tendo tambm outros mtodos a serem definidos alm dos quais j Israel Aece | http://www.projetando.net 3


4

IComparer

esto contidos dentro da Interface ICollection. J as classes como System.Collections.Queue e System.Collections.Stack implementam a Interface ICollection diretamente. Esta Interface utilizada para customizar uma ordenao (sorting) em uma determinada coleo. A Interface IComparer composta por um mtodo chamado Compare, qual compara dois objetos e retorna um valor inteiro indicando se os objetos so ou no iguais, ou seja, se os valores comparados forem iguais, 0 (zero) retornado. H classes, como por exemplo o ArrayList, que j implementa o mtodo Sort para tal ordenao, mas h casos em que desejamos criar uma ordenao customizada, onde a ordenao padro no nos interessa. justamente neste momento que a Interface IComparer utilizada, inclusive o mtodo Sort da classe ArrayList tem um overload que recebe como parmetro um objeto do tipo Interface IComparer. Quando utilizamos o mtodo Sort do ArrayList sem informar nenhum parmetro, a ordenao feita em ordem ascendente, a padro. Mas podemos querer ordenar em ordem descendente, e com isso teramos que criar uma classe que implementa a Interface IComparer, codificando assim o mtodo Compare. A Interface IDictionary a base para todas as colees do tipo "chave-e-valor". Cada elemento inserido neste tipo de coleo armazenado em um objeto do tipo DictionaryEntry (Structure).

IDictionary

Cada associao deve ter um chave original que no seja uma referncia nula, mas o seu respectivo valor de associao pode incluir sem problemas uma referncia nula. IDictionaryEnumerator Esta Interface tem a mesma finalidade da Interface IEnumerator, ou seja, percorrer e ler os elementos de uma determinada coleo, mas esta em especial, trata de enumerar os elementos de um dicionrio, ou seja, uma coleo que contenha "chave-e-valor". IEnumerable a base direta ou indiretamente para algumas outras Interfaces e todas as colees a implementam. Esta interface tem apenas um mtodo a ser implementado, chamado GetEnumerator, qual retorna um objeto do tipo da Interface de IEnumerator. IEnumerator a base para todos os enumeradores. Composta por uma propriedade (Current) e dois mtodos (MoveNext e Reset), percorre e l todos os elementos de uma determinada coleo, permitindo apenas ler os dados, no podendo alter-los. Vale levar em considerao que enumeradores no podem ser Israel Aece | http://www.projetando.net

4


5

IEqualityComparer

utilizados para a coleo subjacente. Expe os mtodos chamados Equals e GetHashCode que permitem a comparao entre dois objetos quando a igualdade. Esta Interface foi introduzida a partir do .NET Framework 2.0. Derivada das Interfaces ICollection e IEnumerable ela a Interface base para todas as listas contidas no .NET Framework. Listas quais podemos acessar individualmente por um determinado ndice. As implementaes da Interface IList podem estar em uma das seguintes categorias: Read-Only, Fixed-Size e Variable-Size. Uma IList Read-Only, no permite que voc modifique os elementos. J uma IList Fixed-Size, no permite adicionar ou remover os elementos, mas permite que voc altere os elementos existentes. E por fim, uma IList Variable-Size, qual permite que voc adicione, remova ou altere os elementos. Claro que quando implementamos esta Interface em alguma classe, necessrio criarmos um membro privado que ser o responsvel por armazenar os items. Este membro privado manipulado pelos mtodos e propriedades da Interface IList que sero implementados nesta classe.

IList

Antes de efetivamente entrar em cada uma das colees concretas dentro das colees primrias, vamos analisar a implementao de alguma das Interfaces que vimos acima para um cenrio customizado de uma determinada aplicao. Entre as vrias Interfaces acima mostradas, duas delas praticamente trabalham em conjunto: IEnumerable e IEnumerator. A Interface IEnumerator fornece mtodos para iterar pela coleo; j a Interface IEnumerable deve ser implementada em um tipo que voc deseja iterar pela coleo atravs de um loop foreach (For Each em Visual Basic .NET). A implementao destas Interfaces geralmente feito em classes separadas e, na maioria dos casos, o mtodo GetEnumerator da Interface IEnumerable retorna a instncia da classe privada que implementa IEnumerator. O cdigo abaixo exemplifica como iterar pelas cidades categorias contidas dentro da classe CategoriesEnumerator:VB.NET Public Class CategoriesEnumerator Implements IEnumerator Private _categories() As String = _ {"ASP.NET", "VB.NET", "C#", "SQL", "XML"} Private _current As Integer = -1

5



6

Public ReadOnly Property Current() As Object Implements IEnumerator.Current Get If Me._current < 0 OrElse Me._current > 4 Then Throw New InvalidOperationException Else Return Me._categories(Me._current) End If End Get End Property Public Function MoveNext() IEnumerator.MoveNext Me._current += 1 Return Me._current 4) throw new InvalidOperationException(); else return this._categories[this._current]; } } public bool MoveNext() { this._current++; return this._current > Attach To Process (ou atravs do atalho Ctrl + Alt + P) e na caixa de dilogo que lhe apresentada, selecione o servio na lista de servios em execuo e ento clique no boto Attach. Isso far com que o debugger do Visual Studio .NET seja anexado ao processo do servio e, quando a execuo chegar no Breakpoint, voc conseguir acompanhar o processo via linha de cdigo. A imagem abaixo ilustra a janela que apresentada para voc escolher o processo qual quer anexar o depurador: Israel Aece | http://www.projetando.net

15

Captulo 11 Criando Servios do Windows

16

Imagem 12.6 Anexando o debugger ao servio Windows.

16


Captulo 12 Interoperabilidade com componentes COMCaptulo 12 Interoperabilidade com componentes COM Introduo

1

Antes mesmo da plataforma .NET surgir, as empresas j estavam desenvolvendo aplicaes e componentes nas mais diversas linguagens, como por exemplo C++, Visual Basic 6, etc.. No h dvidas que as empresas investiram tempo e dinheiro na criao destes componentes que so, em algumas vezes, largamente utilizados e, dificilmente, sero sobrescritos instantaneamento para .NET, utlizando o cdigo gerenciado. No somente esse cenrio, mas temos diversos outros componentes que so expostos via COM que poderamos estar utilizando dentro da plataforma .NET. Felizmente o .NET tem a capacidade de comunicar com o mundo COM, permitindo criarmos componentes que sejam acessveis a linguagens no .NET e, tambm, permite utilizarmos os componentes legados dentro das aplicaes .NET. Na primeira parte deste captulo, vamos abordar como devemos proceder para a criao de componentes que sero utilizados por aplicaes/componentes COM e tambm como consumir componentes COM. A segunda, e ltima parte, destina-se a analisarmos um servio chamado PInvoke que a plataforma .NET nos disponibiliza. Ela nos permite fazer chamadas a DLLs no gerenciadas e, alm disso, e

Documents

23547287 Livro de NET Israel Aece