C# Interview Questions

In C#, nullable types allow you to assign null to value types, which are typically non-nullable. This is particularly useful for scenarios where you must represent a value's absence, such as database operations, optional values, or error handling.

Key Concepts

1. Value Types and Reference Types:

   • By default, value types (e.g., int, double, bool) cannot be assigned null because they represent actual values.
   • Reference types (e.g., string, object) can be assigned null because they represent references to objects.

2. Nullable Value Types:

   • Nullable types are instances of the System.Nullable<T> struct.
   • You can declare a nullable value type using the ? suffix.

Syntax

Declaring Nullable Types

Using the ? suffix:

int? nullableInt = null;
bool? nullableBool = null;

Using Nullable<T>:

Nullable<int> nullableInt = null;
Nullable<bool> nullableBool = null;

Both declarations are equivalent, but the ? syntax is more concise and commonly used.

Example Usage

Assigning and Checking Nullable Types

public class Program
{
    public static void Main()
    {
        int? nullableInt = null;

        if (nullableInt.HasValue)
        {
            Console.WriteLine($"Value: {nullableInt.Value}");
        }
        else
        {
            Console.WriteLine("Value is null");
        }

        nullableInt = 10;

        Console.WriteLine($"Value: {nullableInt ?? -1}"); // Using null-coalescing operator
    }
}

In this example:

• nullableInt.HasValue checks if the nullable type has a value.
• nullableInt.Value retrieves the value if it exists.
• The null-coalescing operator (??) provides a default value if the nullable type is null.

Null-Coalescing Operator (??)

The null-coalescing operator provides a default value when the nullable type is null.

Example:

int? nullableInt = null;
int value = nullableInt ?? -1; // If nullableInt is null, value will be -1

Null-Conditional Operator (?.)

The null-conditional operator is used to safely access members of an object that might be null.

Example:

int? length = nullableString?.Length; // If nullableString is null, length will be null

Combining Nullable Types

Nullable types can be used in expressions and operations, with certain considerations.

Example:

int? a = 10;
int? b = null;
int? sum = a + b; // sum will be null because b is null

Boxing and Unboxing Nullable Types

When a nullable type is boxed, the CLR boxes the underlying value, not the Nullable<T> object itself. If the nullable type is null, the reference is set to null.

Example:

int? nullableInt = 10;
object boxed = nullableInt; // Boxes the underlying value (10)
nullableInt = (int?)boxed; // Unboxes the value back to nullableInt

Default Value for Nullable Types

The default value for a nullable type is null.

Example:

int? defaultValue = default(int?); // defaultValue will be null

Benefits of Nullable Types

1. Represents Absence of Value:

   • Nullable types are useful for scenarios where a value might be absent or unknown, such as database fields that can be null.

2. Type Safety:

   • Provides compile-time type checking, ensuring that null values are handled explicitly.

3. Improved Code Readability:

   • Nullable types and operators (e.g., ??, ?.) improve code readability and reduce the need for explicit null checks.

Summary

Nullable types in C# allow value types to represent null values, providing a flexible and type-safe way to handle scenarios where a value might be absent. By using nullable types, you can improve the robustness and readability of your code, especially when dealing with optional values, database operations, and error handling. The ? suffix and Nullable<T> struct, along with operators like ?? and ?., offer powerful tools for working with nullable types effectively.