Stay up to date on the latest in Coding for AI and Data Science. Join the AI Architects Newsletter today!

Type Conversion in C#

In C#, type conversion is the process of converting one data type into another. This is often necessary when working with different data types or when passing data between methods or classes. In this article, we’ll explore the different ways to perform type conversion in C#.

Automatic Type Conversion

C# provides automatic type conversion for certain types, such as integers and floating-point numbers. For example, you can assign an integer value to a variable of type float without any issues:

int x = 5;
float y = x;

In this example, the integer value 5 is automatically converted to the floating-point type float and assigned to the variable y.

Implicit Conversion

Implicit conversion is a type conversion that occurs without explicit casting. C# provides implicit conversions for several types, such as:

From int to long
From short to int
From byte to int
From sbyte to int
From float to double
From bool to string

Here’s an example of implicit conversion:

long x = (int)5; // x is implicitly converted from int to long

In this example, the integer value 5 is automatically converted to the long type without any explicit casting.

Explicit Conversion

Explicit conversion is a type conversion that requires explicit casting. C# provides explicit conversions for several types, such as:

From object to any other type
From string to any other type
From Enum to its underlying type (e.g., from Color to int)

Here’s an example of explicit conversion:

object x = "hello"; // x is explicitly converted from string to object

In this example, the string value "hello" is explicitly converted to the object type.

User-Defined Conversion

You can also define your own conversion operators in C#. These operators allow you to perform custom type conversions that are not provided by the language. Here’s an example of a user-defined conversion operator:

public class Complex : IComparable<Complex>
{
    public int Real { get; set; }
    public int Imaginary { get; set; }

    public static implicit operator Complex(int real)
    {
        return new Complex { Real = real, Imaginary = 0 };
    }

    public static implicit operator int(Complex c)
    {
        return c.Real;
    }
}

In this example, we define a Complex class with two properties: Real and Imaginary. We also define two conversion operators: one that converts an integer to a Complex object, and another that converts a Complex object to an integer.

With these conversion operators, you can perform custom type conversions like this:

int real = 5;
Complex complex = real; // real is implicitly converted to Complex

In this example, the integer value 5 is automatically converted to a Complex object.