Lorsque vous travaillez avec C#, vous devez souvent gérer les valeurs nulles, surtout avec les types de référence. Les types annulables en C# offrent un moyen de représenter des valeurs non définies ou absentes pour les types de valeur. Ce guide couvre les principes essentiels des types annulables en C#, leurs utilisations pratiques et leur fonctionnement dans différents scénarios. Nous explorerons également IronPDF plus loin dans l'article.

Nullable Types in C#

Par défaut, les types de valeur en C# (par exemple, int, bool, DateTime) ne peuvent pas être affectés de valeurs nulles. Pour résoudre cette limitation, C# introduit les types de valeurs annulables, vous permettant d'affecter null à des types de valeur. Les types annulables sont particulièrement utiles lorsque vous devez représenter l'absence d'une valeur valide.

Déclaration de Types Annulables

Pour déclarer un type annulable en C#, vous utilisez la syntaxe suivante :

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

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

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

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

Ici, int? est une abréviation pour Nullable<int>. La variable nullableInt peut contenir soit une valeur int, soit null.

Vérification de la nullité

Pour vérifier si une variable de type nullable a une valeur ou non, vous pouvez utiliser la propriété HasValue ou comparer directement la variable avec null, comme indiqué ci-dessous :

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

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

Alternativement, vous pouvez utiliser l'opérateur de coalescence de null (??) pour fournir une valeur par défaut lorsque le type annulable est null :

// 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)

' Assign 0 if nullableInt is null
Dim result As Integer = If(nullableInt, 0)
Console.WriteLine("Result: " & result)

Si nullableInt est null, result se verra attribuer la valeur par défaut de 0.

Types de Valeurs Annulables vs Types de Références Annulables

En C#, les types de valeur (comme int, bool et double) diffèrent des types de référence (comme string, object). Les types de valeurs annulables permettent aux types de valeur de représenter null, tandis que les types de références annulables permettent par défaut aux types de référence de ne pas être annulables, réduisant ainsi le risque d'exceptions de référence nulles.

Types de Valeurs Annulables

Un type de valeur annulable permet à un type de valeur de prendre une valeur nulle. Pour déclarer un type valeur nullable, ajoutez un point d'interrogation ? au type de données :

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

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

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

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

Dans cet exemple, nullableDouble peut contenir une valeur double ou null.

Types de Références Annulables

Les types de référence nullable ont été introduits dans C# 8.0. Vous pouvez activer les types de référence nullable au niveau du projet ou en ajoutant la directive #nullable enable au début de votre fichier de code. Avec les types de référence nullable activés, les types de référence doivent être explicitement marqués comme nullable en utilisant ?, ce qui aide à éviter les exceptions potentielles d'exécution causées par des références nulles.

#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

'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

Ici, nullableString est autorisé à être null. Si vous déclarez un type de référence non-nullable sans ?, le compilateur produira des avertissements s'il détecte des affectations nulles potentielles.

Activation des Types de Références Annulables

Pour activer les types de référence nullable globalement dans un projet, ajoutez la ligne suivante à votre fichier .csproj :

<Nullable>enable</Nullable>

<Nullable>enable</Nullable>

Une fois activé, le compilateur traitera par défaut les types de référence comme non annulables. Cette fonctionnalité est particulièrement pratique pour identifier les problèmes de référence nulles à la compilation plutôt qu'à l'exécution.

Exemples Pratiques

Explorons quelques exemples pratiques pour renforcer votre compréhension des types annulables.

Exemple 1 : Type Annulable avec Types de Valeur

Dans cet exemple, nous utiliserons un type annulable avec 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

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

Ici, nullableInt est une variable de type nullable d'int. Si nullableInt est null, b reçoit la valeur 10 grâce à l'opérateur de fusion null. Sinon, b prend la valeur de nullableInt.

Exemple 2 : Types de Références Annulables

Voyons maintenant comment fonctionnent les types de références annulables :

#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

'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

Dans le code ci-dessus, nullableString peut être null, et l'opérateur de fusion null assure que si c'est le cas, la longueur de la chaîne par défaut est 0.

Exemple 3 : Types Annulables Emboîtés

C# vous permet de déclarer des types annulables emboîtés. Par exemple :

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

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

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

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

Bien que les types annulables emboîtés puissent sembler redondants, ils sont syntaxiquement valides en C#. Cependant, en pratique, les types annulables emboîtés n'offrent aucune fonctionnalité supplémentaire et sont rarement utilisés.

Opérateur de Coalescence de Null (??)

L'opérateur de coalescence de null (??) est fréquemment utilisé avec les types annulables pour fournir une valeur par défaut lorsque le type annulable est null. Cet opérateur simplifie le code en évitant des vérifications explicites 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)

Dim nullableValue? As Integer = Nothing
' Assign -1 if nullableValue is null
Dim defaultValue As Integer = If(nullableValue, -1)

Dans cet exemple, si nullableValue est null, defaultValue se verra attribuer -1. Sinon, defaultValue prendra la valeur de nullableValue.

Erreurs de Compilation et Types Annulables

Avec l'activation des types de références annulables, C# produit des avertissements et des erreurs lors de la compilation lorsqu'il détecte des problèmes potentiels avec les affectations nulles. Ces erreurs de compilation aident à identifier les problèmes tôt, rendant votre code plus robuste.

Considérez l'exemple suivant :

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

'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

Dans ce cas, attribuer nullableString à nonNullableString entraîne un avertissement du compilateur parce que nullableString peut être null, et l'assigner à un type non nullable pourrait entraîner des exceptions d'exécution.

Utilisation des Types Annulables avec IronPDF

IronPDF est une bibliothèque PDF pour C# conçue pour aider les développeurs à créer, éditer et manipuler des fichiers PDF directement à partir des applications .NET. Vous pouvez convertir HTML en PDF, générer des rapports, ou même gérer des structures de documents complexes.

Les types annulables sont particulièrement utiles dans les scénarios de génération de rapports dynamiques, comme lorsque vous générez un PDF pour un comptable avec des données financières incomplètes. En utilisant des types annulables, vous pouvez gérer des champs optionnels, éviter les exceptions et fournir des valeurs par défaut.

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

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

Dans ce code, les types nullable (int? et string?) sont utilisés pour gérer en toute sécurité les données manquantes. L'opérateur de coalescence de null (??) garantit que si des données manquent, une valeur par défaut est utilisée dans le PDF.

Conclusion

Les types annulables en C# sont un outil puissant pour gérer les valeurs nulles à la fois dans les types de valeur et de référence. En utilisant des types annulables, vous pouvez éviter les exceptions de référence nulle et améliorer la robustesse de votre code. N'oubliez pas d'activer les types de références annulables dans les nouveaux projets pour bénéficier de la vérification des erreurs à la compilation, et utilisez l'opérateur de coalescence de null (??) pour simplifier votre code lors du traitement des types annulables.

IronPDF propose un essai gratuit pour vous aider à explorer ses fonctionnalités avant de vous engager. Sans coût initial, vous pouvez tester les possibilités et voir comment il s'intègre à votre processus de développement. Une fois que vous êtes prêt à aller de l'avant, les licences commencent à partir de $999.