public static void check(Page aPage)
{
if (aPage.Session[”ok”] == null || aPage.Session[”ok”].ToString() != “ok”)
{
aPage.Response.Redirect(”login.aspx”);
}
}

在母版页里调用的正确方法：

protected void Page_Init(object sender, EventArgs e)
{
checkLogin.check(this.Page);
}

原因：

母版页和内容页的执行顺序：

1.母版页中控件的Init;
2.内容页控件的Init;
3.母版页的Init;
4.内容页的Init;
5.内容页的Load;
6.母版页的Load;
7.内容页中控件的Load;
8.内容页的PreRender;
9.母版页的PreRender;
10.母版页控件的PreRender;
11.内容页中控件的PreRender

出错方法：

１、checkLogin.check(mypage);
运行：MasterPage类转Page类出错

２、Page mypage=new Page();
checkLogin.check(mypage);
运行：System.Web.HttpException: 响应在此上下文中不可用。

３、用户自定义控件MasterPublicMethod.ascx，调用检查方法
protected void Page_Load(object sender, EventArgs e)
{
checkLogin.check(this.Page);
}
控件加入母版页：
这个方法改成：在母版页的Page_Load事件里：checkLogin.check(this.Page);
运行：正常
出错原因：事件执行顺序：内容页的Page_Load事件->母版页的Page_Load事件，要在页面最开始检查有没有登录

４、母版页：
protected void Page_Load(object sender, EventArgs e)
{
//Response.Write(”母版”);
checkLogin.check(this.Page);
}
内容页的Page_LoadComplete事件：
protected void Page_LoadComplete(Object sender, EventArgs e)
{
int t, bid;
//初始化自定义控件用的参数
pg = Convert.ToInt32(Request.QueryString[”pg”]);
bid = Convert.ToInt32(Request.QueryString[”id”]);
t = Convert.ToInt32(Request.QueryString[”t”]);
switch (t)
{
case 1:
//回复
break;
case 2:
//修改回复
break;
case 3:
//隐藏
HideBook(bid);
break;
case 4:
//删除
DelBook(bid);
break;
}
}
修改原因：页面执行顺序：内容页的Page_Load->母版页的Page_Load->内容页的Page_LoadComplete
运行：自定义控件里有变量未赋值出错
出错原因：有的内容页里有自定义控件，自定义控件的Page_Load事件里有代码，自定义控件的参数在内容页的Page_LoadComplete事件里初始化
Page_Load的执行顺序：内容Page_Load->母版Page_Load->自定义控件Page_Load->内容Page_LoadComplete

原文：Teach Yourself Programming in Ten Years
作者：Peter Norvig
翻译：郭晓刚（foosleeper@163.net）
最后修订日期：2004-3-19
2005-01-12增加了新的译本链接。

本中文译本得到了Peter Norvig的许可。

为什么每个人都急不可耐？

走进任何一家书店，你会看见《Teach Yourself Java in 7 Days》（7天Java无师自通）的旁边是一长排看不到尽头的类似书籍，它们要教会你Visual Basic、Windows、Internet等等，而只需要几天甚至几小时。我在Amazon.com上进行了如下搜索：
pubdate: after 1992 and title: days and (title: learn or title: teach yourself)
(出版日期：1992年后 and 书名：天 and （书名：学会 or 书名：无师自通）)
我一共得到了248个搜索结果。前面的78个是计算机书籍（第79个是《Learn Bengali in 30 days》，30天学会孟加拉语）。我把关键词“days”换成“hours”，得到了非常相似的结果：这次有253本书，头77本是计算机书籍，第78本是《Teach Yourself Grammar and Style in 24 Hours》（24小时学会文法和文体）。头200本书中，有96%是计算机书籍。
结论是，要么是人们非常急于学会计算机，要么就是不知道为什么计算机惊人地简单，比任何东西都容易学会。没有一本书是要在几天里教会人们欣赏贝多芬或者量子物理学，甚至怎样给狗打扮。
让我们来分析一下像《Learn Pascal in Three Days》（3天学会Pascal）这样的题目到底是什么意思：

学会：在3天时间里，你不够时间写一些有意义的程序，并从它们的失败与成功中学习。你不够时间跟一些有经验的程序员一起工作，你不会知道在那样的环境中是什么滋味。简而言之，没有足够的时间让你学到很多东西。所以这些书谈论的只是表面上的精通，而非深入的理解。如Alexander Pope（译注：英国诗人、作家，1688-1744）所言，一知半解是危险的（a little learning is a dangerous thing）
。
Pascal：在3天时间里你可以学会Pascal的语法（如果你已经会一门类似的语言），但你无法学到多少如何运用这些语法。简而言之，如果你是，比如说一个Basic程序员，你可以学会用Pascal语法写出Basic风格的程序，但你学不到Pascal真正的优点（和缺点）。那关键在哪里？Alan Perlis（译注：ACM第一任主席，图灵奖得主，1922-1990）曾经说过：“如果一门语言不能影响你对编程的想法，那它就不值得去学”。另一种观点是，有时候你不得不学一点Pascal（更可能是Visual Basic和JavaScript之类）的皮毛，因为你需要接触现有的工具，用来完成特定的任务。但此时你不是在学习如何编程，你是在学习如何完成任务。

3天：不幸的是，这是不够的，正如下一节所言。

10年编程无师自通

一些研究者（Hayes、Bloom）的研究表明，在许多领域，都需要大约10 年时间才能培养出专业技能，包括国际象棋、作曲、绘画、钢琴、游泳、网球，以及神经心理学和拓扑学的研究。似乎并不存在真正的捷径：即使是莫扎特，他4 岁就显露出音乐天才，在他写出世界级的音乐之前仍然用了超过13年时间。再看另一种音乐类型的代表–披头士，他们似乎是在1964年的Ed Sullivan节目中突然冒头的。但其实他们从1957年就开始表演了，即使他们很早就显示出了巨大的吸引力，他们第一次真正的成功之作《Sgt. Peppers》也要到1967年才发行。Samuel Johnson（译注：英国诗人）认为10 年还是不够的：“任何领域的卓越成就都只能通过一生的努力来获得；稍低一点的代价也换不来。”（Excellence in any department can be attained only by the labor of a lifetime; it is not to be purchased at a lesser price.） 乔叟（译注：Chaucer，英国诗人，1340-1400）也抱怨说：“生命如此短暂，掌握技艺却要如此长久。”（the lyf so short, the craft so long to lerne.）
下面是我在编程这个行当里获得成功的处方：

对编程感兴趣，因为乐趣而去编程。确定始终都能保持足够的乐趣，以致你能够将10年时间投入其中。

跟其他程序员交谈；阅读其他程序。这比任何书籍或训练课程都更重要。

编程。最好的学习是从实践中学习。用更加技术性的语言来讲，“个体在特定领域最高水平的表现不是作为长期的经验的结果而自动获得的，但即使是非常富有经验的个体也可以通过刻意的努力而提高其表现水平。”（p. 366），而且“最有效的学习要求为特定个体制定适当难度的任务，有意义的反馈，以及重复及改正错误的机会。”（p. 20-21）《Cognition in Practice: Mind, Mathematics, and Culture in Everyday Life》（在实践中认知：心智、数学和日常生活的文化）是关于这个观点的一本有趣的参考书。

如果你愿意，在大学里花上4年时间（或者再花几年读研究生）。这能让你获得一些工作的入门资格，还能让你对此领域有更深入的理解，但如果你不喜欢进学校，（作出一点牺牲）你在工作中也同样能获得类似的经验。在任何情况下，单从书本上学习都是不够的。“计算机科学的教育不会让任何人成为内行的程序员，正如研究画笔和颜料不会让任何人成为内行的画家”，Eric Raymond，《The New Hacker’s Dictionary》（新黑客字典）的作者如是说。我曾经雇用过的最优秀的程序员之一仅有高中学历；但他创造出了许多伟大的软件，甚至有讨论他本人的新闻组，而且股票期权让他达到我无法企及的富有程度（译注：指Jamie Zawinski，XEmacs和Netscape Navigator的作者）。

跟别的程序员一起完成项目。在一些项目中成为最好的程序员；在其他一些项目中当最差的一个。当你是最好的程序员时，你要测试自己领导项目的能力，并通过你的洞见鼓舞其他人。当你是最差的时候，你学习高手们在做些什么，以及他们不喜欢做什么（因为他们让你帮他们做那些事）。

接手别的程序员完成项目。用心理解别人编写的程序。看看在没有最初的程序员在场的时候理解和修改程序需要些什么。想一想怎样设计你的程序才能让别人接手维护你的程序时更容易一些。

学会至少半打编程语言。包括一门支持类抽象（class abstraction）的语言（如Java或C++），一门支持函数抽象（functional abstraction）的语言（如Lisp或ML），一门支持句法抽象（syntactic abstraction）的语言（如Lisp），一门支持说明性规约（declarative specification）的语言（如Prolog或C++模版），一门支持协程（coroutine）的语言（如Icon或Scheme），以及一门支持并行处理（parallelism）的语言（如Sisal）。

记住在“计算机科学”这个词组里包含“计算机”这个词。了解你的计算机执行一条指令要多长时间，从内存中取一个word要多长时间（包括缓存命中和未命中的情况），从磁盘上读取连续的数据要多长时间，定位到磁盘上的新位置又要多长时间。（答案在这里。）

尝试参与到一项语言标准化工作中。可以是ANSI C++委员会，也可以是决定自己团队的编码风格到底采用2个空格的缩进还是4个。不论是哪一种，你都可以学到在这门语言中到底人们喜欢些什么，他们有多喜欢，甚至有可能稍微了解为什么他们会有这样的感觉。

拥有尽快从语言标准化工作中抽身的良好判断力。

抱着这些想法，我很怀疑从书上到底能学到多少东西。在我第一个孩子出生前，我读完了所有“怎样……”的书，却仍然感到自己是个茫无头绪的新手。30个月后，我第二个孩子出生的时候，我重新拿起那些书来复习了吗？不。相反，我依靠我自己的经验，结果比专家写的几千页东西更有用更靠得住。
Fred Brooks在他的短文《No Silver Bullets》（没有银弹）中确立了如何发现杰出的软件设计者的三步规划：

尽早系统地识别出最好的设计者群体。

指派一个事业上的导师负责有潜质的对象的发展，小心地帮他保持职业生涯的履历。

让成长中的设计师们有机会互相影响，互相激励。

这实际上是假定了有些人本身就具有成为杰出设计师的必要潜质；要做的只是引导他们前进。Alan Perlis说得更简洁：“每个人都可以被教授如何雕塑；而对米开朗基罗来说，能教给他的倒是怎样能够不去雕塑。杰出的程序员也一样”。
所以尽管去买那些Java书；你很可能会从中找到些用处。但你的生活，或者你作为程序员的真正的专业技术，并不会因此在24小时、24天甚至24个月内发生真正的变化。

参考文献

Bloom, Benjamin (ed.) Developing Talent in Young People, Ballantine, 1985.
Brooks, Fred, No Silver Bullets, IEEE Computer, vol. 20, no. 4, 1987, p. 10-19.
Hayes, John R., Complete Problem Solver, Lawrence Erlbaum, 1989.
Lave, Jean, Cognition in Practice: Mind, Mathematics, and Culture in Everyday Life, Cambridge University Press, 1988.

答案

各种操作的计时，2001年夏天在一台典型的1GHz PC上完成：
执行单条指令 1 纳秒 = (1/1,000,000,000) 秒
从L1缓存中取一个word 2 纳秒
从主内存中取一个word 10 纳秒
从连续的磁盘位置中取一个word 200 纳秒
从新的磁盘位置中取一个word（寻址） 8,000,000纳秒 = 8毫秒

脚注

T. Capey指出Amazon上面《Complete Problem Solver》的页面中，《Teach Yourself Bengali in 21 days》和《Teach Yourself Grammar and Style》被列在了“购买此书的顾客还买了以下书籍”栏目里面。我猜其中一大部分察看这两本书的人都是从我这里过去的。

译本

感谢以下作者将本文翻译成其他语言：
日文（Yasushi Murakawa），中文（郭晓刚），繁体中文（Jason Chen），西班牙文（Carlos Rueda），德文（Stefan Ram），法文（P. E. Allary），土耳其文（Çağıl Uluşahin）。

Peter Norvig (Copyright 2001)

程序设计是困难的，其核心是管理的复杂性。计算机程序是人类做出的最复杂的东西。质量是不可靠的且隐蔽的。

好的体系架构是必需给程序足够的结构使其健壮而不会陷入混乱的泥淖，但我们表达一个程序细节的方式是同等重要的。一个程序的本质会被不良的编码所隐藏。只有当一个程序的表达清晰时，我们才能有希望正确的推理出它的效率、安全和正确性。

William Strunk的《风格要素》(The Elements of Style)是关于文学风格的经典著作，它是一本关于英文写作的薄手册，在用法、组织和形式上提出忠告。风格的理念应用于编程，在1972年Kreitzberg和Shneiderman的《FORTRAN风格要素》（The Elements of FORTRAN Style）中是不成功的，但在1978年的Kernighan和Plauger的《编程风格要素》（The Elements of Programming Style）中是非常成功的：

好的编程不能通过笼统的说教。学习编程的好方法是一次又一次的思考：真正的编程是如何通过一些良好实践的原则和一点常识来进行改进的。

他们从他们批评和改进的其他的编程教科书中筛选程序。

当我们在这里谈论风格时，我们谈论的不是潮流或者时尚，也不是CSS、布局惯例或排版。我们正在谈论的是能真正提高代码价值的表达式的永恒品质。对于公司来说，他们的评估和他们的代码是息息相关的，风格应该是一个至关重要的受关注内容。

我们使用许多编程语言，但在某一方面，Javascript是最重要的，它是浏览器的语言。当人们访问我们的站点时，他们将邀请我们的Javascript程序在他们的机器中执行。我们有义务使那些程序执行好。

没有好的关于Javascript编程的课本。在网页使用Javascript的大多数人学习它是通过从糟糕的书、糟糕的站点和糟糕的工具中复制相当糟糕的例子。我们这里有极好的Javascript程序员社区，但我们依旧能从较好的风格实践中获益。

为了证明这个问题，我将从公共网站中抽取一些程序，展示它们如何能被改进。这并不是我有意为难任何人。我的意图仅是通过例子展示风格的价值。我不会保留任何秘密：我展示给你的是我们已经传送给世界上的每一个人。
淘汰过时结构

下面的例子是2005-09-19摘自www.yahoo.com：
<script language=javascript><!–
     lck=”,
     sss=1127143538,
     ylp=’p.gif?t=1127143538&_ylp=A0Je5ipy2C5D54AAwVX1cSkA’,
     _lcs=”;
–></script>

这个脚本块用了language属性。这个特性是微软为了支持VBScript引入的。然而Netscape采用它是为了支持非标准偏差。W3C不采取这个language属性，倾向使用MIME类型的type属性取代。不幸的是，MIME类型未得到标准化，所以它有时是”text/javascript”、”application/ecmascript”或其他。幸运的是所有的浏览器都选择Javascript作为默认的编程语言，所以简单的写<script>是最好的。它最小，且工作在最多的浏览器。在脚本中使用HTML的注释的时间要回溯到Netscape Navigator和Netscape Navigator 2的兼容问题上来。后者引入了<script>标签。然而，前者的用户能像文本一样看到脚本，因为在HTML惯例中不能识别的标签被忽略。<!–注释hack在Netscape Navigator 3出现的时候是需要的，现在它不被需要了。它是丑陋的且浪费空间的。

逗号运算符像Javascript语法的大多数一样从C语言中借用。逗号运算符获得两个值，且返回第二个。在语言的定义中它的存在易于掩盖一定的编码错误，编译器也易于对一些错误视而不见。最好避免逗号运算符，并以分号运算符代替。

在这个案例里，我们定义了一些全局变量。当指定一个未知（匿名）的变量时，Javascript会创建一个新的全局变量来替代产生的错误。事后看来，这是一个错误。即使当他们是一个标准错误，这是避免错误的最好办法。我们应该明确的声明变量。它花费我们四个字符，但是它正是要做的正确的事。
<script>
var lck = ‘3ek6b0i2he2a5eh3/o’,
    sss = 1126894256,
    ylp = ‘p.gif?t=1126894256&_ylp=A0Je5iOwCitDw2YBX331cSkA’,
    _lcs = ‘94040′;
</script>

从上面我们能得出这样的原则：淘汰过时结构
结构化语句要始终使用区块

下面这个例子是一个cookie类构造器。它创建了一个有get和set方法的对象。
function yg_cookie() {
    this.get = function (n) {
        var s,
            e,
            v = ”,
            c = ‘ ‘ + document.cookie + ‘;’;
        if ((s = c.indexOf((’ ‘ + n + ‘=’))) >= 0) {
            if ((e = c.indexOf(’;',s)) == -1)
                e = c.length;
            s += n.length + 2;
            v = unescape(c.substring(s, e));
        }
        return (v);
    }
    this.set = function (n,v,e) {
        document.cookie = n + "=" + escape(v) +
            ";expires=" + (new Date(e * 1000)).toGMTString() +
            ";path=/" + ";domain=www.yahoo.com";
    }
}
var _yc = new yg_cookie();

Javascript的if语句和C语言的相似：它能执行一个语句或一个区块。关于用语句的问题是一个普通的错误非常难以探测。最好把
if ((e = c.indexOf(’;', s)) == -1)
    e = c.length;

写成
if ((e = c.indexOf(’;', s)) == -1) {
    e = c.length;
}

区块的用处是避免了下面的情况：
if ((e = c.indexOf(’;', s)) == -1)
    e = c.length;
    s += n.length + 2;

它将出现当indexOf返回-1是，s是只被增加，但这不是实际情形。像这样的bug被发现代价是非常高的，但是可以通过一直使用大括号声明结构来廉价的避免。
避免赋值表达式

Javascript从C继承的另一个坏习惯是赋值表达式。它出现在流线型代码中，但它能使控制流更难以理解。如果我们从他们的使用中分离了s和e的计算，get方法会变得更清晰。
this.get = function (n) {
    var v = ”,
        c = ‘ ‘ + document.cookie + ‘;’,
        s = c.indexOf((’ ‘ + n + ‘=’)),
        e = c.indexOf(’;', s);
    if (s >= 0) {
        if (e == -1) {
            e = c.length;
        }
        s += n.length + 2;
        v = unescape(c.substring(s, e));
    }
    return (v);
}

我们现在能看到当s被计算时，在indexOf参数两边有多余的括号。（在return语句中也有非必须的括号。）但是更重要的是，能容易的看出if (e == -1)的目的是什么：如果cookie中末尾的分号不存在，假定cookie结束在字符串的末端。然而，当我们计算c时，我们在cookie中加入了一个分号，它保证了预料的if条件将绝不会发生。所以我们能移除if。
使用对象参数

当一个函数被指定一个值，像在this.get = function (n) { … }中，它应该以一个分号来结束所有的赋值语句。
function yg_cookie() {
    this.get = function (n) {
        var v = ”,
            c = ‘ ‘ + document.cookie + ‘;’,
            s = c.indexOf((’ ‘ + n + ‘=’));
        if (s >= 0) {
            s += n.length + 2;
            v = unescape(c.substring(s, c.indexOf(’;', s)));
        }
        return v;
    };
    this.set = function (n,v,e) {
        document.cookie = n + "=" + escape(v) +
            ";expires=" + (new Date(e * 1000)).toGMTString() +
            ";path=/" + ";domain=www.yahoo.com";
    };
}
var _yc = new yg_cookie();

最后，我们看到yg_cookie是一个能产生一个无状态对象的构造器。我们一点也不需要构造器函数。我们能简单创建一个空对象，通过指派方法的方式来增加它。
var _yc = new Object();
_yc.get = function (n) {
    var v = ”,
        c = ‘ ‘ + document.cookie + ‘;’,
        s = c.indexOf((’ ‘ + n + ‘=’));
    if (s >= 0) {
        s += n.length + 2;
        v = unescape(c.substring(s, c.indexOf(’;', s)));
    }
    return v;
};
_yc.set = function (n,v,e) {
    document.cookie = n + "=" + escape(v) +
        ";expires=" + (new Date(e * 1000)).toGMTString() +
        ";path=/" + ";domain=www.yahoo.com";
};

如果我们不需要支持Netscape3和IE4，我们能通过对象字面量来实现的更加优雅。
var _yc = {
    get: function (n) {
        var v = ”,
            c = ‘ ‘ + document.cookie + ‘;’,
            s = c.indexOf((’ ‘ + n + ‘=’));
        if (s >= 0) {
            s += n.length + 2;
            v = unescape(c.substring(s, c.indexOf(’;', s)));
        }
        return v;
    },
    set: function (n,v,e) {
        document.cookie = n + "=" + escape(v) +
            ";expires=" + (new Date(e * 1000)).toGMTString() +
            ";path=/" + ";domain=www.yahoo.com";
    }
};
使用通用库

此时对于处理cookies我们有几种方法。我们发现下一个事情是令人惊奇的，它是没有利用我们定义的方法的cookies处理方式代码。
var b,
    l = ”,
    n = ‘0′,
    y;
y = ‘ ‘ + document.cookie + ‘;’;
if ((b = y.indexOf(’ Y=v’)) >= 0) {
    y = y.substring(b, y.indexOf(’;', b)) + ‘&’;
    if ((b = y.indexOf(’l=’)) >= 0) {
        l = y.substring(b + 2, y.indexOf(’&’, b));
        if ((b = y.indexOf(’n=’)) >= 0)
            n = y.substring(b + 2, y.indexOf(’&’, b));
    }
}

它甚至复制了我们早前看到的同样技术。很有可能两块代码都改写自同一个有缺点的原稿。我们可以利用我们最近的工作来改进它：
var l = ”,
    n = ‘0′,
    y = _yc.get(’Y') + ‘&’,
    b = y.indexOf(’l=’);
if (b >= 0) {
    l = y.substring(b + 2, y.indexOf(’&’, b));
    b = y.indexOf(’n=’);
    if (b >= 0) {
        n = y.substring(b + 2, y.indexOf(’&’, b));
    }
}

代码重用是软件工程的圣杯。我们可以想象通过最先进的技术避免大量的必需的手工工作来得到高效率。这里我们发现一种失败，使用一种方法需要在相邻需要它的地方进行定义。

软件的体系结构倾向于反映生产他们的组织结构。在这种情况下，我们看到一个组织由于缺乏流程的连通意识而导致的明显低效的证据。风格的应用是吹毛求疵的，因为如果我们理解这几条是什么才有可能正确的一起使用这几条。

原文：Douglas Crockford的The Elements of JavaScript Style Part One

我们使用习惯用法可以使我们的意图更加的清晰和简洁。
使用==时，当心强制转换

考虑下面函数：
function gw(f) {
    if (d.w.sv.checked == true) {
        zv = ‘on’;
    } else {
        zv = ‘off’;
    }
    procframe.location.replace("http://b.www.yahoo.com/module/wtr_tr.php?p=" +
        escape(f.p.value) + "&sv=" + zv);
    return false;
}

==运算符不应该被用着和true比较值，因为它要执行强制转换。如果我们想确定d.w.sv.checked是否是布尔值
true，我们必须用===运算符。如果我们仅在意一个值是真实存在的不是假的，最好不要用相等运算符。

例如，由于强制转换：1 == true是真，1 === true是假。==运算符隐藏了类型错误。
使用?:运算符选择两值之一

if语句通常被用来从两个值中选择一个。这应该是三元操作符?:最适合的。
zv = d.w.sv.checked ? ‘on’ : ‘off’;
绝不使用隐含的全局变量

变量zv不是作为一个var或函数参数来声明的，所以它是一个隐式的全局变量。如果这个页面的另一个函数使用了同样名字的全局变量，则可能得到一个失败的结果。这样的臭虫（bug）是非常难以发现，却很容易避免。这个例子中，我们既可以声明zv为一个var，也可以发现它仅仅被使用过一次而整个去掉它。
function gw(f) {
    procframe.location.replace("http://b.www.yahoo.com/module/wtr_tr.php?p=" +
        escape(f.p.value) + "&sv=" + d.w.sv.checked ? ‘on’ : ‘off’);
    return false;
}
绝不使用?:运算符选择两种行为之一

我们常质疑那些返回一个常量的函数，但这有时是在浏览器环境下所必需的。

下面我们看一个不正确使用?:运算符的例子。它常被用于在两个任务间选择。
function u(o, z) {
    var em = o.id.substring(1);
    var p = d.getElementById(’e’ + em);
    if (p) {
        (z == 0) ? p.style.backgroundColor = ‘#fff’ :
                   p.style.backgroundColor = ‘#989898′;
    }
    p = d.getElementById(’e’ + (em - 1));
    if (p) {
        (z == 0) ? p.style.backgroundColor = ‘#fff’ :
                   p.style.backgroundColor = ‘#989898′;
    }
}

对Z的判断是模糊不清的。Z正好等于0时我们选择#fff颜色，那么，Z不等于时？如上所述似乎指明的是前者，但它实际上是后者。在这个例子中幸运的是，我们大概想要的就是后者，所以它不是技术上错误（这次）。但是在文体上只糟糕的。

我们可以用if代替?:，但碰巧的是这些值对应的是同一个左值(lvalue)，所以我们无需if就可以改正这个错误。
function u(o, z) {
    var em = o.id.substring(1),
        p = d.getElementById(’e’ + em);
    if (p) {
        p.style.backgroundColor = z ? ‘#fff’ : ‘#989898′;
    }
    p = d.getElementById(’e’ + (em - 1));
    if (p) {
        p.style.backgroundColor = z ? ‘#fff’ : ‘#989898′;
    }
}
使用||运算符指定一个默认值

事件处理程序依赖于浏览器。理想情况下，应用程序应该通过公共库隔绝对浏览器的依赖。当没有这样的库时，就会有些函数发生如下情况：
function md(e) {
    (window.event) ? ev = window.event : ev = e;
    (ev.target) ? sr = ev.target : sr = ev.srcElement;
    if (ev && sr && sr.id == "fp" || sr.id == "sb") st = 1;
    if (sr.className.indexOf("pllist") < 0 && sr.className != "more" &&
            sr.className != "plinkc" && sr.tagName != "scrollbar " &&
            _toClose && _toCloseNorgie) {
        d.getElementById(_toClose).innerHTML = "";
        _toClose = "";
        _toCloseNorgie.parentNode.className = ”;
        _toCloseNorgie = ”;
    }
}

一些浏览器把事件对象作为一个参数传给事件管理程序。微软选用把事件对象放入到一个全局的事件变量中。在Javascript中，全局变量是全局对象的成员。在浏览器中，全局对象始终包含一个window对象成员，其值是全局对象。当测试一个变量是否存在时，通过window访问全局变量是避免未定义变量错误的一种方法。无论如何，做这样的测试不应该是必要的。

我们能通过问它是否是另外一种，来代替首先判断是否是微软事件。
ev = e || event;

我们用||(默认)运算符。如果e是真，我们将有它的值，但是如果e是假，则我们将用event。

在下一个语句，我们又用||运算符去确定sr是哪个值。

我们应该用var去声明ev和sr来避免全局冲突：
function md(e) {
    var ev = e || event,
        sr = ev.target || ev.srcElement;
    if (sr && (sr.id == ‘fp’ || sr.id == ’sb’)) {
        st = 1;
    }
    if (sr.className.indexOf(’pllist’) < 0 && sr.className != ‘more’ &&
            sr.className != ‘plinkc’ && sr.tagName != ’scrollbar ‘ &&
            _toClose && _toCloseNorgie) {
        d.getElementById(_toClose).innerHTML = ”;
        _toClose = ”;
        _toCloseNorgie.parentNode.className = ”;
        _toCloseNorgie = ”;
    }
}
全局变量是魔鬼

下面我们看到另一个时间处理程序。正如你所料，它重复像前面一样破坏风格。
function kd(e) {
    (window.event) ? ev = window.event : ev = e;
    (ev.target) ? el = ev.target : el = ev.srcElement;
    if (ev && el) {
        code = ev.keyCode;
        id = el.id;
    } else {
        return;
    }
    ctn = lt.id.substring(1);
    if (code == 13) {
        return;
    } else if ((code == 191 || code == 222) && id != ‘fp’) {
        _ffs = 1;
        gk = 0;
    } else if ((code < 31 || code > 41) &&
            (code < 16 || code > 18) && code != 9 && code != 8 ) {
        gk = 1;
    } else {
        gk = 0;
    }
    if (!_ffs && (id == ‘fp’ || id == ’st’)) {
        if (code == 9) {
            if (box.value == ” || (box.value != ” && (at == 1 || ev.shiftKey))) {
                mt(ctn);
            } else if (id == ’st’ && box.value != ” && at == 0) {
                at = 1;
                mt(ctn);
            }
        } else if (id == ‘fp’ && gk == 0 &&  (box.value == ” && st == 0)
                                 && !ev.shiftKey && !ev.ctrlKey && !ev.altKey) {
            d.getElementById(’mk’).focus();
            d.getElementById(’mk’).blur();
        } else if (gk == 1) {
            at = 0;
        }
    } else if ((id == ‘mk2′ && box.value != ” && ev.shiftKey && code == 9) ||
            (id == ‘m6′ && !ev.shiftKey && code == 9)){
        d.getElementById(’mk’).focus();
    } else if (!_ffs && gk == 1 && el.type != ‘text’ && !ev.ctrlKey && !ev.altKey){
        box.value = ”;
        box.focus();
    }
}
function mt(ctn) {
    if ((ev && !ev.ctrlKey && !ev.altKey) || !ev) {
        if (ev.shiftKey){
            nextTab = parseInt(ctn) - 1;
        } else {
            nextTab = parseInt(ctn) + 1;
        }
        if (nextTab == 0) {
            d.getElementById(’mk’).focus();
        } else if (nextTab < 8 ) {
            t(d.getElementById(’v’ + nextTab));
        } else {
            return;
        }
    }
}

有意思的是它有一个同伴函数mt，它仅被kd调用。mt被传给一个参数ctn，但kd和mt之间的通讯大部分是通过全局变量。
使用内部函数避免全局变量

我们可以通过增加传递给mt的参数数量来除掉所有的全局变量。但代替方案，我们将使mt变成kd的内部函数。作为一个内部函数，mt能访问kd的所有变量。
unction kd(e) {
    var ev = e || event,
        el = ev.target || ev.srcElement,
        cnt,
        code = ev.keyCode,
        gk,
        id = el.id,
        ctn = lt.id.substring(1);

    function mt() {
        var nextTab;
        if (!ev.ctrlKey && !ev.altKey) {
            nextTab = parseInt(ctn) + ev.shiftKey ? -1 : 1;
            if (!nextTab) {
                d.getElementById(’mk’).focus();
            } else if (nextTab < 8 ) {
                t(d.getElementById(’v’ + nextTab));
            }
        }
    }

    if (code == 13) {
        return;
    } else if ((code == 191 || code == 222) && id != ‘fp’) {
        _ffs = 1;
        gk = 0;
    } else if ((code < 31 || code > 41) &&
            (code < 16 || code > 18) && code != 9 && code != 8 ) {
        gk = 1;
    } else {
        gk = 0;
    }
    if (!_ffs && (id == ‘fp’ || id == ’st’)) {
        if (code == 9) {
            if (box.value == ” ||
                    (box.value != ” && (at == 1 || ev.shiftKey))) {
                mt();
            } else if (id == ’st’ && box.value != ” && at == 0) {
                at = 1;
                mt();
            }
        } else if (id == ‘fp’ && gk == 0 && (box.value == ” && st == 0) &&
                !ev.shiftKey && !ev.ctrlKey && !ev.altKey) {
            d.getElementById(’mk’).focus();
            d.getElementById(’mk’).blur();
        } else if (gk == 1) {
            at = 0;
        }
    } else if ((id == ‘mk2′ && box.value != ” && ev.shiftKey && code == 9) ||
            (id == ‘m6′ && !ev.shiftKey && code == 9)){
        d.getElementById(’mk’).focus();
    } else if (!_ffs && gk == 1 && el.type != ‘text’ && !ev.ctrlKey &&
            !ev.altKey) {
        box.value = ”;
        box.focus();
    }
}

在函数kd中，从两个地方调用函数mt。通过使它成为一个内部函数，我们能有效的减少kd所用到的全局变量的数目，这将降低了干扰其他组件的可能性。kd依旧是一个烂摊子，但它现在不是一无是处的烂摊子。

原文：Douglas Crockford的The Elements of JavaScript Style Part Two: Idioms

简介

这篇文章是为专业程序员介绍的JavaScript语言的，它是一种小巧的语言，如果你熟悉其他的编程语言，那么这篇文章对你来讲不是那么难以理解。

JavaScript不是Java，他们是两门完全不同的语言，JavaScript不是Java的子集，JavaScript不能被认为是Java(Java就是Java)。JavaScript分享了像Java一样分享C语言的语法，但从更深角度讲JavaScript更与Scheme 和Self有相似之处。它是一门小巧的语言，但是它确实强大的和丰富的语言。你应该好好观察一下它，你会发现它不是一个玩具语言，而是一个拥有许多与众不同特性的、完整的语言。

JavaScript是一门不用花太多时间学习的正规语言。它能更好地适合一些任务，比如与Java相比它更适合客户端编程。以我的实践经验，我发现用JavaScript工作使我成为一个更好的Java程序员，因为它给我带来一套丰富的技巧。

当我最初接触JavaScript时，我没有理他以为它不值得我的注意。后来，我对它刮目相看，因为我发现隐藏在浏览器中的它是一个如此有效的程序语言。我最初是在JavaScript在Sun和Netscape公司的初始陈述注意到它的。他们对JavaScript做了许多错误陈述，以免使它和Java处于竞争的位置。这些错误陈述继续充斥这那些只为傀儡和业余爱好者提供的、不好的JavaScript书中。

历史

JavaScript是被Netscape的Brendan Eich，作为一个页面脚本语言，在Navigator 2中开发的。它是一个非常具有表现力的动态程序语言，因为和浏览器的关系，它立刻变的大红大紫了。它从来没有得到一个可以校正它的问题的和基于真正使用目的测试周期，这一切导致它很强大却也有缺陷。

这篇文章描述了ECMAScript 版本3 (也叫 JavaScript 1.5)。 Microsoft和Netscape一起开发了一个没有改正缺陷的呆滞版本。新版本的语言也许不能叫JavaScript，也不在这篇文章的讨论范围内。

数据类型

JavaScript包含一小套数据类型，它有3种简单的类型：boolean, number, 和 string;特殊的值：null,undefined;其他的所有基于object类型的变化。

布尔类型有2个值：true和false。

数字是64位的浮点值，与Java的Double类似。它没有整型。除法运算可能带来小数位的结果。数字包括特殊值NaN(不是一个数字)和Infinity。

字符串(string)是从零到多个Unicode字符组成的。没有单独的字节类型。一个字节被描绘成一个长度为1的字符串。字符串被’符号或"符号引用到一起，单引号和双引号可以替换使用，但必须前后匹配使用。

‘This is a string.’

"Isn’t this a string? Yes!"

‘A’ // The character A

"" // An empty string

转义用\字符，就像Java一样。字符串是不可变的。字符串有一个length属性类查看字符串的用字符的个数。

var s = "Hello World!";

s.length == 12

可以给这些简单类型增加函数，你可以为所有数字类型增加一个int()的函数，当你调用Math.PI.int()的时候就会得到3这个结果。

一个实现可能提供其它类型，比如日期(Dates)类型,正则表达式类型，但是他们真正的类型是Object类型，所有其它类型都是Object类型。

对象

JavaScript拥有非常漂亮的符号便利以对付那些键值集合(哈希表)(hashtables)。

var myHashtable = {};

这条语句了声明了一个键值集合，并把它分配到一个局部变量里。JavaScript是弱类型的，所以我们不能用类型的名称来进行声明。我们用索引的方式从键值结合中增加、替换和获取对象。

myHashtable["name"] = "Carl Hollywood";

也可以使用“.”的方式带来一点便利。

myHashtable.city = "Anytown";

当索引是一个合法的系统保留字时，点符号就变得没用了。这是因为一个语言上的定义错误，保留字不能被用于点符号的形势下，但是可以用于索引的形式下。

你会发现JavaScript的哈希表符号与Java的对象和数组符号非常地相似。JavaScript把这更发扬广大了：对象和哈希表是一个回事，所以我可以这样写

var myHashtable = new Object();

这个结果确实是一样的。

用for语句可以实现对象一个枚举的能力。

for (var n in myHashtable) {

    if (myHashtable.hasOwnProperty(n)) {

        document.writeln("<p>" + n + ": " + myHashtable[n] + "</p>");

    }

}

这个结果应该是

<p>name: Carl Hollywood</p>

<p>city: Anytown</p>

一个对象就是一个涉及到键/值对的集合，键是字符串（或者其他的元素比如那些被转化为字符串的数字），值可以是任何数据类型，包括其他对象。对象经常以哈希表的方式实现，但是没有任何哈希表（比如哈希函数或重写的函数）天性的可见。

对象很容易被嵌套到别的对象当中，并且对象的表达式可以内容对象里使用。

this.div = document.body.children[document.body.children.length - 1];

对象的文字表达中，一个对象描述了包含在大括弧中的一组用逗点隔开的键/值对。键可以是在其后用冒号的标识符或字符串。由于语言定义的错误，系统预留字不能以标识符方式出现，但可以用字符串方式出现。值可以是任何类型的文字或表达式。

var myObject = {name: "Jack B. Nimble", ‘goto’: ‘Jail’, grade: ‘A’, level: 3};

return {

    event: event,

    op: event.type,

    to: event.srcElement,

    x: event.clientX + document.body.scrollLeft,

    y: event.clientY + document.body.scrollTop};

emptyObject = {};

JavaScript的对象模式是JSON的数据交换格式的基础。

新的成员可以在任何时候被附着增加到任何对象上。

myObject.nickname = ‘Jackie the Bee’;

数组和函数以对象方式实现。

数组

JavaScript中数组也是哈希表对象，这使它非常好地与稀少的数组程序相称。当你声明了一个数组，你不需要声明它的大小，数组会自增长，这很像Java的向量（vectors）。数组的值根据键来定位，而不是根据偏移量，这使JavaScript数组非常方便地使用，但不适合那些数字分析应用。

对象和数组最主要的不同点是length属性。length属性总是比最大的整数键大1。有2种方式创建一个新数组。

var myArray = [];

var myArray = new Array();

数组不是强类型，它可以包括数字、字符串、布尔值、对象、函数和数组，你可以在一个数组中混合使用字符串、数字和对象。你以嵌套序列的方式使用数组，这和s-expressions的方式非常地类似。数组的第一个索引通常用0。

当数组增加一个新元素的时候，它的索引是比数组长度。然后数组的长度变成在索引基础上加1。这个便利的特性使数组很容易在for循环中增加元素的数量。

数组有个与对象类似的符号标记。

myList = [’oats’, ‘peas’, ‘beans’, ‘barley’];

emptyArray = [];

month_lengths = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];

slides = [

    {url: ’slide0001.html’, title: ‘Looking&nbsp;Ahead’},

    {url: ’slide0008.html’, title: ‘Forecast’},

    {url: ’slide0021.html’, title: ‘Summary’}

];

新元素以分配的方式增加到数组中。

a[i + j] = f(a, a[j]);

函数

JavaScript的函数看起来想C语言的函数一样，但JavaScript用function声明而不是类型关键字。当调用一个函数时，传递指定数目的参数不是必须的，过度的参数会被忽略，丢失的参数被赋值为undefined，这使写一个处理可选参数的函数变的很容易。

一个函数有权使用一个参数数组，这个数组包含了所有的实际上被调用传递进来的参数。这使处理一个带可变数目的参数变的很容易，例如：

function sum() {  // Take any number of parameters and return the sum

    var total = 0;

    for (var i = 0; i < arguments.length; ++i) {

        total += arguments;

    }

    return total;

}

JavaScript有内部函数，这与Java的内部类起了相同的作用，但是不是那么地明显。JavaScript也有也有扮演着lambda表达式的匿名函数。函数有词法上的作用域。

函数是对象的第一课，这意味着函数可以被存储在对象中，并且作为参数传递给其它函数。

定义函数

有3种方式定义一个函数：function声明，function操作符和function构造器。

function声明

function声明在当前的作用域内创建一个被命名的函数。

function name(argumentlist) block

函数可以嵌套，必须闭合，有0个或多个以逗号隔开的参数名称。block是由0个或多个{ }附着着。

function声明以function操作符形式速记：

var name = function name (argumentlist) block ;

function操作符

function操作符是一个产生一个对象的前缀操作符，它看起来和function声明很类似。

function name(argumentlist) block

名称是可选的，如果提供了，那么可以用于函数的递归调用。这也用于访问函数的对象成员(除了IE以外)。如果名称被省略了，那么它就是一个匿名函数。

函数的操作符经常用于把它分配给一个原型（prototype）。

函数的操作符也经常用于在适当的地方定义函数，比迅速地得到当写回调的时候。( The function operator can also be used to define functions in-place, which is handy when writing callbacks.)

function构造器

function构造器携带字符包含在参数和内部，从而产生一个function对象。

new Function(strings…)

不要使用这种方式，由于语言引用的惯例导致很难恰当的表达一个函数身体作为一个字符串。在字符形式中，早期的错误检查不起作用。这也是很慢的，因为编译器必须被触发每当构造器被调用的时候，并且这样浪费内存，因为每个函数需要它自己独立的实现。

对象和this

一个函数是一个对象，它可以包含成员就像其它对象一样。这就允许一个函数包含它自己的数据表，这也允许一个对象扮演一个“类”，包含构造函数和一套相关的函数。

一个方式可以是一个对象的成员，当一个函数是一个对象的成员的时候，被成为“方法”。有一个特殊的变量，叫做“this”，当一个对象的方式被调用时指向了对象。

例如：在表达式foo.bar()中，this变量就指向了对象foo，它作为了函数bar的一个额外的参数。函数bar可以使用this进入对象内部以找到有用的项目。

一个深一点的表示式do.re.mi.fa()，this变量指向了对象do.re.mi，而不是对象do。在一个简单的函数调用中，this指向了没有太大用的Global Object (也叫 window)。当调用一个内部函数时，正确的行为是保护好当前this的值。

构造器

当函数被用于初始化对象的时候被叫做构造器，调用一个构造器的次序与调用一个普通的函数有一些细微的不同。一个构造器带着new前缀被调用：

new Constructor(parameters…)

根据习惯，构造器的名字的首字母使用大写的。

new前缀改变了this 的含义，不是平常的值，而是代表了“新对象”。构造器的身体将会初始化对象的成员。构造起将会返回一个新对象，除非明确的使用了return语句进行替换。

被构造的对象将会包含一个秘密的指向了构造器的prototype的成员的原型链接域。

原型(Prototype)

对象包含一个隐藏的连接属性，这个链接指向了prototype，就是构造器的实例。

当条目以点形式或索引形式从一个对象被访问的时候，如果条目没有在对象中被发现那么就检查他的链接对象，如果链接对象中也没发现，那么如果链接对象本身有一个链接对象，那么就继续检查这个链接对象，如果链接对象所有环节都检查完毕，那么就返回undefined。

原型用于链接住一系列的继承

成员可以用分配的方式增加到prototype中来，这我们定义一个类Demo，它从Ancestor继承，并增加了它独有的方法foo。

function Demo() {}

Demo.prototype = new Ancestor();

Demo.prototype.foo = function () {};

变量

定义变量使用var语句。当变量在函数内部定义时，var有着函数范围（function-scope）级别，这个变量不能在函数外被访问。JavaScript中没有其他的范围域粒度了，更具体的说，JavaScript中没有块域（block-scope）。

任何在函数中使用但没有用var明确定义的变量，都会被假定属于全局对象。

任何没有被明确初始化的变量都会被赋值于undefined。

变量不是强类型的，一个变量引用一个对象、字符串、数字、布尔值、null值或者是undefined。

当函数被调用的时候会产生一套新的变量，这允许递归的调用。

闭合

函数可以被定义到其他函数中，内部函数有权使用在外部函数定义的变量，如果一个引用内部函数继续存在（例如一个回调函数），那么外部函数的变量也将继续存在。

返回值

JavaScript没有void类型，所以每个函数都必须返回一个值，除了构造器之外默认值是undefined，构造器的默认返回值是this

语句

语句包括 var, if, switch, for, while, do, break, continue, return, try, throw, and with，它们大多数与C类的语言相同。

var语句是一个或多个变量名称的列表，它们以逗号隔开，带着可选的初始化表达式。

var a, b = window.document.body;

如果var语句出现在所有的函数之外那么就声明了一个全局的变量。如果出现在一个函数内，就声明了一个局部的变量。

在if语句，while语句，do语句， 和符合逻辑的操作符中，JavaScript视为false，null，undefined， ""(空字符串)，和数字0作为假（false）。其它所有值被视为真（true）。

在switch语句中的case标记可以是表达式，它们不必非得是常数，也可以是字符串。

有2种形式的for语句，第一种像这样 (init; test; inc)形式。第二种是对象重复器。

for (name in object) {

    if (object.hasOwnProperty(name)) {

        value = object[name];

    }

}

上面执行在object中的每一个name，名字产生的次序是不确定的。

语句可以有个前缀，就是一个标识符跟着一个冒号。

with语句不应该被使用

操作符

JavaScript有还算完整的操作符，大多数他们都与C类的语言工作的方式相同，但请注意一些细微的差异

+操作符用于加法和字符串联，如果任意操作数是字符串，那么进行串联，这可能会引起错误，比如说’$’ + 3 + 4 会得到’$34′，而不是’$7′。

+可以作为一个前缀操作符把字符操作数转化为数字。

!!可以作为一个前缀操作符，转化操作数为布尔值。

&&操作符，一般被称为“逻辑与”(logical and)，它也被称为guard，如果第一个操作数是false、null、undefined、""(空字符串)或者数字0那么将返回第一个操作数，否则将返回第二个操作数。这提供了一个便利地测试null值的方法：

var value = p && p.name; /* The name value will

only be retrieved from p if p has a value, avoiding an error. */

||操作符一般被称为“逻辑或”(logical or)，它也被称为default，如果第一个操作数是false、null、undefined、""(空字符串)或者数字0， 那么将返回第二个操作数，否则返回第一个操作数。这提供了一个便利地设定默认值的方式：

value = v || 10; /* Use the value of v, but if v

doesn’t have a value, use 10 instead. */

JavaScript支持一套逐位和移位的操作运算符，但却没有偶提供整型将他们应用。当一个数字操作数（一个64位浮点数）转化成32位整型的在运算之前，然后在转化回浮点数在操作在运算之后会发生什么呢？

在JavaScript中，void是一个前缀操作符，而不是一种类型，它总是返回undefined值。这仅仅有一点点价值，我提到它的原因是万一你不小心以习惯打出来它，而不会被它怪异的行为所迷惑。

typeof操作符返回一个基于它的操作数的字符串

错误产生了。
Object    
‘object’

Array    
‘object’

Function    
‘function’

String    
’string’

Number    
‘number’

Boolean    
‘boolean’

null    
‘object’

undefined    
‘undefined’

杂目

全局对象

全局对象包含着所有的函数和所有的那些不在任何函数内定义的变量和对象，令人惊讶的是，全局变量在语言中并没有一个确切的名字。一些时候，this指向它，但大多数情况并不是的。在浏览器中window和self都是指向全局对象的全局对象成员，因此给了一个间接的对它的寻址方法。

如果一个变量可以被访问，但是没有在当前域下被找到，就会在全局对象范围查找，如果仍没有，就会返回错误。

ECMAScript规范没有谈论关于多个全局对象的可行性,或者上下文关系，但是浏览器支持这个，每个窗口都有它自己的全局对象。

分号的插入时机

这个语言的一个错误及时分号的插入，有一个技巧是用分号来终止语句。用各种开发工具去进行插入工作是合理的，没有必要为了语言的定义而让编译器去去做，请使用分号。

预留字

JavaScript对系统预留字的支持严重的过了头，这些预留字是：

abstract
boolean break byte
case catch char class const continue
debugger default delete do double
else enum export extends
false final finally float for function
goto
if implements import in instanceof int interface
long
native new null
package private protected public
return
short static super switch synchronized
this throw throws transient true try typeof
var volatile void
while with

很大一部分这些关键字并没有在JavaScript中使用，一个预留字不可以在如下的方式下被使用：

1. 作为一个对象名字标记

2. 作为点形式的的成员

3. 作为函数的参数

4. 作为一个var

5. 作为一个绝对的全局变量

6. 作为一个语句标号(As a statement label)

前2个限制是不可原谅的，绝对不要使用。接下来的2个的使用可以被接受，但是这样使用是非常不牢靠的。

特别声明，文章翻译于 A Survey of the JavaScript Programming Language
版权由原作者所有。

最近一位朋友的ASP.NET程序怀疑有内存泄露问题。几个简单的页面，起来运行几分钟后，虚拟内存就到600多MB。从性能监视上看，private bytes只有200多MB。

这样的问题从经验上来说，十有八九都是内存碎片了。ASP.NET程序发生内存碎片的原因比较多，我常见的有:

1. Web.config中的debug=true，导致batch compilation=false,使得每一个ASPX页面都生成一个临时assembly。当页面比较多的时候，大量的assembly导致内存泄露。
2. 程序中误用了XmlSerializer。频繁的XML序列化导致大量的动态assembly
3. 程序中有大量的blocking IO操作，而且IO buffer没有及时释放。比如程序中有大量的Web Service调用，但是对方web service返回比较慢，使得调用程序中用来接收web service结果的小块buffer大量堆积，导致内存泄露

下面是我拿到dump后的分析步骤。对于managed程序，找出问题的大致线索还是挺简单的。

(随便无耻地推销下，《Windows高效排错》书中对这样的问题有更多的讨论。包括更多的案例和命令解释。该书最初的PDF草稿在http://www.cnblogs.com/lixiong/archive/2006/08/16/475520.html。如果有朋友从这个PDF中找到过排错的灵感，麻烦也帮忙无耻推销下。)

首先是看看CLR的版本了。这个直接看mscorwks文件或者mscorsrv文件。如果文件版本比较低，后面的就没必要仔细看了，升级CLR补丁后再说。

0:000> lmvm mscorwks
start    end        module name
79e70000 7a3d6000   mscorwks   (deferred)            
    Image path: C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\mscorwks.dll
    Image name: mscorwks.dll
    Timestamp:        Fri Apr 13 15:15:54 2007 (461F2E2A)
    CheckSum:         00564CA8
    ImageSize:        00566000
    File version:     2.0.50727.832
    Product version:  2.0.50727.832
    File flags:       0 (Mask 3F)
    File OS:          4 Unknown Win32
    File type:        2.0 Dll
    File date:        00000000.00000000
    Translations:     0409.04b0
    CompanyName:      Microsoft Corporation
    ProductName:      Microsoft® .NET Framework
    InternalName:     mscorwks.dll
    OriginalFilename: mscorwks.dll
    ProductVersion:   2.0.50727.832
    FileVersion:      2.0.50727.832 (QFE.050727-8300)
    FileDescription:  Microsoft .NET Runtime Common Language Runtime - WorkStation
    LegalCopyright:   © Microsoft Corporation.  All rights reserved.
    Comments:         Flavor=Retail

恩，版本还是比较新的。既然是内存问题，先看GC中有多少object，占用了多少内存

0:000> !eeheap -gc
Number of GC Heaps: 4
——————————
Heap 0 (000f3f10)
generation 0 starts at 0×02fad2fc
generation 1 starts at 0×02f83ff8
generation 2 starts at 0×02f00038
ephemeral segment allocation context: none
segment    begin allocated     size
00109198 7a72c42c  7a74d308 0×00020edc(134876)
000fdfb0 790d5588  790f4b38 0×0001f5b0(128432)
02f00000 02f00038  03081450 0×00181418(1578008)
Large object heap starts at 0×12f00038
segment    begin allocated     size
12f00000 12f00038  131b00a0 0×002b0068(2818152)
Heap Size  0×47190c(4659468)
——————————
Heap 1 (000f50a0)
generation 0 starts at 0×06f5b110
generation 1 starts at 0×06f5acf8
generation 2 starts at 0×06f00038
ephemeral segment allocation context: none
segment    begin allocated     size
06f00000 06f00038  06ff511c 0×000f50e4(1003748)
Large object heap starts at 0×14f00038
segment    begin allocated     size
14f00000 14f00038  14f00048 0×00000010(16)
Heap Size   0xf50f4(1003764)
——————————
Heap 2 (000f68a0)
generation 0 starts at 0×0af78634
generation 1 starts at 0×0af09d40
generation 2 starts at 0×0af00038
ephemeral segment allocation context: none
segment    begin allocated     size
0af00000 0af00038  0af92a0c 0×000929d4(600532)
Large object heap starts at 0×16f00038
segment    begin allocated     size
16f00000 16f00038  16f00048 0×00000010(16)
Heap Size   0×929e4(600548)
——————————
Heap 3 (000f7bc8)
generation 0 starts at 0×0ef7b270
generation 1 starts at 0×0ef7b264
generation 2 starts at 0×0ef00038
ephemeral segment allocation context: none
segment    begin allocated     size
0ef00000 0ef00038  0ef7d27c 0×0007d244(512580)
Large object heap starts at 0×18f00038
segment    begin allocated     size
18f00000 18f00038  18f00048 0×00000010(16)
Heap Size   0×7d254(512596)
——————————
GC Heap Size  0×676638(6776376)

内存占用只有6M，显然不是CLR object导致的问题。那看来真的就是内存碎片了。于是先看看程序中有多少DLL:
0:000> lmf
start    end        module name
00900000 00bc5000   xpsp2res C:\WINDOWS\system32\xpsp2res.dll
01000000 01005000   w3wp     c:\WINDOWS\system32\inetsrv\w3wp.exe
1b740000 1b748000   App_global_asax_incckcvw C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\Temporary ASP.NET Files\root\b972f933\24c4c459\App_global.asax.incckcvw.dll
1b770000 1b790000   Boke_WebRoot_Admin C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\Temporary ASP.NET Files\root\b972f933\24c4c459\assembly\dl3\0854db20\0aaa279d_a314c801\Boke.WebRoot.Admin.DLL
1b7e0000 1b820000   log4net  C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\Temporary ASP.NET Files\root\b972f933\24c4c459\assembly\dl3\8af1019b\00a071ef_de00c801\log4net.DLL
1bb00000 1bb0e000   App_Web_fsrghzyk C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\Temporary ASP.NET Files\root\b972f933\24c4c459\App_Web_fsrghzyk.dll
1bb20000 1bb30000   AspNetPager C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\Temporary ASP.NET Files\root\b972f933\24c4c459\assembly\dl3\53ce5ce1\00a071ef_de00c801\AspNetPager.DLL
1bb30000 1bb3c000   App_Web_qenznn_e C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\Temporary ASP.NET Files\root\b972f933\24c4c459\App_Web_qenznn_e.dll
1bb60000 1bb70000   UDMap    D:\webfolder\dvdvAdmin\bin\Map.dll
50210000 5025c000   SMDiagnostics_ni C:\WINDOWS\assembly\NativeImages_v2.0.50727_32\SMDiagnostics\da4366daf8361c62ed3fcec4c55fa9ca\SMDiagnostics.ni.dll
50270000 50368000   System_IdentityModel_ni C:\WINDOWS\assembly\NativeImages_v2.0.50727_32\System.IdentityModel\bc31a40dee949687576d5395efcab6a0\System.IdentityModel.ni.dll
504e0000 50728000   System_Runtime_Serialization_ni C:\WINDOWS\assembly\NativeImages_v2.0.50727_32\System.Runtime.Seri#\c861896fa11d6eef9fed23cff7b77b01\System.Runtime.Serialization.ni.dll
507a0000 5185e000   System_ServiceModel_ni C:\WINDOWS\assembly\NativeImages_v2.0.50727_32\System.ServiceModel\719a7cce9b36b780b3edd9869ceb2537\System.ServiceModel.ni.dll
5a300000 5a307000   w3tp     c:\WINDOWS\system32\inetsrv\w3tp.dll
5a320000 5a332000   w3isapi  c:\WINDOWS\system32\inetsrv\w3isapi.dll
5a360000 5a36d000   w3dt     c:\WINDOWS\system32\inetsrv\w3dt.dll
5a390000 5a3e8000   w3core   c:\WINDOWS\system32\inetsrv\w3core.dll
5a3f0000 5a3f6000   w3comlog c:\WINDOWS\system32\inetsrv\w3comlog.dll
5a400000 5a408000   w3cache  c:\WINDOWS\system32\inetsrv\w3cache.dll
5a420000 5a431000   iismap   C:\WINDOWS\system32\iismap.dll
5b640000 5b658000   strmfilt C:\WINDOWS\system32\strmfilt.dll
5e620000 5e6da000   Microsoft_JScript C:\WINDOWS\assembly\GAC_MSIL\Microsoft.JScript\8.0.0.0__b03f5f7f11d50a3a\Microsoft.JScript.dll
5f270000 5f2ca000   hnetcfg  C:\WINDOWS\system32\hnetcfg.dll
60060000 60066000   aspnet_filter C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\aspnet_filter.dll
60070000 60075000   aspnet_isapi \\?\c:\WINDOWS\microsoft.net\framework\v2.0.50727\aspnet_isapi.dll
608f0000 60901000   admwprox C:\WINDOWS\system32\admwprox.dll
60ba0000 60bb1000   wamreg   c:\WINDOWS\system32\inetsrv\wamreg.dll
62da0000 62da7000   lonsint  c:\WINDOWS\system32\inetsrv\lonsint.dll
637a0000 63d02000   System_Xml_ni C:\WINDOWS\assembly\NativeImages_v2.0.50727_32\System.Xml\e342cc4334d3ab13ce752de73164c01b\System.Xml.ni.dll
64700000 6472d000   iisutil  c:\WINDOWS\system32\inetsrv\iisutil.dll
647b0000 647d7000   iisrtl   C:\WINDOWS\system32\iisrtl.dll
64890000 6498a000   System_Configuration_ni C:\WINDOWS\assembly\NativeImages_v2.0.50727_32\System.Configuration\edc1f15b90b2c6a4dc59b305f14bb98d\System.Configuration.ni.dll
64e70000 6513c000   System_Data C:\WINDOWS\assembly\GAC_32\System.Data\2.0.0.0__b77a5c561934e089\System.Data.dll
65140000 657a6000   System_Data_ni C:\WINDOWS\assembly\NativeImages_v2.0.50727_32\System.Data\42481d9f835b4b6c150c50d2642781b9\System.Data.ni.dll
65f20000 66ac6000   System_Web_ni C:\WINDOWS\assembly\NativeImages_v2.0.50727_32\System.Web\83c662f1a20af1b2deea3f9a040ccbd6\System.Web.ni.dll
67150000 67159000   httpapi  C:\WINDOWS\system32\httpapi.dll
68000000 68035000   rsaenh   C:\WINDOWS\system32\rsaenh.dll
685b0000 685ba000   gzip     C:\WINDOWS\system32\inetsrv\gzip.dll
695a0000 697da000   System_Web_Mobile_ni C:\WINDOWS\assembly\NativeImages_v2.0.50727_32\System.Web.Mobile\e7d2fee1612b52a914d8d253d5e49a7c\System.Web.Mobile.ni.dll
69890000 698d0000   System_Web_RegularExpressions_ni C:\WINDOWS\assembly\NativeImages_v2.0.50727_32\System.Web.RegularE#\1fa927a42b36176da2cdc193f0435950\System.Web.RegularExpressions.ni.dll
6a2a0000 6a307000   webengine \\?\c:\WINDOWS\microsoft.net\framework\v2.0.50727\webengine.dll
6d0f0000 6d110000   iisres   c:\WINDOWS\system32\inetsrv\iisres.dll
71640000 7180d000   acgenral C:\WINDOWS\AppPatch\acgenral.dll
71ae0000 71ae8000   wshtcpip C:\WINDOWS\system32\wshtcpip.dll
71af0000 71b12000   shimeng  C:\WINDOWS\system32\shimeng.dll
71b20000 71b61000   mswsock  C:\WINDOWS\system32\mswsock.dll
71b70000 71ba6000   uxtheme  C:\WINDOWS\system32\uxtheme.dll
71bb0000 71bb9000   wsock32  C:\WINDOWS\system32\wsock32.dll
71bd0000 71be1000   mpr      C:\WINDOWS\system32\mpr.dll
71bf0000 71bf8000   ws2help  C:\WINDOWS\system32\ws2help.dll
71c00000 71c17000   ws2_32   C:\WINDOWS\system32\ws2_32.dll
71c40000 71c97000   netapi32 C:\WINDOWS\system32\netapi32.dll
745e0000 7489e000   msi      C:\WINDOWS\system32\msi.dll
75490000 754f5000   usp10    C:\WINDOWS\system32\usp10.dll
75e60000 75e87000   apphelp  C:\WINDOWS\system32\apphelp.dll
76190000 761a2000   msasn1   C:\WINDOWS\system32\msasn1.dll
761b0000 76243000   crypt32  C:\WINDOWS\system32\crypt32.dll
76290000 762ad000   imm32    C:\WINDOWS\system32\imm32.dll
76920000 769e2000   userenv  C:\WINDOWS\system32\userenv.dll
76aa0000 76acd000   winmm    C:\WINDOWS\system32\winmm.dll
76b70000 76b7b000   psapi    C:\WINDOWS\system32\psapi.dll
76c90000 76cb7000   msv1_0   C:\WINDOWS\system32\msv1_0.dll
76cf0000 76d0a000   iphlpapi C:\WINDOWS\system32\iphlpapi.dll
76e30000 76e3c000   rtutils  C:\WINDOWS\system32\rtutils.dll
76e40000 76e52000   rasman   C:\WINDOWS\system32\rasman.dll
76e60000 76e8f000   tapi32   C:\WINDOWS\system32\tapi32.dll
76e90000 76ecf000   rasapi32 C:\WINDOWS\system32\rasapi32.dll
76ed0000 76efa000   dnsapi   C:\WINDOWS\system32\dnsapi.dll
76f10000 76f3e000   wldap32  C:\WINDOWS\system32\wldap32.dll
76f50000 76f63000   secur32  C:\WINDOWS\system32\secur32.dll
76f70000 76f77000   winrnr   C:\WINDOWS\system32\winrnr.dll
76f80000 76f85000   rasadhlp C:\WINDOWS\system32\rasadhlp.dll
77010000 770d6000   comres   C:\WINDOWS\system32\comres.dll
77380000 77411000   user32   C:\WINDOWS\system32\user32.dll
77420000 77523000   comctl32 C:\WINDOWS\WinSxS\x86_Microsoft.Windows.Common-Controls_6595b64144ccf1df_6.0.3790.3959_x-ww_D8713E55\comctl32.dll
77670000 777a9000   ole32    C:\WINDOWS\system32\ole32.dll
777b0000 77833000   clbcatq  C:\WINDOWS\system32\clbcatq.dll
77b70000 77b84000   msacm32  C:\WINDOWS\system32\msacm32.dll
77b90000 77b98000   version  C:\WINDOWS\system32\version.dll
77ba0000 77bfa000   msvcrt   C:\WINDOWS\system32\msvcrt.dll
77c00000 77c48000   gdi32    C:\WINDOWS\system32\gdi32.dll
77c50000 77cef000   rpcrt4   C:\WINDOWS\system32\rpcrt4.dll
77d00000 77d8b000   oleaut32 C:\WINDOWS\system32\oleaut32.dll
77da0000 77df2000   shlwapi  C:\WINDOWS\system32\shlwapi.dll
77e00000 77e21000   ntmarta  C:\WINDOWS\system32\ntmarta.dll
77e40000 77f42000   kernel32 C:\WINDOWS\system32\kernel32.dll
77f50000 77feb000   advapi32 C:\WINDOWS\system32\advapi32.dll
78130000 781cb000   msvcr80  C:\WINDOWS\WinSxS\x86_Microsoft.VC80.CRT_1fc8b3b9a1e18e3b_8.0.50727.42_x-ww_0DE06ACD\msvcr80.dll
79000000 79045000   mscoree  C:\WINDOWS\system32\mscoree.dll
79060000 790b3000   mscorjit C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\mscorjit.dll
790c0000 79b90000   mscorlib_ni C:\WINDOWS\assembly\NativeImages_v2.0.50727_32\mscorlib\56cbcbd518a77421a852a37b61624936\mscorlib.ni.dll
79e70000 7a3d6000   mscorwks C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\mscorwks.dll
7a440000 7ac06000   System_ni C:\WINDOWS\assembly\NativeImages_v2.0.50727_32\System\19aba12bb5350aa99107e93bafbb4f51\System.ni.dll
7ade0000 7af6c000   System_Drawing_ni C:\WINDOWS\assembly\NativeImages_v2.0.50727_32\System.Drawing\e3104e1713757f14b54b7835be2a0e26\System.Drawing.ni.dll
7c800000 7c8c0000   ntdll    C:\WINDOWS\system32\ntdll.dll
7c8d0000 7d0ce000   shell32  C:\WINDOWS\system32\shell32.dll
7e020000 7e02f000   samlib   C:\WINDOWS\system32\samlib.dll
7f000000 7f009000   lpk      C:\WINDOWS\system32\lpk.dll

非常普通。也就这点DLL，根本没有导致内存碎片的潜力呀！不死心，看看是不是有很多线程被block住了。要是有个几百个线程，嘿嘿
0:000> ~
.  0  Id: 694.540 Suspend: 1 Teb: 7ffdd000 Unfrozen
   1  Id: 694.12a0 Suspend: 1 Teb: 7ffdb000 Unfrozen
   2  Id: 694.1040 Suspend: 1 Teb: 7ffda000 Unfrozen
   3  Id: 694.11f0 Suspend: 1 Teb: 7ffd9000 Unfrozen
   4  Id: 694.13d0 Suspend: 1 Teb: 7ffd7000 Unfrozen
   5  Id: 694.1338 Suspend: 1 Teb: 7ffd6000 Unfrozen
   6  Id: 694.10e4 Suspend: 1 Teb: 7ffd5000 Unfrozen
   7  Id: 694.e4c Suspend: 1 Teb: 7ffd4000 Unfrozen
   8  Id: 694.10a8 Suspend: 1 Teb: 7ffd3000 Unfrozen
   9  Id: 694.1144 Suspend: 1 Teb: 7ff9f000 Unfrozen
  10  Id: 694.1340 Suspend: 1 Teb: 7ff9e000 Unfrozen
  11  Id: 694.1484 Suspend: 1 Teb: 7ff9d000 Unfrozen
  12  Id: 694.1170 Suspend: 1 Teb: 7ff9c000 Unfrozen
  13  Id: 694.11d8 Suspend: 1 Teb: 7ff9b000 Unfrozen
  14  Id: 694.1768 Suspend: 1 Teb: 7ff9a000 Unfrozen
  15  Id: 694.173c Suspend: 1 Teb: 7ff99000 Unfrozen
  16  Id: 694.a80 Suspend: 1 Teb: 7ff98000 Unfrozen
  17  Id: 694.500 Suspend: 1 Teb: 7ff97000 Unfrozen
  18  Id: 694.1194 Suspend: 1 Teb: 7ff96000 Unfrozen
  19  Id: 694.16c8 Suspend: 1 Teb: 7ff95000 Unfrozen
  20  Id: 694.162c Suspend: 1 Teb: 7ff94000 Unfrozen
  21  Id: 694.a8c Suspend: 1 Teb: 7ff93000 Unfrozen
  22  Id: 694.ad4 Suspend: 1 Teb: 7ff92000 Unfrozen
  23  Id: 694.1098 Suspend: 1 Teb: 7ff2f000 Unfrozen
  24  Id: 694.b08 Suspend: 1 Teb: 7ff2e000 Unfrozen
  25  Id: 694.19c Suspend: 1 Teb: 7ff90000 Unfrozen
  26  Id: 694.fcc Suspend: 1 Teb: 7ff2d000 Unfrozen
  27  Id: 694.764 Suspend: 1 Teb: 7ff91000 Unfrozen
  28  Id: 694.1334 Suspend: 1 Teb: 7ff2b000 Unfrozen

。。。线程也这么少，怎么办

还是不死心。从上面的DLL看到，程序中的模块要么系统的，要么CLR的，没有COM/COM+，问题应该还是在CLR相关的东西上。于是用!eeheap –loader看看loader heap的大小:

0:000> !eeheap -loader
Loader Heap:
————————————–
System Domain: 7a38f918
LowFrequencyHeap: Size: 0×0(0)bytes.
HighFrequencyHeap: 02e72000(8000:1000) Size: 0×1000(4096)bytes.
StubHeap: 02e7a000(2000:2000) 1b5b0000(10000:4000) Size: 0×6000(24576)bytes.
Virtual Call Stub Heap:
  IndcellHeap: Size: 0×0(0)bytes.
  LookupHeap: Size: 0×0(0)bytes.
  ResolveHeap: Size: 0×0(0)bytes.
  DispatchHeap: Size: 0×0(0)bytes.
  CacheEntryHeap: Size: 0×0(0)bytes.
Total size: 0×7000(28672)bytes
————————————–
Shared Domain: 7a38fef0
LowFrequencyHeap: 02ea0000(2000:1000) 1b6d0000(10000:d000) Size: 0xe000(57344)bytes.
Wasted: 0×1000(4096)bytes.
HighFrequencyHeap: 02ea2000(8000:5000) Size: 0×5000(20480)bytes.
StubHeap: 02eaa000(2000:1000) 1bc80000(10000:1000) Size: 0×2000(8192)bytes.
Wasted: 0×1000(4096)bytes.
Virtual Call Stub Heap:
  IndcellHeap: 02eb0000(2000:1000) Size: 0×1000(4096)bytes.
  LookupHeap: 02eb5000(2000:1000) Size: 0×1000(4096)bytes.
  ResolveHeap: 02ebb000(5000:5000) 1bc10000(10000:2000) Size: 0×7000(28672)bytes.
  DispatchHeap: 02eb7000(4000:3000) Size: 0×3000(12288)bytes.
  CacheEntryHeap: 02eb2000(3000:1000) Size: 0×1000(4096)bytes.
Total size: 0×21000(135168)bytes
————————————–
Domain 1: ded80
LowFrequencyHeap: 02e80000(2000:1000) Size: 0×1000(4096)bytes.
HighFrequencyHeap: 02e82000(8000:4000) Size: 0×4000(16384)bytes.
StubHeap: Size: 0×0(0)bytes.
Virtual Call Stub Heap:
  IndcellHeap: Size: 0×0(0)bytes.
  LookupHeap: Size: 0×0(0)bytes.
  ResolveHeap: Size: 0×0(0)bytes.
  DispatchHeap: Size: 0×0(0)bytes.
  CacheEntryHeap: Size: 0×0(0)bytes.
Total size: 0×5000(20480)bytes
————————————–
Domain 2: 113b60
LowFrequencyHeap: 1b550000(2000:2000) 1b760000(10000:f000) 1b830000(10000:10000) 1bcd0000(10000:f000) 1c150000(10000:10000) 1c260000(10000:10000) 1c300000(10000:10000) 1c380000(10000:10000) 1c430000(10000:10000) 1c510000(10000:10000) 1c5c0000(10000:10000) 1c6b0000(10000:10000) 1c750000(10000:10000) 1c800000(10000:f000) 1c8b0000(10000:f000) 1c920000(10000:10000) ……
1db30000(10000:f000) 1dbc0000(10000:f000) 1dca0000(10000:f000) 1dd50000(10000:10000) 1de00000(10000:10000) 1de90000(10000:10000) 1df40000(10000:10000) 1dfb0000(10000:10000) 1df90000(10000:f000) 1e0e0000(10000:f000) 1e180000(10000:10000) 1e230000(10000:10000) 1e2d0000(10000:10000) 1e370000(10000:10000) 1e420000(10000:f000) 1e4b0000(10000:f000) 1e550000(10000:f000) 1e600000(10000:10000) 1e6b0000(10000:10000) 1e740000(10000:10000) 1e7f0000(10000:10000) 1e8e0000(10000:10000) 1eb60000(10000:f000) 1ec10000(10000:f000) 1ed30000(10000:10000) 1eda0000(10000:10000) 1ee40000(10000:c000) Size: 0×447000(4485120)bytes.
Wasted: 0×17000(94208)bytes.
HighFrequencyHeap: 1b552000(8000:8000) 1b820000(10000:f000) 1bb80000(10000:10000) 1c120000(10000:10000) 1c230000(10000:f000) 1c2d0000(10000:10000) 1c390000(10000:10000) 1c460000(10000:10000) 1c570000(10000:10000) 1c610000(10000:10000) 1c720000(10000:f000) 1c7d0000(10000:10000) ……
1dd20000(10000:10000) 1ddf0000(10000:10000) 1dea0000(10000:10000) 1df20000(10000:f000) 1df30000(10000:10000) 1e080000(10000:10000) 1e150000(10000:10000) 1e220000(10000:10000) 1e2e0000(10000:10000) 1e3b0000(10000:f000) 1e450000(10000:10000) 1e500000(10000:10000) 1e5d0000(10000:10000) 1e6a0000(10000:10000) 1e750000(10000:10000) 1e860000(10000:f000) 1e910000(10000:10000) 1ebb0000(10000:10000) 1ec80000(10000:10000) 1ed90000(10000:10000) 1ee50000(10000:9000) Size: 0×3b8000(3899392)bytes.
Wasted: 0×9000(36864)bytes.
StubHeap: 1b55a000(2000:1000) Size: 0×1000(4096)bytes.
Virtual Call Stub Heap:
  IndcellHeap: 1b5a0000(3000:1000) Size: 0×1000(4096)bytes.
  LookupHeap: 1b5a6000(3000:1000) Size: 0×1000(4096)bytes.
  ResolveHeap: 1b5ac000(4000:1000) Size: 0×1000(4096)bytes.
  DispatchHeap: 1b5a9000(3000:1000) Size: 0×1000(4096)bytes.
  CacheEntryHeap: 1b5a3000(3000:1000) Size: 0×1000(4096)bytes.
Total size: 0×804000(8404992)bytes
————————————–
Jit code heap:
LoaderCodeHeap: 1ee10000(10000:c000) Size: 0xc000(49152)bytes.
LoaderCodeHeap: 1ed60000(10000:10000) Size: 0×10000(65536)bytes.
LoaderCodeHeap: 1ebe0000(10000:10000) Size: 0×10000(65536)bytes.
LoaderCodeHeap: 1e8d0000(10000:10000) Size: 0×10000(65536)bytes.
LoaderCodeHeap: 1e7a0000(10000:10000) Size: 0×10000(65536)bytes.
LoaderCodeHeap: 1e690000(10000:10000) Size: 0×10000(65536)bytes.
LoaderCodeHeap: 1e5a0000(10000:10000) Size: 0×10000(65536)bytes.
LoaderCodeHeap: 1e4a0000(10000:10000) Size: 0×10000(65536)bytes.
LoaderCodeHeap: 1e3a0000(10000:10000) Size: 0×10000(65536)bytes.
……
LoaderCodeHeap: 1cb70000(10000:10000) Size: 0×10000(65536)bytes.
LoaderCodeHeap: 1ca50000(10000:10000) Size: 0×10000(65536)bytes.
LoaderCodeHeap: 1c980000(10000:10000) Size: 0×10000(65536)bytes.
LoaderCodeHeap: 1c870000(10000:10000) Size: 0×10000(65536)bytes.
LoaderCodeHeap: 1c780000(10000:10000) Size: 0×10000(65536)bytes.
LoaderCodeHeap: 1c640000(10000:10000) Size: 0×10000(65536)bytes.
LoaderCodeHeap: 1c540000(10000:10000) Size: 0×10000(65536)bytes.
LoaderCodeHeap: 1c400000(10000:10000) Size: 0×10000(65536)bytes.
LoaderCodeHeap: 1c330000(10000:10000) Size: 0×10000(65536)bytes.
LoaderCodeHeap: 1c1c0000(10000:10000) Size: 0×10000(65536)bytes.
LoaderCodeHeap: 1bce0000(10000:10000) Size: 0×10000(65536)bytes.
LoaderCodeHeap: 1bc70000(10000:1000) Size: 0×1000(4096)bytes.
HostCodeHeap: 1bc60000 Size: 0xa000(40960)bytes.
LoaderCodeHeap: 1b7d0000(10000:10000) Size: 0×10000(65536)bytes.
Total size: 0×2d7000(2977792)bytes
————————————–
Module Thunk heaps:
Module 50224000: Size: 0×0(0)bytes.
Module 505c4000: Size: 0×0(0)bytes.
Module 648ec000: Size: 0×0(0)bytes.
Module 6638c000: Size: 0×0(0)bytes.
Module 7a71e000: Size: 0×0(0)bytes.
Module 502c2000: Size: 0×0(0)bytes.
Module 790c2000: Size: 0×0(0)bytes.
Module 02ea2380: Size: 0×0(0)bytes.
Module 02ea2010: Size: 0×0(0)bytes.
……
Module 1ed9705c: Size: 0×0(0)bytes.
Module 1ed9a884: Size: 0×0(0)bytes.
Module 1ed9e0ac: Size: 0×0(0)bytes.
Module 1ee51944: Size: 0×0(0)bytes.
Module 1ee5516c: Size: 0×0(0)bytes.
Total size: 0×0(0)bytes
————————————–
Module Lookup Table heaps:
Module 50224000: Size: 0×0(0)bytes.
Module 505c4000: Size: 0×0(0)bytes.
Module 648ec000: Size: 0×0(0)bytes.
Module 6638c000: Size: 0×0(0)bytes.
Module 7a71e000: Size: 0×0(0)bytes.
Module 502c2000: Size: 0×0(0)bytes.
Module 790c2000: Size: 0×0(0)bytes.
Module 02ea2380: Size: 0×0(0)bytes.
Module 02ea2010: Size: 0×0(0)bytes.
Module 69670000: Size: 0×0(0)bytes.
……
Module 639ea000: Size: 0×0(0)bytes.
Module 50d5a000: Size: 0×0(0)bytes.
Module 653b4000: Size: 0×0(0)bytes.
Module 02ea27cc: Size: 0×0(0)bytes.
Module 1ed9705c: Size: 0×0(0)bytes.
Module 1ed9a884: Size: 0×0(0)bytes.
Module 1ed9e0ac: Size: 0×0(0)bytes.
Module 1ee51944: Size: 0×0(0)bytes.
Module 1ee5516c: Size: 0×0(0)bytes.
Total size: 0×0(0)bytes
————————————–
Total LoaderHeap size: 0xb08000(11567104)bytes
=======================================

上面只是!eeheap –loader输出的5%左右。从上面的输出来看，loader heap占用了11MB的内存。这个数字没问题，问题在于这个module list上面。这里成千上万的module,势必导致内存碎片。
前面lmvm命令可以检查加载的module。但是lmvm命令工作方式是Win32层面的。如果DLL通过LoadLibrary起来的，这个命令能看到。但是CLR的动态DLL,除了使用LoadLibrary外，CLR还可以直接用MapViewOfFile的方法直接把DLL弄到内存中操作。这种情况lmvm就没把法了。所以需要用!eeheap –loader从CLR层面检查。
除了!eeheap外，用!dumpdomain命令，也可以从CLR层面列举出所有的assembly，包括动态的和静态的。
找到内存碎片的原因后，接下来就是分析这些碎片的来源了。既然这里是module，那随便挑一个，用!dumpmodule检查详细信息:
0:000> !dumpmodule -mt 1ee5516c
Name: cplxobsw, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null
Attributes: PEFile
Assembly: 1e929530
LoaderHeap: 00000000
TypeDefToMethodTableMap: 1ee47f18
TypeRefToMethodTableMap: 1ee47fe4
MethodDefToDescMap: 1ee48058
FieldDefToDescMap: 1ee484f4
MemberRefToDescMap: 1ee486e8
FileReferencesMap: 1ee488a4
AssemblyReferencesMap: 1ee488a8
MetaData start address: 1ee8be8c (49668 bytes)

Types defined in this module

      MT    TypeDef Name
——————————————————————————
1ee57e5c 0×02000002 Microsoft.Xml.Serialization.GeneratedAssembly.XmlSerializationWriterI_UAC_WSSoap
1ee587ac 0×02000003 Microsoft.Xml.Serialization.GeneratedAssembly.XmlSerializationReaderI_UAC_WSSoap
1ee55844 0×02000004 Microsoft.Xml.Serialization.GeneratedAssembly.XmlSerializer1
1ee56fac 0×02000005 Microsoft.Xml.Serialization.GeneratedAssembly.ArrayOfObjectSerializer
1ee5745c 0×02000006 Microsoft.Xml.Serialization.GeneratedAssembly.ArrayOfObjectSerializer1
1ee579d4 0×02000007 Microsoft.Xml.Serialization.GeneratedAssembly.ArrayOfObjectSerializer2
1ee575ec 0×02000008 Microsoft.Xml.Serialization.GeneratedAssembly.ArrayOfObjectSerializer3
1ee55e7c 0×02000009 Microsoft.Xml.Serialization.GeneratedAssembly.ArrayOfObjectSerializer4
1ee559cc 0×0200000a Microsoft.Xml.Serialization.GeneratedAssembly.ArrayOfObjectSerializer5
1ee55b5c 0×0200000b Microsoft.Xml.Serialization.GeneratedAssembly.ArrayOfObjectSerializer6
1ee57a9c 0×0200000c Microsoft.Xml.Serialization.GeneratedAssembly.ArrayOfObjectSerializer7
1ee55db4 0×0200000d Microsoft.Xml.Serialization.GeneratedAssembly.ArrayOfObjectSerializer8
1ee56714 0×0200000e Microsoft.Xml.Serialization.GeneratedAssembly.ArrayOfObjectSerializer9
1ee5777c 0×0200000f Microsoft.Xml.Serialization.GeneratedAssembly.ArrayOfObjectSerializer10
1ee57524 0×02000010 Microsoft.Xml.Serialization.GeneratedAssembly.ArrayOfObjectSerializer11
1ee56d54 0×02000011 Microsoft.Xml.Serialization.GeneratedAssembly.ArrayOfObjectSerializer12
1ee57844 0×02000012 Microsoft.Xml.Serialization.GeneratedAssembly.ArrayOfObjectSerializer13
1ee568a4 0×02000013 Microsoft.Xml.Serialization.GeneratedAssembly.ArrayOfObjectSerializer14
1ee576b4 0×02000014 Microsoft.Xml.Serialization.GeneratedAssembly.ArrayOfObjectSerializer15
1ee55a94 0×02000015 Microsoft.Xml.Serialization.GeneratedAssembly.ArrayOfObjectSerializer16
1ee55cec 0×02000016 Microsoft.Xml.Serialization.GeneratedAssembly.ArrayOfObjectSerializer17
1ee57204 0×02000017 Microsoft.Xml.Serialization.GeneratedAssembly.ArrayOfObjectSerializer18
1ee5619c 0×02000018 Microsoft.Xml.Serialization.GeneratedAssembly.ArrayOfObjectSerializer19
1ee5632c 0×02000019 Microsoft.Xml.Serialization.GeneratedAssembly.ArrayOfObjectSerializer20
1ee55f44 0×0200001a Microsoft.Xml.Serialization.GeneratedAssembly.ArrayOfObjectSerializer21
1ee572cc 0×0200001b Microsoft.Xml.Serialization.GeneratedAssembly.ArrayOfObjectSerializer22
1ee57c2c 0×0200001c Microsoft.Xml.Serialization.GeneratedAssembly.ArrayOfObjectSerializer23
1ee55c24 0×0200001d Microsoft.Xml.Serialization.GeneratedAssembly.ArrayOfObjectSerializer24
1ee56c8c 0×0200001e Microsoft.Xml.Serialization.GeneratedAssembly.ArrayOfObjectSerializer25
1ee567dc 0×0200001f Microsoft.Xml.Serialization.GeneratedAssembly.ArrayOfObjectSerializer26
1ee56e1c 0×02000020 Microsoft.Xml.Serialization.GeneratedAssembly.ArrayOfObjectSerializer27
1ee56584 0×02000021 Microsoft.Xml.Serialization.GeneratedAssembly.ArrayOfObjectSerializer28
1ee56a34 0×02000022 Microsoft.Xml.Serialization.GeneratedAssembly.ArrayOfObjectSerializer29
1ee5713c 0×02000023 Microsoft.Xml.Serialization.GeneratedAssembly.ArrayOfObjectSerializer30
1ee5600c 0×02000024 Microsoft.Xml.Serialization.GeneratedAssembly.ArrayOfObjectSerializer31
1ee57074 0×02000025 Microsoft.Xml.Serialization.GeneratedAssembly.ArrayOfObjectSerializer32
1ee560d4 0×02000026 Microsoft.Xml.Serialization.GeneratedAssembly.ArrayOfObjectSerializer33
1ee564bc 0×02000027 Microsoft.Xml.Serialization.GeneratedAssembly.ArrayOfObjectSerializer34
1ee5696c 0×02000028 Microsoft.Xml.Serialization.GeneratedAssembly.ArrayOfObjectSerializer35
1ee57394 0×02000029 Microsoft.Xml.Serialization.GeneratedAssembly.ArrayOfObjectSerializer36
1ee56ee4 0×0200002a Microsoft.Xml.Serialization.GeneratedAssembly.ArrayOfObjectSerializer37
1ee563f4 0×0200002b Microsoft.Xml.Serialization.GeneratedAssembly.ArrayOfObjectSerializer38
1ee56264 0×0200002c Microsoft.Xml.Serialization.GeneratedAssembly.ArrayOfObjectSerializer39
1ee56afc 0×0200002d Microsoft.Xml.Serialization.GeneratedAssembly.ArrayOfObjectSerializer40
1ee56bc4 0×0200002e Microsoft.Xml.Serialization.GeneratedAssembly.ArrayOfObjectSerializer41
1ee5790c 0×0200002f Microsoft.Xml.Serialization.GeneratedAssembly.ArrayOfObjectSerializer42
1ee5664c 0×02000030 Microsoft.Xml.Serialization.GeneratedAssembly.ArrayOfObjectSerializer43
1ee57b64 0×02000031 Microsoft.Xml.Serialization.GeneratedAssembly.ArrayOfObjectSerializer44
1ee55904 0×02000032 Microsoft.Xml.Serialization.GeneratedAssembly.ArrayOfObjectSerializer45
1ee5575c 0×02000033 Microsoft.Xml.Serialization.GeneratedAssembly.XmlSerializerContract

Types referenced in this module

      MT    TypeRef Name
——————————————————————————
63a191a4 0×01000001 System.Xml.Serialization.XmlSerializationWriter
63a18ac0 0×01000002 System.Xml.Serialization.XmlSerializationReader
63a19804 0×01000003 System.Xml.Serialization.XmlSerializer
63a19798 0×01000004 System.Xml.Serialization.XmlSerializerImplementation
1bb88e8c 0×01000005 t_UserInfo
639f2988 0×01000006 System.Xml.XmlReader
790fd8b4 0×01000007 System.Collections.Hashtable
790ffe7c 0×01000008 System.Type
790f9244 0×0100000e System.String
790fdb60 0×0100000f System.Int32
639f3758 0×01000010 System.Xml.XmlConvert
790f8a7c 0×01000014 System.Object
79103c00 0×01000019 System.Boolean
639f59e0 0×0100001a System.Xml.XmlQualifiedName
639fa358 0×0100001b System.Xml.XmlNameTable

上面的输入就非常明显了。程序明显是在做XmlSerialization。接下来看看是在Serialize什么类型的object，有了这个信息后，去看源代码就更有方向了.随便找一个method table来看:

0:000> !dumpmt -md 1ee57e5c
EEClass: 1ee4b428
Module: 1ee5516c
Name: Microsoft.Xml.Serialization.GeneratedAssembly.XmlSerializationWriterI_UAC_WSSoap
mdToken: 02000002  (cplxobsw, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null)
BaseSize: 0×44
ComponentSize: 0×0
Number of IFaces in IFaceMap: 0
Slots in VTable: 53
————————————–
MethodDesc Table
   Entry MethodDesc      JIT Name
7934cdcc   79137ab8   PreJIT System.Object.ToString()
7934bba0   79137ac0   PreJIT System.Object.Equals(System.Object)
7934bb90   79137ad8   PreJIT System.Object.GetHashCode()
793424c0   79137ae0   PreJIT System.Object.Finalize()
1ee5802d   1ee57e38     NONE Microsoft.Xml.Serialization.GeneratedAssembly.XmlSerializationWriterI_UAC_WSSoap.InitCallbacks()
1ee57f61   1ee57cc0     NONE Microsoft.Xml.Serialization.GeneratedAssembly.XmlSerializationWriterI_UAC_WSSoap.Write3_UserReg(System.Object[])
1ee57f65   1ee57cc8     NONE Microsoft.Xml.Serialization.GeneratedAssembly.XmlSerializationWriterI_UAC_WSSoap.Write4_UserRegResponse(System.Object[])
1ee57f69   1ee57cd0     NONE Microsoft.Xml.Serialization.GeneratedAssembly.XmlSerializationWriterI_UAC_WSSoap.Write5_UserRegSimple(System.Object[])
1ee57f6d   1ee57cd8     NONE Microsoft.Xml.Serialization.GeneratedAssembly.XmlSerializationWriterI_UAC_WSSoap.Write6_UserRegSimpleResponse(System.Object[])
1ee57f71   1ee57ce0     NONE Microsoft.Xml.Serialization.GeneratedAssembly.XmlSerializationWriterI_UAC_WSSoap.Write7_UserRegPhone(System.Object[])
1ee57f75   1ee57ce8     NONE Microsoft.Xml.Serialization.GeneratedAssembly.XmlSerializationWriterI_UAC_WSSoap.Write8_UserRegPhoneResponse(System.Object[])
1ee57f79   1ee57cf0     NONE Microsoft.Xml.Serialization.GeneratedAssembly.XmlSerializationWriterI_UAC_WSSoap.Write9_ModifyUserInfo(System.Object[])
1ee57f7d   1ee57cf8     NONE Microsoft.Xml.Serialization.GeneratedAssembly.XmlSerializationWriterI_UAC_WSSoap.Write10_ModifyUserInfoResponse(System.Object[])
1ee57f81   1ee57d00     NONE Microsoft.Xml.Serialization.GeneratedAssembly.XmlSerializationWriterI_UAC_WSSoap.Write11_UserLogin(System.Object[])
1ee57f85   1ee57d08     NONE Microsoft.Xml.Serialization.GeneratedAssembly.XmlSerializationWriterI_UAC_WSSoap.Write12_UserLoginResponse(System.Object[])
1ee57f89   1ee57d10     NONE Microsoft.Xml.Serialization.GeneratedAssembly.XmlSerializationWriterI_UAC_WSSoap.Write13_UserLogout(System.Object[])
1ee57f8d   1ee57d18     NONE Microsoft.Xml.Serialization.GeneratedAssembly.XmlSerializationWriterI_UAC_WSSoap.Write14_UserLogoutResponse(System.Object[])
1ee19d80   1ee57d20      JIT Microsoft.Xml.Serialization.GeneratedAssembly.XmlSerializationWriterI_UAC_WSSoap.Write15_GetUserInfo(System.Object[])
1ee57f95   1ee57d28     NONE Microsoft.Xml.Serialization.GeneratedAssembly.XmlSerializationWriterI_UAC_WSSoap.Write16_GetUserInfoResponse(System.Object[])
1ee57f99   1ee57d30     NONE Microsoft.Xml.Serialization.GeneratedAssembly.XmlSerializationWriterI_UAC_WSSoap.Write17_FindUser(System.Object[])
1ee57f9d   1ee57d38     NONE Microsoft.Xml.Serialization.GeneratedAssembly.XmlSerializationWriterI_UAC_WSSoap.Write18_FindUserResponse(System.Object[])
1ee57fa1   1ee57d40     NONE Microsoft.Xml.Serialization.GeneratedAssembly.XmlSerializationWriterI_UAC_WSSoap.Write19_FindUserEx(System.Object[])
1ee57fa5   1ee57d48     NONE Microsoft.Xml.Serialization.GeneratedAssembly.XmlSerializationWriterI_UAC_WSSoap.Write20_FindUserExResponse(System.Object[])
1ee57fa9   1ee57d50     NONE Microsoft.Xml.Serialization.GeneratedAssembly.XmlSerializationWriterI_UAC_WSSoap.Write21_ModifyPassword(System.Object[])
1ee57fad   1ee57d58     NONE Microsoft.Xml.Serialization.GeneratedAssembly.XmlSerializationWriterI_UAC_WSSoap.Write22_ModifyPasswordResponse(System.Object[])
1ee57fb1   1ee57d60     NONE Microsoft.Xml.Serialization.GeneratedAssembly.XmlSerializationWriterI_UAC_WSSoap.Write23_ResetPassword(System.Object[])
1ee57fb5   1ee57d68     NONE Microsoft.Xml.Serialization.GeneratedAssembly.XmlSerializationWriterI_UAC_WSSoap.Write24_ResetPasswordResponse(System.Object[])
1ee57fb9   1ee57d70     NONE Microsoft.Xml.Serialization.GeneratedAssembly.XmlSerializationWriterI_UAC_WSSoap.Write25_ModifyPasswordPhone(System.Object[])
1ee57fbd   1ee57d78     NONE Microsoft.Xml.Serialization.GeneratedAssembly.XmlSerializationWriterI_UAC_WSSoap.Write26_ModifyPasswordPhoneResponse(System.Object[])
1ee57fc1   1ee57d80     NONE Microsoft.Xml.Serialization.GeneratedAssembly.XmlSerializationWriterI_UAC_WSSoap.Write27_CheckUserToken(System.Object[])
1ee57fc5   1ee57d88     NONE Microsoft.Xml.Serialization.GeneratedAssembly.XmlSerializationWriterI_UAC_WSSoap.Write28_CheckUserTokenResponse(System.Object[])
1ee57fc9   1ee57d90     NONE Microsoft.Xml.Serialization.GeneratedAssembly.XmlSerializationWriterI_UAC_WSSoap.Write29_SetUserStatus(System.Object[])
1ee57fcd   1ee57d98     NONE Microsoft.Xml.Serialization.GeneratedAssembly.XmlSerializationWriterI_UAC_WSSoap.Write30_SetUserStatusResponse(System.Object[])
1ee57fd1   1ee57da0     NONE Microsoft.Xml.Serialization.GeneratedAssembly.XmlSerializationWriterI_UAC_WSSoap.Write31_ActivateUser(System.Object[])
1ee57fd5   1ee57da8     NONE Microsoft.Xml.Serialization.GeneratedAssembly.XmlSerializationWriterI_UAC_WSSoap.Write32_ActivateUserResponse(System.Object[])
1ee57fd9   1ee57db0     NONE Microsoft.Xml.Serialization.GeneratedAssembly.XmlSerializationWriterI_UAC_WSSoap.Write33_AppActivateUser(System.Object[])
1ee57fdd   1ee57db8     NONE Microsoft.Xml.Serialization.GeneratedAssembly.XmlSerializationWriterI_UAC_WSSoap.Write34_AppActivateUserResponse(System.Object[])
1ee57ff1   1ee57dc0     NONE Microsoft.Xml.Serialization.GeneratedAssembly.XmlSerializationWriterI_UAC_WSSoap.Write35_GetUserLoginHistory(System.Object[])
1ee57ff5   1ee57dc8     NONE Microsoft.Xml.Serialization.GeneratedAssembly.XmlSerializationWriterI_UAC_WSSoap.Write36_GetUserLoginHistoryResponse(System.Object[])
1ee57ff9   1ee57dd0     NONE Microsoft.Xml.Serialization.GeneratedAssembly.XmlSerializationWriterI_UAC_WSSoap.Write37_GetUnactiveUserNumber(System.Object[])
1ee57ffd   1ee57dd8     NONE Microsoft.Xml.Serialization.GeneratedAssembly.XmlSerializationWriterI_UAC_WSSoap.Write38_GetUnactiveUserNumberResponse(System.Object[])
1ee58001   1ee57de0     NONE Microsoft.Xml.Serialization.GeneratedAssembly.XmlSerializationWriterI_UAC_WSSoap.Write39_GetTtlUserNumber(System.Object[])
1ee58005   1ee57de8     NONE Microsoft.Xml.Serialization.GeneratedAssembly.XmlSerializationWriterI_UAC_WSSoap.Write40_GetTtlUserNumberResponse(System.Object[])
1ee58009   1ee57df0     NONE Microsoft.Xml.Serialization.GeneratedAssembly.XmlSerializationWriterI_UAC_WSSoap.Write41_GetActiveUserNumber(System.Object[])
1ee5800d   1ee57df8     NONE Microsoft.Xml.Serialization.GeneratedAssembly.XmlSerializationWriterI_UAC_WSSoap.Write42_GetActiveUserNumberResponse(System.Object[])
1ee58011   1ee57e00     NONE Microsoft.Xml.Serialization.GeneratedAssembly.XmlSerializationWriterI_UAC_WSSoap.Write43_DailyRegisterCount(System.Object[])
1ee58015   1ee57e08     NONE Microsoft.Xml.Serialization.GeneratedAssembly.XmlSerializationWriterI_UAC_WSSoap.Write44_DailyRegisterCountResponse(System.Object[])
1ee58019   1ee57e10     NONE Microsoft.Xml.Serialization.GeneratedAssembly.XmlSerializationWriterI_UAC_WSSoap.Write45_GetDailyReport(System.Object[])
1ee5801d   1ee57e18     NONE Microsoft.Xml.Serialization.GeneratedAssembly.XmlSerializationWriterI_UAC_WSSoap.Write46_GetDailyReportResponse(System.Object[])
1ee58021   1ee57e20     NONE Microsoft.Xml.Serialization.GeneratedAssembly.XmlSerializationWriterI_UAC_WSSoap.Write47_Test(System.Object[])
1ee58025   1ee57e28     NONE Microsoft.Xml.Serialization.GeneratedAssembly.XmlSerializationWriterI_UAC_WSSoap.Write48_TestResponse(System.Object[])
1ee19eb8   1ee57e30      JIT Microsoft.Xml.Serialization.GeneratedAssembly.XmlSerializationWriterI_UAC_WSSoap.Write2_t_UserInfo(System.String, System.String, t_UserInfo, Boolean, Boolean)
1ee58031   1ee57e40     NONE Microsoft.Xml.Serialization.GeneratedAssembly.XmlSerializationWriterI_UAC_WSSoap..ctor()

从上面的输出中，就能看到序列化类型的方法。有了这些方法，查找序列化的来源就容易多了。

有了这些信息后，开发人员很容易地定位到问题跟WCF调用相关。实现WCF的时候选择了XML序列化方法。在下面这个blog的评论中，有人批评WCF XML序列化会导致这样的问题:
http://blogs.msdn.com/tess/archive/2006/02/15/net-memory-leak-xmlserializing-your-way-to-a-memory-leak.aspx

这个问题在这里已经非常明显了。当然dump中还有其它可以挖掘的地方。比如用!dumpheap –stat看看CLR object的数量。用!dumpheap –mt寻找一些序列化object的地址，然后用!gcroot看看序列化object的引用关系。或者用!finalizequeue看看是否堆积了大量的object等待Dispose。由于篇幅的关系，这些细枝末节就不列举了。

总的说来，!eeheap –gc隔离问题到loader heap和dynamic module, !dumpmodule –mt找到引发序列化的类型，!dumpmt –md找出类型的详细信息。三个命令就可以隔离出问题。
该问题最后通过WCF object pool的方法缓存WCF client proxy，解决问题。

JavaScript中有一个call和apply方法，其作用基本相同，但也有略微的区别。

先来看看JS手册中对call的解释：
call 方法
调用一个对象的一个方法，以另一个对象替换当前对象。

call([thisObj[,arg1[, arg2[, [,.argN]]]]])

参数
thisObj
可选项。将被用作当前对象的对象。

arg1, arg2, , argN
可选项。将被传递方法参数序列。

说明
call 方法可以用来代替另一个对象调用一个方法。call 方法可将一个函数的对象上下文从初始的上下文改变为由 thisObj 指定的新对象。

如果没有提供 thisObj 参数，那么 Global 对象被用作 thisObj。

说明白一点其实就是更改对象的内部指针，即改变对象的this指向的内容。这在面向对象的js编程过程中有时是很有用的。

引用网上一个代码段，运行后自然就明白其道理。
<input type=”text” id=”myText” value=”input text”>
<script>
function Obj(){this.value=”对象！”;}
var value=”global 变量”;
function Fun1(){alert(this.value);}

window.Fun1(); //global 变量
Fun1.call(window); //global 变量
Fun1.call(document.getElementById(’myText’)); //input text
Fun1.call(new Obj()); //对象！
</script>

call函数和apply方法的第一个参数都是要传入给当前对象的对象，及函数内部的this。后面的参数都是传递给当前对象的参数。
运行如下代码：
<script>
var func=new function(){this.a=”func”}
var myfunc=function(x){
var a=”myfunc”;
alert(this.a);
alert(x);
}
myfunc.call(func,”var”);
</script>

可见分别弹出了func和var。到这里就对call的每个参数的意义有所了解了。

对于apply和call两者在作用上是相同的，但两者在参数上有区别的。
对于第一个参数意义都一样，但对第二个参数：
apply传入的是一个参数数组，也就是将多个参数组合成为一个数组传入，而call则作为call的参数传入（从第二个参数开始）。
如 func.call(func1,var1,var2,var3)对应的apply写法为：func.apply(func1,[var1,var2,var3])

同时使用apply的好处是可以直接将当前函数的arguments对象作为apply的第二个参数传入。