C# -  Coleções Imutáveis

Neste artigo vamos apresentar alguns conceitos das coleções imutáveis na linguagem C#

O namespace System.Collections.Immutable contém interfaces e classes que definem coleções imutáveis. Essas classes são suportadas, começando pelo .NET Framework 4.5.

Coleções imutáveis são coleções que não podem ser alteradas, simples assim.

Mas qual a serventia dessas coleções ?

Com coleções imutáveis, você pode:

• Compartilhar uma coleção de forma que o consumidor pode ter certeza de que a coleção nunca será alterada;
• Oferecer acesso thread-safe implícito em aplicativos com multithread (sem bloqueios necessários para acessar coleções).
• Seguir práticas de programação funcionais;
• Modificar uma coleção durante a enumeração, ao mesmo tempo em que assegura que a coleção original não será alterada;

As classes de coleção imutável estão disponíveis com o .NET Core, no entanto, eles não fazem parte da biblioteca de classes principal distribuída com o .NET Framework. Elas estão disponíveis começando com o .NET Framework 4.5 via pacotes NuGet.

Para os exemplos deste artigo vou criar um projeto Console  App (.NET Core) usando o VS 2017 Community com o nome NetCore_Immutable.

Vamos começar com um array de strings imutáveis ​​simples. Você pode criar um array com o método estático Create :

ImmutableArray<string> a1 = ImmutableArray.Create<string>();

O método Create está sobrecarregado, onde outras variantes deste método permitem passar qualquer número
de elementos. Preste atenção que dois tipos diferentes são usados ​​aqui:

• A classe ImmutableArray não genérica com o método Create estático;
• E a estrutura ImmutableArray genérica que é retornada do método Create.

Assim acabamos de criar um array vazio, o que não é muito útil.

O tipo ImmutableArray<T> oferece um método Add para adicionar elementos. No entanto, ao contrário de outras classes de coleção, o método Add não altera a coleção imutável em si. Em vez disso, uma nova coleção imutável é retornada.

Então, após a chamada do método Add, a1 ainda é uma coleção vazia, e, a2 é uma coleção imutável com um elemento. O método Add retorna a nova coleção imutável:

ImmutableArray <string> a2 = a1.Add ("Macoratti");

Com isso, é possível usar essa API de forma fluente e invocar um método Add após o outro. Vemos isso aplicado no código abaixo onde a variável a3 agora faz referência a uma coleção imutável contendo quatro elementos:

ImmutableArray<string> a3 = a2.Add("Miriam").Add("Jessica").Add("Jefferson");

Com cada um desses estágios usando o array imutável, as coleções completas não são copiadas a cada passo. Em vez disso, os tipos imutáveis ​​usam o estado compartilhado e copiam a coleção apenas quando ela for
necessária.

No entanto, é ainda mais eficiente preencher primeiro a coleção e torná-la um array imutável. Quando alguma manipulação precisa ocorrer, você pode usar novamente uma coleção mutável. Uma classe de construtor oferecida pelos tipos imutáveis ​​ajudam a realizar essa tarefa

Para ver isso em ação, vamos criar uma classe Conta e a seguir torná-la uma coleção imutável:

    public class Conta
    {
        public Conta(string nome, decimal valor)
        {
            Nome = nome;
            Valor = valor;
        }
        public string Nome { get; }
        public decimal Valor { get; }
    }

Após criar a classe vamos criar uma coleção de contas com algumas contas:

   var contas = new List<Conta>()
   {
        new Conta("Macoratti", 1500m),
        new Conta("Janice", -100m),
        new Conta("Jefferson", 200m)
   };

A partir da coleção de contas, uma coleção imutável pode ser criada com o método de extensão ToImmutableList.

Este método de extensão está disponível assim que o namespace System.Collections.Immutable for referenciado.

ImmutableList<Conta> immutableContas = contas.ToImmutableList();

E a variável immutableContas pode ser enumerada como outras coleções. Apenas não pode ser alterada:

  foreach (var conta em immutableContas)
  {
    Console.WriteLine ($ "{conta.Nome} {conta.Valor}");
  }

Em vez de usar a instrução foreach para iterar listas imutáveis, você pode usar o método ForEach que é
definido com ImmutableList<T>. Este método requer um delegate Action<T> como parâmetro e, portanto, um
A expressão lambda pode ser atribuída:

immutableContas.ForEach(a => Console.WriteLine($"{a.Nome} {a.Valor}"));

Trabalhando com essas coleções, métodos como Contains, FindAll, FindLast, IndexOf e outros estão acessíveis, pois esses métodos são iguais aos de outras classes de coleção.

Caso você precise alterar o conteúdo de coleções imutáveis, as coleções oferecem métodos como Add, AddRange, Remove, RemoveAt, RemoveRange, Replace e Sort.

Esses métodos são muito diferentes dos métodos das classes das coleções normais, pois a coleção imutável usada para invocar os métodos nunca é alterada, mas esses métodos retornam uma nova coleção imutável.

A seguir o código completo usado:

using System;
using System.Collections.Generic;
using System.Collections.Immutable;

namespace NetCore_Immutable
{
    public class Conta
    {
       public Conta(string nome, decimal valor)
       {
           Nome = nome;
           Valor = valor;
       }
       public string Nome { get; }
       public decimal Valor { get; }
    }

    class Program
    {
        static void Main(string[] args)
        {
            ImmutableArray<string> a1 = ImmutableArray.Create<string>();
            ImmutableArray<string> a2 = a1.Add("Macoratti");
            ImmutableArray<string> a3 = a2.Add("Miriam").Add("Jessica").Add("Jefferson");

            var contas = new List<Conta>()
            {
                new Conta("Macoratti", 1500m),
                new Conta("Janice", -100m),
                new Conta("Jefferson", 200m)
            };

            ImmutableList<Conta> immutableContas = contas.ToImmutableList();
            foreach (var conta in immutableContas)
            {
                Console.WriteLine($"{conta.Nome} {conta.Valor}");
            }

            immutableContas.ForEach(a => Console.WriteLine($"{a.Nome} {a.Valor}"));
        }
    }
}

Em outro artigo vamos continuar a tratar desse assunto.

Pegue o código usado aqui: NetCore_Immutable.zip

"Por que estás abatida, ó minha alma, e por que te perturbas dentro de mim? Espera em Deus, pois ainda o louvarei, o qual é a salvação da minha face, e o meu Deus."
Salmos 42:11

  Gostou ?   Compartilhe no Facebook   Compartilhe no Twitter

Referências:

• Seção VB .NET do Site Macoratti.net

• Super DVD .NET - A sua porta de entrada na plataforma .NET

• Super DVD Vídeo Aulas - Vídeo Aula sobre VB .NET, ASP .NET e C#

• Super DVD C# - Recursos de aprendizagens e vídeo aulas para C#

• Seção C# do site Macoratti.net

• Seção ASP .NET do site Macoratti .net

• ASP .NET Core 2 - MiniCurso Básico - Macoratti

• ASP .NET Core - Macoratti

• C# - Aplicando os conceitos da POO na prática - Macoratti.net

• C# - Aplicando conceitos OOP e Polimorfismo na prática - Macoratti.net

José Carlos Macoratti