How can I enforce a contract within a struct

Question

I'd like to enforce a struct to always be valid regarding a certain contract, enforced by the constructor. However the contract is violated by the default operator.

Consider the following, for example:

struct NonNullInteger
{
    private readonly int _value;

    public int Value
    {
        get { return _value; }
    }

    public NonNullInteger(int value)
    {
        if (value == 0)
        {
            throw new ArgumentOutOfRangeException("value");
        }

        _value = value;
    }
}

// Somewhere else:
var i = new NonNullInteger(0); // Will throw, contract respected
var j = default(NonNullInteger); // Will not throw, contract broken

As a workaround I changed my struct to a class so I can ensure the constructor is always called when initializing a new instance. But I wonder, is there absolutely no way to obtain the same behavior with a struct?

score 6 · Answer 1 · answered Nov 27 '11 at 18:15

I don't see how you could do this, because, unlike a class, a struct always has a default parameterless constructor; given the way your struct is written, a value of 0 cannot be prevented:

Structs cannot contain explicit parameterless constructors. Struct members are automatically initialized to their default values.

score 3 · Accepted Answer · answered Nov 27 '11 at 21:37

3

One approach is to arrange things so that the default value satisfies the contract:

struct NonNullInteger
{
    private readonly int _valueMinusOne;

    public int Value
    {
        get { return _valueMinusOne + 1; }
    }

    public NonNullInteger(int value)
    {
        if (value == 0)
        {
            throw new ArgumentOutOfRangeException("value");
        }

        _valueMinusOne = value - 1;
    }
}

answered Nov 27 '11 at 21:37

Rick Sladkey

33,988
6
71
95

This is actually a good solution for meeting the letter of the contract, though it would also need checking for int.MinValue. I wouldn't recommend creating this struct, but, if you really wanted to do it, this is probably the cleanest solution. – Dan Bryant Nov 28 '11 at 15:03
+1 Smart trick. May be quite more difficult for more complex contracts however. – user703016 Dec 02 '11 at 09:23

score 1 · Answer 3 · answered Nov 27 '11 at 18:22

An immutable class is preferable in this case, since the default state is invalid. It's a bit more costly as far as memory usage, but that shouldn't matter unless you using a very large number of these. Really though, a 'non-zero number' constraint is probably better handled at a contractual level for each method, rather than put into a class.

If you really want to enforce the contract, put the exception in the Value getter instead of the constructor. Then the contract is that you'll throw an exception if it ever did contain a 0 value; the only real benefit here is that you never silently use a zero value. The downside is that now you have a comparison every time you use the value.

score 1 · Answer 4 · answered Nov 27 '11 at 18:34

While you can't achieve exactly what you want you could validate in the getter:

public int Value
{
    get 
    { 
        if (_value == 0) 
            throw new InvalidOperationException("Use of uninitialized struct"); 
        return _value; 
    }
}

How can I enforce a contract within a struct

4 Answers4