C# IConvertible Interface

In this post, we are going to implement the IConvertible interface in C#. We will also see how our type can convert itself to different common language runtime types.

Introduction

Did you know that an interface binds your class to implement the defined functionalities declared within it? I have to mention this because we are going to explore how to play with IConvertible interface. In this post, we will try to implement the IConvertible using a simple example. Let’s get started.

What is IConvertible Interface?

The IConvertible interface basically provides methods that developers can use for the conversion of different types. Once you have decided to implement this interface, you must choose the field/fields within your type to support the conversion.

The conversion takes place when you have decided to invoke the implemented methods of this interface. In addition, the behavior of this conversion converts the value(s) of the implemented type to a common language runtime type.

The common language runtime types are the following: Boolean, SByte, Byte, Int16, UInt16, UInt32, Int64, UInt64, Single, Double, Decimal, DateTime, Char, and String.

Enough with the definitions, let's have an example.

1. Start by creating a type. 

public partial class Car {

public string Brand { get; set; }

public string Variant { get; set; }

public bool BestSeller { get; set; }

public DateTime DateBuilt { get; set; }

public double SurfaceArea { get; set; }

public double Length { get; set; }

public double Width { get; set; }

public double Height { get; set; }

}

As you can see, the Car type class is using a partial class keyword. One reason, for the separation of implementation of the IConvertible interface and definition of properties. 

 

2. Implement the IConvertible interface. 

public partial class Car : IConvertible {

public TypeCode GetTypeCode () {
    return TypeCode.Object;
}

public bool ToBoolean (IFormatProvider provider) {
    return this.BestSeller;
}

public byte ToByte (IFormatProvider provider) {
    return (byte)this.SurfaceArea;
}

public char ToChar (IFormatProvider provider) {

    return this.Brand[0];
}

public DateTime ToDateTime (IFormatProvider provider) {
    return this.DateBuilt;
}

public decimal ToDecimal (IFormatProvider provider) {
    return (decimal) this.SurfaceArea;
}

public double ToDouble (IFormatProvider provider) {
    return this.SurfaceArea;
}

public short ToInt16 (IFormatProvider provider) {
    return (short) this.SurfaceArea;
}

public int ToInt32 (IFormatProvider provider) {
    return (int) this.SurfaceArea;
}

public long ToInt64 (IFormatProvider provider) {
    return (long) this.SurfaceArea;
}

public sbyte ToSByte (IFormatProvider provider) {
    return Convert.ToSByte (this.SurfaceArea);
}

public float ToSingle (IFormatProvider provider) {
    return (float) this.SurfaceArea;
}

public string ToString (IFormatProvider provider) {
    return $"Brand: {this.Brand} Variant: {this.Variant}";
}

public object ToType (Type conversionType, IFormatProvider provider) {
    return Convert.ChangeType (this.SurfaceArea, conversionType);
}

public ushort ToUInt16 (IFormatProvider provider) {
    return (ushort) this.SurfaceArea;
}

public uint ToUInt32 (IFormatProvider provider) {
    return (uint) this.SurfaceArea;
}

public ulong ToUInt64 (IFormatProvider provider) {
    return (ulong) this.SurfaceArea;
}

}

Probably you have noticed that we didn't handle the overflow-exception for some of the type conversion and just made a narrowed conversion. For instance, see the code sample below. 

public byte ToByte (IFormatProvider provider) {
    return (byte)this.SurfaceArea;
}

 If you are thinking of ways to handle this, please see the sample codes below.

public byte ToByte(IFormatProvider provider)
{
    byte result = 0;

    if (this.SurfaceArea >= byte.MaxValue)
    {
        result = byte.MaxValue;
    }
    else
    {
        result = (byte)this.SurfaceArea;
    }

    return result;
}

public byte ToByte(IFormatProvider provider)
{
    try
    {
        return Convert.ToByte(this.SurfaceArea);
    }
    catch (OverflowException)
    {
        return byte.MaxValue;
    }
}

As long as the value is within the range of byte, the above example will definitely give the expected value. However, once the value goes beyond the value, data loss is expected. In addition, we can only give the maximum value of the type. In our case, the maximum range value of a byte is 255.  

 

 3. Create a new instance of Car class and call the Convert class to examine the result of the Car class type. 

[TestMethod]
public void TestMethod1()
{
var car = new Car { };

car.Brand = "Toyota";
car.Variant = "Vios G";
car.BestSeller = true;
car.DateBuilt = DateTime.Now;
car.Height = 110;
car.Length = 52;
car.Width = 24;
car.SurfaceArea =
    (((car.Length * car.Height) * 2) +
    ((car.Width * car.Height) *  2) +
    ((car.Length * car.Width) * 2));

bool carBool = Convert.ToBoolean(car);

Assert.IsInstanceOfType(carBool, typeof(bool));

Assert.IsTrue(carBool);

DateTime carDateTime = Convert.ToDateTime(car);

Console.WriteLine($"{carDateTime.ToShortDateString()}");

Assert.IsInstanceOfType(carDateTime, typeof(DateTime));

string carString = Convert.ToString(car);

Assert.IsInstanceOfType(carString, typeof(string));

Console.WriteLine($"{carString}");

double carDouble = Convert.ToDouble(car);

Assert.IsInstanceOfType(carDouble, typeof(double));

}

Now, it is possible for the Car type class to be converted into different types. However; the type conversion will still depend on your own implementation.

 

I hope you have enjoyed this example on how to use the IConvertible interface. Until next time, happy programming.