No C# temos os seguintes tipos:

• Value Types - Tipos de valor.
• Reference Types – Tipos de referência.

Vamos iniciar o nosso estudo pelos Value Types.

Value Types:

Um tipo Value Type contém o valor da variável. Por conter o valor da variável e não uma referência (referência= endereço de memória) à variável, valores do tipo Value Type não podem conter o valor Null.

Outro detalhe importante a ser observado é que tudo no C#, mesmo os tipos mais simples como um inteiro, é considerado um objeto. Por exemplo, o tipo inteiro é definido a partir da Estrutura System.Int32 (ou System.Int16 dependendo do tamanho necessário). Ao criarmos uma variável do tipo System.Int32 estamos criando uma instância desta estrutura, o que na prática significa criar um objeto baseado na estrutura System.Int32. Esta estrutura possui métodos. Um dos métodos, a título de exemplo, é o método ToString, o qual converte o valor inteiro na string de texto correspondente.

Vamos a um exemplo. Vamos imaginar que as variáveis a e b são do tipo Value Type. Também vamos imaginar que a variável a contém o valor 10 e a variável b contém o valor 15.  Agora considere o seguinte comando:

a = b

Neste caso o valor da variável b é atribuído à variável a. Ou seja, após a execução deste comando, a variável a contém o mesmo valor da variável b, que no nosso exemplo é 15. Agora se modificarmos o valor da variável b, o que acontece com o valor da variável a?

Nada, como as variáveis são do tipo Value Type, ao fazermos a=b, apenas atribuímos o valor de b para a. Porém a não fica com nenhuma referência para b, ou seja, se b for modificado, a não será afetado.

Para entendermos bem este conceito, observe o exemplo da Listagem 3.2.

Listagem 3.2 – Um exemplo de Value Types – ex2cap3.cs

using System;

class ex2cap3

{

            // Exemplo2  - Capítulo 3.

            // Value  Types

            // Por:  Júlio Battisti

            // MCP,  MCP+I, MCSE, MCSE+I, MCSE, MCDBA

            public  static void Main()

           {

                        //  Declaração das variáveis.

                        Int32  a;

                        Int32  b;

                        //  Atribuo valores às variáveis a e b.

                        a=10;

                        b=15;

                        //  Atribuo o valor da variável b à variável a.

                        a=b;

                        //  Exibo os valores das variáveis a e b.

                        Console.WriteLine("Valor  da variável a: {0}",a);

                        Console.WriteLine("Valor  da variável b: {0}",b);

                        //  Agora modifico o valor da variável b.

                        //  E observamos que o valor de a não se alterou.

                        b=33;

                        Console.WriteLine("****************************");

                        Console.WriteLine("Após  a modificação de b!!!!");

                        Console.WriteLine("****************************");                                     

                        Console.WriteLine("Valor  da variável a: {0}",a);                                        

                        Console.WriteLine("Valor  da variável b: {0}",b);                                      

            }

}

Compile e execute o exemplo da listagem 3.2. Você obterá os resultados indicados na Figura 3.2.

Figura 3.2 Executando o programa ex2cap3.exe.

Observe que após modificarmos o valor da variável b, o valor da variável a manteve-se inalterado. Este é o comportamento esperado, conforme descrito anteriormente.

Em C# também temos os tipos simples presentes na maioria das linguagens. Conforme descrevemos anteriormente, um tipo simples é uma instância de uma estrutura ou classe do namespace System. Para facilitar a programação, o C# oferece aliases (apelidos) para os tipos do Framework .NET. Por exemplo, ao invés de declararmos o tipo de uma variável inteira como System.Int32, podemos utilizar o alias do C#: int.

Na Tabela 3.1 temos uma descrição dos principais tipos básicos do C#. Também apresentamos o alias correspondente, bem como uma descrição da faixa de valores de cada tipo.

Tabela 3.1 Tipos básicos do C# - value types.

Algumas observações importantes sobre os tipos básicos no C#:

• No C/C++ o valor verdadeira, para uma variável do tipo bool, é representado por qualquer valor diferente de zero. No C# o valor verdadeiro não é mais representado por qualquer valor diferente de zero.
• O tipo decimal é utilizado para valores que necessitam de uma alta precisão, como por exemplo valores para cálculos financeiros e monetários. Também devemos destacar que a precisão é dada em dígitos e não em casas decimais. As operações são precisas até um máximo de 28 casas decimais.

Agora vamos falar um pouco mais sobre um tipo que nos oferece mais opções: O tipo struct.

O tipo Struct:

Através da utilização da palavra struct podemos construir estruturas complexas de dados. Por exemplo, um ponto no plano cartesiano é representado pelo valor de x e y. Podemos criar uma estrutura chamada ponto, a qual contém dois campos: x e y. Além de campos, uma estrutura pode conter constantes, métodos, propriedades, indexadores, operadores e tipos aninhados.

Pode parecer que um struct é a mesma coisa do que uma classe. Porém a diferença básica é que um struct é um value type, enquanto uma classe é um reference type (falaremos mais sobre reference type mais adiante). O namespace System contém uma série de estruturas, algumas delas descritas na tabela 3.1: System.Int16, System.Int32, System.Byte, System.SByte e assim por diante.

Vamos criar um exemplo simples, onde criamos uma estrutura para representar números complexos. Um número complexo possui uma parte real e uma parte imaginária (só para lembrarmos um pouco da época do segundo-grau). A seguir temos alguns exemplos de números complexos:

x =  2 + 3i

y = -1 + 4,5i

z =  3 – 5,2i

Onde i, por definição, representa a raiz quadrada de -1.

Para representar um número complexo, precisamos de dois valores do tipo single: um para a parte real e outro para a parte imaginária. Para somar dois números complexos, basta somar as partes reais e as partes imaginárias, conforme exemplo a seguir:

x+y = (2-1)+(3+4,5)i

x=y = 1+7,5y

Vamos a um exemplo simples, onde criaremos uma estrutura para representar números complexos. Nossa estrutura conterá dois campos: um para representar a parte real e outro para representar a parte imaginária. O usuário irá digitar os valores para dois números complexos e o programa fará a soma dos mesmos e exibirá os números digitados e o resultado da soma.

Para definir uma estrutura utilizamos a palavra struct. Por exemplo, vamos definir a estrutura numcomplexo, a qual será utilizada no nosso programa:

struct numcomplexo

{

            public  float preal,pimag;

}

Para utilizar esta estrutura no nosso exemplo, precisamos declarar uma variável do tipo numcomplexo. Como iremos utilizar três variáveis, sendo uma delas para conter a soma, precisamos declarar três variáveis do tipo numcomplexo:

numcomplexo num1,num2;

numcomplexo soma;

Para acessar os campos individuais da estrutura utilizamos a notação tradicional da orientação a objetos, ou seja, o nome da estrutura seguida de um ponto (.) mais o nome do campo. Por exemplo, para atribuirmos um valor ao campo preal, da estrutura num1, utilizamos a seguinte sintaxe:

num1.preal = 3,5;

Agora que já conhecemos o básico sobre estruturas, vamos apresentar o nosso exemplo. Considere o exemplo da Listagem 3.3.

Listagem 3.3 – Um exemplo utilizando estruturas – ex3cap3.cs:

using System;

            // Exemplo3  - Capítulo 3.

            //  Utilização de estruturas.

            // Números  complexos.

            // Por:  Júlio Battisti

            // MCP,  MCP+I, MCSE, MCSE+I, MCSE, MCDBA

struct numcomplexo

{

            public  float preal,pimag;

}

class ex3cap3

{

            public  static void Main()

            {

                        //  Declaração das variáveis.

                        numcomplexo  num1,num2;

                        numcomplexo  soma;

                        //  Entrada dos valores para a parte real

                        //  e a parte imaginária dos números num1 e num2.

                        Console.Write("Digite  a parte real do primeiro número ->");

                        String  Auxreal1=Console.ReadLine();

                        num1.preal  = Convert.ToSingle(Auxreal1);

                        Console.Write("Digite  a parte imaginária do primeiro número ->");

                        String  Auximag1=Console.ReadLine();

                        num1.pimag  = Convert.ToSingle(Auximag1);

                        Console.Write("Digite  a parte real do segundo número ->");

                        String  Auxreal2=Console.ReadLine();

                        num2.preal  = Convert.ToSingle(Auxreal2);

                        Console.Write("Digite  a parte imaginária do segundo número ->");

                        String  Auximag2=Console.ReadLine();

                        num2.pimag  = Convert.ToSingle(Auximag2);

                        //  Cálculo da adição dos números num1 e num2.

                        //  Para isto basta somar as partes reais e imaginárias

                        //  dos respectivos números.

                        soma.preal  = num1.preal + num2.preal;

                        soma.pimag  = num1.pimag + num2.pimag;                    

            // Exibição  dos resultados.

Console.WriteLine("**********************************************");

            Console.WriteLine("O  primeiro complexo é -> {0} + {1}i",num1.preal,num1.pimag);

            Console.WriteLine("**********************************************");

            Console.WriteLine("O  segundo  complexo é -> {0} +  {1}i",num2.preal,num2.pimag);

            Console.WriteLine("**********************************************");

            Console.WriteLine("O  resultado da soma é ->   {0} +  {1}i",soma.preal,soma.pimag);

            Console.WriteLine("**********************************************");

            }

}

Digite o exemplo da listagem 3.3 e salve o mesmo em um arquivo chamado ex3cap3.cs, na pasta C:\ExCsharp\cap3. Compile e execute o exemplo da listagem 3.3. Você obterá os resultados indicados na Figura 3.3.

Figura 3.3 Executando o programa ex3cap3.exe.

Este exemplo simples serve para ilustrar a criação e utilização de estruturas. Também observe que utilizamos o método ToSingle, da classe Convert – Convert.ToSingle. A utilização deste método foi necessária, porque o valor retornado pelo comando ReadLine é do tipo String. Precisamos converter este valor para o tipo Single, para que possamos fazer a operação de adição com os mesmos. O valor retornado por ReadLine é armazenado em uma variável auxiliar do tipo String, conforme o exemplo a seguir:

                        String  Auxreal1=Console.ReadLine();

Depois este valor é convertido para o tipo Single, antes de ser atribuído a parte real da variável num1, conforme exemplo a seguir:

                        num1.preal  = Convert.ToSingle(Auxreal1);

Os tipos de enumeração:

Utilizamos tipos de enumeração para criar um conjunto com valores definidos. Além do valor definido é associado um valor numérico para cada elemento do conjunto. Por padrão o valor numérico associado é do tipo inteiro e inicia com zero.

No exemplo a seguir estamos definindo um tipo de enumeração chamado DiasDaSemana:

enum DiasDaSemana   {Domingo, Segunda,Terça,Quarta,Quinta,Sexta,Sábado}

Neste caso temos associados os seguintes valores do tipo int, com cada elemento:

Domingo         = 0

Segunda         = 1

Terça           = 2

Quarta          = 3

Quinta          = 4

Sexta           = 5

Sábado          = 6

Também podemos modificar o valor associado com o primeiro elemento do conjunto. Os valores dos demais elementos vão sendo incrementados de um em um. Vamos modificar um pouco o exemplo anterior:

enum DiasDaSemana   {Domingo=1, Segunda,Terça,Quarta,Quinta,Sexta,Sábado}

Neste caso os valores inteiros associados aos elementos do conjunto seriam os seguintes:

Domingo         = 1

Segunda         = 2

Terça           = 3

Quarta          = 4

Quinta          = 5

Sexta           = 6

Sábado          = 7

Também é possível definir valores específicos, associados com cada elemento do conjunto. Considere o exemplo a seguir:

enum DiasDaSemana   {Domingo=1, Segunda=3,Terça=4,Quarta=8,Quinta=11,Sexta=15, Sábado=0}

Também podemos fazer com que os valores associados com os elementos do conjunto sejam de um tipo diferente de int. Os tipos permitidos são os seguintes: long, int, short e byte. Para fazer com que os valores numéricos associados aos elementos do conjunto sejam de um tipo diferente, utilizamos a seguinte sintaxe:

enum nome_do_conjunto: tipo_desejado {Elemento1, Elemento2,  ..., Elementon}

Considere o exemplo a seguir, onde definimos o conjunto DiasDaSemana com valores do tipo byte, associados aos elementos do conjunto:

enum DiasDaSemana : byte{Domingo=1,Segunda,Terça,Quarta,Quinta,Sexta,Sábado}

Neste caso os valores do tipo byte associados aos elementos do conjunto são os seguintes:

Domingo         = 1

Segunda         = 2

Terça           = 3

Quarta          = 4

Quinta          = 5

Sexta           = 6

Sábado          = 7

Também podemos utilizar a seguinte sintaxe, onde fazemos a definição de cada elemento em uma linha separada, o que facilita a visualização do código:

enum DiasDaSemana

{

Domingo         = 1

Segunda         = 2

Terça           = 3

Quarta          = 4

Quinta          = 5

Sexta           = 6

Sábado          = 7

}

Reference types:

Os tipos de referência (reference types) não armazenam os dados reais de uma variável, ao invés disso, armazenam uma referência (endereço de memória) para o local onde estes dados estão armazenados. Quando uma variável do tipo reference type é passada como parâmetro de uma função, o endereço da variável é passado para a função e não o seu valor. Se a função modificar a variável passada como parâmetro, na verdade estará modificando a variável original.

Os tipos de referência são os seguintes:

• object
• class
• interfaces
• Delegações
• string
• Arrays

Neste capítulo vamos tratar dos tipos string e Arrays. Veremos alguns exemplos de utilização dos mesmos.

O tipo string:

Toda string (valor do tipo texto) no C# é uma instância da classe System.String do .NET Framework Class Library. Por ser uma classe, temos a disposição uma série de métodos, campos, propriedades, operadores e construtores para manipulação de strings.

Também cabe reforçar que uma string é um valor do tipo reference type.

Para exemplificar o uso de strings considere o exemplo da Listagem 3.4. Neste exemplos utilizaremos alguns métodos da classe System.String.

Listagem 3.4 – Um exemplo utilizando variáveis do tipo string – ex4cap3.cs

using System;

class ex4cap3

{

            // Exemplo4  - Capítulo 3.

            // Entrada  e saído com C#

            // Por:  Júlio Battisti

            // MCP,  MCP+I, MCSE, MCSE+I, MCSE, MCDBA

            public  static void Main()

            {

                        //  Declaração de duas variáveis do tipo string.

                        string  Texto1;

                        string  Texto2;

                        //Defino  valores para as variáveis Texto1 e Texto2;

                        Texto1  = "José da Silva";

                        Texto2  = "Maria do Socorro";

                        //  Agora vamos utilizar o método

                        //  String.ToLower()

                        //  para converter as strings Texto1

                        //  e Texto2 para minúsculas.        

                        Console.WriteLine("*********************************************");

                        Console.WriteLine("Variável  Texto 1-> {0}",Texto1.ToLower());

                        Console.WriteLine("Variável  Texto 2-> {0}",Texto2.ToLower());             

                        Console.WriteLine("*********************************************");

                        //  Agora vamos utilizar o método

                        //  String.ToUpper()

                        //  para converter as strings Texto1

                        //  e Texto2 para MAIÚSCULAS.

                        Console.WriteLine("Variável  Texto 1-> {0}",Texto1.ToUpper());

                        Console.WriteLine("Variável  Texto 2-> {0}",Texto2.ToUpper());              

                        Console.WriteLine("*********************************************");

            }

}

Observe que o fato de uma string ser uma instância de uma classe (System.String), isso faz com que tenhamos acesso a uma série de métodos disponibilizados pela biblioteca de classes do .NET (.NET Framework Class Library). No nosso exemplo utilizamos os métodos ToLower( ) e ToUpper.

Digite o exemplo da listagem 3.4 e salve o mesmo em um arquivo chamado ex4cap3.cs, na pasta C:\ExCsharp\cap3. Compile e execute o exemplo da listagem 3.4. Você obterá os resultados indicados na Figura 3.4.

Figura 3.4 Executando o programa ex4cap3.exe.

Na Tabela 3.2 temos uma descrição dos principais métodos da classe System.String.

Tabela 3.2 Os principais métodos da classe System.String.

Uma variável do tipo string também tem duas propriedades interessantes. A primeira é a propriedade Length, a qual retorna o tamanho da strings, ou seja, o número de caracteres da string.

Para exemplificar o uso da propriedade Length considere o exemplo da Listagem 3.5. Neste exemplo o usuário deve digitar uma string de texto e o programa retorna o número de caracteres digitados. É importante salientar que espaços em branco também contam.

Listagem 3.5 – Um exemplo utilizando a propriedade Length  – ex5cap3.cs

using System;

class ex5cap3

{

            // Exemplo5  - Capítulo 3.

            //  Utilização da propriedade Lenght.

            // Por:  Júlio Battisti

            // MCP,  MCP+I, MCSE, MCSE+I, MCSE, MCDBA

            public  static void Main()

            {

                        //  Entrada da string pelo usuário.

                        Console.Write("Digite  algum texto e pressione <ENTER> ->");

                        String  Texto=Console.ReadLine();

                        //  Exibição dos resultados.  

Console.WriteLine("+++++++++++++++++++++++++++++++++++++++++++++++++++");

Console.WriteLine("Você digitou o seguinte texto  ->  {0}",Texto);

Console.WriteLine("O mesmo tem -> {0}  caracteres.",Texto.Length);

Console.WriteLine("+++++++++++++++++++++++++++++++++++++++++++++++++++");

            }

}

Digite o exemplo da listagem 3.5 e salve o mesmo em um arquivo chamado ex5cap3.cs, na pasta C:\ExCsharp\cap3. Compile e execute o exemplo da listagem 3.5. Quando o programa solicitar digite o texto: APRENDENDO C# e pressione ENTER. Você obterá os resultados indicados na Figura 3.5.

Figura 3.5 Executando o programa ex5cap3.exe.

Também podemos acessar caracteres individuais de uma string, com base na posição dos mesmos. O primeiro caractere é a posição zero, o segundo a posição 1 e assim por diante. Por exemplo, considere a string Teste definida a seguir:

string Teste = ”APRENDENDO C#”

Agora considere a declaração e inicialização das seguintes variáveis do tipo char:

char primcar = teste[0];

char segcar   =  teste[1];

char deccar  =  teste[9];

A variável primcar conterá A.

A variável segcar conterá P.

A variável deccar conterá O.

O tipo Arrays:

Um array é uma variável que contém um conjunto de elementos todos do mesmo tipo. Na época do Fortran ou do Pascal para DOS o array era chamado de vetor, quando fosse um array de uma única dimensão e matriz para um array de duas dimensões. Temos dois fatos fundamentais a respeito de arrays:

• Todos os elementos de um array devem ser do mesmo tipo.
• Acessamos os elementos de um array através de seu(s) índice(s).

Por exemplo, para criarmos um array de uma única dimensão (vetor), com 5 elementos do tipo Int32, utilizamos o seguinte comando:

int[] meuarray = new int[5];

Podemos definir os valores deste array, da seguinte maneira:

meuarray[0] = 25;

meuarray[1] = 15;

meuarray[2] = 20;

meuarray[3] = 12;

meuarray[4] = 44;

Observe que o primeiro elemento do array é o elemento de índice zero.

Também podemos criar arrays de mais dimensões. Observe o exemplo a seguir, onde estamos criando um array de duas dimensões (uma matriz), com 2 linhas e duas colunas:

int[,] minhamatriz = new int[2,2];

Podemos definir os valores deste array, da seguinte maneira:

meuarray[0,0] = 25;

meuarray[0,1] = 15;

meuarray[1,0] = 28;

meuarray[1,1] = 12;

Vamos a um exemplo simples. Onde criamos um array de duas dimensões, com 3 linhas e 3 colunas, atribuímos valores para os elementos do array, depois exibimos os valores no vídeo.

Considere o exemplo da Listagem 3.6.

Listagem 3.6 – Um exemplo utilizando um array de duas dimensões  – ex6cap3.cs

using System;

class ex6cap3

{

            // Exemplo6  - Capítulo 3.

            // Um array  de duas dimensões.

            // Por:  Júlio Battisti

            // MCP,  MCP+I, MCSE, MCSE+I, MCSE, MCDBA

            public  static void Main()

            {

                        //  Declaração do array de duas dimensões.

                        int[,]  minhamatriz = new int[3,3];

                        //  Definição dos valores do array.

                        minhamatriz[0,0]  = 0;

                        minhamatriz[0,1]  = 5;

                        minhamatriz[0,2]  = 10;

                        minhamatriz[1,0]  = 15;

                        minhamatriz[1,1]  = 20;

                        minhamatriz[1,2]  = 15;

                        minhamatriz[2,0]  = 10;

                        minhamatriz[2,1]  = 5;

                        minhamatriz[2,2]  = 0;

                        //  Exibição dos resultados.

Console.WriteLine("O valor da primeira linha primeira  coluna é -> {0}",minhamatriz[0,0]);

Console.WriteLine("O valor da primeira linha  segunda  coluna é -> {0}",minhamatriz[0,1]);

Console.WriteLine("O valor da primeira linha terceira  coluna é -> {0}",minhamatriz[0,2]);

Console.WriteLine("O valor da segunda  linha primeira coluna é ->  {0}",minhamatriz[1,0]);

Console.WriteLine("O valor da segunda  linha segunda  coluna é -> {0}",minhamatriz[1,1]);

Console.WriteLine("O valor da segunda  linha terceira coluna é ->  {0}",minhamatriz[1,2]);

Console.WriteLine("O valor da terceira linha primeira  coluna é -> {0}",minhamatriz[2,0]);

Console.WriteLine("O valor da terceira linha  segunda  coluna é ->  {0}",minhamatriz[2,1]);

Console.WriteLine("O valor da terceira linha terceira  coluna é -> {0}",minhamatriz[2,2]);

            }

}

Digite o exemplo da listagem 3.6 e salve o mesmo em um arquivo chamado ex6cap3.cs, na pasta C:\ExCsharp\cap3. Compile e execute o exemplo da listagem 3.6. Você obterá os resultados indicados na Figura 3.6.

Figura 3.6 Executando o programa ex6cap3.exe.

Os valores para a(s) dimensão(ões) de um array podem ser fornecidas pelo usuário, para que o mesmo seja criado com tamanhos variáveis, cada vez que o programa é executado. Por exemplo, vamos supor que o usuário tenha fornecido o valor 5 para a dimensão de um array e que este valor esteja em uma variável chamada dimenarray. Podemos criar, por exemplo, um array de inteiros com a dimensão definida pela variável dimenarray, utilizando o seguinte comando:

int[] arraydinamico = new int[dimenarray];

Apresentaremos mais alguns exemplos com arrays mais adiante neste capítulo, onde falaremos sobre as estruturas de controle do C#. Veremos alguns exemplos ao apresentarmos a estrutura de controle For, a qual é tipicamente utilizada para percorrer todos os elementos de um array.