Ich habe ein Problem bei der Verwendung von Invarianten mit Codeverträgen festgestellt. Ich möchte eine Invariante in meiner abstrakten Klasse definieren, aber sie wird einfach ignoriert. Der folgende Code zeigt meine Schnittstelle und die abstrakte Klasse.

[ContractClass(typeof(IPointContract))]
interface IPoint
{
    int X { get; }
    int Y { get; }
}

[ContractClassFor(typeof(IPoint))]
abstract class IPointContract : IPoint
{

    public int X
    {
        get { return 0; }

    }

    public int Y
    {
        get { return 0; }
    }

    [ContractInvariantMethod]
    private void PointInvariant()
    {
        Contract.Invariant(X > Y);
    }
}

Anschließend implementiere ich diese Schnittstelle in meiner Point-Klasse und erstelle daraus ein Objekt. Dies sollte zumindest zur Laufzeit fehlschlagen.

class Point : IPoint
{
    public Point(int X, int Y)
    {
        this._x = X;
        this._y = Y;
    }

    private int _x;
    public int X
    {
        get { return _x; }
    }

    private int _y;
    public int Y
    {
        get { return _y; }
    }
}

class Program
{
    static void Main(string[] args)
    {
        Point p = new Point(1, 2);
    }
}

Wenn ich die Invariante in die Point-Klasse verschiebe, funktioniert es einwandfrei. Alle anderen Vor- oder Nachbedingungen funktionieren auch einwandfrei.

Ist es nicht möglich, Invarianten in einer abstrakten Klasse zu haben oder mache ich es falsch?