Skip to content

4. Classes, estruturas, interfaces

4.1. Objetos por meio de exemplos

4.1.1. Visão geral

Vamos agora explorar a programação orientada a objetos por meio de exemplos. Um objeto é uma entidade que contém dados que definem seu estado (chamados de campos, atributos etc.) e funções (chamadas de métodos). Um objeto é criado a partir de um modelo chamado classe:

public class C1
{
    Type1 p1;          // campo p1
    Type2 p2;          // campo p2
    ...
    Type3 M3(...)      // método M3
    {
        ...
    }
    Type4 M4(...)      // método M4
    {
        ...
    }
    ...
}

A partir da classe anterior [C1], é possível criar muitos objetos, como [O1], [O2], … Todos terão os campos [p1], [p2], … e os métodos [M3], [M4], … No entanto, terão valores diferentes para seus campos [pi], de modo que cada um tem seu próprio estado. Se [o1] for um objeto do tipo [C1], [o1.p1] refere-se ao campo [p1] de [o1], e [o1.M3] refere-se ao método [M3] de [o1].

Consideremos um primeiro modelo de objetos: a classe [Person].

4.1.2. Criação do projeto C#

Nos exemplos do capítulo anterior, um programa cabia em um único arquivo-fonte. A partir de agora, um programa pode ser composto de vários arquivos-fonte: uma classe por arquivo, mais o programa principal. Esses arquivos são agrupados em um projeto. O curso de 2008 criava projetos com os assistentes do Visual Studio 2008; aqui usamos a ferramenta de linha de comando [dotnet], que funciona da mesma forma no Windows, no Linux e no macOS. O Capítulo 2 mostrou como abrir o mesmo projeto no VS Code ou no Visual Studio.

Em um terminal, vá até a pasta [04-classes] e crie um projeto de console chamado [Persons]:

1
2
3
4
5
6
7
8
> dotnet new console -n Persons
The template "Console App" was created successfully.

Processing post-creation actions...
Restoring .../04-classes/Persons/Persons.csproj:
  Determining projects to restore...
  Restored .../04-classes/Persons/Persons.csproj (in 126 ms).
Restore succeeded.

O comando cria uma pasta chamada [Persons] contendo dois arquivos. O arquivo [Persons.csproj] descreve o projeto:

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net10.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
  </PropertyGroup>

</Project>
  • Linha 4: o projeto produz um executável;
  • linha 5: o programa de destino é o .NET 10;
  • linha 6: um conjunto de namespaces comuns ([System], [System.IO], [System.Collections.Generic], [System.Linq], …) é importado implicitamente em todos os arquivos-fonte do projeto. É por isso que podemos escrever *[Console.WriteLine] sem a cláusula ***[using System;]** ;
  • Linha 7: os tipos de referência anuláveis estão habilitados. O compilador emite um aviso para qualquer variável de tipo de referência (uma cadeia, um objeto) que possa assumir o valor [null] sem que o programa o espere. Voltaremos a isso na seção dedicada a esses tipos; por ora, basta lembrar que nossos programas devem compilar sem nenhum aviso.

O segundo arquivo, [Program.cs], contém o programa principal. Todos os arquivos [*.cs] da pasta do projeto (e de suas subpastas) fazem parte do projeto: para acrescentar uma classe [Person], basta criar o arquivo [Person.cs] na pasta [Persons]. Para executar o projeto, digite [dotnet run] em sua pasta: o comando compila o projeto, se ele tiver sido alterado, e depois o executa.

Todos os projetos deste capítulo são agrupados em uma solução, um arquivo que referencia um conjunto de projetos e que o VS Code ou o Visual Studio podem abrir de uma só vez. O formato [.slnx] (XML), com suporte do comando [dotnet] desde o .NET 9 e formato padrão desde o .NET 10, substitui o antigo formato [.sln]:

1
2
3
4
5
> dotnet new sln --format slnx -n 04-classes
The template "Solution File" was created successfully.

> dotnet sln 04-classes.slnx add Persons/Persons.csproj
Project `Persons/Persons.csproj` added to the solution.

O comando [dotnet build 04-classes.slnx] compila então todos os projetos da solução.

4.1.3. Definição da classe Person

A definição da classe [Person] no arquivo-fonte [Person.cs] será a seguinte:

namespace Persons;

public class Person
{
    // atributos (campos)
    private string firstName = "";
    private string lastName = "";
    private int age;

    // método
    public void Initialize(string p, string n, int age)
    {
        this.firstName = p;
        this.lastName = n;
        this.age = age;
    }

    // método
    public void Identify()
    {
        Console.WriteLine($"[{firstName}, {lastName}, {age}]");
    }
}
  • Linha 1: a classe pertence ao namespace [Persons] (o nome do projeto). Esta forma, [namespace Persons;], conhecida como “escopo de arquivo”, coloca todos os tipos do arquivo dentro do namespace. Os namespaces são discutidos no final do capítulo;
  • Linhas 6–8: os três campos da classe. As duas cadeias são inicializadas com a cadeia vazia; caso contrário, receberiam [null] na criação do objeto, e o compilador, que tem os tipos anuláveis habilitados, emitiria um aviso;
  • linhas 11–15: um método que define o estado do objeto;
  • linhas 19–21: um método que exibe o estado do objeto.

Aqui temos a definição de uma classe e, portanto, de um tipo de dados. Quando criamos variáveis desse tipo, chamamo-las de objetos ou instâncias da classe. Uma classe é, portanto, um modelo a partir do qual objetos são construídos.

Os membros de uma classe podem ser dados (campos), métodos (funções) ou propriedades. As propriedades são métodos especiais usados para obter ou definir o valor dos campos de um objeto. Esses membros podem vir acompanhados de uma das seguintes palavras-chave:

Palavra-chave
Acesso
[private]
Um membro privado só é acessível pelos métodos internos da classe. É o nível de acesso padrão
[public]
Um membro público é acessível por qualquer método, esteja ou não definido na classe
[protected]
Um membro protegido só é acessível pelos métodos internos da classe ou de uma classe derivada (veja o conceito de herança adiante)
[internal]
Um membro interno é acessível por qualquer método do mesmo assembly (o mesmo projeto)

Em geral, os dados de uma classe são declarados privados, enquanto seus métodos e propriedades são declarados públicos. Isso significa que o usuário de um objeto (o programador):

  • não terá acesso direto aos dados privados do objeto;
  • pode chamar os métodos públicos do objeto, inclusive os que dão acesso a seus dados privados.

A sintaxe para declarar uma classe [C] é a seguinte:

1
2
3
4
5
6
public class C
{
    private private data, method or property;
    public public data, method or property;
    protected protected data, method or property;
}

A ordem em que os membros [private], [protected] e [public] são declarados é arbitrária.

4.1.4. O método Initialize

Qual é a finalidade do método [Initialize]? Como [lastName], [firstName], and [age] são membros privados da classe [Person], as instruções:

1
2
3
4
Person p1;
p1.firstName = "Jean";
p1.lastName = "Dupont";
p1.age = 30;

são inválidas. Precisamos inicializar um objeto do tipo [Person] por meio de um método público. É a finalidade do método [Initialize]. Escreveremos:

Person p1;
p1.Initialize("Jean", "Dupont", 30);

A notação [p1.Initialize] é válida porque [Initialize] é publicamente acessível.

4.1.5. O operador new

No entanto, a sequência de instruções anterior está incorreta. A instrução

Person p1;

declara [p1] como uma referência a um objeto do tipo [Person]. Esse objeto ainda não existe e, portanto, [p1] não está inicializado. Quando escrevemos em seguida [p1.Initialize("Jean", "Dupont", 30)], chamamos o método [Initialize] do objeto referenciado por [p1]. No entanto, esse objeto não existe, e o compilador informa o erro: a variável local [p1] não recebeu um valor. Se escrevermos:

Person? p1 = null;
p1.Initialize("Jean", "Dupont", 30);

indicamos explicitamente com a palavra-chave [null] que a variável [p1] ainda não referencia nenhum objeto (o ponto de interrogação em [Person?] indica que a variável pode receber o valor [null]). O compilador emite então apenas um aviso (desreferência de uma referência nula) e, em tempo de execução, a chamada do método lança uma exceção [NullReferenceException]. Para que [p1] referencie um objeto, é preciso escrever:

Person p1 = new Person();

Isso cria um objeto do tipo [Person] que ainda não foi inicializado: seus campos têm os valores padrão, neste caso a string vazia para [lastName] e [firstName], e 0 para [age] (um campo numérico sem valor inicial explícito vale 0; um campo de tipo referência vale [null]). Agora que [p1] referencia um objeto, a instrução de inicialização desse objeto, [p1.Initialize("Jean", "Dupont", 30)], é válida.

4.1.6. A palavra-chave this

Vejamos o código do método [Initialize]:

    public void Initialize(string p, string n, int age)
    {
        this.firstName = p;
        this.lastName = n;
        this.age = age;
    }

A instrução [this.firstName = p] significa que o campo [firstName] do objeto atual ([this]) recebe o valor [p]. A palavra-chave [this] refere-se ao objeto atual, aquele sobre o qual o método está sendo executado. Como sabemos disso? Vejamos como o objeto referenciado por [p1] é inicializado no programa chamador:

p1.Initialize("Jean", "Dupont", 30);

É o método [Initialize] do objeto [p1] que é chamado. Quando, dentro desse método, o objeto [this] é referenciado, trata-se na verdade do objeto [p1]. O método [Initialize] também poderia ter sido escrito da seguinte forma:

1
2
3
4
5
6
    public void Initialize(string p, string n, int age)
    {
        firstName = p;
        lastName = n;
        this.age = age;
    }

Quando um método de um objeto referencia um campo [A] desse objeto, a notação [this.A] fica implícita. Ela deve ser usada explicitamente quando há conflito de identificadores. É o caso da instrução [this.age = age;], em que [age] designa ao mesmo tempo um campo do objeto atual e o parâmetro [age] recebido pelo método. Nesse caso, a ambiguidade deve ser resolvida designando o campo [age] como [this.age].

4.1.7. Um programa de teste

Eis um pequeno programa de teste. Ele está escrito no arquivo-fonte [Program.cs] do projeto:

1
2
3
4
5
6
using Persons;

// um objeto Person
Person p1 = new Person();
p1.Initialize("Jean", "Dupont", 30);
p1.Identify();
  • Linha 1: o programa principal é escrito com instruções de nível superior, que não pertencem a nenhum namespace. Para designar a classe [Person] apenas pelo nome, é preciso importar seu namespace [Persons] por meio da cláusula [using];
  • Linha 4: criação de um objeto [Person] referenciado por [p1];
  • Linha 5: inicialização do objeto;
  • Linha 6: exibição de seu estado.

Resultados:

> dotnet run
[Jean, Dupont, 30]

4.1.8. Aplicativos de arquivo único

Para um exemplo curto, um projeto é desnecessariamente pesado. Desde a versão 10, um arquivo-fonte autônomo pode ser executado diretamente pelo .NET, sem um arquivo [.csproj]: trata-se de um aplicativo de arquivo único, que usamos no capítulo anterior. As opções do projeto (tipos anuláveis habilitados, [using] implícitos) são as mesmas de um projeto de console. Usaremos esse formato sempre que o exemplo contiver apenas uma ou duas classes.

O arquivo contém então as instruções de nível superior seguidas das declarações de classes: o compilador impõe essa ordem, pois as instruções de nível superior devem preceder qualquer declaração de tipo (classe, estrutura, interface etc.) no arquivo. As classes declaradas dessa forma não pertencem a nenhum namespace, o que é irrelevante em um programa de arquivo único.

4.1.9. Outro método: a sobrecarga

Continuemos com a classe *[Person] e acrescentemos a ela um segundo método, *[Initialize]. O programa *[classes-01.cs]* é o seguinte:

// sobrecarga do método Initialize
Person p1 = new Person();
p1.Initialize("Jean", "Dupont", 30);
p1.Identify();
Person p2 = new Person();
p2.Initialize(p1);
p2.Identify();

// a classe Person é declarada após as instruções de nível superior
public class Person
{
    // atributos
    private string firstName = "";
    private string lastName = "";
    private int age;

    // inicialização a partir de três valores
    public void Initialize(string p, string n, int age)
    {
        firstName = p;
        lastName = n;
        this.age = age;
    }

    // inicialização a partir de outra pessoa
    public void Initialize(Person p)
    {
        firstName = p.firstName;
        lastName = p.lastName;
        age = p.age;
    }

    // identidade da pessoa
    public void Identify()
    {
        Console.WriteLine($"[{firstName}, {lastName}, {age}]");
    }
}
  • linhas 2 a 7: as instruções de nível superior, ou seja, o programa principal;
  • Linha 10: a classe [Person] é declarada após as instruções de nível superior;
  • linhas 18 a 22: o método [Initialize] do parágrafo anterior;
  • linhas 26 a 30: um segundo método, [Initialize].

Temos agora dois métodos chamados [Initialize]: isso é válido desde que aceitem parâmetros diferentes (em número ou tipo). Diz-se que o método [Initialize] está sobrecarregado. O compilador escolhe o método a chamar de acordo com os parâmetros reais: [p1.Initialize("Jean", "Dupont", 30)] (linha 3) chama o primeiro e [p2.Initialize(p1)] (linha 6) chama o segundo.

O parâmetro do segundo método é uma referência ([p]) a uma pessoa. Os campos da pessoa ([p]) são então atribuídos ao objeto atual ([this]). Observe que o método [Initialize] tem acesso direto aos campos do objeto [p] embora eles sejam privados (linhas 28 a 30). Isso vale sempre: um método de uma classe [C] tem acesso aos membros privados de todos os objetos da mesma classe [C].

Resultados:

1
2
3
> dotnet run classes-01.cs
[Jean, Dupont, 30]
[Jean, Dupont, 30]

4.1.10. Construtores da classe Person

Um construtor é um método que tem o nome da classe e é chamado quando o objeto é criado. Geralmente serve para inicializar o objeto. É um método que pode receber parâmetros, mas não retorna valor. Sua declaração não é precedida por nenhum tipo (nem mesmo [void]).

Se uma classe [C] tem um construtor que aceita n parâmetros, a declaração e a inicialização de um objeto dessa classe podem ser feitas da seguinte forma:

C obj = new C(arg1, arg2, ... argn);

ou

1
2
3
C obj;
...
obj = new C(arg1, arg2, ... argn);

Quando uma classe [C] tem um ou mais construtores, um deles deve ser usado para criar um objeto dessa classe. Se uma classe [C] não tem construtores, ela possui um construtor padrão, que é o construtor sem parâmetros [public C()]. Os campos do objeto mantêm então seus valores iniciais. Foi o que aconteceu nos programas anteriores, nos quais havíamos escrito [new Person()].

O programa [classes-02.cs] fornece três construtores para a classe [Person]:

// construtores da classe Person
Person p1 = new Person("Jean", "Dupont", 30);
p1.Identify();
Person p2 = new Person(p1);
p2.Identify();
Person p3 = new Person();
p3.Identify();

public class Person
{
    // atributos
    private string firstName;
    private string lastName;
    private int age;

    // construtor principal
    public Person(string firstName, string lastName, int age)
    {
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
    }

    // construtor de cópia: ele chama o construtor principal
    public Person(Person p) : this(p.firstName, p.lastName, p.age)
    {
    }

    // construtor sem parâmetros: ele também chama o construtor principal
    public Person() : this("?", "?", 0)
    {
    }

    // identidade da pessoa
    public void Identify()
    {
        Console.WriteLine($"[{firstName}, {lastName}, {age}]");
    }
}
  • linhas 17 a 21: o construtor “principal” inicializa os três campos. Como seus parâmetros têm os mesmos nomes dos campos, estes são distinguidos com [this];
  • linha 25: o construtor de cópia. A notação [: this(p.firstName, p.lastName, p.age)] significa que, antes de executar o corpo (vazio) do construtor, é executado o construtor da mesma classe que aceita três parâmetros, [string], [string], [int]. Isso é chamado de encadeamento de construtores. O código de inicialização é assim escrito uma única vez;
  • linha 30: o construtor sem parâmetros, que também é encadeado ao construtor principal. Como a classe declarou construtores, ela não tem mais um construtor padrão: se quisermos poder escrever [new Person()], devemos declará-lo;
  • Linhas 11 a 14: as duas strings não são mais inicializadas na declaração. Isso deixou de ser necessário: todos os construtores, diretamente ou por encadeamento, atribuem um valor a elas, e o compilador verifica isso.

O curso de 2008 fazia os construtores chamarem o método [Initialize]. O encadeamento com [this(...)] é preferível: com os tipos anuláveis habilitados, o compilador não inspeciona o conteúdo dos métodos chamados por um construtor e apontaria que os campos [firstName] e [lastName] poderiam valer [null] ao final da construção.

Resultados:

1
2
3
4
> dotnet run classes-02.cs
[Jean, Dupont, 30]
[Jean, Dupont, 30]
[?, ?, 0]

4.1.11. Referências a objetos

Usamos a classe [Person] do programa anterior, omitindo seu construtor sem parâmetros, mas incluindo o método [Initialize(string, string, int)] do início do capítulo. O programa de teste passa a ser o seguinte [classes-03.cs] (não reproduzimos a classe):

// referências de objetos
// p1
Person p1 = new Person("Jean", "Dupont", 30);
Console.Write("p1="); p1.Identify();
// p2 referencia o mesmo objeto que p1
Person p2 = p1;
Console.Write("p2="); p2.Identify();
// p3 referencia um objeto que é uma cópia do objeto referenciado por p1
Person p3 = new Person(p1);
Console.Write("p3="); p3.Identify();
// alteramos o estado do objeto referenciado por p1
p1.Initialize("Micheline", "Benoît", 67);
Console.Write("p1="); p1.Identify();
// como p2 = p1, o objeto referenciado por p2 mudou de estado
Console.Write("p2="); p2.Identify();
// p3 não referencia o mesmo objeto que p1: o objeto referenciado por p3 não mudou
Console.Write("p3="); p3.Identify();
// p1 e p2 são a mesma referência? e p1 e p3?
Console.WriteLine($"p1 == p2 : {p1 == p2}, p1 == p3 : {p1 == p3}");

Resultados:

1
2
3
4
5
6
7
8
> dotnet run classes-03.cs
p1=[Jean, Dupont, 30]
p2=[Jean, Dupont, 30]
p3=[Jean, Dupont, 30]
p1=[Micheline, Benoît, 67]
p2=[Micheline, Benoît, 67]
p3=[Jean, Dupont, 30]
p1 == p2 : True, p1 == p3 : False

Quando a variável [p1] é declarada como [Person p1 = new Person("Jean", "Dupont", 30);] (linha 3), [p1] refere-se ao objeto [Person("Jean", "Dupont", 30)] mas não é o próprio objeto. Em C, falaríamos de um ponteiro, isto é, o endereço do objeto criado. Se escrevermos em seguida [p1 = null;], não é o objeto [Person("Jean", "Dupont", 30)] que é modificado; é a referência [p1] que muda de valor. O objeto será “perdido” se nenhuma outra variável o referenciar: a memória que ele ocupa será posteriormente recuperada pelo coletor de lixo (garbage collector) do .NET.

Quando escrevemos [Person p2 = p1;] (linha 6), inicializamos a referência [p2]: ela “aponta” para o mesmo objeto (refere-se ao mesmo objeto) que a referência [p1]. Assim, se o objeto “apontado” (ou referenciado) por [p1] for modificado, o objeto referenciado por [p2] também o será (linhas 5 e 6 dos resultados).

Quando se escreve [Person p3 = new Person(p1);] (linha 9), um novo objeto, [Person], é criado. Esse novo objeto será referenciado por [p3]. Se o objeto referenciado por [p1] for modificado, o objeto referenciado por [p3] (linha 7) permanece inalterado.

Por fim, na linha 19, o operador [==], aplicado a duas referências de objetos, indica se elas se referem ao mesmo objeto: [p1] e [p2] referem-se ao mesmo objeto, enquanto [p1] e [p3] referem-se a dois objetos diferentes, embora tenham o mesmo conteúdo (linha 8).

4.1.12. Passagem de parâmetros de referência a objetos

No capítulo anterior, examinamos como os parâmetros de funções são passados quando são de tipos simples ([int], [double], …). Vejamos o que acontece quando o parâmetro é uma referência a um objeto. Para isso, usaremos a classe [StringBuilder] do .NET. Um objeto [string] não pode ser modificado: uma operação como [s.ToUpper()] retorna um novo [string]. Um objeto [StringBuilder], por outro lado, é uma string mutável: seu método [Append] acrescenta caracteres à string sem criar um novo objeto.

O programa [classes-04.cs] é o seguinte:

using System.Text;

// passagem de parâmetros de tipo referência de objeto
StringBuilder sb0 = new StringBuilder("test0"), sb1 = new StringBuilder("test1"), sb2 = new StringBuilder("test2");
Console.WriteLine($"In calling function before call: sb0={sb0}, sb1={sb1}, sb2={sb2}");
ChangeStringBuilder(sb0, sb1, ref sb2, out StringBuilder sb3);
Console.WriteLine($"In calling function after call: sb0={sb0}, sb1={sb1}, sb2={sb2}, sb3={sb3}");

// a função chamada
static void ChangeStringBuilder(StringBuilder sbf0, StringBuilder sbf1, ref StringBuilder sbf2, out StringBuilder sbf3)
{
    Console.WriteLine($"Start of called function: sbf0={sbf0}, sbf1={sbf1}, sbf2={sbf2}");
    sbf0.Append("*****");
    sbf1 = new StringBuilder("test1*****");
    sbf2 = new StringBuilder("test2*****");
    sbf3 = new StringBuilder("test3*****");
    Console.WriteLine($"End of called function: sbf0={sbf0}, sbf1={sbf1}, sbf2={sbf2}, sbf3={sbf3}");
}
  • linha 1: a classe [StringBuilder] pertence ao namespace [System.Text], que não faz parte dos namespaces importados implicitamente;
  • linha 4: três referências [sb0, sb1, sb2] a objetos do tipo [StringBuilder];
  • linha 6: elas são passadas à função [ChangeStringBuilder] em modos diferentes: [sb0] e [sb1] no modo padrão, [sb2] com a palavra-chave [ref], e uma quarta referência, [sb3], declarada na própria chamada ([out StringBuilder sb3]), com a palavra-chave [out];
  • linhas 10 a 17: uma função local com os parâmetros formais [sbf0, sbf1, sbf2, sbf3]. As relações entre os parâmetros formais [sbfi] e os parâmetros reais [sbi] são as seguintes:
    • [sbf0] e [sb0] são, no início da função, duas referências distintas que apontam para o mesmo objeto (as referências são passadas por valor);
    • o mesmo vale para [sbf1] e [sb1];
    • [sbf2] e [sb2] são uma única e mesma referência (palavra-chave [ref]);
    • [sbf3] e [sb3] também são a mesma referência (palavra-chave [out]), que a função deve inicializar.

Resultados:

1
2
3
4
5
> dotnet run classes-04.cs
In calling function before call: sb0=test0, sb1=test1, sb2=test2
Start of called function: sbf0=test0, sbf1=test1, sbf2=test2
End of called function: sbf0=test0*****, sbf1=test1*****, sbf2=test2*****, sbf3=test3*****
In calling function after call: sb0=test0*****, sb1=test1, sb2=test2*****, sb3=test3*****

Explicações:

  • [sb0] e [sbf0] são duas referências distintas ao mesmo objeto. Esse objeto foi modificado por meio de [sbf0] (linha 13). Essa modificação é visível por meio de [sb0] (linha 5);
  • [sb1] e [sbf1] são duas referências distintas ao mesmo objeto. [sbf1] recebe um novo valor dentro da função e passa a apontar para um novo objeto (linha 14). Isso não altera o valor de [sb1], que continua apontando para o objeto original, não modificado;
  • [sb2] e [sbf2] são a mesma referência. [sbf2] passa a apontar para um novo objeto (linha 15). Como [sbf2] e [sb2] são uma única e mesma entidade, [sb2] também aponta para esse novo objeto;
  • antes da chamada da função, [sb3] não tinha valor. Depois da chamada, [sb3] refere-se ao objeto criado pela função (linha 16).

4.1.13. Objetos temporários

Em uma expressão, é possível chamar explicitamente o construtor de um objeto: o objeto é criado, mas não há variável para acessá-lo posteriormente (para modificá-lo, por exemplo). Esse objeto temporário é criado para avaliar a expressão e depois é descartado. O espaço de memória que ele ocupava será recuperado automaticamente mais tarde pelo coletor de lixo, cuja função é recuperar o espaço de memória ocupado por objetos que não são mais referenciados pelos dados do programa.

Considere o seguinte programa, [classes-05.cs], no qual os construtores da classe [Person] exibem uma mensagem:

// objetos temporários
new Person(new Person("Jean", "Dupont", 30)).Identify();

public class Person
{
    // atributos
    private string firstName;
    private string lastName;
    private int age;

    // construtores
    public Person(string firstName, string lastName, int age)
    {
        Console.WriteLine("Constructor Person(string, string, int)");
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
    }

    public Person(Person p)
    {
        Console.WriteLine("Constructor Person(Person)");
        firstName = p.firstName;
        lastName = p.lastName;
        age = p.age;
    }

    // identidade da pessoa
    public void Identify()
    {
        Console.WriteLine($"[{firstName}, {lastName}, {age}]");
    }
}
  • Linha 2: o objeto [Person("Jean", "Dupont", 30)] é construído e depois passado ao construtor de cópia, que constrói um segundo objeto; em seguida, o método [Identify] é chamado nesse objeto. Nenhum dos dois objetos é referenciado por uma variável.

Resultados:

1
2
3
4
> dotnet run classes-05.cs
Constructor Person(string, string, int)
Constructor Person(Person)
[Jean, Dupont, 30]

Os resultados mostram a criação sucessiva dos dois objetos temporários.

4.1.14. Métodos de leitura e escrita de campos privados

Acrescentamos à classe [Person] os métodos necessários para ler ou modificar o estado dos campos dos objetos ([classes-06.cs]):

// métodos de leitura (getters) e métodos de escrita (setters) de atributos privados
Person p = new Person("Jean", "Michelin", 34);
Console.WriteLine("p=(" + p.GetFirstName() + "," + p.GetLastName() + "," + p.GetAge() + ")");
p.SetAge(56);
Console.WriteLine("p=(" + p.GetFirstName() + "," + p.GetLastName() + "," + p.GetAge() + ")");

public class Person
{
    // atributos
    private string firstName;
    private string lastName;
    private int age;

    // construtor
    public Person(string firstName, string lastName, int age)
    {
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
    }

    // getters
    public string GetFirstName()
    {
        return firstName;
    }

    public string GetLastName()
    {
        return lastName;
    }

    public int GetAge()
    {
        return age;
    }

    // setters
    public void SetFirstName(string firstName)
    {
        this.firstName = firstName;
    }

    public void SetLastName(string lastName)
    {
        this.lastName = lastName;
    }

    public void SetAge(int age)
    {
        this.age = age;
    }
}
  • linhas 22 a 35: os métodos de leitura, chamados getters;
  • linhas 38 a 51: os métodos de escrita, chamados setters.

Resultados:

1
2
3
> dotnet run classes-06.cs
p=(Jean,Michelin,34)
p=(Jean,Michelin,56)

Essa abordagem é típica da linguagem Java. O C# oferece um mecanismo mais elegante: as propriedades.

4.1.15. Propriedades

Há outra forma de acessar os campos de uma classe: criar propriedades. Elas permitem manipular campos privados como se fossem públicos.

Uma propriedade permite ler ([get]) ou definir ([set]) o valor de um campo. Uma propriedade é declarada da seguinte forma:

1
2
3
4
5
public Type Property
{
    get { ... }
    set { ... }
}

em que [Type] é geralmente o tipo do campo gerenciado pela propriedade. Ela pode ter dois métodos chamados [get] e [set]. O método [get] normalmente é responsável por retornar o valor do campo que ele gerencia (poderia retornar outra coisa; nada o impede). O método [set] recebe um parâmetro chamado [value], que normalmente atribui ao campo que gerencia. Ele pode aproveitar a oportunidade para verificar a validade do valor recebido e, se necessário, lançar uma exceção caso o valor seja inválido.

Considere o programa [classes-07.cs], no qual os acessores e mutadores anteriores foram substituídos por propriedades de leitura e escrita:

// propriedades
Person p = new Person("Jean", "Michelin", 34);
Console.WriteLine("p=(" + p.FirstName + "," + p.LastName + "," + p.Age + ")");
p.Age = 56;
Console.WriteLine("p=(" + p.FirstName + "," + p.LastName + "," + p.Age + ")");
try
{
    p.Age = -4;
}
catch (ArgumentException ex)
{
    Console.WriteLine(ex.Message);
}
// inicializador de objeto: construtor sem parâmetros e depois atribuição das propriedades
Person p2 = new Person { Age = 7, FirstName = "Arthur", LastName = "Martin" };
Console.WriteLine($"p2=({p2.FirstName},{p2.LastName},{p2.Age})");
try
{
    Person p3 = new Person { FirstName = "Paul", LastName = " " };
}
catch (ArgumentException ex)
{
    Console.WriteLine(ex.Message);
}

public class Person
{
    // atributos
    private string firstName = "";
    private string lastName = "";
    private int age;

    // construtores
    public Person(string firstName, string lastName, int age)
    {
        // passamos pelas propriedades para nos beneficiar de suas verificações
        FirstName = firstName;
        LastName = lastName;
        Age = age;
    }

    public Person()
    {
    }

    // propriedades
    public string FirstName
    {
        get { return firstName; }
        set
        {
            // nome válido?
            if (string.IsNullOrWhiteSpace(value))
            {
                throw new ArgumentException($"invalid first name ({value})");
            }
            firstName = value;
        }
    }

    public string LastName
    {
        get { return lastName; }
        set
        {
            // sobrenome válido?
            if (string.IsNullOrWhiteSpace(value))
            {
                throw new ArgumentException($"invalid last name ({value})");
            }
            lastName = value;
        }
    }

    public int Age
    {
        get { return age; }
        set
        {
            // idade válida?
            if (value < 0)
            {
                throw new ArgumentException($"invalid age ({value})");
            }
            age = value;
        }
    }
}

Os métodos [set] das três propriedades validam o valor recebido (linhas 52 a 57, 66 a 71, 80 a 85).

  • Linhas 53 a 55: o método [string.IsNullOrWhiteSpace] retorna [true] se a string for [null], vazia ou composta apenas por espaços. A exceção lançada é do tipo [ArgumentException], a exceção definida pelo .NET para sinalizar um parâmetro inválido. A versão de 2008 lançava uma exceção do tipo geral [Exception], o que obriga o chamador a capturar todas as exceções;
  • linhas 34 a 39: o construtor inicializa o objeto por meio das propriedades em vez dos campos. Isso permite aproveitar as validações feitas pelos métodos [set], que são implementadas em um único lugar.

Como os métodos [get] e [set] são chamados? Na instrução da linha 3, o programa tenta obter os valores das propriedades [FirstName], [LastName], e [Age] da pessoa [p]. O método [get] dessas propriedades é então chamado e retorna o valor do campo que elas gerenciam. Na instrução [p.Age = 56;] (linha 4), queremos definir o valor da propriedade [Age]. O método [set] dessa propriedade é então chamado. Ele recebe 56 como parâmetro [value].

Uma propriedade [P] de uma classe [C] que define apenas o método [get] é dita somente leitura. Se [c] for um objeto da classe [C], a operação [c.P = value] será rejeitada pelo compilador.

Resultados:

1
2
3
4
5
6
> dotnet run classes-07.cs
p=(Jean,Michelin,34)
p=(Jean,Michelin,56)
invalid age (-4)
p2=(Arthur,Martin,7)
invalid last name ( )

A linha 4 dos resultados mostra que a atribuição [p.Age = -4] (linha 8) foi rejeitada pelo método [set] da propriedade [Age].

4.1.16. Inicializadores de objeto

As propriedades podem ser usadas em conjunto com um construtor por meio da seguinte sintaxe:

Class obj = new Class(...) { Property1 = val1, Property2 = val2, ... };

Essa sintaxe, conhecida como inicializador de objeto, equivale ao seguinte código:

1
2
3
4
Class obj = new Class(...);
obj.Property1 = val1;
obj.Property2 = val2;
...

A ordem das propriedades não importa. No programa anterior [classes-07.cs], a classe [Person] tem um construtor sem parâmetros que não inicializa nada. Voltemos ao final do programa principal:

// inicializador de objeto: construtor sem parâmetros e depois atribuição das propriedades
Person p2 = new Person { Age = 7, FirstName = "Arthur", LastName = "Martin" };
Console.WriteLine($"p2=({p2.FirstName},{p2.LastName},{p2.Age})");
try
{
    Person p3 = new Person { FirstName = "Paul", LastName = " " };
}
catch (ArgumentException ex)
{
    Console.WriteLine(ex.Message);
}

Linha 15: o construtor sem parâmetros é usado para criar uma pessoa, que é então inicializada por suas propriedades. Poderíamos ter escrito [new Person() { Age = 7, ... }], mas os parênteses não são obrigatórios para o construtor sem parâmetros nessa sintaxe. Os métodos [set] são de fato chamados: na linha 19, o nome que contém um espaço é rejeitado (linha 6 dos resultados).

4.1.17. Propriedades automáticas

Em muitos casos, os métodos [get] e [set] de uma propriedade apenas leem e escrevem um campo privado, sem nenhum processamento adicional. Nesses casos, é possível usar uma propriedade automática declarada da seguinte forma:

public Type Property { get; set; }

O campo privado associado à propriedade não é declarado; ele é gerado automaticamente pelo compilador e só pode ser acessado por meio de sua propriedade. Assim, em vez de escrever o campo [firstName] e a propriedade [FirstName] do programa [classes-07.cs], podemos escrever:

    public string FirstName { get; set; } = "";

sem declarar o campo privado [firstName]. A expressão [= ""] que segue a propriedade é o valor inicial do campo oculto. A diferença entre as duas propriedades é que a primeira valida o nome em [set], enquanto a segunda não realiza nenhuma validação.

Será que usar a propriedade automática [FirstName] equivale a declarar um campo público [public string FirstName;]? Para o usuário da classe, a sintaxe é a mesma. Porém, declarar um campo de classe como público não é recomendado: isso viola o conceito de encapsulamento do estado de um objeto, que deve ser privado e exposto por meio de métodos públicos. Com uma propriedade automática, é possível acrescentar verificações posteriormente em [set] sem alterar o código dos usuários da classe.

As propriedades automáticas têm várias variantes, como demonstra o programa [classes-08.cs]:

// propriedades automáticas, somente leitura, init e required
var p = new Person("Dupont", 30) { FirstName = "Jean", City = "Angers" };
Console.WriteLine(p.Identity);
// FirstName é de leitura / escrita
p.FirstName = "Jacques";
// Age só pode ser modificada dentro da classe
p.GrowOlder();
Console.WriteLine(p.Identity);
// as linhas a seguir são rejeitadas pelo compilador
// p.LastName = "Durand"; // LastName é somente leitura
// p.Age = 40;           // o set de Age é privado
// p.City = "Paris";     // City só pode ser definida quando o objeto é criado

// propriedade obrigatória (required)
var c = new Contact { Email = "jean.dupont@example.com" };
Console.WriteLine($"Contact: {c.Email}, {c.Phone}");
// var c2 = new Contact();   // rejeitado: a propriedade obrigatória Email não está inicializada

public class Person
{
    // construtor
    public Person(string lastName, int age)
    {
        LastName = lastName;
        Age = age;
    }

    // propriedade automática de leitura / escrita, com um valor inicial
    public string FirstName { get; set; } = "";
    // propriedade automática somente leitura: definida pelo construtor
    public string LastName { get; }
    // propriedade automática cuja escrita é reservada à classe
    public int Age { get; private set; }
    // propriedade init: definida pelo construtor ou por um inicializador de objeto
    public string City { get; init; } = "?";
    // propriedade calculada somente leitura (membro com corpo de expressão)
    public string Identity => $"[{FirstName}, {LastName}, {Age}, {City}]";

    // método com corpo de expressão
    public void GrowOlder() => Age++;
}

public class Contact
{
    // a propriedade deve ser inicializada quando o objeto é criado
    public required string Email { get; init; }
    // propriedade opcional
    public string Phone { get; init; } = "unknown";
}
  • linha 29: uma propriedade automática de leitura e escrita com valor inicial;
  • linha 31: uma propriedade automática somente leitura: ela não tem [set] e só pode ser definida por um construtor (linha 24);
  • linha 33: o método [set] pode ter um acesso mais restrito que o da propriedade: aqui, a propriedade [Age] pode ser lida por todos, mas só pode ser modificada pelos métodos da classe, como [GrowOlder] (linha 40);
  • linha 35: uma propriedade [init] (C# 9): ela pode ser definida por um construtor ou um inicializador de objeto (linha 2), mas não depois disso. É uma forma de criar objetos imutáveis aproveitando a sintaxe do inicializador de objeto;
  • linha 37: uma propriedade somente leitura cujo valor é calculado. A notação [=> expression] é uma forma abreviada de [get { return expression; }]. Ela também se aplica a métodos (linha 40): fala-se então de membros com corpo de expressão (expression-bodied);
  • linha 46: uma propriedade obrigatória (C# 11): a palavra-chave [required] exige que o código que cria um objeto [Contact] inicialize a propriedade [Email] em um inicializador de objeto (linha 15). O compilador rejeita a linha 17 se ela for descomentada;
  • linhas 10 a 12: três instruções que o compilador rejeita, pelas razões indicadas nos comentários.

Lembre-se de que, com a palavra-chave [var] (linha 2), o tipo da variável é inferido a partir da expressão que a inicializa, neste caso [Person].

Resultados:

1
2
3
4
> dotnet run classes-08.cs
[Jean, Dupont, 30, Angers]
[Jacques, Dupont, 31, Angers]
Contact: jean.dupont@example.com, unknown

Por fim, uma propriedade automática pode ser declarada como virtual ([public virtual string Prop { get; set; }]) e sobrescrita em uma classe derivada, por exemplo, para acrescentar uma validação em [set]. As palavras-chave [virtual] e [override] são apresentadas com a herança.

4.1.18. A palavra-chave field (C# 14)

Entre a propriedade automática, que não realiza nenhuma validação, e a propriedade completa do programa [classes-07.cs], que exige a declaração de um campo, o C# 14 oferece uma opção intermediária: nos acessores de uma propriedade, a palavra-chave [field] designa o campo criado pelo compilador. Isso permite escrever uma validação sem declarar um campo:

// a palavra-chave field (C# 14)
var p = new Person { FirstName = "  jean ", LastName = "Dupont", Age = 30 };
Console.WriteLine(p.Identity);
try
{
    p.LastName = "";
}
catch (ArgumentException ex)
{
    Console.WriteLine(ex.Message);
}
try
{
    p.Age = -4;
}
catch (ArgumentException ex)
{
    Console.WriteLine(ex.Message);
}
Console.WriteLine(p.Identity);

public class Person
{
    // propriedades com verificações, sem campo declarado:
    // [field] denota o campo criado pelo compilador
    public string FirstName
    {
        get;
        set => field = string.IsNullOrWhiteSpace(value)
            ? throw new ArgumentException($"invalid first name ({value})")
            : value.Trim();
    } = "";   // valor inicial do campo oculto

    public string LastName
    {
        get;
        set => field = string.IsNullOrWhiteSpace(value)
            ? throw new ArgumentException($"invalid last name ({value})")
            : value.Trim();
    } = "";

    public int Age
    {
        get;
        set
        {
            if (value < 0)
            {
                throw new ArgumentException($"invalid age ({value})");
            }
            field = value;
        }
    }

    // identidade
    public string Identity => $"[{FirstName}, {LastName}, {Age}]";
}
  • Linhas 26 a 31: a propriedade [FirstName]. Seu método [get] é automático ([get;]): ele retorna o valor do campo oculto. Seu método [set] verifica o valor recebido e o atribui, sem os espaços iniciais e finais, ao campo oculto designado por [field]. A expressão [condition ? throw ... : value] usa uma expressão throw: se a condição for verdadeira, uma exceção é lançada; caso contrário, a expressão é avaliada como [value.Trim()];
  • linha 32: o valor inicial do campo oculto;
  • linhas 42 a 51: um [set] escrito com um bloco de instruções.

Resultados:

1
2
3
4
5
> dotnet run classes-09.cs
[jean, Dupont, 30]
invalid last name ()
invalid age (-4)
[jean, Dupont, 30]

O nome “jean”, fornecido cercado de espaços (linha 2 do programa), foi armazenado sem eles (linha 2 dos resultados).

4.1.19. Métodos e atributos de classe

Suponha que queiramos contar o número de objetos [Person] criados em um aplicativo. Poderíamos gerenciar um contador por conta própria, mas corremos o risco de esquecer objetos temporários criados aqui e ali. Parece mais seguro incluir uma instrução nos construtores da classe [Person] que incremente um contador. Esse contador não pode ser um campo comum, já que cada objeto tem seus próprios campos: ele é um campo da própria classe, e não de uma instância específica dessa classe. Nós o declaramos com a palavra-chave [static]:

    private static long nbPersons;

Para referenciá-lo, escrevemos [Person.nbPersons] para indicar que se trata de um campo da própria classe [Person]. Aqui, criamos um campo privado que não pode ser acessado diretamente de fora da classe. Criamos então uma propriedade pública para dar acesso ao campo de classe [nbPersons]. Para retornar o valor de [nbPersons], o método [get] dessa propriedade não precisa de um objeto [Person] específico: portanto, precisamos também de uma propriedade declarada como [static], que será chamada de fora com a sintaxe [Person.NbPersons]. Eis um exemplo, [classes-10.cs]:

// membros de classe (static)
Person p1 = new Person("Jean", "Dupont", 30);
Person p2 = new Person(p1);
new Person(p1);
Console.WriteLine($"Number of persons created: {Person.NbPersons}");
// um método de classe
Person p3 = Person.Unknown();
p3.Identify();
Console.WriteLine($"Number of persons created: {Person.NbPersons}");

public class Person
{
    // atributo de classe
    private static long nbPersons;

    // propriedade de classe
    public static long NbPersons
    {
        get { return nbPersons; }
    }

    // método de classe
    public static Person Unknown()
    {
        return new Person("?", "?", 0);
    }

    // atributos de instância
    private string firstName;
    private string lastName;
    private int age;

    // construtores
    public Person(string firstName, string lastName, int age)
    {
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
        nbPersons++;
    }

    public Person(Person p) : this(p.firstName, p.lastName, p.age)
    {
    }

    // identidade da pessoa
    public void Identify()
    {
        Console.WriteLine($"[{firstName}, {lastName}, {age}]");
    }
}
  • linha 14: o campo de classe. Como qualquer campo numérico, ele é inicializado com 0;
  • linhas 17 a 19: a propriedade de classe somente leitura. Ela poderia ter sido escrita de forma mais simples como [public static long NbPersons { get; private set; }];
  • linhas 23 a 25: um método de classe. Ele é chamado usando o nome da classe: [Person.Unknown()] (linha 7). Um método de classe não tem objeto atual: a palavra-chave [this] não faz sentido aqui, e ele só pode acessar diretamente os membros [static] da classe;
  • Linha 39: o construtor principal incrementa o contador. O construtor de cópia, que está encadeado ao construtor principal, também o incrementa.

Resultados:

1
2
3
4
> dotnet run classes-10.cs
Number of persons created: 3
[?, ?, 0]
Number of persons created: 4

O programa contou corretamente o objeto temporário criado na linha 4. Desde o início usamos membros de classe: [Console.WriteLine], [int.Parse]e [Math.Sqrt] são métodos [static]. [Console] e [Math] são até mesmo classes estáticas ([static class]): elas contêm apenas membros do tipo [static], e não é possível criar instâncias delas.

4.1.20. Um array de pessoas

Um objeto é um dado como outro qualquer e, como tal, vários objetos podem ser agrupados em um array [classes-11.cs]:

// um array de pessoas
Person[] friends = new Person[3];
friends[0] = new Person("Jean", "Dupont", 30);
friends[1] = new Person("Sylvie", "Vartan", 52);
friends[2] = new Person("Neil", "Armstrong", 66);
// exibição
foreach (Person friend in friends)
{
    friend.Identify();
}
  • Linha 2: cria um array de 3 elementos do tipo [Person]. Esses 3 elementos são inicializados aqui com o valor [null], ou seja, não referenciam nenhum objeto. Tecnicamente, fala-se em “array de objetos”, embora seja apenas um array de referências a objetos. A criação do array, que é ela própria um objeto (como indica [new]), não cria nenhum objeto do mesmo tipo de seus elementos; isso deve ser feito posteriormente. Observe que o compilador não sinaliza o fato de os elementos de um array do tipo [Person[]] serem iguais a [null] imediatamente após sua criação: trata-se de uma limitação da análise de tipos anuláveis;
  • Linhas 3 a 5: criam 3 objetos do tipo [Person];
  • linhas 7 a 9: exibem o conteúdo do array [friends].

A classe [Person], declarada a seguir, é derivada do programa [classes-03.cs], reduzida ao seu construtor de três parâmetros e ao seu método [Identify]. Resultados:

1
2
3
4
> dotnet run classes-11.cs
[Jean, Dupont, 30]
[Sylvie, Vartan, 52]
[Neil, Armstrong, 66]

4.1.21. Expressões new() com tipo de destino

Quando o tipo do objeto a ser criado é conhecido pelo contexto, o C# 9 permite omitir o nome da classe após [new]. O programa [classes-12.cs] demonstra isso:

// inicializadores de objeto e expressões new() com tipo inferido
// o tipo do objeto criado é inferido a partir do tipo da variável
Person p1 = new("Jean", "Dupont", 30);
Person p2 = new() { FirstName = "Arthur", LastName = "Martin", Age = 7 };
// um array inicializado por uma expressão de coleção
Person[] friends =
[
    p1,
    p2,
    new("Sylvie", "Vartan", 52),
    new() { FirstName = "Neil", LastName = "Armstrong", Age = 66 },
];
foreach (Person friend in friends)
{
    Console.WriteLine(friend.Identity);
}
// new() com tipo inferido em uma chamada de método: o tipo é o do parâmetro
Display(new("Pauline", "Leduc", 12));

// uma função local
static void Display(Person p)
{
    Console.WriteLine($"Display: {p.Identity}");
}

public class Person
{
    // construtores
    public Person(string firstName, string lastName, int age)
    {
        FirstName = firstName;
        LastName = lastName;
        Age = age;
    }

    public Person()
    {
    }

    // propriedades automáticas
    public string FirstName { get; set; } = "";
    public string LastName { get; set; } = "";
    public int Age { get; set; }
    // identidade
    public string Identity => $"[{FirstName}, {LastName}, {Age}]";
}
  • Linha 3: o tipo do objeto criado por [new(...)] é o da variável que o recebe, [Person]. Essa sintaxe é o oposto de [var]: com [var], o tipo da variável é inferido a partir da expressão; com [new()], o tipo do objeto é inferido a partir da variável;
  • linha 4: [new()] com um inicializador de objeto;
  • linhas 6 a 11: um array criado e preenchido por uma expressão de coleção (C# 12): os elementos são colocados entre colchetes e separados por vírgulas. O tipo dos elementos, [Person], é conhecido: [new(...)] é suficiente para criá-los;
  • linha 18: o tipo do objeto criado é o do parâmetro da função [Display].

Resultados:

1
2
3
4
5
6
> dotnet run classes-12.cs
[Jean, Dupont, 30]
[Arthur, Martin, 7]
[Sylvie, Vartan, 52]
[Neil, Armstrong, 66]
Display: [Pauline, Leduc, 12]

4.2. A herança por meio de exemplos

4.2.1. Visão geral

Aqui tratamos do conceito de herança. O objetivo da herança é “personalizar” uma classe existente para que ela atenda às nossas necessidades. Suponha que queiramos criar uma classe chamada [Teacher]: um professor é um tipo específico de pessoa. Ele tem atributos que as outras pessoas não têm: a disciplina que leciona, por exemplo. Mas também tem os atributos comuns a todas as pessoas: nome, sobrenome e idade. Um professor é, portanto, um membro de pleno direito da classe [Person] mas com atributos adicionais. Em vez de criar uma classe [Teacher] do zero, preferimos nos apoiar na classe existente [Person] e adaptá-la às características específicas dos professores. O conceito de herança nos permite fazer isso.

Para indicar que a classe [Teacher] herda as propriedades da classe [Person], escrevemos:

public class Teacher : Person

[Person] é chamada de classe-mãe (ou base), e [Teacher] é chamada de classe derivada (ou filha). Um [Teacher] objeto tem todas as características de um objeto [Person]: tem os mesmos campos e métodos. Esses campos e métodos da classe-mãe não são repetidos na definição da classe filha; basta especificar os campos e métodos acrescentados pela classe filha. Uma classe C# só pode derivar de uma única classe-mãe.

Os exemplos desta seção são dois projetos de console, [Inheritance1] e [Inheritance2], da solução [04-classes.slnx]. No projeto [Inheritance1], a classe [Person] é definida da seguinte forma: [Person.cs]:

namespace Inheritance1;

public class Person
{
    // propriedade de classe: o número de pessoas criadas
    public static long NbPersons { get; private set; }

    // construtor
    public Person(string firstName, string lastName, int age)
    {
        FirstName = firstName;
        LastName = lastName;
        Age = age;
        NbPersons++;
        Console.WriteLine("Constructor Person(string, string, int)");
    }

    // propriedades
    public string FirstName
    {
        get;
        set => field = Check(value, "first name");
    } = "";

    public string LastName
    {
        get;
        set => field = Check(value, "last name");
    } = "";

    public int Age
    {
        get;
        set => field = value >= 0 ? value : throw new ArgumentException($"invalid age ({value})");
    }

    // identidade da pessoa
    public string Identity => $"[{FirstName}, {LastName}, {Age}]";

    // verificação de uma string obrigatória
    private static string Check(string text, string label)
    {
        if (string.IsNullOrWhiteSpace(text))
        {
            throw new ArgumentException($"invalid {label} ({text})");
        }
        return text;
    }
}
  • linha 6: o contador de pessoas do parágrafo anterior, desta vez escrito como uma propriedade automática de classe cuja definição é reservada à classe;
  • linhas 9 a 15: o construtor inicializa o objeto por meio de suas propriedades e exibe uma mensagem de acompanhamento;
  • linhas 19 a 34: três propriedades que validam seus valores usando a palavra-chave [field]. As validações do nome e do sobrenome, que são idênticas, são fatoradas no método de classe privado [Check] (linhas 41 a 47);
  • linha 38: o método [Identify] dos exemplos anteriores foi substituído pela propriedade somente leitura [Identity], que retorna a identidade da pessoa em vez de exibi-la.

Criamos uma classe chamada [Teacher] que herda da classe [Person]: [Teacher.cs]:

namespace Inheritance1;

public class Teacher : Person
{
    // construtor
    public Teacher(string firstName, string lastName, int age, int section)
        : base(firstName, lastName, age)
    {
        // armazenamos a seção por meio da propriedade Section
        Section = section;
        // rastreamento
        Console.WriteLine("Constructor Teacher(string, string, int, int)");
    }

    // propriedade Section
    public int Section { get; set; }

    // propriedade Identity: ela oculta (new) a da classe pai
    public new string Identity => $"Teacher[{base.Identity},{Section}]";
}

A classe [Teacher] acrescenta aos métodos e propriedades da classe [Person]:

  • linha 3: a classe [Teacher] deriva da classe [Person];
  • linha 16: uma propriedade [Section], que é o número da seção a que o professor pertence dentro do corpo docente (aproximadamente uma seção por disciplina);
  • linhas 6 a 12: um construtor usado para inicializar todas as propriedades de um professor;
  • linha 19: uma nova propriedade, [Identity], que será discutida com mais detalhes adiante.

4.2.2. Criação de um objeto Teacher

Uma classe filha não herda os construtores da classe-mãe. Ela deve definir seus próprios construtores. O construtor da classe [Teacher] é o seguinte:

    public Teacher(string firstName, string lastName, int age, int section)
        : base(firstName, lastName, age)
    {
        // armazenamos a seção por meio da propriedade Section
        Section = section;
        // rastreamento
        Console.WriteLine("Constructor Teacher(string, string, int, int)");
    }

A declaração das linhas 6 e 7 especifica que o construtor recebe quatro parâmetros: [firstName], [lastName], [age], [section], e repassa três deles ([firstName], [lastName], [age]) à sua classe base, neste caso a classe [Person]. Sabemos que essa classe tem um construtor, [Person(string, string, int)], que nos permitirá criar uma pessoa a partir dos parâmetros repassados. Concluída a construção da parte [Person], a construção do objeto [Teacher] prossegue com a execução do corpo do construtor (linha 10).

Observe que, no lado esquerdo do sinal =, é usada a propriedade [Section]. Se essa propriedade realizasse verificações de validade, o construtor se beneficiaria delas. Isso evita ter de colocar essas verificações em dois lugares diferentes: o construtor e a propriedade.

Em resumo, o construtor de uma classe derivada:

  • repassa à sua classe base os parâmetros de que ela precisa para se construir;
  • usa os demais parâmetros para inicializar seus próprios membros.

Poderíamos ter optado por escrever:

1
2
3
4
5
6
7
public Teacher(string firstName, string lastName, int age, int section)
{
    this.firstName = firstName;
    this.lastName = lastName;
    this.age = age;
    Section = section;
}

Isso é impossível, por duas razões. Primeiro, a classe *[Person] não tem um construtor sem parâmetros: na ausência de ***[: base(...)], o compilador tenta chamar esse construtor e relata um erro. Segundo, mesmo que os campos privados [firstName], [lastName]e [age] existissem (aqui, são os campos ocultos das propriedades), somente os objetos da classe [Person] têm acesso direto a eles. Todos os outros objetos, inclusive os de classes derivadas como neste caso, devem acessá-los por meio de membros públicos (ou protegidos). Seria diferente se a classe *[Person] tivesse declarado esses campos como protegidos (*[protected]*): isso permitiria às classes derivadas acessá-los diretamente. Usar o construtor da classe-mãe é, portanto, a solução correta e a abordagem padrão: ao construir um objeto filho, primeiro chama-se o construtor do objeto pai e depois completam-se as inicializações específicas do objeto filho ([Section]* em nosso exemplo).

Se a classe [Teacher] não definisse uma propriedade [Identity], a expressão [e.Identity], em que [e] é um professor, referir-se-ia à propriedade [Identity] herdada da classe [Person]: ela é pública e, por herança, torna-se uma propriedade pública da classe [Teacher]. Isso resultaria então na identidade da parte [Person] do professor, sem a sua seção.

4.2.3. Ocultação de uma propriedade ou método: a palavra-chave new

Para obter a identidade completa de um professor, a classe [Teacher] define sua própria propriedade [Identity]:

    // propriedade Identity: ela oculta (new) a da classe pai
    public new string Identity => $"Teacher[{base.Identity},{Section}]";

A propriedade [Identity] da classe [Teacher] apoia-se na propriedade [Identity] de sua classe-mãe, designada como [base.Identity], para obter a parte “Person” e depois a complementa com a seção, que é específica da classe [Teacher].

Considere um objeto professor [E]. Esse objeto contém um objeto [Person]:

Image

A propriedade [Identity] é definida tanto na classe [Teacher] quanto em sua classe-mãe [Person]. Na classe filha [Teacher], a propriedade [Identity] é precedida pela palavra-chave [new] para indicar que uma nova propriedade, [Identity], é intencionalmente definida para a classe [Teacher] (sem [new], o compilador emite um aviso). A classe [Teacher] tem agora duas propriedades [Identity]:

  • uma herdada da classe-mãe [Person];
  • a sua própria.

Se [E] é um objeto [Teacher], [E.Identity] refere-se à propriedade [Identity] da classe [Teacher]. Diz-se que a propriedade [Identity] da classe filha mascara (oculta) a propriedade [Identity] da classe-mãe. De modo geral, se [O] é um objeto e [M] é um método, para executar o método [O.M], o compilador procura um método [M] na seguinte ordem:

  • na classe do objeto [O];
  • na sua classe-mãe, se houver;
  • na classe-mãe de sua classe-mãe, se existir;
  • e assim por diante.

A herança permite, portanto, que a classe filha redefina métodos e propriedades com os mesmos nomes dos da classe-mãe. É isso que permite adaptar a classe filha às suas próprias necessidades.

O programa de teste [Program.cs] do projeto [Inheritance1] é o seguinte:

using Inheritance1;

// um professor
Teacher e = new Teacher("Lucile", "Dumas", 56, 61);
// a propriedade Identity da classe Teacher
Console.WriteLine(e.Identity);
// a propriedade Identity da classe Person continua presente
Console.WriteLine(((Person)e).Identity);
// uma pessoa
Person p = new Person("Jean", "Dupont", 30);
// o método Display recebe uma Person ou um objeto de uma classe derivada
Display(e);
Display(p);
// o método ToString herdado da classe object
Console.WriteLine(e.ToString());
Console.WriteLine(p.ToString());
Console.WriteLine($"Number of persons created: {Person.NbPersons}");

// exibe a identidade de p
static void Display(Person p)
{
    Console.WriteLine(p.Identity);
}
  • linha 4: cria um professor;
  • linha 6: exibe sua identidade, a da classe [Teacher];
  • linha 8: o operador de conversão [(Person)] trata o objeto [e] como um [Person]: a propriedade [Identity] da classe [Person] é então usada;
  • linhas 12 e 13: chamada da função [Display] (linhas 20 a 22) com um professor e depois com uma pessoa. Voltaremos a isso no próximo parágrafo;
  • linhas 15 e 16: chamada do método [ToString] nos dois objetos. Também voltaremos a isso.

Resultados:

> dotnet run
Constructor Person(string, string, int)
Constructor Teacher(string, string, int, int)
Teacher[[Lucile, Dumas, 56],61]
[Lucile, Dumas, 56]
Constructor Person(string, string, int)
[Lucile, Dumas, 56]
[Jean, Dupont, 30]
Inheritance1.Teacher
Inheritance1.Person
Number of persons created: 2

Podemos ver que:

  • um objeto [Person] (linha 2) foi criado antes do objeto [Teacher] (linha 3);
  • [e.Identity] forneceu a identidade completa do professor (linha 4), e [((Person)e).Identity] forneceu a identidade de sua parte [Person] (linha 5).

4.2.4. Polimorfismo

Considere uma hierarquia de classes: C0 ← C1 ← C2 ← … ← Cn, em que Ci ← Cj indica que a classe Cj deriva da classe Ci. Isso implica que a classe Cj tem todas as características da classe Ci, além de outras adicionais. Sejam Oi objetos do tipo Ci. É válido escrever [Oi = Oj] com j > i. De fato, por herança, a classe Cj tem todas as características da classe Ci, além de outras adicionais. Portanto, um objeto Oj do tipo Cj contém um objeto do tipo Ci. A operação [Oi = Oj] faz com que Oi seja uma referência ao objeto do tipo Ci contido no objeto Oj.

O fato de uma variável Oi da classe Ci poder referenciar não apenas um objeto da classe Ci, mas qualquer objeto derivado da classe Ci, chama-se polimorfismo: a capacidade de uma variável de referenciar diferentes tipos de objetos.

Tomemos um exemplo e consideremos a função [Display] do programa anterior:

1
2
3
4
static void Display(Person p)
{
    Console.WriteLine(p.Identity);
}

Podemos passar a ela tanto um *[Person]* quanto um *[Teacher]: neste último caso, o parâmetro formal [p], que é do tipo [Person], recebe um valor do tipo [Teacher]. Como o tipo [Teacher] deriva do tipo [Person]*, isso é válido.

A propriedade [p.Identity] retorna uma string que identifica o objeto [Person] [p]. O que acontece se o parâmetro passado à função [Display] for um objeto do tipo [Teacher]? Os resultados anteriores mostram que: a instrução [p.Identity] executou, a cada vez, a propriedade [Identity] de um [Person] , primeiro a pessoa contida no professor [e] (linha 7), depois a própria pessoa [p] (linha 8). Ela não se adaptou ao objeto realmente passado como parâmetro para [Display]. Teríamos preferido obter a identidade completa do professor [e]. Para isso, a notação [p.Identity] teria de se referir à propriedade [Identity] do objeto realmente apontado por [p], e não à propriedade [Identity] da parte “Person” desse objeto. Com a ocultação ([new]), a propriedade é selecionada em tempo de compilação, com base no tipo declarado da variável ([Person]).

4.2.5. Redefinição e polimorfismo: virtual e override

É possível obter o resultado desejado declarando [Identity] como uma propriedade virtual ([virtual]) na classe base [Person]. É o que faz o projeto [Inheritance2]; sua classe [Person] é igual à do projeto [Inheritance1], com duas alterações:

    // identidade da pessoa: propriedade virtual
    public virtual string Identity => $"[{FirstName}, {LastName}, {Age}]";

    // redefinição do método ToString da classe object
    public override string ToString() => Identity;
  • Linha 38: a palavra-chave [virtual] faz de [Identity] uma propriedade virtual. Essa palavra-chave também pode ser aplicada a métodos. As classes filhas que sobrescrevem uma propriedade ou um método virtual devem então usar a palavra-chave [override] em vez de [new] para qualificar a propriedade ou o método sobrescrito;
  • linha 41: uma redefinição do método [ToString], discutida no parágrafo seguinte.

Na classe [Teacher], a propriedade [Identity] é redefinida da seguinte forma:

namespace Inheritance2;

// uma classe selada (sealed): nenhuma classe pode derivar dela
public sealed class Teacher : Person
{
    // construtor
    public Teacher(string firstName, string lastName, int age, int section)
        : base(firstName, lastName, age)
    {
        Section = section;
        Console.WriteLine("Constructor Teacher(string, string, int, int)");
    }

    // propriedade Section
    public int Section { get; set; }

    // propriedade Identity: ela redefine (override) a da classe pai
    public override string Identity => $"Teacher[{base.Identity},{Section}]";
}
  • Linha 18: a propriedade [Identity] sobrescreve a da classe-mãe;
  • Linha 4: a classe é selada ([sealed]), o que explicaremos com mais detalhes adiante.

Com uma propriedade ou um método virtual, a escolha da propriedade executada por [p.Identity] é feita em tempo de execução, com base no tipo real do objeto referenciado por [p]. O programa [Program.cs] do projeto [Inheritance2] é o seguinte:

using Inheritance2;

// um professor
Teacher e = new Teacher("Lucile", "Dumas", 56, 61);
Display(e);
// uma pessoa
Person p = new Person("Jean", "Dupont", 30);
Display(p);
// Console.WriteLine(object) exibe o resultado do método ToString do objeto
Console.WriteLine(e);
Console.WriteLine(p);
// um array de pessoas de tipos diferentes
Person[] persons = [p, e];
foreach (Person person in persons)
{
    Console.WriteLine($"{person.GetType().Name} : {person}");
}

// exibe a identidade de p
static void Display(Person p)
{
    Console.WriteLine(p.Identity);
}

Resultados:

> dotnet run
Constructor Person(string, string, int)
Constructor Teacher(string, string, int, int)
Teacher[[Lucile, Dumas, 56],61]
Constructor Person(string, string, int)
[Jean, Dupont, 30]
Teacher[[Lucile, Dumas, 56],61]
[Jean, Dupont, 30]
Person : [Jean, Dupont, 30]
Teacher : Teacher[[Lucile, Dumas, 56],61]

Desta vez, na linha 4, a função [Display] exibiu corretamente o nome completo do professor.

4.2.6. O método ToString

A classe [object] (o alias C# da classe [System.Object]) é a classe “mãe” de todas as classes C#. Portanto, quando você escreve:

public class Person

você está escrevendo implicitamente:

public class Person : object

A classe [object] define um método virtual, [ToString], que por padrão retorna o nome completo da classe do objeto. Foi isso que as duas últimas linhas da saída do projeto [Inheritance1] exibiram, com as chamadas a [e.ToString()] e [p.ToString()]: [Inheritance1.Teacher] e [Inheritance1.Person]. Embora não tenhamos sobrescrito o método [ToString] nas classes [Person] e [Teacher] , o método [ToString] da classe [object] conseguiu exibir o nome real da classe do objeto.

No projeto [Inheritance2], a classe [Person] redefine o método [ToString] (veja acima):

    public override string ToString() => Identity;

Voltemos ao programa [Program.cs] do projeto [Inheritance2]:

// Console.WriteLine(object) exibe o resultado do método ToString do objeto
Console.WriteLine(e);
Console.WriteLine(p);
// um array de pessoas de tipos diferentes
Person[] persons = [p, e];
foreach (Person person in persons)
{
    Console.WriteLine($"{person.GetType().Name} : {person}");
}

Na linha 10, o método [WriteLine] da classe [Console] não tem uma variante que aceite um parâmetro do tipo [Person]. Entre as várias variantes de [WriteLine], há uma que aceita um parâmetro do tipo [object]. O compilador usará esse método, [WriteLine(object o)], porque essa assinatura significa que o parâmetro [o] pode ser do tipo [object] ou de um tipo derivado. Como [object] é a superclasse de todas as classes, qualquer objeto pode ser passado como parâmetro para [WriteLine], inclusive um objeto do tipo [Person] ou [Teacher]. O método [WriteLine(object o)] escreve [o.ToString()] no console. Como o método [ToString] é virtual, é usado o método [ToString] do objeto real, neste caso o da classe [Person]. Esse método retorna [Identity], que também é uma propriedade virtual: para o professor [e], é portanto a propriedade [Identity] da classe [Teacher] que é usada, como mostra a linha 7 dos resultados. Portanto, é desnecessário redefinir [ToString] na classe [Teacher], ao contrário do curso de 2008.

O mesmo mecanismo se aplica à interpolação de strings: em [$"{person}"] (linha 16), o objeto [person] é convertido em string por seu método [ToString]. O laço das linhas 14 a 16 percorre um array de referências a [Person], que na verdade apontam para objetos de tipos diferentes: o método [GetType] (que também é herdado de [object]) retorna o tipo real do objeto, cuja propriedade [Name] é o nome.

4.2.7. Classes seladas

A classe [Teacher] do projeto [Inheritance2] é declarada como [public sealed class Teacher : Person]. A palavra-chave [sealed] impede que classes sejam derivadas da classe [Teacher]: a declaração [class TeacherResearcher : Teacher] seria rejeitada pelo compilador. Uma classe é selada quando não se destina a ser derivada; o compilador e o runtime também podem otimizar as chamadas a seus métodos virtuais. A palavra-chave também se aplica a um método ou propriedade redefinido: [public sealed override string Identity] impediria que classes derivadas o redefinissem novamente, sem proibir a derivação da classe.

Inversamente, um método ou propriedade que não é declarado como [virtual], [abstract] (veja adiante) ou [override] não pode ser sobrescrito com [override]: em C#, ao contrário do Java, os métodos não são virtuais por padrão.

4.3. Redefinição do significado de um operador para uma classe

4.3.1. Introdução

Considere a expressão [op1 + op2], em que [op1] e [op2] são dois operandos. É possível redefinir o significado do operador [+]. Se o operando [op1] for uma instância da classe [C1], deve-se definir um método estático na classe [C1] com a seguinte assinatura:

public static Type operator +(C1 operand1, C2 operand2)

Quando o compilador encontra a expressão [op1 + op2], ele a traduz para [C1.operator +(op1, op2)]. O tipo retornado pelo método [operator] é importante. De fato, considere a operação [op1 + op2 + op3]. Ela é traduzida pelo compilador como [(op1 + op2) + op3]. Seja [res12] o resultado de [op1 + op2]. A operação seguinte é [res12 + op3]. Se [res12] for do tipo [C1], ela também será traduzida para [C1.operator +(res12, op3)]. Isso permite encadear operações.

Os operadores unários, com um único operando, também podem ser redefinidos. Assim, se [op1] for um objeto do tipo [C1], a operação [op1++] pode ser redefinida por um método estático da classe [C1]:

public static C1 operator ++(C1 operand1)

O que foi dito aqui se aplica à maioria dos operadores, com algumas exceções:

  • Os operadores [==] e [!=] devem ser redefinidos em conjunto, assim como [<] e [>], [<=] e [>=];
  • os operadores [&&], [||], [=], [.], [?:], [??]e [new] não podem ser redefinidos;
  • até o C# 13, os operadores de atribuição composta ([+=], [-=], …) não podiam ser sobrescritos: [a += b] era sempre compilado como [a = a + b]. O C# 14 permite sobrescrevê-los, como veremos.

4.3.2. Um exemplo

O projeto [Lists] da solução define uma classe chamada [ListOfPersons], que é uma lista de pessoas. As classes [Person] e [Teacher] deste projeto são as mesmas do projeto [Inheritance2], mas sem as mensagens de acompanhamento e o contador de pessoas. O curso de 2008 fazia a classe *[ListOfPersons] derivar da classe *[ArrayList]*, uma lista de objetos do tipo *[object], hoje obsoleta. Usamos a lista genérica [List<Person>] (as classes genéricas são tratadas mais adiante neste capítulo; a classe [List<T>] é abordada no próximo capítulo) e, em vez de herdar dela, a colocamos em um campo privado da classe. Fala-se em usar composição em vez de herança: a classe [ListOfPersons] expõe assim apenas as operações que escolheu. Da classe [List<Person>], usamos apenas os seguintes elementos:

  • o método [L.Add(p)], que adiciona a pessoa [p] à lista [L], e o método [L.AddRange(L2)], que adiciona a ela todos os elementos da lista [L2];
  • a propriedade [L.Count], que retorna o número de elementos da lista [L];
  • a notação [L[i]], que designa o elemento de número i da lista [L].

A definição da classe [ListOfPersons] é a seguinte: [ListOfPersons.cs]:

namespace Lists;

public class ListOfPersons
{
    // as pessoas da lista
    private readonly List<Person> persons = [];

    // número de pessoas na lista
    public int Count => persons.Count;

    // operador +: retorna uma nova lista contendo as pessoas de l e a pessoa p
    public static ListOfPersons operator +(ListOfPersons l, Person p)
    {
        ListOfPersons result = new ListOfPersons();
        result.persons.AddRange(l.persons);
        result.persons.Add(p);
        return result;
    }

    // operador de atribuição composta += (C# 14): adiciona p à lista atual
    public void operator +=(Person p)
    {
        persons.Add(p);
    }

    // indexador por posição, leitura e escrita
    public Person this[int i]
    {
        get { return persons[i]; }
        set { persons[i] = value; }
    }

    // indexador por sobrenome, somente leitura: retorna a posição da pessoa ou -1
    public int this[string lastName]
    {
        get
        {
            // procuramos a pessoa
            for (int i = 0; i < persons.Count; i++)
            {
                if (persons[i].LastName == lastName)
                {
                    return i;
                }
            }
            return -1;
        }
    }

    // ToString: retorna (person1,person2,...)
    public override string ToString()
    {
        return "(" + string.Join(",", persons) + ")";
    }
}
  • linha 6: a lista de pessoas. A palavra-chave [readonly] indica que o campo só pode ser atribuído no momento de sua declaração ou dentro de um construtor: o conteúdo da lista pode mudar, mas o campo sempre se referirá à mesma lista. [] é uma expressão de coleção vazia: o tipo da coleção criada, [List<Person>], é inferido a partir do tipo do campo;
  • linha 9: o número de pessoas, uma propriedade somente leitura;
  • linhas 12 a 17: definição do operador [+] para a operação [l + p], em que [l] é do tipo [ListOfPersons] e [p] é do tipo [Person] ou de um tipo derivado. O operador cria uma nova lista (linha 14), copia para ela as pessoas de [l] (linha 15) e depois adiciona a pessoa [p] (linha 16). Como acontece com o operador [+] para números ou strings, os operandos não são modificados. Como a lista [l] é da mesma classe, o operador tem acesso ao seu campo privado [l.persons]. A lista resultante é do tipo [ListOfPersons], o que permite encadear os operadores [+] como em [l + p1 + p2], interpretado (precedência dos operadores) como [(l + p1) + p2];
  • linhas 21 a 23: definição do operador [+=] (C# 14). Ao contrário dos outros operadores, este não é um método estático, mas um método de instância sem valor de retorno ([void]): ele modifica o objeto atual, neste caso adicionando a ele a pessoa [p];
  • linhas 51 a 53: redefinimos o método [ToString] para exibir uma lista de pessoas na forma (pessoa1, pessoa2, ...), em que pessoai é o resultado do método [ToString] da própria pessoa. O método estático [string.Join(separator, elements)] concatena as representações textuais dos elementos, separando-as com o separador. O curso de 2008 construía essa string manualmente com um objeto [StringBuilder].

Observe que a classe [ListOfPersons] não tem construtor. Ela usa, portanto, o construtor padrão [public ListOfPersons()], que apenas inicializa o campo [persons] com o valor especificado em sua declaração. As linhas 26 a 46 são discutidas na seção seguinte.

O programa de teste [Program.cs] começa assim:

using Lists;

// operador +
// uma lista de pessoas
ListOfPersons l = new ListOfPersons();
// adição de pessoas
l = l + new Person("jean", "martin", 10) + new Person("pauline", "leduc", 12);
// exibição
Console.WriteLine("l=" + l);
// l + p retorna uma nova lista: l não é modificada
ListOfPersons l2 = l + new Person("louis", "durand", 8);
Console.WriteLine("l=" + l);
Console.WriteLine("l2=" + l2);

// operador += (C# 14)
ListOfPersons l3 = l;
// += adiciona o professor à lista referenciada por l, sem criar uma nova lista
l += new Teacher("camille", "germain", 27, 60);
Console.WriteLine("l=" + l);
// l e l3 ainda referenciam o mesmo objeto
Console.WriteLine($"l3=l : {ReferenceEquals(l, l3)}");
  • linha 5: criação de uma lista vazia de pessoas [l];
  • linha 7: adiciona duas pessoas com o operador [+];
  • linha 11: [l + p] cria uma nova lista [l2]; a lista [l] permanece inalterada;
  • linha 18: adiciona um professor com o operador [+=];
  • Linhas 9 a 13: a concatenação de uma string e de um objeto usa o método [ToString], que é redefinido na classe [ListOfPersons].

Resultados:

1
2
3
4
5
6
> dotnet run
l=([jean, martin, 10],[pauline, leduc, 12])
l=([jean, martin, 10],[pauline, leduc, 12])
l2=([jean, martin, 10],[pauline, leduc, 12],[louis, durand, 8])
l=([jean, martin, 10],[pauline, leduc, 12],Teacher[[camille, germain, 27],60])
l3=l : True

4.3.3. Operadores de atribuição composta (C# 14)

Por que definir o operador [+=] se [l = l + p] produz o mesmo resultado? Se a classe não define [+=], o compilador traduz [l += p] para [l = l + p]: uma nova lista é criada, todas as pessoas de [l] são copiadas para ela, depois [l] passa a se referir a essa nova lista, e a antiga é descartada pelo coletor de lixo. Com o operador [+=] definido pela classe, a pessoa é adicionada à lista existente sem cópia. A linha 16 armazena uma segunda referência, [l3], à lista [l]; depois da instrução [l += ...], as duas referências continuam apontando para o mesmo objeto (linha 6 dos resultados), o que prova que a lista não foi recriada. Para uma lista grande, ou em um laço, a diferença de desempenho é significativa.

4.4. Definição de um indexador para uma classe

Aqui, continuamos a usar a classe [ListOfPersons]. Se [l] é uma instância de [ListOfPersons], queremos poder usar a notação [l[i]] para designar a pessoa de número i da lista [l], tanto para leitura ([Person p = l[i]]) quanto para escrita ([l[i] = new Person(...)]).

Para poder escrever [l[i]], em que [l[i]] designa um objeto [Person], precisamos definir uma propriedade específica chamada [this] na classe [ListOfPersons]:

    // indexador por posição, leitura e escrita
    public Person this[int i]
    {
        get { return persons[i]; }
        set { persons[i] = value; }
    }

    // indexador por sobrenome, somente leitura: retorna a posição da pessoa ou -1
    public int this[string lastName]
    {
        get
        {
            // procuramos a pessoa
            for (int i = 0; i < persons.Count; i++)
            {
                if (persons[i].LastName == lastName)
                {
                    return i;
                }
            }
            return -1;
        }
    }

A propriedade [this[int i]] é chamada de indexador porque dá sentido à expressão [obj[i]], que se parece com a notação de array, embora [obj] não seja um array, mas um objeto. O método [get] do indexador do objeto [obj] é chamado quando se escreve [variable = obj[i]] e o método [set] é chamado quando se escreve [obj[i] = value].

  • Linhas 27 a 30: o indexador baseado em posição. O método [get] retorna a pessoa de número i da lista privada [persons], e o método [set] atribui a ela a pessoa [value]. O curso de 2008, cuja classe derivava de [ArrayList], precisava mascarar o indexador da classe-mãe com a palavra-chave [new] e converter o elemento do tipo [object] que ele retornava para [Person]. Com uma lista genérica, não é mais necessária nenhuma conversão;
  • linhas 34 a 46: também queremos poder escrever [int i = l["lastName"]], ou seja, indexar a lista [l] não por um número de elemento, mas pelo sobrenome de uma pessoa. O resultado de [l[lastName]] é um inteiro: a posição na lista da pessoa com o sobrenome [lastName], ou -1 se essa pessoa não estiver na lista. Apenas o método [get] é definido, o que impede a sintaxe [l["lastName"] = value], que exigiria a definição de um método [set]. Uma classe pode ter vários indexadores, desde que seus parâmetros sejam diferentes.

O programa de teste continua assim:

// indexadores
// mudança do elemento nº 1
l[1] = new Person("franck", "gallon", 5);
// exibição do elemento nº 1
Console.WriteLine("l[1]=" + l[1]);
// exibição da lista l
Console.WriteLine("l=" + l);
// busca de pessoas pelo sobrenome
string[] lastNames = ["martin", "germain", "xx"];
foreach (string lastName in lastNames)
{
    int index = l[lastName];
    if (index != -1)
    {
        Console.WriteLine($"Person({lastName})={l[index]}");
    }
    else
    {
        Console.WriteLine($"Person({lastName}) does not exist");
    }
}
  • linha 25: chamada do método [set] do indexador [this[int]];
  • linha 27: chamada de seu método [get];
  • Linha 34: chamada do indexador [this[string]];
  • linha 37: chamada do indexador [this[int]].

Resultados:

l[1]=[franck, gallon, 5]
l=([jean, martin, 10],[franck, gallon, 5],Teacher[[camille, germain, 27],60])
Person(martin)=[jean, martin, 10]
Person(germain)=Teacher[[camille, germain, 27],60]
Person(xx) does not exist

4.5. Estruturas

4.5.1. Valor e referência

A estrutura do C# é análoga à estrutura da linguagem C e muito semelhante ao conceito de classe. Uma estrutura é definida da seguinte forma:

struct StructureName
{
    // campos
    ...
    // propriedades
    ...
    // construtores
    ...
    // métodos
    ...
}

Apesar das semelhanças em suas declarações, há diferenças significativas entre classes e estruturas. Por exemplo, o conceito de herança não existe com estruturas (uma estrutura pode, no entanto, implementar interfaces, que serão tratadas adiante). Se estamos escrevendo uma classe que não se destina a ser derivada, quais são as diferenças entre uma estrutura e uma classe que nos ajudarão a escolher entre as duas? Vejamos pelo exemplo a seguir: [classes-13.cs]:

// estrutura e classe: cópia de valor, cópia de referência
// uma estrutura sp1
SPerson sp1;
sp1.Name = "paul";
sp1.Age = 10;
Console.WriteLine("sp1=SPerson(" + sp1.Name + "," + sp1.Age + ")");
// uma estrutura sp2
SPerson sp2 = sp1;
Console.WriteLine("sp2=SPerson(" + sp2.Name + "," + sp2.Age + ")");
// sp2 é modificada
sp2.Name = "nicole";
sp2.Age = 30;
// verificação de sp1 e sp2
Console.WriteLine("sp1=SPerson(" + sp1.Name + "," + sp1.Age + ")");
Console.WriteLine("sp2=SPerson(" + sp2.Name + "," + sp2.Age + ")");

// um objeto op1
CPerson op1 = new CPerson();
op1.Name = "paul";
op1.Age = 10;
Console.WriteLine("op1=CPerson(" + op1.Name + "," + op1.Age + ")");
// um objeto op2
CPerson op2 = op1;
Console.WriteLine("op2=CPerson(" + op2.Name + "," + op2.Age + ")");
// op2 é modificado
op2.Name = "nicole";
op2.Age = 30;
// verificação de op1 e op2
Console.WriteLine("op1=CPerson(" + op1.Name + "," + op1.Age + ")");
Console.WriteLine("op2=CPerson(" + op2.Name + "," + op2.Age + ")");

// estrutura SPerson
struct SPerson
{
    public string Name;
    public int Age;
}

// classe CPerson
class CPerson
{
    public string Name = "";
    public int Age;
}
  • linhas 33 a 36: uma estrutura com dois campos públicos: [Name], [Age];
  • linhas 40 a 43: uma classe com dois campos públicos: [Name], [Age]. Os campos públicos, geralmente desaconselhados, tornam este exemplo mais legível.

Resultados:

1
2
3
4
5
6
7
8
9
> dotnet run classes-13.cs
sp1=SPerson(paul,10)
sp2=SPerson(paul,10)
sp1=SPerson(paul,10)
sp2=SPerson(nicole,30)
op1=CPerson(paul,10)
op2=CPerson(paul,10)
op1=CPerson(nicole,30)
op2=CPerson(nicole,30)

Esta estrutura não tem construtor aqui. Ela poderia ter um, como mostraremos adiante. Por padrão, ela sempre tem um construtor sem parâmetros, neste caso [SPerson()], que zera todos os seus campos ([null] para as referências).

A declaração da linha 3 cria uma estrutura ([Name], [Age]), e o valor de [sp1] é essa própria estrutura. Seus campos ainda não têm valores: o compilador exige que todos sejam atribuídos (linhas 4 e 5) antes de a estrutura ser usada (linha 6). No caso de uma classe, o objeto ([Name], [Age]) deve ser criado explicitamente com o operador [new] (linha 18). A instrução cria um objeto [CPerson] (aproximadamente equivalente à nossa estrutura), e o valor de [op1] é então o endereço (a referência) desse objeto.

Em resumo:

  • no caso da estrutura, o valor de [sp1] é a própria estrutura;
  • no caso da classe, o valor de [op1] é o endereço do objeto criado.

Image

Quando se escreve [SPerson sp2 = sp1;] no programa (linha 8), uma nova estrutura [sp2] ([Name], [Age]) é criada e inicializada com o valor de [sp1], que é a própria estrutura:

Image

A estrutura de [sp1] é duplicada em [sp2] (lado esquerdo do diagrama). Trata-se de uma cópia de valor. Consideremos agora a instrução [CPerson op2 = op1;] (linha 23). No caso das classes, o valor de [op1] é copiado para [op2], mas, como esse valor é na verdade o endereço do objeto, o objeto em si não é duplicado (lado direito do diagrama).

No caso da estrutura, alterar o valor de [sp2] não altera o valor de [sp1], como mostra o programa (linhas 4 e 5 dos resultados). No caso do objeto, se modificarmos o objeto apontado por [op2], o apontado por [op1] também é modificado, já que são o mesmo (linhas 8 e 9).

Podemos, portanto, concluir dessas explicações que:

  • o valor de uma variável do tipo estrutura é a própria estrutura;
  • o valor de uma variável do tipo classe é o endereço do objeto para o qual ela aponta.

Diz-se que as estruturas são tipos de valor e as classes são tipos de referência. Os tipos simples do C# ([int], [double], [decimal], [bool], [char], …) são estruturas do .NET ([System.Int32], [System.Double], …), ao passo que [string] e os arrays são tipos de referência. Uma estrutura é adequada para representar um dado pequeno (um ponto, uma cor, uma data, um valor monetário…) tratado como um valor. Uma estrutura não é alocada individualmente no heap do coletor de lixo: uma variável local do tipo estrutura geralmente é colocada na pilha, e um array de estruturas contém as próprias estruturas, e não referências a elas.

4.5.2. Uma estrutura com propriedades e construtores

Uma vez compreendida a diferença fundamental entre valor e referência, uma estrutura se mostra muito semelhante a uma classe, como mostra o exemplo a seguir [classes-14.cs]:

// uma estrutura com construtores, propriedades e um método
// uma pessoa p1
SPerson p1 = new SPerson();
Console.WriteLine($"p1={p1}");
p1.Name = "paul";
p1.Age = 10;
Console.WriteLine($"p1={p1}");
// uma pessoa p2
SPerson p2 = p1;
Console.WriteLine("p2=" + p2);
// p2 é modificada
p2.Name = "nicole";
p2.Age = 30;
// verificação de p1 e p2
Console.WriteLine("p1=" + p1);
Console.WriteLine("p2=" + p2);
// uma pessoa p3
SPerson p3 = new SPerson("amandin", 18);
Console.WriteLine("p3=" + p3);
// uma pessoa p4
SPerson p4 = new SPerson { Name = "x", Age = 10 };
Console.WriteLine("p4=" + p4);
// o valor padrão de uma estrutura: todos os campos zerados (null para referências)
SPerson p5 = default;
Console.WriteLine("p5=" + p5);
// igualdade de duas estruturas: comparação dos valores dos campos
SPerson p6 = new SPerson("nicole", 30);
Console.WriteLine($"p1.Equals(p2) : {p1.Equals(p2)}, p2.Equals(p6) : {p2.Equals(p6)}");

// estrutura SPerson
struct SPerson
{
    // construtores
    public SPerson(string name, int age)
    {
        Name = name;
        Age = age;
    }

    public SPerson() : this("?", 0)
    {
    }

    // propriedades
    public string? Name { get; set; }
    public int Age { get; set; }

    // ToString
    public override string ToString()
    {
        return $"SPerson({Name},{Age})";
    }
}
  • linhas 34 a 37: um construtor com dois parâmetros. O curso de 2008 explicava que o construtor de uma struct não podia inicializar campos por meio de propriedades: essa restrição foi removida (C# 11);
  • linha 40: desde o C# 10, uma struct pode declarar seu próprio construtor sem parâmetros, que aqui é encadeado ao anterior. Ele é chamado por [new SPerson()] (linha 3) e pelo inicializador de objeto da linha 21, que em seguida modifica as duas propriedades;
  • linhas 45 e 46: duas propriedades automáticas. A propriedade [Name] é declarada do tipo [string?] (uma string que pode ser [null]) porque uma struct sempre pode ser criada sem usar um construtor: é o caso de seu valor padrão (linha 24), em que todos os campos são zerados e o nome é, portanto, [null], bem como dos elementos de um array de estruturas recém-criado;
  • linhas 49 a 51: redefinição do método [ToString]. Uma estrutura deriva implicitamente da classe [System.ValueType], que por sua vez deriva de [object];
  • linha 28: o método [Equals], herdado de [ValueType], compara duas estruturas campo a campo. O operador [==], por outro lado, não é definido para uma estrutura, a menos que seja sobrescrito.

Resultados:

> dotnet run classes-14.cs
p1=SPerson(?,0)
p1=SPerson(paul,10)
p2=SPerson(paul,10)
p1=SPerson(paul,10)
p2=SPerson(nicole,30)
p3=SPerson(amandin,18)
p4=SPerson(x,10)
p5=SPerson(,0)
p1.Equals(p2) : False, p2.Equals(p6) : True

No final do programa, as estruturas [p1] e [p2] são diferentes (linhas 5 e 6): com uma classe, [p1] e [p2] teriam se referido ao mesmo objeto.

4.5.3. Estruturas imutáveis e estruturas de registro

Uma estrutura cujo estado pode ser modificado pode levar a resultados inesperados: como ela é copiada a cada atribuição ou passagem de parâmetro, muitas vezes se modifica uma cópia achando que se está modificando o original. Por isso, recomenda-se tornar as estruturas imutáveis: uma vez criadas, elas não podem mais ser modificadas. O programa [classes-15.cs] demonstra as duas maneiras de fazer isso:

// estruturas imutáveis (readonly struct) e estruturas de registro (record struct)
Point a = new Point(1, 2);
// a.X = 5;   // rejeitado: as propriedades de uma readonly struct não podem ser modificadas
Point b = a.Move(3, 4);
Console.WriteLine($"a={a}, b={b}");

// uma record struct: ToString, Equals, == e != são gerados pelo compilador
PointR r1 = new PointR(1, 2);
PointR r2 = new PointR(1, 2);
Console.WriteLine($"r1={r1}, r2={r2}");
Console.WriteLine($"r1 == r2 : {r1 == r2}");
// uma record struct (não readonly) pode ser modificada
r2.Y = 20;
Console.WriteLine($"r2={r2}, r1 == r2 : {r1 == r2}");
// a expressão with cria uma cópia modificada
PointR r3 = r1 with { X = 10 };
Console.WriteLine($"r3={r3}");

// uma readonly record struct é imutável
Color red = new Color(255, 0, 0);
Color pink = red with { G = 128, B = 128 };
Console.WriteLine($"red={red}, pink={pink}");
// pink.G = 0;   // rejeitado: a estrutura é somente leitura

// uma estrutura imutável
readonly struct Point
{
    public Point(int x, int y)
    {
        X = x;
        Y = y;
    }

    public int X { get; }
    public int Y { get; }

    // não modificamos o ponto: retornamos um novo
    public Point Move(int dx, int dy) => new Point(X + dx, Y + dy);

    public override string ToString() => $"({X},{Y})";
}

// uma estrutura de registro "posicional": X e Y são propriedades públicas
record struct PointR(int X, int Y);

// uma estrutura de registro imutável
readonly record struct Color(byte R, byte G, byte B);
  • linhas 26 a 40: uma estrutura declarada como [readonly] (C# 7.2). O compilador verifica se todos os seus campos e propriedades são somente leitura. Para “mover” um ponto, o método [Move] retorna um novo ponto (linha 38);
  • linha 44: uma estrutura de registro (record struct) (C# 10). Esta única linha declara uma estrutura cujo construtor tem dois parâmetros, [X] e [Y], e que tem duas propriedades públicas de leitura e escrita, [X] e [Y]. O compilador também gera um método chamado [ToString] que exibe o nome da estrutura e suas propriedades, os métodos de igualdade e os operadores [==] e [!=] (linha 11), além do suporte à expressão [with], que cria uma cópia da estrutura modificando certas propriedades (linha 16);
  • linha 47: uma estrutura de registro imutável: suas propriedades são somente leitura (mais precisamente, [init]: só podem ser definidas na criação), enquanto a expressão [with] continua válida (linha 21).

Resultados:

1
2
3
4
5
6
7
> dotnet run classes-15.cs
a=(1,2), b=(4,6)
r1=PointR { X = 1, Y = 2 }, r2=PointR { X = 1, Y = 2 }
r1 == r2 : True
r2=PointR { X = 1, Y = 20 }, r1 == r2 : False
r3=PointR { X = 10, Y = 2 }
red=Color { R = 255, G = 0, B = 0 }, pink=Color { R = 255, G = 128, B = 128 }

Os registros ([record]) também existem como classes: vamos examiná-los em detalhe um pouco mais adiante. Por ora, observemos apenas que um [readonly record struct] é a forma mais concisa de declarar um dado pequeno e imutável de tipo de valor: é o tipo que usaremos para as faixas do imposto de renda no aplicativo de exemplo deste capítulo.

4.6. Interfaces

4.6.1. Um primeiro exemplo

Uma interface é um conjunto de declarações de métodos ou propriedades que forma um contrato. Uma classe (ou estrutura) que opta por implementar uma interface compromete-se a fornecer uma implementação de todos os métodos e propriedades definidos na interface. O compilador verifica essa implementação.

Por exemplo, eis a definição da interface [System.Collections.IEnumerator] do .NET:

1
2
3
4
5
6
7
8
public interface IEnumerator
{
    // propriedades
    object Current { get; }
    // métodos
    bool MoveNext();
    void Reset();
}

As propriedades e os métodos da interface são definidos apenas por suas assinaturas. Eles não são implementados (não têm código). São as classes que implementam a interface que fornecem o código dos métodos e propriedades da interface:

1
2
3
4
5
6
7
public class C : IEnumerator
{
    ...
    public object Current { get { ... } }
    public bool MoveNext() { ... }
    public void Reset() { ... }
}
  • Linha 1: a classe [C] implementa a interface [IEnumerator]. Observe que o símbolo [:] usado para implementar uma interface é o mesmo usado para derivar uma classe;
  • Linhas 4 a 6: a implementação dos métodos e propriedades da interface [IEnumerator]. Eles devem ser públicos.

Por convenção, o nome de uma interface começa com a letra I. Os exemplos a seguir compõem o projeto [Statistics] da solução. Considere a seguinte interface, [IStats.cs]:

namespace Statistics;

public interface IStats
{
    // média de uma série de valores
    double Average { get; }

    // desvio padrão da série
    double StandardDeviation();
}

A interface [IStats] tem:

  • uma propriedade somente leitura [Average]: para calcular a média de uma série de valores;
  • um método [StandardDeviation]: para calcular o desvio padrão.

Observe que não se especifica em lugar nenhum a qual conjunto de valores se faz referência. Poderiam ser as médias das notas de uma turma, a média mensal de vendas de um determinado produto, a temperatura média em um determinado local… Esse é o princípio das interfaces: elas pressupõem a existência de métodos no objeto, mas não a de dados específicos.

Uma primeira classe de implementação da interface [IStats] pode ser uma classe usada para armazenar as notas dos alunos de uma turma em uma determinada disciplina. Um aluno é caracterizado pela seguinte estrutura [Student]: [Student.cs]:

1
2
3
4
namespace Statistics;

// um aluno
public readonly record struct Student(string FirstName, string LastName);

O aluno é identificado por seu nome e sobrenome. O curso de 2008 definia uma estrutura com duas propriedades automáticas; uma estrutura record imutável, como vista no parágrafo anterior, se resume a uma única linha. Uma nota é caracterizada pela seguinte estrutura: [Grade] [Grade.cs]:

1
2
3
4
5
6
7
namespace Statistics;

// a nota de um aluno
public readonly record struct Grade(Student Student, double Value)
{
    public override string ToString() => $"[{Student.FirstName},{Student.LastName},{Value}]";
}

A nota é definida pelo aluno avaliado e pelo valor da nota. A estrutura redefine o método [ToString] gerado pelo compilador para exibir uma nota na forma [firstName,lastName,value].

As notas de todos os alunos de uma determinada disciplina são agrupadas na seguinte classe [ArrayOfGrades]: [ArrayOfGrades.cs]:

namespace Statistics;

public class ArrayOfGrades : IStats
{
    // propriedades
    public string Subject { get; }
    public Grade[] Grades { get; }
    public double Average { get; }
    // campo
    private readonly double standardDeviation;

    // construtor
    public ArrayOfGrades(string subject, Grade[] grades)
    {
        // armazenamento dos dados
        Subject = subject;
        Grades = grades;
        // cálculo da média das notas
        double sum = 0;
        foreach (Grade grade in Grades)
        {
            sum += grade.Value;
        }
        Average = Grades.Length != 0 ? sum / Grades.Length : -1;
        // cálculo do desvio padrão
        double squares = 0;
        foreach (Grade grade in Grades)
        {
            squares += Math.Pow(grade.Value - Average, 2);
        }
        standardDeviation = Grades.Length != 0 ? Math.Sqrt(squares / Grades.Length) : -1;
    }

    // implementação do método StandardDeviation da interface IStats
    public double StandardDeviation()
    {
        return standardDeviation;
    }

    // ToString
    public override string ToString()
    {
        return $"subject={Subject}, grades=({string.Join(",", Grades)})";
    }
}
  • Linha 3: a classe [ArrayOfGrades] implementa a interface [IStats]. Ela deve, portanto, implementar a propriedade [Average] e o método [StandardDeviation]. Eles são implementados na linha 8 ([Average]) e nas linhas 35 a 37 ([StandardDeviation]);
  • linhas 6 a 8: três propriedades automáticas somente leitura: a disciplina para a qual o objeto armazena as notas, o array de notas e a média das notas;
  • linha 10: um campo que armazena o desvio padrão das notas;
  • linhas 13 a 31: o construtor. Aqui, supomos que as notas passadas ao construtor não mudarão depois. Por isso, usamos o construtor para calcular imediatamente a média e o desvio padrão dessas notas e armazená-los. Uma propriedade somente leitura como [Average] pode receber um valor no construtor (linha 24); depois disso, não é mais possível atribuir-lhe um valor. As expressões [condition ? value1 : value2] definem a média e o desvio padrão de um array vazio como -1;
  • linhas 41 a 43: o método [ToString] usa [string.Join] para concatenar as notas, cada uma convertida em string pelo método [ToString] da estrutura [Grade].

Na classe anterior, as notas eram armazenadas em um array. Não era possível adicionar uma nova nota depois que o objeto [ArrayOfGrades] era criado. Oferecemos agora uma segunda implementação da interface [IStats], chamada [ListOfGrades], na qual desta vez as notas são armazenadas em uma lista [List<Grade>], com a possibilidade de adicionar notas depois da criação inicial do objeto [ListOfGrades]: [ListOfGrades.cs]:

namespace Statistics;

public class ListOfGrades : IStats
{
    // propriedades
    public string Subject { get; }
    public List<Grade> Grades { get; }
    // média e desvio padrão armazenados (null: ainda não calculados)
    private double? average;
    private double? standardDeviation;

    // construtor
    public ListOfGrades(string subject, List<Grade> grades)
    {
        Subject = subject;
        Grades = grades;
    }

    // adição de uma nota
    public void Add(Grade grade)
    {
        Grades.Add(grade);
        // a média e o desvio padrão precisarão ser recalculados
        average = null;
        standardDeviation = null;
    }

    // média das notas: calculada na primeira solicitação
    public double Average
    {
        get
        {
            average ??= ComputeAverage();
            return average.Value;
        }
    }

    // desvio padrão das notas: calculado na primeira solicitação
    public double StandardDeviation()
    {
        standardDeviation ??= ComputeStandardDeviation();
        return standardDeviation.Value;
    }

    private double ComputeAverage()
    {
        if (Grades.Count == 0)
        {
            return -1;
        }
        double sum = 0;
        foreach (Grade grade in Grades)
        {
            sum += grade.Value;
        }
        return sum / Grades.Count;
    }

    private double ComputeStandardDeviation()
    {
        if (Grades.Count == 0)
        {
            return -1;
        }
        double m = Average;
        double squares = 0;
        foreach (Grade grade in Grades)
        {
            squares += Math.Pow(grade.Value - m, 2);
        }
        return Math.Sqrt(squares / Grades.Count);
    }

    // ToString
    public override string ToString()
    {
        return $"subject={Subject}, grades=({string.Join(",", Grades)})";
    }
}
  • Linha 3: a classe [ListOfGrades] implementa a interface [IStats];
  • linha 7: as notas agora são armazenadas em uma lista, e não em um array;
  • linhas 20 a 25: agora é possível adicionar uma nota às que já estão armazenadas. A média e o desvio padrão não são mais calculados no construtor, mas sob demanda, dentro dos próprios membros da interface: [Average] (linhas 29 a 34) e [StandardDeviation] (linhas 39 a 42). Depois de calculados, esses valores são armazenados para não serem recalculados a cada solicitação: diz-se que estão em cache. Adicionar uma nota invalida o cache;
  • linhas 9 e 10: o cache. O tipo [double?] (C# 2) é um tipo de valor anulável (nullable): uma variável desse tipo contém um [double] ou [null], o que aqui significa “ainda não calculado”. O curso de 2008 usava o valor -1 para isso;
  • linha 33: o operador [??=] (C# 8) só atribui um valor à variável à esquerda se ela for [null]. O método [ComputeAverage] é, portanto, chamado apenas se a média ainda não tiver sido calculada. A propriedade [Value] de uma variável [double?] retorna o valor [double] que ela contém.

Um programa de teste poderia ser assim: [Program.cs]:

using Statistics;

// alguns alunos e suas notas de inglês
Student[] students = [new Student("Paul", "Martin"), new Student("Maxime", "Germain"), new Student("Berthine", "Samin")];
Grade[] grades = [new Grade(students[0], 14), new Grade(students[1], 16), new Grade(students[2], 18)];
// que armazenamos em um objeto ArrayOfGrades
ArrayOfGrades english = new ArrayOfGrades("english", grades);
// exibição da média e do desvio padrão
DisplayStats(english);
// as mesmas notas em um objeto ListOfGrades
ListOfGrades french = new ListOfGrades("french", new List<Grade>(grades));
DisplayStats(french);
// adicionamos uma nota
french.Add(new Grade(new Student("Jérôme", "Jaric"), 10));
DisplayStats(french);
// uma variável pode ter uma interface como tipo
IStats stats = english;
Console.WriteLine($"English average: {stats.Average}");
stats = french;
Console.WriteLine($"French average: {stats.Average}");

// exibição da média e do desvio padrão de um objeto que implementa IStats
static void DisplayStats(IStats values)
{
    Console.WriteLine($"{values}, Average={values.Average}, Standard deviation={values.StandardDeviation()}");
}
  • linha 4: cria um array de alunos;
  • linha 5: criação de um array de notas;
  • linha 7: um objeto [ArrayOfGrades], cuja média e cujo desvio padrão são exibidos na linha 9;
  • linha 11: um objeto [ListOfGrades], cuja média e cujo desvio padrão são exibidos na linha 12. A classe [List<Grade>] tem um construtor que aceita uma coleção de notas, neste caso o array [grades];
  • linha 14: uma nova nota é adicionada, seguida de uma nova exibição;
  • linhas 23 a 25: a função [DisplayStats] recebe como parâmetro um tipo [IStats], que é um tipo de interface. Isso significa que o parâmetro real pode ser qualquer objeto que implemente a interface [IStats]. Quando se usa um dado de tipo interface, somente os métodos da interface implementados por esse objeto são utilizados. O resto é ignorado. Essa propriedade é semelhante ao polimorfismo que vimos com as classes. Se um conjunto de classes Ci, sem relação entre si por herança (e que, portanto, não podem usar o polimorfismo baseado em herança), compartilha um conjunto de métodos de mesma assinatura, pode ser útil reunir esses métodos em uma interface I que todas as classes envolvidas implementariam. As instâncias dessas classes Ci podem então ser usadas como parâmetros reais de funções que aceitam um parâmetro formal do tipo I, isto é, funções que usam apenas os métodos dos objetos Ci definidos na interface I, e não os campos e métodos específicos das várias classes Ci;
  • linhas 17 a 19: uma variável pode ter o tipo de uma interface. Ela pode então referenciar qualquer objeto de uma classe que implemente a interface. O compilador só permite o acesso aos membros da interface: a propriedade [Average] e o método [StandardDeviation].

Resultados:

1
2
3
4
5
6
> dotnet run
subject=english, grades=([Paul,Martin,14],[Maxime,Germain,16],[Berthine,Samin,18]), Average=16, Standard deviation=1,632993161855452
subject=french, grades=([Paul,Martin,14],[Maxime,Germain,16],[Berthine,Samin,18]), Average=16, Standard deviation=1,632993161855452
subject=french, grades=([Paul,Martin,14],[Maxime,Germain,16],[Berthine,Samin,18],[Jérôme,Jaric,10]), Average=14,5, Standard deviation=2,958039891549808
English average: 16
French average: 14,5

Por fim, observe que as interfaces podem ter várias implementações; ou seja, é possível escrever:

1
2
3
4
public class DerivedClass : BaseClass, I1, I2, ..., In
{
    ...
}

em que os Ij são interfaces: uma classe herda de apenas uma classe, mas pode implementar quantas interfaces quiser.

4.6.2. Métodos de interface com implementação padrão

A partir do C# 8, uma interface pode fornecer uma implementação padrão para alguns de seus métodos. Uma classe que implementa a interface pode então usar essa implementação ou fornecer a sua própria. Isso permite, por exemplo, adicionar um método a uma interface já publicada sem obrigar todas as classes que a implementam a serem modificadas. O programa [classes-16.cs] fornece um exemplo:

// métodos de interface padrão (C# 8)
IShape[] shapes = [new Square(2), new Circle(1)];
foreach (IShape shape in shapes)
{
    Console.WriteLine(shape.Description());
}
// o método padrão só é acessível por meio do tipo da interface
Square square = new Square(3);
// Console.WriteLine(square.Description());   // rejeitado: Square não define Description
Console.WriteLine(((IShape)square).Description());

public interface IShape
{
    // método a implementar
    double Area();

    // método com implementação padrão
    string Description() => $"{GetType().Name} with area {Area():F2}";
}

// Square usa a implementação padrão de Description
public class Square : IShape
{
    private readonly double side;

    public Square(double side)
    {
        this.side = side;
    }

    public double Area() => side * side;
}

// Circle fornece sua própria implementação de Description
public class Circle : IShape
{
    private readonly double radius;

    public Circle(double radius)
    {
        this.radius = radius;
    }

    public double Area() => Math.PI * radius * radius;

    public string Description() => $"Circle with radius {radius} and area {Area():F2}";
}
  • Linhas 12 a 18: a interface [IShape] declara um método, [Area], a ser implementado, e um método, [Description], com uma implementação padrão. Esse método pode usar os outros membros da interface ([Area]) e os de [object] ([GetType]). O formato [{Area():F2}] exibe a área com duas casas decimais;
  • linhas 22 a 31: a classe [Square] implementa apenas [Area]; ela usa o método [Description] por padrão;
  • linhas 35 a 46: a classe [Circle] fornece seu próprio método, [Description];
  • linha 10: o método padrão pertence à interface, e não à classe [Square]: ele só pode ser chamado por meio de uma referência do tipo [IShape]. A chamada a [square.Description()] é rejeitada pelo compilador.

Resultados:

1
2
3
4
> dotnet run classes-16.cs
Square with area 4,00
Circle with radius 1 and area 3,14
Square with area 9,00

Por fim, a partir do C# 11, uma interface pode declarar membros estáticos abstratos que os tipos que a implementam devem fornecer. Eles são usados apenas com tipos genéricos: trataremos deles no final da seção sobre genéricos.

4.7. Classes abstratas

Uma classe abstrata é uma classe que não pode ser instanciada. É preciso criar classes derivadas, que podem ser instanciadas. As classes abstratas podem ser usadas para fatorar o código de uma hierarquia de classes. Vamos examinar o exemplo a seguir, que forma o projeto [Users] da solution: [User.cs]:

namespace Users;

public abstract class User
{
    // campos
    private readonly string login;
    private readonly string password;
    private readonly string role;

    // construtor
    protected User(string login, string password)
    {
        // armazenamos as informações
        this.login = login;
        this.password = password;
        // identificamos o usuário
        string? role = Identify();
        // identificado?
        if (role == null)
        {
            throw new UnknownUserException($"[{login},{password}]");
        }
        this.role = role;
    }

    // ToString
    public override string ToString()
    {
        return $"User[{login},{password},{role}]";
    }

    // identificação: retorna o papel do usuário ou null se ele não for reconhecido
    protected abstract string? Identify();
}
  • linha 3: a classe é declarada abstrata com a palavra-chave [abstract];
  • linhas 11 a 23: o construtor da classe [User]. Essa classe armazena informações sobre um usuário de uma aplicação web. A aplicação tem vários tipos de usuários, que são autenticados por um nome de usuário e uma senha (linhas 6 e 7). Essas duas informações são verificadas em um diretório (LDAP) para alguns usuários, em um banco de dados para outros, e assim por diante. O construtor é [protected]: só pode ser chamado pelos construtores das classes derivadas;
  • linhas 14 e 15: as informações de autenticação são armazenadas;
  • linha 17: elas são verificadas por um método chamado [Identify]. Como o método de autenticação não é conhecido nesse nível, ele é declarado abstrato (linha 33) com a palavra-chave [abstract]. Um método abstrato não tem corpo: as classes derivadas fornecerão um. Uma classe que tem um método abstrato deve ela mesma ser declarada abstrata. O método [Identify] retorna uma string que especifica o papel do usuário (basicamente, o que ele está autorizado a fazer), ou [null] se o usuário não for reconhecido: seu tipo de retorno é, portanto, [string?];
  • linhas 19 a 21: se o usuário não for reconhecido, uma exceção é lançada;
  • linhas 27 a 29: o método [ToString], que identifica uma instância da classe.

Supomos aqui que o desenvolvedor quer ter controle sobre a construção das instâncias da classe [User] e de suas classes derivadas, talvez porque queira garantir que uma exceção de determinado tipo seja lançada se o usuário não for reconhecido. As classes derivadas podem contar com esse construtor. Para isso, elas devem fornecer o método [Identify]. Observe que o construtor aqui chama um método redefinido pelas classes derivadas, embora essas classes ainda não tenham executado seus próprios construtores: o método [Identify] não deve, portanto, usar nenhum campo da classe derivada, pois eles ainda não foram inicializados. Essa é uma prática que deve ser usada com cautela.

A classe [UnknownUserException] é a seguinte:

1
2
3
4
5
6
7
8
namespace Users;

public class UnknownUserException : Exception
{
    public UnknownUserException(string message) : base(message)
    {
    }
}
  • Linha 3: ela deriva da classe [Exception];
  • linha 5: ela tem apenas um construtor, que recebe uma mensagem de erro como parâmetro. Esse parâmetro é passado à classe pai, que tem o mesmo construtor.

Agora derivamos a classe filha [Administrator] da classe [User]:

namespace Users;

public class Administrator : User
{
    // construtor
    public Administrator(string login, string password)
        : base(login, password)
    {
    }

    // identificação
    protected override string? Identify()
    {
        // identificação LDAP
        // ...
        return "admin";
    }
}
  • linhas 6 e 7: o construtor simplesmente repassa os parâmetros que recebe à sua classe pai;
  • Linhas 12 a 16: o método [Identify] da classe [Administrator]. Suponhamos que um administrador seja identificado por um diretório LDAP. Esse método redefine o método abstrato [Identify] de sua classe pai: a palavra-chave [override] é obrigatória (um método abstrato é implicitamente virtual). O curso de 2008 afirmava incorretamente o contrário. Ele mantém o modificador de acesso [protected] do método que redefine.

Agora derivamos a classe filha [Observer] da classe [User]:

namespace Users;

public class Observer : User
{
    // construtor
    public Observer(string login, string password)
        : base(login, password)
    {
    }

    // identificação
    protected override string? Identify()
    {
        // identificação por meio de um banco de dados
        // ...
        return "observer";
    }
}
  • Linhas 12 a 16: o método [Identify] da classe [Observer]. Supomos que um observador seja identificado pela verificação de seus dados de identificação em um banco de dados.

Em última análise, os objetos [Administrator] e [Observer] são inicializados pelo mesmo construtor, o da classe pai [User]. Esse construtor usa o método [Identify] fornecido por essas classes.

Uma terceira classe, [Unknown], também deriva da classe [User]:

namespace Users;

public class Unknown : User
{
    // construtor
    public Unknown(string login, string password)
        : base(login, password)
    {
    }

    // identificação
    protected override string? Identify()
    {
        // usuário desconhecido
        // ...
        return null;
    }
}
  • Linha 16: o método [Identify] retorna [null] para indicar que o usuário não foi reconhecido.

Um programa de teste para [Program.cs] poderia ser assim:

using Users;

Console.WriteLine(new Observer("observer", "pwd1"));
Console.WriteLine(new Administrator("admin", "pwd2"));
try
{
    Console.WriteLine(new Unknown("xx", "yy"));
}
catch (UnknownUserException e)
{
    Console.WriteLine("Unknown user: " + e.Message);
}
// User u = new User("x", "y");   // rejeitado: a classe User é abstrata

Observe que, nas linhas 3 e 4, o método [User.ToString()] é chamado pelo método [WriteLine]. Na linha 7, o construtor lança uma exceção [UnknownUserException], que é capturada na linha 9: o objeto não é criado e nada é exibido por [WriteLine]. A linha 13, se for descomentada, é rejeitada pelo compilador: não se pode criar um objeto de uma classe abstrata.

Resultados:

1
2
3
4
> dotnet run
User[observer,pwd1,observer]
User[admin,pwd2,admin]
Unknown user: [xx,yy]

Uma classe abstrata se parece com uma interface: ambas declaram membros que outras classes devem implementar. No entanto, uma classe abstrata pode ter campos, construtores e código comum às suas classes derivadas; por outro lado, uma classe só pode derivar de uma única classe abstrata, ao passo que pode implementar várias interfaces. Os dois recursos costumam ser combinados: uma interface define o contrato, e uma classe abstrata que a implementa fatora o código comum a várias implementações. É isso que a aplicação de exemplo deste capítulo fará.

4.8. Classes, interfaces e métodos genéricos

4.8.1. Classes e métodos genéricos

Suponha que queiramos escrever um método que troque dois inteiros. Esse método poderia ser assim:

1
2
3
4
5
6
7
public static void Swap1(ref int value1, ref int value2)
{
    // trocamos os valores de value1 e value2
    int temp = value2;
    value2 = value1;
    value1 = temp;
}

Agora, se quiséssemos trocar duas referências a objetos [Person], escreveríamos:

1
2
3
4
5
6
7
public static void Swap2(ref Person value1, ref Person value2)
{
    // trocamos as referências value1 e value2
    Person temp = value2;
    value2 = value1;
    value1 = temp;
}

O que distingue os dois métodos é o tipo T dos parâmetros: [int] em [Swap1] e [Person] em [Swap2]. As classes, interfaces e métodos genéricos atendem à necessidade de código que difere apenas no tipo de certos dados. Eles foram introduzidos com o C# 2: antes disso, usava-se o tipo [object], que aceita qualquer tipo, ao custo de conversões de tipo em tempo de execução e de erros detectados apenas em tempo de execução. Era isso que fazia a classe [ArrayList], mencionada na seção sobre operadores.

O programa [classes-17.cs] apresenta uma classe genérica, um método genérico e uma segunda classe genérica, mais realista:

// classes e métodos genéricos
// uma classe genérica Generic1<T>
// int
int i1 = 1, i2 = 2;
Generic1<int>.Swap(ref i1, ref i2);
Console.WriteLine($"i1={i1},i2={i2}");
// string
string s1 = "s1", s2 = "s2";
Generic1<string>.Swap(ref s1, ref s2);
Console.WriteLine($"s1={s1},s2={s2}");
// Person
Person p1 = new Person("jean", "clu", 20), p2 = new Person("pauline", "dard", 55);
Generic1<Person>.Swap(ref p1, ref p2);
Console.WriteLine($"p1={p1},p2={p2}");

// um método genérico Generic2.Swap<T>
Generic2.Swap<int>(ref i1, ref i2);
Console.WriteLine($"i1={i1},i2={i2}");
// o compilador infere T a partir do tipo dos parâmetros reais
Generic2.Swap(ref s1, ref s2);
Console.WriteLine($"s1={s1},s2={s2}");
Generic2.Swap(ref p1, ref p2);
Console.WriteLine($"p1={p1},p2={p2}");

// uma classe genérica com estado: uma pilha de elementos do tipo T
MyStack<Person> stack = new MyStack<Person>();
stack.Push(p1);
stack.Push(p2);
Console.WriteLine($"The stack contains {stack.Count} persons");
Person top = stack.Pop();
Console.WriteLine($"Popped person: {top}, {stack.Count} left");
// stack.Push("x");   // rejeitado: a pilha só aceita objetos Person

// uma classe genérica
class Generic1<T>
{
    public static void Swap(ref T value1, ref T value2)
    {
        // trocamos os valores de value1 e value2
        T temp = value2;
        value2 = value1;
        value1 = temp;
    }
}

// uma classe não genérica com um método genérico
class Generic2
{
    public static void Swap<T>(ref T value1, ref T value2)
    {
        T temp = value2;
        value2 = value1;
        value1 = temp;
    }
}

// uma pilha de elementos do tipo T
class MyStack<T>
{
    // os elementos da pilha
    private readonly List<T> elements = new List<T>();

    // número de elementos
    public int Count => elements.Count;

    // adiciona um elemento ao topo da pilha
    public void Push(T element)
    {
        elements.Add(element);
    }

    // remove o elemento do topo da pilha
    public T Pop()
    {
        if (elements.Count == 0)
        {
            throw new InvalidOperationException("empty stack");
        }
        T element = elements[^1];
        elements.RemoveAt(elements.Count - 1);
        return element;
    }
}

// uma pessoa
class Person
{
    private readonly string firstName;
    private readonly string lastName;
    private readonly int age;

    public Person(string firstName, string lastName, int age)
    {
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
    }

    public override string ToString() => $"[{firstName}, {lastName}, {age}]";
}
  • linhas 35 a 42: a classe *[Generic1] é parametrizada por um tipo denotado *[T]. Você pode dar a ele o nome que quiser. Esse tipo [T], é então usado dentro da classe como qualquer outro tipo: para os dois parâmetros a serem trocados e para a variável temporária [temp]. Diz-se que a classe [Generic1] é uma classe genérica;
  • Linha 5: ao usar uma classe genérica parametrizada pelos tipos T1, T2, …, esses tipos devem ser “instanciados”. Aqui, usamos o método estático [Swap] do tipo [Generic1<int>] para indicar que as referências passadas ao método [Swap] são do tipo [int]. Linhas 9 e 13: o mesmo vale para os tipos [string] e [Person];
  • Linhas 47 a 49: a classe [Generic2] não é genérica, mas seu método estático [Swap] é;
  • linha 17: o método [Swap] é chamado com a especificação do tipo dos parâmetros entre [<>]. Na verdade, o compilador consegue deduzir, a partir do tipo dos parâmetros reais, qual variante do método [Swap] usar. Portanto, o código das linhas 20 a 22 é válido;
  • linhas 58 a 81: uma classe genérica com estado: uma pilha de elementos do tipo [T]. Os elementos são empilhados no topo da pilha e desempilhados a partir do topo. Eles são armazenados em uma lista genérica do tipo [List<T>] (linha 61), que por sua vez é parametrizada pelo tipo da pilha, [T]. A expressão [elements[^1]] (linha 79) designa o último elemento da lista;
  • linha 26: uma pilha de pessoas. O compilador garante que ela conterá apenas pessoas: a instrução da linha 32 seria rejeitada. O método [Pop] retorna um objeto do tipo [Person], sem conversão.

Resultados:

1
2
3
4
5
6
7
8
9
> dotnet run classes-17.cs
i1=2,i2=1
s1=s2,s2=s1
p1=[pauline, dard, 55],p2=[jean, clu, 20]
i1=1,i2=2
s1=s1,s2=s2
p1=[jean, clu, 20],p2=[pauline, dard, 55]
The stack contains 2 persons
Popped person: [pauline, dard, 55], 1 left

Observe que, para trocar duas variáveis, o C# 7 oferece agora uma sintaxe mais concisa, baseada em tuplas: [(a, b) = (b, a);].

4.8.2. Restrições sobre parâmetros genéricos

Você pode impor restrições aos parâmetros genéricos com a palavra-chave [where]. As principais são as seguintes:

Restrição
Significado
[where T : struct]
T deve ser um tipo de valor (estrutura), excluindo tipos anuláveis como [int?]
[where T : class]
T deve ser um tipo de referência (classe, interface, array, delegate)
[where T : notnull]
T deve ser um tipo não anulável (de valor ou de referência)
[where T : new()]
T deve ter um construtor público sem parâmetros. Essa restrição vem por último
[where T : BaseClass]
T deve ser a classe especificada ou uma classe derivada dela
[where T : IInterface]
T deve implementar a interface especificada. Várias interfaces podem ser especificadas
[where T : U]
T deve ser o tipo U ou um tipo derivado de U, em que U é outro parâmetro genérico
[where T : unmanaged]
T deve ser um tipo de valor que não contém referências

O programa [classes-18.cs] usa duas delas:

// restrições sobre parâmetros genéricos
// restrição where T : class
string s1 = "s1", s2 = "s2";
Generic3.Swap(ref s1, ref s2);
Console.WriteLine($"s1={s1},s2={s2}");
int i1 = 1, i2 = 2;
// Generic3.Swap(ref i1, ref i2);   // erro CS0452: int não é um tipo de referência
Console.WriteLine($"i1={i1},i2={i2}");

// restrição where T : IValue
// troca de instâncias do tipo RandomValue
for (int i = 0; i < 5; i++)
{
    RandomValue c1 = new RandomValue(), c2 = new RandomValue();
    Console.Write($"Before swap --> c1={c1},c2={c2}");
    Generic4.Order(ref c1, ref c2);
    Console.WriteLine($"   After swap --> c1={c1},c2={c2}");
}
// troca de instâncias do tipo StringValue
StringValue c3 = new StringValue("xxxxxxxxxxxxxx"), c4 = new StringValue("xx");
Console.WriteLine($"Before swap --> c3={c3},c4={c4}");
Generic4.Order(ref c3, ref c4);
Console.WriteLine($"After swap --> c3={c3},c4={c4}");

// T deve ser um tipo de referência
class Generic3
{
    public static void Swap<T>(ref T value1, ref T value2) where T : class
    {
        T temp = value2;
        value2 = value1;
        value1 = temp;
    }
}

// o tipo T deve implementar IValue
class Generic4
{
    public static void Order<T>(ref T element1, ref T element2) where T : IValue
    {
        // se o 1º elemento for maior que o 2º, trocamos os elementos
        if (element1.Value() > element2.Value())
        {
            T temp = element2;
            element2 = element1;
            element1 = temp;
        }
    }
}

// um objeto com um valor inteiro
interface IValue
{
    int Value();
}

// um objeto com um valor aleatório
class RandomValue : IValue
{
    // gerador de números aleatórios compartilhado por todas as instâncias
    // (inicializado com uma semente fixa para que os resultados sejam reproduzíveis)
    private static readonly Random generator = new Random(2026);
    // valor do objeto
    private readonly int value = generator.Next(100);

    public int Value() => value;

    public override string ToString() => value.ToString();
}

// um objeto cujo valor é o comprimento de uma string
class StringValue : IValue
{
    private readonly string s;

    public StringValue(string s)
    {
        this.s = s;
    }

    public int Value() => s.Length;

    public override string ToString() => s;
}
  • linhas 26 a 28: o método genérico [Swap] exige que o tipo [T] seja um tipo de referência (restrição [where T : class]);
  • linha 7: se essa linha for descomentada, o compilador relata um erro, porque o tipo [int] não é uma classe nem uma interface: é uma estrutura.

Esta é a mensagem de erro recebida ao compilar o programa depois de descomentar a linha 7:

> dotnet build classes-18.cs
classes-18.cs(7,10): error CS0452: The type 'int' must be a reference type in order to use it as parameter 'T' in the generic type or method 'Generic3.Swap<T>(ref T, ref T)'

A mensagem do compilador é exibida no idioma do sistema, neste caso o inglês (em um computador configurado para o francês, ela estaria em francês). Ela indica o nome do arquivo, os números da linha e da coluna do erro e o código do erro ([CS0452]), que pode ser consultado na documentação.

Voltemos ao programa [classes-18.cs]:

  • Linhas 37 a 39: o tipo [T] deve implementar a interface [IValue] (linhas 52 a 54). Essa interface tem um método chamado [Value], usado na linha 42, que retorna o valor do objeto do tipo [T]. Sem essa restrição, o compilador rejeitaria a chamada a [element1.Value()]: nem todo objeto do tipo [T] tem um método chamado [Value]. As duas referências [element1] e [element2] só são trocadas se o valor de [element1] for maior que o valor de [element2]: o método [Order] ordena os dois elementos em ordem crescente de valor;
  • linhas 58 a 68: a classe [RandomValue] implementa a interface [IValue]. O valor de uma instância é um número aleatório entre 0 e 99 (linha 64), fornecido por um gerador de números aleatórios da classe [Random] compartilhado por todas as instâncias (linha 62). Esse gerador é inicializado com uma “semente” fixa: ele produz, portanto, sempre a mesma sequência de números, o que torna os resultados reproduzíveis. O curso de 2008 criava um gerador para cada objeto, inicializado com a hora atual, e precisava esperar um milissegundo entre as criações para obter números diferentes. Quando a reprodutibilidade não é necessária, o gerador compartilhado [Random.Shared] pode ser usado no lugar dele;
  • linhas 72 a 83: a classe [StringValue] também implementa a interface [IValue]: o valor de uma instância é o comprimento da string passada ao construtor;
  • linhas 12 a 17: instâncias do tipo [RandomValue] são ordenadas;
  • linhas 20 a 23: instâncias do tipo [StringValue] são ordenadas.

Resultados:

> dotnet run classes-18.cs
s1=s2,s2=s1
i1=1,i2=2
Before swap --> c1=15,c2=28   After swap --> c1=15,c2=28
Before swap --> c1=91,c2=99   After swap --> c1=91,c2=99
Before swap --> c1=91,c2=7   After swap --> c1=7,c2=91
Before swap --> c1=66,c2=85   After swap --> c1=66,c2=85
Before swap --> c1=62,c2=36   After swap --> c1=36,c2=62
Before swap --> c3=xxxxxxxxxxxxxx,c4=xx
After swap --> c3=xx,c4=xxxxxxxxxxxxxx

4.8.3. Uma interface genérica: IComparer<T>

Para ilustrar o conceito de interface genérica, vamos ordenar um array de pessoas primeiro por nome e depois por idade. O método que permite ordenar um array é o método estático [Sort] da classe [Array]. Ele tem diferentes assinaturas (é sobrecarregado). Usaremos a seguinte assinatura:

public static void Sort<T>(T[] array, IComparer<T>? comparer)

[Sort] é um método genérico em que [T] designa um tipo qualquer. O método recebe dois parâmetros:

  • [T[] array]: o array de elementos do tipo [T] a serem ordenados;
  • [IComparer<T>? comparer]: uma referência a um objeto que implementa a interface [IComparer<T>].

[IComparer<T>] é uma interface genérica definida da seguinte forma (definição simplificada):

1
2
3
4
public interface IComparer<in T>
{
    int Compare(T? x, T? y);
}

A interface [IComparer<T>] tem apenas um método. O método [Compare]:

  • recebe dois parâmetros, [x] e [y], do tipo [T]. O tipo [T?] indica que seus valores podem ser [null] (a palavra-chave [in] é um detalhe técnico que não explicaremos aqui);
  • retorna um número positivo se x > y, 0 se x == y e um número negativo se x < y. Cabe ao desenvolvedor definir o significado dos operadores <, == e >. Por exemplo, se [p1] e [p2] são dois objetos [Person], podemos dizer que p1 > p2 se o nome de [p1] vier depois do nome de [p2] em ordem alfabética. Isso resultará em uma ordenação crescente pelos nomes das pessoas. Se quisermos ordenar por idade, diremos que p1 > p2 se a idade de [p1] for maior que a idade de [p2];
  • para ordenar em ordem decrescente, basta inverter o sinal dos resultados.

Já sabemos o suficiente para ordenar um array de pessoas. O programa [classes-19.cs] é o seguinte:

// a interface genérica IComparer<T>: ordenação de um array de pessoas
Person[] persons = [new Person("claude", "pollon", 25), new Person("valentine", "germain", 35), new Person("paul", "germain", 32)];
// exibição
Display("Array to sort", persons);
// ordenação por sobrenome e nome
Array.Sort(persons, new CompareNames());
Display("Array after sorting by last name and first name", persons);
// ordenação por idade
Array.Sort(persons, new CompareAges());
Display("Array after sorting by age", persons);

// exibição de um array de pessoas
static void Display(string text, Person[] persons)
{
    Console.WriteLine(text.PadRight(50, '-'));
    foreach (Person p in persons)
    {
        Console.WriteLine(p);
    }
}

// uma pessoa
class Person
{
    public Person(string firstName, string lastName, int age)
    {
        FirstName = firstName;
        LastName = lastName;
        Age = age;
    }

    public string FirstName { get; }
    public string LastName { get; }
    public int Age { get; }

    public override string ToString() => $"[{FirstName}, {LastName}, {Age}]";
}

// comparação dos sobrenomes e nomes de duas pessoas
class CompareNames : IComparer<Person>
{
    public int Compare(Person? p1, Person? p2)
    {
        // descartamos o caso de referências nulas
        ArgumentNullException.ThrowIfNull(p1);
        ArgumentNullException.ThrowIfNull(p2);
        // comparamos os sobrenomes
        int i = string.Compare(p1.LastName, p2.LastName, StringComparison.CurrentCulture);
        if (i != 0)
        {
            return i;
        }
        // sobrenomes iguais: comparamos os nomes
        return string.Compare(p1.FirstName, p2.FirstName, StringComparison.CurrentCulture);
    }
}

// comparação das idades de duas pessoas
class CompareAges : IComparer<Person>
{
    public int Compare(Person? p1, Person? p2)
    {
        ArgumentNullException.ThrowIfNull(p1);
        ArgumentNullException.ThrowIfNull(p2);
        // comparamos as idades
        return p1.Age.CompareTo(p2.Age);
    }
}
  • Linha 2: o array de pessoas;
  • linha 6: ordenação do array de pessoas por sobrenome e nome. O segundo parâmetro do método genérico [Sort] é uma instância da classe [CompareNames], que implementa a interface genérica [IComparer<Person>];
  • linhas 40 a 54: a classe [CompareNames]. Seu método [Compare] implementa o método [int Compare(T? x, T? y)] da interface [IComparer<T>], em que [T] = [Person]:
    • linhas 45 e 46: como os parâmetros são declarados do tipo [Person?], o compilador exige que uma referência nula seja tratada antes de usar [p1] e [p2]. O método estático [ArgumentNullException.ThrowIfNull] lança uma exceção se seu parâmetro for [null]; o compilador sabe que, depois de sua chamada, o parâmetro não é nulo;
    • linha 48: o método [string.Compare] compara duas strings em ordem alfabética de acordo com a cultura atual, neste caso o francês;
  • linha 9: ordenação do array de pessoas por idade, usando uma instância da classe [CompareAges] das linhas 59 a 66. O método [CompareTo] dos tipos numéricos retorna um número negativo, zero ou positivo conforme o número seja menor, igual ou maior que seu parâmetro: é exatamente o que o método [Compare] espera.

Resultados:

> dotnet run classes-19.cs
Array to sort-------------------------------------
[claude, pollon, 25]
[valentine, germain, 35]
[paul, germain, 32]
Array after sorting by last name and first name---
[paul, germain, 32]
[valentine, germain, 35]
[claude, pollon, 25]
Array after sorting by age------------------------
[claude, pollon, 25]
[paul, germain, 32]
[valentine, germain, 35]

Veremos no Capítulo 7, dedicado aos delegates, que também podemos passar uma simples função de comparação para [Array.Sort] sem escrever uma classe: [Array.Sort(persons, (p1, p2) => p1.Age.CompareTo(p2.Age));].

4.8.4. Membros estáticos abstratos e matemática genérica

Podemos escrever um método genérico que some os elementos de um array de números, qualquer que seja o seu tipo ([int], [double], [decimal]…)? Seria preciso poder escrever [sum + value] e ter o elemento zero do tipo [T]. No entanto, o operador [+] é um método estático, e uma restrição de interface comum só permite o uso de métodos de instância. Desde o C# 11, uma interface pode declarar membros estáticos abstratos ([static abstract]), que todo tipo que a implementa deve fornecer. O .NET 7 derivou daí a “matemática genérica”: todos os tipos numéricos implementam a interface [INumber<T>] do namespace [System.Numerics], que declara o zero do tipo ([T.Zero]), os operadores aritméticos e assim por diante. O programa [classes-20.cs] demonstra isso:

using System.Numerics;

// membros de interface static abstract (C# 11) e matemática genérica
Console.WriteLine($"Sum of integers: {Sum([1, 2, 3])}");
Console.WriteLine($"Sum of reals: {Sum([1.5, 2.25])}");
Console.WriteLine($"Sum of decimals: {Sum([10.5m, 0.25m])}");
// uma interface própria
Describe<Cat>();
Describe<Dog>();

// soma dos elementos de um array de números do tipo T
// INumber<T> declara membros static abstract: T.Zero, o operador +, ...
static T Sum<T>(T[] values) where T : INumber<T>
{
    T sum = T.Zero;
    foreach (T value in values)
    {
        sum += value;
    }
    return sum;
}

// o método usa um membro estático do tipo T
static void Describe<T>() where T : IAnimal
{
    Console.WriteLine($"{typeof(T).Name} : {T.Sound}");
}

interface IAnimal
{
    // membro estático que cada classe deve implementar
    static abstract string Sound { get; }
}

class Cat : IAnimal
{
    public static string Sound => "meow";
}

class Dog : IAnimal
{
    public static string Sound => "woof";
}
  • linhas 13 a 20: o método genérico *[Sum] exige que *[T] implemente *[INumber<T>]. Ele pode então usar o membro estático [T.Zero] (linha 15) e o operador [+] do tipo [T]* (linha 18);
  • linhas 4 a 6: o mesmo método soma valores [int], [double] e [decimal]. As expressões de coleção criam arrays do tipo esperado;
  • linhas 29 a 32: uma interface personalizada que declara uma propriedade estática abstrata [Sound];
  • linhas 35 a 42: duas classes implementam a propriedade estática;
  • Linhas 24 a 26: o método genérico [Describe] usa o membro estático [T.Sound] do tipo [T], sem precisar de uma instância desse tipo. [typeof(T)] retorna a descrição do tipo [T], cuja propriedade [Name] é o nome.

Resultados:

1
2
3
4
5
6
> dotnet run classes-20.cs
Sum of integers: 6
Sum of reals: 3,75
Sum of decimals: 10,75
Cat : meow
Dog : woof

4.9. Namespaces

Para escrever uma linha na tela, usamos a instrução [Console.WriteLine(...)]. Se consultarmos a definição da classe [Console] na documentação do .NET, veremos que ela faz parte do namespace [System]. Isso significa que a classe [Console] deveria ser referenciada como [System.Console], e que deveríamos, na verdade, escrever [System.Console.WriteLine(...)]. Evitamos isso com uma cláusula [using]:

1
2
3
using System;
...
Console.WriteLine(...);

Isso significa que o namespace [System] é importado pela cláusula [using]. Quando o compilador encontra um nome de classe (neste caso, [Console]), ele o procura nos diversos namespaces importados pelas cláusulas [using]. Aqui, ele encontra a classe [Console] no namespace [System]. Em um projeto .NET recente, nem sequer precisamos escrever [using System;]: esse namespace está incluído nas instruções implícitas **using** do projeto, como vimos no início do capítulo.

A documentação fornece uma segunda informação sobre a classe [Console]: o assembly que a contém, o arquivo [System.Console.dll]. Um assembly é o resultado da compilação de um projeto: um arquivo [.dll] (biblioteca) ou um executável. Para usar as classes de um assembly, o compilador precisa conhecê-lo. O curso de 2008 mostrava como passar essas referências ao compilador [csc] pela linha de comando ([csc /r:fic1.dll /r:fic2.dll prog.cs]). Hoje, não chamamos mais o compilador diretamente: os assemblies do framework .NET são referenciados automaticamente, e o arquivo [.csproj] referencia as outras bibliotecas, seja como pacotes ([PackageReference]), seja como projetos ([ProjectReference]), como veremos no Capítulo 6, dedicado às arquiteturas em camadas.

Ao criar uma classe, é possível criá-la dentro de um namespace. A finalidade dos namespaces é evitar conflitos de nomes entre classes, por exemplo, quando elas são distribuídas. Considere duas empresas, E1 e E2, que distribuem classes empacotadas nos assemblies [e1.dll] e [e2.dll], respectivamente. Suponha que um cliente C compre esses dois conjuntos de classes, nos quais ambas as empresas definiram uma classe chamada [Person]. Se o programa do cliente usar a classe [Person], o compilador não saberá se deve usar a classe [Person] de [e1.dll] ou a de [e2.dll]. Ele relatará um erro. Se a empresa E1 criar suas classes em um namespace chamado [E1] e a empresa E2 criar as suas em um namespace chamado [E2], as duas classes chamadas [Person] passarão a se chamar [E1.Person] e [E2.Person]. O cliente deverá usar [E1.Person] ou [E2.Person] (ou um alias) em suas classes, mas não [Person]. O namespace resolve essa ambiguidade.

Para criar uma classe em um namespace, o curso de 2008 indicava:

1
2
3
4
namespace NamespaceName
{
    // definição de classe
}

Esse formato continua válido (ele permite incluir vários namespaces em um único arquivo), mas, desde o C# 10, prefere-se o namespace de escopo de arquivo ([namespace NamespaceName;]), colocado no início do arquivo, pois economiza um nível de indentação. Este é o formato que usamos desde o início deste capítulo.

O projeto [Namespaces] da solution ilustra esses conceitos. Ele contém duas classes, [Person], em dois namespaces diferentes. A primeira, [E1/Person.cs]:

// as classes deste arquivo pertencem ao namespace E1
namespace E1;

public class Person
{
    private readonly string firstName;
    private readonly string lastName;

    public Person(string firstName, string lastName)
    {
        this.firstName = firstName;
        this.lastName = lastName;
    }

    public override string ToString() => $"E1.Person[{firstName}, {lastName}]";
}

A segunda, *[E2/Person.cs]*:

// as classes deste arquivo pertencem ao namespace E2
namespace E2;

public class Person
{
    public Person(string name)
    {
        Name = name;
    }

    public string Name { get; }

    public override string ToString() => $"E2.Person[{Name}]";
}

Observe que a pasta de um arquivo-fonte não determina seu namespace; só a declaração *[namespace]* importa. No entanto, é uma convenção útil organizar os arquivos de um mesmo namespace em uma pasta com o mesmo nome.

O arquivo [GlobalUsings.cs] contém as seguintes cláusulas [global using] (C# 10):

1
2
3
// imports válidos para todos os arquivos-fonte do projeto
global using E1;
global using System.Text;

Uma diretiva [global using] se aplica a todos os arquivos-fonte do projeto. É assim que as instruções using implícitas são implementadas: durante a compilação, o SDK gera um arquivo [obj/Debug/net10.0/Namespaces.GlobalUsings.g.cs] que contém as linhas [global using System;], [global using System.Collections.Generic;], [global using System.IO;], [global using System.Linq;], [global using System.Net.Http;], [global using System.Threading;] e [global using System.Threading.Tasks;]. Também é possível adicionar uma instrução "using" global no arquivo [.csproj]: [<Using Include="E1" />].

O programa principal, [Program.cs], é o seguinte:

// aliases de namespace e aliases de tipo
using PersonE2 = E2.Person;
using Point = (int X, int Y);

// Person denota E1.Person: o namespace E1 é importado em GlobalUsings.cs
Person p1 = new Person("Jean", "Dupont");
// PersonE2 é um alias de E2.Person
PersonE2 p2 = new PersonE2("Durand");
// o nome completo de uma classe elimina qualquer ambiguidade
E2.Person p3 = new E2.Person("Martin");
Console.WriteLine($"{p1} {p2} {p3}");
// nome completo dos tipos e assembly que os contém
Console.WriteLine($"{typeof(Person).FullName}, {typeof(PersonE2).FullName}");
Console.WriteLine($"{typeof(Console).FullName} is in the assembly {typeof(Console).Assembly.GetName().Name}");
// StringBuilder é conhecido graças ao global using System.Text
StringBuilder sb = new StringBuilder("abc");
Console.WriteLine(sb.Append("def"));
// Point é um alias do tipo tupla (int X, int Y)
Point origin = (0, 0);
Console.WriteLine($"origin=({origin.X},{origin.Y})");
  • linha 2: um alias: neste arquivo, [PersonE2] refere-se à classe [E2.Person];
  • linha 3: a partir do C# 12, um alias pode se referir a qualquer tipo; aqui, ele se refere a uma tupla com dois campos chamados [X] e [Y];
  • linha 6: [Person] refere-se à classe [E1.Person], graças à cláusula [global using E1;]. Se o namespace [E2] também fosse importado, o nome [Person] seria ambíguo e o compilador o rejeitaria;
  • linha 8: uso do alias;
  • linha 10: o nome totalmente qualificado da classe resolve qualquer ambiguidade;
  • linha 13: a propriedade [FullName] de um tipo retorna seu nome completo, prefixado pelo namespace;
  • linha 14: a propriedade [Assembly] de um tipo se refere ao assembly que o contém;
  • linha 16: a classe [System.Text.StringBuilder] é definida por meio da cláusula [global using System.Text;];
  • linha 19: uso do alias para o tipo tupla.

Resultados:

1
2
3
4
5
6
> dotnet run
E1.Person[Jean, Dupont] E2.Person[Durand] E2.Person[Martin]
E1.Person, E2.Person
System.Console is in the assembly System.Console
abcdef
origin=(0,0)

4.10. Records

Muitas classes servem apenas para transportar dados: uma pessoa, uma nota, uma faixa de imposto… Para elas, sempre escrevemos o mesmo código: um construtor que copia seus parâmetros para propriedades, um método [ToString] que exibe essas propriedades e, muitas vezes, métodos de comparação. O C# 9 introduziu os records: o compilador gera esse código a partir de uma declaração de uma única linha. Já encontramos a versão para estruturas ([record struct]); eis a versão para classes ([classes-21.cs]):

// records (C# 9)
Person r1 = new Person("Jean", "Dupont", 30);
Person r2 = new Person("Jean", "Dupont", 30);
// ToString gerado pelo compilador
Console.WriteLine(r1);
// igualdade por valor: r1 e r2 são dois objetos diferentes, mas iguais
Console.WriteLine($"r1 == r2 : {r1 == r2}, same object: {ReferenceEquals(r1, r2)}");
// as propriedades são somente leitura (init)
// r1.Age = 31;   // rejeitado
// a expressão with cria uma cópia modificada
Person r3 = r1 with { Age = 31 };
Console.WriteLine(r3);
Console.WriteLine($"r1 == r3 : {r1 == r3}");
// desconstrução em variáveis
var (firstName, lastName, age) = r1;
Console.WriteLine($"first name={firstName}, last name={lastName}, age={age}");

// a mesma coisa com uma classe
PersonC c1 = new PersonC("Jean", "Dupont", 30);
PersonC c2 = new PersonC("Jean", "Dupont", 30);
Console.WriteLine(c1);
Console.WriteLine($"c1 == c2 : {c1 == c2}");

// um record derivado
Teacher e = new Teacher("Lucile", "Dumas", 56, 61);
Console.WriteLine(e);
Console.WriteLine(e.Identity);
// a igualdade leva o tipo em conta: uma Person não é igual a uma Teacher
Person pe = new Person("Lucile", "Dumas", 56);
Console.WriteLine($"pe == e : {pe == e}");

// um record posicional: FirstName, LastName, Age são propriedades públicas { get; init; }
record Person(string FirstName, string LastName, int Age)
{
    // membros podem ser adicionados
    public virtual string Identity => $"[{FirstName}, {LastName}, {Age}]";
}

// um record pode derivar de outro record
record Teacher(string FirstName, string LastName, int Age, int Section) : Person(FirstName, LastName, Age)
{
    public override string Identity => $"Teacher[{base.Identity},{Section}]";
}

// uma classe equivalente... ou quase
class PersonC
{
    public PersonC(string firstName, string lastName, int age)
    {
        FirstName = firstName;
        LastName = lastName;
        Age = age;
    }

    public string FirstName { get; init; }
    public string LastName { get; init; }
    public int Age { get; init; }
}
  • Linhas 33 a 36: um record posicional. A declaração [record Person(string FirstName, string LastName, int Age)] gera:
    • um construtor com três parâmetros;
    • três propriedades públicas somente leitura: [FirstName], [LastName] e [Age] ([{ get; init; }]);
    • um método [ToString] que exibe o nome do tipo e suas propriedades públicas (linha 5);
    • os métodos [Equals] e [GetHashCode] e os operadores [==] e [!=], que comparam os valores das propriedades, e não as referências;
    • um método [Deconstruct] que decompõe o objeto em variáveis (linha 15);
    • a expressão [with];
    • um record também pode, como uma classe, ter membros adicionais; aqui, a propriedade [Identity];
  • Linha 7: [r1] e [r2] são dois objetos distintos ([ReferenceEquals] retorna [false]), mas são iguais no sentido de [] porque suas propriedades têm os mesmos valores. Em uma classe comum, [] compara as referências (linha 22);
  • linha 11: como um record é, em princípio, imutável, ele não é modificado (linha 9): a expressão [with] cria uma cópia de [r1] na qual certas propriedades foram alteradas;
  • linhas 40 a 42: um record pode derivar de outro record (e não de uma classe comum). Os parâmetros [FirstName], [LastName] e [Age] são passados ao construtor do record pai. A propriedade [Identity], declarada como [virtual] em [Person], é redefinida;
  • linha 30: a igualdade de records leva em conta o tipo real dos objetos: um [Person] nunca é igual a um [Teacher], mesmo que suas propriedades em comum sejam iguais;
  • Linhas 46 a 57: uma classe que se parece com o record [Person]… exceto que o construtor e as propriedades tiveram de ser escritos, e a igualdade por valor, [ToString] e [with] não são fornecidos.

Resultados:

> dotnet run classes-21.cs
Person { FirstName = Jean, LastName = Dupont, Age = 30, Identity = [Jean, Dupont, 30] }
r1 == r2 : True, same object: False
Person { FirstName = Jean, LastName = Dupont, Age = 31, Identity = [Jean, Dupont, 31] }
r1 == r3 : False
first name=Jean, last name=Dupont, age=30
PersonC
c1 == c2 : False
Teacher { FirstName = Lucile, LastName = Dumas, Age = 56, Identity = Teacher[[Lucile, Dumas, 56],61], Section = 61 }
Teacher[[Lucile, Dumas, 56],61]
pe == e : False

Observe que o método gerado [ToString] também exibe a propriedade calculada [Identity] (linha 2), ao passo que o método [ToString] da classe [PersonC] exibe simplesmente o nome da classe (linha 7).

Resumamos as diferenças entre uma classe e um record:

 
Classe
Record
Igualdade: [==], [Equals]
mesmo objeto (referências iguais)
mesmos valores de propriedades, mesmo tipo
[ToString]
nome do tipo
nome do tipo e propriedades públicas
construtor e propriedades
a escrever
geradas pela declaração posicional, propriedades [init]
cópia modificada
a escrever
expressão [with]
herança
de uma classe
de um record

Um record é usado para dados definidos por seu valor (uma pessoa recuperada de um banco de dados, uma mensagem trocada em uma rede, uma faixa de imposto), e uma classe é usada para um objeto com identidade e comportamento (um serviço de cálculo, uma conexão, uma lista editável). Um record é escrito como [record] (ou [record class], que é idêntico) para um tipo de referência, e [record struct] para um tipo de valor.

4.11. Construtores primários

Os records posicionais declaram os parâmetros de seu construtor imediatamente após o nome. Desde o C# 12, as classes e estruturas comuns podem fazer o mesmo: é o construtor primário. O programa [classes-22.cs] ilustra isso:

// construtores primários (C# 12)
Person p = new Person("Jean", "Dupont", 30);
Console.WriteLine(p.Identity);
p.GrowOlder();
Console.WriteLine(p.Identity);
// outro construtor
Person unknown = new Person("Martin");
Console.WriteLine(unknown.Identity);
// uma classe derivada
Teacher e = new Teacher("Lucile", "Dumas", 56, 61);
Console.WriteLine(e.Identity);
// uma estrutura
Point pt = new Point(3, 4);
Console.WriteLine($"pt=({pt.X},{pt.Y}), distance to the origin: {pt.Distance()}");

// uma classe com um construtor primário
class Person(string firstName, string lastName, int age)
{
    // os parâmetros firstName e lastName são usados para inicializar propriedades
    public string FirstName { get; } = firstName;
    public string LastName { get; } = lastName;
    // o parâmetro age é usado pelos métodos: ele é mantido em um campo oculto
    public int Age => age;

    // qualquer outro construtor deve chamar o construtor primário
    public Person(string lastName) : this("?", lastName, 0)
    {
    }

    public void GrowOlder() => age++;

    public virtual string Identity => $"[{FirstName}, {LastName}, {age}]";
}

// uma classe derivada: ela passa três de seus parâmetros ao construtor primário da classe pai
class Teacher(string firstName, string lastName, int age, int section) : Person(firstName, lastName, age)
{
    public int Section { get; } = section;

    public override string Identity => $"Teacher[{base.Identity},{Section}]";
}

// uma estrutura com um construtor primário
readonly struct Point(double x, double y)
{
    public double X { get; } = x;
    public double Y { get; } = y;

    public double Distance() => Math.Sqrt(X * X + Y * Y);
}
  • linha 17: a classe [Person] tem um construtor primário com três parâmetros. Ao contrário dos de um record, esses parâmetros não se tornam propriedades públicas: são parâmetros, visíveis em todo o corpo da classe;
  • linhas 20 e 21: os parâmetros [firstName] e [lastName] são usados para inicializar duas propriedades somente leitura;
  • linha 23: o parâmetro [age] é usado por membros da classe: a propriedade [Age], o método [GrowOlder] (linha 30) e a propriedade [Identity]. O compilador o armazena então em um campo oculto, que pode ser modificado ([age++]). Recomenda-se não misturar esses dois usos para o mesmo parâmetro (inicializar uma propriedade e usá-lo diretamente), pois isso pode resultar em duas cópias do mesmo dado;
  • linha 26: uma classe com construtor primário pode ter outros construtores, mas estes devem chamar o construtor primário com [this(...)];
  • linha 36: uma classe derivada passa alguns dos parâmetros de seu construtor primário ao construtor de sua classe pai: [: Person(firstName, lastName, age)]. Isso equivale a [: base(firstName, lastName, age)] em um construtor tradicional;
  • linha 44: uma estrutura também pode ter um construtor primário.

Resultados:

1
2
3
4
5
6
> dotnet run classes-22.cs
[Jean, Dupont, 30]
[Jean, Dupont, 31]
[?, Martin, 0]
Teacher[[Lucile, Dumas, 56],61]
pt=(3,4), distance to the origin: 5

O construtor primário elimina o código repetitivo dos construtores que apenas armazenam seus parâmetros. Ele é muito usado em classes que recebem serviços durante a construção, como veremos com a injeção de dependência (Capítulo 6).

4.12. Métodos e membros de extensão

Como adicionar um método a uma classe que não pode ser modificada, como a classe [string] do .NET? O C# 3 introduziu os métodos de extensão: métodos estáticos usados como métodos de instância do tipo estendido. O C# 14 amplia esse mecanismo para propriedades e membros estáticos com os blocos de extensão. O programa [classes-23.cs] demonstra ambos:

// métodos de extensão (C# 3) e membros de extensão (C# 14)
Person p = new Person("jean", "dupont", 30);
// métodos de extensão clássicos: são usados como métodos de instância
Console.WriteLine(p.Initials());
Console.WriteLine("jean".FirstUpper());
// a chamada anterior é traduzida pelo compilador na seguinte chamada de método estático
Console.WriteLine(ClassicExtensions.FirstUpper("jean"));
// propriedades de extensão (C# 14)
Console.WriteLine($"{p.FullName} is an adult: {p.IsAdult}");
Console.WriteLine($"\"the weather is nice\" has {"the weather is nice".NbWords} words");
// membro de extensão estático (C# 14): é usado com o nome do tipo
Person unknown = Person.Unknown;
Console.WriteLine($"{unknown.FullName} is an adult: {unknown.IsAdult}");

// uma pessoa
record Person(string FirstName, string LastName, int Age);

// métodos de extensão clássicos: métodos estáticos de uma classe estática,
// cujo primeiro parâmetro é precedido da palavra-chave this
static class ClassicExtensions
{
    public static string Initials(this Person p)
    {
        return $"{char.ToUpper(p.FirstName[0])}.{char.ToUpper(p.LastName[0])}.";
    }

    public static string FirstUpper(this string s)
    {
        return s.Length == 0 ? s : char.ToUpper(s[0]) + s[1..];
    }
}

// blocos de extensão (C# 14)
static class Cs14Extensions
{
    // membros de instância adicionados ao tipo Person: p denota o objeto estendido
    extension(Person p)
    {
        public bool IsAdult => p.Age >= 18;

        public string FullName => $"{p.FirstName.FirstUpper()} {p.LastName.ToUpper()}";
    }

    // membros estáticos adicionados ao tipo Person
    extension(Person)
    {
        public static Person Unknown => new Person("?", "?", 0);
    }

    // uma propriedade adicionada ao tipo string
    extension(string s)
    {
        public int NbWords => s.Split(' ', StringSplitOptions.RemoveEmptyEntries).Length;
    }
}
  • linhas 20 a 29: os métodos de extensão tradicionais são métodos estáticos de uma classe estática. Seu primeiro parâmetro, precedido pela palavra-chave [this], especifica o objeto estendido:
    • [Initials(this Person p)] estende o tipo [Person]: ele é chamado como [p.Initials()] (linha 4);
    • [FirstUpper(this string s)] estende o tipo [string]: ele é chamado como ["jean".FirstUpper()] (linha 5). A expressão [s[1..]] designa a substring a partir do caractere nº 1;
  • linha 7: um método de extensão continua sendo um método estático comum: o compilador traduz ["jean".FirstUpper()] nessa chamada. O método só tem acesso aos membros públicos do objeto estendido;
  • linhas 34 a 53: os blocos de extensão do C# 14, também declarados dentro de uma classe estática:
    • linhas 37 a 41: o bloco ***[extension(Person p)] adiciona os membros de instância que contém ao tipo *[Person]. *[p]* designa o objeto estendido. Propriedades agora podem ser adicionadas ([IsAdult], [FullName]), o que não era possível com os métodos de extensão tradicionais;
    • linhas 45 a 47: o bloco [extension(Person)], sem nomes de parâmetros, adiciona membros estáticos ao tipo [Person]: [Person.Unknown] (linha 12) é escrito como se a propriedade tivesse sido declarada no record [Person];
    • Linhas 51 a 53: uma propriedade de extensão do tipo [string], usada na linha 10.

Resultados:

1
2
3
4
5
6
7
> dotnet run classes-23.cs
J.D.
Jean
Jean
Jean DUPONT is an adult: True
"the weather is nice" has 4 words
? ? is an adult: False

Os métodos de extensão estão por toda parte no .NET: os operadores do LINQ ([Where], [Select], [OrderBy]…), tratados no próximo capítulo, são métodos de extensão da interface [IEnumerable<T>]. Para que uma extensão seja utilizável, o namespace de sua classe estática deve ser importado.

4.13. Filtragem de padrões em objetos

A expressão [switch] e a filtragem de padrões não se limitam a valores simples (números, strings); elas também se aplicam a objetos. É possível testar o tipo de um objeto, verificar os valores de suas propriedades e obter o objeto convertido para o tipo correto, tudo em uma única expressão. O programa [classes-24.cs] usa uma hierarquia de três records:

// pattern matching em objetos
object?[] objects =
[
    new Person("Jean", "Dupont", 30),
    new Person("Lise", "Morel", 12),
    new Teacher("Lucile", "Dumas", 56, 61),
    new Teacher("Marc", "Petit", 44, 27),
    new Student("Paul", "Martin", 19, "computer science"),
    "a string",
    42,
    null,
];

// 1 - o padrão de tipo: is Type variable
foreach (object? o in objects)
{
    if (o is Person p)
    {
        // aqui p é uma Person (ou um objeto de uma classe derivada)
        Console.WriteLine($"{p.FirstName} is of type {p.GetType().Name}");
    }
}

// 2 - o padrão de propriedade: { Property: pattern }
foreach (object? o in objects)
{
    if (o is Person { Age: >= 18 } adult)
    {
        Console.WriteLine($"{adult.FirstName} is an adult");
    }
}

// 3 - a expressão switch sobre o tipo e as propriedades do objeto
foreach (object? o in objects)
{
    Console.WriteLine(Describe(o));
}

static string Describe(object? o) => o switch
{
    Teacher { Section: 27 } e => $"{e.FirstName} teaches computer science",
    Teacher e => $"{e.FirstName} teaches in section {e.Section}",
    Student(var firstName, _, _, var major) => $"{firstName} studies {major}",
    Person { Age: < 18 } p => $"{p.FirstName} is a minor",
    Person p => $"{p.FirstName} is {p.Age} years old",
    string s => $"a string of {s.Length} characters",
    int n and > 0 => $"the positive integer {n}",
    null => "the null reference",
    _ => "an unknown object",
};

record Person(string FirstName, string LastName, int Age);
record Teacher(string FirstName, string LastName, int Age, int Section) : Person(FirstName, LastName, Age);
record Student(string FirstName, string LastName, int Age, string Major) : Person(FirstName, LastName, Age);
  • linhas 52 a 54: um record [Person] e dois records derivados, [Teacher] e [Student];
  • linhas 2 a 11: um array de objetos de diversos tipos (o tipo [object?] também aceita [null]);
  • linha 17: o padrão de tipo [o is Person p] é verdadeiro se [o] referencia um objeto do tipo [Person] ou de um tipo derivado; nesse caso, a variável [p], do tipo [Person], referencia esse objeto. Isso evita a sequência do curso de 2008: testar o tipo com [is] e depois converter com [(Person)o]. O padrão é falso se [o] for igual a [null];
  • linha 27: o padrão de propriedade [{ Age: >= 18 }] (C# 8) testa o valor de uma propriedade do objeto, neste caso com um padrão relacional [>= 18] (C# 9). Várias propriedades podem ser testadas separando-as por vírgulas;
  • linhas 39 a 49: a expressão [switch] tenta os padrões em ordem e retorna o valor associado ao primeiro que corresponder:
    • linha 41: um professor da seção 27;
    • linha 42: qualquer outro professor. A ordem é importante: se estivesse antes do padrão anterior, este padrão o tornaria inacessível, o que o compilador sinalizaria como erro;
    • linha 43: um padrão posicional: ele usa o método [Deconstruct] do record [Student] para extrair suas propriedades na ordem em que foram declaradas; [_] ignora uma propriedade;
    • linha 44: um menor de idade;
    • linha 47: um inteiro positivo, com o combinador [and] (C# 9); também existem [or] e [not];
    • linha 48: o padrão [null];
    • linha 49: o padrão [_] aceita tudo. Sem ele, o compilador indicaria que a expressão [switch] não cobre todos os casos.

Resultados:

> dotnet run classes-24.cs
Jean is of type Person
Lise is of type Person
Lucile is of type Teacher
Marc is of type Teacher
Paul is of type Student
Jean is an adult
Lucile is an adult
Marc is an adult
Paul is an adult
Jean is 30 years old
Lise is a minor
Lucile teaches in section 61
Marc teaches computer science
Paul studies computer science
a string of 8 characters
the positive integer 42
the null reference

Observe que o padrão de tipo também corresponde a tipos derivados: o laço de padrão de tipo (linhas 2 a 6) capturou os professores e o aluno, que são pessoas. A correspondência de padrões é uma alternativa útil a uma cascata de [if (o is ...)]; no entanto, ela não deve substituir o polimorfismo: quando o comportamento depende do tipo do objeto e você tem controle sobre a hierarquia de classes, um método virtual redefinido em cada classe continua sendo a solução orientada a objetos.

4.14. Tipos de referência anuláveis

Desde o início deste capítulo, nossos projetos têm os tipos de referência anuláveis habilitados ([<Nullable>enable</Nullable>] no [.csproj], uma opção habilitada por padrão em aplicações de arquivo único). O princípio é o seguinte:

  • uma variável, campo, parâmetro ou resultado de tipo de referência declarado sem ponto de interrogação, por exemplo do tipo [Person], nunca deve ser igual a [null];
  • se puder ser [null], ele é declarado com um ponto de interrogação: [Person?];
  • o compilador analisa o fluxo do programa e emite um aviso sempre que um valor potencialmente nulo é usado sem verificação ou atribuído a uma variável não anulável.

A linguagem não proíbe nada em tempo de execução: são avisos de compilação, mas um programa que compila sem avisos está muito menos sujeito à exceção [NullReferenceException], o erro de execução mais comum. O curso de 2008, anterior a esse recurso (C# 8, 2019), evidentemente não o abordava. O programa [classes-25.cs] demonstra os operadores associados aos tipos anuláveis:

// tipos de referência anuláveis aplicados a objetos
Person[] persons = [new Person("Jean", "Dupont") { MiddleName = "Marie" }, new Person("Paul", "Martin")];
foreach (Person p in persons)
{
    // ?. : retorna null se o objeto à esquerda for null, caso contrário acessa o membro
    int? length = p.MiddleName?.Length;
    // ?? : retorna o operando da direita se o da esquerda for null
    Console.WriteLine($"{p.FirstName} : middle name={p.MiddleName ?? "(none)"}, length={length?.ToString() ?? "null"}");
}

// um método que pode retornar null: seu tipo de retorno é Person?
Person? found = Find(persons, "Durand");
Console.WriteLine(found?.FirstName ?? "Durand: person not found");
// após um teste, o compilador sabe que a referência não é null
found = Find(persons, "Martin");
if (found is not null)
{
    Console.WriteLine($"Martin : {found.FirstName}");
}
// ??= : atribui um valor somente se a variável (ou a propriedade) for null
persons[1].MiddleName ??= "Pierre";
persons[0].MiddleName ??= "Pierre";
Console.WriteLine($"{persons[0].MiddleName}, {persons[1].MiddleName}");
// C# 14: atribuição condicional: só é feita se o objeto não for null
Find(persons, "Dupont")?.MiddleName = "Louise";
Find(persons, "Durand")?.MiddleName = "Louise";
Console.WriteLine(persons[0].MiddleName);
// ! : afirmamos ao compilador que a referência não é null
Person martin = Find(persons, "Martin")!;
Console.WriteLine(martin.FirstName);
// as linhas a seguir geram avisos do compilador
// Console.WriteLine(new Person("Lise", "Morel").MiddleName.Length);   // aviso
// Person dupond = Find(persons, "Dupond");   // aviso
// persons[0] = null;   // aviso

// busca de uma pessoa pelo sobrenome
static Person? Find(Person[] persons, string lastName)
{
    foreach (Person p in persons)
    {
        if (p.LastName == lastName)
        {
            return p;
        }
    }
    return null;
}

class Person
{
    public Person(string firstName, string lastName)
    {
        FirstName = firstName;
        LastName = lastName;
    }

    // propriedades não anuláveis: nunca devem ser null
    public string FirstName { get; }
    public string LastName { get; }
    // propriedade anulável: null significa "sem nome do meio"
    public string? MiddleName { get; set; }
}
  • linhas 58 a 61: a classe [Person] tem duas propriedades não anuláveis, inicializadas pelo construtor, e uma propriedade anulável, [MiddleName]: [null] significa “sem nome do meio”;
  • linha 6: o operador [?.] (C# 6) retorna [null] se o objeto à sua esquerda for [null], e acessa o membro caso contrário. O resultado é do tipo [int?];
  • linha 8: o operador [??] retorna seu operando esquerdo se ele não for [null], e seu operando direito caso contrário;
  • linhas 37 a 46: a função [Find] retorna a pessoa procurada ou [null]; seu tipo de retorno é [Person?];
  • linha 13: os dois operadores são combinados;
  • linhas 16 a 18: depois da verificação [is not null], o compilador sabe que [found] não é igual a [null]: [found.FirstName] pode ser escrito sem aviso;
  • linhas 21 e 22: o operador [??=] só atribui um valor à propriedade se ela for [null]: o nome do meio de Jean, “Marie”, não é substituído;
  • linhas 25 e 26: o C# 14 permite [?.] no lado esquerdo de uma atribuição: a atribuição só é realizada se o objeto não for nulo. Dupont existe e recebe um novo nome do meio; Durand não existe, e a instrução não faz nada;
  • linha 29: o operador [!] (um operador “null-forgiving”) informa ao compilador que sabemos que o valor não é nulo: ele não emite aviso. Cabe ao desenvolvedor ter certeza disso: se o valor for nulo em tempo de execução, ocorrerá um erro mais adiante. Use com moderação;
  • linhas 32 a 34: três instruções que provocam avisos.

Resultados:

1
2
3
4
5
6
7
8
> dotnet run classes-25.cs
Jean : middle name=Marie, length=5
Paul : middle name=(none), length=null
Durand: person not found
Martin : Paul
Marie, Pierre
Louise
Paul

Vamos descomentar as três últimas linhas do programa principal e compilar:

1
2
3
4
> dotnet build classes-25.cs
classes-25.cs(32,19): warning CS8602: Dereference of a possibly null reference.
classes-25.cs(33,17): warning CS8600: Converting null literal or possible null value to non-nullable type.
classes-25.cs(34,14): warning CS8625: Cannot convert null literal to non-nullable reference type.
  • Aviso [CS8602]: a propriedade [MiddleName] de uma pessoa recém-criada pode ser [null]: não é possível usar sua propriedade [Length] sem verificação;
  • Aviso [CS8600]: a função [Find] pode retornar [null], valor que é atribuído a uma variável não anulável do tipo [Person];
  • Aviso [CS8625]: a constante [null] é atribuída a um elemento do tipo [Person], que não é anulável.

O programa seria executado apesar desses avisos, mas a primeira linha lançaria uma exceção [NullReferenceException]. Neste curso, todos os programas compilam sem nenhum aviso: corrigimos o código (declarando o tipo como anulável, verificando o valor ou fornecendo um valor padrão com [??]) em vez de ignorar o aviso ou suprimi-lo com [!].

4.15. Aplicação de exemplo - V2

Retomamos o cálculo do imposto visto no capítulo anterior (Versão 1) e o implementamos com classes e interfaces. Vamos relembrar o problema. Queremos escrever um programa para calcular o imposto de um contribuinte. Consideraremos o caso simplificado de um contribuinte que tem apenas um salário a declarar (usando a tabela de 2004 para os rendimentos de 2003, mantida como está: trata-se de um exercício):

  • calcula-se o número de cotas do empregado: cotas = nbChildren / 2 + 1 se ele for solteiro, nbChildren / 2 + 2 se for casado, em que nbChildren é o número de filhos;
  • se ele tiver pelo menos três filhos, recebe uma meia cota adicional;
  • sua renda tributável R é calculada como R = 0,72 × S, em que S é seu salário anual;
  • seu quociente familiar é calculado como QF = R / cotas;
  • seu imposto I é calculado com base na tabela a seguir:
limite
coeffR
coeffN
4962
0
0
8382
0.068
291.09
14,753
0.191
1,322.92
23,888
0.283
2,668.39
38,868
0.374
4,846.98
47,932
0.426
6,883.66
0
0.481
9,505.54

Cada linha tem três campos. Para calcular o imposto I, procura-se a primeira linha em que QF ≤ limite. Por exemplo, se QF = 5.000, será encontrada a linha (8.382; 0,068; 291,09). O imposto I é então igual a 0,068 × R - 291,09 × cotas. Se QF for tal que a condição QF ≤ limite nunca seja satisfeita, usam-se os coeficientes da última linha, resultando em um imposto I = 0,481 × R - 9.505,54 × cotas.

A aplicação forma o projeto [TaxV2] da solution:

1
2
3
4
5
6
7
TaxV2/
  TaxBracket.cs        a bracket of the tax scale
  ITax.cs              the tax calculation interface
  AbstractTax.cs       an abstract class implementing ITax
  HardwiredTax.cs      a derived class, with hard-coded data
  Program.cs           the program that dialogues with the user
  TaxV2.csproj

Primeiro, definimos um tipo capaz de encapsular uma linha da tabela anterior [TaxBracket.cs]:

1
2
3
4
namespace TaxV2;

// uma faixa da tabela do imposto
public readonly record struct TaxBracket(decimal Limit, decimal CoeffR, decimal CoeffN);

O curso de 2008 usava uma estrutura com três propriedades automáticas de leitura e escrita. Nós usamos uma estrutura record imutável ([readonly record struct]):

  • uma estrutura porque uma faixa é um dado pequeno, sem identidade, definido unicamente por seu valor: um array de faixas contém diretamente as faixas, sem um objeto separado na memória para cada uma. Com três [decimal] (48 bytes), a estrutura excede o tamanho de cerca de 16 bytes normalmente recomendado para uma estrutura; isso não é um problema aqui: há poucas faixas, e elas só são copiadas quando lidas;
  • imutável ([readonly]) porque não há razão para que uma faixa de imposto seja modificada depois de criada. O curso de 2008, aliás, modificava o limite da última faixa durante o cálculo, um efeito colateral que eliminamos;
  • um record ([record]) porque o compilador gera o construtor, as propriedades, [ToString], e o operador de igualdade a partir de uma única linha.

Em seguida, definimos uma interface [ITax] capaz de calcular o imposto [ITax.cs]:

1
2
3
4
5
6
7
namespace TaxV2;

public interface ITax
{
    // cálculo do imposto de um contribuinte
    int Calculate(bool married, int nbChildren, int salary);
}
  • Linha 6: o método de cálculo do imposto com base em três dados: o estado civil do contribuinte, o número de filhos e o salário anual. Ele retorna o imposto arredondado para baixo, em euros inteiros.

Depois, definimos uma classe abstrata que implementa essa interface [AbstractTax.cs]:

namespace TaxV2;

public abstract class AbstractTax : ITax
{
    // as faixas de imposto necessárias ao cálculo vêm de uma fonte externa
    // que somente as classes derivadas conhecem
    protected abstract TaxBracket[] TaxBrackets { get; }

    // cálculo do imposto
    public int Calculate(bool married, int nbChildren, int salary)
    {
        // cálculo do número de cotas
        decimal shares = (decimal)nbChildren / 2 + (married ? 2 : 1);
        if (nbChildren >= 3)
        {
            shares += 0.5m;
        }
        // cálculo da renda tributável e do quociente familiar
        decimal income = 0.72m * salary;
        decimal quotient = income / shares;
        // busca da faixa de imposto: a última é usada se nenhum limite servir
        TaxBracket[] brackets = TaxBrackets;
        TaxBracket bracket = brackets[^1];
        for (int i = 0; i < brackets.Length - 1; i++)
        {
            if (quotient <= brackets[i].Limit)
            {
                bracket = brackets[i];
                break;
            }
        }
        // cálculo do imposto
        return (int)(income * bracket.CoeffR - shares * bracket.CoeffN);
    }
}
  • Linha 3: a classe [AbstractTax] implementa a interface [ITax];
  • linha 7: os dados da tabela, na forma de uma propriedade abstrata protegida. A classe [AbstractTax] não sabe de onde vêm esses dados (escritos no código, lidos de um arquivo, de um banco de dados etc.). Ela deixa isso a cargo das classes derivadas. É por isso que é declarada abstrata, o que impede que seja instanciada. O curso de 2008 usava um campo protegido que as classes derivadas precisavam inicializar; a propriedade abstrata obriga as classes derivadas a fornecê-la: o compilador verifica isso;
  • linhas 10 a 33: a implementação do método [Calculate] da interface [ITax]. As classes derivadas não precisarão reescrever esse método. A classe [AbstractTax] serve, assim, como classe de fatoração para as classes derivadas: ela contém o que é comum a todas elas;
  • linha 13: o número de cotas. A conversão [(decimal)nbChildren] é essencial: sem ela, [nbChildren / 2] seria uma divisão inteira (3 / 2 = 1). A expressão [married ? 2 : 1] vale 2 para um contribuinte casado e 1 caso contrário;
  • Linhas 19 e 20: a renda tributável e o quociente familiar. Todos os cálculos são feitos com [decimal], um tipo adequado a valores monetários: o sufixo [m] de [0.72m] denota uma constante desse tipo;
  • Linhas 22 a 29: determinação da faixa de imposto. Por padrão, é a última faixa ([brackets[^1]], linha 23). O laço percorre todas as faixas, exceto a última, e para ([break]) na primeira faixa cujo limite seja maior ou igual ao quociente familiar;
  • linha 33: cálculo do imposto. A conversão [(int)] trunca o resultado [decimal] para sua parte inteira.

Uma classe que implementa a interface [ITax] pode ser criada derivando-a da classe [AbstractTax]. É o que faremos agora com [HardwiredTax.cs]:

namespace TaxV2;

public class HardwiredTax : AbstractTax
{
    // dados do cálculo do imposto (tabela de 2004 sobre a renda de 2003), fixos no código
    private static readonly decimal[] limits = [4962m, 8382m, 14753m, 23888m, 38868m, 47932m, 0m];
    private static readonly decimal[] coeffR = [0m, 0.068m, 0.191m, 0.283m, 0.374m, 0.426m, 0.481m];
    private static readonly decimal[] coeffN = [0m, 291.09m, 1322.92m, 2668.39m, 4846.98m, 6883.66m, 9505.54m];

    // as faixas de imposto
    private readonly TaxBracket[] taxBrackets;

    // construtor
    public HardwiredTax()
    {
        // criação e preenchimento do array de faixas de imposto
        taxBrackets = new TaxBracket[limits.Length];
        for (int i = 0; i < taxBrackets.Length; i++)
        {
            taxBrackets[i] = new TaxBracket(limits[i], coeffR[i], coeffN[i]);
        }
    }

    // implementação da propriedade abstrata da classe pai
    protected override TaxBracket[] TaxBrackets => taxBrackets;
}
  • Linhas 6 a 8: a classe [HardwiredTax] codifica diretamente no código os dados necessários ao cálculo do imposto. São campos de classe ([static]) somente leitura ([readonly]): são compartilhados por todas as instâncias e não podem ser substituídos por outros arrays;
  • linhas 14 a 20: o construtor usa esses dados para montar a tabela de faixas de imposto;
  • linha 25: a propriedade abstrata da classe pai é implementada: ela retorna a tabela de faixas de imposto.

O próximo capítulo acrescentará outras classes derivadas de [AbstractTax], que lerão as faixas de imposto de um arquivo de texto ou JSON: elas só precisarão fornecer a propriedade [TaxBrackets].

Um programa de teste poderia ser o seguinte [Program.cs]:

using TaxV2;

// programa interativo de cálculo do imposto
// o usuário digita três dados no teclado: married nbChildren salary
// o programa então exibe o imposto a pagar

const string syntax = """
    syntax: Married NbChildren Salary
    Married: y for married, n for not married
    NbChildren: number of children
    Salary: annual salary in euros
    """;

// criação de um objeto ITax
ITax tax = new HardwiredTax();

// laço de entrada
while (true)
{
    // pedimos os parâmetros do cálculo do imposto
    Console.Write("Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: ");
    string parameters = (Console.ReadLine() ?? "").Trim();
    // há algo a fazer?
    if (parameters == "")
    {
        break;
    }
    // verificação do número de campos da linha digitada
    string[] fields = parameters.Split(' ', StringSplitOptions.RemoveEmptyEntries);
    if (fields.Length != 3)
    {
        Console.WriteLine(syntax);
        continue;
    }
    // verificação da validade dos parâmetros
    // married
    string married = fields[0].ToLower();
    if (married != "y" && married != "n")
    {
        Console.WriteLine(syntax + "\nIncorrect married argument: type y or n");
        continue;
    }
    // nbChildren
    if (!int.TryParse(fields[1], out int nbChildren) || nbChildren < 0)
    {
        Console.WriteLine(syntax + "\nIncorrect NbChildren argument: type a positive or zero integer");
        continue;
    }
    // salary
    if (!int.TryParse(fields[2], out int salary) || salary < 0)
    {
        Console.WriteLine(syntax + "\nIncorrect salary argument: type a positive or zero integer");
        continue;
    }
    // os parâmetros estão corretos: calculamos o imposto
    Console.WriteLine($"Tax={tax.Calculate(married == "y", nbChildren, salary)} euros");
}

O programa acima permite ao usuário executar simulações repetidas de cálculo de imposto.

  • linhas 7 a 11: a mensagem de ajuda é escrita como um literal de string bruto (C# 11), delimitado por três aspas: a string pode ocupar várias linhas, e a indentação comum das linhas, determinada pela posição das aspas de fechamento, é removida;
  • Linha 15: criação de um objeto [tax] que implementa a interface [ITax]. Esse objeto é obtido instanciando um tipo [HardwiredTax], um tipo que implementa a interface [ITax]. Observe que a variável [tax] não recebeu o tipo [HardwiredTax] , e sim o tipo [ITax]. Ao escrever isso, indicamos que só nos interessa o método [Calculate] do objeto [tax], e não o resto. Para usar dados de um arquivo, basta alterar essa única linha;
  • linhas 18 a 56: o laço das simulações de cálculo de imposto;
  • linha 22: os três parâmetros necessários ao método [Calculate] são solicitados em uma única linha digitada no teclado. [Console.ReadLine] retorna [null] se a entrada padrão for fechada: o operador [??] substitui então [null] por uma string vazia, o que encerra o programa;
  • linha 29: o método [Split] divide a linha em palavras separadas por espaços, com a opção [StringSplitOptions.RemoveEmptyEntries] eliminando as palavras vazias causadas por espaços consecutivos;
  • linhas 44 a 50: o método [int.TryParse] verifica se os dois últimos campos são inteiros; a declaração [out int nbChildren] cria a variável que recebe o número. O curso de 2008 usava [int.Parse] dentro de um bloco [try / catch];
  • linha 56: chamada ao método [Calculate] do objeto [tax] que implementa a interface [ITax].

Eis um exemplo do programa em execução:

> dotnet run
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: q s d
syntax: Married NbChildren Salary
Married: y for married, n for not married
NbChildren: number of children
Salary: annual salary in euros
Incorrect married argument: type y or n
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 2 d
syntax: Married NbChildren Salary
Married: y for married, n for not married
NbChildren: number of children
Salary: annual salary in euros
Incorrect salary argument: type a positive or zero integer
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: q s d f
syntax: Married NbChildren Salary
Married: y for married, n for not married
NbChildren: number of children
Salary: annual salary in euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y -1 60000
syntax: Married NbChildren Salary
Married: y for married, n for not married
NbChildren: number of children
Salary: annual salary in euros
Incorrect NbChildren argument: type a positive or zero integer
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 2 60000
Tax=4282 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 3 60000
Tax=2959 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: n 0 60000
Tax=11519 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: 

Os valores do imposto são calculados corretamente: 4.282 euros para um contribuinte casado com dois filhos e salário anual de 60.000 euros (linha 26), e 2.959 euros com três filhos (linha 28). Um contribuinte solteiro sem filhos paga 11.519 euros pelo mesmo salário (linha 30).

Em comparação com a Versão 1, o cálculo agora está encapsulado em classes por trás de uma interface: o programa de diálogo só conhece a interface [ITax]. As versões seguintes se apoiarão nessa separação: a Versão 3 mudará a fonte de dados derivando novas classes de [AbstractTax], e a Versão 4 organizará a aplicação em camadas.