How to work with nullable types in C#?

Working with nullable types in C# allows you to represent the absence of a value in addition to its actual value. This is particularly useful when dealing with data from sources where values may be missing or when you want to distinguish between an uninitialized value and a meaningful “null” value. Nullable types are mainly used for value types like integers, decimals, and DateTime, as reference types can inherently represent null values. Here’s how to work with nullable types in C#:

1. Declaration:

   To create a nullable type, you append a `?` symbol to the underlying value type. For example, `int? nullableInt = null;` declares a nullable integer variable initialized to null.

2. Nullable Value Assignment:

   Nullable types can hold the actual value or be set to null. You can assign values to nullable variables just like regular variables of the underlying type. For instance, `nullableInt = 42;` assigns the integer value 42 to `nullableInt`.

3. Checking for Null:

   You can check whether a nullable variable has a value by using the `.HasValue` property. If it has a value, you can access it using the `.Value` property. For example:

```csharp
  if (nullableInt.HasValue)
  {
      int actualValue = nullableInt.Value;
  }
  ```

4. The `??` Operator:

   The null-coalescing operator `??` is a convenient way to provide a default value for a nullable variable if it’s null. For example, `int result = nullableInt ?? 0;` assigns 0 to `result` if `nullableInt` is null.

5. Nullable Types and Database Integration:

   Nullable types are commonly used when working with databases. Database columns that allow null values can be mapped to nullable types in C#.

6. Using `Nullable<T>` Struct:

   Behind the scenes, nullable types are represented using the `Nullable<T>` struct, where `T` is the underlying value type. You can also use this struct directly if needed.

7. Initializing with `default`:

   You can initialize a nullable variable with the `default` keyword to set it to its default value, which is null for nullable types.

Using nullable types in C# adds flexibility and clarity to your code, especially when dealing with potentially missing or uninitialized data. They help prevent null reference exceptions and make your code more robust when handling uncertain or nullable values.