博客园_狂风之家－.net 学习、研究中

ActiveRecord 模型

2010-12-06T06:20:00Z

ActiveRecord是什么:
1. 每一个数据库表对应创建一个类.类的每一个对象实例对应于数据库中表的一行记录; 通常表的每个字段在类中都有相应的Field;
2. ActiveRecord同时负责把自己持久化. 在ActiveRecord中封装了对数据库的访问, 即CRUD;
3. ActiveRecord是一种领域模型(Domain Model), 封装了部分业务逻辑;

ActiveRecord与数据库耦合更紧;

定义：

1、Active Record pattern实现，它是指一个既包含数据又包含行为的对象，这些数据需要持久保存到对应的数据表中。Active Record一个很明显的特征是：将数据访问逻辑也包含在这个domain对象中，通过这种办法让人们可以知道如何从数据库读写数据。也就是将Dao中对数据库的CRUD方法和Domain Object整合在一起

ActiveRecord适用于:

1. 业务逻辑比较简单;当你的类基本上和数据库中的表一一对应时, ActiveRecord是非常方便的, 即你的业务逻辑大多数是对单表操作;

2. 当发生跨表的操作时, 往往会配合使用事务脚本(Transaction Script), 把跨表事务提升到事务脚本中;

3. ActiveRecord最大优点是简单, 直观; 一个类就包括了数据访问和业务逻辑. 如果配合代码生成器使用就更方便了;

4. 这些优点使ActiveRecord特别适合web快速开发, 而正是快速开发框架ROR采用了ActiveRecord, 并且很多类ROR框架如Castle的纷纷效仿才使ActiveRecord重新进入大家视线;
我想这也是为什么Martin Fowler在PoEAA中早就提出了这个模式, 但是直到最近两三年ActiveRecord才热起来可能就是这个原因;

ActiveRecord不适合于
1. ActiveRecord虽然有业务逻辑, 但基本上都是基于单表的. 跨表逻辑一般会放到当发生跨表的操作时, 往往会配合使用事务脚本(Transaction Script)中. 如果对象间的关联越来越多, 你的事务脚本越来越庞大, 重复的代码越来越多, 你就要考虑Domain Model + O/R Mapper了;

2. ActiveRecord保存了数据, 使它有时候看上去像数据传输对象(DTO). 但是ActiveRecord有数据库访问能力, 不要把它当DTO用. 尤其在跨越进程边界调用的时候, 不能传递ActiveRecord对象;

这个模式的技术架构：

UI（Form/Web网页）：数据展示，有控件，或者完全的HTML标签， Jsp中还有EL

Datasource：数据提供者，提供给页面控件（元素）展示数据， Net有 SQLDatasource，ObjectDatasource

Java有 JSP 对应的<jsp:bean>, <jsp:setProperty>, <jsp:getProperty> 等标签

Zen框架中 QuerySource

BO：业务逻辑层，实现：业务逻辑与算法，Entity类业务逻辑方法，数据验证，生成DTO层对象等功能，

业务逻辑与Datasource之间的DTO层，用来传输数据，这些数据可能是表、视图或者综合的一个POJO，对于简单数据可以与Entity共用一个类。

Entity层：类与数据库之间的映射层，对应的关系型数据库，保存数据时转换成SQL语句，对应Cache数据库使用它自己的代理方法

ActiveRecord：技术框架层，所有的Entity都继承此层的基类；本基类中包含了数据操作方法，封装了部分业务逻辑

对应的产品： Net Castle的 ActiveRecord框架， Cache数据库的Persistent类的数据存储框架，

本文出处http://zhaocz.blog.51cto.com/542576/307894

本文链接

自动内存管理

2010-12-05T12:31:00Z

自动内存管理是公共语言运行库在托管执行过程过程中提供的服务之一。公共语言运行库的垃圾回收器为应用程序管理内存的分配和释放。对开发人员而言，这就意味着在开发托管应用程序时不必编写执行内存管理任务的代码。自动内存管理可解决常见问题，例如，忘记释放对象并导致内存泄漏，或尝试访问已释放对象的内存。本节描述垃圾回收器如何分配和释放内存。

分配内存
初始化新进程时，运行时会为进程保留一个连续的地址空间区域。这个保留的地址空间被称为托管堆。托管堆维护着一个指针，用它指向将在堆中分配的下一个对象的地址。最初，该指针设置为指向托管堆的基址。托管堆上部署了所有引用类型。应用程序创建第一个引用类型时，将为托管堆的基址中的类型分配内存。应用程序创建下一个对象时，垃圾回收器在紧接第一个对象后面的地址空间内为它分配内存。只要地址空间可用，垃圾回收器就会继续以这种方式为新对象分配空间。
从托管堆中分配内存要比非托管内存分配速度快。由于运行时通过为指针添加值来为对象分配内存，所以这几乎和从堆栈中分配内存一样快。另外，由于连续分配的新对象在托管堆中是连续存储，所以应用程序可以快速访问这些对象。

释放内存
垃圾回收器的优化引擎根据所执行的分配决定执行回收的最佳时间。垃圾回收器在执行回收时，会释放应用程序不再使用的对象的内存。它通过检查应用程序的根来确定不再使用的对象。每个应用程序都有一组根。每个根或者引用托管堆中的对象，或者设置为空。应用程序的根包含全局对象指针、静态对象指针、线程堆栈中的局部变量和引用对象参数以及 CPU 寄存器。垃圾回收器可以访问由实时 (JIT) 编译器和运行时维护的活动根的列表。垃圾回收器对照此列表检查应用程序的根，并在此过程中创建一个图表，在其中包含所有可从这些根中访问的对象。
不在该图表中的对象将无法从应用程序的根中访问。垃圾回收器会考虑无法访问的对象垃圾，并释放为它们分配的内存。在回收中，垃圾回收器检查托管堆，查找无法访问对象所占据的地址空间块。发现无法访问的对象时，它就使用内存复制功能来压缩内存中可以访问的对象，释放分配给不可访问对象的地址空间块。在压缩了可访问对象的内存后，垃圾回收器就会做出必要的指针更正，以便应用程序的根指向新地址中的对象。它还将托管堆指针定位至最后一个可访问对象之后。请注意，只有在回收发现大量的无法访问的对象时，才会压缩内存。如果托管堆中的所有对象均未被回收，则不需要压缩内存。
为了改进性能，运行时为单独堆中的大型对象分配内存。垃圾回收器会自动释放大型对象的内存。但是，为了避免移动内存中的大型对象，不会压缩此内存。

级别和性能
为了优化垃圾回收器的性能，托管堆分为三个生成级别：0、1 和 2。运行时的垃圾回收算法基于以下几个普遍原理，这些垃圾回收方案的原理已在计算机软件业通过实验得到了证实。首先，压缩托管堆的一部分内存要比压缩整个托管堆速度快。其次，较新的对象生存期较短，而较旧的对象生存期则较长。最后，较新的对象趋向于相互关联，并且大致同时由应用程序访问。
运行时的垃圾回收器将新对象存储在第 0 级托管堆中。在应用程序生存期的早期创建的对象如果未被回收，则被升级并存储在第 1 级和第 2 级托管堆中。对象升级的过程将在本主题的后面介绍。因为压缩托管堆的一部分要比压缩整个托管堆速度快，所以此方案允许垃圾回收器在每次执行回收时释放特定级别的内存，而不是整个托管堆的内存。
实际上，垃圾回收器在第 0 级托管堆已满时执行回收。如果应用程序在第 0 级托管堆已满时尝试新建对象，垃圾回收器将会发现第 0 级托管堆中没有可分配给该对象的剩余地址空间。垃圾回收器执行回收，尝试为对象释放第 0 级托管堆中的地址空间。垃圾回收器从检查第 0 级托管堆中的对象（而不是托管堆中的所有对象）开始执行回收。这是最有效的途径，因为新对象的生存期往往较短，并且期望在执行回收时，应用程序不再使用第 0 级托管堆中的许多对象。另外，单独回收第 0 级托管堆通常可以回收足够的内存，这样，应用程序便可以继续创建新对象。
垃圾回收器执行第 0 级托管堆的回收后，会压缩可访问对象的内存，如本主题前面的释放内存中所述。然后，垃圾回收器升级这些对象，并考虑第 1 级托管堆的这一部分。因为未被回收的对象往往具有较长的生存期，所以将它��升级至更高的级别很有意义。因此，垃圾回收器在每次执行第 0 级托管堆的回收时，不必重新检查第 1 级和第 2 级托管堆中的对象。
在执行第 0 级托管堆的首次回收并把可访问的对象升级至第 1 级托管堆后，垃圾回收器将考虑第 0 级托管堆的其余部分。它将继续为第 0 级托管堆中的新对象分配内存，直至第 0 级托管堆已满并需执行另一回收为止。这时，垃圾回收器的优化引擎会决定是否需要检查较旧的级别中的对象。例如，如果第 0 级托管堆的回收没有回收足够的内存，不能使应用程序成功完成创建新对象的尝试，垃圾回收器就会先执行第 1 级托管堆的回收，然后再执行第 0 级托管堆的回收。如果这样仍不能回收足够的内存，垃圾回收器将执行第 2、1 和 0 级托管堆的回收。每次回收后，垃圾回收器都会压缩第 0 级托管堆中的可访问对象并将它们升级至第 1 级托管堆。第 1 级托管堆中未被回收的对象将会升级至第 2 级托管堆。由于垃圾回收器只支持三个级别，因此第 2 级托管堆中未被回收的对象会继续保留在第 2 级托管堆中，直到在将来的回收中确定它们为无法访问为止。

为非托管资源释放内存
对于应用程序创建的大多数对象，可以依赖垃圾回收器自动执行必要的内存管理任务。但是，非托管资源需要显式清除。最常用的非托管资源类型是包装操作系统资源的对象，例如，文件句柄、窗口句柄或网络连接。虽然垃圾回收器可以跟踪封装非托管资源的托管对象的生存期，但却无法具体了解如何清理资源。创建封装非托管资源的对象时，建议在公共 Dispose 方法中提供必要的代码以清理非托管资源。通过提供 Dispose 方法，对象的用户可以在使用完对象后显式释放其内存。使用封装非托管资源的对象时，应该了解 Dispose 并在必要时调用它。有关清理非托管资源的更多信息和实现 Dispose 的设计模式示例，请参见垃圾回收。
本文链接

服务端合并和压缩JS和CSS文件

2010-10-21T09:48:00Z

Web性能优化最佳实践中最重要的一条是减少HTTP请求，它也是YSlow中比重最大的一条规则。减少HTTP请求的方案主要有合并JavaScript和CSS文件、CSS Sprites、图像映射（Image Map）和使用Data URI来编码图片。CSS Sprites和图像映射现在已经随处可见了，但由于IE6和IE7不支持Data URI以及性能问题，这项技术尚未大量使用。目前大部分网页中的JavaScript和CSS文件数量和开发时一致，少量的网页会根据实际情况采取本地合并，这些合并中相当多的是有选择地手动完成，每次新的合并都需要重新在本地完成并上传到服务器，比较的随意和繁琐，同样文件的压缩也有类似的情况。而利用服务端的合并和压缩，我们就可以按照开发的逻辑尽可能让文件的颗粒度变小，利用网页中URL的规则来自动实现文件的合并和压缩，这会相当的灵活和高效。

YUI Combo Handler

2008年7月YUI Team宣布在YAHOO！ CDN上对YUI JavaScript组件提供Combo Handler服务。Combo Handler是Yahoo！开发的一个Apache模块，它实现了开发人员简单方便地通过URL来合并JavaScript和CSS文件，从而大大减少文件请求数。比如在页面上使用YUI2的Rich Text Editor组件需要引入多个JavaScript文件，常用方式如下：

而使用Combo Handler服务之后，则上述的代码可以写为：

除了代码的可读性稍稍有一点点降低外，使用Combo Handler服务大大的降低了HTTP请求数，同时也减少了URL代码量，这对于Web性能优化来讲至关重要。所以，随后YUI从2.6.0开始，其核心组件YUI Loader内置了Combo Handling功能，即使用YUI Loader时，通过配置combine属性就可以把要加载的多个JavaScript或CSS文件按照使用Combo Handler服务的形式合并起来，这时只要静态文件的服务器支持Combo Handler就行了。在YUI中当combine配置为true时，CDN默认是使用Yahoo！ CDN（http://yui.yahooapis.com），所以没有任何问题。这正是YUI最迷人的地方之一。

遗憾的是http://yui.yahooapis.com在中国的速度并不佳，本来中国雅虎提供http://cn.yui.yahooapis.com/ ，但尚未提供Combo Handler服务，同时因种种原因，其更新在YUI 2.7.0之后就停滞了。更糟糕的是Yahoo！开发的支持Combo Handler的Apache模块虽然据传有计划开源，但至少现在依旧是私有技术，要使用就需要自己实现类似功能，所以国内类似技术的应用并不太多。

Minify

在Google Code上有一个PHP的开源项目叫Minify，它可以合并、精简、Gzip压缩和缓存JavaScript和CSS文件。其文件合并功能就非常类似Combo Handler，只不过URL的语法稍微有点不同。如果Yahoo！ CDN安装了Minify，那么上面Rich Text Editor的代码用Minify的默认格式来写就是：

本地使用Minify很简单，只需要Apache + PHP环境就OK了：

安装好Apache + PHP （Windows、Mac）。

下载Minify源码，解压，然后把min文件夹复制到指定的根目录下，比如localhost。这时URL的写法大概是http://localhost/min/f=。..

启用Apache的Mod Rewrite模块，然后在min文件夹下新建.htaccess文件，并添加如下Rewrite规则：

<IfModule mod_rewrite.c>
RewriteEngine on
# You may need RewriteBase on some servers
# 如果做了所有的开启Mod Rewrite的设置依旧无效，请城市尝试启用下面这句
#RewriteBase /min
# rewrite URLs like "/min/f=..." to "/min/?f=..."
RewriteRule ^([bfg]=.*) index.php?$1 [L,NE]
</IfModule>

如果不启用Mod Rewrite功能，则Minify的URL会类似http://localhost/min/index.php?f=…，这对客户端和中间服务器的缓存不利，而启用了Mod Rewrite之后的URL类似http://localhost/min/f=…，不仅解决前面问题且更短。

4. 配置Minify，即编辑min/config.php文件

$min_enableBuilder = true;
//本地使用时可以通过http://dwn/min/builder/来进行配置，外部使用时请设置为false
//$min_cachePath = 'c:\\WINDOWS\\Temp';
//$min_cachePath = '/tmp';
//$min_cachePath = preg_replace('/^\\d+;/', '', session_save_path());
//选择其一，去掉注释设置临时缓存目录，这样可以减少程序运算提高性能
$min_serveOptions['maxAge'] = 1800;
//设置浏览器缓存的时间，为了提升性能建议这个时间设置尽可能的长，比如315360000
//如果需要在不改变URL的情况下更新静态文件，可以采用类似时间戳的方式，
//如http://localhost/min/f=example/example.css&20100601.css
//建议静态文件采用版本号管理，每次修改都需要升级版本号，这样就无需时间戳了
//如http://localhost/min/f=example/example_1_0_1.css
$min_serveOptions['minApp']['maxFiles'] = 10;
//参数f获取参数的个数，即合并的文件个数，这个数量完全可以增大，比如50，
//当然可能会遇到URL最大值问题，后会有解释
$min_documentRoot = '';
//$min_documentRoot = substr(__FILE__, 0, strlen(__FILE__) - 15);
//$min_documentRoot = $_SERVER['SUBDOMAIN_DOCUMENT_ROOT'];
//当$min_documentRoot为空时，其值就是$_SERVER['DOCUMENT_ROOT']，
//但合并的文件不在$_SERVER['DOCUMENT_ROOT']下，会导致400错误，
//这个时候可以启用第2行或第3行

4. 配置Minify，即编辑min/config.php文件

5. 使用Minify

比如，有两个JavaScript文件，http://localhost/example/a.js，http://localhost/example/b.js，那么使用Minify合并的URL是http://localhost/min/f=/example/a.js，/example/b.js，直接把这个URL放到页面中就可以使用了。

实际上Minify不仅仅实现了合并功能，同时默认在合并的同时还会对文件进行精简压缩，如果你在本地本身就对文件进行压缩了，比如使用YUI Compressor，那么可以在config.php中进行如下设置取消Minify的压缩以提升性能：

$min_serveOptions['minifiers']['application/x-javascript'] = '';
$min_serveOptions['minifiers']['text/css'] = '';

如果服务端支持Java，那么也可以对Minify进行简单配置而实现利用YUI Compressor压缩JavaScript和CSS文件。

直接在服务端进行合并和压缩，这非常的灵活，也极大的减轻了前端开发成果的部署过程，真使事半功倍。更多配置请看Minify CookBook和Wiki

在YUI3中使用Minify

在YUI2中，合并机制只支持库本身的文件，自定义的文件会单独一一加载。从YUI3开始，模块变得更小，这样就导致使用合并时URL会变长，但在IE下URL的最大值是2083，Apache默认的URL最大值是8192，所以当URL在对应浏览器下超出最大值时，YUI3会自动根据浏览器判断进行拆分成多个合并的URL，并且还提供maxURLLength来设置最大值。而从YUI3.1.0开始，不仅仅支持自定义文件的合并，还支持可以使用多个提供合并服务的CDN，即可以对YUI组件使用http://yui.yahooapis.com这个CDN，其余文件使用其他支持合并的CDN，这样非常的实用、方便和灵活。示例在YUI3中使用Minify就说明了这点。

由于YUI默认URL的合并形式和Minify的不相同，所以在YUI实例化时需要利用正则替换来实现YUI3支持Minify的URL合并形式，但这种方式既不灵活，且有风险，不友好又效率低。比较简单的方式是直接修改YUI 3的源码，如示例在修改后的YUI3中使用Minify。同时，YUI 3.1.*的版本有一个bug，即同时合并JavaScript和CSS时，较短的那个URL结尾处多一个&符号，如示例在YUI3中使用Minify中：

http://yui.yahooapis.com/combo?3.1.1/build/widget/assets/skins/sam/widget.css&
3.1.1/build/console/assets/skins/sam/console.css&

http://dancewithnet.com/min/b=yui&f=3.1.1/tabview/assets/
skins/sam/tabview.css&

这两种都可以使用，虽然在早期的IE浏览器版本（如IE6）中会有无法解析的风险，且影响某些特定情况下的缓存，但当使用修改后的YUI时，合并的URL变成类似/min/b=yui&f=3.1.1/tabview/assets/skins/sam/tabview.css，的样子，就会出现bug了。对于YUI的Combo Handler来说这是一个小bug，所以YUI3把这个bug设置为P5。但当我们改造YUI3来更好的支持Minify时，还要解决这个问题，具体方案请看示例在修改后的YUI3中使用Minify。

在CDN上使用Minify

CDN的全称是Content Delivery Network，即内容分发网络。其最常应用就是通过位于不同地理位置的服务器把静态资源部署到用户最近的边缘，这样能有效解决Web服务中大量静态资源的速度和性能问题。由于实施成本比较高，所以在实际的应用中，大型公司一般会组建自己的CDN，而小型公司只能租借第三方的CDN，但不管怎样这两种方式都不会影响在服务端实施合并和压缩程序。一般情况下，静态资源也并不是直接上传到CDN，而是先传到一台后台服务器，然后各地CDN的前端Cache服务器按需索取。YUI CDN的Combo Handler就是部署在其后台服务器上的，Minify也应如此。简单图示如下：

当一个资源请求到CDN时，CDN会先检查本地是否存在这个资源，如果有则会直接返回该资源，如果没有则会请求其后台服务器，后台服务器会依据资源URL的信息进行相应的处理，然后返回给CDN，CDN就会存储这个资源，再次出现这个资源请求时就无需请求后台服务器了。所以，虽然合并特别是压缩JavaScript和CSS文件是消耗时间的，但是由于只需要第一次，并且第一次基本上由我们自己访问掉（我们可以创建程序自动进行一次访问来保证，实际上图片优化也可以采用这种方式），所以基本上很安全。这正是目前在口碑网实施的JavaScript和CSS合并方案，在第4届D2的《前端性能优化和自动化》中也介绍了它。

原文：http://dancewithnet.com/2010/06/08/minify-js-and-css-files-in-server/

本文链接

C#Excel操作的用法

2010-09-17T09:11:00Z

这里是一些整理的Excel的一些简单的操作

ApplicationClass ExcelApp = New ApplicationClass();

2) 更改 Excel 标题栏：
 ExcelApp.Caption := '应用程序调用 Microsoft Excel';
3) 添加新工作簿：
 ExcelApp.WorkBooks.Add;
4) 打开已存在的工作簿：
 ExcelApp.WorkBooks.Open( 'C:\Excel\Demo.xls' );
5) 设置第2个工作表为活动工作表：
 ExcelApp.WorkSheets[2].Activate; 或
 ExcelApp.WorksSheets[ 'Sheet2' ].Activate;
6) 给单元格赋值：
 ExcelApp.Cells[1,4].Value := '第一行第四列';
7) 设置指定列的宽度（单位：字符个数），以第一列为例：
 ExcelApp.ActiveSheet.Columns[1].ColumnsWidth := 5;
8) 设置指定行的高度（单位：磅）（1磅＝0.035厘米），以第二行为例：
 ExcelApp.ActiveSheet.Rows[2].RowHeight := 1/0.035; // 1厘米
9) 在第8行之前插入分页符：
 ExcelApp.WorkSheets[1].Rows[8].PageBreak := 1;
10) 在第8列之前删除分页符：
 ExcelApp.ActiveSheet.Columns[4].PageBreak := 0;
11) 指定边框线宽度：
 ExcelApp.ActiveSheet.Range[ 'B3:D4' ].Borders[2].Weight := 3;
 1-左 2-右 3-顶 4-底 5-斜( \ ) 6-斜( / )
12) 清除第一行第四列单元格公式：
 ExcelApp.ActiveSheet.Cells[1,4].ClearContents;
13) 设置第一行字体属性：
 ExcelApp.ActiveSheet.Rows[1].Font.Name := '隶书';
 ExcelApp.ActiveSheet.Rows[1].Font.Color := clBlue;
 ExcelApp.ActiveSheet.Rows[1].Font.Bold := True;
 ExcelApp.ActiveSheet.Rows[1].Font.UnderLine := True;
14) 进行页面设置：
 a.页眉：
 ExcelApp.ActiveSheet.PageSetup.CenterHeader := '报表演示';
 b.页脚：
 ExcelApp.ActiveSheet.PageSetup.CenterFooter := '第&P页';
 c.页眉到顶端边距2cm：
 ExcelApp.ActiveSheet.PageSetup.HeaderMargin := 2/0.035;
 d.页脚到底端边距3cm：
 ExcelApp.ActiveSheet.PageSetup.HeaderMargin := 3/0.035;
 e.顶边距2cm：
 ExcelApp.ActiveSheet.PageSetup.TopMargin := 2/0.035;
 f.底边距2cm：
 ExcelApp.ActiveSheet.PageSetup.BottomMargin := 2/0.035;
 g.左边距2cm：
 ExcelApp.ActiveSheet.PageSetup.LeftMargin := 2/0.035;
 h.右边距2cm：
 ExcelApp.ActiveSheet.PageSetup.RightMargin := 2/0.035;
 i.页面水平居中：
 ExcelApp.ActiveSheet.PageSetup.CenterHorizontally := 2/0.035;
 j.页面垂直居中：
 ExcelApp.ActiveSheet.PageSetup.CenterVertically := 2/0.035;
 k.打印单元格网线：
 ExcelApp.ActiveSheet.PageSetup.PrintGridLines := True;
15) 拷贝操作：
 a.拷贝整个工作表：
 ExcelApp.ActiveSheet.Used.Range.Copy;
 b.拷贝指定区域：
 ExcelApp.ActiveSheet.Range[ 'A1:E2' ].Copy;
 c.从A1位置开始粘贴：
 ExcelApp.ActiveSheet.Range.[ 'A1' ].PasteSpecial;
 d.从文件尾部开始粘贴：
 ExcelApp.ActiveSheet.Range.PasteSpecial;
16) 插入一行或一列：
 a. ExcelApp.ActiveSheet.Rows[2].Insert;
 b. ExcelApp.ActiveSheet.Columns[1].Insert;
17) 删除一行或一列：
 a. ExcelApp.ActiveSheet.Rows[2].Delete;
 b. ExcelApp.ActiveSheet.Columns[1].Delete;
18) 打印预览工作表：
 ExcelApp.ActiveSheet.PrintPreview;
19) 打印输出工作表：
 ExcelApp.ActiveSheet.PrintOut;
20) 工作表保存：
 if not ExcelApp.ActiveWorkBook.Saved then
 ExcelApp.ActiveSheet.PrintPreview;
21) 工作表另存为：
 ExcelApp.SaveAs( 'C:\Excel\Demo1.xls' );
22) 放弃存盘：
 ExcelApp.ActiveWorkBook.Saved := True;
23) 关闭工作簿：
 ExcelApp.WorkBooks.Close;
24) 退出 Excel：
 ExcelApp.Quit;

001 /// <summary>

002 /// ExcelEdit 的摘要说明

003 /// </summary>

004 public class ExcelEdit

005 {

006 public string mFilename;

007 public Microsoft.Office.Interop.Excel.Application app;

008 public Microsoft.Office.Interop.Excel.Workbooks wbs;

009 public Microsoft.Office.Interop.Excel.Workbook wb;

010 public Microsoft.Office.Interop.Excel.Worksheets wss;

011 public Microsoft.Office.Interop.Excel.Worksheet ws;

012 public ExcelEdit()

013 {

014 //

015 // TODO: 在此处添加构造函数逻辑

016 //

017 }

018 public void Create()//创建一个Excel对象

019 {

020 try

021 {

022 app = new Microsoft.Office.Interop.Excel.Application();

023 wbs = app.Workbooks;

024 wb = wbs.Add(true);

025 }

026 catch (Exception ex)

027 {

028

029 throw new Exception(ex.Message);

030 }

031

032 }

033 /// <summary>

034 /// 读取Excel文档

035 /// </summary>

036 /// <param name="Path">文件名称</param>

037 /// <returns>返回一个数据集</returns>

038 public DataTable ExcelToTable(string tablename)

039 {

040 string strConn = "Provider=Microsoft.Jet.OLEDB.4.0;" + "Data Source=" + mFilename+ ";" + "Extended Properties=Excel 8.0;";

041 OleDbConnection conn = new OleDbConnection(strConn);

042 conn.Open();

043 string strExcel = "";

044 OleDbDataAdapter myCommand = null;

045 DataTable dt = null;

046 strExcel = "select * from [" + tablename + "$]";

047 myCommand = new OleDbDataAdapter(strExcel, strConn);

048 dt = new DataTable();

049 myCommand.Fill(dt);

050 return dt;

051 }

052 public void Open(string FileName)//打开一个Excel文件

053 {

054 try

055 {

056 app = new Microsoft.Office.Interop.Excel.Application();

057 wbs = app.Workbooks;

058 wb = wbs.Add(FileName);

059 //wb = wbs.Open(FileName, 0, true, 5,"", "", true, Excel.XlPlatform.xlWindows, "\t", false, false, 0, true,Type.Missing,Type.Missing);

060 //wb = wbs.Open(FileName,Type.Missing,Type.Missing,Type.Missing,Type.Missing,Type.Missing,Type.Missing,Excel.XlPlatform.xlWindows,Type.Missing,Type.Missing,Type.Missing,Type.Missing,Type.Missing,Type.Missing,Type.Missing);

061 mFilename = FileName;

062 }

063 catch (Exception ex)

064 {

065

066 throw new Exception(ex.Message);

067 }

068

069 }

070 public Microsoft.Office.Interop.Excel.Worksheet GetSheet(string SheetName)//获取一个工作表

071 {

072 Microsoft.Office.Interop.Excel.Worksheet s = (Microsoft.Office.Interop.Excel.Worksheet)wb.Worksheets[SheetName];

073 return s;

074

075 }

076 public Microsoft.Office.Interop.Excel.Worksheet GetSheet(int index)//获取一个工作表

077 {

078 Microsoft.Office.Interop.Excel.Worksheet s = (Microsoft.Office.Interop.Excel.Worksheet)wb.Worksheets[index];

079 return s;

080 }

081 public Microsoft.Office.Interop.Excel.Worksheet AddSheet(string SheetName)//添加一个工作表

082 {

083 Microsoft.Office.Interop.Excel.Worksheet s = (Microsoft.Office.Interop.Excel.Worksheet)wb.Worksheets.Add(Type.Missing, Type.Missing, Type.Missing, Type.Missing);

084 s.Name = SheetName;

085 return s;

086 }

087

088 public void DelSheet(string SheetName)//删除一个工作表

089 {

090 ((Microsoft.Office.Interop.Excel.Worksheet)wb.Worksheets[SheetName]).Delete();

091 }

092 public Microsoft.Office.Interop.Excel.Worksheet ReNameSheet(string OldSheetName, string NewSheetName)//重命名一个工作表一

093 {

094 Microsoft.Office.Interop.Excel.Worksheet s = (Microsoft.Office.Interop.Excel.Worksheet)wb.Worksheets[OldSheetName];

095 s.Name = NewSheetName;

096 return s;

097 }

098

099 public Microsoft.Office.Interop.Excel.Worksheet ReNameSheet(Microsoft.Office.Interop.Excel.Worksheet Sheet, string NewSheetName)//重命名一个工作表二

100 {

101

102 Sheet.Name = NewSheetName;

103

104 return Sheet;

105 }

106

107 public void SetCellValue(Microsoft.Office.Interop.Excel.Worksheet ws, int x, int y, object value)//ws：要设值的工作表 X行Y列 value 值

108 {

109 ws.Cells[x, y] = value;

110 }

111 public void SetCellValue(string ws, int x, int y, object value)//ws：要设值的工作表的名称 X行Y列 value 值

112 {

113

114 GetSheet(ws).Cells[x, y] = value;

115

116 }

117

118 public void SetCellProperty(Microsoft.Office.Interop.Excel.Worksheet ws, int Startx, int Starty, int Endx, int Endy, int size, string name, Microsoft.Office.Interop.Excel.Constants color, Microsoft.Office.Interop.Excel.Constants HorizontalAlignment)//设置一个单元格的属性字体，大小，颜色，对齐方式

119 {

120 name = "宋体";

121 size = 12;

122 color = Microsoft.Office.Interop.Excel.Constants.xlAutomatic;

123 HorizontalAlignment = Microsoft.Office.Interop.Excel.Constants.xlRight;

124 ws.get_Range(ws.Cells[Startx, Starty], ws.Cells[Endx, Endy]).Font.Name = name;

125 ws.get_Range(ws.Cells[Startx, Starty], ws.Cells[Endx, Endy]).Font.Size = size;

126 ws.get_Range(ws.Cells[Startx, Starty], ws.Cells[Endx, Endy]).Font.Color = color;

127 ws.get_Range(ws.Cells[Startx, Starty], ws.Cells[Endx, Endy]).HorizontalAlignment = HorizontalAlignment;

128 }

129

130 public void SetCellProperty(string wsn, int Startx, int Starty, int Endx, int Endy, int size, string name, Microsoft.Office.Interop.Excel.Constants color, Microsoft.Office.Interop.Excel.Constants HorizontalAlignment)

131 {

132 //name = "宋体";

133 //size = 12;

134 //color = Excel.Constants.xlAutomatic;

135 //HorizontalAlignment = Excel.Constants.xlRight;

136

137 Microsoft.Office.Interop.Excel.Worksheet ws = GetSheet(wsn);

138 ws.get_Range(ws.Cells[Startx, Starty], ws.Cells[Endx, Endy]).Font.Name = name;

139 ws.get_Range(ws.Cells[Startx, Starty], ws.Cells[Endx, Endy]).Font.Size = size;

140 ws.get_Range(ws.Cells[Startx, Starty], ws.Cells[Endx, Endy]).Font.Color = color;

141

142 ws.get_Range(ws.Cells[Startx, Starty], ws.Cells[Endx, Endy]).HorizontalAlignment = HorizontalAlignment;

143 }

144

145

146 public void UniteCells(Microsoft.Office.Interop.Excel.Worksheet ws, int x1, int y1, int x2, int y2)//合并单元格

147 {

148 ws.get_Range(ws.Cells[x1, y1], ws.Cells[x2, y2]).Merge(Type.Missing);

149 }

150

151 public void UniteCells(string ws, int x1, int y1, int x2, int y2)//合并单元格

152 {

153 GetSheet(ws).get_Range(GetSheet(ws).Cells[x1, y1], GetSheet(ws).Cells[x2, y2]).Merge(Type.Missing);

154

155 }

156

157

158 public void InsertTable(System.Data.DataTable dt, string ws, int startX, int startY)//将内存中数据表格插入到Excel指定工作表的指定位置为在使用模板时控制格式时使用一

159 {

160

161 for (int i = 0; i <= dt.Rows.Count - 1; i++)

162 {

163 for (int j = 0; j <= dt.Columns.Count - 1; j++)

164 {

165 GetSheet(ws).Cells[startX + i, j + startY] = dt.Rows[i][j].ToString();

166

167 }

168

169 }

170

171 }

172 public void InsertTable(System.Data.DataTable dt, Microsoft.Office.Interop.Excel.Worksheet ws, int startX, int startY)//将内存中数据表格插入到Excel指定工作表的指定位置二

173 {

174

175 for (int i = 0; i <= dt.Rows.Count - 1; i++)

176 {

177 for (int j = 0; j <= dt.Columns.Count - 1; j++)

178 {

179

180 ws.Cells[startX + i, j + startY] = dt.Rows[i][j];

181

182 }

183

184 }

185

186 }

187

188

189 public void AddTable(System.Data.DataTable dt, string ws, int startX, int startY)//将内存中数据表格添加到Excel指定工作表的指定位置一

190 {

191

192 for (int i = 0; i <= dt.Rows.Count - 1; i++)

193 {

194 for (int j = 0; j <= dt.Columns.Count - 1; j++)

195 {

196

197 GetSheet(ws).Cells[i + startX, j + startY] = dt.Rows[i][j];

198

199 }

200

201 }

202

203 }

204 public void AddTable(System.Data.DataTable dt, Microsoft.Office.Interop.Excel.Worksheet ws, int startX, int startY)//将内存中数据表格添加到Excel指定工作表的指定位置二

205 {

206

207

208 for (int i = 0; i <= dt.Rows.Count - 1; i++)

209 {

210 for (int j = 0; j <= dt.Columns.Count - 1; j++)

211 {

212

213 ws.Cells[i + startX, j + startY] = dt.Rows[i][j];

214

215 }

216 }

217

218 }

219

220 public void InsertActiveChart(Microsoft.Office.Interop.Excel.XlChartType ChartType, string ws, int DataSourcesX1, int DataSourcesY1, int DataSourcesX2, int DataSourcesY2, Microsoft.Office.Interop.Excel.XlRowCol ChartDataType)//插入图表操作

221 {

222 ChartDataType = Microsoft.Office.Interop.Excel.XlRowCol.xlColumns;

223 wb.Charts.Add(Type.Missing, Type.Missing, Type.Missing, Type.Missing);

224 {

225 wb.ActiveChart.ChartType = ChartType;

226 wb.ActiveChart.SetSourceData(GetSheet(ws).get_Range(GetSheet(ws).Cells[DataSourcesX1, DataSourcesY1], GetSheet(ws).Cells[DataSourcesX2, DataSourcesY2]), ChartDataType);

227 wb.ActiveChart.Location(Microsoft.Office.Interop.Excel.XlChartLocation.xlLocationAsObject, ws);

228 }

229 }

230 public bool Save()//保存文档

231 {

232 if (mFilename == "")

233 {

234 return false;

235 }

236 else

237 {

238 try

239 {

240 wb.Save();

241 return true;

242 }

243

244 catch (Exception ex)

245 {

246 return false;

247 }

248 }

249 }

250 public bool SaveAs(object FileName)//文档另存为

251 {

252 try

253 {

254 wb.SaveAs(FileName, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Microsoft.Office.Interop.Excel.XlSaveAsAccessMode.xlExclusive, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing);

255 return true;

256

257 }

258

259 catch (Exception ex)

260 {

261 return false;

262

263 }

264 }

265 public void Close()//关闭一个Excel对象，销毁对象

266 {

267 //wb.Save();

268 wb.Close(Type.Missing, Type.Missing, Type.Missing);

269 wbs.Close();

270 app.Quit();

271 wb = null;

272 wbs = null;

273 app = null;

274 GC.Collect();

275 }

276 }

本文链接

SQL Server数据库的数据汇总完全解析(WITH ROLLUP)

2010-09-11T00:57:00Z

现有表A，内容如下：

编码仓库数量
01 A 6
01 B 7
02 A 8
02 B 9

现在想按编码查询出这种格式:

01 A 6
01 B 7
汇总小计： 13
02 A 8
02 B 9
汇总小计： 17

问：该如何实现？

乍一看，好像很容易，用group by好像能实现？但仔细研究下去，你又会觉得group by也是无能为力，总欠缺点什么，无从下手。那么，到底该如何做呢？别急，SQL Server早就帮我们做好了，下面，跟我来。

首先，让我们来看一段话：

在生成包含小计和合计的报表时，ROLLUP 运算符很有用。ROLLUP 运算符生成的结果集类似于 CUBE 运算符所生成的结果集。

CUBE 运算符生成的结果集是多维数据集。多维数据集是事实数据的扩展，事实数据即记录个别事件的数据。扩展建立在用户打算分析的列上。这些列被称为维。多维数据集是一个结果集，其中包含了各维度的所有可能组合的交叉表格。

CUBE 运算符在 SELECT 语句的 GROUP BY 子句中指定。该语句的选择列表应包含维度列和聚合函数表达式。GROUP BY 应指定维度列和关键字 WITH CUBE。结果集将包含维度列中各值的所有可能组合，以及与这些维度值组合相匹配的基础行中的聚合值。

CUBE 和 ROLLUP 之间的区别在于：

CUBE 生成的结果集显示了所选列中值的所有组合的聚合。

ROLLUP 生成的结果集显示了所选列中值的某一层次结构的聚合。

看完以上的这段话，悟出了什么没有？如果没有，那么……嘿嘿，你的悟性还不够哟，离“三花棸顶”还早着呢：）。接下来我们再看一段（注意哟，答案马上就揭晓了）：

SELECT 编码, 仓库, Sum(数量) as 数量
FROM A
GROUP BY 编码, 仓库 WITH ROLLUP

--关键就是后面的WITH ROLLUP

--当然，你也可以用WITH CUBE，但是结果会有点不大一样

可能看完上面这段你还是觉得“云里雾里”，摸不着头脑。实在不明白也没关系，自己动手做。

首先：建一个上面所说的A表，输入几行数据；

接着：打开你的SQL Server查询分析器，连上包含你上面所建A表的服务器，选择包含该表的数据库；

然后：Copy上面这段SQL 语句，Paste到查询分析器中，按F5，怎么样？看到下面出来了什么？是不是和我下面的一样？

编码仓库数量
01 A 　6
01 B 　 7
01 NULL　 13
02 A 8
02 B 9
02 NULL　　17
NULL NULL　　30

--如果你用的是WITH CUBE，结果集的后面还会多出两条（如果你也只是输入示例中的几行数据的话）：

NULL A 14
NULL B 16

咦！奇怪，结果中怎么有那么多“NULL”值？哈，别急，这几行正是我们所要的汇总数据行，不难看出：

01　NULL　13正是对编码为01的所有仓库中的数量的汇总；02　NULL　17是对编码为02的所有仓库的数量的汇总；

NULL　NULL　30是对所有资料行数量的汇总。

如何？答案出来了吧？是不是很简单呢？当然，上面还有点美中不足，那就是有好多“NULL”的存在。如何去掉这些无意义的NULL呢？下面我们再进行优化。

1、用Grouping替换NULL值

SELECT CASE WHEN (GROUPING(编码) = 1) THEN 'ALL'
ELSE ISNULL(编码, 'UNKNOWN')
END AS 编码,
CASE WHEN (GROUPING(仓库) = 1) THEN 'ALL'
ELSE ISNULL(仓库, 'UNKNOWN')
END AS 仓库,
SUM(数量) AS 数量
FROM A
GROUP BY 编码, 仓库 WITH ROLLUP

--适当的运用Case函数

结果我这里就不写了，就是把上面的“NULL”值全部换成“ALL”字符串

2、利用程序做进一步的优化

//通常为了显示上的需要，我们必须对以上SQL语句生成的结果做一些优化，下面给出自然语言描述：

WHILE（未到达最后一条记录）｛
IF 编码值不为ALL而仓库值为ALL
｛
　将编码值用“小计：”替换，将仓库值用""替换;
　将这一行的颜色标示为灰色;
｝
ELSE 编码值为ALL仓库值也为ALL
｛
　将编码值用“总计：”替换，将仓库值用""替换;
　将这一行的着色标示为淡绿色;
｝
指针移到下一条;
}

本文链接

net托管资源和非托管资源

2010-08-19T02:09:00Z

对于托管的资源的回收工作，是不需要人工干预回收的，而且你也无法干预他们的回收，所能够做的只是了解.net CLR如何做这些操作。也就是说对于您的应用程序创建的大多数对象，可以依靠 .NET Framework 的垃圾回收器隐式地执行所有必要的内存管理任务。

对于非托管资源，您在应用程序中使用完这些非托管资源之后，必须显示的释放他们，例如System.IO.StreamReader的一个文件对象，必须显示的调用对象的Close()方法关闭它，否则会占用系统的内存和资源，而且可能会出现意想不到的错误。

我想说到这里，一定要清楚什么是托管资源，什么是非托管资源了？

最常见的一类非托管资源就是包装操作系统资源的对象，例如文件，窗口或网络连接，对于这类资源虽然垃圾回收器可以跟踪封装非托管资源的对象的生存期，但它不了解具体如何清理这些资源。还好.net Framework提供了Finalize()方法，它允许在垃圾回收器回收该类资源时，适当的清理非托管资源。如果在MSDN Library 中搜索Finalize将会发现很多类似的主题，这里列举几种常见的非托管资源：ApplicationContext,Brush,Component,ComponentDesigner,Container,Context,Cursor,FileStream,Font,Icon,Image,Matrix,Object,OdbcDataReader,OleDBDataReader,Pen,Regex,Socket,StreamWriter,Timer,Tooltip 等等资源。可能在使用的时候很多都没有注意到！

关于托管资源，就不用说了撒，像简单的int,string,float,DateTime等等，.net中超过80%的资源都是托管资源。

非托管资源如何释放，.NET Framework 提供 Object.Finalize 方法，它允许对象在垃圾回收器回收该对象使用的内存时适当清理其非托管资源。默认情况下，Finalize 方法不执行任何操作。默认情况下，Finalize 方法不执行任何操作。如果您要让垃圾回收器在回收对象的内存之前对对象执行清理操作，您必须在类中重写 Finalize 方法。然而大家都可以发现在实际的编程中根本无法override方法Finalize(),在C#中，可以通过析构函数自动生成 Finalize 方法和对基类的 Finalize 方法的调用。

例如：
~MyClass()
{
// Perform some cleanup operations here.
}
该代码隐式翻译为下面的代码。
protected override void Finalize()
{
try
{
// Perform some cleanup operations here.
}
finally
{
base.Finalize();
}
}

但是，在编程中，并不建议进行override方法Finalize()，因为，实现 Finalize 方法或析构函数对性能可能会有负面影响。一个简单的理由如下：用 Finalize 方法回收对象使用的内存需要至少两次垃圾回收，当垃圾回收器回收时，它只回收没有终结器(Finalize方法)的不可访问的内存，这时他不能回收具有终结器(Finalize方法)的不可以访问的内存。它改为将这些对象的项从终止队列中移除并将他们放置在标记为“准备终止”的对象列表中，该列表中的项指向托管堆中准备被调用其终止代码的对象，下次垃圾回收器进行回收时，就回收并释放了这些内存。

C#托管及未托管对象管理

　c#中的对象分为值类型和引用类型,二者最大的区别在于数据的存储方式和存储位置.WINDOWS操作系统使用虚拟寻址系统来管理程序运行时产生的数据存放.简单的说,该系统管理着一个内存区域,在该区域中划拨出一部分出来专门存放值类型变量,称为堆栈,堆栈采用先进后出的原则,将值类型变量从区域的最高地址位开始向低位地址存储,先进后出,后进先出的管理方式保证了值类型变量在出了作用域后能即使的清除占用的内存区域,由于堆栈速度快,所保存的数据一般不太大，这部分一般不需要用户专门操作. 值类型保存在堆栈汇总，堆栈有非常高的性能，但对于所有的变量来说还是不太灵活。通常我们希望使用一个方法分配内存，来存储一些数据，并在方法退出后的很长一段时间内数据仍是可以使用的。只要是用new运算符来请求存储空间，就存在这种可能性——例如所有的引用类型。此时就要使用托管堆。它在垃圾收集器的控制下工作，托管堆(或简称为堆)是系统管理的大内存区域中的另一个内存区域。要了解堆的工作原理和如何为引用数据类型分配内存，看看下面的代码：
Customer arabel = new Customer();
这行代码完成了以下操作：首先，分配堆上的内存，以存储Customer实例(一个真正的实例，不只是一个地址)。然后把变量arabel的值设置为分配给新Customer对象的内存地址(它还调用合适的Customer()构造函数初始化类实例中的字段，但我们不必担心这部分)。
Customer实例没有放在堆栈中，而是放在内存的堆中。如果我们这样操作:
Customer newaddress = arabel ;
这时候,newaddress也会保存在堆栈中，其值和arabel 相同,都是存储Customer实例的堆地址.
    　知道了这些,我们会发现这样一个问题，如果堆栈中arabel 和newaddress两个变量过期销毁，那堆中保存的Customer对象会怎样？实际上它仍保留在堆中，一直到程序停止，或垃圾收集器删除它为止．　Ｃ＃的垃圾收集器如果没有显示调用，会定时运行并检查内存，删除没有任何变量引用的数据．看起来似乎不错，但是想想，垃圾回收器并不是时时检查，它是定时运行，而在这段时间内如果产生大量的过期数据驻留在内存中.....　那么或许我们可以通过调用System.GC.Collect()，强迫垃圾收集器在代码的某个地方运行，System.GC是一个表示垃圾收集器的.NET基类， Collect()方法则调用垃圾收集器。但是，这种方式适用的场合很少，（难道销毁一个对象就让垃圾回收检查一便内存吗？）例如，代码中有大量的对象刚刚停止引用，就适合调用垃圾收集器。况且垃圾收集器的逻辑不能保证在一次垃圾收集过程中，从堆中删除所有过期数据，对于不受垃圾回收器管理的未托管对象（例如文件句柄、网络连接和数据库连接），它是无能为力的。那该怎么做呢？
这时需要制定专门的规则，确保未托管的资源在回收类的一个实例时释放。
在定义一个类时，可以使用两种机制来自动释放未托管的资源。这些机制常常放在一起实现，因为每个机制都为问题提供了略为不同的解决方法。这两个机制是：
●         声明一个析构函数，作为类的一个成员
●         在类中实现System.IDisposable接口
下面依次讨论这两个机制，然后介绍如何同时实现它们，以获得最佳的效果。
析构函数
前面介绍了构造函数可以指定必须在创建类的实例时进行的某些操作，在垃圾收集器删除对象时，也可以调用析构函数。由于执行这个操作，所以析构函数初看起来似乎是放置释放未托管资源、执行一般清理操作的代码的最佳地方。但是，事情并不是如此简单。由于垃圾回首器的运行规则决定了，不能在析构函数中放置需要在某一时刻运行的代码，如果对象占用了宝贵而重要的资源，应尽可能快地释放这些资源，此时就不能等待垃圾收集器来释放了．
IDisposable接口
一个推荐替代析构函数的方式是使用System.IDisposable接口。IDisposable接口定义了一个模式(具有语言级的支持)，为释放未托管的资源提供了确定的机制，并避免产生析构函数固有的与垃圾函数器相关的问题。IDisposable接口声明了一个方法Dispose()，它不带参数，返回void，Myclass的方法Dispose()的执行代码如下：
class Myclass : IDisposable
{
    public void Dispose()
    {
       // implementation
    }
}
Dispose()的执行代码显式释放由对象直接使用的所有未托管资源，并在所有实现IDisposable接口的封装对象上调用Dispose()。这样，Dispose()方法在释放未托管资源时提供了精确的控制。
假定有一个类ResourceGobbler，它使用某些外部资源，且执行IDisposable接口。如果要实例化这个类的实例，使用它，然后释放它，就可以使用下面的代码：
ResourceGobbler theInstance = new ResourceGobbler();

    // 这里是theInstance 对象的使用过程

theInstance.Dispose();
如果在处理过程中出现异常，这段代码就没有释放theInstance使用的资源，所以应使用try块，编写下面的代码：
ResourceGobbler theInstance = null;
try
{
    theInstance = new ResourceGobbler();
//   这里是theInstance 对象的使用过程
}
finally
{
   if (theInstance != null) theInstance.Dispose();
}
即使在处理过程中出现了异常，这个版本也可以确保总是在theInstance上调用Dispose()，总是释放由theInstance使用的资源。但是，如果总是要重复这样的结构，代码就很容易被混淆。C#提供了一种语法，可以确保在引用超出作用域时，在对象上自动调用Dispose()(但不是 Close())。该语法使用了using关键字来完成这一工作—— 但目前，在完全不同的环境下，它与命名空间没有关系。下面的代码生成与try块相对应的IL代码：
using (ResourceGobbler theInstance = new ResourceGobbler())
{
    //   这里是theInstance 对象的使用过程
}
using 语句的后面是一对圆括号，其中是引用变量的声明和实例化，该语句使变量放在随附的复合语句中。另外，在变量超出作用域时，即使出现异常，也会自动调用其 Dispose()方法。如果已经使用try块来捕获其他异常，就会比较清晰，如果避免使用using语句，仅在已有的try块的finally子句中调用Dispose()，还可以避免进行额外的缩进。
注意：
对于某些类来说，使用Close()要比Dispose()更富有逻辑性，例如，在处理文件或数据库连接时，就是这样。在这些情况下，常常实现IDisposable接口，再执行一个独立的Close()方法，来调用 Dispose()。这种方法在类的使用上比较清晰，还支持C#提供的using语句。

前面的章节讨论了类所使用的释放未托管资源的两种方式：
●         利用运行库强制执行的析构函数，但析构函数的执行是不确定的，而且，由于垃圾收集器的工作方式，它会给运行库增加不可接受的系统开销。
●         IDisposable接口提供了一种机制，允许类的用户控制释放资源的时间，但需要确保执行Dispose()。
一般情况下，最好的方法是执行这两种机制，获得这两种机制的优点，克服其缺点。假定大多数程序员都能正确调用Dispose()，实现IDisposable接口，同时把析构函数作为一种安全的机制，以防没有调用Dispose()。下面是一个双重实现的例子：
public class ResourceHolder : IDisposable
{
     private bool isDispose ＝ false;

      // 显示调用的Dispose方法
　 public void Dispose()
      {
           Dispose(true);
          GC.SuppressFinalize(this);
       }

        // 实际的清除方法
　 protected virtual void Dispose(bool disposing)
       {
            if (!isDisposed)
          {
       　       if (disposing)
         {
                     // 这里执行清除托管对象的操作.
                  }
                  // 这里执行清除非托管对象的操作
            }

　       isDisposed=true;
      }

       // 析构函数
      ~ResourceHolder()
      {
            Dispose (false);
      }
}
可以看出，Dispose()有第二个protected重载方法，它带一个bool参数，这是真正完成清理工作的方法。Dispose(bool)由析构函数和IDisposable.Dispose()调用。这个方式的重点是确保所有的清理代码都放在一个地方。
传递给Dispose(bool)的参数表示Dispose(bool)是由析构函数调用，还是由IDisposable.Dispose()调用——Dispose(bool)不应从代码的其他地方调用，其原因是：
●         如果客户调用IDisposable.Dispose()，该客户就指定应清理所有与该对象相关的资源，包括托管和非托管的资源。
●         如果调用了析构函数，在原则上，所有的资源仍需要清理。但是在这种情况下，析构函数必须由垃圾收集器调用，而且不应访问其他托管的对象，因为我们不再能确定它们的状态了。在这种情况下，最好清理已知的未托管资源，希望引用的托管对象还有析构函数，执行自己的清理过程。
isDispose成员变量表示对象是否已被删除，并允许确保不多次删除成员变量。这个简单的方法不是线程安全的，需要调用者确保在同一时刻只有一个线程调用方法。要求客户进行同步是一个合理的假定，在整个.NET类库中反复使用了这个假定(例如在集合类中)。最后，IDisposable.Dispose()包含一个对 System.GC. SuppressFinalize()方法的调用。SuppressFinalize()方法则告诉垃圾收集器有一个类不再需要调用其析构函数了。因为 Dispose()已经完成了所有需要的清理工作，所以析构函数不需要做任何工作。调用SuppressFinalize()就意味着垃圾收集器认为这个对象根本没有析构函数．

正确理解以上内容，可以大大优化系统性能，及时释放不需要的数据，不能仅靠Ｃ＃提供的自动回收机制，也需要程序员使用更灵活的办法！二者合一既能让程序运行飞快，也让系统更加稳定！

托管程序中资源的释放问题

.Net所指的托管只是针对内存这一个方面，并不是对于所有的资源；因此对于Stream，数据库的连接，GDI+的相关对象，还有Com对象等等，这些资源并不是受到.Net管理而统称为非托管资源。而对于内存的释放和回收，系统提供了GC-Garbage Collector，而至于其他资源则需要手动进行释放。

那么第二个概念就是什么是垃圾，通过我以前的文章，会了解到.Net类型分为两大类，一个就是值类型，另一个就是引用类型。前者是分配在栈上，并不需要GC回收；后者是分配在堆上，因此它的内存释放和回收需要通过GC来完成。GC的全称为“Garbage Collector”,顾名思义就是垃圾回收器，那么只有被称为垃圾的对象才能被GC回收。也就是说，一个引用类型对象所占用的内存需要被GC回收，需要先成为垃圾。那么.Net如何判定一个引用类型对象是垃圾呢，.Net的判断很简单，只要判定此对象或者其包含的子对象没有任何引用是有效的，那么系统就认为它是垃圾。

明确了这两个基本概念，接下来说说GC的运作方式以及其的功能。内存的释放和回收需要伴随着程序的运行，因此系统为GC安排了独立的线程。那么GC的工作大致是，查询内存中对象是否成为垃圾，然后对垃圾进行释放和回收。那么对于GC对于内存回收采取了一定的优先算法进行轮循回收内存资源。其次，对于内存中的垃圾分为两种，一种是需要调用对象的析构函数，另一种是不需要调用的。GC对于前者的回收需要通过两步完成，第一步是调用对象的析构函数，第二步是回收内存，但是要注意这两步不是在GC一次轮循完成，即需要两次轮循；相对于后者，则只是回收内存而已。

很明显得知，对于某个具体的资源，无法确切知道，对象析构函数什么时候被调用，以及GC什么时候会去释放和回收它所占用的内存。那么对于从C、C++之类语言转换过来的程序员来说，这里需要转变观念。那么对于程序资源来说，我们应该做些什么，以及如何去做，才能使程序效率最高，同时占用资源能尽快的释放。前面也说了，资源分为两种，托管的内存资源，这是不需要我们操心的，系统已经为我们进行管理了；那么对于非托管的资源，这里再重申一下，就是Stream，数据库的连接，GDI+的相关对象，还有Com对象等等这些资源，需要我们手动去释放。

如何去释放，应该把这些操作放到哪里比较好呢。.Net提供了三种方法，也是最常见的三种，大致如下：

1． 析构函数；

2． 继承IDisposable接口，实现Dispose方法；

3． 提供Close方法。

经过前面的介绍，可以知道析构函数只能被GC来调用的，那么无法确定它什么时候被调用，因此用它作为资源的释放并不是很合理，因为资源释放不及时；但是为了防止资源泄漏，毕竟它会被GC调用，因此析构函数可以作为一个补救方法。而Close与Dispose这两种方法的区别在于，调用完了对象的Close方法后，此对象有可能被重新进行使用；而Dispose方法来说，此对象所占有的资源需要被标记为无用了，也就是此对象被销毁了，不能再被使用。例如，常见SqlConnection这个类，当调用完Close方法后，可以通过Open重新打开数据库连接，当彻底不用这个对象了就可以调用Dispose方法来标记此对象无用，等待GC回收。明白了这两种方法的意思后，大家在往自己的类中添加的接口时候，不要歪曲了这两者意思。

接下来说说这三个函数的调用时机，我用几个试验结果来进行说明，可能会使大家的印象更深。

首先是这三种方法的实现，大致如下：

public class DisposeClass:IDisposable

{

public void Close()

{

Debug.WriteLine( "Close called!" );

}

~DisposeClass()

{

Debug.WriteLine( "Destructor called!" );

}

#region IDisposable Members

public void Dispose()

{

// TODO: Add DisposeClass.Dispose implementation

Debug.WriteLine( "Dispose called!" );

}

#endregion

}

对于Close来说不属于真正意义上的释放，除了注意它需要显示被调用外，我在此对它不多说了。

而对于析构函数而言，不是在对象离开作用域后立刻被执行，只有在关闭进程或者调用方法的时候才被调用，参看如下的代码运行结果。

private void Create()

{

DisposeClass myClass = new DisposeClass();

}

private void CallGC()

{

GC.Collect();

}

// Show destructor

Create();

Debug.WriteLine( "After created!" );

CallGC();

运行的结果为：

After created!

Destructor called!

显然在出了Create函数外，myClass对象的析构函数没有被立刻调用，而是等显示调用GC.Collect才被调用。

对于Dispose来说，也需要显示的调用，但是对于继承了IDisposable的类型对象可以使用using这个关键字，这样对象的Dispose方法在出了using范围后会被自动调用。例如：

using( DisposeClass myClass = new DisposeClass() )

{

//other operation here

}

如上运行的结果如下：

Dispose called!

我想说到这里，一定要清楚什么是托管资源，什么是非托管资源了？

关于托管资源，就不用说了撒，像简单的int,string,float,DateTime等等，.net中超过80%的资源都是托管资源。

C#托管及未托管对象管理

托管程序中资源的释放问题

如何去释放，应该把这些操作放到哪里比较好呢。.Net提供了三种方法，也是最常见的三种，大致如下：

1． 析构函数；

2． 继承IDisposable接口，实现Dispose方法；

3． 提供Close方法。

接下来说说这三个函数的调用时机，我用几个试验结果来进行说明，可能会使大家的印象更深。

首先是这三种方法的实现，大致如下：

public class DisposeClass:IDisposable

{

public void Close()

{

Debug.WriteLine( "Close called!" );

}

~DisposeClass()

{

Debug.WriteLine( "Destructor called!" );

}

#region IDisposable Members

public void Dispose()

{

// TODO: Add DisposeClass.Dispose implementation

Debug.WriteLine( "Dispose called!" );

}

#endregion

}

对于Close来说不属于真正意义上的释放，除了注意它需要显示被调用外，我在此对它不多说了。

而对于析构函数而言，不是在对象离开作用域后立刻被执行，只有在关闭进程或者调用方法的时候才被调用，参看如下的代码运行结果。

private void Create()

{

DisposeClass myClass = new DisposeClass();

}

private void CallGC()

{

GC.Collect();

}

// Show destructor

Create();

Debug.WriteLine( "After created!" );

CallGC();

运行的结果为：

After created!

Destructor called!

显然在出了Create函数外，myClass对象的析构函数没有被立刻调用，而是等显示调用GC.Collect才被调用。

using( DisposeClass myClass = new DisposeClass() )

{

//other operation here

}

如上运行的结果如下：

Dispose called!

本文链接

web性能测试分析-工具篇

2010-08-18T06:28:00Z

用于Web性能分析的工具还有很多，以下只不过是我所略知的几种，如各位有使用未列出性能工具，请跟帖共享。以下软件都可容易下载到.我建议全部下载，根据自已的需求，选择最适合自己的一款，呵呵，这个工作比较累呀。

微软官方免费软件：

CLRProfiler

是一个可以用于分析.NET程序行为的工具。可用其分析垃圾回收器堆正在发生的事情，例如什么方法分配了什么类型的对象？另外，还提供了调用图（call graph）功能用于显示哪个方法调用了哪个方法

Microsoft Web Application Stress Tool

Microsoft Web Application Stress Tool 是由微软的网站测试人员所开发，专门用来进行实际网站压力测试的一套工具。透过这套功能强大的压力测试工具，您可以使用少量的Client端计算机仿真大量用户上线对网站服务所可能造成的影响，在网站实际上线之前先对您所设计的网站进行如同真实环境下的测试，以找出系统潜在的问题，对系统进行进一步的调整、设置工作。

Microsoft Application Center Test

Microsoft Application Center Test是vs.net2003企业版自带的一个测试工具.使用它可以收集性能信息.确定WEB应用程序的容量.也可以创建测试,模拟同时从WEB应用程序请求网页的多个用户.这些模拟测试有助于确定应用程序的稳定性.速度和响应能力.

商业软件(其实试用30天已经足够用了)：

dotTrace

是个很不错的分析工具（Profiling Tool），可以分析windows form和asp.net ，它能够快速分析、过滤、函数查找（快速定位function，并且导航）和查看源码.

试用版下载(http://www.red-gate.com/products/ants_profiler/index.htm)

ANTS Profiler

一个检测基于.Net Framework的任何语言开发出的应用程序的代码性能的工具。她可以通过记录每行代码花费的时间，来帮助你优化程序的执行，而且可以用很多种格式来探测应用程序中效率不好的区域。ANTS Profiler还可以分析应用程序的内存使用状况，她就是通过记录每个对象分配的内存空间大小，来提供很多种报告样式给开着这察看哪个对象或者类占用了最多的内存，从而可以帮助你优化内存的使用。

试用版下载(http://www.red-gate.com/products/ants_profiler/index.htm)

AQTime

一款功能强大的Code Profiler工具,有很多种代码分析方式，一般主要是用它来做性能分析，目的是定位程序性能瓶颈，然后再有针对性地进行优化。函数追踪功能，能看清函数的调用，而且能定位到行级,确定系统性能的瓶颈。

试用版下载(http://www.automatedqa.com)

.NET Memory Profiler

是NET Memory Profiler是一款强大的.net 内存跟踪和优化工具。

DevPartner Studio Professional Edition

是一套功能非常强大全面性的软件开发除错工具，协助程序开发人员使用微软Visual Studio .NET与Visual Studio 6.0开发应用程序与WebService。其功能包括扫描程序找出程序码潜在的问题，侦测执行阶段的错误，程序执行效能分析，分散式应用系统问题分析，与程序码测试涵盖度分析等。支持微软的 Visual Studio .NET、Native Windows或是两者混合使用的应用程序，加速应用程序的开发，提高应用系统的稳定性与执行效能。

LoadRunner

是否目前国内最多人用的压力测试工具，感觉与.net搭配不是很好。

本文链接

操作iis应用程序池

2010-04-09T04:32:00Z

using System; using System.DirectoryServices; using System.Reflection;namespace ADSIX { /// /// Small class containing methods to configure IIS. /// class ConfigIIS { /// /// The main entry p...

深入理解.NET内存回收机制

2009-09-02T03:03:00Z

Net平台提供了许多新功能，这些功能能够帮助程序员生产出更高效和稳定的代码。其中之一就是垃圾回收器（GC）。这篇文章将深入探讨这一功能，了解它是如何工作的以及如何编写代码来更好地使用这一.Net平台提供的功能。 .Net中的内存回收机制垃圾回收器是用来管理应用程序的内存分配和释放的。在垃圾回收器出现以前，程序员在使用内存时需要向系统申请内存空间。有些语言，例如Visual Basic，可以自动完成...

磁盘空间使用关乎SQL Server性能

2009-07-01T03:19:00Z

当谈到影响SQL Server性能的组分时，你很可能会想到CPU的使用率、内存和查询过程所占用的I/O资源。不过，还有另外一个值得注意的影响因素，那就是磁盘空间的使用。在以前，磁盘空间的成本非常高，所以大部分人都会竭尽所能地节约磁盘空间的使用。相信大家对千年虫问题还记忆犹新，问题的产生正是源于日期是以八位字符(例如2000年11月7日的格式为11/07/00)形式存储的。老牌的计算机程序员在存储每...