博客园_金旭亮

前几天收到了一个在职普通程序员的邮件，在邮件中他说两次报考我们学校计算机专业研究生，但总是惨败而回，第1年总分考了250，砸在政治和数学上，努力复习了一年，又是砸在数学上，总分才285……。我几乎能真切地体会到他那种沮丧和不甘心——为什么我经过一年的辛苦努力，却还是原地踏步并在同一个地方跌倒两次？同样的疑问我也曾经问过自己无数遍，因为我也是连续考研三次才通过的。

我是一个“智商平平”的人，但还算比较努力，有幸“混入”高校，成了一名讲授软件开发技术的普通教师。任教8年多以来，接触到了相当数量的学生，有了一些教学经验，同时我还阅读了一些有关教育学心理学方面的书籍和文章，一直在思索这样的一个问题：

“智商平平”的人应该如何自学软件技术，而我又应该如何教“智商平平”的人学会软件开发技术？

我觉得“学”与“教”其实是同一个问题的两个不同侧面，都遵循类似的学习与认知规律。

这里首先要对“智商平平”作个界定。

国外比较重视智商测定，并已发展出了比较成熟的智商测试机制，往往能给某人以一个比较准确的智商测试成绩，这些成绩可被用于高校招生、企业录用员工、军队征兵等。但我们中国这一前提就不存在，比如笔者就从未做过智商测试。

尽管无法用数字精确地说明，但我们还是可以凭感觉和观察来得出一些结论——某些人很聪明，某些人则比较笨……，比如在同样一所高中里学习的学生，有的能在全国数学、物理等竞赛中屡屡得奖，不用参加高考就能保送到名校，之后顺理成章地继续攻读研究生，甚至能到国外名校去继续深造，考试对于他们来说实在是小菜一碟，想得个低分都不容易……，而许多普通学生，哪怕每天只睡几个小时，日以继夜地做题，高考也得不了几分。

记得我高考那年有位兄弟就是个典型例子，当我等正在题海中挣扎的时候，这位老兄却捧着本《神雕侠侣》畅游武侠世界，末了人家高考总分还是名列前茅。更有趣的是这位哥们后来学的是经济管理方面专业，毕业后工作没多久突然决定要考研，仅复习半年，就跨专业成为了一名计算机专业研究生……

还有我的一位师兄，在微软研究院“混”，他读博的几年，发论文就象我等编写几个小程序业似的，拿博士学位如探囊取物，这位兄弟给我印象最深的地方在于他曾经想出国准备GRE，一天背300多个单词。我的神啊，我一天能记100个就不错了，而且第2天还没准会忘了80个！

只要留心一下，会发现我们可以在身边找到许多类似的例子，这些例子说明了一点：人与人之间是存在着差异的，各有所长，也各有所短。我觉得大家公认为聪明的人，其智商应该都属于比较高的，可以合理地假设此人的智商属于人群中最高的10%（即十里选一）那一群体，那么正常情况下，他进入重点大学学习深造应该不成问题，如果是百里选一，那么他进入名校应该问题不大。

除了智商偏低的人（应该也有10%），中间约占80%的应该是“不笨也不聪明”的普通人，而我也属于这个群体，所以我最关注的也就是“普通人”的学习问题。

软件行业从业人员中有两种典型的类型：科研人员与软件工程师。个人感觉，从事科研工作并取得相应成就的人，应该是属于人群中那10%的智商最高的群体，而软件工程师这一工作，则80%的普通人经过训练都可以胜任，但要达到一流的水平，对其智商的要求也是相当高的。

科研领域取得成就的人，还有那些优秀的软件工程师，突出的一点是他们的抽象思维能力较高，而体现抽象思维能力水平最直接的标志，就是数学。我发现计算机科学研究弄到后头，来来回回摆弄的都是数学；另一方面，对于高水平的软件系统开发，与数学有很密切联系的计算机算法、数据结构、编译原理等比较抽象复杂的计算机科学理论的作用也开始突显。

前段时间，机械工业出版社送给我了一本《深入计算机系统（第2版）》，这本书以程序员的视角从底向上地介绍计算机系统的各个方面，许多人说这是本好书。有趣的是，在新浪微博上我看到有网友说：“这本书太枯燥了，根本看不下去”。我为此也发了一条微博和他一起交流：

觉得技术书枯燥与没兴趣，可能关键在于你实际开发经验不多，所以缺乏理解这些书所需的一些基础。个人体会，当某本书大多数人说好，而自己觉得很枯燥的，日后很有可能会发现原因在于自己第一次阅读时还没有具备看懂它的基础，无法引发共鸣……

这的确是我亲身体会。许多复杂抽象的计算机科学理论，在自己还没有具备相应的基础前，别去碰它，否则，收获的将只有挫折与失望。

举个例子：还没有使用编程语言亲自编程的体验，《编译原理》是学不会的；有的人高中数学其实都没掌握好，却想通过阅读《算法导论》来成长为一名算法高手，似乎也没这可能；同样的，如果没有足够的开发设计经验，却抱本《设计原本》（The Design of Design: Essays from A Computer Scientist）来啃，我只能对着你长长地叹息一声……

大家都急，想迅速成功，想迅速达到自己的目标，都等不了了，我也一样，但世界自有其规律，主观归主观，客观归客观，客观世界不会“听从”人的主观愿望，“人有多大胆，地有多大产”注定是一个神话……

很明显，每个人都应该想办法弄清楚自己的“家底”，然后选择最适合自己的学习方式。

时间倒推30年，那时只有很少数的人可以上大学，这些人绝大多数属于人群中较聪明的那一族，所以，整个大学教育体制其实偏向于“精英教育”，其主要目的是培养精英和栋梁之才。而21世纪以后，大批的普通智商的学生进入校园，从总体上来说，除了少数名校，大学教育应该转向“平民教育”。而中国教育最大的问题也在这：由于众所周知的原因，很多大学属于“反应迟缓”并“拒绝改变”的“恐龙”，仍然采用“精英”教育的传统方式方法教学，这本质上就是将原来只针对少数优秀学生的教育方式与方法给“人为放大”，具体现象之一就是原先的十几人的小班变成了几十人甚至是上百人的大班。要知道，近十多年以来中国高等教育的重大变化不仅仅体现在学生规模的激增上，还体现在学生平均智商与素质的“普通化”。

用“放大”的精英模式教育大批的“普通人”，正如没有刘翔的身体素质，却按照刘翔的训练方法训练，用脚思索都会发现这是不太对头的。

拿计算机专业来说，近些年来虽然在不断的调整，但目前仍然是“理论”重于“实践”。前面也说过，复杂抽象的计算机理论课，绝不是那么好学与好理解好掌握的，有些课程，真的应该只针对那些比较聪明的学生来讲，而即使是所有学生都要学的同一门必修课程，针对不同层次的学生，也应该有不同的讲法。

好了，就软件这个领域，“智商平平”的普通人应该如何有效地学习？

我觉得，“智商平平”的普通人学软件，在一开始应该避开那些复杂抽象的要求有较高学习能力的计算机科学理论课程，特别是那些要求有实践作基础的课，应从能“即时反馈”并能“立即用于开发实践”的专业课程与开发技术入手。

举个例子，是否学生要学的第一门编程语言必须要是C语言？这个问题就可以讨论。我个人觉得，尽管从C入手是经典途径，已经多年的实践检验，但这并不排斥可以采用其他的方式。比如，能否一开始就直接学Python？诸如Python这类的动态编程语言，具有语法简单、反馈迅速的特点，很有助于学生理解编程语言，培养软件开发的思维方式。我还尝试过一开始就直接让学生学习面向对象的编程语言（比如C#），哪怕他们没学过C，但使用Visual Studio这种高度智能化的开发环境，以可视化的方式设计软件，最终能开发出真正可以在日常使用的软件，对学生还是有着很强的吸引力，不象C，学了一个学期，学生还只是编写几个“黑底白字”的小程序，根本就不知道现在的可视化软件是怎么写出来的，太有挫败感了。特别是C++，我觉得通过它来给刚学完C的学生讲面向对象编程，实在是个杯具，有几个学生真能在短短的一学期课程中搞得掂C++这么复杂的编程语言，而且还要求他们理解面向对象的思想并能用它写出真正可用的软件？我觉得，学完C之后，用Java或C#课程来帮助学生掌握面向对象的编程语言与思想，要比C++好得多。而且学生通过Java或C#掌握面向对象的基本思想与理论之后，再去学C++就好多了。

计算机科学与技术有很多个子领域，学习顺序其实是很重要的。

我个人认为，计算机专业的学生应该在大一，最晚不要拖到大二，就掌握一门主流的编程语言和开发工具，Java和C#是两个好的选择，为什么要这么做？道理很简单，你掌握了它们，就可以迅速地投身于软件开发实践，并且有助于掌握后继的计算机专业课程理论。

举个例子，在大一大二就使用Java或C#写过多线程程序的学生，在学习《操作系统》这门课程时将要轻松得多，而能在大学低年级就开始编写游戏的学生，往往会对《数据结构》、《人工智能》、《图形图像处理》等理论课程感兴趣，他就会主动地去学习相关的游戏开发平台与工具，学习C++这种复杂的编程语言就会有强大的动力，因为许多游戏引擎是采用C++编写的……。

在“无网不胜”的网络时代，学生掌握了Java、C#或C++之类主流的编程语言之后，他就具备了进军网络开发领域的可能，此时，他再学习《计算机网络》这门课程就水到渠成了，他可以将已具备的软件开发能力与相关计算机网络理论结合起来，自己开发一个Web服务器，自己开发一个QQ，自己开发一个网络游戏，自己写个互联网工具，自己写个跑在手机上的应用……，其所获得的成就感是枯燥的“空对空”理论学习所无法比拟的。

写到这，不妨作个阶段的小结：

软件技术怎么学？如果你属于“智商平平”的普通人，那么，请从动手编写小程序入手，在开发实践的基础上去学习计算机科学理论。

在具体技术领域的学习上，需要谨慎选择学习的方式与材料，当此领域内的某本经典著作你怎么也看不懂或觉得很枯燥时，请另选一本比较浅显的，或者咨询一下这个领域内的人，了解一下掌握这个领域的技术需要哪些前提，把这些欠缺的东西补上之后，这些书你就看得懂了，甚至是看得津津有味。

这里谈谈我的体会。我以前从未觉得有必要去了解各种网络协议的细节，但后来有了一些网络应用程序的开发经验，并且尝试分析.NET基类库中相关网络组件的设计时，就体会到如果不了解网络协议的特点，就难于了解为什么设计者会以这种方式来封装网络功能。

蔡学镛先生曾发过一篇微博，推荐大家看看《HTTP: The Definitive Guide》一书，后来我在网上找到了这本详细介绍HTTP协议各个方面技术细节的书，翻阅之后，对原先的许多有关Web开发的问题有了新的看法，很有收获。然而，如果某人没有开发Web应用程序的经验，恐怕又会说这本书“枯燥”了。

如果阅读本文的还是在校学生，他们可能说：“老师，我们没有选择课程与学习方式的余地，学校安排了这么多的必修课程，不硬着头皮去啃，我怎么毕业啊？”

而另一些已经工作的朋友则会说：“每天都有那么多的工作，很难有这个时间和精力按照你所说的方法去学习。”

这确实是个问题，但我也没解决办法，因为我们所处的环境我们没有选择权。在这里，我只是向大家描绘一下：我认为合理的软件技术学习方式应该是怎样的。而且我也看到了，正是因为违背了这些教育与学习的基本原则，中国大学才被国民“千夫所指”。这么多年来，中国大学在“培养真正的精英与栋梁之才”方面国民是不满意的（不然为什么会有钱学森的“世纪之问”并引发广泛共鸣？）。事实证明，中国大学这么些年来，精英没培养出来，大批的普通学生也没教育好，他们中的许多直到毕业也没有能掌握一些必要的职业技能，高不成低不就的，找工作困难，另一方面，IT企业许多岗位缺人却同样找不到能胜任工作要求的人才，整个一“死循环”……

莫谈国事，还是聊聊“笨”与“聪明”的问题。

前面我说过了，整个人群总可以划分为10%比较聪明的，10%比较“笨”的，余下80%的“普通人”。其实所谓“比较聪明”的人，主要体现在他反应快，记忆力强，抽象思维水平高，学习能力强，掌握新知识、新技能的速度快，投入少而收益大，……，但这并不意味着许多知识与技能只有聪明人才能掌握。

对于占80%的普通人而言，绝大多数聪明人所掌握的知识与技能也是完全可以掌握的，只不过需要更长的时间、更多的精力和更强的毅力，套句老话，就是要“笨鸟先飞”。

如果把智商高的那批人比作兔子，普通人比作乌龟，那么从理论上讲，兔子能到的地方，只要给与足够的时间，乌龟也是能爬到那的。当然，由于人的生命有限，对于那些从不偷懒的兔子，乌龟要达到这些兔子所到达的地方，是不可能的。然而老天比较公平，人性也有弱点，本身跑得快又不偷懒的兔子，在兔子这一群体中比例并不高，许多兔子往往会由于看到那么多的乌龟落在自己的后面，他们做事的方法那么低效那么笨，素质也差，就充满了优越感，往往会变得浮燥，不愿再辛勤努力了，结果他们最终也没有取得大的成就。相反，乌龟就没有任何骄傲的资本，乌龟中的那些上进的人，往往具有很强的坚持精神，不停地爬呀爬的，而且在爬的过程中他们会不断地动脑筋想点子，怎样爬得更快？结果大家都知道，有些乌龟，爬到了许多兔子所没能到达的地方。

金庸先生的名著《射雕英雄传》其实是一个经典的“龟兔赛跑”故事，比较“笨”的郭靖，其最终的成就比“聪明”的杨康要大得多，而小说中所描写的郭靖的学艺过程与心理活动和体验，实在是太切合实际了。我推荐所有的“乌龟”们好好地读读《射雕英雄传》，重点看看郭靖的成长过程。我有时在想，金庸先生是怎样的一个人，能将一个“笨人”的故事讲到这般的精彩？我觉得说金庸先生属于“跑得快的兔子”行列大家应该不会有异议，但我必须同时指出，他绝对是一只不偷懒的兔子，想想看，有几只偷懒的“兔子”能写出14部雅俗共赏的小说？更关键的是，这些小说部部不同，每部都有自己的风格，创新、创新，还是创新，绝不重复昨天的成功，结果让金庸先生在武侠小说领域成为他人难以企及的高峰……。

所以，即使是天才，不努力，也是废材，即使“智商平平”，坚持下去，也能爬得很远，但对于那些勤奋努力的天才，我想，大家一定会怀着敬意地提到他们的名字……

这就是“聪明”与“笨”的辩证法。

=========================================================================

附录：

这个学期我给本校成教学院“高中起点大专班”的学生讲授《C#面向对象程序设计》课程，为此，我设计了一套针对零面向对象编程基础的学生（但要求他们学过C语言）学习面向对象技术的教案，今天发布前两讲《C#程序设计语言与.NET面向对象程序设计概述》和《C#程序设计语言基础》。

欲作其事，先正其意。因此《概述》一讲中我分析了当前计算机教育的现状，介绍了软件技术的学习方法；而在《C#程序设计语言基础》一讲中，我针对学生几乎没有写过程序的现状，我采用了现场编程演示和现场上机练习的教学方式，要求学生自带笔记本电脑，跟着教师同步地在课堂上键入代码，然后马上现场完成一些小的编程任务的方式，有问题及时反馈，现场解决，同时留了课后作业。

我希望这些课程能帮助学生迈入软件开发的大门。

后续的课程教案将陆续发布，可供讲授《C#面向对象程序设计》课程的教师参考，也可以作为C#的初学者的自学资料。

请点击以下链接下载教案及相关源码（在博客园）。

1 《C#程序设计语言与.NET面向对象程序设计概述》

2 《C#程序设计语言基础》

本文链接

《.NET 4.0网络开发入门之旅》7：填平缓冲区陷阱

2011-01-18T06:58:00Z

《.NET 4.0网络开发入门之旅》——

填平缓冲区陷阱

注：

这是一个针对 网络开发领域初学者 的系列文章，可作为《.NET 4.0 面向对象编程漫谈》一书的扩充阅读，写作过程中我假设读者可以对照阅读此书的相关章节，不再浪费笔墨重复介绍相关的内容。

对于其他类型的读者，除非您已经有相应的.NET 技术背景与一定的开发经验，否则，阅读中可能会遇到困难。

我希望这系列文章能让读者领略到网络开发的魅力！

另外，这些文章均为本人原创，请读者尊重作者的劳动，我允许大家出于知识共享的目的自由转载这些文章及相关示例，但未经本人许可，请不要用于商业盈利目的。

本文如有错误，敬请回贴指正。

谢谢大家！

金旭亮

=================================================

点击以下链接阅读本系列前面的文章：

1 《开篇语—— 无网不胜》

2 《 IP知多少》

3 《我在“网” 中央》

4 《与Socket的第一次“约会” 》

5 《与Socket的“再次见面” 》

6 《“麻烦“的数据缓冲区》

=========================================

    前一篇文章《“引发麻烦”的缓冲区》，介绍了TCP Socket编程数据缓冲区必须要注意的两个问题：
    （1）TCP不保存消息的边界，因此，服务端必须能有一种方法从收到的数据中正确地“切分”出一条完整的消息
    （2）客户端与服务端的数据发送和接收速率应该匹配，否则，有可能出现“黏包”和“丢包”现象。
    那么，我们怎么样来解决这两个问题？
    1 为要传输的多条消息规定统一的长度
    这是最直观的方法，我们可以事先制定一个消息代码表，每个消息代码都代表不同的含义，比如“000”代表“初始化”，“999”表示“结束”之类，这种思想在HTTP中我们也可以看到，比如HTTP就定义了一些状态码，200代表“OK”，500代表“服务端内部错误”。还可以参考CPU指令的设计方法，自行制定一些定长的“消息代码表”。
    由于所有消息长度都一致，服务端的处理将变得非常简单，它将收到的数据按约定的长度“切块”即可。
    请看示例解决方案FixedSizeMessageDemo。客户端需要将一个int数组发给服务端，服务端使用一个MemoryStream保存这些数据，然后按照4个字节一块一块地读取它们，正确地还原数据。
    以下是服务端的代码框架：

    int recv = 0;
    //用于暂存数据的内存流
    MemoryStream mem = new MemoryStream();
    while (true) //接收客户端发来的所有数据
    {
        //将接收到的数据保存到内存流中
        recv = client.Receive(data);
        mem.Write(data, 0, recv);
        if (recv == 0) //数据接收完毕，断开客户端 {0} 连接
        {
            client.Close();
            break;
        }
    }
    mem.Seek(0, SeekOrigin.Begin);
     long datalength = mem.Length;
     BinaryReader reader = new BinaryReader(mem);
     Console.WriteLine("接收到数据为：");
     while (reader.BaseStream.Position < datalength)
     {
        //切分数据
        Console.Write("{0},", reader.ReadInt32() );
    }
    reader.Close();

    2 给消息附加长度信息
    使用定长的消息虽然可以简化服务端的代码，但却受到很大的限制，而且如何设计一整套消息代码也是件比较麻烦的事。
    一种比较好的方式是将两者结合起来，在每个消息开头附加一个固定长度的“消息长度”信息，这样，服务端就知道本消息到底有多长。
    HTTP协议就是这么干的，在HTTP响应消息的头部（Headers）中有一个Content-length项，通知浏览器HTTP消息的主体（Body）部分占多少个字节。

    提示：
    HTTP是应用层协议，它在底层依赖TCP协议完成HTTP消息的传输。

    首先，我们设计一个发送数据的静态方法：

    // 发送变长的数据，将数据长度附加于数据开头
    public static int SendVarData(Socket s, byte[] data)
     {
            int total = 0;
            int size = data.Length; //要发送的消息长度
            int dataleft = size;     //剩余的消息
            int sent;
            //将消息长度（int类型）的，转为字节数组
            byte[] datasize = new byte[4];
            datasize = BitConverter.GetBytes(size);
            //将消息长度发送出去
            sent = s.Send(datasize);
            //发送消息剩余的部分
            while (total < size)
            {
                sent = s.Send(data, total, dataleft, SocketFlags.None);
                total += sent;
                dataleft -= sent;
            }
            return total;
     }

    仔细看一下注释，上述代码完成的工作“一目了然”，无需废话。
    以下静态方法则完成接收并切分消息的工作：

        // 接收变长的数据，要求其打头的4个字节代表有效数据的长度
        public static byte[] ReceiveVarData(Socket s)
        {
            if (s == null)
                throw new ArgumentNullException("s");
            int total = 0; //已接收的字节数
            int recv;
            //接收4个字节，得到“消息长度”
            byte[] datasize = new byte[4];
            recv = s.Receive(datasize, 0, 4, 0);
            int size = BitConverter.ToInt32(datasize, 0);
            //按消息长度接收数据
            int dataleft = size;
            byte[] data = new byte[size];
            while (total < size)
            {
                recv = s.Receive(data, total, dataleft, 0);
                if (recv == 0)
                {
                    break;
                }
                total += recv;
                dataleft -= recv;
            }
            return data;
        }

    可以看到，由于“事先”知道消息长度，接收消息变得非常直观。
    为了方便重用，我们可以把上述两个静态方法放到一个静态类SocketHelper中，并且将此类添加到MyNetworkLibrary类库中。以后的例子，还会用到这两个方法。
    示例解决方案VariableLengthMessageDemo展示了使用上述方法发送变长数据。
    3 “一问一答”的数据传送
    仔细分析一下TCP协议，会发现它其实是通过“一问一答”的“握手”方式实现数据的可靠传输。
    我们可以依葫芦画瓢，在更高的层次实现“一问一答”的通讯，简单地说：

数据发送方发送完一条消息之后，就停下来等待接收方发来一个确认消息，收到之后，再发送第二条消息。
数据接收方由于确切地知道发送方一次只发送一条消息，所以，它可以“放心大胆”地不断接收数据，直到receive方法返回0为止，然后，再向发送方发送一条“消息已收到”的“通知”，然后，准备接收下一条消息。

    对于这种方式的数据通讯，每条消息可以不必附加上长度信息。
    请看示例解决方案SendAndWaitDemo。客户端发送数据完毕之后，发送一条“SendFinished”消息。服务端接收完数据之后，发送一条“ReceiveFinished”消息。客户端没收到“ReceiveFinished”消息，就不会发送新的消息。
    就请读者自行阅读源码，不再赘述。

    4 开发一个“网络计算器”
    前面介绍的许多示例程序都是出于学习目的而设计的，几乎没有什么实际用途，在学习了这么多的Socket编程知识之后，我们终于具备了开发一个“有点用”的网络应用程序的前提。
    我在《.NET 4.0面向对象编程漫谈》一书的第24章，介绍了一个支持加减乘除和多级括号的“四则运算计算器”，并且将相关的前序、中序表达式解析算法封装成了一个程序集MathFuncLib.dll。我们就通过重用这个程序集，加上新学的Socket编程技术，实现一个“网络版四则运算计算器”（示例程序 NetworkCalculator）。

图 1

上述示例程序客户端使用前面介绍的SendVarData方法发送表达式，使用ReceiveVarData方法接收服务端发回的计算结果。服务端使用 MathFuncLib程序集封装的中序算法解析表达式，它的表达式接收和发回计算结果也是用的ReceiveVarData和SendVarData方法。
请读者自行阅读源码。

    最后留几个作业：
    请读者应用《.NET 4.0面向对象编程漫谈》中介绍的多线程技术，改造NetworkCalculator示例程序：
   （1）让服务端可以同时响应多个客户端的表达式计算请求
   （2）将客户端由Console程序改为Windows Forms或WPF程序，在后台启动线程发送和接收表达式及计算结果。

再来点难度大的：

    为了提升处理效率，允许客户端将“多条要计算的表达式”打包在一起，一起发送给服务端，服务端计算完毕之后，再把所有结果也“打包”一次性地发回给客户端。
    应用本文所介绍的技术，现在读者您能开发出这样的程序吗？
    下一讲，我们将暂时“告别一下” TCP，而去领略一下另一个非常重要的协议--UDP的风彩！

===============================================================================
    有关“四则运算计算器”示例程序和MathFuncLib.dll的详细介绍，请看《.NET 4.0面向对象编程漫谈》一书的第24章，读者可以从书的配套资源包中找到下载链接。以下列出博客园中的下载链接：

《从面向对象到SOA》正文及源码
(http://files.cnblogs.com/bitfan/%e4%bb%8e%e9%9d%a2%e5%90%91%e5%af%b9%e8%b1%a1%e5%88%b0SOA.rar)

以下是本文所附之示例源码的下载链接：

示例源码下载链接

本文链接

一个多线程示例程序的BUG修复

2011-01-14T05:41:00Z

一个多线程示例程序的BUG修复

在《.NET 4.0面向对象编程漫谈》的《应用篇》一书中，我介绍了一个使用“信号量（Semaphore） ”同步对象模拟多人使用图书馆公共计算机的UseLibraryComputer示例（参看17.3.3节《管理多个共享资源--Semaphore》）：

图 1 UseLibraryComputer示例

    此示例程序定义了一个Computer类代表计算机，使用一个Computer对象数组（取名LibraryComputers）保存图书馆所拥有的多台公共计算机（即Computer对象）。
    示例程序动态创建多个线程模拟多用户（每个线程代表一个用户）同时访问3个Computer对象，为了同步这些线程，创建了一个Semaphore对象（取名sp），以下为示例中的线程函数：

        static void UseComputer(Object UserName)
        {
            sp.WaitOne();//等待计算机可用
            //查找可用的计算机
            Computer cp=null;
            for (int i = 0; i < ComputerNum; i++)
                if (LibraryComputers[i].IsOccupied == false)
                {
                    cp = LibraryComputers[i];
                    break;
                }
            //使用计算机工作
            cp.Use(UserName.ToString());
            //不再使用计算机，让出来给其他人使用
            sp.Release();
        }

    Computer类中定义了一个IsOccupied字段用于标识此计算机是否被占用，其Use方法模拟表示用户正在使用计算机的过程：

    //是否被占用
    public bool IsOccupied = false;
    //读者在使用计算机
    public void Use(String userName)
    {
        Console.WriteLine("{0}开始使用计算机{1}", userName,ComputerName);
        IsOccupied = true; //设置占用标记
        Thread.Sleep(new Random().Next(1, 2000)); //随机休眠，以模拟人使用计算机
        Console.WriteLine("{0}结束使用计算机{1}", userName,ComputerName);
        IsOccupied = false; //设置空闲标记
    }

    前述示例代码中隐藏着一个BUG，请看图2：

图 2

    BUG隐藏于何处？
    请读者先仔细阅读原示例程序，尝试着自己定位并修正此BUG。
    以下是BUG分析：
    这里面的关键是Semaphore对象可能会一次允许多个线程投入运行，而这些投入运行的线程都需要访问LibraryComputers数组（请参看前面的UseComputer静态方法）。
    假设有3台计算机空闲，当示例程序第1次运行时，会有3个线程同时访问LibraryComputers数组，完全有可能两个线程都发现第1台计算机是“空闲”的，于是它们将调用此Computer对象的Use()方法。
    这就是BUG所在。
    定位BUG之后，要修正它就很容易了--互斥访问LibraryComputers数组即可 。
    修改后的线程函数如下：

        static void UseComputer(Object UserName)
        {
            sp.WaitOne();//等待计算机可用
            Computer cp=null; //查找可用的计算机
            lock (LibraryComputers)
            {
                for (int i = 0; i < ComputerNum; i++)
                    if (LibraryComputers[i].IsOccupied == false)
                    {
                        cp = LibraryComputers[i];
                        cp.IsOccupied = true; //设置已被使用标记
                        break;
                    }
            }
            cp.Use(UserName.ToString());//使用计算机工作
            sp.Release();//不再使用计算机，让出来给其他人使用
        }

    注意：上述代码中不仅添加了锁，还将修改Computer对象占用标记的代码（原先在Computer.Use方法中）也移到这里来了。
    以下修改后的Computer.Use()方法：

    public void Use(String userName)
    {
        Console.WriteLine("{0}开始使用计算机{1}", userName,ComputerName);
        Thread.Sleep(new Random().Next(1, 2000)); //随机休眠，以模拟人使用计算机
        Console.WriteLine("{0}结束使用计算机{1}", userName,ComputerName);
        IsOccupied = false;
    }

    最后留给读者一个思考题：
    Computer.Use()方法中修改IsOccupied字段的那句代码需要锁定本对象吗？

============================================================================

点击下载本文示例源码

附注：
此示例程序中的BUG由CSDN网友“笑傲江湖 ”发现，是本人在设计示例时的疏漏，在此特别感谢“笑傲江湖" 网友的热心！也欢迎各位读者或业界朋友多指正本人拙著中的错误，互相探讨技术，共同进步。

本文链接

《.NET 4.0网络开发入门之旅》6：“麻烦”的数据缓冲区

2011-01-10T04:05:00Z

点击以下链接阅读本系列前面的文章：

   1. 《开篇语—— 无网不胜》
   2. 《 IP知多少》
   3. 《我在“网” 中央》
   4.《与Socket的第一次“约会”》

5. 《与Socket的“再次见面”》

点击以下链接阅读《.NET 4.0网络开发入门之旅》的第6部分：

　6.《“麻烦”的数据缓冲区》

此文内容比较简单，恐怕不合园子里高手的口味，而且同一文章贴两遍麻烦，所以上述文章发在CSDN。

本文链接

《.NET 4.0网络开发入门之旅》5：与Socket的“再次见面”

2011-01-05T08:10:00Z

《.NET 4.0网络开发入门之旅》系列文章

点击以下链接阅读本系列前面的文章：

   1. 《开篇语—— 无网不胜》
   2. 《 IP知多少》
   3. 《我在“网” 中央》
   4 《与Socket的第一次“约会”》

点击以下链接阅读《.NET 4.0网络开发入门之旅》的第5部分：

5. 《与Socket的“再次见面”》

此文内容比较简单，恐怕不合园子里高手的口味，而且同一文章贴两遍麻烦，所以上述文章发在CSDN。

本文链接

软件天才与技术民工

2010-12-29T17:35:00Z

软件天才与技术民工

——薛涌《天才是训练出来的》读后感

金旭亮

长期以来，“软件业”一直被视为“智力密集”型的“朝阳”产业，大多数从业者都受过高等教育，其平均素质居于社会各行业的前列，这个产业的顶尖人物被公众视为“知识英雄”，比如微软公司的创始人比尔盖茨雄据世界首富之位多年，更是为人“津津乐道”。

16年前我下决心开始学习计算机技术的时候，对这个行业也充满了自豪感。

    然而世事难料，在2009年高考刚刚结束之际，中国权威出版机构社会科学文献出版社于2009年6月10日发布首部《中国大学毕业生就业报告（2009）》，其中“计算机专业”荣登 “就业最困难的十大专业”光荣榜。
    大约从2003年开始，我在北京理工大学这所211、985重点大学开设.NET课程，这件事后来给某些人“炮轰”--说我要将重点大学学生培养成IT民工，也曾有技术牛人谆谆教诲年青学生--想学软件，离金某人远些……
    “程序员”何时变成了“IT民工”？
    仅仅十多年，“程序员”就从“精英”沦落为“民工”，这也未免太戏剧性了吧！
    “程序员”真的是“IT民工”？
    在中国，不少程序员都是“CRUD”程序员，这不能怪他们，因为中国多数项目都是CRUD的。所以，CRUD似乎成为了“IT民工”身上的标签，问题是CRUD这活真的象在建筑工地上倒水泥一样，不需要太高的智商和较多的训练？
    下面分析一下需要从事这个CRUD的工作的程序员，到底需要哪些知识和技能。
    我大致地思索了一下，画了以下这个图，展示出一名 “.NET程序员民工”要顺利参与一个CRUD的数据库应用项目开发所大致需要掌握的知识与技能：

图 1

    说句实话，这个图虽然“挂一漏万”，但列出来的知识点与需要掌握的技能之多已经很“恐怖”了，对于一个需要掌握这么多知识与技术才能胜任与干好的工作，非要认为它是一个“低级”的 “民工”就可以干的活，想必持这种观点的人一定知识丰富如汪洋大海，属“白骨精（白领-骨干-精英）”一族。
    需要掌握这么多的知识，才有资格当一名合格的“CRUD”程序员，“IT民工”的“门槛”其实挺高的，不是吗？
    事实也如此，软件开发行业从业人员的平均学历我估计至少是大专，很可能是“本科”，其中固然有一些只有“高中”甚至更低学历的“奇才”，但这仅是少数，而且这些人，虽然学历低，但绝不会是一个低智商的人。这说明软件开发行业从业者的“平均智商”应该是挺高的。
    我在旅美学者薛涌写的《天才是训练出来的》一书中找到了美国的一些统计数据：

美国大学本科生的中等智商为118，学士学位获得者的中等智商为123，优秀毕业生的中等智商为133，物理学博士的平均智商为140。而在一般的人口中，中等智商为100。也就是说，你的智商如低于100分，你就属于偏笨的人，高于此线，就属于偏聪明的了。

    老外依据数据得出结论：要把书读懂读好，智商还真的得达到一定的水准。所以，能上大学并且顺利拿到学位的人，基本上是属于比较聪明的那一批人。
    我们中国也有类似的观点，比如经常可以听到某家长叹息其小孩子成绩不好：我家的那个小祖宗，看来根本就不是读书的那块料！套用老外的观点，就是说这个小孩可能智商达不到上大学的基本要求。
    老外什么都喜欢数字化，所以动不动就来个什么“智商”测试，而中国虽然不讲智商这一套，但其实高考就可以看成是一次智商测试。在80、90年代，那时的大学生，经常都是百里挑一、几十里挑一，记得89年我参加高考，那年我们省的录取率还是十几取一。所以那个时代的大学生被称为“天之娇子”，并非“空穴来风”。
    重大的变化发生于1999年，从这一年开始中国大学开始扩招，尤其是计算机专业，更是扩招的重点，其规模迅速膨胀，录取率大大地提高，其结果是，用一句打趣的话说，“阿猫阿狗都去读大学了”，中国大学没有做智商测试的制度，不然，我想应该会看到21世纪在校大学生的平均智商比上世纪80、90年代的在校大学生的平均智商要低。但扩招对一些历史悠久声誉良好的重点大学的影响就没那么大，因为不管你怎么扩招，能进名校（比如北大清华）的学生，智商是不会低的，因为其入学竞争仍然十分激烈，各方面差一点的根本就没这个机会。
    老外还给出了一些著名科学家的智商：牛顿190，伽利略195，开普勒175，达尔文165，哥白尼160。
    我对这些数据抱有怀疑：牛顿和伽利略等的那个时代有智商测试吗？这些数据是从哪计算出来的？
    但这些著名科学的智商高于普通人，我想不会有人怀疑。
    现在回到软件开发这个行业，其从业者平均学历为大专以上，应该说明这个行业需要的是整个人群中比较聪明的那一批。
    这个观点与我的实际感受是一致的。
    我在IT业“混”了十多年，深感这个行业牛人辈出，别说这个行业的“顶尖”级别人物，就是在许多普通的IT企业、科研院所中，也有不少的让人佩服的牛人。我在北理工教了8年书，“笨”的学生实在没见着，而不少学生的聪明程度和学习能力等，都比我在他们这个年纪时要强得多，还有一些学生，真的很聪明，悟性好，能举一反三，在技术上没多久就可以跑到我前面去了。
    所以，软件开发应该是一个需要有较高智商的行业，我觉得不会有太大疑义。
    为什么智商重要？我在薛涌写的《天才是训练出来的》找到了以下描述：

在美国的白人中，生于占人口5%的最低层的穷孩子，日后生活在贫困线以下的可能比那些生于占人口5%的最富裕阶层的孩子要高8倍。但是，那些智商属于最低的5%的孩子，则比那些智商属于最高的5%的孩子日后生活于贫困线以下的可能性高15倍。也就是说，你的脑子是否好使，比你的家庭是否富裕对你的未来重要得多。

    中国人有句俗话：三百六十行，行行出状元。这些“状元”的出身并不重要，但他们应该接近100%的都有高的智商。
    智商这个东西非常奇特，老外研究了这么多年，也没研究明白很多关键问题，比如智商是不是纯天生的？后天不能提高？如果能，那能提高多少？如何解释一些高智商的人一辈子成就平平？如何解释某些天才在某个领域内出类拔萃，在其他领域却连普通人都比不上？还有，更重要的一点：
    普通人付出艰苦的努力，能成为天才吗？
    我不是心理学家，下面我仅就想针对软件开发来聊聊自己对这个问题的看法。

你能成为软件天才吗？

    在整个计算机领域，有一些老外的名字如雷贯耳：冯诺依曼，图灵，比尔盖茨、Anders Hejlsberg，在中国，诸如“求伯君”、“柳传志”、“李开复”等名人的故事也是众人皆知，虽然我们拿不到其智商测试的分数，但相信他们个个都是聪明人。
    “高智商”其实是成为“天才”的必要条件。相应的另一个结论就是：普通人再怎么努力，也成不了天才。
    这话看上去令人泄气，但这是客观事实。
    天才在各自领域内所达到的高度，大多数普通人是永远达不到的，比如如果有某人告诉我：你只要努力，就可以比Anders Hejlsberg还牛。我一定会认为他在开一个让我很生气的玩笑。
    回想起当年的高考，我费了九牛二虎之力，总分才刚够重点大学的最低分数线，后来的考研，我要考3次才侥幸过关，我也曾参过北大的博士生入学考试，结果惨败而回，以后知趣地不再尝试……，我就这智商，普通人一个，所以您就别忽悠我了，我才不信天天坚持跑步，日后就可以参加奥运会的马拉松比赛呢！
    个体间智商的差异是客观存在的。
    但成为不了天才不能成为躺倒不干的理由。因为这里有一个引发了巨大争论的问题……

智商重要还是努力重要？

    国外心理学的统计数据明确无误地说明了智商的重要性，但这里有一个问题：就算是具有“天才”浅质的人在总人员的比例很少，但人类有数十亿之多，“天才”应该不少啊？怎么数千年来，公认 “天才”的就是牛顿等那几个？
    1973年，诺贝尔经济学奖得主、人工智能研究的开拓者Herbert Simon和William Chase在研究国际象棋大师的成长规律时发现：再大的天才，也需要10年修炼成器。
    音乐天才莫扎特似乎打破了这个“十年定律”。5岁做曲，10岁登台演出，一生创作了数百部传世之作。尽管如此，西方学者们还是发现，莫扎特6岁时就已经和父亲一起训练了3500个小时，他第一部达到大师水平的作品，创作年纪是21岁，实际上已经经历了18年的严格训练。
    聪明的脑瓜是必要的，但仅有它也是不够的。
    我引用了这么多的资料，其实只为了说明一个结果：
    不经“十年寒窗”，“天才”不可能出来。
    本身具有高智商的人是这样，在平均智商上下的人更应该努力。
    现在很好解释当下的一些现象了：
    （1）“程序员”为何是“IT民工”？因为这些所谓的“程序员”本身就没有具备从事软件开发的基本知识与基本技能，加上人数众多，可替换性强，怎么会不成为“IT民工”？
    （2）计算机专业学生为何就业难？很简单，一个计算机专业本科生，四年下来至少应该有4~6万行的代码量，但就我观察，达到这个要求的不到10%。
    尽管软件开发行业需要较高的智商，但在平均学历为本科的软件开发行业，从业者已经过高考的筛选，智商并不是问题关键，之所以“IT民工”多和计算机专业学生就业难，主要问题是“懒”和“训练不得法”。
    下图是我总结的一个靠技术吃饭的“程序员”知识与能力增长路线图：

图 2

这个图不是针对“天才”设计的，而是针对一个普通的计算机专业大学生可能的主要人生经历绘制的，虽然经过了大量的简化，但主线还是很清楚的。

我成不了天才，那成为“人材”，可以吗？

    对这个问题，我的观点和薛涌先生在《天才是训练出来的》这本书中所表达的观点是一致的：
    完全可以。
    我们需要解决的问题是“如何努力”的问题。
    薛涌先生在书中介绍了一种名为“处心积虑的训练（deliberation practice）”的天才训练方法，这种方法是由天才研究的权威人士Ericsson教授提出的，简称为“深练（deep practice）”，其意思是一般人练得浅，水平自然平庸，天才则练得深，所以能超出凡人之上。
    普通人如果能科学地深练，虽然不能成为天才，但成为“半个”天才是完全可能的。
    有关“深练”的介绍，朋友们可以自行去看《天才是训练出来的》这本书。就我多年自学软件技术和8年的教学经验，我并不觉得“深练”有何奇特之处，我将“深练”总结为以下几句话：
    （1）织网：分解软件技术的大块知识为多个小的知识点，各个击破，将新知识与老知识联系起来，构造一张完整的可动态扩充的知识之网
    （2）训练：将开发技能给拆分为多个小的步骤或子技能，针对每个步骤或子技能反复地严格地训练，然后再这些步骤或子技能组合起来，以达到职业的水准。
    （3）探究性的学习与实践：要将被动的学习转换为主动的探索，要通过开发实践把一切给“激活”。
    我写了不少文章表达过自己针对软件技术学习的看法，在个人所写的几本书的前言中也比较系统地表达过类似的观点，这里就不再重复了，这些文章在我的个人博客上都可以找到。
    而我也将在日后的开发与教学实践中应用这些原则，探索更有效的学习与训练方法。
    下面，我们来看另一个很困扰人的问题：

我是知道我成不了天才，但为何我也没成“人材”？我可从没偷懒过啊！

    这个问题太有中国特色了！这里面关键有几点：
    （1）你错过了“学习天窗”。任何一种知识和技能，都有学习与培养它的最佳时间段，我们将它称为“学习天窗”，比如一个两三岁的小孩子可以轻而易举地学会两三种语言，而且不会有口音，而一个成人就够呛了，以英语为例，我们都受够了难听无比的“日本英语”和“印度英语”，“中国英语”也好不到哪去。拿软件技术而言，最佳的学习时间是大学的这几年，18岁~25岁左右，精力、体力、智力，无不处于高峰，你这时不学，拿这个时间去玩游戏，看大片，QQ海聊，上网乱逛……，等到30岁以后再学，会发现你花3个小时才能记住的东西，10年以前可能1.5个小时（甚至更少的时间）就能记住了。后悔也晚了。这也只能怪你自己。
    （2）命运：
    幸运的是，你生在中国！你没生在阿富汗和非洲，那里天天子弹飞，饿肚子，闹瘟疫，这种环境下你还能学计算机，编程序？
    倒霉的是，你也生在中国！如果你生在美国，你就可以摆脱那因为千军万马过独木桥而喘不过气来的中小学应试体制，上了大学，也可以得到比较好的专业引导和教育，避开那因为“行政化”而“弊端从生”的中国高等教育体制。中国这个大环境你个人是改不了的。
    最倒霉的是，你不仅生在中国，而且你爸不是李刚，你家在很远的地方，那地方很穷，家里买不起电脑，更别说上网了，你可能要到大学才第一次接触到电脑……，让你雪上加霜的是：你竞争不过那些学习条件好的同学，虽然你不笨，也很努力，但在起点就落后了，结果你没上到好大学，没碰到好老师，一步晚，步步晚……
    这不是你的责任，真的，不是你的责任！

但不要追问是谁的责任。

    再追问下去，你可能就要去宗教中寻找归宿了。
    路在何方？
    你手上抓的牌不太好，这没办法，这是命运问题，这世界本来就是不公平的，老子说过：天地不仁，以万物为刍狗……
    别想那么多了，不抱怨不等待，积极努力，想办法把手头抓的这副“坏牌”打好，这是最现实最正确的选择。
    只要个人努力了，其他的丢给命运吧！你还能怎的？

本文链接

《.NET 4.0网络开发入门之旅》4：与Socket的第一次“约会”

2010-12-25T02:42:00Z

《.NET 4.0网络开发入门之旅》系列文章

点击以下链接阅读本系列前面的文章：

   1. 《开篇语—— 无网不胜》
   2. 《 IP知多少》
   3. 《我在“网” 中央》

点击以下链接阅读《.NET 4.0网络开发入门之旅》的第4部分：

   4 《与Socket的第一次“约会”》

此文内容比较简单，恐怕不合园子里高手的口味，而且同一文章贴两遍麻烦，所以上述文章发在CSDN。

本文链接

.NET 4.0网络开发入门之旅——我在“网” 中央（下）

2010-12-10T06:28:00Z

.NET 4.0网络开发入门之旅--

我在“网” 中央（下）

续上篇《.NET 4.0网络开发入门之旅——我在“网” 中央（上）》

4 我“连网”了吗？

     好了，有了前面的铺垫，现在解决判断计算机连网问题水到渠成，其思路很简单：
   （1）检测一下计算机中的所有网络接口状态，只要都为“Down”，没说的，肯定没连网。
   （2）从状态为“Up”的网络接口中选一个（注意排除掉环回接口Loopback），获取其网关和DNS服务器地址，先Ping一下它的网关，如果能Ping通，再Ping一下DNS服务器，看看能不能Ping通。
   如果网关Ping不通，就换一个“Up”的网络接口试一试，重复上述过程，直到检测完了所有“Up”的网络接口。

   现在结果呼之欲出了：
   （1）只要有一个网络接口可以Ping通网关，则“本计算机肯定已连上本地网络。”
   （2）只要有一个网络接口可以Ping通DNS，则“本计算机的本地网络设置没有问题。”除非DNS服务器本身故障（应该发生机率不高）或由于你欠费之类的账号被限制，则“本计算机联上互联网应该没问题”。
   （3）为了真正确认已联上互联网，Ping一个“Well-Known”的网址，比如“百度”，能Ping通则100%确信可以上网了。

   注意：
   某些网站不响应Ping数据包，比如笔者发现微软公司主机就不理会Ping数据包，对其主机的Ping操作将以“超时（TimeOut）”收场。

   有的朋友看到这里，不禁会说：
   你这不是多此一举了吗？一上来直接Ping一个互联网主机，不就知道能不能上网了吗？
   呵呵，这怎么说呢？不能上网的原因太多了，如果你的网络应用程序能告之用户更详细的信息：

无法连接网关，请检查你的网络设置
无法连接DNS服务器，您所指定的DNS服务地址“192.168.1.1”可能有误，或者是DNS服务器故障……

是不是更有助于用户定位网络问题？
我在示例程序中写了一个IsOnline方法实现了前述的连网检测逻辑：

static bool IsOnline()
{
    if (NetworkInterface.GetIsNetworkAvailable() == false)
        return false;  //所有网卡都是“Dwon”的
    //选出“Up”的网卡，并且排除掉环回接口
    var query = from nic in NetworkInterface.GetAllNetworkInterfaces()
                   where nic.OperationalStatus == OperationalStatus.Up &&
                   nic.NetworkInterfaceType != NetworkInterfaceType.Loopback
                   select nic;
    foreach (var nic in query)
    {
        //先Ping网关
        Ping pinger = new Ping();
        bool GatewayReady = false;
        foreach (GatewayIPAddressInformation GatewayAddr in
            nic.GetIPProperties().GatewayAddresses)
        {
            PingReply reply = pinger.Send(GatewayAddr.Address);
            if (reply.Status == IPStatus.Success)
            {
                GatewayReady = true;
                break;
            }
        }
        if (GatewayReady == false)
            continue; //所有网关都不通，不再进行下一步测试，直接检测下一个网卡
        //网关Ping通了，可以Ping DNS
        foreach (IPAddress addr in nic.GetIPProperties().DnsAddresses)
        {
            PingReply reply = pinger.Send(addr);
            if (reply.Status == IPStatus.Success)
            {
                return true;
            }
        }
    }
    return false;
}

上述代码中除了没有完成Ping一个“Well-Known”的真实互联网之外，其余的工作都已完成。
IsOnLine方法返回“True”时，表示本地网络可以Ping通DNS，否则，返回“False”，你可以修改这个方法，让其依据具体情况返回更详细的信息（比如是哪个网卡的网关还是DNS不能Ping通）。

5 让我们“并行”起来！

现在再来一点“Cool”的。

仔细考虑一下我们的“连网”判断逻辑，不难发现这些Ping操作是可以并行执行的，如果能使用多个线程同时执行Ping操作，无疑可以减少得到“是否可以访问互联网”这一最终结论的时间。

我们可以将IsOneLine方法转换为多线程版。

   使用独立的线程执行每个网络接口的Ping操作，必须等待Ping网关的线程执行结束之后，依据其执行结果再决定是否新开一个线程执行Ping DNS的操作。
   当有一个网卡可以Ping通DNS时，应该通知其它线程停止工作，因为“能否上网”的结论已经得出了。

这里面其实涉及到不少比较复杂的线程同步问题，需要用到多个线程同步对象，并且还涉及到如何中途取消一个线程执行的问题，我在《.NET 4.0面向对象编程漫谈》的《应用篇》中，花了100多页的篇幅讲多线程，其中介绍了.NET 4.0基类库中几乎所有的线程同步对象的用法，并大力推荐推荐使用.NET 4.0的“线程统一取消模型”（参看《应用篇》的16.5 《线程统一取消模型》）来中途取消一个线程的执行。

读者您能否将IsOneLine方法转换为多线程版，是一块检测您是否真正掌握了多线程技术的试金石。

在这里，我想向读者介绍如何直接使用TPL（任务并行库）而不是线程达到目的。

需要仔细分析一下IsOnLine的处理逻辑，看看哪些部分是可以并行的，这些并行操作间有怎样的合作关系。

   很明显，对于多个网络接口的连接检测工作完全是可以并行的，这是第一个任务并行点。
   其次，一个网络接口一般只有一个网关，不需要并行，但一个网络接口可能会有两个以上的DNS服务地址，很明显，这是第二个任务并行点。
   第三，在同时运行的多个并行任务之间，任何一个得到“互联网可达”最终结果的并行任务，需要通知其他任务提前中止执行。

经过以上考虑，使用并行循环（Parallel.ForEach）而不是Task对象是更合理的选择。Parallel.ForEach可以并行执行一个循环，并且通过ParallelLoopState对象可以提前中止循环，还可以“通知到”其他工作线程。

以下是使用任务并行库实现的IsOnLine版本：

static bool IsOnlineUseTPL()
{
    if (NetworkInterface.GetIsNetworkAvailable() == false)
        return false;
    //选出所有处于激活状态的网卡
    var query = from nic in NetworkInterface.GetAllNetworkInterfaces()
                where nic.OperationalStatus == OperationalStatus.Up &&
                nic.NetworkInterfaceType != NetworkInterfaceType.Loopback
                select nic;
    int NicReady = 0;  //当有一个网卡的DNS是可达时，此值会大于0.
    //以下开始定义可并行的任务，针对每个网络接口的
    Action<NetworkInterface, ParallelLoopState> PingNetworkInterface =
        (nic, outState) =>
        {
                Ping pinger = new Ping();//Ping网关
                bool GatewayReady = false;
                foreach (GatewayIPAddressInformation GatewayAddr in
                nic.GetIPProperties().GatewayAddresses)
                {
                    if (outState.IsStopped) //其他网卡的Ping循环已被中止
                        return;
                    PingReply reply = pinger.Send(GatewayAddr.Address);
                    if (reply.Status == IPStatus.Success)
                    {
                        GatewayReady = true;
                        break;
                    }
                }
                if (GatewayReady != true)  //网关的都Ping不通，不必再Ping DNS了
                    return;  //结束本网卡的Ping工作
                else //网关是通的，就可并行Ping所有DNS地址
                {
                    Parallel.ForEach(nic.GetIPProperties().DnsAddresses,
                     (dnsaddr, innerState) =>
                    {
                    //其他Ping循环（本网卡的或者是其它网卡的）已被中止
                        if (innerState.IsStopped || outState.IsStopped)
                                                    return;
                        Ping pinger2 = new Ping();
                        PingReply reply = pinger2.Send(dnsaddr);
                        if (reply.Status == IPStatus.Success) //Ping成功
                        {
                            //表明此网卡DNS可达
                            Interlocked.Increment(ref NicReady);
                            //不需要再进行本并行循环的后继的循环工作
                            innerState.Stop();
                            outState.Stop();    //上层的并行循环也可以中止了
                            return;
                        }
                     }
                );
                }
            };   //并行任务定义结束
            //执行并行任务
            Parallel.ForEach(query, PingNetworkInterface);
            return NicReady > 0;
        }

上述代码比较长，用到了一些比较复杂的编程特性，比如“LINQ查询”、“Lambda”表达式，Parallel并行循环等。请读者先仔细阅读《.NET 4.0面向对象编程漫谈》的以下章节扫清知识障碍，再通过阅读代码中的注释，并在Visual Studio中进行调试才能看懂这些代码：

8.4节《匿名方法与Lambda表达式》
11.5节《掌握LINQ查询表达式的编写技巧》
17.2.3节《实现原子操作--Interlocked》
19.3.3节《使用Parallel类编写并行代码》
19.3.9 节《并行任务的取消》

如果希望将并行版本的IsOnlineTPL用于有可视化界面的程序，推荐创建一个新的背景线程执行此方法，然后使用第18章《跨线程访问可视化控件》所介绍的方法将结果“推送”到UI线程中，更新可视化界面（比如就象Windows一样切换显示图片）。

另外，.NET基类库中有一个NetworkChange密封类，当用户计算机的IP地址改变时（包括用户手动更改的，或者是用户关闭了无线功能等间接原因造成）它可以引发一个NetworkAddressChanged事件，可以在此事件中调用IsOnlineTPL方法重新检测是否网络可达。

6 小结

由于我的网络环境比较单一，所以没法测试IsOnlineTPL方法是否可以在各种各样的网络环境下正常工作，另外，此方法仅仅检测到DNS是否“通”为止，并没有去Ping一个真正的“互联网主机”，而且有些网络主机可能不理会“Ping”操作发出的数据包，因此，IsOnlineTPL返回false并不一定意味着网络不可达。读者大可以在我的代码的基础上进行完善，或者是设计一个新的更好的实现方案。
本文仅起一个抛砖引玉的工作，如有错误，敬请朋友们回贴指出，不胜感激！
=======================================

点击下载本文所关联的示例源码

预告：

在后面的文章中，.NET网络开发的主角——Socket 将正式登场！

本文链接

博客园_金旭亮

金旭亮《C#面向对象程序设计》2011完整版发布

.NET 4.0 技术亮点剖析——在中科院计算所的讲座PPT及源码下载

“智商平平”学软件

《.NET 4.0网络开发入门之旅》7：填平缓冲区陷阱

《从面向对象到SOA》正文及源码 (http://files.cnblogs.com/bitfan/%e4%bb%8e%e9%9d%a2%e5%90%91%e5%af%b9%e8%b1%a1%e5%88%b0SOA.rar) 以下是本文所附之示例源码的下载链接： 示例源码下载链接

一个多线程示例程序的BUG修复

《.NET 4.0网络开发入门之旅》6：“麻烦”的数据缓冲区

《.NET 4.0网络开发入门之旅》5：与Socket的“再次见面”

软件天才与技术民工

《.NET 4.0网络开发入门之旅》4：与Socket的第一次“约会”

.NET 4.0网络开发入门之旅——我在“网” 中央（下）

《从面向对象到SOA》正文及源码
(http://files.cnblogs.com/bitfan/%e4%bb%8e%e9%9d%a2%e5%90%91%e5%af%b9%e8%b1%a1%e5%88%b0SOA.rar)

以下是本文所附之示例源码的下载链接：

示例源码下载链接