Arrays são objetos que armazenam múltiplas variáveis de um mesmo tipo, eles são muito úteis quando trabalhamos com coleções de dados que possuem um tamanho previamente definido.

É comum encontrar muitos desenvolvedores que estejam iniciando na área de T.I com vários questionamentos sobre a utilização de um objeto array, no entanto o array é apenas uma classe como qualquer outra que possui propriedades e métodos. A classe Array herda de Object(uma vez que todos os objetos herdam dessa classe), ou seja, os métodos públicos declarados na classe pai, podem ser acessados sem problemas na classe filha.

Todo array inicia-se a partir da posição zero, ou seja, se criarmos um objeto e definirmos com o tamanho de 5 elementos, o último índice será o de valor quatro e não cinco. Se tentarmos acessar o índice cinco em um array de 5 elementos, receberemos uma exceção em tempo de execução: System.IndexOutOfRangeException.

Como foi visto anteriormente o array é uma coleção de objetos de um determinado tipo, por exemplo em vez de declararmos vinte variáveis do tipo int, nós podemos criar um array contendo vinte posições e acessá-las a partir do seu índice.

Listagem 1: Declaração de um array.


//VÁLIDO, PORÉM MENOS LEGÍVEL POIS SEMPRE SERÁ PRECISO DECLARAR    UMA  NOVA VARIÁVEL
int a = 0;
int b = 0;
int c = 0;
int d = 0;
int e = 0;
//SEMPRE QUE PRECISAR DE UM NOVO ELEMENTO, SERA NECESSÁRIO O INCREMENTO DO TAMANHO
int[] arrayint = new int[5];

Analisando as duas formas de se criar variáveis do tipo inteiro, podemos perceber que na primeira forma será preciso criar sempre uma nova variável e isso torna a aplicação muito dependente do programador, pois se o número de objetos for menor que a demanda, além do sistema não funcionar corretamente, a equipe do desenvolvimento será sempre acionada. Na segunda forma possuímos mais dinamismo, porém o tamanho ainda é estático, então se o número de demandas for maior que o tamanho declarado no array, será preciso também a intervenção do desenvolvedor. No entanto podemos encontrar algumas vantagens, observemos que apenas em uma linha o array foi declarado, instanciado e todos os elementos do objeto já foram inicializados com o seu valor padrão.

OBSERVAÇÃO: existem outras formas mais eficientes de se trabalhar com coleções de dados. Quando fazemos uma chamada ao namespace System.Collections.Generic possuímos uma série de classes e interfaces como List<>,Dictionary que proveem uma maior performance e segurança que os arrays propriamente ditos.

Criação de um array em tempo de execução

Figura 1: Criação de um array em tempo de execução

Mais em:
Performance .NET: Arrays em C# (csharp)
Array Simples, Array Collections e Array Bidimencional no C# 4.0

Como criamos um array de números primitivos do tipo int, todos os elementos receberam o valor default de zero. Lembrando que os elementos só possuem um valor padrão porque utilizamos a palavra reservada new, do contrário o array teria sido apenas declarado.

Listagem 2: Alguns tipos de array.


int[] arrayint = new int[5];//VALOR PADRÃO = 0
           
string[] arraystring = new string[5];//VALOR PADRÃO = ""
           
bool[] arrayboolean = new bool[5];//VALOR PADRÃO = FALSE
            
double[] arraydouble = new double[5];//VALOR PADRÃO = 0.0

ClasseArray[] arrayClasse = new ClasseArray[5];//VALOR PADRÃO = NULL

Como podemos ver, o código acima demonstra que é possível criar arrays de diferentes tipos. No entanto cada array deve receber apenas valores do tipo do qual está sendo declarado, a não ser que os tipos de dados sejam semelhantes e automaticamente aconteça uma conversão implícita. Caso o tipo do array não comporte o tipo de dados que esteja recebendo, é possível utilizar a conversão explicita.

Listagem 2: Conversões implicitas e explicitas


short s = 3;
int[] arrayint = new int[5];
           
arrayint[0]=s; // Conversão implicita
arrayint[1] =(int) 33.0;// Conversão explicita

No exemplo acima podemos acompanhar uma das tarefas mais comuns na vida do desenvolvedor, a conversão de dados. Também podemos ver como é possível acessar as posições de um array a partir dos seus índices. Vamos analisar como o nosso array de inteiros está no momento.

Conversão de valores em um array de inteiros

Figura 2: Conversão de valores em um array de inteiros

APLICAÇÃO WEB UTILIZANDO ARRAYS

A aplicação a ser desenvolvida será apenas para fins didáticos, ela terá uma interface bem simples e de fácil usabilidade. O foco do sistema é abordar os conceitos previamente vistos e mostrar o seu uso na prática. No entanto, não veremos a conversão de dados, pois utilizaremos apenas um array de strings e isso não será necessário para o nosso projeto.

O projeto será um sistema que possui uma pequena lista de alguns jogos de Xbox, e a partir dele seja possível selecionar os itens desejáveis, adicionar, ordenar, remover e no final será mostrado uma relação dos jogos adquiridos.

O sistema foi desenvolvido em uma interface web Asp.net com a linguagem de programação C# utilizando o IDE Visual Studio 2010.

Layout da aplicação

Figura 3: Layout da aplicação

Listagem 3: Array de jogos XBOX



string[] jogos = {  "Resident Evil  6", "Max Payne 3", "Grand Thef Auto IV",  "Street Fighter IV " };

Essa será a coleção de dados que iremos trabalhar ao longo do projeto. A partir dela conseguiremos manipular as informações conforme desejarmos. Veja que na declaração do array não foi definido o tamanho e alguns valores padrões já foram adicionados, isso é uma forma alternativa válida de criar e instanciar arrays.

OBSERVAÇÃO: observe que a palavra new não precisou ser utilizada.

Listagem 4: Funcionalidades do sistema


protected void Adicionar_Click(object sender, EventArgs e)
{
 //ADICIONAR JOGOS
}

protected void Remover_Click(object sender, EventArgs e)
{
 //REMOVER JOGOS
}

protected void Ordenar_Click(object sender, EventArgs e)
{
 //ORDENAR JOGOS
}

protected void MostrarRelacao_Click(object sender, EventArgs e)
{
 //MOSTRAR RELAÇÃO
}

O sistema possuirá apenas as quatro funcionalidades citadas acima, em cada uma delas será preciso utilizar estruturas de repetição e de decisão, para podermos implementar a lógica do sistema.

COMPONENTES UTILIZADOS

CONTROLESID
ButtonAdicionar
ButtonRemover
ButtonOrdenar
ButtonMostrarRelacao
ListBoxListaComp
ListBoxListVend
LabelRelacao

Tabela 1: Controles do sistema.

Na tabela acima podemos ver todos os controles utilizados para o nosso projeto e o seus respectivos identificadores(ids), será a partir deles que teremos acesso às propriedades dos objetos.

Antes de começarmos a implementar o nosso sistema, devemos fazer alguns pequenos ajustes.

Alterando Propriedades

Figura 4: Alterando Propriedades

Para podermos realizar múltiplas seleções com o controle ListBox, devemos alterar a propriedade SelectionMode para Multiple, do contrário apenas seleções simples serão possíveis. É necessário que tanto ListaComp como ListVenda possuam essa propriedade alterada, pois além de inserções múltiplas, faremos o mesmo processo com a remoção. A propriedade text da label Relacao deve estar vazia.

CARREGANDO PÁGINA PADRÃO

Preechendo o ListaComp

Figura 5: Preechendo o ListaComp

Logo acima podemos ver nosso ListBox principal preenchido com os valores que declaramos no array, para isso acontecer precisamos ter alguns cuidados, é preciso entender como funcionam as páginas asp.net.

No codebehind de uma página ASP.net, possuímos acesso ao evento Page_Load, que como o próprio nome já diz, é o evento que carrega a página.

Listagem 5: Carregando informações iniciais


protected void Page_Load(object sender, EventArgs e)
{           
if (!Page.IsPostBack) {
ListaComp.DataSource = jogos;
             ListaComp.DataBind();
}
}

OBSERVAÇÃO: o nosso lisbox será preenchido uma única vez, por isso utilizamos a propriedade IsPostBack, de forma negativa. Se não fizermos esse tipo de verificação, o listbox será sempre populado através de uma solicitação.

Preechendo o ListaComp

Figura 6: Preechendo o ListaComp

Veja que o botão adicionar, realmente está enviando somente as informações selecionadas para a ListVend.

Listagem 6: Adicionando Jogos


protected void Adicionar_Click(object sender, EventArgs e)
{
foreach (ListItem linha in ListaComp.Items)
       {
       	if( linha.Selected==true && !ListVend.Items.Contains(linha)){
                ListVend.Items.Add(linha);
             }
}
}

Primeiramente precisamos ter conhecimento de todas os elementos contidos na ListaComp e depois verificar quais elementos estão selecionados, para isso precisamos utilizar estruturas de repetição e condição.

A lógica é a seguinte: se a seleção que fazemos no ListaComp for verdadeira e os itens selecionados não estiverem contidos na ListVend, então adicione os itens.

Selecionado para Remoção

Figura 7: Selecionado para Remoção

Removendo itens

Figura 8: Removendo itens

Listagem 6: Removendo Jogos

 
protected void Remover_Click(object sender, EventArgs e)
{
       while (ListVend.SelectedItem != null)
       {
       	if (ListVend.SelectedItem.Selected == true)
             {
             		ListVend.Items.Remove(ListVend.SelectedItem);
                    
             }
             Relacao.Text = "";
}
}

Para removermos algum item, precisamos antes de tudo verificar se a seleção contida não é nula. Após essa verificação é possível realizar a remoção dos itens.

CONCLUSÃO

Espero que os conceitos mostrados no artigo tenham ficado bem compreensíveis para aquelas pessoas que estão iniciando no desenvolvimento de aplicações com .NET.

A ideia foi criar uma aplicação bem simples e de uso prático. Obviamente não foram utilizadas técnicas avançadas e também boas práticas de desenvolvimento e construção de layout. O foco foi apenas mostrar onde podemos utilizar arrrays na prática.

Obrigado e até o próximo artigo.