AJUDA DO .NET

Tipos anuláveis em C# (Como funciona para desenvolvedores)

Q: Qual é o papel do operador de coalescência nula no gerenciamento de tipos anuláveis?

O operador de coalescência nula ?? é usado no gerenciamento de tipos anuláveis, fornecendo um valor padrão quando um tipo anulável é nulo. Isso simplifica o código e ajuda a evitar verificações explícitas do tipo if-else.

Curtis Chau

Atualizado:julho 28, 2025

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.

Tipos Anuláveis em C

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.

Declaração de tipos anuláveis

Para declarar um tipo anulável em C#, você usa a seguinte sintaxe:

// Declare a nullable integer
int? nullableInt = null;

// Declare a nullable integer
int? nullableInt = null;

' Declare a nullable integer
Dim nullableInt? As Integer = Nothing

$vbLabelText $csharpLabel

Aqui, int? é uma abreviação para Nullable<int>. A variável nullableInt pode armazenar um valor inteiro ou nulo.

Verificando se é nulo

Para verificar se uma variável de tipo anulável possui 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)
{
    // 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 If

$vbLabelText $csharpLabel

Alternativamente, 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
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)

$vbLabelText $csharpLabel

Se nullableInt for nulo, result receberá o valor padrão de 0.

Tipos de valor anuláveis vs. tipos de referência anuláveis

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.

Tipos de valores anuláveis

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 dados:

// Declare a nullable double
double? nullableDouble = null;

// Declare a nullable double
double? nullableDouble = null;

' Declare a nullable double
Dim nullableDouble? As Double = Nothing

$vbLabelText $csharpLabel

Neste exemplo, nullableDouble pode conter um valor double ou nulo.

Tipos de referência anuláveis

Os tipos de referência anuláveis foram introduzidos no C# 8.0. Você pode habilitar os tipos de referência anuláveis no 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 possíveis exceções em tempo de execução causadas por referências nulas.

#nullable enable
// Declare a nullable string
string? nullableString = null;

#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 = Nothing

$vbLabelText $csharpLabel

Aqui, nullableString pode ser nulo. Se você declarar um tipo de referência não anulável sem o ?, o compilador emitirá avisos se detectar possíveis atribuições nulas.

Habilitando Tipos de Referência Anuláveis

Para habilitar tipos de referência anuláveis globalmente em um projeto, adicione a seguinte linha ao seu arquivo .csproj:

<Nullable>enable</Nullable>

<Nullable>enable</Nullable>

XML

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.

Exemplos práticos

Vamos explorar alguns exemplos práticos para consolidar sua compreensão de tipos anuláveis.

Exemplo 1: Tipo anulável com tipos de valor

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");
        }
    }
}

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 Class

$vbLabelText $csharpLabel

Aqui, nullableInt é uma variável do tipo int que pode ser anulada. Se nullableInt for nulo, b receberá o valor 10 devido ao operador de coalescência nula. Caso contrário, b assume o valor de nullableInt.

Exemplo 2: Tipos de Referência Anuláveis

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);
    }
}

#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 Class

$vbLabelText $csharpLabel

No código acima, nullableString pode ser nulo, e o operador de coalescência nula garante que, se for nulo, o comprimento da string assuma o valor 0 por padrão.

Exemplo 3: Tipos anuláveis aninhados

Em C#, você pode declarar tipos anuláveis aninhados. Por exemplo:

// Redundant, but syntactically valid
int? nestedNullableInt = null;

// Redundant, but syntactically valid
int? nestedNullableInt = null;

' Redundant, but syntactically valid
Dim nestedNullableInt? As Integer = Nothing

$vbLabelText $csharpLabel

Embora 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.

Operador de coalescência nula (??)

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;

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)

$vbLabelText $csharpLabel

Neste exemplo, se nullableValue for nulo, defaultValue receberá o valor -1. Caso contrário, defaultValue assumirá o valor de nullableValue.

Erros de tempo de compilação e tipos anuláveis

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;

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 = nullableString

$vbLabelText $csharpLabel

Neste caso, atribuir nullableString a nonNullableString gera um aviso do compilador porque nullableString pode ser nulo, e atribuí-lo a um tipo não anulável pode levar a exceções em tempo de execução.

Utilizando tipos anuláveis com IronPDF

Tipos anuláveis em C# (Como funciona para desenvolvedores): Figura 1 - IronPDF: Biblioteca PDF em C#

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.");
    }
}

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

$vbLabelText $csharpLabel

Tipos anuláveis em C# (Como funciona para desenvolvedores): Figura 2 - Exemplo de saída de código

Neste código, os 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.

Conclusão

Tipos anuláveis em C# (Como funciona para desenvolvedores): Figura 3 - Página de licenciamento do IronPDF

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. Quando estiver pronto para prosseguir, as licenças começam a partir de $799.

Perguntas frequentes

Como os tipos anuláveis podem ser utilizados na geração dinâmica de PDFs?

Tipos anuláveis podem ser cruciais na geração dinâmica de PDFs, permitindo que campos opcionais sejam representados com segurança, utilizando bibliotecas como o IronPDF. Isso garante que os dados ausentes sejam tratados adequadamente, com valores padrão fornecidos quando necessário.

Qual é a sintaxe para declarar tipos anuláveis em C#?

Em C#, você pode declarar um tipo anulável adicionando um ponto de interrogação '?' ao tipo de dados. Por exemplo, para declarar um inteiro anulável, você escreveria int? nullableInt = null; .

Os tipos anuláveis em C# podem afetar a robustez dos relatórios gerados?

Sim, o uso de tipos anuláveis pode aumentar a robustez dos relatórios gerados, garantindo que campos opcionais não causem erros quando seus valores estiverem ausentes. Bibliotecas como o IronPDF podem utilizar tipos anuláveis para gerenciar essas condições de forma eficiente.

Como os tipos de referência anuláveis ajudam a prevenir erros em tempo de execução?

Os tipos de referência anuláveis, introduzidos no C# 8.0, ajudam a prevenir erros em tempo de execução, permitindo que os tipos de referência não sejam anuláveis por padrão. Isso reduz o risco de exceções de referência nula e permite a detecção precoce de possíveis problemas durante a compilação.

Qual é o papel do operador de coalescência nula no gerenciamento de tipos anuláveis?

O operador de coalescência nula ?? é usado no gerenciamento de tipos anuláveis, fornecendo um valor padrão quando um tipo anulável é nulo. Isso simplifica o código e ajuda a evitar verificações explícitas do tipo if-else.

Como verificar se um tipo anulável possui um valor em C#?

Em C#, você pode determinar se um tipo anulável possui um valor usando a propriedade HasValue ou comparando a variável diretamente com null.

Quais são alguns cenários típicos para o uso de tipos anuláveis em aplicações C#?

Os tipos anuláveis são frequentemente usados em situações onde os dados podem estar incompletos ou serem opcionais, como em campos de formulário, configurações ou ao interagir com bancos de dados que permitem valores nulos. Eles são particularmente úteis na geração dinâmica de relatórios com bibliotecas como o IronPDF.

Como habilitar tipos de referência anuláveis afeta a compilação de projetos C#?

Habilitar tipos de referência anuláveis em um projeto C# leva a avisos e erros em tempo de compilação para possíveis problemas de referência nula, detectando problemas precocemente e promovendo um desenvolvimento de código mais robusto.

Curtis Chau

Converse agora mesmo com a equipe de engenharia.

Redator Técnico

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 ...

Destaque do cliente:

Destaque do desenvolvedor:

Webinários:

Experimente gratuitamente por 30 dias.

Tipos anuláveis em C# (Como funciona para desenvolvedores)

Tipos Anuláveis em C

Declaração de tipos anuláveis

Verificando se é nulo

Tipos de valor anuláveis vs. tipos de referência anuláveis

Tipos de valores anuláveis

Tipos de referência anuláveis

Habilitando Tipos de Referência Anuláveis

Exemplos práticos

Exemplo 1: Tipo anulável com tipos de valor

Exemplo 2: Tipos de Referência Anuláveis

Exemplo 3: Tipos anuláveis aninhados

Operador de coalescência nula (??)

Erros de tempo de compilação e tipos anuláveis

Utilizando tipos anuláveis com IronPDF

Conclusão

Perguntas frequentes

Como os tipos anuláveis podem ser utilizados na geração dinâmica de PDFs?

Qual é a sintaxe para declarar tipos anuláveis em C#?

Os tipos anuláveis em C# podem afetar a robustez dos relatórios gerados?

Como os tipos de referência anuláveis ajudam a prevenir erros em tempo de execução?

Qual é o papel do operador de coalescência nula no gerenciamento de tipos anuláveis?

Como verificar se um tipo anulável possui um valor em C#?

Quais são alguns cenários típicos para o uso de tipos anuláveis em aplicações C#?

Como habilitar tipos de referência anuláveis afeta a compilação de projetos C#?

Equipe de suporte de ferro

Experimente gratuitamente por 30 dias.

Tipos anuláveis em C# (Como funciona para desenvolvedores)

Tipos Anuláveis em C

Declaração de tipos anuláveis

Verificando se é nulo

Tipos de valor anuláveis ​​vs. tipos de referência anuláveis

Tipos de valores anuláveis

Tipos de referência anuláveis

Habilitando Tipos de Referência Anuláveis

Exemplos práticos

Exemplo 1: Tipo anulável com tipos de valor

Exemplo 2: Tipos de Referência Anuláveis

Exemplo 3: Tipos anuláveis ​​aninhados

Operador de coalescência nula (??)

Erros de tempo de compilação e tipos anuláveis

Utilizando tipos anuláveis ​​com IronPDF

Conclusão

Perguntas frequentes

Como os tipos anuláveis podem ser utilizados na geração dinâmica de PDFs?

Qual é a sintaxe para declarar tipos anuláveis em C#?

Os tipos anuláveis em C# podem afetar a robustez dos relatórios gerados?

Como os tipos de referência anuláveis ajudam a prevenir erros em tempo de execução?

Qual é o papel do operador de coalescência nula no gerenciamento de tipos anuláveis?

Como verificar se um tipo anulável possui um valor em C#?

Quais são alguns cenários típicos para o uso de tipos anuláveis em aplicações C#?

Como habilitar tipos de referência anuláveis afeta a compilação de projetos C#?

Artigos relacionados

Unindo a simplicidade da linha de comando e o .NET: usando Curl DotNet com IronPDF

Gerador de Números Aleatórios em C#

O operador Equals em C# (Como funciona para desenvolvedores)

Want to deploy IronSuite to a live project for FREE?

What’s included?

Thank You

Want to deploy IronSuite to a live project for FREE?

What’s included?

Aprovado por milhões de engenheiros em todo o mundo.

Equipe de suporte de ferro

Tipos de valor anuláveis vs. tipos de referência anuláveis

Exemplo 3: Tipos anuláveis aninhados

Utilizando tipos anuláveis com IronPDF