C# Nullable Types (How It Works For Developers) (Les types annulables en C# (Comment cela fonctionne pour les développeurs))

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

Types annulables dans C# ;

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

Déclarer des types annulables

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

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

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

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

Ici, int ? est l'abréviation de Nullable. 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 la variable directement avec null. Par exemple :

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

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

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 est nul, la valeur par défaut de 0 sera attribuée au résultat.

Types de valeurs annulables et types de références annulables

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

Types de valeurs nulles

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

double? nullableDouble = null;

double? nullableDouble = null;

Dim nullableDouble? As Double = Nothing

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

Types de référence annulables

Les types de référence nullables ont été introduits dans C# 8.0. Vous activez les types de référence nullables au niveau du projet ou en ajoutant la directive #nullable enable au début de votre fichier de code. Lorsque les types de référence nullables sont activés, les types de référence doivent être explicitement marqués comme nullables à l'aide de la directive ?

#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

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

Activation des types de référence annulables

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

<Nullable>enable</Nullable>

<Nullable>enable</Nullable>

Une fois activé, le compilateur traitera les types de référence comme non annulables par défaut. Cette fonctionnalité est particulièrement utile pour détecter les problèmes liés aux références nulles au moment de la compilation plutôt qu'au moment de l'exécution.

Exemples pratiques

Explorons quelques exemples pratiques pour consolider votre compréhension des types nullables.

Exemple 1 : Type Nullable avec types de valeurs

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

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

Exemple 2 : Types de référence annulables

Voyons maintenant comment fonctionnent les types de référence nullables :

#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

Dans le code ci-dessus, nullableString peut être null, et l'opérateur de coalescence null garantit que s'il est null, la longueur de la chaîne est par défaut égale à 0.

Exemple 3 : Types Nullables imbriqués

C# vous permet de déclarer des types imbriqués nullables. Par exemple, en C#, vous pouvez déclarer des types nullables imbriqués :

int?? nestedNullableInt = null;

int?? nestedNullableInt = null;

If(Integer, nestedNullableInt) = Nothing

Bien que les types nullables imbriqués puissent sembler redondants, ils sont syntaxiquement valides en C#. Cependant, dans la pratique, les types nullables imbriqués n'apportent aucune fonctionnalité supplémentaire et sont rarement utilisés.

Opérateur de coalescence nulle ( ??)

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

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

Erreurs de compilation et types annulables

Lorsque les types de référence nullables sont activés, C# produit des avertissements et des erreurs lors de la compilation lorsqu'il détecte des problèmes potentiels avec les affectations null. Ces erreurs de compilation permettent de détecter les problèmes à un stade précoce, ce qui rend votre code plus robuste.

Prenons l'exemple suivant :

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

Dans ce cas, l'affectation de nullableString à nonNullableString produit un avertissement du compilateur car nullableString peut être null, et son affectation à un type non nullable pourrait entraîner des exceptions à l'exécution.

Utiliser les types annulables avec IronPDF

IronPDF est une bibliothèque PDF C# conçue pour aider les développeurs à créer, modifier et manipuler des fichiers PDF directement depuis 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, par exemple lorsque vous générez un PDF pour un comptable avec des données financières incomplètes. L'utilisation de types nullables permet de gérer les champs facultatifs, d'éviter les exceptions et de fournir des valeurs par défaut

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

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

Conclusion

Les types nullables dans C# constituent un outil puissant pour gérer les valeurs nulles dans les types de valeur et les types de référence. En utilisant les types nullables, 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érence annulables dans les nouveaux projets pour bénéficier de la vérification des erreurs lors de la compilation, et utilisez l'opérateur de coalescence nulle (??) pour simplifier votre code lorsque vous travaillez avec des types annulables.

IronPDF offre un essai gratuit pour vous aider à explorer ses fonctionnalités avant de vous engager. Sans coût initial, vous pouvez tâter le terrain et voir comment ces outils s'intègrent dans votre processus de développement. Une fois que vous êtes prêt à avancer, les licences commencent à partir de $749.