Trabalhando com o Namespace System.Collections - Parte 1

Você precisa estar logado para dar um feedback. Clique aqui para efetuar o login
Para efetuar o download você precisa estar logado. Clique aqui para efetuar o login
Confirmar voto
0
 (0)  (0)

Composto por interfaces e classes responsáveis por definir coleções de objetos, o Namespace System.Collections é utilizado para trabalhar com diversas coleções de objetos, tais como listas, filas, arrays de bit, hashtables e dicionários.

por:André Ramos

Trabalhar com coleções de objetos é algo que os desenvolvedores geralmente necessitam em diversas partes dos projetos. Tirando o máximo de proveito da Base Class Library (BCL), podemos contar com o Namespace System.Collections, responsável por proporcionar flexibilidade quando necessitamos trabalhar com coleções, o que era um tanto quanto trabalhoso nas tecnologias passadas.

O Namespace System.Collections

Composto por interfaces e classes responsáveis por definir coleções de objetos, o Namespace System.Collections é utilizado para trabalhar com diversas coleções de objetos, tais como listas, filas, arrays de bit, hashtables e dicionários.

Vou demonstrar o manuseio de coleções com o conceito de cesta de compras onde, para tanto, será criada uma classe responsável por armazenar os dados básicos dos produtos que desejo comprar, tais como código, quantidade comprada e valor unitário, conforme a listagem 1.

using System;
namespace ItemCarrinho
{

      ///
      /// Classe responsável por armazenar dados
      /// que compõem itens do carrinho de compras.
     
///
      public class Produto
      {
            private int codigo;
           
private double quantidade;
           
private double valorUnitario;
           
// Construtor: Recebo código, quantidade e
            // valor unitário do meu item.
           
public Produto(int cod, double qtd, double               
              vUnit)
           
{
                  codigo = cod;
                  quantidade = qtd;
                  valorUnitario = vUnit;
            }
            // Propriedade referente ao código
           
// do item
            public int Codigo
            {
                  get
                  {
                        return codigo;
                  }
                  set
                  {
                       
codigo = value;
                  }
            }
            // Propriedade referente à quantidade
            // do item
            public double Quantidade
           
{
                  get
                  {

                        return quantidade;

                  }
                  set
                 
{
                        quantidade = value;
                  }
            }
            // Propriedade referente ao valor
            // unitário do item
            public double ValorUnitario
           
{
                  get
                  {
                        return valorUnitario;
                  }
                  set
                  {
                        valorUnitario = value;
                 
}
            }
      }
}


Listagem 1 - Classe responsável por representar itens a serem comprados

Meu carrinho de compras é, basicamente, a coleção dos itens que desejo comprar. A princípio deve-se criar um projeto Console Application, o qual irá conter a classe  Carrinho (Ver listagem 2) utilizada para manipular um objeto ArrayList, onde produtos serão armazenados. Para trabalhar com a classe Produto, deve-se adicionar às referências da aplicação o projeto que a contém.

using System;
using System.Collections;
using ItemCarrinho;
namespace ManipCollection
{
      ///
      /// Classe utilizada para manipular um ArrayList
      /// que armazena produtos.
     
///
      class Carrinho
      {
            ///
            /// The main entry point for the application.
            ///
            [STAThread]
            static void Main(string[] args)
           
{
                  // Declaro os objetos e variáveis
                      necessários
                 
ArrayList carrinhoCompras = new                     
                     ArrayList();
                 
Produto produto;
                  int i;
                  int codigoProduto;
                  double quantidadeProduto;
                  double valorUnitario;
                  // Populo a coleção "carrinhoCompras" com
                  // 10 produtos
                  for(i = 0; i < 10; i++)
                  {
                        codigoProduto = i + 1;
                        quantidadeProduto = ((i + 1) * 1.5 /
                          0.6);
                        valorUnitario = ((i + 1) * (5.9 /
                          0.7));
                        //Crio uma nova instância da classe Produto
                        produto = new Produto(codigoProduto,
                         quantidadeProduto,valorUnitario);
                        // Adiciono meu produto ao ArrayList
                        carrinhoCompras.Add(produto);
                  }
                  Console.WriteLine("Situação 1:");
                  ExibeCollection(carrinhoCompras);
                  // Crio uma nova instância da classe 
                   Produto
                  produto = new Produto(100, 2d, 48.75d);
                  // Substituo o produto que encontra-se na
                  // quinta posição do meu ArrayList pelo
                  // criado na linha acima
                  
carrinhoCompras[5] = produto;
                  Console.WriteLine("\nSituação 2:");
                  ExibeCollection(carrinhoCompras);
                  // Removo o primeiro elemento do meu
                 
// ArrayList
                  carrinhoCompras.RemoveAt(0);
                  Console.WriteLine("\nSituação 3:");
                  ExibeCollection(carrinhoCompras);
            }
           
// Método utilizado para exibir o conteúdo de
              determinado
            // ArrayList composto de objetos do tipo Produto
           
private static void ExibeCollection(ArrayList
               carrinhoCompras)
           
{
                  int i;
                  Console.WriteLine(
                    "Código\tQuantidade\tValor Unitário");
                 
for(i = 0; i < carrinhoCompras.Count; i++)
                  {                       
                     Console.WriteLine("{0}\t{1}\t\t{2}",
                     
((Produto)carrinhoCompras[i]).Codigo,
                      ((Produto)carrinhoCompras[i]).Quantidade,
                      ((Produto)carrinhoCompras[i]).ValorUnitario);
                  }
                  return;
            }
      }
}

Listagem 2 - Classe utilizada para manipular uma coleção de produtos

A correta execução deste exemplo tem como resultado a tela exibida na imagem 1 abaixo.

Imagem 1 - Resultado da execução do exemplo

Conclusão

Dependendo do emprego a ser dado às coleções, a complexidade quanto a seu uso em determinados projetos pode ser um tanto quanto preocupante pois, apesar da facilidade em seu manuseio, podemos cair em casos que necessitem um maior entendimento do desenvolvedor quanto este assunto. Abordarei em uma sequência de artigos as particularidades que podemos encontrar quando trabalhamos com o Namespace System.Collections.

Referência sobre o namespace System.Collections na MSDN Library:  http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfsystemcollections.asp

André Ramos, andrerms@hotmail.com Analista de Sistemas na Accenture, atua na área de TI há 7 anos com o desenvolvimento de sistemas em diferentes arquiteturas. Com experiência nas tecnologias Microsoft, desde o Visual Basic 4, possui sólidos conhecimentos nas plataformas .NET e Java. Escritor de crônicas nas horas vagas.

 
Você precisa estar logado para dar um feedback. Clique aqui para efetuar o login
Ficou com alguma dúvida?