C# - Comparando IList<T> com List<T>

 Neste artigo eu fazer algumas comparações entre a interface genérica IList<T> e a classe genérica List<T>.

A interface IList  é uma coleção de objetos não genéricos que podem ser individualmente acessada pelo índice. A interface IList é implementada a partir das interfaces : ICollection e IEnumerable.

Por natureza IList armazena sempre object. Assim mesmo inicializando com um valor inteiro o valor será armazenado como object.

A interface IList<T> é a coleção de objetos genéricos representados pelo tipo T e implementa diversas interfaces incluindo a interface IList.

Em uma interface IList<T> podemos usar somente o tipo definido por T enquanto que em uma interface IList<> podemos usar diferentes tipos de objetos.

Nota : A razão pela qual List<T> implementa tanto IList<T> como IList é torná-la utilizável em qualquer lugar no seu código onde esta assumindo um IList.

A interface genérica IList<T> é descendente da interface ICollection<T> e é a interface base de todas as listas genéricas.

Assim IList<T> é uma interface implementada por List<T> então lembre-se que você não pode criar uma instância de uma interface logo temos que:

//Não vai compilar
IList<Cliente> listaCliente = new IList<Cliente>();
 

//Vai compilar
List<Cliente> listaCliente = new List<Cliente>();
 

//Também vai compilar
IList<Cliente> listaCliente = new List<Cliente>();
 

A seguir temos as  propriedades da interface IList<T> :

Nome Descrição
Count Obtém o número de elementos contidos em ICollection<T>.
IsReadOnly Obtém um valor indicando se a ICollection<T> é somente leitura.
Item Obtém ou define o elemento no índice especificado.

Os métodos desta interface são:

Nome Descrição
Add Adiciona um item para o ICollection<T>.
Clear Remove todos os itens a partir do ICollection<T>.
Contains Determina se a ICollection<T> contém um valor específico.
CopyTo Copia os elementos da ICollection<T> para um Array, iniciando em um determinado índice.
GetEnumerator Retorna um enumerador que itera pela coleção. (Herdado de IEnumerable<T>.)
IndexOf Determina o índice de um item específico na IList<T>.
Insert Insere um item para o IList<T> no índice especificado.
Remove Remove a primeira ocorrência de um objeto específico a partir do ICollection<T>. (Herdado de ICollection<T>.)
RemoveAt Remove o item IList<T> no índice especificado.

Além disso a interface IList<T> possui dezenas de métodos de extensão como :  Aggregate<T>(Func<T, T, T>), AsEnumerable<T> , AsQueryable() , Contains<T>(T), First<T>() , GroupBy<T, TKey>(Func<T, TKey>), Intersect<T>(IEnumerable<T>), etc.

Listas e arrays implementam IList. Esta interface é uma abstração que permite que os tipos de lista possam ser usados através de um único tipo de referência. Com ele, podemos criar um método único para receber um int[] ou um List<int>.

Abaixo vemos um exemplo de utilização básica da interface List<T> :

using System;
using System.Collections.Generic;
namespace CSharp_IList
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] array = new int[3];
            array[0] = 1;
            array[1] = 2;
            array[2] = 3;
            Exibir(array);
            List<int> lista = new List<int>();
            lista.Add(5);
            lista.Add(7);
            lista.Add(9);
            Exibir(lista);
        }
        static void Exibir(IList<int> lista)
        {
            Console.WriteLine("Count = {0}", lista.Count);
            foreach (int valor in lista)
            {
                Console.WriteLine(valor);
            }
            Console.Readkey();
        }
    }
}
 
Module Module1
    Sub Main()
        Dim array(2) As Integer
        array(0) = 1
        array(1) = 2
        array(2) = 3
        Exibir(array)
        Dim lista As New List(Of Integer)()
        lista.Add(5)
        lista.Add(7)
        lista.Add(9)
        Exibir(lista)
    End Sub
    Private Sub Exibir(ByVal lista As IList(Of Integer))
        Console.WriteLine("Count =  {0}", lista.Count)
        For Each valor As Integer In lista
            Console.WriteLine(valor)
        Next valor
        Console.ReadKey()
    End Sub

End Module

 

  

 

Basicamente, IList<T> pode por implementada por qualquer classe (inclusive por List<>). Portanto, usar IList<T> para os parâmetros e propriedades torna o acoplamento mais baixo, o que geralmente é uma coisa boa.

Se você esta expondo suas classes através de uma library que outros irão usar, é melhor expor suas classes via interfaces (IList<T>) do que implementações concretas, ou seja, usando List<T>.

Então qual devo usar ?

IList<T> ou List<T> ?

Nota: Considere o princípio:  "dependa sempre de uma abstração e não de uma implementação";

João 5:24 Na verdade, na verdade vos digo que quem ouve a minha palavra, e crê naquele que me enviou, tem a vida eterna, e não entrará em condenação, mas passou da morte para a vida.

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