Im letzten Teil (siehe: Ein eigener Datentyp (Teil 3)) haben wir die letzten Operatoren implementiert. In diesem Part geht es um die „Parsing“-Methoden. Diese Methoden sollen dazu dienen das Parsing von Strings zu ermöglichen. Hierfür gibt es an den Standarddatentypen die Statischen-Methoden „TryParse“ sowie „Parse“. Auch wir wollen nun diese Methoden implementieren und zur Verfügung stellen. Hierbei ist „TryParse“ quasi Exception sicher (hier werden die Exceptions gecatcht und anschließend ein false zurück gegeben). Beginnen wir mit den beiden Varianten der „TryParse“-Methode. Diese könnten wie folgt aussehen:

public static bool TryParse(string s, out Int24 result)
{
    return TryParse(s, NumberStyles.Integer, null, out result);
}

public static bool TryParse(string s, NumberStyles style, IFormatProvider formatProvider, out Int24 result)
{
    int output;
    bool canParse = Int32.TryParse(s, style, formatProvider, out output);

    if (!canParse || output > IntMaxValue || output < IntMinValue)
    {
        result = new Int24();
        return false;
    }

    result = new Int24(output);
    return true;
}

Während die kurze Fassung dieser Methode lediglich unsere längere aufruft, nutzt die ausführlich implementierte Fassung nur die „TryParse“-Methode des 32-Bit Integers. Zusätzlich werden hier allerdings noch unsere begrenzten Max- und Minwerte geprüft.  

Von der „Parse“-Methode gibt es insgesamt vier Fassungen, die alle relativ ähnlich gestaltet sind. Hier erfolgt ein ähnliches Vorgehen nur, da die „Parse“-Methode auch Exceptions schmeißen darf, wird hier im Außer-Reichweite-Fall dies getan.

public static Int24 Parse(string s)
{
    int result = Int32.Parse(s);

    if (result > IntMaxValue || result < IntMinValue)
        throw new OverflowException("Value was either too large or too small for an Int24.");

    return result;
}

public static Int24 Parse(string s, IFormatProvider formatProvider)
{
    int result = Int32.Parse(s, formatProvider);

    if (result > IntMaxValue || result < IntMinValue)
        throw new OverflowException("Value was either too large or too small for an Int24.");

    return result;
}

public static Int24 Parse(string s, NumberStyles numberStyles)
{
    int result = Int32.Parse(s, numberStyles);

    if (result > IntMaxValue || result < IntMinValue)
        throw new OverflowException("Value was either too large or too small for an Int24.");

    return result;
}

public static Int24 Parse(string s, NumberStyles numberStyles, IFormatProvider formatProvider)
{
    int result = Int32.Parse(s, numberStyles, formatProvider);

    if (result > IntMaxValue || result < IntMinValue)
        throw new OverflowException("Value was either too large or too small for an Int24.");

    return result;
}

Im nächsten Teil geht es mit dem Konvertieren von Standardtypen weiter. Mir ist durchaus bewusst, dass hier sehr viel auf 32-Bit Interger Aktionen zurück gegriffen wird, aber es soll ja auch nur eine Erklärung zum eigenen Datentypen sein und solche müssen an möglichst simplen Beispielen erfolgen.