如何在继承off接口时向接口代码契约添加实现

Question

我的例子是这样一种情况，即继承基本接口的接口需要添加由其附加字段导致的后置条件 - 当我决定将IInitialise接口作为继承的接口时发生的示例总是想要一个pre / post条件添加到Initialise方法。

我可以看到问题是由于抽象实现无法避免彼此（由于拦截或重写器）。

    [ContractClass(typeof(IInitialiseContract))]
    public   interface IInitialise
    {
        bool IsInitialised { get; }
        void Initialise();

    }

    [ContractClassFor(typeof(IInitialise))]
    public abstract class IInitialiseContract : IInitialise
    {

        public bool IsInitialised
        {
            get { return default(bool); }
        }

        public void Initialise()
        {
            Contract.Ensures(IsInitialised == true);
        }
    }

然后我最终得到以下界面

  [ContractClass(typeof(IEnginecontract))]
    public interface IEngine : IInitialise 
    {
        ICommandManager CommandManager { get; }
        IDictionary<int, IEntity> World { get; } 
    }

    [ContractClassFor(typeof(IEngine))]
    public abstract class IEnginecontract : IEngine
    {

        public ICommandManager CommandManager
        {
            get
            {
                Contract.Ensures(Contract.Result<ICommandManager>() != null);
                return default(ICommandManager);
            }
        }

        public IDictionary<int, IEntity> World
        {
            get
            {
                Contract.Ensures(Contract.Result<IDictionary<int, IEntity>>() != null);
                return default(IDictionary<int, IEntity>);
            }
        }

        public bool IsInitialised
        {
            get { return default(bool); }
        }

        public void Initialise()
        {
            // I would like to put my pre and post conditions here but 
            // cannot because it is implemented in the base interfaces contract.
        }
    }

我到了这里，我想不出一个很好的清洁方式来为Initialise（）添加条件。

编辑2：如果我在这个方法中提出了一个要求，我会得到这样的错误

警告1合同类IEngine无法定义方法IInitialise.Initialise的合同，因为其原始定义不在IEngine类型中。 相反，在IInitialise类型上定义合同。 IEngine .cs

有任何想法吗？

Answer 1

任何来自您正在编写合同的接口以外的接口的方法都应标记为abstract 。 这些方法的合同将自动继承，您无法更改它们（或者这会改变基本接口的含义，这没有意义）。

所以你应该有你的基本接口及其合同：

[ContractClass(typeof(IInitialiseContract))]
public interface IInitialise
{
    bool IsInitialised { get; }
    void Initialise();

}

[ContractClassFor(typeof(IInitialise))]
public abstract class IInitialiseContract : IInitialise
{

    public bool IsInitialised
    {
        get { return default(bool); }
    }

    public void Initialise()
    {
        Contract.Ensures(IsInitialised == true);
    }
}

你的派生接口及其契约（注意抽象继承的）：

[ContractClass(typeof(IEnginecontract))]
public interface IEngine : IInitialise 
{
    ICommandManager CommandManager { get; }
    IDictionary<int, IEntity> World { get; } 
}

[ContractClassFor(typeof(IEngine))]
public abstract class IEnginecontract : IEngine
{

    public ICommandManager CommandManager
    {
        get
        {
            Contract.Ensures(Contract.Result<ICommandManager>() != null);
            return default(ICommandManager);
        }
    }

    public IDictionary<int, IEntity> World
    {
        get
        {
            Contract.Ensures(Contract.Result<IDictionary<int, IEntity>>() != null);
            return default(IDictionary<int, IEntity>);
        }
    }

    public abstract bool IsInitialised {get;}
    public abstract void Initialise();
}

Answer 2

我不认为这是可能的。 我广泛使用代码合同，据我所知 - 我记得自己尝试过这样的东西 - 你的派生接口的代码契约必须再次包含所有条件，它不能继承它们。