Nullable Types In C# Complete Guide

Complete Example: Step-by-Step Guide to Nullable Types in C#

In this example, we will guide you through understanding and using nullable types by simulating a simple application that records student's scores, including students who did not attempt a particular assignment.

Step 1: Set Up the Environment

First, ensure that you have Visual Studio installed (or any other C# development environment). If not, download it from the official Visual Studio website.

Step 2: Create a New Console Application

1. Open Visual Studio.
2. Create a new project:
   • File -> New -> Project
3. Select Console App (.NET Core) and click Next.
4. Name your project (e.g., NullableTypesDemo) and click Create.

Step 3: Understand What Nullable Types Are

Before diving into the code, let's look at how nullable types are declared:

int? nullableInt = null; // Declare a nullable int
double? nullableDouble = 4.5; // Nullable double can hold a double value or null
bool? nullableBool = true; // Nullable bool can hold true, false, or null

The ? suffix in int?, double?, and bool? makes these value types capable of storing null values.

Step 4: Write Sample Code Using Nullable Types

We will create a Student class that includes a score, which is sometimes not available. For this purpose, we will use a nullable double type.

1. Open Program.cs.
2. Replace the existing code with the following:

using System;

namespace NullableTypesDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            // Create students
            Student student1 = new Student("John Doe", 87.5);
            Student student2 = new Student("Jane Smith");
            Student student3 = new Student("Mike Johnson", 92.7);

            // Store students in an array
            Student[] students = { student1, student2, student3 };

            // Display scores of each student
            foreach (Student student in students)
            {
                if (student.Score.HasValue)
                {
                    Console.WriteLine($"{student.Name}'s score is: {student.Score.Value}");
                }
                else
                {
                    Console.WriteLine($"{student.Name} did not submit the assignment.");
                }
            }

            // Try to get a score even if it doesn't exist
            try
            {
                double johnsScore = student1.Score.Value;
                Console.WriteLine($"John Doe's score is: {johnsScore}");

                // This will throw InvalidOperationException because Score does not exist
                double janesScore = student2.Score.Value;
            }
            catch (InvalidOperationException ex)
            {
                Console.WriteLine(ex.Message);
            }

            // Use ?? operator to provide default value
            foreach (Student student in students)
            {
                // Provide a default score of 0 if Score is null
                double finalScore = student.Score ?? 0;
                Console.WriteLine($"{student.Name}'s final score is: {finalScore}");
            }

            // Use GetValueOrDefault() method to provide default value
            foreach (Student student in students)
            {
                // Provide a default score of 0 if Score is null
                double finalScore = student.Score.GetValueOrDefault(0);
                Console.WriteLine($"{student.Name}'s final score is: {finalScore}");
            }
        }
    }

    public class Student
    {
        public string Name { get; set; }
        public double? Score { get; set; }

        // Constructor when Score is provided
        public Student(string name, double score)
        {
            Name = name;
            Score = score;
        }

        // Constructor when Score is not provided
        public Student(string name)
        {
            Name = name;
            Score = null; // Alternatively, you could omit this line because the default is null
        }
    }
}

Step 5: Run the Program

1. Press F5 or click the Start button in Visual Studio to run your program.
2. Observe the output in the console.

Expected Output:

John Doe's score is: 87.5
Jane Smith did not submit the assignment.
Mike Johnson's score is: 92.7
John Doe's score is: 87.5
Nullable object must have a value before using it.
John Doe's final score is: 87.5
Jane Smith's final score is: 0
Mike Johnson's final score is: 92.7
John Doe's final score is: 87.5
Jane Smith's final score is: 0
Mike Johnson's final score is: 92.7

Explanation of the Code

• Nullable Double Declaration: The Score property of the Student class is declared as double? which means it can hold either a double value or null.

public double? Score { get; set; }

• Checking Values: We use the HasValue property to see if a student submitted a score. If they did, we access the score using the Value property.

if (student.Score.HasValue)
{
    Console.WriteLine($"{student.Name}'s score is: {student.Score.Value}");
}
else
{
    Console.WriteLine($"{student.Name} did not submit the assignment.");
}

• Handling Null: If you try to access the .Value property on a nullable type that is null, it will throw an InvalidOperationException. We wrapped this in a try-catch block to handle such exceptions gracefully.

try
{
    double johnsScore = student1.Score.Value;
    Console.WriteLine($"John Doe's score is: {johnsScore}");
    double janesScore = student2.Score.Value;
}
catch (InvalidOperationException ex)
{
    Console.WriteLine(ex.Message); // Display exception message if Score is null
}

• Using the Null Coalescing Operator (??): The null coalescing operator allows us to provide a default value if the variable is null.

double finalScore = student.Score ?? 0;
Console.WriteLine($"{student.Name}'s final score is: {finalScore}");

• Using GetValueOrDefault() Method: This is another way to provide a default value if the nullable variable is null.

double finalScore = student.Score.GetValueOrDefault(0);
Console.WriteLine($"{student.Name}'s final score is: {finalScore}");

Conclusion

Nullable types in C# are essential for scenarios where data might be missing. They help maintain clean and robust code. In our example, we demonstrated how to use nullable doubles in a Student class, checking for null, handling exceptions, and providing default values.