Tipos nulos en C# (Cómo funciona para desarrolladores)

Cuando se trabaja con C#, a menudo es necesario manejarvalores nulos... especialmente con los tipos de referencia. Los tipos nulos en C# proporcionan una forma de representar valores indefinidos o ausentes para tipos de valor. Esta guía cubre lo esencial de los tipos anulables en C#, sus usos prácticos y cómo funcionan en diferentes escenarios. Exploraremos laIronPDF así como más adelante en el artículo.

Tipos nulos en C#

Por defecto, los tipos de valor en C#(por ejemplo, int, bool, DateTime) no se pueden asignar valores nulos. Para hacer frente a esta limitación, C# introduce los tipos de valor anulables, que permiten asignar nulos a los tipos de valor. Los tipos anulables son particularmente útiles cuando se necesita representar la ausencia de un valor válido.

Declaración de tipos nulos

Para declarar un tipo anulable en C#, se utiliza la siguiente sintaxis:

// Nullable type variable value
int? nullableInt = null;

// Nullable type variable value
int? nullableInt = null;

' Nullable type variable value
Dim nullableInt? As Integer = Nothing

En este caso, int? es la abreviatura de Nullable. La variable nullableInt puede contener un valor int o null.

Comprobación de nulos

Para comprobar si una variable de tipo nullable tiene un valor o no, puede utilizar la propiedad HasValue o comparar directamente la variable con null. Por ejemplo:

if (nullableInt.HasValue)
{
    Console.WriteLine("Value: " + nullableInt.Value);
}
else
{
    Console.WriteLine("No value assigned.");
}

if (nullableInt.HasValue)
{
    Console.WriteLine("Value: " + nullableInt.Value);
}
else
{
    Console.WriteLine("No value assigned.");
}

If nullableInt.HasValue Then
	Console.WriteLine("Value: " & nullableInt.Value)
Else
	Console.WriteLine("No value assigned.")
End If

Como alternativa, puede utilizar el operador de coalescencia de nulos(??) para proporcionar un valor por defecto cuando el tipo nullable es null:

int result = nullableInt ?? 0;
Console.WriteLine("Result: " + result);

int result = nullableInt ?? 0;
Console.WriteLine("Result: " + result);

Dim result As Integer = If(nullableInt, 0)
Console.WriteLine("Result: " & result)

Si nullableInt es nulo, se asignará al resultado el valor predeterminado de 0.

Tipos de valor anulables frente a tipos de referencia anulables

En C#, los tipos de valor(como int, bool y double) diferenciarse de los tipos de referencia(como cadena, objeto). Los tipos de valor anulables permiten que los tipos de valor representen nulos, mientras que los tipos de referencia anulables permiten que los tipos de referencia no sean anulables por defecto, reduciendo así el riesgo de excepciones de referencia nula.

Tipos de valores anulables

Un tipo de valor anulable permite que un tipo de valor tome un valor nulo. Para declarar un tipo de valor anulable, añada un signo de interrogación ? al tipo de datos:

double? nullableDouble = null;

double? nullableDouble = null;

Dim nullableDouble? As Double = Nothing

En este ejemplo, nullableDouble puede contener un valor doble o nulo.

Tipos de referencia anulables

Los tipos de referencia anulables se introdujeron en C# 8.0. Los tipos de referencia anulables se habilitan a nivel de proyecto o añadiendo la directiva #nullable enable al principio del archivo de código. Con los tipos de referencia anulables habilitados, los tipos de referencia deben marcarse explícitamente como anulables mediante ?, lo que ayuda a evitar posibles excepciones en tiempo de ejecución causadas por referencias nulas.

#nullable enable
string? nullableString = null;

#nullable enable
string? nullableString = null;

'INSTANT VB TODO TASK: There is no equivalent to #nullable in VB:
'#nullable enable
'INSTANT VB WARNING: Nullable reference types have no equivalent in VB:
'ORIGINAL LINE: string? nullableString = null;
Dim nullableString As String = Nothing

Aquí, se permite que nullableString sea null. Si declara un tipo de referencia no anulable sin el símbolo ?, el compilador producirá advertencias si detecta posibles asignaciones nulas.

Habilitación de tipos de referencia anulables

Para habilitar globalmente los tipos de referencia anulables en un proyecto, añada la siguiente línea a su archivo .csproj:

<Nullable>enable</Nullable>

<Nullable>enable</Nullable>

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'<Nullable> enable</Nullable>

Una vez activado, el compilador tratará por defecto los tipos de referencia como no anulables. Esta función es especialmente útil para detectar problemas de referencias nulas en tiempo de compilación y no en tiempo de ejecución.

Ejemplos prácticos

Exploremos algunos ejemplos prácticos para consolidar su comprensión de los tipos anulables.

Ejemplo 1: Tipo nulo con tipos de valor

En este ejemplo, utilizaremos un tipo anulable con int:

class Program
{
    static void Main(string[] args)
    {
        int? nullableInt = null;
        int b = nullableInt ?? 10; // Use null coalescing operator
        Console.WriteLine("b: " + b);
        if (nullableInt.HasValue)
        {
            Console.WriteLine("nullableInt has value: " + nullableInt.Value);
        }
        else
        {
            Console.WriteLine("nullableInt is null");
        }
    }
}

class Program
{
    static void Main(string[] args)
    {
        int? nullableInt = null;
        int b = nullableInt ?? 10; // Use null coalescing operator
        Console.WriteLine("b: " + b);
        if (nullableInt.HasValue)
        {
            Console.WriteLine("nullableInt has value: " + nullableInt.Value);
        }
        else
        {
            Console.WriteLine("nullableInt is null");
        }
    }
}

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim nullableInt? As Integer = Nothing
		Dim b As Integer = If(nullableInt, 10) ' Use null coalescing operator
		Console.WriteLine("b: " & b)
		If nullableInt.HasValue Then
			Console.WriteLine("nullableInt has value: " & nullableInt.Value)
		Else
			Console.WriteLine("nullableInt is null")
		End If
	End Sub
End Class

Aquí, nullableInt es una variable de tipo nullable de int. Si nullableInt es nulo, b obtiene el valor 10 debido al operador de coalescencia de nulos. De lo contrario, b toma el valor de nullableInt.

Ejemplo 2: Tipos de referencia anulables

Veamos ahora cómo funcionan los tipos de referencia anulables:

#nullable enable
class Program
{
    static void Main()
    {
        string? nullableString = null;
        string nonNullableString = "Hello";
        Console.WriteLine(nullableString?.Length ?? 0); // Use null coalescing operator
        Console.WriteLine(nonNullableString.Length);
    }
}

#nullable enable
class Program
{
    static void Main()
    {
        string? nullableString = null;
        string nonNullableString = "Hello";
        Console.WriteLine(nullableString?.Length ?? 0); // Use null coalescing operator
        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"
		Console.WriteLine(If(nullableString?.Length, 0)) ' Use null coalescing operator
		Console.WriteLine(nonNullableString.Length)
	End Sub
End Class

En el código anterior, nullableString puede ser null, y el operador null coalescing garantiza que, si es null, la longitud de la cadena sea 0 por defecto.

Ejemplo 3: Tipos nulos anidados

C# permite declarar tipos anulables anidados. Por ejemplo:

int?? nestedNullableInt = null;

int?? nestedNullableInt = null;

If(Integer, nestedNullableInt) = Nothing

Aunque los tipos anulables anidados pueden parecer redundantes, son sintácticamente válidos en C#. Sin embargo, en la práctica, los tipos anulables anidados no proporcionan ninguna funcionalidad adicional y rara vez se utilizan.

Operador coalescente nulo (??)

El operador de fusión nulo(??) se utiliza frecuentemente con tipos anulables para proporcionar un valor por defecto cuando el tipo anulable es nulo. Este operador simplifica el código al evitar las comprobaciones explícitas if-else.

int? nullableValue = null;
int defaultValue = nullableValue ?? -1;

int? nullableValue = null;
int defaultValue = nullableValue ?? -1;

Dim nullableValue? As Integer = Nothing
Dim defaultValue As Integer = If(nullableValue, -1)

En este ejemplo, si nullableValue es nulo, se asignará -1 a defaultValue. En caso contrario, defaultValue tomará el valor de nullableValue.

Errores de compilación y tipos anulables

Con los tipos de referencia anulables activados, C# produce advertencias y errores durante la compilación cuando detecta problemas potenciales con asignaciones nulas. Estos errores en tiempo de compilación ayudan a detectar problemas en una fase temprana, haciendo que el código sea más robusto.

Considere el siguiente ejemplo:

string? nullableString = null;
string nonNullableString = nullableString; // Compiler warning

string? nullableString = null;
string nonNullableString = nullableString; // Compiler warning

'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 = nullableString ' Compiler warning

En este caso, asignar nullableString a nonNullableString produce una advertencia del compilador porque nullableString puede ser nulo, y asignarlo a un tipo no anulable podría provocar excepciones en tiempo de ejecución.

Uso de tipos anulables con IronPDF

IronPDF es una biblioteca PDF en C# diseñada para ayudar a los desarrolladores a crear, editar y manipular archivos PDF directamente desde aplicaciones .NET. Puedeconvertir HTML a PDFla traducción debe ser profesional, preservando la precisión técnica y explicando al mismo tiempo las características y ventajas de estas herramientas para desarrolladores.

Los tipos anulables son especialmente útiles en situaciones de generación de informes dinámicos, como cuando se genera un PDF para un contable con datos financieros incompletos. El uso de tipos anulables permite gestionar campos opcionales, evitar excepciones y proporcionar valores por defecto

using IronPdf;
class Program
{
    static void Main(string[] args)
    {
        int? optionalIncome = null;  // Nullable type
        string? clientName = "Iron Dev";  // Nullable reference type
        var renderer = new ChromePdfRenderer();
        string htmlContent = $@"
            <h1>Financial Report</h1>
            <p>Client Name: {clientName ?? "Unknown"}</p>
            <p>Income: {optionalIncome?.ToString() ?? "Data not available"}</p>";
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);
        pdf.SaveAs("FinancialReport.pdf");
        Console.WriteLine("PDF Generated Successfully.");
    }
}

using IronPdf;
class Program
{
    static void Main(string[] args)
    {
        int? optionalIncome = null;  // Nullable type
        string? clientName = "Iron Dev";  // Nullable reference type
        var renderer = new ChromePdfRenderer();
        string htmlContent = $@"
            <h1>Financial Report</h1>
            <p>Client Name: {clientName ?? "Unknown"}</p>
            <p>Income: {optionalIncome?.ToString() ?? "Data not available"}</p>";
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);
        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
'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
		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>"
		Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
		pdf.SaveAs("FinancialReport.pdf")
		Console.WriteLine("PDF Generated Successfully.")
	End Sub
End Class

En este código, los tipos anulables(¿int? y cadena?) se utilizan para manejar con seguridad los datos que faltan. El operador de fusión nulo(??) garantiza que, si falta algún dato, se utilice un valor por defecto en el PDF.

Conclusión

Los tipos anulables en C# son una potente herramienta para manejar valores nulos tanto en tipos de valor como en tipos de referencia. Mediante el uso de tipos anulables, puede evitar excepciones de referencia nula y mejorar la solidez de su código. Recuerde habilitar los tipos de referencia anulables en los nuevos proyectos para beneficiarse de la comprobación de errores en tiempo de compilación y utilizar el operador de coalescencia de nulos(??) para simplificar el código cuando se trabaja con tipos anulables.

IronPDF ofrece unprueba gratuita para ayudarle a explorar sus características antes de comprometerse. Sin ningún coste por adelantado, puedes probarlo y ver cómo encaja en tu proceso de desarrollo. Una vez que estés listo para avanzar, las licencias comienzan desde $749.