C# - Operações com Collections(revisitado)

 Neste artigo vou apresentar algumas operações básicas usando Collections para recordar como interagir e usar esse importante recurso da linguagem C#.

O que é uma coleção e qual a diferença entre uma Collection e um Array ?

As coleções são estruturas de dados enumeráveis que podem ser acessadas usando índices e chaves.

Uma coleção também armazena um conjunto de valores da mesma forma que um array a diferença é que uma coleção armazena os elementos como Object. Portanto as coleções tem capacidade de colecionar itens do tipo Object.

As classes de coleções podem ser encontradas no namespace System.Collections e elas dão suporte a pilhas, filas, listas e hash tables.(stacks, queues, lists , hash tables)

A maioria das coleções implementam as mesmas interfaces e estas interfaces podem ser herdadas para criar classes de coleções mais especializadas.

Como funciona o armazenamento de elementos em uma coleção ?

Uma coleção armazena elementos como Object, assim se eu guardar um item do tipo String em uma coleção ela irá armazenar um object. Se for um integer a mesma coisa e assim por diante.

Com isto temos sempre que estar tipando manualmente cada item da coleção quando formos tratá-los. Desta forma quando eu coloco um item em uma coleção faço o boxing e quando eu retiro um item da coleção faço o unboxing.

  • Boxing: É a conversão de um Value Type para um Reference Type

  • Unboxing: É quando um Reference Type (object) volta a ser um Value Type

Dessa forma podemos enumerar algumas características das coleções:

  • As coleções aceitam qualquer tipo de dados (inteiros,strings,etc.);

  • As coleções fazem a conversão implícita dos tipos de dados para Object;

  • Ao tratarmos os itens das coleções temos que fazer o caminho de volta Object-> tipo-do-item via casting;

  • As coleções não exibem suas propriedades no intelissense;

  • O tamanho de uma coleção é gerenciado automaticamente de forma dinâmica;

  • As coleções possuem métodos que permitem incluir, alterar, remover , copiar, etc. seus elementos;

Após essa breve introdução vou mostrar inicializar e percorrer Collections.

Recursos Usados:

Criando o projeto no VS Community 2017

Abra no VS community 2017 e no menu File clique em New Project;

A seguir selecione o template Visual C# -> Windows -> Console Application e informe o nome cshp_Collections e clique em OK;

1- Inicializando e percorrendo Coleções do tipo List

Uma List é uma das classes de coleção genéricas do namespace System.Collection.Generic. Além dessa coleção temos também as seguintes coleções : Dictionary, Stack e Queue.

Diferentemente dos arrays uma List pode crescer de tamanho de forma dinâmica é do tipo genérico e fornece método para procurar, ordenar e manipular listas;

Abaixo temos um exemplo que inicializa e percorre coleções do tipo List:

using static System.Console;
using System.Collections.Generic;
namespace cshp_Collections
{
    class Gato
    {
        public string Nome { get; set; } = "Faisca";
        public int Idade { get; set; } = 9;
    }
    class Program
    {
        private static double CalculaImposto()
        {
                return 100 / 13;
        }
        static void Main(string[] args)
        {
            var numeros = new List<int> { 1, 2, 3, 4, 5 };
            var valores = new List<double> { 4 / 5, 13 % 3, 4.86, CalculaImposto() };
            var nomes = new List<string> { "João", "Maria", "Paulo", "Pedro", "Jose"};
            List<Gato> gatos = new List<Gato>
            {
                        new Gato(){ Nome = "Pipoca", Idade=8 },
                        new Gato(){ Nome = "Mimosa", Idade=2 },
                        new Gato(){ Nome = "Dengoso", Idade=14 },
                        null
            };

            Gato gato = new Gato();
            //exibe os valores inicializados da classe
            WriteLine(gato.Nome);
            WriteLine(gato.Idade);
            //percorre a coleção numeros
            foreach (int n in numeros)
                WriteLine(n);
            //percorre a coleção valores
            foreach (double v in valores)
                WriteLine(v);
            //percorre a coleção nomes
            foreach (string n in nomes)
                WriteLine(n);

            //percorre a coleção gatos
            foreach (Gato g in gatos)
                if (g != null)
                    WriteLine(g.Nome);
                else
                    WriteLine("O elmento da coleção possui um valor Nulo.");

              Readkey();
        }
    }
}
  
 

Neste código estamos inicializando algumas coleções e também usando algunas recursos da linguagem C# disponíveis a partir da versão 6.0 como a inicialização das propriedades da classe Gato e o uso da diretiva estática using static que torna os métodos estáticos disponíveis no escopo global.

Note que a sintaxe foi simplificada pelo uso do namespace using static System.Console, e assim, podemos usar apenas o nome do método WriteLine(), ReadKey().

Inicializamos assim 4 coleções do tipo List;

  1. numeros - uma coleção de inteiros;

  2. valores - uma coleção de double;

  3. nomes - uma coleção de strings;

  4. gatos - uma coleção de um tipo complexo , ou seja, uma coleção de objetos da classe Gato;

Para percorrer uma coleção usamos a instrução foreach que repete um grupo de instruções inseridas para cada elemento em uma matriz ou uma coleção de objetos que implementa a interface de System.Collections.IEnumerable ou de System.Collections.Generic.IEnumerable<T>

2- Inicializando e percorrendo Coleções do tipo Dictionary

A classe Dictionary esta definica no namespace System.Collections.Generic e é uma estrutura de dados que representa uma coleção de pares de dados compostos por chaves e valores.

Esta classe e implementa  a interface IDictionary que possui duas coleções no seu interior uma para guardar a chave e outra para guardar o valor.  (Uma HashTable não é um tipo genérico)

A classe genérica Dictionary é uma classe que mapeia um conjunto de chaves, as quais podem ser de qualquer tipo, para um conjunto de valores, que também podem ser de qualquer tipo sendo que os tipos da chave e o valor não precisam ser idênticos.

A sintaxe usada é a seguinte : Dictionary < TKey, TValue >

onde:

TKey - representa o tipo da chave no dicionário;
TValue - representa o tipo do valor no dicionário;

Assim a coleção Dictionary é uma coleção genérica de tipo que é informado no momento de definir a coleção. É uma coleção do tipo chave/valor onde a chave faz o papel do índice na coleção.

A seguir temos um exemplo que inicializa e percorre coleções do tipo Dictionary :

using static System.Console;
using System.Collections.Generic;
using System.Linq;
namespace Dictionary
{
    class Aluno
    {
        public string Nome { get; set; }
        public int Idade { get; set; }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Dictionary<string, int> dict = new Dictionary<string, int>();
            dict.Add("Segunda-feira", 1);
            dict.Add("Terça-feira", 2);
            dict.Add("Quarta-Feira", 3);
            dict.Add("Quinta-Feira", 4);
            dict.Add("Sexta-Feira", 5);
            dict.Add("Sabado", 6);
            dict.Add("Domingo", 7);
            //exibe a chave e o valor 
            foreach (var item in dict)
            {
                WriteLine(item.Key + "   " + item.Value);
            }
            //outra sintaxe para exibir chave e valor
            foreach (KeyValuePair<string, int> item in dict)
            {
                WriteLine("{0} - {1}", item.Key, item.Value);
            }
            //retorna o valor das chaves
            foreach (var key in dict.Keys)
            {
                WriteLine(key);
            }
            //retorna o valor dos valores
            foreach (var value in dict.Values)
            {
                WriteLine(value.ToString());
            }
            //Exibindo dados do dictionary ordenados por valor
            foreach (var item in dict.OrderByDescending(r => r.Value))
            {
                WriteLine("Chave: {0}, Valor: {1}", item.Key, item.Value);
            }
            //popula um Dictionary com objetos
            Dictionary<int, Aluno> alunos = new Dictionary<int, Aluno>()
            {
               { 101, new Aluno {Nome="Sabrina", Idade=22}},
               { 102, new Aluno {Nome="Diana", Idade =18}},
               { 103, new Aluno {Nome="Antonior", Idade=21}}
            };
            //percorre o dictionary
            foreach(var item in alunos)
            {
                WriteLine(item.Key + "   " + item.Value.Nome + " " + item.Value.Idade);
            }
            ReadKey();
        }
    }
}
  
 

Recordamos assim como podemos popular e iterar sobre as coleções List e Dictionary.

Mas longe esteja de mim gloriar-me, a não ser na cruz de nosso Senhor Jesus Cristo, pela qual o mundo está crucificado para mim e eu para o mundo. 
 Gálatas 6:14

Veja os Destaques e novidades do SUPER DVD Visual Basic (sempre atualizado) : clique e confira !

Quer migrar para o VB .NET ?

Quer aprender C# ??

Quer aprender os conceitos da Programação Orientada a objetos ?

Quer aprender o gerar relatórios com o ReportViewer no VS 2013 ?

  Gostou ?   Compartilhe no Facebook   Compartilhe no Twitter

Referências:

José Carlos Macoratti