## What happens when we Box or Unbox Nullable types?

When a nullable value type is boxed or unboxed in C#, the following behaviors occur:

- Boxing Nullable Types:
- Boxing is the process of converting a value type to an object reference type (boxed representation) to store it on the heap.
- When a nullable value type is boxed, the underlying value (if it exists) is boxed along with an additional flag that indicates whether the value is null or not.
- If the nullable value type has a value, it is boxed as usual, and the resulting boxed object contains both the value and the null flag.
- If the nullable value type is null (HasValue is false), the resulting boxed object is a null reference.

- Unboxing Nullable Types:
- Unboxing is the process of converting an object reference type (boxed representation) back to its original value type.
- When unboxing a boxed nullable value type, the null flag is checked first.
- If the null flag indicates that the value is null, an
`InvalidOperationException`

is thrown because an unboxing operation cannot be performed on a null reference. - If the null flag indicates that the value is not null, the underlying value is unboxed and returned as a nullable value type with the appropriate value and nullability.

Here’s an example to illustrate the boxing and unboxing of nullable types:

```
int? nullableValue = 42;
// Boxing nullable value type
object boxed = nullableValue; // Boxing occurs here
// Unboxing nullable value type
int? unboxed = (int?)boxed; // Unboxing occurs here
// Unboxing nullable value type from null
object boxedNull = null;
int? unboxedNull = (int?)boxedNull; // Throws InvalidOperationException
```

In the example above, the nullable value type `nullableValue`

is boxed by assigning it to an `object`

variable (`boxed`

). The resulting `boxed`

object contains the value 42 along with the null flag.

Later, the `boxed`

object is unboxed by explicitly casting it to a nullable value type (`int?`

). The unboxing operation retrieves the underlying value and assigns it to the `unboxed`

variable.

In the last part, an attempt to unbox a null reference (`boxedNull`

) into a nullable value type throws an `InvalidOperationException`

because unboxing operations cannot be performed on a null reference.

It’s important to note that boxing and unboxing operations can have performance implications and should be used judiciously. In general, it’s recommended to avoid unnecessary boxing and unboxing operations, especially in performance-critical code, by using nullable value types directly or leveraging nullable-aware APIs where possible.