List em C# é uma estrutura de dados ou coleção dinâmica fortemente tipada com suporte a Generics.

Algumas características:

1. Pertence ao namespace System.Collections.Generic
2. Fortemente tipada
3. Aceita elementos repetidos
4. Suporta dados heregêneos, se Object utilizado
5. Elementos acessados com []

As operações mais complexas que envolvem List, devem ser realizadas utilizando os métodos da classe Métodos da classe List.

A declaração de uma List em C# é feita utilizando um tipo de dado desejado para armazenar nossos elementos. Esse tipo é informado como na sintaxe abaixo:

Sintaxe: Iniciado

List<tipo_dado> var_list; //não iniciada;

List<tipo_dado> var_list = null; //nula

List<tipo_dado> var_list = new <List<tipo_dado>{ elem1, elem2, elemN };

List<tipo_dado> var_list = new <List<tipo_dado>(); //vazia

List<tipo_dado> var_list = new() //vazia

List<tipo_dado> var_list = [elem1, elem2, elem3];

Uma List com valores iniciados devem ter seus valores, baseados no tipo de dado utilizado, delimitados por { e }, separados por (,) e terminada com (;):

Exemplo 1

using System;
using System.Collections.Generic;

public class Program 
{
  static void Main() 
  {
    List<int> lst1; //null
    List<int> lst2 = new List<int>{ 1,2,3};
    List<int> lst3 = new List<int>();

    List<int> lst3 = new(); //C# 9+
    List<int> lst3 = [1,2,3];
  }
}

Saída

-

O tipo de dado int foi utilizado no exemplo acima, mas outros tipos de dados podem também serem utilizados como outros tipos primitivos, tipos da biblioteca .NET ou definidos pelo usuário.

O acesso aos elementos de uma List é feito utilizando o seus índices como argumentos que são passados como argumentos para o indexador [].

A alteração é feita atribuíndo um novo valor ao elemento identificado pelo seu índice ou posição utilizando o indexador mencionado acima.

Sintaxe

objeto_list[indice] = valor; //alteração

objeto_list[indice]; //acesso

Exemplo 2

using System;
using System.Collections.Generic;

public class Program 
{
  static void Main() 
  {
    List<int> lst2 = new List<int>{ 1,2,3};
    
    Console.WriteLine(lst2[1]);
    lst2[1] = 4;
    Console.WriteLine(lst2[1]);
  }
}
            

Saída

2
4

Utilizando a propriedade Count de uma List, podemos ter conhecimento da quantidade de elementos que essa possui. Abaixo, a sintaxe do uso da propriedade mencionada:

Sintaxe

objeto_list.Count;

Exemplo 3

using System;
using System.Collections.Generic;

public class Program 
{
  static void Main() 
  {
    List<int> lst2 = new List<int>{ 1,2,3};
    
    Console.WriteLine(lst2.Count);
  }
}

Saída

3

Para iterarmos ou percorrermos os elementos contidos em uma List, podemos utilizar o comando foreach que foi estudado em C# Básico: Comandos de repetição.

Exemplo 4

using System;
using System.Collections.Generic;

public class Program 
{
  static void Main() 
  {
    List<int> lst2 = new List<int>{ 1,2,3};
    
    foreach( int el in lst2)
        Console.Write(el);
  }
}

Saída

123

Para adicionar novos elementos em uma List, usamos o método Add que recebe um elemento como argumento. Esse elemento será adicionado no fim da List.

Para adicionarmos um novo elemento em uma posição ou índice arbitrário, utilizamos o método Insert que recebe um elemento e sua posição como argumentos.

Sintaxe

objeto_list.Add(elemento);

objeto_list.Insert(elemento, indice);

Onde

-

Exemplo 5

using System;
using System.Collections.Generic;

public class Program 
{
  static void Main() 
  {
    List<int> lst2 = new List<int>();
    
    lst2.Add(0);
    lst2.Add(1);
    lst2.Add(2);
    
    Console.WriteLine(lst2.Count);

    lst.Insert(7,0);

    foreach( int el in lst)
        Console.Write(el);
    
  }
}

Saída

3
7012

Para remover elementos de uma List, fazemos uso dos métodos Remove ou RemoveAt quem recebem um elemento e um índice respectivamente para que a remoção seja feita.

Sintaxe

objeto_list.Remove(elemento);

objeto_list.RemoveAt(indice);

Onde

-

Exemplo 6

using System;
using System.Collections.Generic;

public class Program 
{
  static void Main() 
  {
    List<int> lst2 = new List<int>(){1,2,3};
    
    Console.WriteLine(lst2.Count);
    lst2.Remove(1);
    Console.WriteLine(lst2.Count);
  }
}

Saída

2

Para verificar se um determinado elemento está contido em uma List, utilizamos o métodos Contains quem recebe o elemento que checar como argumento.

Sintaxe

objeto_list.Constains(elemento);

Onde

-

Retorno

true se elemento está contido, false caso contrário.

Exemplo 5

using System;
using System.Collections.Generic;

public class Program 
{
  static void Main() 
  {
    List<int> lst2 = new List<int>(){1,2,3};
    
    Console.WriteLine(lst2.Count);
    lst2.Remove(1);
    Console.WriteLine(lst2.Count);
  }
}

Saída

True

Para verificar verificar se uma lista está vazia, utilizando o método Count estudado acima. Na possibilidade de uma List estar nula, fazemos a validação a comparando com null.

Sintaxe

objeto_list == null;

objeto_list != null;

Exemplo 5.1

using System;
using System.Collections.Generic;
public class Program
{
	public static void Main()
	{
		List lst = new();	
		List lst2 = null;
		    
		Console.WriteLine(lst.Count); //vazia
		Console.WriteLine(lst == null);
		Console.WriteLine(lst2 == null);

	}
}

Saída

0
False
True

A classe List fornecida pelo .NET, fornece um conjunto de Propriedades para a recuperação de suas informações internas.

Tab. 1: Propriedades

Método	Descrição
Item[indice]	Atribui ou recupera os itens da list	Visitar
Count	Retorna número de elementos	Visitar
Capacity	Atribui ou recupera capacidade sem redimensionar	Visitar

Sintaxe

objeto_dict.Nome_propriedade;

Exemplo

using System;
using System.Collections.Generic;

public class Program 
{
  static void Main() 
  {
    List lst2 = new List(){1,2,3};
    
    Console.WriteLine(lst2.Count);
	Console.WriteLine(lst2.Capacity);
	
	lst2.Capacity = 5;
	  
	Console.WriteLine(lst2.Count);
	Console.WriteLine(lst2.Capacity);
	
  }
}

Saída

3
0

descrição pendente

Tab. 2: Métodos

Método	Descrição
Add	Adiciona um elemento no fim	Visitar
AddRange	Adiciona ou Concatena uma List	Visitar
BinarySeach	Busca o índice de uma elemento usando busca binária	Visitar
Clear	Excluir todos os elementos	Visitar
Contains	Verifica se um elemeto está contido	Visitar
ConvertAll	-	Visitar
CopyTo	Copia um intervalo de elementos	Visitar
EnsureCapacity	-	Visitar
Equals	Compara duas lists	Visitar
Exists	Verifica se elemento existe	Visitar
Find	Encontra o primeiro elemento	Visitar
FindAll	O mesmo que Find, mas encontra todos os elementos	Visitar
FindIndex	Busca o primeiro elemento e retorna seu índice	Visitar
ForEach	Executa uma Action para todos os elementos	Visitar
FindLast	Retorna o último índice de um elemento	Visitar
GetEnumerator	-	Visitar
GetRange	Retorna um intervalo de elementos	Visitar
IndexOf	Retorna o índice do primeiro elemento	Visitar
Insert	Insere um elemento em um índice	Visitar
InsertRange	Insere uma List em um índice específico	Visitar
LastIndexOf	Retorna o último indice de um elemento	Visitar
Remove	Remove um elemento baseado em seu valor	Visitar
RemoveAll	Remove todos os elementos	Visitar
RemoveAt	Remove um elemento em um índice	Visitar
RemoveRange	Remove um intervalo de elementos	Visitar
Reverse	Inverte a ordem dos elementos	Visitar
Slice	Retorna uma cópia de um intervalo de elementos	Visitar
Sort	Ordena uma List de forma crescente	Visitar
ToArray	Retorna um array com os elementos	Visitar
ToString	-	Visitar
TrimExcess	-	Visitar
TrueForAll	Verifica se todos elementos satisfazem uma condição	Visitar

1. 13/08/2025 - revisão 2 - Ajustes: pontuais, sintaxes, exemplos e 'Objetivos'; Adição: 'verificação null' e 'Propriedades'
2. 10/10/2024 - revisão 1 - Correções e ajustes pontuais
3. 18/03/2024 - versão inicial