Ola, Amigos.

Iniciaremos este tutorial falando sobre classe List<T> do namespace System.Collection.Generics ou também podemos falar objetos do tipo genérico.  O List<T> exige que especifique um único valor que descreva o tipo de item sobre o qual List<T> devera trabalhar ou armazenar. Portando se desejar criar três objetos List<T> para conter inteiros e os objetos SportCar() e Person(), terá que escrever o seguinte:

static void Main()
{
    List<int> MyInt = new List<int>();
    List<SportCar> MyCars = new List<SportCar>();           
    List<Person> MyPeople = new List<Person>();
}

Bom, no exemplo acima vemos como declarar um objeto do tipo List<T> e especificar o tipo que iremos objeto que este ira armazenar, podemos dizer que a classe List<T> é uma classe que pode armazenar vários tipos de objetos instanciados na memoria. Vejamos o exemplo abaixo:

private void addSportCarInList()
{
    SportCar MyCar = new SportCar();
   
    MyCar.returnModel = "Mazda";
    MyCar.returnColor = "White";
    MyCar.returnMaxSpeed = 210;

    List<SportCar> MyCars = List<SportCar>();
    MyCars.Add(MyCar);
}

No exemplo acima, nos criamos um objeto do tipo SportCar() e atribuímos as propriedades da classe que são: Modelo, Cor e Velocidade máxima, o valores que desejamos. Após isso criamos um objeto do tipo List<T> onde <T> nesta questão é do tipo SportCar ou seja <SportCar>.

No código acima nos podemos falar que o objeto List<SportCar> contem dentro de si uma instancia só do tipo SportCar, resumindo dentro de nossa Lista temos uma instancia de uma objeto Carro esportivo podemos comprovar isso pelo código abaixo:

MessageBox.Show("Total de carros em minha lista {0}", MyCars.Count);

No exemplo abaixo iremos adicionar vários carros em nossa lista de carros consequentemente no mundo POO (programação orientada a objeto) para cada carro iremos criar uma instancia. Vejamos no Exemplo:

private void addFiveSportCarInList()
{
    // Car 1
    SportCar MyCar1 = new SportCar();

    MyCar1.returnModel = "Mazda";
    MyCar1.returnColor = "White";
    MyCar1.returnMaxSpeed = 210;

    // Car 2
    SportCar MyCar2 = new SportCar();

    MyCar2.returnModel = "Subaru";
    MyCar2.returnColor = "Red";
    MyCar2.returnMaxSpeed = 180;

    // Car 3
    SportCar MyCar3 = new SportCar();

    MyCar3.returnModel = "Volvo";
    MyCar3.returnColor = "Green";
    MyCar3.returnMaxSpeed = 200;
   
    // Car 4
    SportCar MyCar4 = new SportCar();

    MyCar4.returnModel = "Volkswagen";
    MyCar4.returnColor = "Black";
    MyCar4.returnMaxSpeed = 240;
   
    // Car 5
    SportCar MyCar5 = new SportCar();

    MyCar5.returnModel = "Ferrari";
    MyCar5.returnColor = "Silver";
    MyCar5.returnMaxSpeed = 210;

    List<SportCar> MyCars = List<SportCar>();
    MyCars.Add(MyCar);

    MessageBox.Show("Total de carros em minha lista {0}", MyCars.Count);
}

Também podemos acessar métodos e propriedades do objeto SportCar() armazenado dentro de nossa lista, podemos fazer isso percorrendo nossa List<SportCar>, através de uma laço de repetição for, while, do while etc. visto que é uma lista ou também coleção de objetos. Vejamos o exemplo abaixo:

int i = 0;
for (i = 0; i <= MyCars.Count - 1; i++)
{
    MessageBox.Show("Carro número {0} sua marca é: {1}", i.ToString(), MyCars[i].returnModel.ToString());
}

 
No código acima fazemos um laço de repetição “for” para contar nossa lista de carros e exibir o modelo de cada um deles, no caso acima igualamos nossa variável “i” igual a zero só que para uma lista a qual estamos trabalhando ou um Array (vetor) a quantidade de objetos dentro sempre se inicia em um e não em zero, é por esse motivo que colocamos no meio de laço “for”

i <= MyCars.Count - 1

O total de itens da nossa lista menos um, isso por que nosso contador “i” é iniciado em zero.  Vale apena lembrar que a ordem em que instanciamos os objetos do mesmo tipo é a mesma ordem que esta armazenado dentro do objeto List<SportCar>.

Podemos dizer então que no caso acima em que adicionamos cinco carros em nossa lista o primeiro que instanciamos a marca dele é Mazda, pois é esse é o primeiro da nossa lista, como no exemplo do laço podemos perceber que o nome do primeiro carro que aparece no laço é o da marca Mazda, e assim por diante, como na ordem de instanciação.

Podemos também remover objetos desta lista usando o método Remove de nossa lista criada.
Vejamos no exemplo:

int i = 0;
for (i = 0; i <= MyCars.Count - 1; i++)
{
    if (MyCars[i].returnModel == "Volvo")
    {
        SportCar MyCarRemove = MyCars[i];
        MyCars.Remove(MyCarRemove);

        MessageBox.Show("Carro removido da lista");
    }   
}

No código acima nos removemos de nossa lista de carros, o carro de marca “Volvo” podemos perceber que nos criamos um objeto, mas não instanciamos um novo usando a sintaxe new e assim criamos uma variável do tipo SportCar e igualamos essa variável a um carro que estava dentro de nossa lista, esta ai o motivo por que não precisamos instanciar e sim só referenciamos a um que já estava lá dentro na nossa lista e depois passamos a variável ou objeto do tipo SportCar para a lista através do método remove, e esse método é o que ira remover o carro da marca Volvo da nossa lista.

Para limpar uma lista com vários objetos dentro podemos usar o método Clear, podemos limpar a lista como no exemplo abaixo:

MyCars.Clear();

O método acima limpa todas as instancias de objetos que a lista aceita que por ventura esteja carregada. Como vimos à coleção de genéricos do framework dot net permite dar soluções para eventuais problemas de desenvolvimento de softwares de nosso dia-a-dia. Além disso, os tipos genéricos geralmente excluem a necessidade de construir tipos de coleção personalizados.

Podemos utilizar List<T> em inumeráveis situações no desenvolvimento de software seja desktop ou web uma situação ótima para citar a inclusão de uma Lista seria implementar um carrinho de compras para um sistema de e-commerce.

Espero que tenham gostado deste post, pois em minhas horas de desenvolvimento de software sempre estou utilizando generics, collections entre estes a classe List<T>, sempre para guardar objetos fortemente tipados do projeto em que estou trabalhando.

Até o próximo post.