Forcing code contracts through interface contracts

Sometimes we need a way to make different implementations of same interface follow same rules. One option is to duplicate contracts to all implementation but this is not good option because we have duplicated code then. The other option is to force contracts to all implementations at interface level. In this posting I will show you how to do it using interface contracts and contracts class.

Using code from previous example about unit testing code with code contracts I will go further and force contracts at interface level. Here is the code from previous example. Take a careful look at it because I will talk about some modifications to this code soon.


public interface IRandomGenerator
{
   
int Next(int min, int
max);
}

public class RandomGenerator : IRandomGenerator
{
   
private Random _random = new Random
();

   
public int Next(int min, int
max)
    {
       
return
_random.Next(min, max);
    }
}

public class Randomizer
{
   
private IRandomGenerator
_generator;

   
private
Randomizer()
    {
        _generator =
new RandomGenerator
();
    }

   
public Randomizer(IRandomGenerator
generator)
    {
        _generator = generator;
    }

   
public int GetRandomFromRangeContracted(int min, int
max)
    {
       
Contract.Requires<ArgumentOutOfRangeException
>(
            min < max,
           
"Min must be less than max"
        );

       
Contract
.Ensures(
           
Contract.Result<int
>() >= min &&
           
Contract.Result<int
>() <= max,
           
"Return value is out of range"
        );

       
return _generator.Next(min, max);
    }
}

If we look at the GetRandomFromRangeContracted() method we can see that contracts set in this method are applicable to all implementations of IRandomGenerator interface. Although we can write new implementations as we want these implementations need exactly the same contracts. If we are using generators somewhere else then code contracts are not with them anymore.

To solve the problem we will force code contracts at interface level.

NB! To make the following code work you must enable Contract Reference Assembly building from project settings.

Interface contracts and contracts class

Interface contains no code – only definitions of members that implementing type must have. But code contracts must be defined in body of member they are part of. To get over this limitation, code contracts are defined in separate contracts class. Interface is bound to this class by special attribute and contracts class refers to interface through special attribute.

Here is the IRandomGenerator with contracts and contracts class. Also I write simple fake so we can test contracts easily based only on interface mock.


[ContractClass(typeof(RandomGeneratorContracts))]
public interface IRandomGenerator
{
   
int Next(int min, int
max);
}
 
[
ContractClassFor(typeof(IRandomGenerator))]
internal sealed class RandomGeneratorContracts : IRandomGenerator
{
   
int IRandomGenerator.Next(int min, int
max)
    {
       
Contract.Requires<ArgumentOutOfRangeException
>(
                min < max,
               
"Min must be less than max"
            );
 
       
Contract
.Ensures(
           
Contract.Result<int
>() >= min &&
           
Contract.Result<int
>() <= max,
           
"Return value is out of range"
        );
 
       
return default(int
);
    }
}
 

public class RandomFake : IRandomGenerator
{
   
private int
_testValue;
 
   
public RandomGen(int
testValue)
    {
        _testValue = testValue;
    }
 
   
public int Next(int min, int
max)
    {
       
return _testValue;
    }
}

To try out these changes use the following code.


var gen = new RandomFake(3);

try
{
    gen.Next(10, 1);
}

catch (Exception
ex)
{
   
Debug
.WriteLine(ex.Message);
}

try
{
    gen.Next(5, 10);
}

catch (Exception
ex)
{
   
Debug.WriteLine(ex.Message);
}

Now we can force code contracts to all types that implement our IRandomGenerator interface and we must test only the interface to make sure that contracts are defined correctly.


One thought on “Forcing code contracts through interface contracts

Leave a Reply

Your email address will not be published. Required fields are marked *