Ao trabalhar com C#, você frequentemente precisa lidar com valores nulos , especialmente com tipos de referência. Os tipos anuláveis em C# fornecem uma maneira de representar valores indefinidos ou ausentes para tipos de valor. Este guia aborda os fundamentos dos tipos anuláveis em C#, seus usos práticos e como eles funcionam em diferentes cenários. Analisaremos também o IronPDF mais adiante neste artigo.
Por padrão, os tipos de valor em C# (por exemplo, int, bool, DateTime) não podem receber valores nulos. Para contornar essa limitação, o C# introduz os tipos de valor anuláveis , permitindo atribuir o valor nulo a esses tipos. Os tipos anuláveis são particularmente úteis quando você precisa representar a ausência de um valor válido.
Para declarar um tipo anulável em C#, você usa a seguinte sintaxe:
// Declare a nullable integer
int? nullableInt = null;' Declare a nullable integer
Dim nullableInt? As Integer = NothingAqui, int? é uma abreviação para Nullable<int>. A variável nullableInt pode conter um valor int ou null.
Para verificar se uma variável de tipo anulável tem um valor ou não, você pode usar a propriedade HasValue ou comparar a variável diretamente com null, como mostrado abaixo:
if (nullableInt.HasValue)
{
// If nullableInt has a value, print it
Console.WriteLine("Value: " + nullableInt.Value);
}
else
{
// If nullableInt does not have a value, print a message
Console.WriteLine("No value assigned.");
}If nullableInt.HasValue Then
' If nullableInt has a value, print it
Console.WriteLine("Value: " & nullableInt.Value)
Else
' If nullableInt does not have a value, print a message
Console.WriteLine("No value assigned.")
End IfAlternativamente, você pode usar o operador de coalescência nula (??) para fornecer um valor padrão quando o tipo anulável for nulo:
// Assign 0 if nullableInt is null
int result = nullableInt ?? 0;
Console.WriteLine("Result: " + result);' Assign 0 if nullableInt is null
Dim result As Integer = If(nullableInt, 0)
Console.WriteLine("Result: " & result)Se nullableInt for null, result receberá o valor padrão de 0.
Em C#, os tipos de valor (como int, bool e double) diferem dos tipos de referência (como string e object). Os tipos de valor anuláveis permitem que os tipos de valor representem valores nulos, enquanto os tipos de referência anuláveis permitem que os tipos de referência não sejam anuláveis por padrão, reduzindo assim o risco de exceções de referência nula.
Um tipo de valor anulável permite que um tipo de valor assuma um valor nulo. Para declarar um tipo de valor anulável, adicione um ponto de interrogação ? ao tipo de dado:
// Declare a nullable double
double? nullableDouble = null;' Declare a nullable double
Dim nullableDouble? As Double = NothingNeste exemplo, nullableDouble pode conter um valor double ou null.
Os tipos de referência anuláveis foram introduzidos no C# 8.0. Você pode habilitar tipos de referência anuláveis ao nível do projeto ou adicionando a diretiva #nullable enable no início do seu arquivo de código. Com os tipos de referência anuláveis habilitados, os tipos de referência devem ser explicitamente marcados como anuláveis usando ?, ajudando a evitar potenciais exceções de tempo de execução causadas por referências nulas.
#nullable enable
// Declare a nullable string
string? nullableString = null;'INSTANT VB TODO TASK: There is no equivalent to #nullable in VB:
'#nullable enable
' Declare a nullable string
'INSTANT VB WARNING: Nullable reference types have no equivalent in VB:
'ORIGINAL LINE: string? nullableString = null;
Dim nullableString As String = NothingAqui, nullableString está permitido ser null. Se você declarar um tipo de referência não anulável sem o ?, o compilador produzirá avisos se detectar potenciais atribuições nulas.
Para habilitar tipos de referência anuláveis globalmente em um projeto, adicione a seguinte linha ao seu arquivo .csproj:
<Nullable>enable</Nullable>Uma vez ativada, a opção fará com que o compilador trate os tipos de referência como não anuláveis por padrão. Essa funcionalidade é especialmente útil para detectar problemas de referência nula em tempo de compilação, em vez de em tempo de execução.
Vamos explorar alguns exemplos práticos para consolidar sua compreensão de tipos anuláveis.
Neste exemplo, usaremos um tipo anulável com o valor int:
class Program
{
static void Main(string[] args)
{
int? nullableInt = null;
// Use null coalescing operator to assign a default value
int b = nullableInt ?? 10;
Console.WriteLine("b: " + b);
if (nullableInt.HasValue)
{
// nullableInt has a value
Console.WriteLine("nullableInt has value: " + nullableInt.Value);
}
else
{
// nullableInt is null
Console.WriteLine("nullableInt is null");
}
}
}Friend Class Program
Shared Sub Main(ByVal args() As String)
Dim nullableInt? As Integer = Nothing
' Use null coalescing operator to assign a default value
Dim b As Integer = If(nullableInt, 10)
Console.WriteLine("b: " & b)
If nullableInt.HasValue Then
' nullableInt has a value
Console.WriteLine("nullableInt has value: " & nullableInt.Value)
Else
' nullableInt is null
Console.WriteLine("nullableInt is null")
End If
End Sub
End ClassAqui, nullableInt é uma variável de tipo anulável de int. Se nullableInt for null, b recebe o valor 10 devido ao operador de coalescência nula. Caso contrário, b assume o valor de nullableInt.
Agora, vejamos como funcionam os tipos de referência anuláveis:
#nullable enable
class Program
{
static void Main()
{
string? nullableString = null;
string nonNullableString = "Hello";
// Use null coalescing operator to provide a default value for length
Console.WriteLine(nullableString?.Length ?? 0);
Console.WriteLine(nonNullableString.Length);
}
}'INSTANT VB TODO TASK: There is no equivalent to #nullable in VB:
'#nullable enable
Friend Class Program
Shared Sub Main()
'INSTANT VB WARNING: Nullable reference types have no equivalent in VB:
'ORIGINAL LINE: string? nullableString = null;
Dim nullableString As String = Nothing
Dim nonNullableString As String = "Hello"
' Use null coalescing operator to provide a default value for length
Console.WriteLine(If(nullableString?.Length, 0))
Console.WriteLine(nonNullableString.Length)
End Sub
End ClassNo código acima, nullableString pode ser null, e o operador de coalescência nula garante que, se for null, o comprimento da string será 0 por padrão.
Em C#, você pode declarar tipos anuláveis aninhados. Por exemplo:
// Redundant, but syntactically valid
int? nestedNullableInt = null;' Redundant, but syntactically valid
Dim nestedNullableInt? As Integer = NothingEmbora tipos anuláveis aninhados possam parecer redundantes, eles são sintaticamente válidos em C#. No entanto, na prática, tipos anuláveis aninhados não fornecem nenhuma funcionalidade adicional e raramente são usados.
O operador de coalescência nula (??) é frequentemente usado com tipos anuláveis para fornecer um valor padrão quando o tipo anulável é nulo. Este operador simplifica o código ao evitar verificações explícitas de if-else.
int? nullableValue = null;
// Assign -1 if nullableValue is null
int defaultValue = nullableValue ?? -1;Dim nullableValue? As Integer = Nothing
' Assign -1 if nullableValue is null
Dim defaultValue As Integer = If(nullableValue, -1)Neste exemplo, se nullableValue for null, defaultValue será atribuído -1. Caso contrário, defaultValue assumirá o valor de nullableValue.
Com os tipos de referência anuláveis habilitados, o C# gera avisos e erros durante a compilação quando detecta possíveis problemas com atribuições nulas. Esses erros de tempo de compilação ajudam a detectar problemas precocemente, tornando seu código mais robusto.
Considere o seguinte exemplo:
string? nullableString = null;
// This will produce a compiler warning because nullableString may be null
string nonNullableString = nullableString;'INSTANT VB WARNING: Nullable reference types have no equivalent in VB:
'ORIGINAL LINE: string? nullableString = null;
Dim nullableString As String = Nothing
' This will produce a compiler warning because nullableString may be null
Dim nonNullableString As String = nullableStringNeste caso, atribuir nullableString a nonNullableString produz um aviso do compilador porque nullableString pode ser null, e atribuí-lo a um tipo não anulável pode levar a exceções de tempo de execução.
IronPDF é uma biblioteca C# para PDF projetada para ajudar desenvolvedores a criar, editar e manipular arquivos PDF diretamente de aplicativos .NET . Você pode converter HTML para PDF , gerar relatórios ou até mesmo lidar com estruturas de documentos complexas.
Os tipos anuláveis são especialmente úteis em cenários de geração dinâmica de relatórios, como quando você está gerando um PDF para um contador com dados financeiros incompletos. Ao usar tipos anuláveis, você pode gerenciar campos opcionais, evitar exceções e fornecer valores padrão.
using IronPdf;
class Program
{
static void Main(string[] args)
{
int? optionalIncome = null; // Nullable type for optional income
string? clientName = "Iron Dev"; // Nullable reference type for client name
var renderer = new ChromePdfRenderer();
string htmlContent = $@"
<h1>Financial Report</h1>
<p>Client Name: {clientName ?? "Unknown"}</p>
<p>Income: {optionalIncome?.ToString() ?? "Data not available"}</p>";
// Render the HTML to a PDF
var pdf = renderer.RenderHtmlAsPdf(htmlContent);
// Save the PDF to disk
pdf.SaveAs("FinancialReport.pdf");
Console.WriteLine("PDF Generated Successfully.");
}
}Imports IronPdf
Friend Class Program
Shared Sub Main(ByVal args() As String)
Dim optionalIncome? As Integer = Nothing ' Nullable type for optional income
'INSTANT VB WARNING: Nullable reference types have no equivalent in VB:
'ORIGINAL LINE: string? clientName = "Iron Dev";
Dim clientName As String = "Iron Dev" ' Nullable reference type for client name
Dim renderer = New ChromePdfRenderer()
Dim htmlContent As String = $"
<h1>Financial Report</h1>
<p>Client Name: {If(clientName, "Unknown")}</p>ignoreignore<p>Income: {If(optionalIncome?.ToString(), "Data not available")}</p>"
' Render the HTML to a PDF
Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
' Save the PDF to disk
pdf.SaveAs("FinancialReport.pdf")
Console.WriteLine("PDF Generated Successfully.")
End Sub
End Class
Neste código, tipos anuláveis (int? e string?) são usados para lidar com dados ausentes de forma segura. O operador de coalescência nula (??) garante que, se algum dado estiver faltando, um valor padrão seja usado na PDF.
Os tipos anuláveis em C# são uma ferramenta poderosa para lidar com valores nulos tanto em tipos de valor quanto em tipos de referência. Ao usar tipos anuláveis, você pode evitar exceções de referência nula e melhorar a robustez do seu código. Lembre-se de habilitar tipos de referência anuláveis em novos projetos para se beneficiar da verificação de erros em tempo de compilação e use o operador de coalescência nula (??) para simplificar seu código ao lidar com tipos anuláveis.
O IronPDF oferece um período de teste gratuito para que você possa explorar seus recursos antes de se comprometer. Sem custos iniciais, você pode testar o serviço e ver como ele se encaixa no seu processo de desenvolvimento. Uma vez que você esteja pronto para prosseguir, as licenças começam a partir de $999.
Curtis Chau é bacharel em Ciência da Computação (Universidade Carleton) e se especializa em desenvolvimento front-end, com experiência em Node.js, TypeScript, JavaScript e React. Apaixonado por criar interfaces de usuário intuitivas e esteticamente agradáveis, Curtis gosta de trabalhar com frameworks modernos e criar manuais bem estruturados e visualmente atraentes.
IronPDF faz parte do IRON SUITE.
10 produtos de API .NET para seus documentos de escritório
Quando você precisa que seu PDF tenha a aparência de HTML, rapidamente.
