[MEU 50º LIVRO]: BANCOS DE DADOS E ACESS - CURSO COMPLETO - DO BÁSICO AO VBA - 1602 páginas

Páginas: 1602 | Autor: Júlio Battisti | 40% de Desconto e 70h de Vídeo Aulas de Bônus

Você está em: PrincipalArtigosASP.NET › Capítulo 03 : 04
Quer receber novidades e e-books gratuitos?
›››
  « Lição anterior Δ Página principal ¤ Capítulos Próxima lição »
ASP.NET - CURSO COMPLETO
Autor: Júlio Battisti


Promoção: Livro Windows Server 2012 R2 e Active Directory - Curso Completo, 2100 Páginas. Tudo para você se tornar um administrador de redes altamente qualificado para o mercado de trabalho e levar a sua carreira para o próximo nível!

Promoção: Livro Windows Server 2012 R2 e Active Directory

Curso Completo, 2100 páginas. Tudo para você se tornar um administrador de redes altamente qualificado para o mercado de trabalho e levar a sua carreira para o próximo nível!


Lição 029 - Capítulo 03 - Tipos da linguagem C#

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.

Curso Completo de ASP.NET - Júlio Battisti
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.

Tipo Alias no C# Descrição
System.Byte byte

Byte de 8 bits, sem sinal. Valor variando entre 0 e 255.

System.SByte sbyte Byte de 8 bits, com sinal. Valor variando entre -128 e 127.
System.Int16 short Inteiro de 16 bits, com sinal. Valor variando entre –32.768 e 32.767.
System.UInt16 ushort Inteiro de 16 bits, sem sinal. Valor variando entre 0 e 65.535.
System.Int32 int Inteiro de 32 bits, com sinal. Valor variando entre  -2.147.438.648 e 2.147.438.647.
System.UInt32 uint Inteiro de 32 bits, sem sinal. Valor variando entre  0 e 4.294.967.295.
System.Int64 uint Inteiro de 64 bits, com sinal. Valor variando entre  -9.223.372.036.854.775.808  e 9.223.372.036.854.775.807.
System.UInt64 ulong Inteiro de 64 bits, sem sinal. Valor variando entre  0 e 184.467.440.737.095.551.615.
System.Char char Um único caractere unicode com 16 bits.
System.Single float Real de 32 bits, com sinal. Valor variando entre -3,402823E38 e 3,402823E38.
System.Double double Real de 64 bits, com sinal. Valor variando entre  -1,79769313486232E308 e 1,79769313486232E308.
System.Boolean bool Pode conter os valores True ou False.
System.Decimal decimal Real de 128 bits, com sinal. Valor variando entre -79.228.162.514.264.337.593.543.950.335 e 79.228.162.514.264.337.593.543.950.335.

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.

Curso Completo de ASP.NET - Júlio Battisti
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.

Curso Completo de ASP.NET - Júlio Battisti
Figura 3.4 Executando o programa ex4cap3.exe.

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

Método Descrição
Compare()

Utilizado para comparar o valor de duas strings. Recebe como parâmetros duas string: Compare(str1,str2).

Retorna um valor inteiro de 32 bits, com sinal. Se for menor do que zero, str1 é menor do que str2. Por exemplo: José é menor do que Pedro, conta a ordem alfabética. Se for igual a zero str1 é igual a str2 e se for maior do que zero, str1 é maior do que str2.

CompareOrdinal()

Compara strings desconsiderando diferenças entre idiomas, ou seja, faz uma comparação posição a posição da string. Recebe como parâmetros duas strings.

CompareTo()

Compara uma string com a instância de um objeto recebido como parâmetro, sendo que este objeto deve ser capaz de ser avaliado como uma string.

EndsWith()

Utilizada para verifica se uma substring existe no final de uma string.

Concat()

Concatena duas ou mais strings passadas como parâmetros. Também podem ser passados objetos como parâmetros, desde que os mesmos possam ser avaliados como strings.

Replace()

Substitui todas as ocorrências de um determinado caractere por outro caractere.

ToLower() Converte a string para letras minúsculas.
ToUpper() Converte a string para letras maiúsculas.
Trim() Remove os espaços em branco de uma 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.

Curso Completo de ASP.NET - Júlio Battisti
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.

Curso Completo de ASP.NET - Júlio Battisti
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.


Promoção: Livro Windows Server 2012 R2 e Active Directory - Curso Completo, 2100 Páginas. Tudo para você se tornar um administrador de redes altamente qualificado para o mercado de trabalho e levar a sua carreira para o próximo nível!

Promoção: Livro Windows Server 2012 R2 e Active Directory

Curso Completo, 2100 páginas. Tudo para você se tornar um administrador de redes altamente qualificado para o mercado de trabalho e levar a sua carreira para o próximo nível!


  « Lição anterior Δ Página principal ¤ Capítulos Próxima lição »

Best Sellers de Programação do Julio Battisti

Todos com Vídeo Aulas, E-books ou Exemplos de Brinde!

Aprenda com Júlio Battisti: SQL Server 2008 R2

 

Autor: Júlio Battisti | Páginas: 1164 | Editora: Instituto Alpha

 

Macros e Programação VBA no Excel 2010

 

Autor: Júlio Battisti | Páginas: 1124 | Editora: Instituto Alpha

 

Access 2010 Avançado, Macros e Programação VBA - Passo a Passo

 

Autor: Júlio Battisti | Páginas: 828 | Editora: Instituto Alpha

 

 

Todos os livros com dezenas de horas de vídeo aulas de bônus, preço especial (alguns com 50% de desconto). Aproveite. São poucas unidades de cada livro e por tempo limitado.

Dúvidas?

Utilize a área de comentários a seguir.

Me ajude a divulgar este conteúdo gratuito!

Use a área de comentários a seguir, diga o que achou desta lição, o que está achando do curso.
Compartilhe no Facebook, no Google+, Twitter e Pinterest.

Indique para seus amigos. Quanto mais comentários forem feitos, mais lições serão publicadas.

Quer receber novidades e e-books gratuitos?
›››

Novidades e E-books grátis

Fique por dentro das novidades, lançamento de livros, cursos, e-books e vídeo-aulas, e receba ofertas de e-books e vídeo-aulas gratuitas para download.



Institucional

  • Quem somos
  • Garantia de Entrega
  • Formas de Pagamento
  • Contato
  • O Autor
  • Endereço

  • Júlio Battisti Livros e Cursos Ltda
  • CNPJ: 08.916.484/0001-25
  • Rua Vereador Ivo Cláudio Weigel, 537 Universitário
  • Santa Cruz do Sul/RS
  • CEP 96816-208
  • Todos os direitos reservados, Júlio Battisti 2001-2017 ®

    [LIVRO]: MACROS E PROGRAMAÇÃO VBA NO EXCEL 2010 - PASSO-A-PASSO

    APRENDA COM JULIO BATTISTI - 1124 PÁGINAS: CLIQUE AQUI