代码契约CodeContract（八）

代码契约（Code Contract）：它并不是语言本身的新功能，而是一些额外的工具，帮助人们控制代码边界。

代码契约之于C#，就相当于诗词歌赋之于语言。 --- C# in Depth

一，概述

　　1.1 未引入“代码契约（特指MS代码契约）”之前的状态---“契约”

　　　　• 契约：20世纪80年代，Bertand Meyer在设计Eiffel语言时就将其作为重要的部分。已有大量的计算机科学研究开始探究正式的规范说明和验证，它允许在编译时检查程序的正确性，不过契约的作用还不止于此。

　　　　• 契约编程的核心理念是将API的需求和承诺与实现相分离。

　　　　• 契约约定比文档约定方式更“同步”一些。

　　　　• 或使用Debug.Assert方式，但其不能在Release构建时不会捕获非法参数。

　　　　　/************************使用代码契约方式之前*****************************/
　　　　　/// <summary>
        /// Counts the number of whitespace characters in <paramref name="text"/>
        /// </summary>
        /// <param name="text">String to examine. Must not be null.</param>
        /// <example cref="ArgumentNullException"><paramref name="text"/> is null.</example>
        /// <returns>The number of whitespace characters</returns>
        public static int CountWhiteSpace(string text)
        {
            if (string.IsNullOrEmpty(text))
                throw new ArgumentNullException("text");
            return text.Count(char.IsWhiteSpace);
        }

        /************************使用代码契约方式之前*****************************/
        /// <summary>
        /// 说明:只能在Debug模式下规范”契约“。
        /// </summary>
        /// <param name="text"></param>
        /// <returns></returns>
        public static int CountStringLength(string text)
        {
            // 命名空间：using System.Diagnostics;
            Debug.Assert(text != null);
            return text.Length;
        }

　1.2 代码契约

　　　　• C#代码契约起源于微软开发的一门研究语言Spec#（参见http://mng.bz/4147）。

　　　　• 契约工具：包括：ccrewrite（二进制重写器，基于项目的设置确保契约得以贯彻执行）、ccrefgen（它生成契约引用集，为客户端提供契约信息）、cccheck（静态检查器，确保代码能在编译时满足要求，而不是仅仅

　　　　　　　　　　检查在执行时实际会发生什么）、ccdocgen（它可以为代码中指定的契约生成xml文档）。

　　　　• 契约种类：前置条件、后置条件、固定条件、断言和假设、旧式契约。

　　　  • 代码契约工具下载及安装：下载地址Http://mng.bz/cn2k。（代码契约工具并不包含在Visual Studio 2010中，但是其核心类型位于mscorlib内。）

　　　　• 命名空间：System.Diagnostics.Contracts.Contract

　　　　

　　　　• 代码契约优势：编译前执行检查（如若设置异常类型使用EnsuresOnThrow<Exception>则会在编译时抛出异常），这样比较编译后检查有明显的优势。

　　　　   　　　　　　

　　1.3 契约种类介绍

　　　　• 前置条件（precondition）：是对方法调用者提出的要求，而不是表示普通条件下方法本身的行为。Contract.Requires<T>();

 1         /// <summary>
 2         /// 实现“前置条件”的代码契约
 3         /// </summary>
 4         /// <param name="text">Input</param>
 5         /// <returns>Output</returns>
 6         public static int CountWhiteSpace(string text)
 7         {
 8             // 命名空间：using System.Diagnostics.Contracts;
 9             Contract.Requires<ArgumentNullException>(text != null, "Paramter:text");// 使用了泛型形式的Requires
10             return text.Count(char.IsWhiteSpace);
11         }

　　　　• 后置条件(postcondition)：表示对方法输出的约束：返回值、out或ref参数的值，以及任何被改变的状态。Ensures();

        /// <summary>
        /// 实现“前置条件”的代码契约
        /// </summary>
        /// <param name="text">Input</param>
        /// <returns>Output</returns>
        public static int CountWhiteSpace(string text)
        {
            // 命名空间：using System.Diagnostics.Contracts;
            Contract.Requires<ArgumentNullException>(!string.IsNullOrEmpty(text), "text"); // 使用了泛型形式的Requires
            Contract.Ensures(Contract.Result<int>() > 0); // 1.方法在return之前，所有的契约都要在真正执行方法之前（Assert和Assume除外，下面会介绍）。
                                                          // 2.实际上Result<int>()仅仅是编译器知道的”占位符“：在使用的时候工具知道它代表了”我们将得到那个返回值“。
            return text.Count(char.IsWhiteSpace);
        }

        public static bool TryParsePreserveValue(string text, ref int value)
        {
            Contract.Ensures(Contract.Result<bool>() || Contract.OldValue(value) == Contract.ValueAtReturn(out value)); // 此结果表达式是无法证明真伪的。
            return int.TryParse(text, out value); // 所以此处在编译前就会提示错误信息：Code Contract：ensures unproven: XXXXX
        }

　　　　• 固定条件（invariant）：它们是只要对象的状态可见，就必须自始至终遵循的契约。换句话说，在类的公共方法运行时，固定条件可以改变，但在方法的最后，它们仍要满足契约。

 1         public sealed class CardGame
 2         {
 3             readonly Stack<Card> deck = new Stack<Card>(Card.CreateFullDeck());
 4             readonly Stack<Card> discardPile = new Stack<Card>();
 5             readonly List<Player> players = new List<Player>();
 6
 7             public void DealCard(Player p)
 8             {
 9                 players.Add(p);
10             }
11
12             [ContractInvariantMethod]
13             private void ObjectInvarint()
14             {
15                 Contract.Invariant((deck.Count + discardPile.Count + players.Sum(p => p.CardCount)) == Card.FullDeckSize); // 校验总和是否一致。
16             }
17         }

　　　　　　　　特性：1. 固定条件方法是无参数、无返回值、私有的。

　　　　　　　　　　　2. 用[ContractInvariantMethod]标签修饰。

　　　　　　　　　　　3. 执行起来代价低廉，不必担心性能损失。

　　　　　　　　　　　4. 如果检查集合内容还可用Contract.ForAll or Contarct.Exists.

            [ContractInvariantMethod]
            private void InvarintCollection()
            {
                Contract.Invariant(Contract.ForAll(players, item => item.Name != "Stephen")); // 校验集合。
                Contract.Invariant(!Contract.Exists(players, item => item.Name != "Stephen")); // 与上句作用相同。
            }

　　　　• 断言和假设 ：可检测在代码进行到“一半”时发生的事情。

　　　　　　　　断言Assert：静态检查器会检测Assert是否正确，而Assume不会。大多数情况下使用。

　　　　　　　　假设Assume：正因为静态检查器不会检查，所以某些情况下需要过滤掉静态检查器无法检验的东西。

            public static int RollDic(Random rng)
            {
                Contract.Ensures(Contract.Result<int>() >= 2);

                if (rng == null)
                    rng = new Random();
                Contract.Assert(rng != null);

                int firstRoll = rng.Next(1, 7);
                Contract.Assume(firstRoll >= 1);
                Contract.Assume(firstRoll <= 6);

                return firstRoll;
            }

　　　　• 旧式契约：本质上是另一种形式的前置条件。DoNet2.0支持。

            public static int CountSpace(string text)
            {
                if (text == null)
                    throw new ArgumentNullException("text");
                Contract.EndContractBlock(); // 此方法不做任何事情，只是让二进制编译器知道，此句以上的部分是契约。

                return text.Count(char.IsWhiteSpace);
            }

　　二， 使用ccrewrite和ccrefge重写二进制

　　　  2.1 契约重写：重写刚刚获取的程序集的某些部分，以替换原始的程序集。

　　　　　　替换的事件序列：

　　　　　　　　　　• 检查前置条件。

　　　　　　　　　　• 为OldValue方法调用获取初始的状态。

　　　　　　　　　　• 执行代码的功能部分，如Assert

• 检查后置条件

　　　　　　　　　　• 检查固定条件

　　　　2.2 契约继承（重要）

　　　　　　• 特性：1. 覆盖某方法（或实现某个接口方法，规范契约）会继承该方法中的契约。

　　　　　　　　　2. 不能再继承的方法中添加额外的前置条件，但却可以添加固定条件和后置条件。必须符合Liskov替换原则（里氏代换原则http://zh.wikipedia.org/wiki/Liskov%E4%BB%A3%E6%8F%9B%E5%8E%9F%E5%89%87）。

　　　　　  • 继承：使其子类也有父类中的前置条件、后置条件等，作为一种条件约束，但也有其限制，而且继承很容易被滥用，不如实现接口方式稳妥。

        [Pure]
        public static bool Report(string text)
        {
            Console.WriteLine(text);
            return true;
        }

        public class ContractBase
        {
            public virtual void VirtualMethod(string text)
            {
                Contract.Requires(Report("Base precondition"));
                Contract.Ensures(Report("Base postcondition"));
            }
        }

        public class Derived : ContractBase
        {
            public override void VirtualMethod(string text)
            {
                Contract.Ensures(Report("Dervied postcondition"));
            }
        }

        /* *******************************************************
         * 结果：
         * Base precondition
         * Dervied postcondition
         * Base postconditon
         *
         * 注：尽管Dervied中覆写的方法没有调用base.VirtualMethod(),
         * 契约仍然被执行。
         * *******************************************************/

　　　　　　• 为接口指定契约：

 1         /*************************************************************
 2          * 说明：
 3          * 1. ICaseConverter与ICaseConverterContracts互为实现（相互反向
 4          *    引用）。
 5          * 2. ICaseConverter只定义接口方法。
 6          * 3. ICaseConverterContracts抽象类中实现接口的约束，内部要定义成
 7          *    私有。
 8          * 4. CurrentCultrueUpperCaseFormatter实现接口ICaseConverter，而
 9          *    与抽象类隔离。
10          * ***********************************************************/
11         /// <summary>
12         /// 接口类
13         /// </summary>
14         [ContractClass(typeof(ICaseConverterContracts))] // 指定契约类
15         public interface ICaseConverter
16         {
17             string Convert(string text);
18         }
19
20         /// <summary>
21         /// 契约类
22         /// </summary>
23         [ContractClassFor(typeof(ICaseConverter))] // 声明契约所服务的类型
24         internal abstract class ICaseConverterContracts : ICaseConverter
25         {
26             public string Convert(string text)
27             {
28                 Contract.Requires(!string.IsNullOrEmpty(text)); // 前置条件
29                 Contract.Ensures(Contract.Result<string>() != null); // 后置条件
30                 return default(string);// 如果没有实现此类，则返回默认值。
31             }
32
33             private ICaseConverterContracts() { } // 禁止实例化该类
34         }
35
36         /// <summary>
37         /// 实现类
38         /// </summary>
39         public class CurrentCultrueUpperCaseFormatter : ICaseConverter // 继承接口中的契约
40         {
41             public string Convert(string text)
42             {
43                 return text.ToUpper(CultureInfo.CurrentCulture); // 实现接口方法。（由二进制重写器执行检查）
44             }
45         }

　　　　      • 失败行为

　　　　　　　　Contract全局失败事件：Contract.ContractFailed ，可注册并捕获所有Contract失败事件

        Contract.ContractFailed += new EventHandler<ContractFailedEventArgs>(Contract_ContractFailed);

...
        static void Contract_ContractFailed(object sender, ContractFailedEventArgs e)
        {
            Console.WriteLine("{0}:{1},{2}", e.FailureKind, e.Condition, e.Message);
            e.SetHandled();
        } 

　　　　　　

　　三， 静态检查

　　      • 意义：在编译时执行检查，任何错误将在Error List中显示警告信息和错误信息。

        static string DontPassMeNull(string input)
        {
            Contract.Requires(input != null);
            Contract.Ensures(Contract.Result<string>() != null);
            return input;
        }

        static string MightReturnNull()
        {
            return "Not null really";
        }

        /// <summary>
        /// Error list中显示警告信息
        /// </summary>
        public static void DoTest()
        {
            DontPassMeNull("definitely okay"); // 总能通过
            DontPassMeNull(MightReturnNull()); // CodeContracts:requires unproven:input != null 无法证明
            DontPassMeNull(null); // 提示错误信息
        }

　　　　 • 静态检查选项：在属性页中选择Implicit Non-null Obligations选项可执行前置空引用的检查，Implicit Array Bounds Obligations选项可检查数组是否越界。

　　　　  • 有选择性的执行检查

　　　　　　1. BaseLine（基线）方法：

　　　　　　　 在属性页中，选中：

　　　　　　　则，在程序跟目录会生成baseline.xml文件，包含所有警告信息。

　　　　　　将错误导出到文件中有利于分析错误。

　　　　2. 特性控制检查：

　　　　　　[assembly: ContractVerification(false)]

　　　　　   [ContractVerification(false)]

　　四，后记（契约实战）

　　  　4.1 契约是一种稳固的保障：它不仅意味着在满足前置条件时，代码将以特定的方式运行，还意味着在不满足的时候，就不会继续执行。

　　　　4.2 不要考虑为不易变类型设置固定条件。如果某些情况不会改变类型的状态，那它也肯定不会破坏固定条件。相反，如果在构造时有必须遵循的规则，那么也应该是前置条件。

更多关于“代码契约”内容请阅读《C# in Depth》

官方文档：http://download.csdn.net/detail/cuiyansong/5580307

工程狮必备属性：追新，执着，高内聚低耦合。 版权声明：凡是没有标注[转载]的，在引用文章时，均要加上本博客地址http://www.cnblogs.com/cuiyansong/。

 

分类: 读书笔记, 原创

标签: C# 契约编程 契约

轻量级前端MVVM框架avalon - 执行流程1

基本上确定了avalon的几个重要元素的关系：

• Ｍ，即model，一个普通的ＪＳ对象，可能是后台传过来的，也可能是直接从ＶＭ中拿到，即ＶＭ.$json。有关的这个$json的名字还在商讨

• V，即View，HTML页面，通过绑定属性或插值表达式，呈现数据，处理隐藏，绑定事件或动画等各种交互效果。Ｖ只与ＶＭ打交道。

• ＶＭ，即ViewModel，我们通过avalon.define("xxx", function(vm){vm.firstName = "正美"})，这里的vm是一个临时的对象，用于定义，真正的ＶＭ是avalon.define方法的返回值。它上面的$json属性就是Ｍ，可以见ＶＭ处于一切的核心。我们对ＶＭ的每一个操作，都会向上同步到Ｖ，向下同步到Ｍ。并且出于节能低碳起见（减少对象的创建），我们在生成Ｍ时，会重复利用ＶＭ中的一些属性，比如vm的某个属性是一个对象，那么这个对象会直接搬到$json中。若它是一个数组，它里面每个元素为对象，这些数组或对象都会直接$json中去，当然有时会修复一下（比如计算属性会转换一个简单的数据类型）

在MVVM模式中,ViewModel是贯穿整个框架的梁柱

我们现在分析下整个代码如何运作的一个流程：本文不讨论具体实现,只讨论流程

首先自然是HTML结构

<fieldset ms-controller="simple">
         <legend>例子</legend>
         <p>First name: <input ms-model="firstName" /></p>
         <p>Last name: <input ms-model="lastName"  /></p>
         <p>Hello,    <input ms-model="fullName"></p>
         <div>{{firstName +" | "+ lastName }}</div>
     </fieldset>

观察后得出结论：

@ 与常规结构不同

@ 定义了很多自定义标签  如何:ms-model ,ms-controller

@ 插值表达式 {{}}

.........等等,具体请看api手册

那么接下来开发着定义JS

avalon.ready(function() {
    avalon.define("simple", function(vm) {
        vm.firstName = "司徒"
        vm.lastName = "正美"
        vm.fullName = {//一个包含set或get的对象会被当成PropertyDescriptor，
            set: function(val) {//set, get里面的this不能改成vm
                var array = (val || "").split(" ");
                this.firstName = array[0] || "";
                this.lastName = array[1] || "";
            },
            get: function() {
                return this.firstName + " " + this.lastName;
            }
        },
        vm.nick = {
            name: "暗黑之民"
        }
    })
})

大概理解下代码的意思：

1. avalon.ready(function() { //这是domReady，相当于jQuery的 $(function(){})
2. var model = avalon.define("aaa", [], function(vm) { //创建一个名字为aaa的ViewModel
3. vm.firstName = "司徒"  //创建一个监控属性
4. vm.lastName = "正美"    //创建一个监控属性
5. vm.fullName = {//一个包含set或get的对象 用于创建一个依赖监控属性
6. avalon.scan();//开始扫描DOM树，处理绑定

第二步就能看出来这个就是定义的一个模型了,vm->ViewModel 视图模型

整个运作都是围绕着vm展开的,mvvm模式中ＶＭ处于一切的核心,我们对ＶＭ的每一个操作，都会向上同步到Ｖ，向下同步到Ｍ。

VM的创建不仅仅只是我们看到的定义了几个属性,几个方法,其实框架内部帮我们做了很多事:

具体大概说下

VM模型的创建：

1.框架内部创建模型对象VM

2.VM吸收开发定义的处理方法

3.把开发定义的方法给经内部的转换，它的属性与方法会换胎换骨

4.返回这个被改造过的模型对象,挂到全局保存起来

所以这个里面涉及闭包与作用域链的问题了,以后再慢慢分析

那么这个VM创建好了,我们接下来干嘛呢? 

大家有没有发现在HTML结构中与VM代码中,有没有共同点？

1.HTML中定义的自定义标签与VM中的属性方法名是不是一样？

2.根据API的定义,HTML对应的每一个标签的都会对应着某一种JS的处理方式

3.现在HTML结构与JS代码都是独立的东东,所以我们想个办法让他们关联起来

如何关联?

答案：扫描绑定

avalon.scan();//开始扫描DOM树，处理绑定

简而言之呢就是扫描属性节点，文本节点,找到对应的事件处理器,执行事件绑定等一堆东东

属性节点

<input ms-model="firstName" />

发现有ms-开头的名字就会解析成对应的一个处理方法

比如ms-model

//将模型中的字段与input, textarea的value值关联在一起
var modelBinding = bindingHandlers.model = function(data, scopes) {
    var element = data.element;
    var tagName = element.tagName;
    //是否有对应元素的标签名的处理方法
    if (typeof modelBinding[tagName] === "function") {
        var array = getValueFunction(data.value.trim(), scopes);
        if (array) {
            modelBinding[tagName](element, array[0], array[1]);
        }
    }

当然还会传递一些需要运行的参数

特别指出来传递的实参scopes就是ViewModel对象

所以我们大胆猜测下

* 在这一大堆扫描绑定方法中应该会哪些实现(这些方法才是最终的执行体)

待续...

 

 

分类: MVVM