Im letzten Teil (siehe: Ein eigener Datentyp (Teil 4)) haben wir die „Parsing“-Methoden implementiert. In diesem Teil wird es um die Methoden zur Konvertierung aus Standardtypen gehen. Unter Standardtypen verstehen sich folgende: byte, sbyte,  short, ushort, int, uint, long, ulong, float, double, decimal sowie string (welchen wir theoretisch bereits im letzten Teil implementiert haben). Beginnen wir also mit den beiden Byte-Typen.

public static Int24 ConvertFromByte(byte value)
{
    return new Int24(value);
}

public static Int24 ConvertFromSByte(sbyte value)
{
    return new Int24(value);
}

Nicht weiter kompliziert. Da ein Byte niemals außerhalb der Reichweite unseres Typen sein kann, benötigen wir keine weiteren Aktionen. Dies wird bei späteren Typen anders aussehen und auch beim UInt24 würde dies unter Umständen wegen den vorzeichenbehafteten Typen anders aussehen.

Weiter geht es mit der Einbindung der beiden Short-Typen. Auch diese sind nicht weiter komplex als die Byte-Typen, da auch diese einen geringeren Wertebereich haben als unser 24-Bit Integer Typ.

public static Int24 ConvertFromShort(short value)
{
    return new Int24(value);
}

public static Int24 ConvertFromUShort(ushort value)
{
    return new Int24(value);
}

Nun geht es jedoch weiter mit 32-Bit Integers und diese sind unter Umständen größer als unser Typ. Aber ich denke mal, dass die meisten jetzt eh schon wissen was passieren wird. Deshalb würde ich auch dies als komplett selbsterklärend ansehen:

public static Int24 ConvertFromInt(int value)
{
    if (value > IntMaxValue || value < IntMinValue)
        throw new OverflowException("Value was either too large or too small for an Int24.");

    return new Int24(value);
}

public static Int24 ConvertFromUInt(uint value)
{
    if (value > IntMaxValue)
        throw new OverflowException("Value was either too large or too small for an Int24.");

    return new Int24(Convert.ToInt32(value));
}

Weiter geht es mit den 64-Bit Integers und diese funktionieren im Endeffekt genauso wie bereits der 32-Bit Integer zuvor. Nur das diesmal bei beiden ein Konvert zum Int32 genutzt werden muss, da beide Typen laut .NET außerhalb der Reichweite liegen können (das .NET-Framework weiß ja nicht, dass wir dies zuvor Filtern).

public static Int24 ConvertFromLong(long value)
{
    if (value > IntMaxValue || value < IntMinValue)
        throw new OverflowException("Value was either too large or too small for an Int24.");

    return new Int24(Convert.ToInt32(value));
}

public static Int24 ConvertFromULong(ulong value)
{
    if (value > IntMaxValue)
        throw new OverflowException("Value was either too large or too small for an Int24.");

    return new Int24(Convert.ToInt32(value));
}

Nun sind jedoch alle Ganzzahlen-Typen durch und es geht weiter mit Gleitkommazahlen. Nur wie Funktioniert dies hier? Im Prinzip ändert sich für uns rein gar nichts, denn die statische „Convert“-Klasse bietet uns hierfür alles benötigte an. Und dadurch sieht es genauso aus wie beim 64-Bit Integer Datentyp.

public static Int24 ConvertFromFloat(float value)
{
    if (value > IntMaxValue || value < IntMinValue)
        throw new OverflowException("Value was either too large or too small for an Int24.");

    return new Int24(Convert.ToInt32(value));
}

public static Int24 ConvertFromDouble(double value)
{
    if (value > IntMaxValue || value < IntMinValue)
        throw new OverflowException("Value was either too large or too small for an Int24.");

    return new Int24(Convert.ToInt32(value));
}

public static Int24 ConvertFromDecimal(decimal value)
{
    if (value > IntMaxValue || value < IntMinValue)
        throw new OverflowException("Value was either too large or too small for an Int24.");

    return new Int24(Convert.ToInt32(value));
}

Da neben Float auch der Double und der Decimal exakt gleich aussehen, habe ich alle Methoden gerade abgedruckt (außerdem ist es eh das gleiche wie bei allen zuvor). Die letzte Methode ist die des String-Datentypes und diese nutzt lediglich unsere Parse-Methode für die Konvertierung.

public static Int24 ConvertFromString(string value)
{
    return Parse(value);
}

Im nächsten Teil geht es weiter mit der Implementierung der überschriebenen Methoden, bevor wir zu den Interface-Implementierungen kommen.