Tutorial: Expresse sua intenção de design com mais clareza com tipos de referência anuláveis e não anuláveis
Os tipos de referência anuláveis complementam os tipos de referência da mesma forma que os tipos de valor anuláveis complementam os tipos de valor. Você declara uma variável como um tipo de referência anulável anexando um ? ao tipo. Por exemplo, string? representa um stringanulável . Você pode usar esses novos tipos para expressar mais claramente sua intenção de design: algumas variáveis sempre devem ter um valor, outras podem estar faltando um valor.
Neste tutorial, você aprenderá a:
- Incorpore tipos de referência anuláveis e não anuláveis em seus designs
- Ative as verificações de tipos de referência nulos em todo o código.
- Escreva código onde o compilador impõe essas decisões de design.
- Use o recurso de referência anulável em seus próprios designs
Pré-requisitos
Você precisará configurar sua máquina para executar o .NET, incluindo o compilador C#. O compilador C# está disponível com o Visual Studio 2022ou o .NET SDK.
Este tutorial pressupõe que você esteja familiarizado com C# e .NET, incluindo o Visual Studio ou a CLI do .NET.
Incorpore tipos de referência anuláveis em seus designs
Neste tutorial, você criará uma biblioteca que modela a execução de uma pesquisa. O código usa tipos de referência anuláveis e tipos de referência não anuláveis para representar os conceitos do mundo real. As perguntas da pesquisa nunca podem ser nulas. Um entrevistado pode preferir não responder a uma pergunta. Neste caso, as respostas podem ser null.
O código que você escreverá para este exemplo expressa essa intenção, e o compilador impõe essa intenção.
Criar o aplicativo e habilitar tipos de referência anuláveis
Crie um novo aplicativo de console no Visual Studio ou na linha de comando usando dotnet new console. Nomeie o aplicativo NullableIntroduction. Depois de criar o aplicativo, você precisará especificar que todo o projeto seja compilado em um contexto de anotação ativado anulável. Abra o arquivo de .csproj do e adicione um elemento Nullable ao elemento PropertyGroup. Defina seu valor como enable. Você deve optar pelo recurso tipos de referência anuláveis em projetos anteriores ao C# 11. Isso porque, uma vez que o recurso é ativado, as declarações de variáveis de referência existentes se tornam tipos de referência não anuláveis. Embora essa decisão ajude a encontrar problemas em que o código existente pode não ter verificações nulas adequadas, ela pode não refletir com precisão sua intenção de design original:
<Nullable>enable</Nullable>
Antes do .NET 6, novos projetos não incluem o elemento Nullable. A partir do .NET 6, novos projetos incluem o elemento <Nullable>enable</Nullable> no arquivo de projeto.
Projetar os tipos para o aplicativo
Este aplicativo de pesquisa requer a criação de várias classes:
- Uma classe que modela a lista de perguntas.
- Uma classe que modela uma lista de pessoas contatadas para a pesquisa.
- Uma classe que modela as respostas de uma pessoa que respondeu ao questionário.
Esses tipos usarão tipos de referência anuláveis e não anuláveis para expressar quais membros são necessários e quais membros são opcionais. Os tipos de referência anuláveis comunicam claramente essa intenção de design:
- As perguntas que fazem parte do inquérito nunca podem ser nulas: não faz sentido fazer uma pergunta vazia.
- Os entrevistados nunca podem ser nulos. Você vai querer rastrear as pessoas que você contatou, até mesmo os entrevistados que se recusaram a participar.
- Qualquer resposta a uma pergunta pode ser nula. Os entrevistados podem recusar-se a responder a algumas ou a todas as perguntas.
Se você programou em C#, pode estar tão acostumado a tipos de referência que permitem valores null que pode ter perdido outras oportunidades de declarar instâncias não anuláveis:
- A recolha de perguntas não deve ser anulável.
- A recolha de inquiridos não deve ser anulável.
Ao escrever o código, você verá que um tipo de referência não anulável como padrão para referências evita erros comuns que podem levar a NullReferenceExceptions. Uma lição deste tutorial é que você tomou decisões sobre quais variáveis poderiam ou não ser null. A linguagem não fornecia sintaxe para expressar essas decisões. Agora sim.
O aplicativo que você criará executa as seguintes etapas:
- Cria uma pesquisa e adiciona perguntas a ela.
- Cria um conjunto pseudoaleatório de respondentes para a pesquisa.
- Entra em contato com os respondentes até que o tamanho da pesquisa concluída atinja o número da meta.
- Escreve estatísticas importantes sobre as respostas ao inquérito.
Criar a pesquisa com tipos de referência anuláveis e não anuláveis
O primeiro código que você escreverá criará a pesquisa. Você escreverá classes para modelar uma pergunta de pesquisa e a realização de uma pesquisa. O questionário tem três tipos de perguntas, distinguidas pelo formato da resposta: respostas Sim/Não, respostas numéricas e respostas em texto. Crie uma classe public SurveyQuestion:
namespace NullableIntroduction
{
public class SurveyQuestion
{
}
}
O compilador interpreta cada declaração de variável de tipo de referência como um tipo de referência não anulável para código em um contexto de anotação anulável habilitado. Você pode ver seu primeiro aviso adicionando propriedades para o texto da pergunta e o tipo de pergunta, conforme mostrado no código a seguir:
namespace NullableIntroduction
{
public enum QuestionType
{
YesNo,
Number,
Text
}
public class SurveyQuestion
{
public string QuestionText { get; }
public QuestionType TypeOfQuestion { get; }
}
}
Como você não inicializou QuestionText, o compilador emite um aviso de que uma propriedade não anulável não foi inicializada. Seu design requer que o texto da pergunta não seja nulo, então você adiciona um construtor para inicializá-lo e o valor QuestionType também. A definição de classe concluída se parece com o seguinte código:
namespace NullableIntroduction;
public enum QuestionType
{
YesNo,
Number,
Text
}
public class SurveyQuestion
{
public string QuestionText { get; }
public QuestionType TypeOfQuestion { get; }
public SurveyQuestion(QuestionType typeOfQuestion, string text) =>
(TypeOfQuestion, QuestionText) = (typeOfQuestion, text);
}
Ao adicionar o construtor, o aviso é removido. O argumento do construtor também é um tipo de referência não anulável, portanto, o compilador não emite nenhum aviso.
Em seguida, crie uma classe public chamada SurveyRun. Essa classe contém uma lista de SurveyQuestion objetos e métodos para adicionar perguntas à pesquisa, conforme mostrado no código a seguir:
using System.Collections.Generic;
namespace NullableIntroduction
{
public class SurveyRun
{
private List<SurveyQuestion> surveyQuestions = new List<SurveyQuestion>();
public void AddQuestion(QuestionType type, string question) =>
AddQuestion(new SurveyQuestion(type, question));
public void AddQuestion(SurveyQuestion surveyQuestion) => surveyQuestions.Add(surveyQuestion);
}
}
Como antes, você deve inicializar o objeto list para um valor não nulo ou o compilador emite um aviso. Não há verificações nulas na segunda sobrecarga de AddQuestion porque elas não são necessárias: você declarou essa variável como não anulável. Seu valor não pode ser null.
Mude para Program.cs no editor e substitua o conteúdo do Main pelas seguintes linhas de código:
var surveyRun = new SurveyRun();
surveyRun.AddQuestion(QuestionType.YesNo, "Has your code ever thrown a NullReferenceException?");
surveyRun.AddQuestion(new SurveyQuestion(QuestionType.Number, "How many times (to the nearest 100) has that happened?"));
surveyRun.AddQuestion(QuestionType.Text, "What is your favorite color?");
Como todo o projeto está em um contexto de anotação anulável habilitado, você receberá avisos quando passar null para qualquer método que espere um tipo de referência não anulável. Experimente adicionando a seguinte linha ao Main:
surveyRun.AddQuestion(QuestionType.Text, default);
Crie respondentes e obtenha respostas para a pesquisa
Em seguida, escreva o código que gera as respostas para a pesquisa. Este processo envolve várias pequenas tarefas:
- Crie um método que gere objetos de respondente. Estes representam as pessoas convidadas a preencher o inquérito.
- Crie lógica para simular fazer as perguntas a um entrevistado e coletar respostas ou notar que um entrevistado não respondeu.
- Repita até que um número suficiente de entrevistados tenha respondido à pesquisa.
Você precisará de uma classe para representar a resposta de uma pesquisa, portanto, adicione isso agora. Habilite o suporte anulável. Adicione uma propriedade Id e um construtor que a inicializa, conforme mostrado no código a seguir:
namespace NullableIntroduction
{
public class SurveyResponse
{
public int Id { get; }
public SurveyResponse(int id) => Id = id;
}
}
Em seguida, adicione um método static para criar novos participantes gerando uma ID aleatória:
private static readonly Random randomGenerator = new Random();
public static SurveyResponse GetRandomId() => new SurveyResponse(randomGenerator.Next());
A principal responsabilidade desta aula é gerar as respostas para um participante às perguntas da pesquisa. Esta responsabilidade tem alguns passos:
- Peça a participação no inquérito. Se a pessoa não consentir, devolva uma resposta ausente (ou nula).
- Faça cada pergunta e registre a resposta. Cada resposta também pode estar faltando (ou nula).
Adicione o seguinte código à sua classe SurveyResponse:
private Dictionary<int, string>? surveyResponses;
public bool AnswerSurvey(IEnumerable<SurveyQuestion> questions)
{
if (ConsentToSurvey())
{
surveyResponses = new Dictionary<int, string>();
int index = 0;
foreach (var question in questions)
{
var answer = GenerateAnswer(question);
if (answer != null)
{
surveyResponses.Add(index, answer);
}
index++;
}
}
return surveyResponses != null;
}
private bool ConsentToSurvey() => randomGenerator.Next(0, 2) == 1;
private string? GenerateAnswer(SurveyQuestion question)
{
switch (question.TypeOfQuestion)
{
case QuestionType.YesNo:
int n = randomGenerator.Next(-1, 2);
return (n == -1) ? default : (n == 0) ? "No" : "Yes";
case QuestionType.Number:
n = randomGenerator.Next(-30, 101);
return (n < 0) ? default : n.ToString();
case QuestionType.Text:
default:
switch (randomGenerator.Next(0, 5))
{
case 0:
return default;
case 1:
return "Red";
case 2:
return "Green";
case 3:
return "Blue";
}
return "Red. No, Green. Wait.. Blue... AAARGGGGGHHH!";
}
}
O armazenamento para as respostas da pesquisa é um Dictionary<int, string>?, indicando que pode ser nulo. Você está usando o novo recurso de linguagem para declarar sua intenção de design, tanto para o compilador quanto para qualquer pessoa que leia seu código mais tarde. Se desreferenciar surveyResponses sem primeiro verificar o valor de null, receberá um aviso do compilador. Você não recebe um aviso no método AnswerSurvey porque o compilador pode determinar a variável surveyResponses foi definida como um valor não nulo acima.
Usar null para respostas ausentes destaca um ponto-chave para trabalhar com tipos de referência anuláveis: seu objetivo não é remover todos os valores null do seu programa. Em vez disso, seu objetivo é garantir que o código que você escreve expresse a intenção do seu design. Valores ausentes são um conceito necessário para expressar em seu código. O valor null é uma maneira clara de expressar esses valores ausentes. Tentar remover todos os valores null só leva a definir alguma outra maneira de expressar esses valores ausentes sem null.
Em seguida, você precisa escrever o método PerformSurvey na classe SurveyRun. Adicione o seguinte código na classe SurveyRun:
private List<SurveyResponse>? respondents;
public void PerformSurvey(int numberOfRespondents)
{
int respondentsConsenting = 0;
respondents = new List<SurveyResponse>();
while (respondentsConsenting < numberOfRespondents)
{
var respondent = SurveyResponse.GetRandomId();
if (respondent.AnswerSurvey(surveyQuestions))
respondentsConsenting++;
respondents.Add(respondent);
}
}
Aqui, novamente, sua escolha de um List<SurveyResponse>? anulável indica que a resposta pode ser nula. Isso indica que a pesquisa ainda não foi dada a nenhum entrevistado. Observe que os respondentes são adicionados até atingir o número necessário de consentimentos.
A última etapa para executar a pesquisa é adicionar uma chamada para executar a pesquisa no final do método Main:
surveyRun.PerformSurvey(50);
Examinar as respostas da pesquisa
A última etapa é exibir os resultados da pesquisa. Irá adicionar código a muitas das classes que já escreveu. Este código demonstra o valor de distinguir tipos de referência anuláveis e não anuláveis. Comece adicionando os seguintes dois membros com corpo de expressão à classe SurveyResponse:
public bool AnsweredSurvey => surveyResponses != null;
public string Answer(int index) => surveyResponses?.GetValueOrDefault(index) ?? "No answer";
Como surveyResponses é um tipo de referência anulável, verificações nulas são necessárias antes de desreferenciar isso. O método Answer retorna uma cadeia de caracteres não anulável, portanto, temos que cobrir o caso de uma resposta ausente usando o operador null-coalescing.
Em seguida, adicione estes três membros com corpo de expressão à classe SurveyRun:
public IEnumerable<SurveyResponse> AllParticipants => (respondents ?? Enumerable.Empty<SurveyResponse>());
public ICollection<SurveyQuestion> Questions => surveyQuestions;
public SurveyQuestion GetQuestion(int index) => surveyQuestions[index];
O membro AllParticipants deve levar em conta que a variável respondents pode ser nula, mas o valor de retorno não pode ser nulo. Se você alterar essa expressão removendo o ?? e a sequência vazia a seguir, o compilador avisa que o método pode retornar null e sua assinatura de retorno retorna um tipo não anulável.
Finalmente, adicione o seguinte loop na parte inferior do método Main:
foreach (var participant in surveyRun.AllParticipants)
{
Console.WriteLine($"Participant: {participant.Id}:");
if (participant.AnsweredSurvey)
{
for (int i = 0; i < surveyRun.Questions.Count; i++)
{
var answer = participant.Answer(i);
Console.WriteLine($"\t{surveyRun.GetQuestion(i).QuestionText} : {answer}");
}
}
else
{
Console.WriteLine("\tNo responses");
}
}
Você não precisa de nenhuma verificação de null neste código porque projetou as interfaces subjacentes para que todas elas retornem tipos de referência não anuláveis.
Obter o código
Você pode obter o código para o tutorial concluído de nossos exemplos de repositório na pasta csharp/NullableIntroduction.
Experimente alterando as declarações de tipo entre tipos de referência anuláveis e não anuláveis. Veja como isso gera diferentes avisos para garantir que não desreferencies acidentalmente um null.
Próximos passos
Saiba como usar o tipo de referência anulável ao usar o Entity Framework:
