博客园_忘却之都

[原创]一步一步用C#编写三国杀（三）：设计流程

2010-08-03T16:13:00Z

原创文章，转载请保留作者署名！

前面已经说了牌堆的设计，那么现在就正式进入流程，满足我们在（一）中所说的需求。

由于在（二）中已经说了要维护扩展，因此对于之前定义的Scene，则需要定义一个所选择的扩展包，代码如下：

        private readonly IPackage[] selectedPackages;

        /// <summary>
        /// 初始化新的<see cref="Scene"/>类的实例。
        /// </summary>
        /// <param name="packages">所要加载的包。</param>
        public Scene(IEnumerable<IPackage> packages)
        {
            players[currentToken].HasToken = true;
            selectedPackages = packages.ToArray();
        }

由于玩家是轮动的，因此设定一个令牌，只有持有令牌的玩家才能行动。

private int currentToken;

那么定义一个Start方法，开始游戏循环。

首先要根据选择的扩展包生成游戏牌堆。对于游戏牌堆，由于我们之前已经定义好了牌堆基类，因此实现就比较简单了，将扩展包中的游戏牌载入并洗牌即可。

    /// <summary>
    /// 表示游戏牌牌堆。
    /// </summary>
    public sealed class GameCardHeap : CardHeap<GameCard>
    {
        /// <summary>
        /// 初始化新的<see cref="GameCardHeap"/>类的实例。
        /// </summary>
        /// <param name="packages">所要加载的扩展包。</param>
        public GameCardHeap(IEnumerable<IPackage> packages)
        {
            foreach (var package in packages)
            {
                ((List<GameCard>) Items).AddRange(package.GameCards);
            }
            Items.Shuffle();
        }
    }

回头看我们上面的Start方法，在牌堆创建后，就进入了流程循环，还是直接来代码吧，注释都写的蛮清楚的

        /// <summary>
        /// 开始游戏。
        /// </summary>
        public void Start()
        {
            Player currentPlayer;
            GameCardHeap heap = new GameCardHeap(selectedPackages);  // 创建牌堆

            while(true)
            {
                currentPlayer = players[currentToken];  // 设置当前有令牌的玩家

                // 摸牌阶段
                GameCard[] newCards = heap.Pop(2, true);
                currentPlayer.Draw(newCards);

                // 出牌阶段
                while(currentPlayer.HasPlayableCard)
                {
                    // NOTE:为了简单，先实现只杀下家，并只使用杀、闪、桃
                    int nextToken = currentToken == players.Length - 1 ? 0 : currentToken + 1;
                    currentPlayer.Play(players[nextToken], currentPlayer.FirstPlayableCard);

                    if (IsGameEnds())
                        goto label;
                }

                // 弃牌阶段
                // NOTE:为了简单，先实现只弃从头开始的牌到当前体力值
                int disCardCount = currentPlayer.HandCards.Length - currentPlayer.Hp;
                if (disCardCount > 0)
                {
                    GameCard[] removeCards = currentPlayer.HandCards.Take(disCardCount).ToArray();
                    currentPlayer.Discard(removeCards);
                }

                // 将令牌给下一个人
                GiveTokenToNext();
            }
            label:
            Console.WriteLine("游戏结束！");
        }

这里使用了一个死循环，但在游戏结束的时候使用goto语句跳出循环。所涉及到的一些方法如下：

        private void GiveTokenToNext()
        {
            if (currentToken == players.Length - 1)
                currentToken = 0;
            else
                currentToken++;

            players[currentToken].HasToken = true;
        }

        private bool IsGameEnds()
        {
            return players.Any(p => p.IsDead);  // 如果选择到IsDead的Player，游戏结束
        }

注意，流程的设计中，由于玩家是在游戏逻辑边界内的，因此采用了主动的做法来进行设计。这样对于程序来说，我只要去考虑玩家的摸牌、出牌和弃牌所引起的各种变化即可。

本文链接

[原创]一步一步用C#编写三国杀（二）：牌堆的设计

2010-07-29T00:55:00Z

原创文章，转载请保留作者署名！

前一节说到了一些基础性的定义。这一节开始将进入流程的分析。

首先，在游戏的场景建立之后，你就必须有一个牌堆。对于目前的需求来说，只要有手牌的牌堆即可；尽管后面可能还要有身份牌堆和武将牌堆，但目前只考虑手牌，即游戏牌。于是有以下定义：

    /// <summary>
    /// 定义牌堆的基本类型。
    /// </summary>
    /// <typeparam name="T">参数类型。</typeparam>
    public abstract class CardHeap<T> : Collection<T>
    {

    }

定义为抽象的，是我希望能提供一些通用的方法以简化其他牌堆的设计。

对于牌堆来说，其一个重要的功能就是能够压出牌以供使用，因此定义如下：

        /// <summary>
        /// 从牌堆中压出指定数量的牌，这些牌将会从牌堆中移除。
        /// </summary>
        /// <param name="number">要压出的牌的数量。</param>
        /// <returns>所压出的牌的数组。</returns>
        public T[] Pop(int number)
        {
            if (number <= 0)
                return new T[0];

            if (Items.Count < number)
                number = Items.Count;

            T[] newT = new T[number];
            for (int i = 0; i < number; i++)
            {
                newT[i] = Items.First();
                Items.RemoveAt(0);
            }

            return newT;
        }

牌堆定义之后就需要定义洗牌的操作。由于我定义了从Collection<T> 继承，其内部有个IList<T>类型的Items属性，因此编写一个扩展方法，对IList<T>类型的数据进行类似洗牌的操作：

    /// <summary>
    /// 定义对List的扩展方法。
    /// </summary>
    public static class ListExtension
    {
        /// <summary>
        /// 将IList中的元素进行洗牌操作。
        /// </summary>
        /// <typeparam name="T">类型参数。</typeparam>
        /// <param name="list">所要洗牌的List。</param>
        public static void Shuffle<T>(this IList<T> list)
        {
            Random random = new Random();
            int count = list.Count;

            for (int i = 0; i < count; i++)
            {
                int currentIndex = random.Next(0, count - i);
                T tempCard = list[currentIndex];
                list[currentIndex] = list[count - 1 - i];
                list[count - 1 - i] = tempCard;
            }
        }
    }

很明显，只要游戏没有结束，牌堆中拿出使用过的废牌总要回收进行循环利用，所以废牌要保存起来，并让牌堆支持其中的Items的重生。因此CardHeap中便多了如下定义：

        private readonly IList<T> usedItems = new List<T>();

        private void ReCreate()
        {
            // 将usedItems的牌还原到Items中，并进行洗牌，然后清空usedItems
            ((List<T>) Items).AddRange(usedItems);
            usedItems.Clear();
            Items.Shuffle();
        }

既然多了usedItems，那么上面定义的Pop就需要有个重载，以指定牌堆是否可以进行重生，所以重构上面的Pop方法，改为重载：

        /// <summary>
        /// 从牌堆中压出指定数量的牌，这些牌将会从牌堆中移除。如果牌堆的牌数量不够，则只返回牌堆中剩余的牌。
        /// </summary>
        /// <param name="number">要压出的牌的数量。</param>
        /// <returns>所压出的牌的数组。</returns>
        public T[] Pop(int number)
        {
            return Pop(number, false);
        }

        /// <summary>
        /// 从牌堆中压出指定数量的牌，这些牌将会从牌堆中移除。
        /// </summary>
        /// <param name="number">要压出的牌的数量。</param>
        /// <param name="recreateHeap">在压出牌数量不够的时候是否重新创建牌堆。</param>
        /// <returns>所压出的牌的数组。</returns>
        public T[] Pop(int number, bool recreateHeap)
        {
            if (number <= 0)
                return new T[0];

            if (Items.Count < number && !recreateHeap)
                number = Items.Count;

            T[] newT = new T[number];
            for (int i = 0; i < number; i++)
            {
                if (recreateHeap && Items.Count == 0)
                {
                    ReCreate();
                }

                newT[i] = Items.First();
                Items.RemoveAt(0);
                usedItems.Add(newT[i]);
            }

            return newT;
        }

这样，牌堆的定义就算基本完成了。但在此基础上考虑考虑扩展包的问题。实际上扩展包主要是牌的扩展，而且在设计初期，就已经考虑将标准版的牌从这个Core中分离，即除了基本牌的杀、闪、桃之外，锦囊和装备、武将都是由扩展包来提供。因此定义了个扩展包的接口：

    /// <summary>
    /// 定义扩展包所必须实现的接口。
    /// </summary>
    public interface IPackage
    {
        /// <summary>
        /// 扩展包中的游戏牌。
        /// </summary>
        GameCard[] GameCards { get; }
    }

好，牌堆的设计就说到这里，后面就定义实际的基本牌，并将进入实际流程循环。

本文链接

[原创]一步一步用C#编写三国杀（一）：规则和需求描述

2010-07-25T14:16:00Z

原创文章，转载请保留作者署名！

最近做翻译做的头疼，疼过之余，想想之前公司内组织的三国杀开发兴趣小组在三国杀开发问题上几乎又停滞了。于是又翻出来搞了搞，这次却搞的有点像模像样了，特地把思路和方法都共享出来，一起学习。

三国杀在上海是挺风靡的，如果你还不知道玩法和规则，请猛击这里。

今天要说的是实现的第一步。为了尽量简化需求，我们最初要实现的东西也挺简单，就是能支持两个玩家自动对战。具体的描述如下：在一个场景中设置两个玩家，游戏的牌堆中只有三种基本牌：杀、闪、桃。其中，只有杀和桃是属于主动性游戏牌，即可以在自己行动回合将其打出；闪是被动性游戏牌，只有当别人对自己出杀的时候才可以出闪，否则扣除一点体力，而使用桃则为自己增加一点体力。同样，为了简化实现，只要有能使用的牌，就必须使用；而且，如果你的手牌数量大于体力值，则需要弃牌直到手牌数与体力值相等。在这种情况下，只要有一方体力为0，游戏结束！

对需求进行整理，不难发现有以下需求待实现：

1、游戏结束的条件：只要有玩家死亡即宣告结束。

2、牌堆的实现，注意牌堆中拿出的牌需要从牌堆中移除，以及洗牌的功能。

3、杀、闪、挑的逻辑实现。

4、从手牌中计算是否还有可用的牌。

5、玩家轮询行动的实现。

在设计中，我的思路是这样的：一局游戏实际都在一个场景中进行，直到游戏结束。因此首先有场景的定义：

/// <summary>
/// 表示游戏场景。
/// </summary>
public class Scene
{
private readonly Player[] players;
}

其中场景中定义了游戏玩家，因为场景中的游戏玩家在场景生成之后就固定了，所以使用了readonly。

同样，游戏实际是个循环，结束的条件就是有玩家死亡。因此，先定义玩家死亡的条件：

private bool IsGameEnds()
{
return players.Where(p => p.IsDead).Count() > 0; // 如果选择到IsDead的Player，游戏结束
}

这样，由于其中引用到了Player类，因此，建立玩家类，来对其按照需求进行设计。代码如下：

Player

    /// <summary>
    /// 表示游戏中的玩家。
    /// </summary>
    public class Player
    {
        private readonly List<GameCard> handCards = new List<GameCard>(20);

        public Player(string name, byte maxHp)
        {
            this.Name = name;
            this.Hp = maxHp;
            this.MaxHp = maxHp;
        }

        /// <summary>
        /// 表示该玩家的名称。
        /// </summary>
        public string Name { get; private set; }

        /// <summary>
        /// 表示该玩家是否已经死亡。
        /// </summary>
        public bool IsDead
        {
            get { return Hp == 0; }
        }

        /// <summary>
        /// 表示该玩家所选武将的当前HP.
        /// </summary>
        public byte Hp { get; private set; }

        /// <summary>
        /// 表示该玩家所选武将的最大HP.
        /// </summary>
        public byte MaxHp { get; private set; }
    }

其中的handCards表示玩家手中可以拿的手牌数量，这里设定上限为20张。那么同样要开始定义游戏卡牌，代码如下：

    /// <summary>
    /// 表示游戏中用作游戏的卡牌。
    /// </summary>
    public abstract class GameCard
    {
        /// <summary>
        /// 表示牌的花色。
        /// </summary>
        public CardMark Mark { get; protected set; }

        /// <summary>
        /// 表示牌的大小。
        /// </summary>
        public CardValue Value { get; protected set; }

        /// <summary>
        /// 表示牌的名称。
        /// </summary>
        public string Name { get; protected set; }

        /// <summary>
        /// 对目标玩家使用卡牌。
        /// </summary>
        /// <param name="source">使用卡牌的源对象。</param>
        /// <param name="target">使用卡牌的目标对象。</param>
        public abstract void Use(Player source, Player target);
    }

直到现在，所需要的定义已经基本完成。这其中的代码有很多不规范的地方，之所以展现出来，也是为了表现自己的思维过程，在后面会有很多对目前代码的重构。

在这样定义完了之后，下一步将开始仔细分析流程，按照流程先写出最初能运行的版本。（未完待续...）

本文链接

走进单元测试（3）：消灭HttpContext的依赖，兼谈单元测试的设计辅助性

2010-06-03T09:50:00Z

前篇提到过由于我们已经有了一个现成的平台，现在要对其进行单元测试的补完。而在这个过程中，就出现了HttpContext这类东西，其依附于一个host环境，对单元测试的自动化是一个很大的阻碍。

对于HttpContext，如果没有一个web托管环境，其中的Request和Response等只读属性根本就无法造出来。而如果要搭建一个web托管环境，不仅为测试带来了干扰（因为要确定是否是托管环境的问题），而且给测试的自动化带来了不方便。那么怎么去解决这个问题呢？

在MSDN中我们可以查到一个叫SimpleWorkerRequest的东西，这个东西的提供了一个简单的System.Web.HttpWorkerRequest的实现，使得我们可以在IIS之外托管ASP.NET应用程序。而当我们使用reflector来查看这个东西的源码的时候，发现其中的一些方法很有趣：

1 [ComVisible(false), AspNetHostingPermission(SecurityAction.InheritanceDemand, Level=AspNetHostingPermissionLevel.Minimal), AspNetHostingPermission(SecurityAction.LinkDemand, Level=AspNetHostingPermissionLevel.Minimal)]
2 public class SimpleWorkerRequest : HttpWorkerRequest
3 {
4     //...
5
6     public override string GetHttpVerbName()
7     {
8         return "GET";
9     }
10
11     public override string GetHttpVersion()
12     {
13         return "HTTP/1.0";
14     }
15
16     public override string GetLocalAddress()
17     {
18         return "127.0.0.1";
19     }
20
21     public override int GetLocalPort()
22     {
23         return 80;
24     }
25
26     //...
27 }

这果然是一个简单的实现啊，把IP地址，Http版本，端口等全部硬编码了。

但对我们的需求来说，其实也非常的简单，既然他硬编码了，那我们再派生一下，把这些方法override一下不就可以了：

1     /// <summary>
2     /// Provides a simple implementation of the System.Web.HttpWorkerRequest abstract class that can be used to host ASP.NET applications outside an Internet Information Services (IIS) application.
3     /// This class can be used for unit test which needs a web host.
4     /// </summary>
5     public class TestWorkerRequest : SimpleWorkerRequest
6     {
7         private readonly string hostName = "";
8
9         /// <summary>
10         /// Initializes a new instance of the <see cref="T:System.Web.Hosting.SimpleWorkerRequest"/> class when the target application domain has been created using the <see cref="M:System.Web.Hosting.ApplicationHost.CreateApplicationHost(System.Type,System.String,System.String)"/> method.
11         /// </summary>
12         /// <param name="page">The page to be requested (or the virtual path to the page, relative to the application directory).</param>
13         /// <param name="query">The text of the query string.</param>
14         /// <param name="output">A <see cref="T:System.IO.TextWriter"/> that captures output from the response</param>
15         /// <param name="hostName">The host name that will be requested.</param>
16         public TestWorkerRequest(string page, string query, TextWriter output, string hostName)
17             : base(page, query, output)
18         {
19             this.hostName = hostName;
20         }
21
22         /// <summary>
23         /// Initializes a new instance of the <see cref="T:System.Web.Hosting.SimpleWorkerRequest"/> class for use in an arbitrary application domain, when the user code creates an <see cref="T:System.Web.HttpContext"/> (passing the SimpleWorkerRequest as an argument to the HttpContext constructor).
24         /// </summary>
25         /// <param name="appVirtualDir">The virtual path to the application directory; for example, "/app".</param>
26         /// <param name="appPhysicalDir">The physical path to the application directory; for example, "c:\app".</param>
27         /// <param name="page">The virtual path for the request (relative to the application directory).</param>
28         /// <param name="query">The text of the query string.</param>
29         /// <param name="output">A <see cref="T:System.IO.TextWriter"/> that captures the output from the response.</param>
30         /// <param name="hostName">The host name that will be requested.</param>
31         /// <exception cref="T:System.Web.HttpException">The <paramref name="appVirtualDir"/> parameter cannot be overridden in this context.
32         /// </exception>
33         public TestWorkerRequest(string appVirtualDir, string appPhysicalDir, string page, string query, TextWriter output, string hostName)
34             : base(appVirtualDir, appPhysicalDir, page, query, output)
35         {
36             this.hostName = hostName;
37         }
38
39         /// <summary>
40         /// Returns the server IP address of the interface on which the request was received.
41         /// </summary>
42         /// <returns>
43         /// The server IP address of the interface on which the request was received.
44         /// </returns>
45         public override string GetLocalAddress()
46         {
47             return hostName;
48         }
49     }

那么使用如下代码便可以模拟出一个HttpContext了，这样依赖就不存在了。

            //设置Cookie环境
             Thread.GetDomain().SetData(".appPath", @"D:\Test");
            Thread.GetDomain().SetData(".appVPath", "/");
            TextWriter tw = new StringWriter();
            string address = "http://www.sina.com.cn/";
            HttpWorkerRequest wr = new MyWorkerRequest("login.aspx", "", tw, address);
            HttpContext.Current = new HttpContext(wr);

其实说这个事情，本身并不是为了这个技巧，而是想借这个例子说明怎么去考虑层的职责。比如对HttpContext这个东西，因为你知道你现在设计的是Web程序，你直接使用了这个。但如果有一天同样的业务，让你做一个WinForm呢？HttpContext该怎么办？所以，这样一分析就知道HttpContext这个东西肯定不属于逻辑层。

而如果你对逻辑层做单元测试的话，那么你必定会遇到上述问题。而一旦遇到这种问题，应该就说明了你的设计思路有问题，因为从逻辑本身来说，实现一个测试，我不应该需要借助任何的模拟。至于Mock这个东西，留给以后的篇幅吧。

本文链接

走进单元测试（2）：必须要自动化

2010-05-20T15:06:00Z

前面讲到了现在被调到公司创新组做单元测试相关的工作，先交代下一些背景：

公司是一个做电子商务网站的公司，规模还可以。目前已经有了一套框架，该框架实现了ORM、同步、缓存等很多的功能；然后整个业务算是构建在这个框架之上的二次开发。我目前的任务是对这个业务代码构建一个相对完整的单元测试集。

既然提到单元测试，就不得不提自动化这一块。这里的自动化包含两层意思：首先，单元测试用例需要一个自动化执行的环境，即一个能够由外部条件触发而自动运行。其次是单元测试用例本身要能够自动化的进行，不能每次运行之前需要先配置好环境之类，也即能满足回归测试的要求。

对于第一个要求，我们使用的是CruiseControl.NET这个持续集成工具来进行自动化的配置。这个工具的具体用法这里不介绍了，具体可参见http://ccnetlive.thoughtworks.com/。注意到我们现在建立测试并不是走的测试驱动开发流程，因此可以采用一个定时的方式来发动集成请求，我们把这个时间设置在半夜，具体做的事情如下：先去SVN上取出最新的源代码和测试代码，然后编译，最后使用NUnit运行生成的测试dll。

下面是一个ccnet配置示例，有兴趣的可以拿来直接去用了

1 <cruisecontrol xmlns:cb="urn:ccnet.config.builder">
2     
3     <project name="" queuePriority="1" queue="Q1">
4         <workingDirectory>D:\ccnet</workingDirectory>
5         <artifactDirectory>D:\ccnet</artifactDirectory>
6         <category>Unit Test</category>
7
8     <sourcecontrol type="multi">
9       <sourceControls>
10         <svn>
11           <trunkUrl></trunkUrl>
12           <workingDirectory>D:\ccnet\source\</workingDirectory>
13           <executable>C:\Program Files (x86)\Subversion\bin\svn.exe</executable>
14           <username></username>
15           <password></password>
16           <cleanCopy>true</cleanCopy>
17           <timeout>60000</timeout>
18         </svn>
19
20         <svn>
21           <trunkUrl></trunkUrl>
22           <workingDirectory>D:\ccnet\source\UT</workingDirectory>
23           <executable>C:\Program Files (x86)\Subversion\bin\svn.exe</executable>
24           <username></username>
25           <password></password>
26           <cleanCopy>true</cleanCopy>
27           <timeout>60000</timeout>
28         </svn>
29       </sourceControls>
30     </sourcecontrol>
31
32         <tasks>
33       <modificationWriter>
34         <filename>changelist.xml</filename>
35         <path>D:\ccnet\changelist</path>
36         <appendTimeStamp>true</appendTimeStamp>
37       </modificationWriter>
38
39       <msbuild>
40         <executable>C:\Windows\Microsoft.NET\Framework\v3.5\MSBuild.exe</executable>
41         <workingDirectory>D:\ccnet</workingDirectory>
42         <projectFile></projectFile>
43         <timeout>600</timeout>
44         <logger>C:\Program Files (x86)\CruiseControl.NET\server\ThoughtWorks.CruiseControl.MsBuild.dll</logger>
45       </msbuild>
46
47       <nunit>
48         <path>C:\Program Files (x86)\NUnit 2.5\bin\net-2.0\nunit-console.exe</path>
49         <assemblies>
50           <assembly></assembly>
51         </assemblies>
52       </nunit>
53         </tasks>
54
55     <triggers>
56       <scheduleTrigger time="23:30" name="UnitTestSchedule" buildCondition="ForceBuild">
57         <weekDays>
58           <weekDay>Monday</weekDay>
59           <weekDay>Tuesday</weekDay>
60           <weekDay>Wednesday</weekDay>
61           <weekDay>Thursday</weekDay>
62           <weekDay>Friday</weekDay>
63         </weekDays>
64       </scheduleTrigger>
65     </triggers>
66
67     <publishers>
68       <modificationHistory onlyLogWhenChangesFound="true"/>
69       <xmllogger logDir="D:\ccnet\buildlogs"/>
70
71       <email from="" mailhost="" mailport="25" includeDetails="true" mailhostUsername="" mailhostPassword="">
72         <users>
73           <user name="Billy" group="buildmasters" address="" />
74         </users>
75         <groups>
76           <group name="buildmaster" notification="always" />
77         </groups>
78         <subjectSettings>
79           <subject buildResult="StillBroken" value="Build is still broken for ${CCNetProject}, the fix failed." />
80           <subject buildResult="Broken" value="{CCNetProject} broke at ${CCNetBuildDate} ${CCNetBuildTime } , last checkin(s) by ${CCNetFailureUsers}"  />
81           <subject buildResult="Exception" value="Serious problem for ${CCNetProject}, it is now in Exception! Check status of network / sourcecontrol" />
82         </subjectSettings>
83       </email>
84     </publishers>
85   </project>
86 </cruisecontrol>

（我这里使用的是MSBuild，也可以使用VS的solution直接编译，详见ccnet帮助）

对于第二个自动化要求，这个本身对被测代码的要求比较高。比如很明显的就是现在都采用了分层架构，但这段代码到底属于哪个层，很多人却并不是很清楚。举个例子：业务逻辑层的代码中出现了HttpContext这个东西，那么对单元测试的编写就是个很大的烦恼；再比如cookie等的设置。至于原因，从第一条可以看到要保证这个测试能自动化，那么其运行环境不能依赖于IIS或者WebServer，因此这也是单元测试设计工作中最难的地方，后面将会有很大的篇幅讲述如何消除掉这些依赖或者模拟出一个环境来。

可能有人会问为什么要自动化，同样从上面的两个方面来说。第一个方面的自动化，用Email通知下相关人员可以很快知道测试中有些什么问题，需要他们的协助。第二个方面的自动化则是出于第一个方面的需求，因为如果每次测试都要人工干预的话会很麻烦，成本很高。

本文链接

我也想对广大程序员说一些话

2010-04-29T08:07:00Z

今天上来就看到头条《想对广大程序员说的一些话》，作者的观点还是有很多可取之处的，只是针对博客园的目标群，我觉得有必要谈谈我的观点。

在技术的路上，我一直认为就如同金庸小说中的大侠一样，要内外兼修。光有内功没有外功，虽然很厉害，但略显粗重；光有外功没有内功，则属于花拳绣腿，中看不中用。

那么在技术上，什么是内功？什么是外功呢？我认为内功就是思想层面上的东西。在当前时期，针对广大程序员，其实就是面向对象的思想。但至于什么是面向对象思想，这个东西很空泛，而且本身思想层面上的东西，如果强制使用语言表达出来，或多或少都有些变味，所以只能自己体会了。如果真要说点什么，那么我的理解就是以人的思维方式去思考系统的做事方式。在思想成型之后可以升华到模式思维，这时候看系统就能直观并且自然的看出该使用什么些模式来解决问题，并且能根据自己的需要创建新的模式。外功就是语言，思想最终需要落实到编程语言上，知道如何使用语言来实现思维层次上的东西，这是外功的修炼。

至于新技术、新框架，他们的出现无非就是为了解决目前编程模型中的一些问题。他们的不断更新就是不断的为解决问题提供方便。因此，当内功修炼好之后，看看新增的特性，应该就能对新的更新理解的八九不离十。而外功的修炼，则可以结合内功来创建自己的技术和框架。

至于C，C++，数据结构等这些，个人认为是锦上添花。注意，这里是对广大程序员说的，因为对广大程序员来说，都没有必要重复制造轮子的必要。所以，我认为学习技术应该是两方面一起着手，一部分是面向对象的分析和设计，这部分与语言无关，是属于内功的范畴。另一部分就是选择一个合适的面向对象的语言，精通其语法，搞清楚编程模式和各类关键字的使用含义，了解如何最大化去发挥语言的效率和生产力。

本文链接

走进单元测试（1）：为什么难以广泛应用？

2010-04-25T00:31:00Z

这几天在北京参加Qcon，觉得Scrum和敏捷在这里提到的比较多，而单元测试作为敏捷方法的一个重要配套工具，了解和真正进入实施的却并不是很多。

这里并不想告诉你如何做单元测试，这样的文章园子里已经一搜一大把，我没有再写这种的必要。开这个系列，首先是因为我进入了公司的技术创新组，目前主要负责单元测试这块，以期记录自己的成长；二是希望借这个系列，能够为大家带来一些真实的单元测试用例的设计方法和在设计用例中遇到的问题，以及解决问题的方法。

在我6年的技术工作中，如果问我什么技术对我的影响最大，我会毫不犹豫的说是单元测试。我比大多数人幸运的地方就是我的第一份写代码的工作就是编写单元测试；没错，是单元测试，尽管不是TDD的实践。但至少为我理解TDD打下了一个坚实的基础。而6年来，我一直希望能够有一个地方可以真正的将这些东西用起来，现在来看暂时算是等到了希望。

我辗转过很多公司，也曾经提过很多次关于单元测试的问题。然而每每提及的时候会得到支持，但最终实施都不了了之。我一直在思索为什么？为什么一个明明觉得很好的东西大家都嘴上说好而就一直不肯去实践？下面是我认为的几个原因：

1、开发成本的高昂。单元测试会加重开发人员的负担，因为有了更多的代码需要编写。而这种成本的增加在小作坊是一个很重的负担，毕竟对于他们生存是第一要务。即使是在大公司，鉴于很多人没有这样的经验，因此培训和指导如何编写单元测试也是一块很大的成本。

2、时间上的紧迫。从一个软件项目的角度来看，尽管编码所占的时间并不多。但如果是一个小的软件作坊形式的公司，其生存的要点在于能够短平快的做完项目，实施单元测试会延长项目的交付时间。即使是在一个比较规范性的公司，由于客户或者内部需求的时间压力，也很多时候只能选择放弃采用这样的过程，毕竟满足客户需求才是项目的最终目标。

3、开发人员的素质。为什么会有这一条，是因为接触过很多人开发人员，他们仅仅把完成任务当做目标，他们希望的就是尽量以自己熟悉的方式来尽快完成任务，剩下的时间就可以做自己的事了。而这部分人恰恰却是推动过程中的最大阻力。如何说服他们，采取什么措施，后面的系列可能会有这方面的思考。

鉴于中国的软件公司多数还处于小作坊时代以及开发人员的素养还有待提高，我一直比较悲观的认为，就不说敏捷了，就是单元测试的普及，在中国还有很长的路要走。我也希望自己的这个系列，能够为这个事情的推动尽自己的绵薄之力！

本文链接

高级语言发展之回归人类思维——听老赵的Session有感

2010-04-18T12:19:00Z

周末去听了老赵的《Why Java sucks and C# rocks》的演讲，觉得非常的精彩。先说明这个题目的确很好很强大，直接对Java程序员施放了嘲讽。其实关于这个题目，明眼人一眼就知道老赵本人并没有让Java程序员都转到C#的意思，更没有大家把Java平台都扔了的意思；只是让那种如同“看别人写的代码都是垃圾”的那种程序员所特有的傲气蒙蔽的人，才会有上面的想法。

个人认为老赵演示中对我而言比较精彩的部分有两块：一是用yield关键字大大简化了异步编程的困难，二是C# 3.0所提供的LINQ功能。写过异步的人应该都明白异步相对于同步的复杂性，但yield关键字直接讲异步的编程模型转换为了同步的编程模型，很神奇。至于第二个部分LINQ，应该熟悉的人比较多，但其中举得例子一句话搞定一个功能让人觉得非常的兴奋，这正是我一直所期盼的一种写代码的方式！

就用其课程中的一个例子来说明：比如将bbcode转换为html这件事情，平时的做法就是先转为html，然后再消除掉一些攻击脚本，最后删除空格。

如果使用C# 3.0以下版本：

Util.StripWhites(
    Util.StripXss(
        Util.BbToHtml(bbcode)
    )
)

而使用C# 3.0：

bbcode.BbToHtml().StripXss().StripWhites()

通过比较明显的出，C# 3.0的扩展方法的支持可以使得代码就如日常做事的思维一般，这是何等的一个进步！

我曾经对面向对象进行过一些探索，如何向人解释面向对象这个东西的确是很难。在经历过多次的尝试和自己的总结之后，其实面向对象的思维很简单，就是你日常做事情是怎样做，那么面向对象的思考也跟其一样。可以这么说，拿到一件事情，抛弃计算机，想想在没有计算机的情况下我该如何做这件事，这本身就是一个面向对象的思维，剩下的就是将这种思维转换为计算机实现。因此，C# 3.0的这个特性让我觉得特别的兴奋，因为如果采取合适的封装和抽象，那么对于使用你代码的客户来说，他只需要知道我该做些什么来完成工作，而不是去思考如何去做！其实仔细想想，这不正是高级编程语言的任务吗？让你关注于你的逻辑，而不是具体的计算机实现。所以我认为，高级语言的发展目标，便是回归人类自身思维。直到有一天，任何用户拿到计算机，可以根据自己需要做什么而去编写代码，那便是编程语言发展的终极形态！

既然说到这里，就忍不住不得不狠批一个现象：很多程序员借性能之名来阻碍生产力的提升。其实上面的C# 3.0的特性，我是早已知晓，但限于平台因素平时的开发环境都仍然是在2.0上，曾极力推荐将环境升级到3.5（因为3.5是2.0的一个超集，基本不存在兼容性问题），以带来生产力的巨大提升，但被很多人以性能为名压住。从理论上来说，LINQ的一些东西的确是比自己写循环来的慢，因为有很多的委托需要创建。但相比于生产力的巨大提高，那么一点微小的性能开销真的很重要？而且，很多时候性能的问题在于设计，而不是因为使用了某些高级特性！

本文链接

缺乏自信怎么办？

2010-03-19T17:17:00Z

今天跟一个同事出去吃饭，路上谈到了没有自信怎么办的问题。

对于这个问题，我的观点是最简单有效的解决办法，就是做培训或者主持活动。其实每个人都有不自信的时候，仔细的去分析一下在你不自信的时候的心理活动，其实会发现原来都是面子问题。举个例子：公司的网站出现了一个问题，我已经知道了问题的解决方案，但是就是因为没有自信使我失去了解决问题的资格，最终这个功劳被别人夺去了。

我们来尝试分析下这个案例中的心理活动：从我个人的经验来说，遇到这种情况基本会有如下问题：

如果我也没解决怎么办？
是不是给领导造成不好的印象？
领导会不会再把这件事跟别人说造成连锁反应？
解决了同事会不会眼红？
没解决会不会被同事笑话？

其中1、2、3、5都是面子问题。分别对每个问题做一个针对性的心理解答：

出了问题我站出来解决是责任感，站出来解决说明我有心，但不能解决只是说明我能力不够，以后会努力。
领导会觉得你很热情，有问题会站出来尝试解决，责任心比较强。
一般来说，没人会关心这些事情。即使关心了，随便打趣下就能避开的话题，又何必担心？
谁让你自己不站出来，有本事你也站出来解决啊？
这个同3的解答

那么，当你把这些问题从这个角度来想之后，便觉得不是问题了。而真正造成这些心理困扰，是因为在完全面对一群陌生人的情况下，正常人都会有一种状态失衡，因为陌生人之间总会有一个场限制着你的发挥。而一旦进入了状态，这种限制就不是那么的强烈了，很自然的就能步入到正轨上。所以，放下面子，上台讲课或者主持活动，是克服这种心理障碍的最佳实践。很多人其实说是可以说的，但每每担心别人提刁钻古怪的问题怎么办。对于这类问题，一定要很坦然的用于承认自己的才疏学浅，不知道就是不知道，可以说有空研究研究。最好不要不懂装懂，因为下面很可能有人就是这方面的专家，然后你就会死的很难看。其实出现不懂很正常，没有人对素有的领域都有涉及。

其实，我们的教育体制就存在这样的弊端。很多时候在课堂上，如果回答某个问题答错了，会造成哄堂大笑而教师并不加以制止，这其实是一个很错误的行为。本来，表达出自己的想法就是一个很需要锻炼的事情，然后在这样的气氛中，教师如果不加以制止，后面的结果就是愿意表达的学生越来越少，然后课堂气氛沉闷。好在中国目前还是应试教育，这些教师暂时还可以衣食无忧。因此，目前的社会环境下，还是多多依靠父母来帮助形成能良好表达自己想法的习惯。

本文链接

梦话对象之三：三要素的差异与统一

2010-01-31T10:28:00Z

这篇说说分类的问题。面向对象的设计从根本上就是一个选择分类的过程，而在分类的过程中，只要不出逻辑上的问题，任何分类都是正确的。所以说，对一个系统进行面向对象的建模，1000个人能建立出1000个不同的模型，但只要建立的模型中没有逻辑问题，都不能说这个建模是错的。只有对系统需求建模的适合与不适合，易扩展与不易扩展之分。而对于开发人员来说，大多数人的思维习惯都是非黑即白的思维，这大概也是真正的对象技术...