Nullable types in C# allow value types to represent the normal range of values plus an additional null value. This is particularly useful when dealing with databases and other scenarios where a value might be undefined or missing.
### Key Points about Nullable Types
1. **Definition**:
- Nullable types are instances of the `System.Nullable<T>` structure.
- They can represent all the values of their underlying type `T`, plus an additional `null` value.
2. **Syntax**:
- A nullable type is defined using the `?` syntax after the value type.
```csharp
int? nullableInt = null;
```
3. **Properties and Methods**:
- **HasValue**: Returns `true` if the variable contains a non-null value.
- **Value**: Gets the value if `HasValue` is `true`; otherwise, it throws an `InvalidOperationException`.
```csharp
if (nullableInt.HasValue)
{
int value = nullableInt.Value;
}
```
4. **Null-Coalescing Operator**:
- The `??` operator provides a default value when a nullable type has no value.
```csharp
int value = nullableInt ?? 0; // value will be 0 if nullableInt is null
```
5. **Conversion**:
- Nullable types can be implicitly converted from the underlying type.
- Explicitly converting a nullable type to its underlying type requires checking for null first.
```csharp
int? nullableInt = 5;
int nonNullableInt = (int)nullableInt; // explicit conversion
```
### Example Code
```csharp
using System;
class Program
{
static void Main()
{
// Declaration of a nullable int
int? nullableInt = null;
// Check if it has a value
if (nullableInt.HasValue)
{
Console.WriteLine($"Value: {nullableInt.Value}");
}
else
{
Console.WriteLine("No value");
}
// Assign a value
nullableInt = 10;
// Use the null-coalescing operator
int result = nullableInt ?? 0; // result will be 10
Console.WriteLine($"Result: {result}");
// Convert nullable to non-nullable
if (nullableInt.HasValue)
{
int nonNullableInt = nullableInt.Value;
Console.WriteLine($"Non-nullable int: {nonNullableInt}");
}
}
}
```
### Usage Scenarios
1. **Database Operations**: When retrieving data from a database, columns may contain null values.
2. **Optional Parameters**: When a method parameter is optional and can have no value.
3. **Data Validation**: Representing optional fields in data input forms.
Using nullable types ensures that your code can handle cases where a value might not be available, making it more robust and preventing potential runtime errors related to null values.