Im letzten Teil (siehe: Ein eigener Datentyp (Teil 2)) haben wir uns um die Implementierung der Grund-Operatoren gekümmert. In diesem Teil wollen wir uns den Vergleichs- sowie Bitoperatoren wenden, welche ebenfalls eine entschiedene Bedeutung für Datentypen haben. Hierfür müssen wir uns jedoch zunächst darüber im Klaren sein, dass wir letztendlich nur eine Einschränkung eines Int32-Datentypes erstellen und deshalb erneut, wie auch bei den Teilen zuvor, von den bereits in Int32 implementierten Methoden Gebrauch machen können. Die hier wohl wichtigsten Operatoren sind jene, die uns die Gleicheit bzw. Ungleichheit bestätigen. Diese würden, da wir eh nur eine Integer-Spezifikation verwenden, wie folgt aussehen:

public static bool operator ==(Int24 value1, Int24 value2)
{
    return value1.Value == value2.Value;
}

public static bool operator !=(Int24 value1, Int24 value2)
{
    return value1.Value != value2.Value;
}

Auch hier ist wieder zu erkennen, dass man es sich als Entwickler oft sehr einfach machen kann. Wobei an dieser Stelle ebenfalls bedacht werden sollte, dass bei einem wirklich eigenen Typen der nicht eine so große Ähnlichkeit mit einem anderen bereits existierenden Typen hat, natürlich viel mehr Aufwand benötigt wird. 

Als nächstes folgen vier Operatoren, die den Zahlen-Typen eigentlich vorbehalten sind. Die Prüfung auf Größer und Kleiner in der Wertigkeit. Aber auch hier ist wieder das gleiche Vorgehen wie zuvor zu wählen. Man bedient sich lediglich der bereits vorhandenen Operatoren im Integer-Datentyp.

public static bool operator <(Int24 value1, Int24 value2)
{
    return value1.Value < value2.Value;
}

public static bool operator >(Int24 value1, Int24 value2)
{
    return value1.Value > value2.Value;
}

public static bool operator <=(Int24 value1, Int24 value2)
{
    return value1.Value <= value2.Value;
}

public static bool operator >=(Int24 value1, Int24 value2)
{
    return value1.Value >= value2.Value;
}

Das sind eigentlich auch schon die wichtigsten Operatoren. Aber es gibt noch weitere, die nicht so oft Verwendung finden. Die Bit-Operatoren. Von diesen gibt es insgesamt sechs Stück, wobei wir hier bereits einen im 2.Teil implementiert hatten (den „~“-Operator). Folglich fehlen noch fünf, die wir uns jetzt vornehmen.

public static Int24 operator &(Int24 value1, Int24 value2)
{
    return new Int24(value1.Value & value2.Value);
}

public static Int24 operator |(Int24 value1, Int24 value2)
{
    return new Int24(value1.Value | value2.Value);
}

public static Int24 operator ^(Int24 value1, Int24 value2)
{
    return new Int24(value1.Value ^ value2.Value);
}

public static Int24 operator <<(Int24 value, int move)
{
    int val = value.Value << move;

    if (val > IntMaxValue || val < IntMinValue)
    {
        val *= -1;
        if (val > IntMaxValue || val < IntMinValue)
            return new Int24();
    }

    return new Int24(val);
}

public static Int24 operator >>(Int24 value, int move)
{
    int val = value.Value >> move;

    if (val > IntMaxValue || val < IntMinValue)
    {
        val *= -1;
        if (val > IntMaxValue || val < IntMinValue)
            return new Int24();
    }

    return new Int24(val);
}

Und damit endet auch der 3te Teil dieser Serie. Wer möchte kann sich gerne bereits den weiteren Implementierungen widmen, den aktuellen Stand mit den noch fehlenden Methoden findet Ihr hier: Int24 (Ein eigener Datentyp (Teil 3)). Ansonsten geht es im nächsten Teil mit der Implementierung der Parsing-Methoden weiter.