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:
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]:
O comando cria uma pasta chamada [Persons] contendo dois arquivos. O arquivo [Persons.csproj] descreve o projeto:
- 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]:
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:
- 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:
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:
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:
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
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:
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:
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]:
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:
É 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:
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:
- 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:
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:
- 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:
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:
ou
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]:
- 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:
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):
Resultados:
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:
- 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:
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:
- 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:
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]):
- linhas 22 a 35: os métodos de leitura, chamados getters;
- linhas 38 a 51: os métodos de escrita, chamados setters.
Resultados:
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:
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:
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:
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:
Essa sintaxe, conhecida como inicializador de objeto, equivale ao seguinte código:
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:
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:
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:
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]:
- 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:
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:
- 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:
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]:
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]:
- 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:
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]:
- 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:
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:
- 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:
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:
[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]:
- 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]:
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:
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:
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]:
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]:

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:
- 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:
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:
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:
- 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:
- 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:
Resultados:
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:
você está escrevendo implicitamente:
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):
Voltemos ao programa [Program.cs] do projeto [Inheritance2]:
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:
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]:
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]:
- 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:
- 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:
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]:
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:
- 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:
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:
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]:
- 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:
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.

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:

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]:
- 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:
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:
- 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:
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:
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:
- 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]:
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]:
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]:
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]:
- 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]:
- 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]:
- 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
Cipodem então ser usadas como parâmetros reais de funções que aceitam um parâmetro formal do tipoI, isto é, funções que usam apenas os métodos dos objetosCidefinidos na interfaceI, e não os campos e métodos específicos das várias classesCi; - 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:
Por fim, observe que as interfaces podem ter várias implementações; ou seja, é possível escrever:
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:
- 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:
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]:
- 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:
- 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]:
- 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]:
- 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]:
- 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:
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:
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:
Agora, se quiséssemos trocar duas referências a objetos [Person], escreveríamos:
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:
- 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:
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:
- 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:
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:
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:
[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):
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:
- 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:
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:
- 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:
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]:
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:
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]:
A segunda, *[E2/Person.cs]*:
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):
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:
- 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:
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]):
- 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:
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:
- 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:
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:
- 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.
- linhas 37 a 41: o bloco
Resultados:
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:
- 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:
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:
- 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:
Vamos descomentar as três últimas linhas do programa principal e compilar:
- 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:
Primeiro, definimos um tipo capaz de encapsular uma linha da tabela anterior [TaxBracket.cs]:
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]:
- 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]:
- 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]:
- 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]:
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:
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.