Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. .NET Aide
  4. Types Nullable C#
.NET AIDE

C# Types Nullable (Comment ça fonctionne pour les développeurs)

Jacob Mellor, Directeur technique @ Team Iron
Jacob Mellor
Mis à jour:

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.

Types Nullable en 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 Nullable

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
$vbLabelText   $csharpLabel

Ici, int? est une abréviation de 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
$vbLabelText   $csharpLabel

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)
$vbLabelText   $csharpLabel

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

Types de valeurs Nullable vs types de références Nullable

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 Nullable

Un type de valeur annulable 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 :

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

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

Types de références Nullable

Les types référence nullables ont été introduits dans C# 8.0. Vous pouvez les activer au niveau du projet ou en ajoutant la directive #nullable enable au début de votre fichier de code. Lorsque les types référence nullables sont activés, il est nécessaire de les déclarer explicitement comme tels à l'aide de ?, ce qui permet d'éviter les exceptions d'exécution potentielles dues à 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
$vbLabelText   $csharpLabel

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

Activation des types de références Nullable

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

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 Nullable 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
$vbLabelText   $csharpLabel

Ici, nullableInt est une variable de type nullable de type int. Si nullableInt est nul, b obtient la valeur 10 en raison de l'opérateur de fusion nul. Sinon, b prend la valeur de nullableInt.

Exemple 2 : types de références Nullable

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
$vbLabelText   $csharpLabel

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

Exemple 3 : types Nullable 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
$vbLabelText   $csharpLabel

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)
$vbLabelText   $csharpLabel

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

Erreurs de compilation et types Nullable

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
$vbLabelText   $csharpLabel

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

Utilisation des types Nullable avec IronPDF

Types nullables en C# (Fonctionnement pour les développeurs) : Figure 1 - IronPDF: Bibliothèque PDF C#

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
$vbLabelText   $csharpLabel

Types nullables en C# (Fonctionnement pour les développeurs) : Figure 2 - Exemple de sortie de code

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 de null (??) garantit que si des données manquent, une valeur par défaut est utilisée dans le PDF.

Conclusion

Types nullables en C# (Fonctionnement pour les développeurs) : Figure 3 - Page de licence IronPDF

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.

Questions Fréquemment Posées

Comment les types nullable peuvent-ils être utilisés dans la génération dynamique de PDF ?

Les types nullable peuvent être cruciaux dans la génération dynamique de PDF en permettant de représenter de manière sécurisée les champs optionnels, en utilisant des bibliothèques comme IronPDF. Cela garantit que les données manquantes sont gérées de manière appropriée, avec des valeurs par défaut fournies là où nécessaire.

Quelle est la syntaxe pour déclarer des types nullable en C# ?

En C#, vous pouvez déclarer un type nullable en ajoutant un point d'interrogation '?' au type de données. Par exemple, pour déclarer un entier nullable, vous écririez int? nullableInt = null;.

Les types nullable en C# peuvent-ils affecter la robustesse des rapports générés ?

Oui, l'utilisation des types nullable peut améliorer la robustesse des rapports générés en veillant à ce que les champs optionnels ne causent pas d'erreurs lorsque leurs valeurs sont absentes. Les bibliothèques comme IronPDF peuvent utiliser des types nullable pour gérer ces conditions efficacement.

Comment les types de référence nullable aident-ils à prévenir les erreurs d'exécution ?

Les types de référence nullable, introduits dans C# 8.0, aident à prévenir les erreurs d'exécution en permettant aux types de référence d'être non-nullable par défaut. Cela réduit le risque d'exceptions de référence nulles et permet une détection précoce des problèmes potentiels lors de la compilation.

Quel est le rôle de l'opérateur de coalescence de null dans la gestion des types nullable ?

L'opérateur de coalescence de null ?? est utilisé dans la gestion des types nullable en fournissant une valeur par défaut lorsqu'un type nullable est null. Il simplifie le code et aide à éviter les vérifications explicites if-else.

Comment pouvez-vous vérifier si un type nullable a une valeur en C# ?

Vous pouvez déterminer si un type nullable a une valeur en C# en utilisant la propriété HasValue ou en comparant directement la variable à null.

Quels sont quelques scénarios typiques d'utilisation des types nullable dans les applications C# ?

Les types nullable sont souvent utilisés dans des situations où les données peuvent être incomplètes ou optionnelles, telles que les entrées de formulaire, les paramètres de configuration ou lors de l'interfaçage avec des bases de données qui autorisent les valeurs nulles. Ils sont particulièrement utiles dans la génération de rapports dynamiques avec des bibliothèques comme IronPDF.

Comment l'activation des types de référence nullable influence-t-elle la compilation de projet C# ?

L'activation des types de référence nullable dans un projet C# entraîne des avertissements et des erreurs de compilation pour les problèmes potentiels de référence null, ce qui permet de détecter les problèmes tôt et de promouvoir un développement de code plus robuste.

Jacob Mellor, Directeur technique @ Team Iron
Jacob Mellor
  Discutez maintenant avec l'équipe d'ingénierie
Directeur technique

Jacob Mellor est directeur de la technologie chez Iron Software et un ingénieur visionnaire pionnier de la technologie C# PDF. En tant que développeur à l'origine de la base de code centrale d'Iron Software, il a façonné l'architecture des produits de l'entreprise depuis sa création, ...

Lire la suite

Articles connexes

Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Essai gratuit

Équipe de soutien Iron

Nous sommes en ligne 24 heures sur 24, 5 jours sur 7.
Chat
Email
Appelez-moi