Skip to main content

2.3 - Type Casting

In C#, a strongly-typed language, type casting is the process of converting a variable from one data type to another. Understanding type conversion is essential for writing robust and efficient code, as it helps prevent data loss, runtime errors, and unexpected behavior.

🔰 Beginner's Corner: What is Type Casting?​

Think of type casting like converting between different units of measurement:

  • When you convert 1 foot to 12 inches, you're getting the same length in a different unit
  • When you convert 3.8 liters to 4 liters (rounding up), you're losing some precision
  • When you try to convert 100 degrees Celsius to miles, it doesn't make sense!

In programming, type casting works similarly:

// Converting a smaller container (int) to a larger one (double)
// This is like converting feet to inches - no data is lost
int myInt = 5;
double myDouble = myInt;  // Implicit casting: 5 becomes 5.0

// Converting a larger container (double) to a smaller one (int)
// This is like rounding liters - some precision may be lost
double myPreciseValue = 5.8;
int myRoundedValue = (int)myPreciseValue;  // Explicit casting: 5.8 becomes 5

// Some conversions don't make sense without special handling
// string myText = "Hello";
// int impossibleConversion = (int)myText;  // This would cause an error!

💡 Concept Breakdown: Why We Need Type Casting​

Type casting is necessary because:

  1. Different operations require specific types - For example, you can't directly add a number to a text string
  2. Data comes in different forms - User input is often text that needs to be converted to numbers
  3. Systems have different requirements - Some APIs might need integers while others need decimals
  4. Memory and performance optimization - Smaller types use less memory

2.3.1 - Understanding Type Conversion​

2.3.1.1 - Why Type Conversion Matters​

Type conversion is necessary in many programming scenarios:

  1. Data Processing: Converting user input (often strings) to appropriate data types
  2. Arithmetic Operations: Ensuring operands are of compatible types
  3. API Integration: Converting between types required by different APIs or libraries
  4. Data Storage: Converting between in-memory representations and storage formats
  5. Polymorphism: Converting between base and derived types in object-oriented programming

2.3.1.2 - Type Conversion Categories​

C# provides several mechanisms for type conversion, which can be categorized as:

CategoryDescriptionSafetyPerformanceExample
Implicit ConversionAutomatic conversion with no data lossSafeFastint to long
Explicit ConversionManual conversion with potential data lossPotentially unsafeFastdouble to int
User-Defined ConversionCustom conversion defined by developersVariesVariesCustom type conversions
Conversion MethodsHelper methods for type conversionSafe with proper handlingModerateint.Parse(), Convert.ToInt32()
Boxing/UnboxingConverting between value types and reference typesSafe (boxing), Potentially unsafe (unboxing)Slowint to object and back

2.3.2 - Implicit Type Conversion​

Implicit type conversion (also called implicit casting or widening conversion) happens automatically when there is no risk of data loss. The compiler handles these conversions without requiring explicit syntax.

2.3.2.1 - Numeric Type Conversions​

The following implicit numeric conversions are supported in C#:

byte → short → int → long → decimal
      ↘       ↘     ↘     ↗
        float → double
// Implicit numeric conversions
byte smallNumber = 100;
int mediumNumber = smallNumber;    // byte to int
long largeNumber = mediumNumber;   // int to long
float floatNumber = mediumNumber;  // int to float
double doubleNumber = floatNumber; // float to double

Console.WriteLine($"byte: {smallNumber}");   // 100
Console.WriteLine($"int: {mediumNumber}");   // 100
Console.WriteLine($"long: {largeNumber}");   // 100
Console.WriteLine($"float: {floatNumber}");  // 100
Console.WriteLine($"double: {doubleNumber}"); // 100

2.3.2.2 - Character to Integer Conversion​

Characters can be implicitly converted to numeric types that can represent their Unicode value:

char letter = 'A';
int asciiValue = letter;  // Implicit conversion from char to int

Console.WriteLine($"Character: {letter}");      // A
Console.WriteLine($"ASCII/Unicode value: {asciiValue}"); // 65

2.3.2.3 - Reference Type Conversions​

Implicit conversions can occur between compatible reference types:

// Derived class to base class
class Animal { }
class Dog : Animal { }

Dog myDog = new Dog();
Animal myAnimal = myDog;  // Implicit conversion from Dog to Animal

// Array covariance
Dog[] dogs = new Dog[3];
Animal[] animals = dogs;  // Implicit conversion from Dog[] to Animal[]

// Interface implementation
interface IMovable { }
class Car : IMovable { }

Car myCar = new Car();
IMovable movable = myCar;  // Implicit conversion from Car to IMovable

2.3.2.4 - Nullable Type Conversions​

Non-nullable value types can be implicitly converted to their nullable equivalents:

int definiteNumber = 42;
int? nullableNumber = definiteNumber;  // Implicit conversion from int to int?

Console.WriteLine(nullableNumber.HasValue); // True
Console.WriteLine(nullableNumber.Value);    // 42

2.3.3 - Explicit Type Conversion​

Explicit type conversion (also called explicit casting or narrowing conversion) requires manual intervention using the cast operator (). This is necessary when there's a risk of data loss or when converting between types that aren't implicitly compatible.

🔰 Beginner's Corner: Understanding Explicit Casting​

Think of explicit casting like forcing a square peg into a round hole - you need to tell the compiler "I know what I'm doing":

IMPLICIT CASTING (Automatic)       EXPLICIT CASTING (Manual)
┌───────┐     ┌───────────┐       ┌───────────┐     ┌───────┐
│ Small │ ──► │  Large    │       │  Large    │ ──► │ Small │
│ Type  │     │  Type     │       │  Type     │     │ Type  │
└───────┘     └───────────┘       └───────────┘     └───────┘
   int            double             double            int
    5              5.0                5.7              5
                                                  (data lost!)

When you do explicit casting:

  1. You use parentheses with the target type: (int), (byte), etc.
  2. You're telling C#: "I know this might lose data, but do it anyway"
  3. You take responsibility for any data loss or errors that might occur

⚠️ Common Pitfalls with Explicit Casting​

  1. Loss of precision: When converting from floating-point to integer, the decimal portion is truncated (not rounded)

    double price = 9.99;
    int wholeDollars = (int)price;  // Results in 9, not 10!

  2. Overflow: When the value is too large for the target type

    int largeNumber = 1000;
    byte smallByte = (byte)largeNumber;  // Results in 232 (not 1000!)

  3. Invalid casts: Not all types can be cast to others

    // This would cause a runtime error:
    // object obj = "Hello";
    // int number = (int)obj;  // Cannot cast string to int!

2.3.3.1 - Numeric Type Conversions​

When converting from a larger numeric type to a smaller one, or from floating-point to integer types, explicit casting is required:

// Explicit numeric conversions
double largeDouble = 1234.7;
int mediumInt = (int)largeDouble;     // Explicit cast: double to int (fractional part lost)
short smallShort = (short)mediumInt;  // Explicit cast: int to short (potential overflow)

Console.WriteLine($"Original double: {largeDouble}"); // 1234.7
Console.WriteLine($"Converted to int: {mediumInt}");  // 1234 (fractional part lost)
Console.WriteLine($"Converted to short: {smallShort}"); // 1234 (if within short range)

// Potential data loss example
long veryLargeNumber = 2147483648; // Larger than int.MaxValue
int overflowRisk = (int)veryLargeNumber; // Results in -2147483648 due to overflow

Console.WriteLine($"Original long: {veryLargeNumber}");  // 2147483648
Console.WriteLine($"After unsafe cast to int: {overflowRisk}"); // -2147483648

2.3.3.2 - Reference Type Conversions​

Explicit casting is required when converting from a base class to a derived class:

// Base class to derived class (requires explicit cast)
class Animal { }
class Dog : Animal { }

Animal myAnimal = new Dog();  // A Dog stored in an Animal reference
Dog myDog = (Dog)myAnimal;    // Explicit downcast - safe because myAnimal refers to a Dog

// Unsafe downcast example
Animal genericAnimal = new Animal();
try
{
    Dog impossibleDog = (Dog)genericAnimal; // Will throw InvalidCastException
}
catch (InvalidCastException ex)
{
    Console.WriteLine($"Cast failed: {ex.Message}");
    // "Unable to cast object of type 'Animal' to type 'Dog'."
}

2.3.3.3 - The as Operator​

The as operator provides a safer way to perform explicit reference type conversions:

// Using the 'as' operator for safer casting
Animal someAnimal = new Dog();
Dog safeDog = someAnimal as Dog;  // Returns null if cast is not possible

if (safeDog != null)
{
    Console.WriteLine("Successfully cast to Dog");
}
else
{
    Console.WriteLine("Cast failed, safeDog is null");
}

// Comparing with direct casting
Animal justAnAnimal = new Animal();
Dog nullDog = justAnAnimal as Dog;  // Returns null
Console.WriteLine(nullDog == null); // True

try
{
    Dog throwingDog = (Dog)justAnAnimal; // Throws InvalidCastException
}
catch (InvalidCastException)
{
    Console.WriteLine("Direct cast failed with exception");
}

2.3.3.4 - The is Operator and Pattern Matching​

The is operator checks if an object is compatible with a given type, and pattern matching extends this with direct conversion:

// Using 'is' operator to check type compatibility
Animal pet = new Dog();

if (pet is Dog)
{
    Console.WriteLine("This animal is a dog");
    
    // Traditional approach
    Dog dogPet = (Dog)pet;
    
    // Pattern matching (C# 7.0+)
    if (pet is Dog matchedDog)
    {
        // matchedDog is already cast to Dog type
        Console.WriteLine("Pattern matching succeeded");
    }
}

// Pattern matching with switch (C# 8.0+)
object shape = new Circle { Radius = 5 };

switch (shape)
{
    case Circle c:
        Console.WriteLine($"Circle with radius {c.Radius}");
        break;
    case Rectangle r:
        Console.WriteLine($"Rectangle with width {r.Width} and height {r.Height}");
        break;
    default:
        Console.WriteLine("Unknown shape");
        break;
}

2.3.3.5 - Checked and Unchecked Contexts​

C# provides checked and unchecked keywords to control overflow checking during explicit numeric conversions:

int largeValue = int.MaxValue;
int result;

// Unchecked context (default) - overflow silently occurs
unchecked
{
    result = largeValue + 1;  // Overflows to int.MinValue
    Console.WriteLine(result); // -2147483648
}

// Checked context - throws OverflowException
try
{
    checked
    {
        result = largeValue + 1;  // Will throw OverflowException
    }
}
catch (OverflowException ex)
{
    Console.WriteLine($"Overflow detected: {ex.Message}");
}

// Checked conversion
try
{
    checked
    {
        int overflowTest = (int)2147483648L; // Will throw OverflowException
    }
}
catch (OverflowException ex)
{
    Console.WriteLine($"Conversion overflow: {ex.Message}");
}

2.3.4 - Conversion Methods​

C# provides several built-in methods for converting between types, especially when dealing with strings and other non-directly compatible types.

2.3.4.1 - Parse Methods​

Each numeric type in C# has a Parse method that converts a string representation to that type:

// Basic parsing examples
string intString = "42";
int parsedInt = int.Parse(intString);

string doubleString = "3.14159";
double parsedDouble = double.Parse(doubleString);

string boolString = "true";
bool parsedBool = bool.Parse(boolString);

// Culture-specific parsing
using System.Globalization;

string currencyString = "€1,234.56";
decimal amount = decimal.Parse(
    currencyString,
    NumberStyles.Currency,
    new CultureInfo("fr-FR")
);

// Date parsing
string dateString = "2023-06-15";
DateTime date = DateTime.Parse(dateString);
caution

Parse methods throw exceptions when the conversion fails. Always validate input or use TryParse methods for user input.

2.3.4.2 - TryParse Methods​

TryParse methods provide a safer alternative to Parse by returning a boolean indicating success rather than throwing exceptions:

// Basic TryParse example
string userInput = "123";
if (int.TryParse(userInput, out int result))
{
    Console.WriteLine($"Successfully parsed: {result}");
}
else
{
    Console.WriteLine("Failed to parse input as integer");
}

// Handling potentially invalid input
string[] inputs = { "42", "3.14159", "not a number", "" };

foreach (string input in inputs)
{
    if (double.TryParse(input, out double number))
    {
        Console.WriteLine($"'{input}' → {number}");
    }
    else
    {
        Console.WriteLine($"'{input}' could not be parsed as a double");
    }
}

// Output:
// '42' → 42
// '3.14159' → 3.14159
// 'not a number' could not be parsed as a double
// '' could not be parsed as a double

2.3.4.3 - The Convert Class​

The System.Convert class provides a comprehensive set of methods for converting between various types:

// String to numeric conversions
string numericString = "123";
int intValue = Convert.ToInt32(numericString);
double doubleValue = Convert.ToDouble(numericString);
decimal decimalValue = Convert.ToDecimal(numericString);

// Boolean conversions
bool boolFromString = Convert.ToBoolean("True");  // True
bool boolFromInt = Convert.ToBoolean(1);          // True
bool boolFromZero = Convert.ToBoolean(0);         // False

// DateTime conversions
DateTime dateFromString = Convert.ToDateTime("2023-12-31");

// Base conversions
string binaryString = "1010";
int fromBinary = Convert.ToInt32(binaryString, 2);  // 10
string hexString = "1A";
int fromHex = Convert.ToInt32(hexString, 16);       // 26

// Handling null values
string nullString = null;
int defaultInt = Convert.ToInt32(nullString);  // Returns 0 instead of throwing

Key Differences Between Parse and Convert​

FeatureParse MethodsConvert Class
Null HandlingThrows ArgumentNullExceptionReturns default value (0, false, etc.)
Available TypesLimited to the specific typeConverts between many different types
Culture SupportSupports culture via overloadsLimited culture support
PerformanceGenerally fasterSlightly slower due to additional checks

2.3.4.4 - ToString Method​

Every object in C# inherits the ToString() method, which converts the object to its string representation:

// Basic ToString examples
int number = 42;
string numberString = number.ToString();  // "42"

double pi = 3.14159;
string piString = pi.ToString();  // "3.14159"

// Formatting with ToString
decimal price = 1234.56m;
string formattedPrice = price.ToString("C");  // "$1,234.56" (culture-dependent)

DateTime now = DateTime.Now;
string dateString = now.ToString("yyyy-MM-dd");  // "2023-06-15" (format-specific)

// Custom object ToString override
public class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    
    public override string ToString()
    {
        return $"{FirstName} {LastName}";
    }
}

var person = new Person { FirstName = "John", LastName = "Doe" };
Console.WriteLine(person.ToString());  // "John Doe"

2.3.4.5 - Custom Type Converters​

For more complex conversion scenarios, C# allows creating custom type converters:

using System;
using System.ComponentModel;
using System.Globalization;

// Custom type converter for a Point class
public class Point
{
    public int X { get; set; }
    public int Y { get; set; }
    
    public override string ToString()
    {
        return $"({X},{Y})";
    }
}

[TypeConverter(typeof(PointConverter))]
public class PointConverter : TypeConverter
{
    // Check if we can convert from the source type
    public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
    {
        if (sourceType == typeof(string))
        {
            return true;
        }
        return base.CanConvertFrom(context, sourceType);
    }
    
    // Convert from the source type
    public override object ConvertFrom(ITypeDescriptorContext context, 
                                      CultureInfo culture, object value)
    {
        if (value is string stringValue)
        {
            string[] parts = stringValue.Trim('(', ')').Split(',');
            if (parts.Length == 2 && 
                int.TryParse(parts[0], out int x) && 
                int.TryParse(parts[1], out int y))
            {
                return new Point { X = x, Y = y };
            }
        }
        return base.ConvertFrom(context, culture, value);
    }
    
    // Check if we can convert to the destination type
    public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
    {
        if (destinationType == typeof(string))
        {
            return true;
        }
        return base.CanConvertTo(context, destinationType);
    }
    
    // Convert to the destination type
    public override object ConvertTo(ITypeDescriptorContext context, 
                                    CultureInfo culture, object value, Type destinationType)
    {
        if (destinationType == typeof(string) && value is Point point)
        {
            return $"({point.X},{point.Y})";
        }
        return base.ConvertTo(context, culture, value, destinationType);
    }
}

// Usage
TypeConverter converter = TypeDescriptor.GetConverter(typeof(Point));
Point point = (Point)converter.ConvertFrom("(10,20)");
string pointString = converter.ConvertTo(point, typeof(string)) as string;

2.3.6 - Type Conversion with Convert.ChangeType​

The Convert.ChangeType method in C# is a versatile function provided by the System.Convert class. It allows you to convert an object to a specified type, which is particularly useful when the target type is only known at runtime. This guide will cover how to use Convert.ChangeType, its syntax, practical examples, and the scenarios where it is most useful.

2.3.6.1 - Syntax​

The Convert.ChangeType method comes in the following form:

public static object ChangeType(object value, Type conversionType);

Additionally, there is an overload that accepts an IFormatProvider for culture-specific conversions:

public static object ChangeType(object value, Type conversionType, IFormatProvider provider);

2.3.6.2 - Parameters​

  • value: The object to convert. This must implement the IConvertible interface.
  • conversionType: The Type to which value is to be converted.
  • provider (optional): An IFormatProvider implementation that provides culture-specific formatting information.

2.3.6.3 - Return Value​

The method returns an object of the specified conversionType that represents the converted value.

2.3.6.4 - Examples​

Example 1 - Basic Example:

Here is a basic example of converting a string to an integer using Convert.ChangeType:

using System;

class Program
{
    static void Main()
    {
        object source = "123";
        Type targetType = typeof(int);

        object result = Convert.ChangeType(source, targetType);

        Console.WriteLine(result);             // Outputs: 123
        Console.WriteLine(result.GetType());   // Outputs: System.Int32
    }
}

In this example, the string "123" is converted to an integer.

Example 2 - Conversion with Culture Information:

Sometimes, the conversion needs to be culture-specific, especially for dates and numbers. Here's an example using IFormatProvider:

using System;
using System.Globalization;

class Program
{
    static void Main()
    {
        object source = "123.45";
        Type targetType = typeof(double);
        IFormatProvider provider = CultureInfo.InvariantCulture;

        object result = Convert.ChangeType(source, targetType, provider);

        Console.WriteLine(result);             // Outputs: 123.45
        Console.WriteLine(result.GetType());   // Outputs: System.Double
    }
}

In this case, the string "123.45" is correctly converted to a double using the invariant culture.

2.3.6.5 - Use Cases​

2.3.6.5.1 - Dynamic Type Conversion​

Convert.ChangeType is particularly useful when writing generic or reflection-based code where the type of the data may not be known until runtime. For example, in a deserialization routine that reads different types of data from a source:

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var data = new Dictionary<string, object>
        {
            { "Integer", "42" },
            { "Double", "3.14" },
            { "DateTime", "2023-06-28" }
        };

        foreach (var key in data.Keys)
        {
            Type targetType = key switch
            {
                "Integer" => typeof(int),
                "Double" => typeof(double),
                "DateTime" => typeof(DateTime),
                _ => typeof(string)
            };

            object result = Convert.ChangeType(data[key], targetType);
            Console.WriteLine($"{key}: {result} ({result.GetType()})");
        }
    }
}

In this example, the method converts various types stored as strings in a dictionary to their appropriate types based on the key.

2.3.6.5.2 - Enum Conversion​

Convert.ChangeType can also be used to convert between enums and their underlying integral types:

using System;

enum Days { Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday }

class Program
{
    static void Main()
    {
        Days day = Days.Friday;
        object dayNumber = Convert.ChangeType(day, Enum.GetUnderlyingType(typeof(Days)));

        Console.WriteLine(dayNumber);         // Outputs: 5
        Console.WriteLine(dayNumber.GetType());// Outputs: System.Int32
    }
}

Here, the enum Days.Friday is converted to its underlying integer value.

2.3.6.6 - Limitations and Considerations​

  • Unsupported Conversions: Convert.ChangeType does not support all possible conversions. For instance, you cannot convert a custom object directly to another custom object type unless they implement IConvertible.
  • Exception Handling: Always be prepared to handle exceptions such as InvalidCastException, FormatException, and OverflowException when the conversion fails.
  • Performance: While Convert.ChangeType is powerful, it is relatively slow compared to direct casting or using specific Convert methods (e.g., Convert.ToInt32), especially in performance-critical applications.

2.3.7 - Dynamic Type Conversion​

In C#, the dynamic type conversion mechanism revolves around the use of the dynamic keyword, introduced in C# 4.0. Utilizing dynamic allows bypassing the static type checking system of the compiler. During compilation, objects declared as dynamic are treated as capable of executing any operations; their true types are only verified at runtime. This postponement of type and operation checks to runtime provides great flexibility but also introduces potential risks and performance costs.

2.3.7.1 - Utilizing the Dynamic Keyword​

The dynamic keyword enables runtime type resolution, facilitating interaction with objects when their types are unknown at compile time.

Example:

dynamic myObject = 10;  // Initially an int
Console.WriteLine(myObject);

myObject = "Hello world!";  // Changes to a string
Console.WriteLine(myObject);

myObject = new List<int>();  // Finally becomes a List<int>
myObject.Add(1);
Console.WriteLine(myObject.Count);  // Outputs: 1

In this example, myObject is initially set as an integer. It is then changed to a string and finally to a List<int>, demonstrating the flexibility of dynamic types which can alter during program execution.

2.3.7.2 - Advantages and Considerations​

Advantages:

  • Flexibility: The dynamic type supports operations not known at compile time, making it useful for applications interacting with dynamic scripting languages or COM objects.
  • Simplification of COM Interoperability: It simplifies calling COM APIs where interfaces might not be known at compile time.

Considerations:

  • Performance Impact: Runtime type checking can lead to a performance decrease because operations are resolved at runtime.
  • Error Handling: Potential runtime exceptions due to errors that static typing would normally catch at compile time.

2.3.7.3 - Safely Converting Dynamic Types​

To safely convert dynamic types without introducing runtime errors, employ conversion methods like Convert.ToInt32 or utilize exception handling structures such as try-catch blocks.

Example:

dynamic value = "123";
int number;

try
{
    number = Convert.ToInt32(value);
    Console.WriteLine(number);  // Outputs the converted number
}
catch (FormatException e)
{
    Console.WriteLine("Conversion failed: " + e.Message);  // Handles conversion errors
}

In this code snippet, the dynamic variable value is converted to an integer safely, handling potential format exceptions gracefully.

2.3.7.4 - Common Type Conversion Methods in C#​

Below is a reference table that details common methods from the Convert class used for type conversions in C#. These methods are crucial for safely handling conversions between different types, especially when working with dynamic types where the data type is not known until runtime.

Method NameReturn TypeDescriptionExample Usage
ToInt32()intConverts a compatible type to a 32-bit integer.int result = Convert.ToInt32(value);
ToString()stringConverts a type to its string representation.string text = Convert.ToString(num);
ToBoolean()boolConverts a type to a boolean value.bool flag = Convert.ToBoolean(value);
ToDouble()doubleConverts a type to a double-precision floating-point number.double number = Convert.ToDouble(value);
ToDateTime()DateTimeConverts a type to a DateTime.DateTime date = Convert.ToDateTime(value);
ToChar()charConverts a type to a single Unicode character.char letter = Convert.ToChar(value);
ToByte()byteConverts a type to an 8-bit unsigned integer.byte b = Convert.ToByte(value);
ToDecimal()decimalConverts a type to a decimal number.decimal amount = Convert.ToDecimal(value);
ToSingle()floatConverts a type to a single-precision floating-point number.float f = Convert.ToSingle(value);
ToInt64()longConverts a type to a 64-bit integer.long bigNum = Convert.ToInt64(value);
ToInt16()shortConverts a type to a 16-bit integer.short smallNum = Convert.ToInt16(value);

These methods can throw exceptions if the conversion is not feasible, so using them within a try-catch block is advisable to handle any potential errors gracefully. This ensures robust and error-resistant code, especially when types are determined at runtime or when handling inputs from dynamic sources.

2.3.5 - Boxing and Unboxing​

Boxing and unboxing are special conversion operations in C# that bridge the gap between value types and reference types. Understanding these operations is crucial for writing efficient code and avoiding performance pitfalls.

2.3.5.1 - What is Boxing?​

Boxing is the process of converting a value type (such as int, double, or a struct) to a reference type (object or an interface implemented by the value type). When boxing occurs:

  1. Memory is allocated on the managed heap
  2. The value is copied into that memory
  3. A reference to the newly allocated memory is returned
// Boxing examples
int number = 42;
object boxedNumber = number;  // Boxing: int → object

double pi = 3.14159;
object boxedPi = pi;          // Boxing: double → object

// Boxing when passing to a method that takes object
void ProcessValue(object value) { /* ... */ }
ProcessValue(number);         // Boxing occurs here

// Boxing when adding to non-generic collections
ArrayList list = new ArrayList();
list.Add(number);             // Boxing occurs here

2.3.5.2 - What is Unboxing?​

Unboxing is the reverse process - extracting the value type from a boxed object. Unboxing requires an explicit cast and involves:

  1. Checking that the object instance is a boxed value of the given value type
  2. Copying the value from the instance to the value-type variable
// Unboxing examples
object boxedNumber = 42;
int unboxedNumber = (int)boxedNumber;  // Unboxing: object → int

// Unboxing with type checking
object unknownValue = "not a number";
try
{
    int impossibleUnbox = (int)unknownValue;  // Throws InvalidCastException
}
catch (InvalidCastException ex)
{
    Console.WriteLine($"Unboxing failed: {ex.Message}");
}

// Safe unboxing with pattern matching (C# 7.0+)
if (unknownValue is int numberValue)
{
    Console.WriteLine($"Successfully unboxed: {numberValue}");
}
else
{
    Console.WriteLine("Value is not an int");
}

2.3.5.3 - Performance Implications​

Boxing and unboxing operations have significant performance implications:

// Performance comparison
using System;
using System.Diagnostics;

class BoxingPerformance
{
    static void Main()
    {
        const int iterations = 10_000_000;
        Stopwatch sw = new Stopwatch();
        
        // Without boxing
        sw.Start();
        int sum1 = 0;
        for (int i = 0; i < iterations; i++)
        {
            sum1 += i;
        }
        sw.Stop();
        Console.WriteLine($"Without boxing: {sw.ElapsedMilliseconds}ms");
        
        // With boxing
        sw.Restart();
        int sum2 = 0;
        for (int i = 0; i < iterations; i++)
        {
            object boxed = i;      // Boxing
            sum2 += (int)boxed;    // Unboxing
        }
        sw.Stop();
        Console.WriteLine($"With boxing: {sw.ElapsedMilliseconds}ms");
        
        // Typical output:
        // Without boxing: 8ms
        // With boxing: 350ms
    }
}

2.3.5.4 - Common Boxing Scenarios​

Boxing can occur in many situations, sometimes unexpectedly:

// 1. Using non-generic collections
ArrayList nonGenericList = new ArrayList();
nonGenericList.Add(42);  // Boxing occurs

// 2. Using value types with interface methods
interface IDisplayable { void Display(); }
struct Point : IDisplayable
{
    public int X, Y;
    public void Display() => Console.WriteLine($"({X}, {Y})");
}

Point p = new Point { X = 10, Y = 20 };
IDisplayable d = p;  // Boxing occurs here

// 3. Using value types with params object[]
void LogValues(params object[] values) { /* ... */ }
LogValues(42, "text", true);  // 42 and true are boxed

// 4. String interpolation with value types
int x = 10;
string s = $"Value is {x}";  // x is boxed during interpolation

// 5. Using value types with non-generic delegates
Action action = () => Console.WriteLine(x);  // x is captured and boxed

2.3.5.5 - Avoiding Unnecessary Boxing​

Modern C# provides several ways to avoid boxing:

// 1. Use generic collections instead of non-generic ones
List<int> genericList = new List<int>();
genericList.Add(42);  // No boxing

// 2. Use generics for methods
void LogValues<T>(params T[] values) { /* ... */ }
LogValues(42, 43, 44);  // No boxing

// 3. Use Span<T> or ReadOnlySpan<T> for high-performance scenarios
ReadOnlySpan<int> numbers = stackalloc[] { 1, 2, 3, 4, 5 };
ProcessSpan(numbers);  // No boxing

void ProcessSpan(ReadOnlySpan<int> span) { /* ... */ }

// 4. Use struct implementations of interfaces with generics
void ProcessDisplayable<T>(T item) where T : IDisplayable
{
    item.Display();  // No boxing even if T is a struct
}

ProcessDisplayable(p);  // No boxing

// 5. Use value tuples instead of object arrays
(int, string, bool) tuple = (42, "text", true);  // No boxing

2.3.5.6 - Boxing and Equality​

Boxing can lead to unexpected behavior with equality comparisons:

// Value equality vs. reference equality
int a = 42;
int b = 42;
Console.WriteLine(a == b);  // True (value equality)

object boxedA = a;
object boxedB = b;
Console.WriteLine(boxedA == boxedB);  // True (value equality for boxed value types)

// But with custom structs:
struct CustomPoint { public int X, Y; }

CustomPoint p1 = new CustomPoint { X = 10, Y = 20 };
CustomPoint p2 = new CustomPoint { X = 10, Y = 20 };
Console.WriteLine(p1.Equals(p2));  // True (value equality)

object boxedP1 = p1;
object boxedP2 = p2;
Console.WriteLine(boxedP1 == boxedP2);  // False (reference equality)
Console.WriteLine(boxedP1.Equals(boxedP2));  // True (calls Equals method)

2.3.5.7 - Best Practices​

  1. Avoid boxing in performance-critical code:

    • Use generic collections and methods
    • Use appropriate value types and avoid unnecessary conversions to object

  2. Be aware of hidden boxing:

    • Interface implementations by structs
    • Non-generic collections and methods
    • String interpolation and formatting

  3. Use profiling tools to identify boxing in your application

  4. Consider the memory impact of boxing in high-frequency operations

  5. Override Equals and GetHashCode for custom structs that might be boxed

2.3.6 - Summary and Best Practices​

Type conversion is a fundamental aspect of C# programming that requires careful consideration to ensure correctness, safety, and performance. This section summarizes key concepts and provides best practices for effective type conversion.

2.3.6.1 - Type Conversion Decision Tree​

When deciding how to convert between types, consider the following decision tree:

  1. Is the conversion from a smaller type to a larger type with no data loss?

    • Use implicit conversion (no cast required)
    • Example: int to long, float to double

  2. Is the conversion from a larger type to a smaller type with potential data loss?

    • Use explicit conversion with cast operator ()
    • Consider using checked context for critical operations
    • Example: double to int, long to short

  3. Is the conversion between reference types in an inheritance hierarchy?

    • Derived to base: Use implicit conversion
    • Base to derived: Use explicit cast or as operator with null check
    • Use pattern matching (is operator) for safer conversions
    • Example: Dog to Animal, Animal to Dog

  4. Is the conversion between unrelated types or to/from string?

    • Use conversion methods: Parse, TryParse, or Convert class
    • For user input, prefer TryParse to handle invalid input gracefully
    • Example: string to int, DateTime to string

  5. Is the conversion between a value type and object?

    • Be aware of boxing/unboxing performance implications
    • Use generics where possible to avoid boxing
    • Example: int to object, object to int

  6. Do you need custom conversion logic?

    • Implement implicit/explicit operators for your custom types
    • Create a TypeConverter for more complex scenarios
    • Example: Custom string format to your type

2.3.6.2 - Best Practices for Type Conversion​

  1. Prioritize Type Safety

    • Use the most type-safe conversion method available
    • Validate input before conversion when possible
    • Handle potential exceptions or use TryParse methods

  2. Consider Performance

    • Avoid unnecessary conversions, especially in loops or high-frequency code
    • Be aware of hidden boxing operations
    • Use appropriate collection types (generic vs. non-generic)

  3. Ensure Correctness

    • Be aware of potential data loss during narrowing conversions
    • Use checked contexts when overflow is a concern
    • Test edge cases (min/max values, null values, etc.)

  4. Write Clear, Intention-Revealing Code

    • Use explicit casts to make narrowing conversions obvious
    • Document assumptions about conversion safety
    • Use descriptive variable names that indicate type

  5. Handle Errors Gracefully

    • Use TryParse methods for user input
    • Implement appropriate exception handling
    • Provide meaningful error messages

2.3.6.3 - Common Pitfalls to Avoid​

  1. Ignoring Conversion Failures

    • Always check the result of TryParse operations
    • Handle or document potential exceptions

  2. Assuming Precision

    • Be aware that floating-point to integer conversions truncate (don't round)
    • Understand that some decimal values can't be precisely represented as binary floating-point

  3. Neglecting Culture Considerations

    • Remember that string parsing can be culture-dependent
    • Specify culture explicitly for consistent results

  4. Excessive Boxing/Unboxing

    • Avoid using value types with non-generic collections
    • Be cautious with interface implementations on structs

  5. Unsafe Downcasting

    • Always verify type compatibility before downcasting
    • Use pattern matching or the as operator with null checks

By understanding these principles and following these best practices, you can write C# code that handles type conversions safely, efficiently, and correctly.