我用的是一种很笨的方法，但可以帮助初学者了解访问XML节点的过程。

                 java中四种操作xml方式的比较

1. 介绍
1）DOM(JAXP Crimson解析器)
                   
    DOM是用与平台和语言无关的方式表示XML文档的官方W3C标准。DOM是以层次结构组织的节点或信息片断的集合。这个层次结构允许开发人员在树中寻找特定信息。分析该结构通常需要加载整个文档和构造层次结构，然后才能做任何工作。由于它是基于信息层次的，因而DOM被认为是基于树或基于对象的。DOM以及广义的基于树的处理具有几个优点。首先，由于树在内存中是持久的，因此可以修改它以便应用程序能对数据和结构作出更改。它还可以在任何时候在树中上下导航，而不是像SAX那样是一次性的处理。DOM使用起来也要简单得多。
           
2）SAX
                   
    SAX处理的优点非常类似于流媒体的优点。分析能够立即开始，而不是等待所有的数据被处理。而且，由于应用程序只是在读取数据时检查数据，因此不需要将数据存储在内存中。这对于大型文档来说是个巨大的优点。事实上，应用程序甚至不必解析整个文档；它可以在某个条件得到满足时停止解析。一般来说，SAX还比它的替代者DOM快许多。

    选择DOM还是选择SAX？ 对于需要自己编写代码来处理XML文档的开发人员来说，选择DOM还是SAX解析模型是一个非常重要的设计决策。 DOM采用建立树形结构的方式访问XML文档，而SAX采用的事件模型。

    DOM解析器把XML文档转化为一个包含其内容的树，并可以对树进行遍历。用DOM解析模型的优点是编程容易，开发人员只需要调用建树的指令，然后利用navigation APIs访问所需的树节点来完成任务。可以很容易的添加和修改树中的元素。然而由于使用DOM解析器的时候需要处理整个XML文档，所以对性能和内存的要求比较高，尤其是遇到很大的XML文件的时候。由于它的遍历能力，DOM解析器常用于XML文档需要频繁的改变的服务中。

    SAX解析器采用了基于事件的模型，它在解析XML文档的时候可以触发一系列的事件，当发现给定的tag的时候，它可以激活一个回调方法，告诉该方法制定的标签已经找到。SAX对内存的要求通常会比较低，因为它让开发人员自己来决定所要处理的tag。特别是当开发人员只需要处理文档中所包含的部分数据时，SAX这种扩展能力得到了更好的体现。但用SAX解析器的时候编码工作会比较困难，而且很难同时访问同一个文档中的多处不同数据。

3）JDOM http://www.jdom.org
                     
    JDOM的目的是成为Java特定文档模型，它简化与XML的交互并且比使用DOM实现更快。由于是第一个Java特定模型，JDOM一直得到大力推广和促进。正在考虑通过“Java规范请求JSR-102”将它最终用作“Java标准扩展”。从2000年初就已经开始了JDOM开发。

    JDOM与DOM主要有两方面不同。首先，JDOM仅使用具体类而不使用接口。这在某些方面简化了API，但是也限制了灵活性。第二，API大量使用了Collections类，简化了那些已经熟悉这些类的Java开发者的使用。

    JDOM文档声明其目的是“使用20%(或更少)的精力解决80%(或更多)Java/XML问题”(根据学习曲线假定为20%)。JDOM对于大多数Java/XML应用程序来说当然是有用的，并且大多数开发者发现API比DOM容易理解得多。JDOM还包括对程序行为的相当广泛检查以防止用户做任何在XML中无意义的事。然而，它仍需要您充分理解XML以便做一些超出基本的工作(或者甚至理解某些情况下的错误)。这也许是比学习DOM或JDOM接口都更有意义的工作。

    JDOM自身不包含解析器。它通常使用SAX2解析器来解析和验证输入XML文档(尽管它还可以将以前构造的DOM表示作为输入)。它包含一些转换器以将JDOM表示输出成SAX2事件流、DOM模型或XML文本文档。JDOM是在Apache许可证变体下发布的开放源码。
          
4）DOM4J http://dom4j.sourceforge.net
   
    虽然DOM4J代表了完全独立的开发结果，但最初，它是JDOM的一种智能分支。它合并了许多超出基本XML文档表示的功能，包括集成的XPath支持、XML Schema支持以及用于大文档或流化文档的基于事件的处理。它还提供了构建文档表示的选项，它通过DOM4J API和标准DOM接口具有并行访问功能。从2000下半年开始，它就一直处于开发之中。

    为支持所有这些功能，DOM4J使用接口和抽象基本类方法。DOM4J大量使用了API中的Collections类，但是在许多情况下，它还提供一些替代方法以允许更好的性能或更直接的编码方法。直接好处是，虽然DOM4J付出了更复杂的API的代价，但是它提供了比JDOM大得多的灵活性。

    在添加灵活性、XPath集成和对大文档处理的目标时，DOM4J的目标与JDOM是一样的：针对Java开发者的易用性和直观操作。它还致力于成为比JDOM更完整的解决方案，实现在本质上处理所有Java/XML问题的目标。在完成该目标时，它比JDOM更少强调防止不正确的应用程序行为。

    DOM4J是一个非常非常优秀的Java XML API，具有性能优异、功能强大和极端易用使用的特点，同时它也是一个开放源代码的软件。如今你可以看到越来越多的Java软件都在使用DOM4J来读写XML，特别值得一提的是连Sun的JAXM也在用DOM4J。

2. 比较
1）DOM4J性能最好，连Sun的JAXM也在用DOM4J。目前许多开源项目中大量采用DOM4J，例如大名鼎鼎的Hibernate也用DOM4J来读取XML配置文件。如果不考虑可移植性，那就采用DOM4J.

2）JDOM和DOM在性能测试时表现不佳，在测试10M文档时内存溢出。在小文档情况下还值得考虑使用DOM和JDOM。虽然JDOM的开发者已经说明他们期望在正式发行版前专注性能问题，但是从性能观点来看，它确实没有值得推荐之处。另外，DOM仍是一个非常好的选择。DOM实现广泛应用于多种编程语言。它还是许多其它与XML相关的标准的基础，因为它正式获得W3C推荐(与基于非标准的Java模型相对)，所以在某些类型的项目中可能也需要它(如在JavaScript中使用DOM)。

3）SAX表现较好，这要依赖于它特定的解析方式－事件驱动。一个SAX检测即将到来的XML流，但并没有载入到内存(当然当XML流被读入时，会有部分文档暂时隐藏在内存中)。

3. 四种xml操作方式的基本使用方法

xml文件：
＜?xml version="1.0" encoding="GB2312"?＞
  ＜RESULT＞
    ＜VALUE＞
      ＜NO＞A1234＜/NO＞
      ＜ADDR＞四川省XX县XX镇XX路X段XX号＜/ADDR＞
    ＜/VALUE＞
    ＜VALUE＞
      ＜NO＞B1234＜/NO＞
      ＜ADDR＞四川省XX市XX乡XX村XX组＜/ADDR＞
    ＜/VALUE＞
  ＜/RESULT＞

1）DOM
import java.io.*;
import java.util.*;
import org.w3c.dom.*;
import javax.xml.parsers.*;
public class MyXMLReader{
  public static void main(String arge[]){
    long lasting =System.currentTimeMillis();
    try{ 
         File f=new File("data_10k.xml");
         DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance();
         DocumentBuilder builder=factory.newDocumentBuilder();
         Document doc = builder.parse(f);
         NodeList nl = doc.getElementsByTagName("VALUE");
         for (int i=0;i＜nl.getLength();i++){
           System.out.print("车牌号码:" +                                     doc.getElementsByTagName("NO").item(i).getFirstChild().getNodeValue());
           System.out.println("车主地址:" +
                  doc.getElementsByTagName("ADDR").item(i).getFirstChild().getNodeValue());
         }
     }catch(Exception e){
        e.printStackTrace();
     }
  }
}

2）SAX
import org.xml.sax.*;
import org.xml.sax.helpers.*;
import javax.xml.parsers.*;
public class MyXMLReader extends DefaultHandler {
  java.util.Stack tags = new java.util.Stack();
  public MyXMLReader() {
    super();
  }
  public static void main(String args[]) {
    long lasting = System.currentTimeMillis();
    try {
           SAXParserFactory sf = SAXParserFactory.newInstance();
           SAXParser sp = sf.newSAXParser();
           MyXMLReader reader = new MyXMLReader();
           sp.parse(new InputSource("data_10k.xml"), reader);
         } catch (Exception e) {
            e.printStackTrace();
         }
    System.out.println("运行时间：" + (System.currentTimeMillis() - lasting) + "毫秒");
  }
  public void characters(char ch[], int start, int length) throws SAXException {
    String tag = (String) tags.peek();
    if (tag.equals("NO")) { 
       System.out.print("车牌号码：" + new String(ch, start, length));
    }
    if (tag.equals("ADDR")) {
       System.out.println("地址:" + new String(ch, start, length));
    }
  }
  public void startElement(String uri,String localName,String qName,Attributes attrs) {
    tags.push(qName);
  }
} 

3） JDOM
import java.io.*;
import java.util.*;
import org.jdom.*;
import org.jdom.input.*;
public class MyXMLReader {
  public static void main(String arge[]) {
    long lasting = System.currentTimeMillis();
    try {
       SAXBuilder builder = new SAXBuilder(); 
       Document doc = builder.build(new File("data_10k.xml")); 
       Element foo = doc.getRootElement(); 
       List allChildren = foo.getChildren(); 
       for(int i=0;i＜allChildren.size();i++) { 
         System.out.print("车牌号码:" + ((Element)allChildren.get(i)).getChild("NO").getText());
         System.out.println("车主地址:" + ((Element)allChildren.get(i)).getChild("ADDR").getText());
       }
     } catch (Exception e) {
         e.printStackTrace();
     }
  }
}

4）DOM4J
import java.io.*;
import java.util.*;
import org.dom4j.*;
import org.dom4j.io.*;
public class MyXMLReader {
  public static void main(String arge[]) {
    long lasting = System.currentTimeMillis();
    try {
          File f = new File("data_10k.xml");
          SAXReader reader = new SAXReader();
          Document doc = reader.read(f);
          Element root = doc.getRootElement();
          Element foo;
          for (Iterator i = root.elementIterator("VALUE"); i.hasNext();) {
            　 foo = (Element) i.next();
            　 System.out.print("车牌号码:" + foo.elementText("NO"));
            　 System.out.println("车主地址:" + foo.elementText("ADDR"));
          }
     } catch (Exception e) {
        e.printStackTrace();
     }
  }
}

作者Blog：http://blog.csdn.net/best2010/

系统及系统自带的软件(如:ie,wmplayer等)出错,大部分由于动态链接库 (DLL) 文件或 ActiveX 控件 (OCX) 文件损坏，会导致各种系统故障,甚至重装IE,甚至系统,问题依旧.这时您可以使用 Regsvr32 工具修复.

使用方法:开始→运行，输入regsvr32 *.dll 或regsvr32 *.ocx

一、轻松修复IE浏览器

regsvr32 Shdocvw.dll
regsvr32 Oleaut32.dll
regsvr32 Actxprxy.dll
regsvr32 Mshtml.dll
regsvr32 Urlmon.dll
regsvr32 jscript.dll
同时运行以上命令可以解决以下IE问题:
IE不能打开新的窗口，用鼠标点击超链接也没有任何反应的问题；网页显示不完整，JAVA效果不出现，网页不自动跳转，打开某些网站时总提示‘无法显示该页’;状态栏显示‘网页上有错误’的提示。

二、Windows无法在线升级
----regsvr32 wupdinfo.dll

三.XP系统的搜索功能、帮助和支持.管理工具等，打开无任何反应------regsvr32 shdocvw.dll


四.控制面板中的添加/删除程序时，双击它的图标后无反应，或者打开后自动关闭了或打开后一片空白.
regsvr32 appwiz.cpl
regsvr32 mshtml.dll
regsvr32 jscript.dll
regsvr32 msi.dll
regsvr32 c:\program files\common files\system\ole db\oledb32.dll
regsvr32 c:\program files\common files\system\ado\msado15.dll
regsvr32 mshtmled.dll
regsvr32 /i shdocvw.dll
regsvr32 /i shell32.dll

五.文件夹中不使用缩略图查看文件
2000: regsvr32 C:＼Winnt＼System32＼thumbvw.dll
XP:  regsvr32 shimgvw.dll

  
六.搜索’功能的搜索助理操作面板空白及系统还原功能无法使用等。如图1
解决方法:regsvr32 vbscript.dll  
        regsvr32 jscript.dll

七.WINplayer 9打开时提示‘出现内部应用程序错误’,如图2:
regsvr32 jscript.dll

八. 恢复Windows默认的文件关联
rundl32l setup.dll,InstallHinfSection DefaultInstall 132 c:\windows\inf\shell.in
regsvr32.exe /i shdocvw.dll
regsvr32 /i shell32.dll
regsvr32.exe /i shdoc401.dll

九：内存不能读写，如图2。
除去硬件原因：如内存不兼容等。软件原因大部分也是.dll文件损坏。
当然如果是个别软件运行时出现这个问题，重装那个软件看看能不能解决。
需要修复的.DLL文件如下：
regsvr32 actxprxy.dll
regsvr32 shdocvw.dll
regsvr32 oleaut32.dll
regsvr32 actxprxy.dll
regsvr32 mshtml.dll
regsvr32 msjava.dll
regsvr32 browseui.dll
regsvr32 urlmon.dll

注1:一个重要参数 /U(卸载.DLL或.ocx文件,导致系统错误)

如:regsvr32 /u jscript.dll  就会出现上图七中的错误.

注2:有的系统故障要用注册很多个.dll文件,可以用记事本建一个文件,把那些命令拷贝进去.然后另存为"修复.bat",运行"修复.bat"就可以修复了.

我的修复.bat,注册上面的所有.dll文件
regsvr32 Shdocvw.dll
regsvr32 Oleaut32.dll
regsvr32 Actxprxy.dll
regsvr32 Mshtml.dll
regsvr32 Urlmon.dll
regsvr32 jscript.dll
regsvr32 wupdinfo.dll
rundll32 setup.dll,InstallHinfSection DefaultInstall 132 c:\windows\inf\shell.inf
regsvr32.exe /i shdocvw.dll
regsvr32 /i shell32.dll
regsvr32.exe /i shdoc401.dll
regsvr32 shdocvw.dll
regsvr32 vbscript.dll  

邓辉 、孙鸣(dhui@263.net)

abstract class和interface是Java语言中对于抽象类定义进行支持的两种机制，正是由于这两种机制的存在，才赋予了Java强大的面向对象能力。abstract class和interface之间在对于抽象类定义的支持方面具有很大的相似性，甚至可以相互替换，因此很多开发者在进行抽象类定义时对于abstract class和interface的选择显得比较随意。其实，两者之间还是有很大的区别的，对于它们的选择甚至反映出对于问题领域本质的理解、对于设计意图的理解是否正确、合理。本文将对它们之间的区别进行一番剖析，试图给开发者提供一个在二者之间进行选择的依据。

理解抽象类

abstract class和interface在Java语言中都是用来进行抽象类（本文中的抽象类并非从abstract class翻译而来，它表示的是一个抽象体，而abstract class为Java语言中用于定义抽象类的一种方法，请读者注意区分）定义的，那么什么是抽象类，使用抽象类能为我们带来什么好处呢？

在面向对象的概念中，我们知道所有的对象都是通过类来描绘的，但是反过来却不是这样。并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。抽象类往往用来表征我们在对问题领域进行分析、设计中得出的抽象概念，是对一系列看上去不同，但是本质上相同的具体概念的抽象。比如：如果我们进行一个图形编辑软件的开发，就会发现问题领域存在着圆、三角形这样一些具体概念，它们是不同的，但是它们又都属于形状这样一个概念，形状这个概念在问题领域是不存在的，它就是一个抽象概念。正是因为抽象的概念在问题领域没有对应的具体概念，所以用以表征抽象概念的抽象类是不能够实例化的。

在面向对象领域，抽象类主要用来进行类型隐藏。我们可以构造出一个固定的一组行为的抽象描述，但是这组行为却能够有任意个可能的具体实现方式。这个抽象描述就是抽象类，而这一组任意个可能的具体实现则表现为所有可能的派生类。模块可以操作一个抽象体。由于模块依赖于一个固定的抽象体，因此它可以是不允许修改的；同时，通过从这个抽象体派生，也可扩展此模块的行为功能。熟悉OCP的读者一定知道，为了能够实现面向对象设计的一个最核心的原则OCP(Open-Closed Principle)，抽象类是其中的关键所在。

从语法定义层面看abstract class和interface

在语法层面，Java语言对于abstract class和interface给出了不同的定义方式，下面以定义一个名为Demo的抽象类为例来说明这种不同。

使用abstract class的方式定义Demo抽象类的方式如下：

使用interface的方式定义Demo抽象类的方式如下：

在abstract class方式中，Demo可以有自己的数据成员，也可以有非abstarct的成员方法，而在interface方式的实现中，Demo只能够有静态的不能被修改的数据成员（也就是必须是static final的，不过在interface中一般不定义数据成员），所有的成员方法都是abstract的。从某种意义上说，interface是一种特殊形式的abstract class。

对于abstract class和interface在语法定义层面更多的细节问题，不是本文的重点，不再赘述，读者可以参阅参考文献〔1〕获得更多的相关内容。

从编程层面看abstract class和interface

从编程的角度来看，abstract class和interface都可以用来实现"design by contract"的思想。但是在具体的使用上面还是有一些区别的。

首先，abstract class在Java语言中表示的是一种继承关系，一个类只能使用一次继承关系。但是，一个类却可以实现多个interface。也许，这是Java语言的设计者在考虑Java对于多重继承的支持方面的一种折中考虑吧。

其次，在abstract class的定义中，我们可以赋予方法的默认行为。但是在interface的定义中，方法却不能拥有默认行为，为了绕过这个限制，必须使用委托，但是这会 增加一些复杂性，有时会造成很大的麻烦。

在抽象类中不能定义默认行为还存在另一个比较严重的问题，那就是可能会造成维护上的麻烦。因为如果后来想修改类的界面（一般通过abstract class或者interface来表示）以适应新的情况（比如，添加新的方法或者给已用的方法中添加新的参数）时，就会非常的麻烦，可能要花费很多的时间（对于派生类很多的情况，尤为如此）。但是如果界面是通过abstract class来实现的，那么可能就只需要修改定义在abstract class中的默认行为就可以了。

同样，如果不能在抽象类中定义默认行为，就会导致同样的方法实现出现在该抽象类的每一个派生类中，违反了"one rule，one place"原则，造成代码重复，同样不利于以后的维护。因此，在abstract class和interface间进行选择时要非常的小心。

从设计理念层面看abstract class和interface

上面主要从语法定义和编程的角度论述了abstract class和interface的区别，这些层面的区别是比较低层次的、非本质的。本小节将从另一个层面：abstract class和interface所反映出的设计理念，来分析一下二者的区别。作者认为，从这个层面进行分析才能理解二者概念的本质所在。

前面已经提到过，abstarct class在Java语言中体现了一种继承关系，要想使得继承关系合理，父类和派生类之间必须存在"is a"关系，即父类和派生类在概念本质上应该是相同的（参考文献〔3〕中有关于"is a"关系的大篇幅深入的论述，有兴趣的读者可以参考）。对于interface 来说则不然，并不要求interface的实现者和interface定义在概念本质上是一致的，仅仅是实现了interface定义的契约而已。为了使论述便于理解，下面将通过一个简单的实例进行说明。

考虑这样一个例子，假设在我们的问题领域中有一个关于Door的抽象概念，该Door具有执行两个动作open和close，此时我们可以通过abstract class或者interface来定义一个表示该抽象概念的类型，定义方式分别如下所示：

使用abstract class方式定义Door：

使用interface方式定义Door：

其他具体的Door类型可以extends使用abstract class方式定义的Door或者implements使用interface方式定义的Door。看起来好像使用abstract class和interface没有大的区别。

如果现在要求Door还要具有报警的功能。我们该如何设计针对该例子的类结构呢（在本例中，主要是为了展示abstract class和interface反映在设计理念上的区别，其他方面无关的问题都做了简化或者忽略）？下面将罗列出可能的解决方案，并从设计理念层面对这些不同的方案进行分析。

解决方案一：

简单的在Door的定义中增加一个alarm方法，如下：

或者

那么具有报警功能的AlarmDoor的定义方式如下：

或者

这种方法违反了面向对象设计中的一个核心原则ISP（Interface Segregation Priciple），在Door的定义中把Door概念本身固有的行为方法和另外一个概念"报警器"的行为方法混在了一起。这样引起的一个问题是那些仅仅依赖于Door这个概念的模块会因为"报警器"这个概念的改变（比如：修改alarm方法的参数）而改变，反之依然。

解决方案二：

既然open、close和alarm属于两个不同的概念，根据ISP原则应该把它们分别定义在代表这两个概念的抽象类中。定义方式有：这两个概念都使用abstract class方式定义；两个概念都使用interface方式定义；一个概念使用abstract class方式定义，另一个概念使用interface方式定义。

显然，由于Java语言不支持多重继承，所以两个概念都使用abstract class方式定义是不可行的。后面两种方式都是可行的，但是对于它们的选择却反映出对于问题领域中的概念本质的理解、对于设计意图的反映是否正确、合理。我们一一来分析、说明。

如果两个概念都使用interface方式来定义，那么就反映出两个问题：1、我们可能没有理解清楚问题领域，AlarmDoor在概念本质上到底是Door还是报警器？2、如果我们对于问题领域的理解没有问题，比如：我们通过对于问题领域的分析发现AlarmDoor在概念本质上和Door是一致的，那么我们在实现时就没有能够正确的揭示我们的设计意图，因为在这两个概念的定义上（均使用interface方式定义）反映不出上述含义。

如果我们对于问题领域的理解是：AlarmDoor在概念本质上是Door，同时它有具有报警的功能。我们该如何来设计、实现来明确的反映出我们的意思呢？前面已经说过，abstract class在Java语言中表示一种继承关系，而继承关系在本质上是"is a"关系。所以对于Door这个概念，我们应该使用abstarct class方式来定义。另外，AlarmDoor又具有报警功能，说明它又能够完成报警概念中定义的行为，所以报警概念可以通过interface方式定义。如下所示：

这种实现方式基本上能够明确的反映出我们对于问题领域的理解，正确的揭示我们的设计意图。其实abstract class表示的是"is a"关系，interface表示的是"like a"关系，大家在选择时可以作为一个依据，当然这是建立在对问题领域的理解上的，比如：如果我们认为AlarmDoor在概念本质上是报警器，同时又具有Door的功能，那么上述的定义方式就要反过来了。

结论

abstract class和interface是Java语言中的两种定义抽象类的方式，它们之间有很大的相似性。但是对于它们的选择却又往往反映出对于问题领域中的概念本质的理解、对于设计意图的反映是否正确、合理，因为它们表现了概念间的不同的关系（虽然都能够实现需求的功能）。这其实也是语言的一种的惯用法，希望读者朋友能够细细体会。

参考文献
[1] Thinking in Java, Bruce Eckel
[2] Design Patterns Explained: A New Perspective on Object-Oriented Design, Alan Shalloway
and James R. Trott
[3] Effective C++: 50 Specific Ways to Improve Your Programs and Design, Scott Meyers

.net 配置文件：App.Config（放在运行程序同一个目录下改名为 程序名.exe.Config）
Web.Config

一、访问：

1.访问 <appSettings> 节点
<appSettings> 
 <add key="aa" value="Provider=Microsoft.Jet.OLEDB.4.0;Data Source=qq.mdb"/> 
 <add key="bb" value="bb"/> 
</appSettings> 

方法1 ：
string conString1=System.Configuration.ConfigurationSettings.AppSettings["aa"]; 

方法2：
System.Configuration.AppSettingsReader appReader=new System.Configuration.AppSettingsReader(); 
string conString2=Convert.ToString(appReader.GetValue("bb",typeof(string))); 

方法一在书写上简单明朗。
方法二写法稍微多些，一次读取多个配置点的数值，可以考虑方法二。

2.访问自定义节点
<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <configSections>
    <sectionGroup name="users">
      <section name="user1" type="System.Configuration.NameValueSectionHandler" />
    </sectionGroup>
  </configSections>
  <users>
    <user1>
      <add key="fid" value="fid=17" />
      <add key="tid" value="tid=6530445" />
      <add key="formhash" value="9c633d92" />
      <add key="cdb_sid" value="vQ6cmg" />
      <add key="cdb_cookietime" value="315360000" />
      <add key="cdb_auth" value="UA0ADwEPAVUGAApTBQRSXgwFUVBVC1MAAldTUANTBQFrCF8FAA1bVg07CAgJBFhf" />
    </user1>
  </users>
</configuration>

NameValueCollection usr1 = ConfigurationSettings.GetConfig("users/user1") as NameValueCollection;

string temp = (String)(usr1["fid"]);

疑问：在 <add key="fid" value="fid=17" /> value 中如果有 "&" 符号，似乎创建 NameValueCollection 会失败，不得其解，以后再研究。

最近为了搭J2EE服务器，由于Windows XP不太稳定，又耗资源，于是决定装一个Linux。为了安装使用方便，当然是选择使用最广泛的Red Hat Linux，其最新版本是9。

由于系统已经安装了XP，而且我的主要工作还是在XP下进行的，因此决定安装双系统。

参考了网上相关资料后，结合我的机器的具体配置，经历了几次实践后，终于成功实现双系统，并且通过XP的OS Loader引导Linux。

1. 首先，从ftp://ftp.redhat.com下载3个ISO光盘镜像文件，放到一个FAT32的分区中，这样就可以直接从硬盘安装，而不必刻录到光盘上再安装。注意，最好放在根目录下，可以省去安装过程中指定目录的麻烦。

2. 将第一张盘shrike-i386-disc1.iso加载到虚拟光驱中，把dosutils目录复制出来，放到FAT32分区中。

3. 用DOS软盘启动电脑，进入FAT32分区的dosutils目录，运行autoboot，启动Red Hat Linux 9 安装程序。

4. Red Hat Linux 9 安装程序启动后，会让你选择安装方式，选择从硬盘安装，并输入ISO文件所在的驱动器，我的FAT32分区对应的是/dev/hda4，因此输入/dev/hda4。

5. 接下来是Red Hat Linux 9的标准安装，注意要不破坏XP的引导系统，可以将GRUB或LILO安装到Linux启动分区而不是硬盘的MBR中。安装过程中制作一张启动软盘，安装完成后用软盘重启计算机。

6. 进入Linux系统后，先挂载FAT32分区，比如我将它挂到/mnt/dos下，使用命令
mount -t vfat /dev/hda4 /mnt/dos

7. 使用dd命令复制Linux根分区的第一个扇区到一个文件中，以便使用Windows XP的NT Boot Loader启动Linux。由于我的Linux装在/dev/hda2，因此用root登陆，输入：
#dd if=/dev/hda2 of=/mnt/dos/linuxboot.lnx bs=512 count=1
文件应该存放到FAT32分区或软盘中。

8. 重启进入XP，将FAT32分区的linuxboot.lnx复制到C:盘根目录下，在系统属性中打开启动选项，编辑boot.ini，在[operating systems]下添加：
C:\linuxboot.lnx="Red Hat Linux 9"

9. 重启XP，会出现启动菜单
Microsoft Windows XP Professional
Red Hat Linux 9
选择Red Hat Linux 9就可以直接启动Linux了！

以上的关键是我的C:盘使用的NTFS格式，Linux无法识别，只能通过FAT32分区或者软盘来交换数据。

此外，如果没有制作启动盘，可以将第一张光盘里的loadlin.exe（在dosutils目录下）和vmlinuz（在dosutils\autoboot下）复制到软盘，用DOS启动后，输入：
loadlin vmlinuz root=/dev/hda2 ro
也可以启动Linux，但是要注意，启动后的内核版本显示为2.4.20-8BOOT，而不是2.4.20-8，因此很多驱动无法正确加载，也就无法配置网卡声卡等，但可以通过步骤6-8实现硬盘启动，这样就能正确配置系统了。

java语言已经内置了多线程支持，所有实现Runnable接口的类都可被启动一个新线程，新线程会执行该实例的run()方法，当run()方法执行完毕后，线程就结束了。一旦一个线程执行完毕，这个实例就不能再重新启动，只能重新生成一个新实例，再启动一个新线程。

Thread类是实现了Runnable接口的一个实例，它代表一个线程的实例，并且，启动线程的唯一方法就是通过Thread类的start()实例方法：

Thread t = new Thread();
t.start();

start()方法是一个native方法，它将启动一个新线程，并执行run()方法。Thread类默认的run()方法什么也不做就退出了。注意：直接调用run()方法并不会启动一个新线程，它和调用一个普通的java方法没有什么区别。

因此，有两个方法可以实现自己的线程：

方法1：自己的类extend Thread，并复写run()方法，就可以启动新线程并执行自己定义的run()方法。例如：

public class MyThread extends Thread {
    public run() {
        System.out.println("MyThread.run()");
    }
}

在合适的地方启动线程：new MyThread().start();

方法2：如果自己的类已经extends另一个类，就无法直接extends Thread，此时，必须实现一个Runnable接口：

public class MyThread extends OtherClass implements Runnable {
    public run() {
        System.out.println("MyThread.run()");
    }
}

为了启动MyThread，需要首先实例化一个Thread，并传入自己的MyThread实例：

MyThread myt = new MyThread();
Thread t = new Thread(myt);
t.start();

事实上，当传入一个Runnable target参数给Thread后，Thread的run()方法就会调用target.run()，参考JDK源代码：

public void run() {
    if (target != null) {
        target.run();
    }
}

线程还有一些Name, ThreadGroup, isDaemon等设置，由于和线程设计模式关联很少，这里就不多说了。

6.在Eclipse中使用CVS

版本控制在团队开发中是必不可少的。CVS是优秀的开源版本控制软件，Eclipse本身就内置了对CVS的支持，只需简单配置，即可使用CVS。

首先我们要正确安装并配置好CVS服务器，通常Linux Server都自带CVS服务，不过命令行操作比较繁琐。Windows下也有简单易用的CVS服务器，这里我们推荐CVSNT，可以下载CVSNT 2.0.51a，安装并启动CVSNT：

然后切换到Repositories面板，添加一个Repository，命名为/cvs-java，CVSNT会提示是否初始化这个Repository，选择是：

然后在Advanced面板上选中“Pretend to be a Unix CVS version”：

然后，在Windows账户中为每一个开发人员添加用户名和口令。

现在，CVSNT的安装配置已经完成，下一步，启动Eclipse，我们可以使用原有的Hello工程，或者新建一个Project，然后选择菜单Window->Show View->Other，打开CVS->CVS Repositories：

然后点击按钮，添加一个Repository：

注意用户名和口令直接填Windows的用户名和口令，然后选中“Validate Connection on Finish”，点击Finish完成：

首先，我们要将一个现有的工程放到CVS服务器中，切换到Package Explorer，选中Hello工程，右键点击，选择Team->Share Project…：

使用刚才我们添加的Repository，继续，并将所有文件都添加到CVS中，最后Eclipse提示Commit：

填入一个简单的注释，确定，然后Eclipse会把整个工程提交到CVS服务器，可以在Package Explorer中看到图标发生了变化，Hello.java文件后面会有版本号1.1。在CVS Repositories面板中刷新，可以看到刚添加进来的工程：

在团队开发中，当创建了一个基本的工程并提交到CVS后，别的开发人员首先要Check Out这个工程到各自的本地计算机上，这里为了演示，首先我们在Package Explorer中删除Hello工程，然后打开CVS Repositories（如果没有看到Repository就按照上面的方法添加Repository），选择Hello工程，右键点击，选择Check Out As…：

作为一个Project签出，就可以在Package Explorer中看到签出的工程。

当对某些源文件作了修改后，需要提交更改到CVS服务器。选中更改的文件或工程，右键点击，选择Team->Commit…：

然后填入简单的注释，就可以提交到CVS服务器上了，可以看到源文件的版本号变成了1.2。

以上简单介绍了如何搭建CVS服务器以及在Eclipse中如何使用CVS，可以参考CVS手册以便了解Branch、Merge等更多功能的使用。

5. 在Eclipse中使用Ant

Ant是Java平台下非常棒的批处理命令执行程序，能非常方便地自动完成编译，测试，打包，部署等等一系列任务，大大提高开发效率。如果你现在还没有开始使用Ant，那就要赶快开始学习使用，使自己的开发水平上一个新台阶。

Eclipse中已经集成了Ant，我们可以直接在Eclipse中运行Ant。

以前面建立的Hello工程为例，创建以下目录结构：

新建一个build.xml，放在工程根目录下。build.xml定义了Ant要执行的批处理命令。虽然Ant也可以使用其它文件名，但是遵循标准能更使开发更规范，同时易于与别人交流。

通常，src存放Java源文件，classes存放编译后的class文件，lib存放编译和运行用到的所有jar文件，web存放JSP等web文件，dist存放打包后的jar文件，doc存放API文档。

然后在根目录下创建build.xml文件，输入以下内容：

<?xml version="1.0"?>
<project name="Hello world" default="doc">

 <!-- properies -->
    <property name="src.dir" value="src" />
    <property name="report.dir" value="report" />
    <property name="classes.dir" value="classes" />
    <property name="lib.dir" value="lib" />
    <property name="dist.dir" value="dist" />
 <property name="doc.dir" value="doc"/>

    <!-- 定义classpath -->
    <path id="master-classpath">
        <fileset file="${lib.dir}/*.jar" />
        <pathelement path="${classes.dir}"/>
    </path>

    <!-- 初始化任务 -->
    <target name="init">
    </target>

    <!-- 编译 -->
    <target name="compile" depends="init" description="compile the source files">
        <mkdir dir="${classes.dir}"/>
        <javac srcdir="${src.dir}" destdir="${classes.dir}" target="1.4">
            <classpath refid="master-classpath"/>
        </javac>
    </target>

    <!-- 测试 -->
    <target name="test" depends="compile" description="run junit test">
        <mkdir dir="${report.dir}"/>
        <junit printsummary="on"
                haltonfailure="false"
                failureproperty="tests.failed"
                showoutput="true">
            <classpath refid="master-classpath" />
            <formatter type="plain"/>
            <batchtest todir="${report.dir}">
                <fileset dir="${classes.dir}">
                    <include name="**/*Test.*"/>
                </fileset>
            </batchtest>
        </junit>
        <fail if="tests.failed">
        ***********************************************************
        ****  One or more tests failed!  Check the output ...  ****
        ***********************************************************
        </fail>
    </target>

    <!-- 打包成jar -->
    <target name="pack" depends="test" description="make .jar file">
     <mkdir dir="${dist.dir}" />
        <jar destfile="${dist.dir}/hello.jar" basedir="${classes.dir}">
            <exclude name="**/*Test.*" />
            <exclude name="**/Test*.*" />
        </jar>
    </target>

    <!-- 输出api文档 -->
    <target name="doc" depends="pack" description="create api doc">
     <mkdir dir="${doc.dir}" />
     <javadoc destdir="${doc.dir}"
            author="true"
            version="true"
            use="true"
            windowtitle="Test API">
            <packageset dir="${src.dir}" defaultexcludes="yes">
                <include name="example/**" />
            </packageset>
            <doctitle><![CDATA[<h1>Hello, test</h1>]]></doctitle>
            <bottom><![CDATA[<i>All Rights Reserved.</i>]]></bottom>
            <tag name="todo" scope="all" description="To do:" />
        </javadoc>
    </target>
</project>

以上xml依次定义了init（初始化），compile（编译），test（测试），doc（生成文档），pack（打包）任务，可以作为模板。

选中Hello工程，然后选择“Project”，“Properties”，“Builders”，“New…”，选择“Ant Build”：

填入Name：Ant_Builder；Buildfile：build.xml；Base Directory：${workspace_loc:/Hello}（按“Browse Workspace”选择工程根目录），由于用到了junit.jar包，搜索Eclipse目录，找到junit.jar，把它复制到Hello/lib目录下，并添加到Ant的Classpath中：

然后在Builder面板中钩上Ant_Build，去掉Java Builder：

再次编译，即可在控制台看到Ant的输出：

Buildfile: F:\eclipse-projects\Hello\build.xml

init:

compile:
       [mkdir] Created dir: F:\eclipse-projects\Hello\classes
       [javac] Compiling 2 source files to F:\eclipse-projects\Hello\classes

test:
       [mkdir] Created dir: F:\eclipse-projects\Hello\report
       [junit] Running example.HelloTest
       [junit] Tests run: 1, Failures: 0, Errors: 0, Time elapsed: 0.02 sec

pack:
       [mkdir] Created dir: F:\eclipse-projects\Hello\dist
         [jar] Building jar: F:\eclipse-projects\Hello\dist\hello.jar

doc:
       [mkdir] Created dir: F:\eclipse-projects\Hello\doc
     [javadoc] Generating Javadoc
     [javadoc] Javadoc execution
     [javadoc] Loading source files for package example...
     [javadoc] Constructing Javadoc information...
     [javadoc] Standard Doclet version 1.4.2_04
     [javadoc] Building tree for all the packages and classes...
     [javadoc] Building index for all the packages and classes...
     [javadoc] Building index for all classes...
     [javadoc] Generating F:\eclipse-projects\Hello\doc\stylesheet.css...
     [javadoc] Note: Custom tags that could override future standard tags:  @todo. To avoid potential overrides, use at least one period character (.) in custom tag names.
     [javadoc] Note: Custom tags that were not seen:  @todo
BUILD SUCCESSFUL
Total time: 11 seconds

Ant依次执行初始化，编译，测试，打包，生成API文档一系列任务，极大地提高了开发效率。将来开发J2EE项目时，还可加入部署等任务。并且，即使脱离了Eclipse环境，只要正确安装了Ant，配置好环境变量ANT_HOME=<Ant解压目录>，Path=…;%ANT_HOME%\bin，在命令行提示符下切换到Hello目录，简单地键入ant即可。

4. 在Eclipse中使用JUnit

测试对于保证软件开发质量有着非常重要的作用，单元测试更是必不可少，JUnit是一个非常强大的单元测试包，可以对一个/多个类的单个/多个方法测试，还可以将不同的TestCase组合成TestSuit，使测试任务自动化。Eclipse同样集成了JUnit，可以非常方便地编写TestCase。

我们创建一个Java工程，添加一个example.Hello类，首先我们给Hello类添加一个abs()方法，作用是返回绝对值：

下一步，我们准备对这个方法进行测试，确保功能正常。选中Hello.java，右键点击，选择New->JUnit Test Case：

Eclipse会询问是否添加junit.jar包，确定后新建一个HelloTest类，用来测试Hello类。

选中setUp()和tearDown()，然后点击“Next”：

选择要测试的方法，我们选中abs(int)方法，完成后在HelloTest.java中输入：

JUnit会以以下顺序执行测试：（大致的代码）

try {
    HelloTest test = new HelloTest(); // 建立测试类实例
    test.setUp(); // 初始化测试环境
    test.testAbs(); // 测试某个方法
    test.tearDown(); // 清理资源
}
catch…

setUp()是建立测试环境，这里创建一个Hello类的实例；tearDown()用于清理资源，如释放打开的文件等等。以test开头的方法被认为是测试方法，JUnit会依次执行testXxx()方法。在testAbs()方法中，我们对abs()的测试分别选择正数，负数和0，如果方法返回值与期待结果相同，则assertEquals不会产生异常。

如果有多个testXxx方法，JUnit会创建多个XxxTest实例，每次运行一个testXxx方法，setUp()和tearDown()会在testXxx前后被调用，因此，不要在一个testA()中依赖testB()。

直接运行Run->Run As->JUnit Test，就可以看到JUnit测试结果：

绿色表示测试通过，只要有1个测试未通过，就会显示红色并列出未通过测试的方法。可以试图改变abs()的代码，故意返回错误的结果（比如return n+1;），然后再运行JUnit就会报告错误。

如果没有JUnit面板，选择Window->Show View->Other，打开JUnit的View：

JUnit通过单元测试，能在开发阶段就找出许多Bug，并且，多个Test Case可以组合成Test Suite，让整个测试自动完成，尤其适合于XP方法。每增加一个小的新功能或者对代码进行了小的修改，就立刻运行一遍Test Suite，确保新增和修改的代码不会破坏原有的功能，大大增强软件的可维护性，避免代码逐渐“腐烂”。

Eclipse是一款非常优秀的开源IDE，非常适合Java开发，由于支持插件技术，受到了越来越多的开发者的欢迎。最新的Eclipse 3.0不但界面作了很大的增强，而且增加了代码折叠等众多优秀功能，速度也有明显的提升。配合众多令人眼花缭乱的插件，完全可以满足从企业级Java应用到手机终端Java游戏的开发。本文将带您手把手步入Eclipse的广阔天地，详细介绍在Eclipse下如何开发普通Java程序，Web应用，J2EE应用，手机Java程序，以及如何进行单元测试，重构，配置CVS等详细内容。

我的开发环境是JDK1.4.2+Eclipse3.0+Windows XP SP2，如果你在其他平台上遇到任何问题，欢迎来信交流。

1. 安装JDK1.4

Eclipse是一个基于Java平台的开发环境，它本身也要运行在Java虚拟机上，还要使用JDK的编译器，因此我们必须首先安装JDK。JDK1.4是目前最稳定的版本，同时也是Eclipse运行的必须条件。先从SUN的官方站点http://java.sun.com下载JDK1.4 Windows版，目前最新的是1.4.2_06，然后运行j2sdk-1_4_2_06-windows-i586-p.exe安装，你可以自行设定安装目录，我把它安装到D:\software\j2sdk1.4目录下。

接下来要配置环境变量，以便Java程序能找到已安装的JDK和其他配置信息。右键点击“我的电脑”，选择“属性”，在弹出的对话框中选择“高级”，“环境变量”，就可以看到环境变量对话框：

上面是用户变量，只对当前用户有效，下面是系统变量，对所有用户都有效。如果你希望所有用户都能使用，就在系统变量下点击“新建”，填入：

JAVA_HOME是JDK的安装目录，许多依赖JDK的开发环境都靠它来定位JDK，所以必须保证正确无误。

下一步，找到系统变量Path，点击“编辑”，在最后添上JDK的可执行文件的所在目录，即%JAVA_HOME%\bin，我的对应目录便是D:\software\j2sdk1.4\bin，附加到Path中即可，注意要以分号“;”隔开：

注意：如果系统安装了多个Java虚拟机（比如安装了Oracle 9i就有自带的JDK1.3），必须把JDK1.4的路径放在其他JVM的前面，否则Eclipse启动将报错。

最后一个系统变量是CLASSPATH，Java虚拟机会根据CLASSPATH的设定来搜索class文件所在目录，但这不是必需的，可以在运行Java程序时指定CLASSPATH，比如在Eclipse中运行写好的Java程序时，它会自动设定CLASSPATH，但是为了在控制台能方便地运行Java程序，我建议最好还是设置一个CLASSPATH，把它的值设为“.”，注意是一个点“.”代表当前目录。用惯了Windows的用户可能会以为Java虚拟机在搜索时会搜索当前目录，其实不会，这是UNIX中的习惯，出于安全考虑。许多初学Java的朋友兴匆匆地照着书上写好了Hello，world程序，一运行却弹出java.lang.NoClassDefFoundError，其实就是没有设置好CLASSPATH，只要添加一个当前目录“.”就可以了。

2. 安装Eclipse 3.0

配置好JDK后，下一步便是安装Eclipse 3.0，可以从Eclipse的官方站点http://www.eclipse.org上下载，你会看到如下版本：

● Eclipse SDK
● RCP Runtime Binary
● RCP SDK
● Platform Runtime Binary
● Platform SDK
● JDT Runtime Binary

Eclipse SDK包括了Eclipse开发环境，Java开发环境，Plug-in开发环境，所有源代码和文档，如果你需要所有的功能，可以下载这个版本。

如果你和我一样，只是用Eclipse开发Java应用，而不是开发Eclipse插件或者研究Eclipse代码，那么下载一个Platform Runtime Binary再加上JDT Runtime Binary是最好的选择。

下载eclipse-platform-3.0-win32.zip和eclipse-JDT-3.0.zip后，将它们解压到同一个目录，勿需安装，直接找到目录下的eclipse.exe运行，出现启动画面：

稍等片刻，Eclipse界面就出来了。

如果遇到错误，启动失败，可以检查Eclipse目录下的log文件，我曾经遇到过XmlParser异常，仔细检查发现原来Path中还有一个Oracle的Java1.3版本的虚拟机，将它从Path中去掉后Eclipse启动正常。

3. 第一个Java程序

运行Eclipse，选择菜单“File”，“New”，“Project”，新建一个Java Project，我把它命名为HelloWorld，然后新建一个Java Class：

我把它命名为HelloWorld，并且填上Package为example，钩上“public static void main(String[] args)”，点击“Finish”，Eclipse自动生成了代码框架，我们只需在main方法中填入：

默认设置下，Eclipse会自动在后台编译，我们只需保存，然后选择“Run”，“Run As”，“Java Application”，即可在Eclipse的控制台看到输出。

要调试Java程序也非常简单，Run菜单里包含了标准的调试命令，可以非常方便地在IDE环境下调试应用程序。

1.4版本支持：

选择菜单“Window”，“Preferences”，在对话框中找到“Java”，“Compiler”，“Compliance and Classfiles”，将编译选项改成1.4，就可以使用JDK1.4版的assert（断言）语法，使得测试更加方便：

使用SMTP协议发送邮件，可以不通过SMTP服务器，直接将邮件发送到邮件服务器。很多服务器端程序可能需要向很多用户发送邮件，直接通过SMTP发送可能是最有效的。

关于SMTP协议定义在RFC821，可以在此看中文版。

第一步：通过目标email查找邮件服务器。
例如：asklxf@sohu.com，其邮件服务器地址为：sohumx.sohu.com

import java.net.*;
import java.io.*;
import java.util.*;
import javax.naming.*;
import javax.naming.directory.*;

public class Smtp {

    public static void main(String[] args) throws Exception {
        // DNS服务器，看看本机的DNS配置
        String dns = "dns://192.168.1.1";
        // 邮箱后缀：
        String domain = "sohu.com";
        Hashtable env = new Hashtable();
        env.put("java.naming.factory.initial", "com.sun.jndi.dns.DnsContextFactory");
        env.put("java.naming.provider.url", dns);
        DirContext ctx = new InitialDirContext(env);
        Attributes attr = ctx.getAttributes(domain, new String[]{"MX" });
        NamingEnumeration servers = attr.getAll();
        // 列出所有邮件服务器：
        while(servers.hasMore()) {
            System.out.println(servers.next());
        }
    }
}

第二步：直接连接邮件服务器的25端口，用SMTP协议发送邮件。
这里使用sohu信箱，邮件服务器为sohumx.sohu.com，收信人必须在此服务器上：

import java.net.*;
import java.io.*;
import java.util.*;
import javax.naming.*;
import javax.naming.directory.*;

public class Smtp {

    private static String END_FLAG = "\r\n";

    public static void main(String[] args) throws Exception {
        String mx = "sohumx.sohu.com";
        InetAddress addr = InetAddress.getByName(mx);
        Socket socket = new Socket(addr, 25);

        InputStream in = socket.getInputStream();
        OutputStream out = socket.getOutputStream();

        // 连接成功后服务器会响应：
        response(in);

        // 首先发送HELO命令：
        send("HELO www.javasprite.com" + END_FLAG, out);
        response(in);

        // 然后发送发件人地址：
        send("MAIL FROM: someone@somewhere.com" + END_FLAG, out);
        response(in);

        // 设置收件人地址：
        send("RCPT TO: asklxf@sohu.com" + END_FLAG, out);
        response(in);

        // 开始发送邮件正文：
        send("DATA" + END_FLAG, out);
        response(in);

        send("From: someone@somewhere.com" + END_FLAG, out);
        send("To: asklxf@sohu.com" + END_FLAG, out);
        send("Subject: Test without smtp server" + END_FLAG, out);
        send("Content-Type: text/plain;" + END_FLAG, out);
        send(END_FLAG + END_FLAG, out);

        // 发送邮件正文，如果用中文，需要BASE64编码：
        send("text message body!" + END_FLAG, out);
        // 每行以\r\n结束，不可过长，可拆成多行。

        // 以"\r\n.\r\n"作为结束标志：
        send(END_FLAG + "." + END_FLAG, out);
        response(in);

        // 结束并确认发送：
        send("QUIT" + END_FLAG, out);
        response(in);
        in.close();
        out.close();
        socket.close();
    }

    public static void response(InputStream in) throws Exception {
        byte[] buffer = new byte[1024];
        int n = in.read(buffer);
        String s = new String(buffer, 0, n);
        // 服务器会返回：### Text
        // 具体含义见RFC821
        System.out.println(s);
    }

    public static void send(String s, OutputStream out) throws Exception {
        byte[] buffer = s.getBytes();
        out.write(buffer);
        // 不要忘了flush()，否则可能在缓冲区：
        out.flush();
    }
}

Ok,打开outlook收信，会发现有一封来自someone@somewhere.com的信件。

第三步：处理服务器返回码，各种异常，包装成Java组件以便重用：

public interface SendMail {
    void send(String from, String to, String subject, String text)
}

public class SendMailImpl extends Thread implements SendMail {
    // TODO: 自己写......
}

为了深入了解Java的ClassLoader机制，我们先来做以下实验：

package java.lang;
public class Test {
    public static void main(String[] args) {
        char[] c = "1234567890".toCharArray();
        String s = new String(0, 10, c);
    }
}

String类有一个Package权限的构造函数String(int offset, int length, char[] array)，按照默认的访问权限，由于Test属于java.lang包，因此理论上应该可以访问String的这个构造函数。编译通过！执行时结果如下：

Exception in thread "main" java.lang.SecurityException: Prohibited package name:
 java.lang
        at java.lang.ClassLoader.defineClass(Unknown Source)
        at java.security.SecureClassLoader.defineClass(Unknown Source)
        at java.net.URLClassLoader.defineClass(Unknown Source)
        at java.net.URLClassLoader.access$100(Unknown Source)
        at java.net.URLClassLoader$1.run(Unknown Source)
        at java.security.AccessController.doPrivileged(Native Method)
        at java.net.URLClassLoader.findClass(Unknown Source)
        at java.lang.ClassLoader.loadClass(Unknown Source)
        at sun.misc.Launcher$AppClassLoader.loadClass(Unknown Source)
        at java.lang.ClassLoader.loadClass(Unknown Source)
        at java.lang.ClassLoader.loadClassInternal(Unknown Source)

奇怪吧？要弄清为什么会有SecurityException，就必须搞清楚ClassLoader的机制。

Java的ClassLoader就是用来动态装载class的，ClassLoader对一个class只会装载一次，JVM使用的ClassLoader一共有4种：

启动类装载器，标准扩展类装载器，类路径装载器和网络类装载器。

这4种ClassLoader的优先级依次从高到低，使用所谓的“双亲委派模型”。确切地说，如果一个网络类装载器被请求装载一个java.lang.Integer，它会首先把请求发送给上一级的类路径装载器，如果返回已装载，则网络类装载器将不会装载这个java.lang.Integer，如果上一级的类路径装载器返回未装载，它才会装载java.lang.Integer。

类似的，类路径装载器收到请求后（无论是直接请求装载还是下一级的ClassLoader上传的请求），它也会先把请求发送到上一级的标准扩展类装载器，这样一层一层上传，于是启动类装载器优先级最高，如果它按照自己的方式找到了java.lang.Integer，则下面的ClassLoader都不能再装载java.lang.Integer，尽管你自己写了一个java.lang.Integer，试图取代核心库的java.lang.Integer是不可能的，因为自己写的这个类根本无法被下层的ClassLoader装载。

再说说Package权限。Java语言规定，在同一个包中的class，如果没有修饰符，默认为Package权限，包内的class都可以访问。但是这还不够准确。确切的说，只有由同一个ClassLoader装载的class才具有以上的Package权限。比如启动类装载器装载了java.lang.String，类路径装载器装载了我们自己写的java.lang.Test，它们不能互相访问对方具有Package权限的方法。这样就阻止了恶意代码访问核心类的Package权限方法。

Ftp服务是最常用的网络服务之一，虽然在www风行的今天，Ftp已经远不如以前使用得广泛，但是在许多大学等科研单位，Ftp仍然是最常用的文件交换方式。

构建一个Ftp服务器要比构建一个Ftp客户端来得简单，因为服务器不需要复杂的图形界面。相比传统的C/C++，使用Java的多线程和网络编程能令我们更轻易地开发出稳定可靠的Ftp服务器。

Ftp协议简介
File Transfer Protocol，文件传输协议，顾名思义，Ftp就是用于文件的传输，Ftp协议是基于TCP协议的，因此，在一个Ftp会话开始前，客户端和服务器必须首先建立一个TCP连接，这个TCP连接通常被称作控制连接，客户端通过此连接向服务器发送FTP命令，服务器处理命令后，将返回一个响应码。

每个命令必须有最少一个响应，如果是多个，要易于区别。FTP响应由三个数字构成，后面是一些文本。数字带有足够的信息，客户端程序不用知道后面的文本就知道发生了什么。文本信息与服务器相关，不同的用户，不同的服务器可能有不同的文本信息。文本和数字以空格间隔，文本后以换行符（\n）结束。如果文本多于一行，第一行内要有信息表示这是多行文本，最后一行也要标记为结束行。比如客户端发送获取当前目录的命令“PWD”，服务器的响应可能是：

200 /pub/incoming

响应码的三位数字都有明确的含义：

• 1xx 确定预备应答，这类响应用于说明命令被接受，但请求的操作正在被初始化，在进入下一个命令前等待另外的应答。
  
• 2xx 确定完成应答，要求的操作已经完成，可以执行新命令。
  
• 3xx 确定中间应答，命令已接受，但要求的操作被停止。
  
• 4xx 暂时拒绝完成应答，未接受命令，但错误是临时的，过一会儿可以再次发送消息，比如服务器忙。
  
• 5yz 永远拒绝完成应答，此类响应码一般表示错误，如拒绝登陆。

第二位数字代表的意义：

• x0x 格式错误；
  
• x1x 此类应答是为了请求信息的；
  
• x2x 此类应答是关于控制和数据连接的；
  
• x3x 关于认证和帐户登录过程；
  
• x4x 未使用；
  
• x5x 此类应答是关于文件系统的；

常见的相应有：

• 200 命令执行成功；
  
• 202 命令未实现；
  
• 230 用户登录；
  
• 331 用户名正确，需要口令；
  
• 450 请求的文件操作未执行；
  
• 500 命令不可识别
  
• 502 命令未实现

一个Ftp会话过程中，始终有一个控制连接，如果客户端请求文件，则会有一个数据连接，但FTP协议规定：只要关闭了控制连接，数据连接（如果有）也必须关闭。

不同的FTP服务器对FTP命令的支持程度可能不同，但是TCP标准定义了所有FTP服务器都必须实现的命令，我们的目标就是构建一个实现这个最小命令集的FTP服务器。

（待续）

Eclipse使用技巧

1.在源代码中快速跳转

eclipse中的跳转甚至比VS.Net还方便，方法是按住Ctrl键，然后鼠标指向变量名，方法名，类名，就会出现链接，点击就可跳到定义处。

2.实时语法检查

编辑区右侧如果有红色小方块，直接点击就可跳到有错的行；黄色小方块是警告，可以忽略，但最好检查一下；如果某个函数尚未完成，要提醒自己注意怎么办？加上注释// TODO，右侧就会有蓝色小方块，提示你此处尚未完成。当一个源码的右侧没有任何提示时，说明这个文件已经完成了。

3.自动生成getter/setter方法

只需要申明protected，private类成员变量，然后在Package Explore中找到该类，右键点击，选择“Source”“Generate Getters and Setters”。

4.更改类名/变量名

如果涉及到多处修改，不要直接在源码中更改，在Package Explore中找到要改名的类或变量，右键点击，选择“Refactor”“Rename”，eclipse会自动搜索所有相关代码并替换，确保不会遗漏或改错。

注：我用的版本是Eclipse 3.0

如何编写测试代码肯定是开发人员最头疼的。JUnit是一个非常强大的单元测试包，可以对一个/多个类的单个/多个方法测试，还可以将不同的TestCase组合成TestSuit，使测试任务自动化。

本文简单介绍如何在eclipse中使用JUnit创建一个TestCase来测试一个简单的类。

我们写一个要测试的类Simple如下：

package jexi.test;
public class Simple {
    private int n;
    public Simple(int n) {
        this.n = n;
    }
    // 返回绝对值：
    public int foo() {
        return n>0 ? n : (-n);
    }
}

foo()方法返回绝对值，下一步，我们准备用JUnit对这个foo()方法进行全面测试。

首先，在eclipse中，创建一个java工程，把plugins\org.junit_3.8.1\junit.jar包含进去：


然后写好Simple.java，为它创建一个JUnit Test Case：

在弹出的对话框中填入测试类的名字：SimpleTest，勾上setUp()：

编写测试代码：

package jexi.test;
import junit.framework.TestCase;

public class SimpleTest extends TestCase {
    private Simple s1, s2;

    protected void setUp() throws Exception {
        super.setUp();
        s1 = new Simple(10);
        s2 = new Simple(-7);
    }

    public void testFoo() {
        assertTrue(s1.foo()==10);
        assertTrue(s2.foo()==7);
    }
}

其中setUp()方法是构造初始化环境，我们在setUp中创建两个Simple的实例，testFoo()是用来测试foo()的测试方法，总是以test+方法名构成，然后在测试方法中测试：s1.foo()==10，如果返回值与期待的结果10相等，assertTrue()就执行成功，我们现在可以运行Run->Run As...->JUnit Test，左侧会显示测试结果：

如果我们把Simple的foo()方法改成：

    public int foo() {
        return n;
    }

再次运行JUnit Test，现在assertTrue(s2.foo()==7);测试结果就不正确了，JUnit会报告哪一行结果不正确：

双击就可以快速定位到测试失败的方法调用上。

总结：

JUnit功能非常强大，是代码质量的可靠保证。精心设计的TestCase可以反复使用，将来对某个类进行了更改，只需要运行一遍TestCase就知道改动对客户端有无影响。若干个TestCase还可以组合成TestSuit，结合Ant使得编译，测试，运行整个过程自动化，只需要查看测试结果就可以知道哪些代码出了问题。

一个对象有多种状态，在不同的状态下，同一种方法有不同的行为。如果用swich-case语句，将有大量的条件分支和逻辑代码混在一起。状态模式将每个状态封装到一个独立的类中，利用多态性使得不同状态下同一种方法表现不同的行为。

状态模式的UML图如下：

星际中人族的机枪兵Marine有两种状态：普通状态和打了兴奋针后的状态，两种状态下机枪兵的开枪频率是不同的，我们用状态模式来实现机枪兵的fire()方法。

首先定义抽象状态State接口，这个接口指定了机枪兵的fire行为：

public interface State {

    public void fire();

}

State接口有一个fire()方法，我们实现两个子类NormalState和ExcitedState，分别表示普通状态和打了兴奋针后的状态，并实现具体的fire方法：

public class NormalState implements State {

    public void fire() {

       System.out.println("普通状态每秒开枪1次。");

    }

}

public class ExcitedState implements State {

    public void fire() {

       System.out.println("兴奋状态每秒开枪2次。");

    }

}

最后，定义机枪兵类Marine，每个Marine的实例代表一个机枪兵：

public class Marine {

    // 保持一个状态类的实例：

    private State state = new NormalState();

    // 为机枪兵设置状态：

    public void setState(State state) {

       this.state = state;

    }

    // fire()方法，实际调用的是state变量的fire()方法：

    public void fire() {

       state.fire();

    }

}

最后我们看看如何在客户端控制一个机枪兵的状态：

public static void main(String[] args) {

    // 创建一个机枪兵的实例：

    Marine marine = new Marine();

    // 调用fire()方法：

    marine.fire();

    // 设置为兴奋状态：

    marine.setState(new ExcitedState());

    // 再调用fire()方法：

    marine.fire();

}

对同一个Marine对象调用两次fire()方法，屏幕输出为：

普通状态每秒开枪1次。

兴奋状态每秒开枪2次。

可见机枪兵在两种状态下的同一个fire()方法有不同的行为。

使用状态模式的好处是每个状态被封装到一个独立的类中，这些类可以独立变化，而主对象中没有繁琐的swich-case语句，并且添加新的状态非常容易，只需要从State派生一个新类即可。

　　线性表，链表，哈希表是常用的数据结构，在进行Java开发时，JDK已经为我们提供了一系列相应的类来实现基本的数据结构。这些类均在java.util包中。本文试图通过简单的描述，向读者阐述各个类的作用以及如何正确使用这些类。

Collection
├List
│├LinkedList
│├ArrayList
│└Vector
│　└Stack
└Set
Map
├Hashtable
├HashMap
└WeakHashMap

Collection接口
　　Collection是最基本的集合接口，一个Collection代表一组Object，即Collection的元素（Elements）。一些Collection允许相同的元素而另一些不行。一些能排序而另一些不行。Java SDK不提供直接继承自Collection的类，Java SDK提供的类都是继承自Collection的“子接口”如List和Set。
　　所有实现Collection接口的类都必须提供两个标准的构造函数：无参数的构造函数用于创建一个空的Collection，有一个Collection参数的构造函数用于创建一个新的Collection，这个新的Collection与传入的Collection有相同的元素。后一个构造函数允许用户复制一个Collection。
　　如何遍历Collection中的每一个元素？不论Collection的实际类型如何，它都支持一个iterator()的方法，该方法返回一个迭代子，使用该迭代子即可逐一访问Collection中每一个元素。典型的用法如下：
　　　　Iterator it = collection.iterator(); // 获得一个迭代子
　　　　while(it.hasNext()) {
　　　　　　Object obj = it.next(); // 得到下一个元素
　　　　}
　　由Collection接口派生的两个接口是List和Set。

List接口
　　List是有序的Collection，使用此接口能够精确的控制每个元素插入的位置。用户能够使用索引（元素在List中的位置，类似于数组下标）来访问List中的元素，这类似于Java的数组。
和下面要提到的Set不同，List允许有相同的元素。
　　除了具有Collection接口必备的iterator()方法外，List还提供一个listIterator()方法，返回一个ListIterator接口，和标准的Iterator接口相比，ListIterator多了一些add()之类的方法，允许添加，删除，设定元素，还能向前或向后遍历。
　　实现List接口的常用类有LinkedList，ArrayList，Vector和Stack。

LinkedList类
　　LinkedList实现了List接口，允许null元素。此外LinkedList提供额外的get，remove，insert方法在LinkedList的首部或尾部。这些操作使LinkedList可被用作堆栈（stack），队列（queue）或双向队列（deque）。
　　注意LinkedList没有同步方法。如果多个线程同时访问一个List，则必须自己实现访问同步。一种解决方法是在创建List时构造一个同步的List：
　　　　List list = Collections.synchronizedList(new LinkedList(...));

ArrayList类
　　ArrayList实现了可变大小的数组。它允许所有元素，包括null。ArrayList没有同步。
size，isEmpty，get，set方法运行时间为常数。但是add方法开销为分摊的常数，添加n个元素需要O(n)的时间。其他的方法运行时间为线性。
　　每个ArrayList实例都有一个容量（Capacity），即用于存储元素的数组的大小。这个容量可随着不断添加新元素而自动增加，但是增长算法并没有定义。当需要插入大量元素时，在插入前可以调用ensureCapacity方法来增加ArrayList的容量以提高插入效率。
　　和LinkedList一样，ArrayList也是非同步的（unsynchronized）。

Vector类
　　Vector非常类似ArrayList，但是Vector是同步的。由Vector创建的Iterator，虽然和ArrayList创建的Iterator是同一接口，但是，因为Vector是同步的，当一个Iterator被创建而且正在被使用，另一个线程改变了Vector的状态（例如，添加或删除了一些元素），这时调用Iterator的方法时将抛出ConcurrentModificationException，因此必须捕获该异常。

Stack 类
　　Stack继承自Vector，实现一个后进先出的堆栈。Stack提供5个额外的方法使得Vector得以被当作堆栈使用。基本的push和pop方法，还有peek方法得到栈顶的元素，empty方法测试堆栈是否为空，search方法检测一个元素在堆栈中的位置。Stack刚创建后是空栈。

Set接口
　　Set是一种不包含重复的元素的Collection，即任意的两个元素e1和e2都有e1.equals(e2)=false，Set最多有一个null元素。
　　很明显，Set的构造函数有一个约束条件，传入的Collection参数不能包含重复的元素。
　　请注意：必须小心操作可变对象（Mutable Object）。如果一个Set中的可变元素改变了自身状态导致Object.equals(Object)=true将导致一些问题。

Map接口
　　请注意，Map没有继承Collection接口，Map提供key到value的映射。一个Map中不能包含相同的key，每个key只能映射一个value。Map接口提供3种集合的视图，Map的内容可以被当作一组key集合，一组value集合，或者一组key-value映射。

Hashtable类
　　Hashtable继承Map接口，实现一个key-value映射的哈希表。任何非空（non-null）的对象都可作为key或者value。
　　添加数据使用put(key, value)，取出数据使用get(key)，这两个基本操作的时间开销为常数。
Hashtable通过initial capacity和load factor两个参数调整性能。通常缺省的load factor 0.75较好地实现了时间和空间的均衡。增大load factor可以节省空间但相应的查找时间将增大，这会影响像get和put这样的操作。
使用Hashtable的简单示例如下，将1，2，3放到Hashtable中，他们的key分别是”one”，”two”，”three”：
　　　　Hashtable numbers = new Hashtable();
　　　　numbers.put(“one”, new Integer(1));
　　　　numbers.put(“two”, new Integer(2));
　　　　numbers.put(“three”, new Integer(3));
　　要取出一个数，比如2，用相应的key：
　　　　Integer n = (Integer)numbers.get(“two”);
　　　　System.out.println(“two = ” + n);
　　由于作为key的对象将通过计算其散列函数来确定与之对应的value的位置，因此任何作为key的对象都必须实现hashCode和equals方法。hashCode和equals方法继承自根类Object，如果你用自定义的类当作key的话，要相当小心，按照散列函数的定义，如果两个对象相同，即obj1.equals(obj2)=true，则它们的hashCode必须相同，但如果两个对象不同，则它们的hashCode不一定不同，如果两个不同对象的hashCode相同，这种现象称为冲突，冲突会导致操作哈希表的时间开销增大，所以尽量定义好的hashCode()方法，能加快哈希表的操作。
　　如果相同的对象有不同的hashCode，对哈希表的操作会出现意想不到的结果（期待的get方法返回null），要避免这种问题，只需要牢记一条：要同时复写equals方法和hashCode方法，而不要只写其中一个。
　　Hashtable是同步的。

HashMap类
　　HashMap和Hashtable类似，不同之处在于HashMap是非同步的，并且允许null，即null value和null key。，但是将HashMap视为Collection时（values()方法可返回Collection），其迭代子操作时间开销和HashMap的容量成比例。因此，如果迭代操作的性能相当重要的话，不要将HashMap的初始化容量设得过高，或者load factor过低。

WeakHashMap类
　　WeakHashMap是一种改进的HashMap，它对key实行“弱引用”，如果一个key不再被外部所引用，那么该key可以被GC回收。

总结
　　如果涉及到堆栈，队列等操作，应该考虑用List，对于需要快速插入，删除元素，应该使用LinkedList，如果需要快速随机访问元素，应该使用ArrayList。
　　如果程序在单线程环境中，或者访问仅仅在一个线程中进行，考虑非同步的类，其效率较高，如果多个线程可能同时操作一个类，应该使用同步的类。
　　要特别注意对哈希表的操作，作为key的对象要正确复写equals和hashCode方法。
　　尽量返回接口而非实际的类型，如返回List而非ArrayList，这样如果以后需要将ArrayList换成LinkedList时，客户端代码不用改变。这就是针对抽象编程。

（参考：Sun JDK1.4.1 API DOC）

一种实用实现

Nigel Morton
软件工程师, IBM e-BIT — 商业事件基础结构
2002 年 8 月

本文是 Brian Venn 的文章 利用远程注册表访问（developerWorks，2002 年 1 月）的后续。本文不需要 InstallShield 就可以启用注册表查询（正如 Brian Venn 原先所描述的那样），这看起来是个不错的想法。用于注册表操作的所有函数都包含在 Windows API 中，所以这看起来是个试用部分 Windows API 的理想机会。

必要的函数
要启用远程注册表操作，必需实现两个函数：对远程注册表读出和写入的能力。

读和写函数已经被封装进了 RegConnect DLL。该 DLL 本身隐藏了这些函数实际操作原理的复杂性，稍后我们将对此进行描述。DLL 执行实际连接／断开和读／写函数，并提供了两个易于使用的函数。

可以通过任何能够利用 DLL 的语言（如 C 或 Visual Basic）调用这些函数。要允许从 Java 环境使用 DLL，得做一些额外的工作。

清单 1、 2和 3说明了这些函数的原型。

int WINAPI RegDBGetKeyValueEx(LPCTSTR MachineName, HKEY RegKey, LPCTSTR KeyName,

LPCTSTR ValueName, LPTSTR KeyValue) ;


int WINAPI RegDBSetKeyValueEx(LPCTSTR MachineName, HKEY RegKey, LPCTSTR KeyName,

LPCTSTR ValueName, LPTSTR KeyValue) ;

Declare Function RegDBGetKeyValueEx Lib "RegConnect.dll" (ByVal MachineName As String,

ByVal RegKey As Long, ByVal KeyName As String, ByVal ValueName As String,

ByVal KeyValue As String)

As Integer


Declare Function RegDBSetKeyValueEx Lib "RegConnect.dll" (ByVal MachineName As String,

ByVal RegKey As Long, ByVal KeyName As String, ByVal ValueName As String,

ByVal KeyValue As String)

As Integer

public native String RegDBGetKeyValueEx(String MachineName, int RegKey,

String KeyName, String ValueName) ;


注：因为函数将字符串作为调用结果返回，所以对于 Java 没有 KeyValue 参数。

public native int RegDBSetKeyValueEx(String MachineName, int RegKey, String KeyName,

String ValueName, String KeyValue) ;

公用类 GetKey 和 SetKey 定义了调用和变量。这些类可以用来调用 DLL 函数。

函数参数
对于所有语言，参数如下：

• MachineName：您希望询问的机器的名称 ― 如果这是一个空字符串，则询问本地机器
  
• RegKey：您希望查询的根键值，即 HKEY_LOCAL_MACHINE
  
• KeyName：您希望查询的键名称，即 SOFTWARE\IBM\DB2
  
• ValueName：您希望查询的键中值的名称，即 DB2 Folder Name

• KeyValue：在该参数中将返回键值

• KeyValue：您希望设置的键值

使用函数
通过用所需参数调用各个函数来实现对这些函数的调用。当调用 RegDBGetKeyValueEx 时，某些语言需要用于返回字符串的预定义存储器。如果没有预先分配这个存储器，那么，该函数可能会（并且很可能会）失败。

正如其实现的那样，RegDBGetKeyValueEx 函数仅限于返回注册表字符串（REG_SZ）和数字（DWORD）数据。还请注意，RegDBGetKeyValueEx 仅返回字符串 ― DWORD 值是作为与其等价的 ASCII 数值返回的。

当使用 RegDBSetKeyValueEx 函数来创建键时，如果该键不存在，则将创建键名和键值，记住这一点很重要。如果键已经存在，则原先的值将被覆盖。还请注意，正如其实现的那样，RegDBSetKeyValueEx 将仅存储字符串值。

清单 4显示了一个用 Visual Basic 函数封装 RegDBGetKeyValueEx 函数的示例。

Function GetRegValue(szMachine$, hKey&, szRegTree$, szKey$) As String

Dim Temp&, sReturn$


   sReturn$ = Space(128)           'Pre-define storage for the returned value

   Temp& = RegDBGetKeyValueEx(szMachine$, hKey&, szRegTree$,

   szKey$, sReturn$)

   GetRegValue = Left$(sReturn$, InStr(sReturn$, Chr$(0)))

End Function

为了在 Java 环境中使用这些函数，使用类 GetKey 和 SetKey。 清单 5中的下列示例演示了使用 Java 设置和检索键。

// Test for registry read/write using JNI call to RegConnect.dll


class RegTest

{

   public static void main(String[] args)

   {

   // Set a registry key value

   SetKey skey = new SetKey() ;

   skey.RegKey = skey.HKEY_LOCAL_MACHINE ;

   skey.MachineName = "" ;

   		//Change this to a remote machine if you wish

   skey.KeyName = "software\\IBM\\MyKey" ;

   skey.ValueName ="test" ;

   skey.KeyValue ="My NEW reg value" ;

   skey.iResult = skey.RegDBSetKeyValueEx(skey.MachineName, skey.RegKey,

   		skey.KeyName,

   skey.ValueName, skey.KeyValue) ;

   System.out.println("Set Result is " + skey.iResult); //Display the result of the call

   // Now read the value back again

   GetKey gkey = new GetKey() ;

   gkey.RegKey = gkey.HKEY_LOCAL_MACHINE ;

   gkey.MachineName = "" ;

   		//Change this to a remote machine if you wish

   gkey.KeyName = "software\\IBM\\MyKey" ;

   gkey.ValueName ="test" ;

   gkey.KeyValue = gkey.RegDBGetKeyValueEx(gkey.MachineName, gkey.RegKey,

   		gkey.KeyName, gkey.ValueName) ;

   System.out.println("Data is " + gkey.KeyValue);      //Display the key value

   }

}

DLL 代码（完成所有工作的那部分）
本文所提供的实现 Registry 功能的 DLL 使用标准 Windows API 调用来执行其函数。两个函数的初始需求都是连接到远程注册表。使用下列函数调用实现这一点：

// Connect to the remote registry

lRC = RegConnectRegistry(cMachine, hRegKey, &hRemoteKey) ;

这个函数调用的重要参数是正在连接的远程机器名和您希望访问的注册表的根。这些参数包含于用于机器名的 cMachine 参数和用于注册表根的 hRegKey 参数中。hRegKey 参数实际上只是一个长数据类型，它是用与所需注册表根相关的值设置的。这些值被声明为常数值，即 HKEY_CURRENT_USER。剩下的那个参数返回一个指向该注册表的句柄，其余函数使用该句柄来访问该远程注册表。

一旦获得了到远程机器的注册表的连接，就可以执行对该注册表读或写的函数。

如果正在调用设置键值的函数，则要设置的注册表项可能不存在。为了确保该项存在，调用 RegCreateKeyEx 函数。这样做的效果是创建该项（如果它不存在）或仅打开该项以便访问（如果它已经存在）。返回的 hKey 值是一个句柄，它指向下列函数调用中使用的注册表键。下列代码显示了执行这个操作的函数调用：

//  Initialize variables

lRC = RegCreateKeyEx(hRemoteKey, lpKeyName, 0, REG_NONE,

      REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hKey, &dwDisp) ;

当读取键时，只需要获得指向注册表键的句柄。使用 API 调用 RegOpenKeyEx 来获取必要的 hKey 注册表句柄，如下所示。

lRC = RegOpenKeyEx(hRemoteKey, lpKeyName, 0, KEY_ALL_ACCESS, &hKey);

注册表项可以是多种类型，包括字符串和数字。当读入项时，了解正在读取的项的类型很重要。这可以通过调用 RegQueryValueEx 获取的注册表键数据类型进行确定。dwKeyDataType 参数返回键的数据类型。下面显示了该函数。

// Got key, get value.  First, get the size of the key.

lRC = RegQueryValueEx(hKey, lpValueName, NULL, &dwKeyDataType, NULL, &dwKeySize);

我们可以使用 dwKeyDataType 值确定得到的是字符串值还是数字值，并查询该键以便正确返回该值，如下所示。

if(dwKeyDataType == REG_DWORD) //DWORD (Numeric value)

        {

        char cData[128] = {0} ;

        lRC = RegQueryValueEx(hKey, lpValueName, NULL, &dwKeyDataType, (LPBYTE)cData

     &dwKeySize);

        ltoa((LONG)cData[0], lpszKeyValue, 10) ;

        }

else

        // Now get the actual key value

        lRC = RegQueryValueEx(hKey, lpValueName, NULL, &dwKeyDataType, (LPBYTE)lpszKeyValue,

     &dwKeySize);

为了使 DLL 函数保持简单，RegDBGetKeyValueEx 函数只返回字符串值。因为注册表可以包含数值，所以所有返回的数值都被转换成字符串。使用调用应用程序自身的函数，很容易将该字符串转换回数字值。如上所示，ltoa 函数是用来将数值转换成字符串的。在任一函数的结束部分都必须关闭注册表。这是通过调用 RegCloseKey API 函数完成的。

DLL 的 Java 支持
Java 能够通过使用 JNI 接口调用 DLL 中的函数。要允许与 Java 一起使用 DLL，需要在类文件中设置用于 DLL 的 Java 可调用函数。首要任务是为每个函数创建一个 Java 类。用于 GetKey 函数的类如下：

// Class to read a registry key from a local or remote machine

public class GetKey{

       int RegKey ;                  //Key value, that is, HKEY_CLASSES_ROOT

       String MachineName ;          //Machine name we want to interrogate

       String KeyName ;              //Name of key we want to read

       String ValueName ;            //Value of key we want to read

       String KeyValue ;             //Return value from key


       public native String RegDBGetKeyValueEx(String MachineName, int RegKey,

          String KeyName, String ValueName) ;

       public static final int HKEY_CLASSES_ROOT = 0x80000000 ;

       public static final int HKEY_CURRENT_USER = 0x80000001 ;

       public static final int HKEY_LOCAL_MACHINE = 0x80000002 ;

       public static final int HKEY_USERS = 0x80000003 ;

       public static final int HKEY_CURRENT_CONFIG = 0x80000005 ;

       public static final int HKEY_DYN_DATA = 0x80000006 ;

       static

       {

         System.loadLibrary("RegConnect") ;

       }

}

如代码所示，值和函数都与 C 或 Visual Basic 所使用的值和函数非常相似。

一旦创建了类，就可以使用 JDK 函数 Javah 来为 DLL 创建一个能包含在 C 代码中的头文件。该头文件包含类函数的所有 C 实现代码。这和打开一个命令提示符、更改到驻留 Java 源文件的目录以及运行命令 javah GetKey 一样简单。这个操作将创建可以被包含到 C 代码中的 GetKey.h 文件。相同过程也适用于创建 SetKey.h 头文件。

最后，需要在 JNI 代码中封装 C 函数。从 Javah JDK 实用程序创建的头文件中复制函数原型：

// Java implementation of RegDBGetKeyValueEx

JNIEXPORT jobject JNICALL Java_GetKey_RegDBGetKeyValueEx(JNIEnv* env, jobject this_obj,

  jstring jMachineName, jint hRegKey, jstring jKeyName, jstring jValueName)

接下来，为调用 C 函数所需的每个字符串创建参数：

LPCTSTR lpMachineName ;

LPCTSTR lpKeyName ;

LPCTSTR lpValueName ;

char cKeyValue[255] ;

最后，为函数返回声明 Java 对象：

jobject ret ;

当进行 JNI 调用时，Java 向该函数传递一个对象。这个对象必需是非绑定的，并且获取了字符串。JNI 函数 GetStringUTFChars 执行这个任务。用下列代码用来获取字符串：

lpMachineName = (*env)->GetStringUTFChars(env, jMachineName, NULL) ;

lpKeyName = (*env)->GetStringUTFChars(env, jKeyName, NULL) ;

lpValueName = (*env)->GetStringUTFChars(env, jValueName, NULL) ;

现在，我们已准备好调用 C 函数了。下面显示了该调用，它带有从 Java 对象获取的参数：

RegDBGetKeyValueEx(lpMachineName, (HKEY)hRegKey, lpKeyName, lpValueName, cKeyValue) ;

我们现在已经完成了 Java 对象的使用，所以需要释放它们使用的字符串和内存。ReleaseStringUTFChars 函数执行这个任务，如下所示：

(*env)->ReleaseStringUTFChars(env, jMachineName, NULL) ;

(*env)->ReleaseStringUTFChars(env, jKeyName, NULL) ;

(*env)->ReleaseStringUTFChars(env, jValueName, NULL) ;

最后，我们需要将从注册表获取的字符串存放到正在返回的 Java 对象，然后将该对象返回到 Java 程序。JNI 函数 NewStringUTF 执行该任务，如下所示：

ret = (*env)->NewStringUTF(env, cKeyValue) ;

return ret ;

这就是所有步骤。如果您检查所提供的代码，就会发现 SetKey 函数几乎和 GetKey 函数相同。

示例代码
本文提供的代码（请参阅 参考资料）包含下列内容：

• RegConnect.DLL 源代码，Visual Studio 6 工程以及预构建的发行版 DLL
  
• Java 类和头文件以及用来试验函数的 Java 样本
  
• 封装了函数调用并演示函数的 Visual Basic 工程

结束语
本文说明了如何通过使用 DLL 执行 Windows API 函数调用来实现本地或远程注册表操作。它提供了从 Java 和 Visual Basic 环境使用 DLL 的样本。注册表操作可以成为任何程序的有用补充，因为它允许保存和检索运行时配置数据。

参考资料

• 您可以参阅本文在 developerWorks 全球站点上的 英文原文.
  
  
  
• 请阅读 Brian Venn 的文章 利用远程注册表访问（ developerWorks，2002 年 1 月）
  
  
  
• Core JAVA 1.1 Volume II：Advanced Features，第四版（Cay S. Horstmann 和 Gary Cornell 合著，1998 年 12 月，ISBN 0-13-092798-4）描述了如何使用 JNI 调用封装 DLL 以及如何从 Java 使用它们。
  
  
  
• Microsoft Windows System Information ― About the Registry
  
  
  
• Microsoft Developer Network Registry Functions提供了关于注册表访问 API 调用的信息
  
  
  
• zip 文件中有本文的 示例代码。 user1/1/upload/20059223858.zip
  

所有 ODBC 数据源名都存放在 Windows 注册表下的：HKEY_LOCAL_MACHINE\SOFTWARE\ODBC\ODBC.INI\ODBC Data Sources（系统 DSN）和 HKEY_CURRENT_USER\Software\ODBC\ODBC.INI\ODBC Data Sources（用户DSN）键值中。

前面讲过很多的用asp+实现网长追捕的程序，现在就在这里给大家提供这个完整应用的原程序，希望大家首先先看看
以前的文章，带者问题来看这个程序，其实是很简单的。同时我也给大家带来了这个程序的下载！
这个程序现在还是 有些 小问题，比如在 处理通过IP 地址查找 主机域名的时候，如果输入的不是合法的IP地址，则程序会
返回一个错误，大家 如果有兴趣，可以自己修改修改这个程序的：）
<%@ Import NameSpace="System.Net" %>
<% @Import Namespace="System.Net.Sockets" %>
<%@ Import Namespace="System.IO" %>
<script language="C#" runat=server>
String strRet;
protected void doClick(Object Src, EventArgs E){

if(dropdown1.SelectedItem.Value.ToInt16()==2){

IPHostEntry hostInfo = DNS.GetHostByName(txtSearch.Text);
strRet= hostInfo.AddressList[0].ToString() + "<br>"; //域名转换成IP地址
}
else{
IPHostEntry hostInfo = DNS.GetHostByAddr(txtSearch.Text);
strRet= hostInfo.Hostname + "<br>"; //IP地址转换成域名
}

if(CheckBox1.Checked){
String host=txtSearch.Text;

TCPClient tcpc = new TCPClient();
strRet=strRet + "SMTP Server:" + TcpConnect(tcpc,host,25) + "<br>"; //SMTP 端口

tcpc = new TCPClient();
strRet=strRet + "WWW Server:" + TcpConnect(tcpc,host,80) + "<br>"; //WWW 端口

tcpc = new TCPClient();
strRet=strRet + "FTP Server: " + TcpConnect(tcpc,host,21) + "<br>"; //FTP 端口

tcpc = new TCPClient();
strRet=strRet + "Pop3 Server:" + TcpConnect(tcpc,host,110) + "<br>"; //Pop 端口

tcpc = new TCPClient();
strRet=strRet + "代理 Server:" + TcpConnect(tcpc,host,1080) + "<br>"; //Socket5 端口 代理服务器使用的端口

tcpc = new TCPClient();
strRet=strRet + "DNS Server:" + TcpConnect(tcpc,host,53) + "<br>"; //DNS 端口
}
showmsg.Text=strRet;
}

String TcpConnect(TCPClient tcpc,String host,int port){
//这个函数的功能是 检查 指定的 host 的 port 是否在用？
String strRet="服务没有找到";
if(0 == tcpc.Connect(host,port)){
//联结服务器成功
strRet="正在运行";
}
return strRet;
}

</script>
<html>
<head>
<title>WEB追捕</title>
<SCRIPT LANGUAGE="JScript">
//这两个函数是功能是对 剪贴板 进行存取
function doufucopy() {
textRange = txtSearch.createTextRange();
textRange.execCommand("Copy");
}
function doufupaste() {
textRange = txtSearch.createTextRange();
textRange.execCommand("Paste");
}
-->
</SCRIPT>
</head>
<body>
<form id=testForm runat=server>
<asp:DropDownList id="dropdown1" runat="server">
<asp:ListItem ID=ListItem1 Value=1>查找域名</asp:ListItem>
<asp:ListItem ID=ListItem2 Value=2>查找IP</asp:ListItem>
</asp:DropDownList>
<asp:TextBox runat=server id=txtSearch />
<br>
<asp:CheckBox id="CheckBox1" runat="server" Text="检查对方的机器" />
<br>
<asp:Button runat=server id=do Text="查找" onClick=doClick />
</form>
<asp:Label id=showmsg runat=server />
<input type=button value="复制" onclick="doufucopy();">
<input type=button value="粘贴" onclick="doufucopy();">
</body>
</html>

whois.aspx

<% @Page Language="C#" %>
<% @Import Namespace="System.Net.Sockets" %>
<% @Import Namespace="System.Text" %>
<% @Import Namespace="System.IO" %>
<% @Import Namespace="System.Collections" %>
<script language="C#" runat="server">
void doQuery(Object sender, EventArgs e)
{
  String strDomain = txtDomain.Text;
  char[] chSplit = {'.'};
  string[] arrDomain = strDomain.Split(chSplit);
  // es darf genau ein domain name + ein suffix sein
  if (arrDomain.Length != 2)
  {
    return;
  }

  // das suffic darf nur 2 oder 3 zeichen lang sein
  int nLength = arrDomain[1].Length;
  if (nLength != 2 && nLength != 3)
  {
    return;
  }

  Hashtable table = new Hashtable();
  table.Add("at", "whois.nic.at");
  table.Add("de", "whois.denic.de");
  table.Add("be", "whois.dns.be");
  table.Add("gov", "whois.nic.gov");
  table.Add("mil", "whois.nic.mil");

  String strServer = "whois.OnlineNIC.com";
  if (table.ContainsKey(arrDomain[1]))
  {
    strServer = table[arrDomain[1]].ToString();
  }
  else if (nLength == 2)
  {
    // 2-letter TLD's always default to RIPE in Europe
    strServer = "whois.ripe.net";
  }
 
  String strResponse;
  bool bSuccess = DoWhoisLookup(strDomain, strServer, out strResponse);
  if (bSuccess)
  {
    txtResult.Text = strResponse;
  }
  else
  {
    txtResult.Text = "Lookup failed";
  }
}

bool DoWhoisLookup(String strDomain, String strServer, out String strResponse)
{
  strResponse = "none";
  bool bSuccess = false;

  TcpClient tcpc = new TcpClient();
  try
  {
    tcpc.Connect(strServer, 43);
  }
  catch(SocketException ex)
  {
    strResponse = "Could not connect to Whois server";
    return false;
  }

  strDomain += "\r\n";
  Byte[] arrDomain = Encoding.ASCII.GetBytes(strDomain.ToCharArray());
  try
  {
 Stream s = tcpc.GetStream();
 s.Write(arrDomain, 0, strDomain.Length);
 
 StreamReader sr = new StreamReader(tcpc.GetStream(), Encoding.ASCII);
 StringBuilder strBuilder = new StringBuilder();
 string strLine = null;

 while (null != (strLine = sr.ReadLine()))
 {
  strBuilder.Append(strLine+"<br>");
 }
 tcpc.Close();
  
 bSuccess = true;
 strResponse = strBuilder.ToString();
  }
  catch(Exception e)
  {
 strResponse = e.ToString();
  }
   
    return bSuccess;
}
</script>
<html>
<head>
<title></title>
</head>
<body>

<form runat="server">
域名whois查询(.NET版): <asp:TextBox id="txtDomain" value="/oblog4/3cts.com" runat="server" />
&nbsp;<asp:Button id="btnQuery" OnClick="doQuery" text="Query!" runat="server" />
<BR><HR width="100%"><BR>
<asp:label id="txtResult" runat="server" />
</form>

</body>
</html>

其实只要使用系统内置的存储过程sp_spaceused就可以得到表的相关信息

如：sp_spaceused 'tablename'

以下是为了方便写的一个存储过程，目的是把当前的所有表的相关信息全部都保存在一个指定的表里面

CREATE PROCEDURE get_tableinfo AS

if not exists (select * from dbo.sysobjects where id = object_id(N'[dbo].[tablespaceinfo]') and OBJECTPROPERTY(id, N'IsUserTable') = 1)
create table  tablespaceinfo                         --创建结果存储表
              (nameinfo varchar(50) , 
               rowsinfo int , reserved varchar(20) , 
               datainfo varchar(20)  , 
               index_size varchar(20) , 
               unused varchar(20) )


delete from tablespaceinfo --清空数据表

declare @tablename varchar(255)  --表名称

declare @cmdsql varchar(500)

DECLARE Info_cursor CURSOR FOR 
select o.name  
from dbo.sysobjects o where OBJECTPROPERTY(o.id, N'IsTable') = 1 
     and o.name not like N'#%%'  order by o.name

OPEN Info_cursor

FETCH NEXT FROM Info_cursor 
INTO @tablename 

WHILE @@FETCH_STATUS = 0
BEGIN

  if exists (select * from dbo.sysobjects where id = object_id(@tablename) and OBJECTPROPERTY(id, N'IsUserTable') = 1)
  execute sp_executesql 
         N'insert into tablespaceinfo  exec sp_spaceused @tbname',
          N'@tbname varchar(255)',
          @tbname = @tablename

  FETCH NEXT FROM Info_cursor 
  INTO @tablename 
END

CLOSE Info_cursor
DEALLOCATE Info_cursor
GO

执行存储过程
exec get_tableinfo

查询运行该存储过程后得到的结果
select *
from tablespaceinfo 
order by cast(left(ltrim(rtrim(reserved)) , len(ltrim(rtrim(reserved)))-2) as int) desc

作者Blog：http://blog.csdn.net/keenx/

HOW TO：使用 Osql 工具管理 SQL Server 桌面引擎 (MSDE 2000)

转自msdn

本页

	概要
		何为 Osql？
		如何使用 Osql？
			交互式输入 Transact-SQL 语句
			提交 Osql 作业
		连接到 SQL Server 桌面引擎 (MSDE 2000)
		管理 MSDE 2000
			新建登录帐户
			访问数据库
			如何更改登录密码
			创建数据库
			备份和还原数据库
			附加和分离数据库
	参考
	这篇文章中的信息适用于:

概要

“SQL Server 桌面引擎”（也叫 MSDE 2000）没有自己的用户界面，因为它主要设计为在后台运行。用户通过 MSDE 2000 嵌入的程序与它交互。随 MSDE 2000 提供的唯一工具是 osql 。可执行文件 Sql.exe 在 MSDE 2000 的默认实例的 MSSQL\Binn 文件夹中。本文重点讨论如何通过使用 osql 工具管理 MSDE 2000。

回到顶端

何为 Osql？

osql 工具是一个 Microsoft Windows 32 命令提示符工具，您可以使用它运行 Transact-SQL 语句和脚本文件。osql 工具使用 ODBC 数据库应用程序编程接口 (API) 与服务器通讯。

回到顶端

如何使用 Osql？

一般情况下，可以这样使用 osql 工具：

•	用户通过与使用命令提示符时相似的方式交互输入 Transact-SQL 语句。
•	用户提交 osql 作业，方法是： • 指定单个要运行的 Transact-SQL 语句。 - 或 - • 将该工具指向一个包含要运行的 Transact-SQL 语句的脚本文件。

交互式输入 Transact-SQL 语句

提交 Osql 作业

回到顶端

连接到 SQL Server 桌面引擎 (MSDE 2000)

   1>

						

回到顶端

管理 MSDE 2000

本文下面的部分将向您简单介绍管理 MSDE 2000 时最常用的 Transact-SQL 命令。

新建登录帐户

未提供有效登录 id 的用户无法连接到 SQL Server。可调用 sp_grantlogin 存储过程来授权一个 Microsoft Windows 网络帐户（一个组或者一个用户帐户），使之作为一个使用 Windows 身份验证连接到 SQL Server 实例的 SQL Server 登录帐户。下面的示例允许一个名为 Corporate\Test 的 Windows NT 用户连接到 SQL Server 实例：

EXEC sp_grantlogin 'Corporate\Test'

				

只有 sysadmin 或 securityadmin 固定服务器角色的成员可以运行 sp_grantlogin 存储过程。有关这些角色的更多信息，请参见“SQL Server 联机图书”中“Roles, SQL Server Architecture”主题。

有关 sp_grantlogin 存储过程的更多信息，请参见“SQL Server 联机图书”中的“sp_grantlogin, Transact-SQL Reference”主题。

您可以使用 sp_addlogin 存储过程创建一个使用 SQL Server 身份验证建立 SQL Server 连接的新登录帐户。下面的示例为一个名叫“test”的用户创建了一个密码为“hello”的 SQL Server 登录：

EXEC sp_addlogin 'test','hello'

				

只有 sysadmin 和 securityadmin 固定服务器角色的成员可以运行 sp_addlogin 存储过程。有关 sp_addlogin 存储过程的更多信息，请参见“SQL Server 联机图书”中的“sp_addlogin, Transact-SQL Reference”主题。

访问数据库

在用户连接到 SQL Server 的一个实例后，他们只有在 dbo 授予他们对数据库的访问权后才可以在数据库中执行活动。您可以使用 sp_grantdbaccess 存储过程为新用户向当前数据库中添加一个安全帐户。下面的示例为一个名叫 Corporate\BobJ 的 Microsoft Windows NT 的用户向当前数据库添加了一个帐户，并将其命名为“Bob”：

EXEC sp_grantdbaccess 'Corporate\BobJ', 'Bob'

				

sp_adduser 存储过程执行与 sp_grantdbaccess 存储过程相同的功能。因为包括 sp_adduser 存储过程是为了向后兼容，所以 Microsoft 建议您使用 sp_grantdbacess 存储过程。

只有 sysadmin 固定服务器角色、db_accessadmin 和 db_owner 固定数据库角色的成员才可以运行 sp_grantdbaccess 存储过程。有关 sp_grantdbaccess 存储过程的更多信息，请参见“SQL Server 联机图书”中的“sp_grantdbaccess, Transact-SQL Reference”主题。

如何更改登录密码

如要修改登录密码，请使用 sp_password 存储过程。下面的示例将“test”登录的密码从“ok”更改为“hello”：

EXEC sp_password 'ok', 'hello','test'

				

执行权限默认授予正在更改其自己的登录密码的用户的公共角色。只有 sysadmin 角色才可以为其他用户更改登录密码。有关 sp_password 存储过程的更多信息，请参见“SQL Server 联机图书中”的“sp_password, Transact-SQL Reference”主题。

创建数据库

MSDE 2000 数据库由一个表的集合组成，这些表中包含数据和其他对象，如视图、索引、存储过程和事件触发器，这些内容定义为支持对数据执行的各种活动。如要创建 MSDE 2000 数据库，请使用“CREATE DATABASE”Transact-SQL 命令。有关 创建数据库的更多信息，请参见“SQL Server 联机图书”中的“Creating a Database”主题。

下面的示例创建了一个名为 Test 的数据库。因为没有向该命令行添加其他参数，所以 Test 数据库将与 model 数据库大小相同：

CREATE DATABASE Test

				

CREATE DATABASE 权限默认授予 sysadmin 和 dbcreator 固定服务器角色的成员。有关“CREATE DATABASE”命令的更多信息，请参见“SQL Server 联机图书”中的“CREATE DATABASE, Transact-SQL Reference”主题。

如要创建一个新的数据库对象，请使用“CREATE Transact-SQL”命令。例如，要新建一个表，请使用“CREATE TABLE”Transact-SQL 命令。有关更多信息，请参考“SQL Server 联机图书”。

备份和还原数据库

SQL Server 的备份和还原组件为保护存储在 SQL Server 数据库中的关键数据提供了一个重要的保护措施。

通过适当的规划，您可以从许多故障中恢复，包括：

•	存储媒体故障。
•	用户错误。
•	服务器的永久丢失。

另外，备份和还原数据库还有其他方面的用途，例如将数据库从一个服务器复制到另一个服务器。通过从一台计算机上备份一个数据库和将此数据库还原到另一台计算机上，您可以快速方便地制作数据库的副本。

有关数据库备份和还原操作方面的更多信息，请参见“SQL Server 联机图书”中的“Backing Up and Restoring Databases”主题。

下面的示例为一个名为 mydb的数据库执行完全数据库备份，将此备份命名为 Mydb.bak，然后将此备份存储在 C:\Msde\Backup 文件夹中。

BACKUP DATABASE mydb TO DISK = 'C:\MSDE\Backup\mydb.bak'

				

下面的示例为一个名为 mydb 的数据库执行日志备份，将此备份命名为 Mydb_log.bak，然后将其存储在 C:\Msde\Backup 文件夹中：

BACKUP LOG mydb TO DISK = 'C:\MSDE\Backup\mydb_log.bak'

				

BACKUP DATABASE 和 BACKUP LOG 权限默认授予 sysadmin 固定服务器角色以及 db_owner 和 db_backupoperator 固定数据库角色的成员。有关 BACKUP 语句的更多信息，请参见“SQL Server 联机图书”中的“BACKUP, Transact-SQL Reference”主题。


MSDE 包括 SQL Server 代理程序服务用以管理安排的作业。例如，您可以创建并安排一个 Transact-SQL 备份作业。SQL Server 代理程序服务管理作业安排。如想查看演示如何在 MSDE 2000 中使用各种存储过程执行和安排备份的示例代码，请参见下面的 Microsoft 知识库文章：

241397 (http://support.microsoft.com/kb/241397/EN-US/) HOWTO:Back Up a Microsoft Data Engine Database with Transact-SQL

有关 SQL Server 代理程序服务的更多信息，请参见“SQL Server 联机图书”中的“SQL Server Agent Service”主题。

备份数据库只是全部过程的一半。知道如何从备份中还原数据库也非常重要。下面的示例将一个名为 mydb 的数据库从备份文件 C:\Msde\Backup\Mydb.bak 中还原：

RESTORE DATABASE mydb FROM DISK ='C:\MSDE\Backup\mydb.bak'

				

如果将要还原的数据库不存在，则用户必须具有 CREATE DATABASE 权限才可以运行 RESTORE 语句。如果该数据库存在，则 RESTORE 权限默认授予 sysadmin 和 dbcreator 固定服务器角色的成员，以及该数据库的所有者 (dbo)。有关 RESTORE 语句的更多信息，请参见“SQL Server 联机图书”中的“RESTORE, Transact-SQL Reference”主题。

附加和分离数据库

可以分离一个数据库的数据和事务日志文件然后将其重新附加到另一个服务器，或重新附加到同一服务器。分离一个数据库虽然从 SQL Server 中删除了该数据库，但构成该数据库的数据和事务日志文件没有任何改动。 然后您可以使用这些数据和事务日志文件将该数据库附加到任何 SQL Server 实例，其中包括从中分离该数据库的那一服务器。这使该数据库能够以与在被分离时完全相同的状态供在其他位置使用。有关更多信息，请参见 “SQL Server 联机图书”中的“Attaching and Detaching a Database”主题。

下面的示例将一个名为 mydb 的数据库从 SQL Server 的当前实例中分离出来：

EXEC sp_detach_db 'mydb'

				

只有 sysadmin 固定服务器角色的成员才可以运行 sp_detach_db 存储过程。有关 sp_detach_db 存储过程的更多信息，请参见“SQL Server 联机图书”中的“sp_detach_db, Transact-SQL Reference”主题。

下面的示例将来自名为 mydb 的数据库的两个文件附加到 SQL Server 的当前实例：

EXEC sp_attach_db @dbname = N'mydb',

   @filename1 = N'C:\MSDE\Backup\mydb.mdf',

   @filename2 = N'C:\MSDE\Backup\mydb.ldf'

				

大写字母“N”用来给“Unicode 字符串”常量添加前缀。“N”前缀代表 SQL-92 标准中的区域语言。有关详细信息，请参见 Microsoft 知识库中的以下文章：

239530 (http://support.microsoft.com/kb/239530/EN-US/) INF:Unicode String Constants in SQL Server Require N Prefix

只有 sysadmin 和 dbcreator 固定服务器角色的成员才可以运行此过程。有关 sp_attach_db 存储过程的更多信息，请参见“SQL Server 联机图书”中的“sp_attach_db, Transact-SQL Reference”主题。 下面关于 osql 工具使用方面的信息适用于所有版本的 Microsoft SQL Server 2000。

回到顶端

参考

如要下载“SQL Server 2000 联机图书”的更新版本，请访问下面的 Microsoft Web 站点：

http://www.microsoft.com/sql/techinfo/productdoc/2000/books.asp (http://support.microsoft.com/?scid=http%3a%2f%2fwww.microsoft.com%2fsql%2ftechinfo%2fproductdoc%2f2000%2fbooks.asp)

如要下载“SQL Server 联机图书”的 SQL Server 7.0 版，请访问下面的 Microsoft Web 站点：

http://download.microsoft.com/download/SQL70/File/2/Win98/En-US/SQLBOL.exe (http://download.microsoft.com/download/sql70/file/2/win98/en-us/sqlbol.exe)

有关 MSDE 2000 的更多信息，请参见下列 Microsoft 知识库文章：

319930 (http://support.microsoft.com/kb/319930/EN-US/) HOW TO：Connect to Microsoft Desktop Engine

241397 (http://support.microsoft.com/kb/241397/EN-US/) HOWTO:Back Up a Microsoft Desktop Engine Database with Transact-SQL

回到顶端

一、创建型模式

　　FACTORY？人才市场：以往是要哪个人才，就找哪个人才，效率低，现在有了人才市场，我们只需直接去人才市场挑一个好了；

　　BUILDER？生产流水线：以前是手工业作坊式的人工单个单个的生产零件然后一步一步组装做，好比有了工业革命，现在都由生产流水线代替了。如要造丰田汽车，先制定汽车的构造如由车胎、方向盘、发动机组成。再以此构造标准生产丰田汽车的车胎、方向盘、发动机。然后进行组装。最后得到丰田汽车；

　　PROTOTYPE？印刷术的发明：以前只能临贴才能保持和别人的字迹基本相同，直从印刷技术发明，从而保证了复制得和原物一模一样；

　　SINGLETON？唯一：以前是商标满天飞，相同的商标难免造成侵权，直从有商标保护法后，就保证了不会再产生第家企业使用相同的商标；


　　二、结构型模式

　　ADAPTER？集众人之私，成一己之公：武当派张三丰会太极拳，少林派智空大师会金刚般若掌，如果他们两个都成为我的师傅，我就既会太极拳，又会金刚般若掌了；

　　DECORATOR？青出于蓝而胜于蓝：武当派张三丰会太极拳，是我师傅，他教会了我太极拳，但我自己还会点蒙古式摔交，张三丰却不会。于是我就成了DECORATOR模式的实现；

　　BRIDGE？白马非马：马之颜色有黑白，马之性别有公母。我们说"这是马"太抽象，说"这是黑色的公马"又太死板，只有将颜色与性别和马动态组合，"这是（黑色的或白色的）（公或母）马"才显得灵活而飘逸，如此bridge模式精髓得矣。

　　COMPOSITE？大家族：子又生孙，孙又生子，子子孙孙，无穷尽也，将众多纷杂的人口组织成一个按辈分排列的大家族即是此模式的实现；

　　FACADE？求同存异：高中毕业需读初中和高中，博士也需读初中和高中，因此国家将初中和高中普及成九年制义务教育；

　　FLYWEIGHT？一劳永逸：认识三千汉字，可以应付日常读书与写字，可见头脑中存在这个汉字库的重要；

　　PROXY？垂帘听政：犹如清朝康熙年间的四大府臣，很多权利不在皇帝手里，必须通过辅佐大臣去办；

　　三、行为模式

　　CHAIN OF RESPONSIBLEITY？租房：以前为了找房到处打听，效率低且找不到好的房源。现在有了房屋中介，于是向房屋中介提出租房请求，中介提供一个合适的房源，满意则不再请求，不满意继续看房，直到满意为止；

　　COMMAND？借刀杀人：以前是想杀谁就杀，但一段时间后领悟到，长此以往必将结仇太多，于是假手他人，挑拨他人之间的关系从而达到自己的目的；

　　INTERPRETER？文言文注释：一段文言文，将它翻译成白话文；

　　ITERATOR？赶尽杀绝：一个一个的搜索，绝不放掉一个；

　　MEDIATOR？三角债：本来千头万绪的债务关系，忽出来一中介，包揽其一切，于是三角关系变成了独立的三方找第四方中介的关系；

　　MEMENTO？有福同享：我有多少，你就有多少；

　　OBSERVER？看守者：一旦被看守者有什么异常情况，定会及时做出反应；

　　STATE？进出自由：如一扇门，能进能出，如果有很多人随时进进出出必定显得杂乱而安全，如今设一保安限制其进出，如此各人进出才显得规范；

　　STRATEGY？久病成良医：如人生病可以有各种症状，但经过长期摸索，就可以总结出感冒、肺病、肝炎等几种；

　　TEMPLATE METHOD？理论不一定要实践：教练的学生会游泳就行了，至于教练会不会则无关紧要；

　　VISITOR？依法治罪：因张三杀人要被处死，李四偷窃要被罚款。由此势必制定处罚制度，故制定法律写明杀人、放火、偷窃等罪要受什么处罚，经通过后须变动要小。今后有人犯罪不管是谁，按共条例处罚即是，这就是访问者模式诞生的全过程。

对于一个刚刚接触 .net、c# 或者 oop 的人来说， events 和 delegates 的概念是比较复杂而难于理解的。而下面的这个例子我认为也许是说明 c#  Event Handling 最简单的例子之一（此话有点绝对）。

一个 Metronome(节拍器) class 创建 events，每3秒钟作一个 tick，然后有一个 Listener(收听者) class 来接收(或者说是收听)这个 Metronome(节拍器)发出的 ticks，每接收到一个 tick 就以 Console 的形式打印出 "HEARD IT"。

这是一个非常好的想法，能够使所谓的 新手(novice programmer)，迅速理解 events 的概念及使用。

下面这篇代码已经通过测试，可以直接粘贴到一个空的 c# project 中 ……

Download source - 3.97 Kb

Features

• Delegate invoke instance method with parameter.
  
• Delegate invoke static method with parameter.
  
• Delegate multi-casting: delegate invoking more than one methods at once.

Instructions

Just compile and run the sample. The code is documented and is self-explanatory.

Concept/background

Delegate are just simple mechanism to re-route calls to functions/methods that it references. The idea is simple. Invoking delegate invokes the methods/functions that the delegate references. The question is, why delegate? Why not just invoke the function/method directly?

• The association between delegate and methods referenced by delegate is established in runtime - so, you get flexibility here.
  
• Multi-cast: That's to associate a few methods/functions to ONE delegate. Invoking one delegate fires off ALL methods referenced by that one delegate all at once.

Code fragments

Here's your delegate

• Delegate - Note that delegate has the same signature to all functions/methods that it references.
  
• A delegate can reference more than one function/method - that's called multi-casting.

  public delegate int SomeDelegate(int nID, string sName);

Methods referenced by SomeDelegate can be found in WorkerClass

public class WorkerClass

{

  //(1) First method (instance method) referenced by delegate:

  public int InstanceMethod(int nID, string sName) {...}

  //(2) Second method (static method) referenced by delegate:

  static public int StaticMethod(int nID, string sName) {...}

};

The only difference between these two methods is that "InstanceMethod" is an instance method, that is, it must be invoked by an actual instance of WorkerClass. StaticMethod is a static member function - invoke it by: WorkerClass.StaticMethod(10,"aaa");

What the function does?

• It will multiply "nID" by LENGTH of "sName". For example, nID=10, sName="aaa" (Length=3). Therefore return value="/oblog4/10x3=30."
  
• It will write to console:

  "InstanceMethod invoked, return value=..." OR
  
  "StaticMethod invoked, return value=..."

Association between delegates and methods it references can be found in main(...)

//PART 1: invoking instance method            

WorkerClass wr = new WorkerClass();

SomeDelegate d1 = new SomeDelegate(wr.InstanceMethod); 

   //Associating delegate with wr.InstanceMethod


Console.WriteLine("Invoking delegate InstanceMethod, return={0}", 

   d1(5, "aaa") ); //Invoking wr.InstanceMethod with input parameters.

//PART 2: invoking static method

SomeDelegate d2 = new SomeDelegate(WorkerClass.StaticMethod); 

    //Associating delegate with WorkerClass.StaticMethod (NOTE: "wr" 

    //instance is NOT used. The class itself is used!!)

Console.WriteLine("Invoking delegate StaticMethod, return={0}", 

  d2(5, "aaa") ); //Invoking InstanceMethod with input parameters.

//PART 3: MultiCAST!

Console.WriteLine();

Console.WriteLine("Testing delegate multi-cast..");

SomeDelegate d3 = (SomeDelegate) Delegate.Combine(d1, d2);

Console.WriteLine("Invoking delegate(s) d1 AND d2 (multi-cast), return={0} ", 

  d3(5, "aaa") ); //Fire BOTH delegates (d1 AND d2) by firing d3!

Conclusion

That's it. It's simple right?

　　VB.NET中还是有很多有用的东西的。比如VB.NET可以直接调用Microsoft.VisualBasic命名空间下的各种有用的函数，特别是一些类型验证函数（IsDate，IsNumeric）就十分有用。就拿判断是否为数字来说，在网上我找到了在C#中用到的三种方法（但都有各自的不足之处）：
1、将字符串分解成Char，然后用Char.IsNumber(c)验证

public bool IsNumericChar(string str)
{
    if (str == null || str.Length==0) 
    {
        return false; 
    }
    foreach(char c in str) 
    { 
        if (!Char.IsNumber(c)) 
        { 
            return false; 
        } 
    } 
    return true; 
}

缺点：只能验证正整形数字，对浮点数，负数无效。

2、用正则表达式来判断是否为数字

public bool IsNumericRegex(string str)
{
    System.Text.RegularExpressions.Regex reg = new System.Text.RegularExpressions.Regex(@"^[-]?\d+[.]?\d*$");   
    return reg.IsMatch(str);  
}

缺点：数字类型的形式多样，像以科学计数法出现的是形式就不能判断，如：1.234568E+008。当然可以考虑修改正则表达式，但是终究不清楚还有何种形式我们没有考虑到。

3、用try...catch...将指定字符串转为数字，如果转换不成功则表示不是数字

public bool IsNumericTry(string str)
{
    try
    {
        // 先判断是否为整形
        Int32.Parse(str);
    }
    catch
    {
        // 在判断是否为浮点型
        try
        {
            Double.Parse(str);
        }
        catch
        {
            return false;
        }
    }
    return true;
}

缺点：功能倒是实现了，不过性能要大打折扣。（有人测试过，不过我没有测试）

　　我们为什么不用微软提供的Microsoft.VisualBasic.IsNumeric(obj)函数呢？在C#中不能直接调用Microsoft.VisualBasic命名空间下的函数，但是可以考虑建一个VB.NET项目，然后在C#中引用它。方法如下：
1、建一个VB.NET项目，并添加一个名为Validator的验证函数类。

Namespace VBUtilitiesNamespace VBUtilities
    Public Class ValidatorClass Validator
        Public Shared Function IsNumeric()Function IsNumeric(ByVal obj As Object) As Boolean
            Return Microsoft.VisualBasic.IsNumeric(obj)
        End Function
    End Class
End Namespace

2、在需要用到该函数的C#项目中引用该程序集。用Validator.IsNumeric(obj)的方法调用就可以了。

　　利用Microsoft.VisualBasic命名空间下的函数，我们还可以实现更多的验证功能，比如验证是否是日期类型（用IsDate）。这样要省掉不少麻烦去自己编写。还有别的方法吗？拿出来一起分享一些吧！

.Net框架由于拥有CLR提供的丰富库支持，只需很少的代码即可实现先前使用C等旧式语言很难实现的加密算法。本类实现一些常用机密算法，供参考。其中MD5算法返回Int的ToString字串。返回数字字母型结果的算法参见之前Blog文章。

using System;
using System.IO;
using System.Data;
using System.Text;
using System.Diagnostics;
using System.Security;
using System.Security.Cryptography;

namespace com.Quickline.Encrypt
{
 /// <summary>
 /// 类名：HashEncrypt
 /// 作用：对传入的字符串进行Hash运算，返回通过Hash算法加密过的字串。
 /// 属性：［无］
 /// 构造函数额参数：
 /// IsReturnNum:是否返回为加密后字符的Byte代码
 /// IsCaseSensitive：是否区分大小写。
 /// 方法：此类提供MD5，SHA1，SHA256，SHA512等四种算法，加密字串的长
度依次增大。
 /// </summary>
 public class HashEncrypt
 {
  //private string strIN;
  private bool isReturnNum;
  private bool isCaseSensitive;
  
  public HashEncrypt(bool IsCaseSensitive,bool IsReturnNum)
  {
   this.isReturnNum = IsReturnNum;
   this.isCaseSensitive = IsCaseSensitive;
  }
  
  
  private string getstrIN(string strIN)
  {
   //string strIN = strIN;
   if (strIN.Length == 0)
   {
    strIN = "~NULL~";
   }
   if (isCaseSensitive == false)
   {
    strIN = strIN.ToUpper();
   }
   return strIN;
  }
  public string MD5Encrypt(string strIN)
  {
   //string strIN = getstrIN(strIN);
   byte[] tmpByte;
   MD5 md5 = new MD5CryptoServiceProvider();
   tmpByte =
md5.ComputeHash(GetKeyByteArray(getstrIN(strIN)));
   md5.Clear();

   return GetStringValue(tmpByte);

  }
  
  public string SHA1Encrypt(string strIN)
  {
   //string strIN = getstrIN(strIN);
   byte[] tmpByte;
   SHA1 sha1 = new SHA1CryptoServiceProvider();

   tmpByte = sha1.ComputeHash(GetKeyByteArray(strIN));
   sha1.Clear();

   return GetStringValue(tmpByte);

  }

  public string SHA256Encrypt(string strIN)
  {
   //string strIN = getstrIN(strIN);
   byte[] tmpByte;
   SHA256 sha256 = new SHA256Managed();

   tmpByte =
sha256.ComputeHash(GetKeyByteArray(strIN));
   sha256.Clear();

   return GetStringValue(tmpByte);

  }

  public string SHA512Encrypt(string strIN)
  {
   //string strIN = getstrIN(strIN);
   byte[] tmpByte;
   SHA512 sha512 = new SHA512Managed();

   tmpByte =
sha512.ComputeHash(GetKeyByteArray(strIN));
   sha512.Clear();

   return GetStringValue(tmpByte);

  }
  
  /// <summary>
  /// 使用DES加密（Added by niehl 2005-4-6）
  /// </summary>
  /// <param name="originalValue">待加密的字符串</param>
  /// <param name="key">密钥(最大长度8)</param>
  /// <param name="IV">初始化向量(最大长度8)</param>
  /// <returns>加密后的字符串</returns>
  public string DESEncrypt(string originalValue,string key,string IV)
  {
   //将key和IV处理成8个字符
   key += "12345678";
   IV += "12345678";
   key = key.Substring(0,8);
   IV = IV.Substring(0,8);

   SymmetricAlgorithm sa;
   ICryptoTransform ct;
   MemoryStream ms;
   CryptoStream cs;
   byte[] byt;

   sa = new DESCryptoServiceProvider();
   sa.Key = Encoding.UTF8.GetBytes(key);
   sa.IV = Encoding.UTF8.GetBytes(IV);
   ct = sa.CreateEncryptor();

   byt = Encoding.UTF8.GetBytes(originalValue);

   ms = new MemoryStream();
   cs = new CryptoStream(ms, ct,
CryptoStreamMode.Write);
   cs.Write(byt, 0, byt.Length);
   cs.FlushFinalBlock();

   cs.Close();

   return Convert.ToBase64String(ms.ToArray());

  }

  public string DESEncrypt(string originalValue,string key)
  {
   return DESEncrypt(originalValue,key,key);
  }

  /// <summary>
  /// 使用DES解密（Added by niehl 2005-4-6）
  /// </summary>
  /// <param name="encryptedValue">待解密的字符串</param>
  /// <param name="key">密钥(最大长度8)</param>
  /// <param name="IV">m初始化向量(最大长度8)</param>
  /// <returns>解密后的字符串</returns>
  public string DESDecrypt(string encryptedValue,string key,string IV)
  {
   //将key和IV处理成8个字符
   key += "12345678";
   IV += "12345678";
   key = key.Substring(0,8);
   IV = IV.Substring(0,8);

   SymmetricAlgorithm sa;
   ICryptoTransform ct;
   MemoryStream ms;
   CryptoStream cs;
   byte[] byt;

   sa = new DESCryptoServiceProvider();
   sa.Key = Encoding.UTF8.GetBytes(key);
   sa.IV = Encoding.UTF8.GetBytes(IV);
   ct = sa.CreateDecryptor();

   byt = Convert.FromBase64String(encryptedValue);

   ms = new MemoryStream();
   cs = new CryptoStream(ms, ct,
CryptoStreamMode.Write);
   cs.Write(byt, 0, byt.Length);
   cs.FlushFinalBlock();

   cs.Close();

   return Encoding.UTF8.GetString(ms.ToArray());

  }

  public string DESDecrypt(string encryptedValue,string key)
  {
   return DESDecrypt(encryptedValue,key,key);
  }

  private string GetStringValue(byte[] Byte)
  {
   string tmpString = "";

   if (this.isReturnNum == false)
   {
    ASCIIEncoding Asc = new ASCIIEncoding();
    tmpString = Asc.GetString(Byte);
   }
   else
   {
    int iCounter;

    for
(iCounter=0;iCounter<Byte.Length;iCounter++)
    {
     tmpString = tmpString +
Byte[iCounter].ToString();
    }
    
   }
   
   return tmpString;
  }

  private byte[] GetKeyByteArray(string strKey)
  {

   ASCIIEncoding Asc = new ASCIIEncoding();
   
   int tmpStrLen = strKey.Length;
   byte[] tmpByte = new byte[tmpStrLen-1];

   tmpByte = Asc.GetBytes(strKey);

   return tmpByte;

  }

 }
}

我在自己最近的编程中注意到一个趋势，正是这个趋势才引出本月的专栏主题。最近，我在基于 Microsoft® .NET Framework 的应用程序中完成了大量的 Win32® Interop。我并不是要说我的应用程序充满了自定义的 interop 代码，但有时我会在 .NET Framework 类库中碰到一些次要但又繁絮、不充分的内容，通过调用该 Windows® API，可以快速减少这样的麻烦。

因此我认为，.NET Framework 1.0 或 1.1 版类库中存在任何 Windows 所没有的功能限制都不足为怪。毕竟，32 位的 Windows（不管何种版本）是一个成熟的操作系统，为广大客户服务了十多年。相比之下，.NET Framework 却是一个新事物。

随着越来越多的开发人员将生产应用程序转到托管代码，开发人员更频繁地研究底层操作系统以图找出一些关键功能显得很自然 — 至少目前是如此。

值得庆幸的是，公共语言运行库 (CLR) 的 interop 功能（称为平台调用 (P/Invoke)）非常完善。在本专栏中，我将重点介绍如何实际使用 P/Invoke 来调用 Windows API 函数。当指 CLR 的 COM Interop 功能时，P/Invoke 当作名词使用；当指该功能的使用时，则将其当作动词使用。我并不打算直接介绍 COM Interop，因为它比 P/Invoke 具有更好的可访问性，却更加复杂，这有点自相矛盾，这使得将 COM Interop 作为专栏主题来讨论不太简明扼要。

走进 P/Invoke

首先从考察一个简单的 P/Invoke 示例开始。让我们看一看如何调用 Win32 MessageBeep 函数，它的非托管声明如以下代码所示：

BOOL MessageBeep(

  UINT uType   // beep type

);

为了调用 MessageBeep，您需要在 C# 中将以下代码添加到一个类或结构定义中：

[DllImport("User32.dll")]

static extern Boolean MessageBeep(UInt32 beepType);

令人惊讶的是，只需要这段代码就可以使托管代码调用非托管的 MessageBeep API。它不是一个方法调用，而是一个外部方法定义。（另外，它接近于一个来自 C 而 C# 允许的直接端口，因此以它为起点来介绍一些概念是有帮助的。）来自托管代码的可能调用如下所示：

MessageBeep(0);

请注意，现在 MessageBeep 方法被声明为 static。这是 P/Invoke 方法所要求的，因为在该 Windows API 中没有一致的实例概念。接下来，还要注意该方法被标记为 extern。这是提示编译器该方法是通过一个从 DLL 导出的函数实现的，因此不需要提供方法体。

说到缺少方法体，您是否注意到 MessageBeep 声明并没有包含一个方法体？与大多数算法由中间语言 (IL) 指令组成的托管方法不同，P/Invoke 方法只是元数据，实时 (JIT) 编译器在运行时通过它将托管代码与非托管的 DLL 函数连接起来。执行这种到非托管世界的连接所需的一个重要信息就是导出非托管方法的 DLL 的名称。这一信息是由 MessageBeep 方法声明之前的 DllImport 自定义属性提供的。在本例中，可以看到，MessageBeep 非托管 API 是由 Windows 中的 User32.dll 导出的。

到现在为止，关于调用 MessageBeep 就剩两个话题没有介绍，请回顾一下，调用的代码与以下所示代码片段非常相似：

[DllImport("User32.dll")]

static extern Boolean MessageBeep(UInt32 beepType);

最后这两个话题是与数据封送处理 (data marshaling) 和从托管代码到非托管函数的实际方法调用有关的话题。调用非托管 MessageBeep 函数可以由找到作用域内的extern MessageBeep 声明的任何托管代码执行。该调用类似于任何其他对静态方法的调用。它与其他任何托管方法调用的共同之处在于带来了数据封送处理的需要。

C# 的规则之一是它的调用语法只能访问 CLR 数据类型，例如 System.UInt32 和 System.Boolean。C# 显然不识别 Windows API 中使用的基于 C 的数据类型（例如 UINT 和 BOOL），这些类型只是 C 语言类型的类型定义而已。所以当 Windows API 函数 MessageBeep 按以下方式编写时

BOOL MessageBeep( UINT uType )

外部方法就必须使用 CLR 类型来定义，如您在前面的代码片段中所看到的。需要使用与基础 API 函数类型不同但与之兼容的 CLR 类型是 P/Invoke 较难使用的一个方面。因此，在本专栏的后面我将用完整的章节来介绍数据封送处理。

样式

在 C# 中对 Windows API 进行 P/Invoke 调用是很简单的。但如果类库拒绝使您的应用程序发出嘟声，应该想方设法调用 Windows 使它进行这项工作，是吗？

是的。但是与选择的方法有关，而且关系甚大！通常，如果类库提供某种途径来实现您的意图，则最好使用 API 而不要直接调用非托管代码，因为 CLR 类型和 Win32 之间在样式上有很大的不同。我可以将关于这个问题的建议归结为一句话。当您进行 P/Invoke 时，不要使应用程序逻辑直接属于任何外部方法或其中的构件。如果您遵循这个小规则，从长远看经常会省去许多的麻烦。

图 1 中的代码显示了我所讨论的 MessageBeep 外部方法的最少附加代码。图 1 中并没有任何显著的变化，而只是对无包装的外部方法进行一些普通的改进，这可以使工作更加轻松一些。从顶部开始，您会注意到一个名为 Sound 的完整类型，它专用于 MessageBeep。如果我需要使用 Windows API 函数 PlaySound 来添加对播放波形的支持，则可以重用 Sound 类型。然而，我不会因公开单个公共静态方法的类型而生气。毕竟这只是应用程序代码而已。还应该注意到，Sound 是密封的，并定义了一个空的私有构造函数。这些只是一些细节，目的是使用户不会错误地从 Sound 派生类或者创建它的实例。

图 1 中的代码的下一个特征是，P/Invoke 出现位置的实际外部方法是 Sound 的私有方法。这个方法只是由公共 MessageBeep 方法间接公开，后者接受 BeepTypes 类型的参数。这个间接的额外层是一个很关键的细节，它提供了以下好处。首先，应该在类库中引入一个未来的 beep 托管方法，可以重复地通过公共 MessageBeep 方法来使用托管 API，而不必更改应用程序中的其余代码。

该包装方法的第二个好处是：当您进行 P/Invoke 调用时，您放弃了免受访问冲突和其他低级破坏的权利，这通常是由 CLR 提供的。缓冲方法可以保护您的应用程序的其余部分免受访问冲突及类似问题的影响（即使它不做任何事而只是传递参数）。该缓冲方法将由 P/Invoke 调用引入的任何潜在的错误本地化。

将私有外部方法隐藏在公共包装后面的第三同时也是最后的一个好处是，提供了向该方法添加一些最小的 CLR 样式的机会。例如，在图 1 中，我将 Windows API 函数返回的 Boolean 失败转换成更像 CLR 的异常。我还定义了一个名为 BeepTypes 的枚举类型，它的成员对应于同该 Windows API 一起使用的定义值。由于 C# 不支持定义，因此可以使用托管枚举类型来避免幻数向整个应用程序代码扩散。

包装方法的最后一个好处对于简单的 Windows API 函数（如 MessageBeep）诚然是微不足道的。但是当您开始调用更复杂的非托管函数时，您会发现，手动将 Windows API 样式转换成对 CLR 更加友好的方法所带来的好处会越来越多。越是打算在整个应用程序中重用 interop 功能，越是应该认真地考虑包装的设计。同时我认为，在非面向对象的静态包装方法中使用对 CLR 友好的参数也并非不可以。

DLL Import 属性

现在是更深入地进行探讨的时候了。在对托管代码进行 P/Invoke 调用时，DllImportAttribute 类型扮演着重要的角色。DllImportAttribute 的主要作用是给 CLR 指示哪个 DLL 导出您想要调用的函数。相关 DLL 的名称被作为一个构造函数参数传递给 DllImportAttribute。

如果您无法肯定哪个 DLL 定义了您要使用的 Windows API 函数，Platform SDK 文档将为您提供最好的帮助资源。在 Windows API 函数主题文字临近结尾的位置，SDK 文档指定了 C 应用程序要使用该函数必须链接的 .lib 文件。在几乎所有的情况下，该 .lib 文件具有与定义该函数的系统 DLL 文件相同的名称。例如，如果该函数需要 C 应用程序链接到 Kernel32.lib，则该函数就定义在 Kernel32.dll 中。您可以在 MessageBeep 中找到有关 MessageBeep 的 Platform SDK 文档主题。在该主题结尾处，您会注意到它指出库文件是 User32.lib；这表明 MessageBeep 是从 User32.dll 中导出的。

可选的 DllImportAttribute 属性

除了指出宿主 DLL 外，DllImportAttribute 还包含了一些可选属性，其中四个特别有趣：EntryPoint、CharSet、SetLastError 和 CallingConvention。

EntryPoint 在不希望外部托管方法具有与 DLL 导出相同的名称的情况下，可以设置该属性来指示导出的 DLL 函数的入口点名称。当您定义两个调用相同非托管函数的外部方法时，这特别有用。另外，在 Windows 中还可以通过它们的序号值绑定到导出的 DLL 函数。如果您需要这样做，则诸如“#1”或“#129”的 EntryPoint 值指示 DLL 中非托管函数的序号值而不是函数名。

CharSet 对于字符集，并非所有版本的 Windows 都是同样创建的。Windows 9x 系列产品缺少重要的 Unicode 支持，而 Windows NT 和 Windows CE 系列则一开始就使用 Unicode。在这些操作系统上运行的 CLR 将Unicode 用于 String 和 Char 数据的内部表示。但也不必担心 — 当调用 Windows 9x API 函数时，CLR 会自动进行必要的转换，将其从 Unicode转换为 ANSI。

如果 DLL 函数不以任何方式处理文本，则可以忽略 DllImportAttribute 的 CharSet 属性。然而，当 Char 或 String 数据是等式的一部分时，应该将 CharSet 属性设置为 CharSet.Auto。这样可以使 CLR 根据宿主 OS 使用适当的字符集。如果没有显式地设置 CharSet 属性，则其默认值为 CharSet.Ansi。这个默认值是有缺点的，因为对于在 Windows 2000、Windows XP 和 Windows NT® 上进行的 interop 调用，它会消极地影响文本参数封送处理的性能。

应该显式地选择 CharSet.Ansi 或 CharSet.Unicode 的 CharSet 值而不是使用 CharSet.Auto 的唯一情况是：您显式地指定了一个导出函数，而该函数特定于这两种 Win32 OS 中的某一种。ReadDirectoryChangesW API 函数就是这样的一个例子，它只存在于基于 Windows NT 的操作系统中，并且只支持 Unicode；在这种情况下，您应该显式地使用 CharSet.Unicode。

有时，Windows API 是否有字符集关系并不明显。一种决不会有错的确认方法是在 Platform SDK 中检查该函数的 C 语言头文件。（如果您无法肯定要看哪个头文件，则可以查看 Platform SDK 文档中列出的每个 API 函数的头文件。）如果您发现该 API 函数确实定义为一个映射到以 A 或 W 结尾的函数名的宏，则字符集与您尝试调用的函数有关系。Windows API 函数的一个例子是在 WinUser.h 中声明的 GetMessage API，您也许会惊讶地发现它有 A 和 W 两种版本。

SetLastError 错误处理非常重要，但在编程时经常被遗忘。当您进行 P/Invoke 调用时，也会面临其他的挑战 — 处理托管代码中 Windows API 错误处理和异常之间的区别。我可以给您一点建议。

如果您正在使用 P/Invoke 调用 Windows API 函数，而对于该函数，您使用 GetLastError 来查找扩展的错误信息，则应该在外部方法的 DllImportAttribute 中将 SetLastError 属性设置为 true。这适用于大多数外部方法。

这会导致 CLR 在每次调用外部方法之后缓存由 API 函数设置的错误。然后，在包装方法中，可以通过调用类库的 System.Runtime.InteropServices.Marshal 类型中定义的 Marshal.GetLastWin32Error 方法来获取缓存的错误值。我的建议是检查这些期望来自 API 函数的错误值，并为这些值引发一个可感知的异常。对于其他所有失败情况（包括根本就没意料到的失败情况），则引发在 System.ComponentModel 命名空间中定义的 Win32Exception，并将 Marshal.GetLastWin32Error 返回的值传递给它。如果您回头看一下图 1 中的代码，您会看到我在 extern MessageBeep 方法的公共包装中就采用了这种方法。

CallingConvention 我将在此介绍的最后也可能是最不重要的一个 DllImportAttribute 属性是 CallingConvention。通过此属性，可以给 CLR 指示应该将哪种函数调用约定用于堆栈中的参数。CallingConvention.Winapi 的默认值是最好的选择，它在大多数情况下都可行。然而，如果该调用不起作用，则可以检查 Platform SDK 中的声明头文件，看看您调用的 API 函数是否是一个不符合调用约定标准的异常 API。

通常，本机函数（例如 Windows API 函数或 C- 运行时 DLL 函数）的调用约定描述了如何将参数推入线程堆栈或从线程堆栈中清除。大多数 Windows API 函数都是首先将函数的最后一个参数推入堆栈，然后由被调用的函数负责清理该堆栈。相反，许多 C-运行时 DLL 函数都被定义为按照方法参数在方法签名中出现的顺序将其推入堆栈，将堆栈清理工作交给调用者。

幸运的是，要让 P/Invoke 调用工作只需要让外围设备理解调用约定即可。通常，从默认值 CallingConvention.Winapi 开始是最好的选择。然后，在 C 运行时 DLL 函数和少数函数中，可能需要将约定更改为 CallingConvention.Cdecl。

数据封送处理

数据封送处理是 P/Invoke 具有挑战性的方面。当在托管和非托管代码之间传递数据时，CLR 遵循许多规则，很少有开发人员会经常遇到它们直至可将这些规则记住。除非您是一名类库开发人员，否则在通常情况下没有必要掌握其细节。为了最有效地在 CLR 上使用 P/Invoke，即使只偶尔需要 interop 的应用程序开发人员仍然应该理解数据封送处理的一些基础知识。

在本月专栏的剩余部分中，我将讨论简单数字和字符串数据的数据封送处理。我将从最基本的数字数据封送处理开始，然后介绍简单的指针封送处理和字符串封送处理。

封送数字和逻辑标量

Windows OS 大部分是用 C 编写的。因此，Windows API 所用到的数据类型要么是 C 类型，要么是通过类型定义或宏定义重新标记的 C 类型。让我们看看没有指针的数据封送处理。简单起见，首先重点讨论的是数字和布尔值。

当通过值向 Windows API 函数传递参数时，需要知道以下问题的答案：

有时答案很明显，但有时却不明显。Windows API 以各种方式重新定义了基本的 C 数据类型。图 2 列出了 C 和 Win32 的一些公共数据类型及其规范，以及一个具有匹配规范的公共语言运行库类型。

通常，只要您选择一个其规范与该参数的 Win32 类型相匹配的 CLR 类型，您的代码就能够正常工作。不过也有一些特例。例如，在 Windows API 中定义的 BOOL 类型是一个有符号的 32 位整型。然而，BOOL 用于指示 Boolean 值 true 或 false。虽然您不用将 BOOL 参数作为 System.Int32 值封送，但是如果使用 System.Boolean 类型，就会获得更合适的映射。字符类型的映射类似于 BOOL，因为有一个特定的 CLR 类型 (System.Char) 指出字符的含义。

在了解这些信息之后，逐步介绍示例可能是有帮助的。依然采用 beep 主题作为例子，让我们来试一下 Kernel32.dll 低级 Beep，它会通过计算机的扬声器发生嘟声。这个方法的 Platform SDK 文档可以在 Beep 中找到。本机 API 按以下方式进行记录：

BOOL Beep(

  DWORD dwFreq,      // Frequency

  DWORD dwDuration   // Duration in milliseconds

);

在参数封送处理方面，您的工作是了解什么 CLR 数据类型与 Beep API 函数所使用的 DWORD 和 BOOL 数据类型相兼容。回顾一下图 2 中的图表，您将看到 DWORD 是一个 32 位的无符号整数值，如同 CLR 类型 System.UInt32。这意味着您可以使用 UInt32 值作为送往 Beep 的两个参数。BOOL 返回值是一个非常有趣的情况，因为该图表告诉我们，在 Win32 中，BOOL 是一个 32 位的有符号整数。因此，您可以使用 System.Int32 值作为来自 Beep 的返回值。然而，CLR 也定义了 System.Boolean 类型作为 Boolean 值的语义，所以应该使用它来替代。CLR 默认将 System.Boolean 值封送为 32 位的有符号整数。此处所显示的外部方法定义是用于 Beep 的结果 P/Invoke 方法：

[DllImport("Kernel32.dll", SetLastError=true)]

static extern Boolean Beep(

   UInt32 frequency, UInt32 duration);

指针参数

许多 Windows API 函数将指针作为它们的一个或多个参数。指针增加了封送数据的复杂性，因为它们增加了一个间接层。如果没有指针，您可以通过值在线程堆栈中传递数据。有了指针，则可以通过引用传递数据，方法是将该数据的内存地址推入线程堆栈中。然后，函数通过内存地址间接访问数据。使用托管代码表示此附加间接层的方式有多种。

在 C# 中，如果将方法参数定义为 ref 或 out，则数据通过引用而不是通过值传递。即使您没有使用 Interop 也是这样，但只是从一个托管方法调用到另一个托管方法。例如，如果通过 ref 传递 System.Int32 参数，则在线程堆栈中传递的是该数据的地址，而不是整数值本身。下面是一个定义为通过引用接收整数值的方法的示例：

void FlipInt32(ref Int32 num){

   num = -num;

}

这里，FlipInt32 方法获取一个 Int32 值的地址、访问数据、对它求反，然后将求反过的值赋给原始变量。在以下代码中，FlipInt32 方法会将调用程序的变量 x 的值从 10 更改为 -10：

Int32 x = 10;

FlipInt32(ref x);

在托管代码中可以重用这种能力，将指针传递给非托管代码。例如，FileEncryptionStatus API 函数以 32 位无符号位掩码的形式返回文件加密状态。该 API 按以下所示方式进行记录：

BOOL FileEncryptionStatus(

  LPCTSTR lpFileName,  // file name

  LPDWORD lpStatus     // encryption status

);

请注意，该函数并不使用它的返回值返回状态，而是返回一个 Boolean 值，指示调用是否成功。在成功的情况下，实际的状态值是通过第二个参数返回的。它的工作方式是调用程序向该函数传递指向一个 DWORD 变量的指针，而该 API 函数用状态值填充指向的内存位置。以下代码片段显示了一个调用非托管 FileEncryptionStatus 函数的可能外部方法定义：

[DllImport("Advapi32.dll", CharSet=CharSet.Auto)]

static extern Boolean FileEncryptionStatus(String filename, 

   out UInt32 status);

该定义使用 out 关键字来为 UInt32 状态值指示 by-ref 参数。这里我也可以选择 ref 关键字，实际上在运行时会产生相同的机器码。out 关键字只是一个 by-ref 参数的规范，它向 C# 编译器指示所传递的数据只在被调用的函数外部传递。相反，如果使用 ref 关键字，则编译器会假定数据可以在被调用的函数的内部和外部传递。

托管代码中 out 和 ref 参数的另一个很好的方面是，地址作为 by-ref 参数传递的变量可以是线程堆栈中的一个本地变量、一个类或结构的元素，也可以是具有合适数据类型的数组中的一个元素引用。调用程序的这种灵活性使得 by-ref 参数成为封送缓冲区指针以及单数值指针的一个很好的起点。只有在我发现 ref 或 out 参数不符合我的需要的情况下，我才会考虑将指针封送为更复杂的 CLR 类型（例如类或数组对象）。

如果您不熟悉 C 语法或者调用 Windows API 函数，有时很难知道一个方法参数是否需要指针。一个常见的指示符是看参数类型是否是以字母 P 或 LP 开头的，例如 LPDWORD 或 PINT。在这两个例子中，LP 和 P 指示参数是一个指针，而它们指向的数据类型分别为 DWORD 或 INT。然而，在有些情况下，可以直接使用 C 语言语法中的星号 (*) 将 API 函数定义为指针。以下代码片段展示了这方面的示例：

void TakesAPointer(DWORD* pNum);

可以看到，上述函数的唯一一个参数是指向 DWORD 变量的指针。

当通过 P/Invoke 封送指针时，ref 和 out 只用于托管代码中的值类型。当一个参数的 CLR 类型使用 struct 关键字定义时，可以认为该参数是一个值类型。Out 和 ref 用于封送指向这些数据类型的指针，因为通常值类型变量是对象或数据，而在托管代码中并没有对值类型的引用。相反，当封送引用类型对象时，并不需要 ref 和 out 关键字，因为变量已经是对象的引用了。

如果您对引用类型和值类型之间的差别不是很熟悉，请查阅 2000 年 12 月 发行的 MSDN® Magazine，在 .NET 专栏的主题中可以找到更多信息。大多数 CLR 类型都是引用类型；然而，除了 System.String 和 System.Object，所有的基元类型（例如 System.Int32 和 System.Boolean）都是值类型。

封送不透明 (Opaque) 指针：一种特殊情况

有时在 Windows API 中，方法传递或返回的指针是不透明的，这意味着该指针值从技术角度讲是一个指针，但代码却不直接使用它。相反，代码将该指针返回给 Windows 以便随后进行重用。

一个非常常见的例子就是句柄的概念。在 Windows 中，内部数据结构（从文件到屏幕上的按钮）在应用程序代码中都表示为句柄。句柄其实就是不透明的指针或有着指针宽度的数值，应用程序用它来表示内部的 OS 构造。

少数情况下，API 函数也将不透明指针定义为 PVOID 或 LPVOID 类型。在 Windows API 的定义中，这些类型意思就是说该指针没有类型。

当一个不透明指针返回给您的应用程序（或者您的应用程序期望得到一个不透明指针）时，您应该将参数或返回值封送为 CLR 中的一种特殊类型 — System.IntPtr。当您使用 IntPtr 类型时，通常不使用 out 或 ref 参数，因为 IntPtr 意为直接持有指针。不过，如果您将一个指针封送为一个指针，则对 IntPtr 使用 by-ref 参数是合适的。

在 CLR 类型系统中，System.IntPtr 类型有一个特殊的属性。不像系统中的其他基类型，IntPtr 并没有固定的大小。相反，它在运行时的大小是依底层操作系统的正常指针大小而定的。这意味着在 32 位的 Windows 中，IntPtr 变量的宽度是 32 位的，而在 64 位的 Windows 中，实时编译器编译的代码会将 IntPtr 值看作 64 位的值。当在托管代码和非托管代码之间封送不透明指针时，这种自动调节大小的特点十分有用。

请记住，任何返回或接受句柄的 API 函数其实操作的就是不透明指针。您的代码应该将 Windows 中的句柄封送成 System.IntPtr 值。

您可以在托管代码中将 IntPtr 值强制转换为 32 位或 64 位的整数值，或将后者强制转换为前者。然而，当使用 Windows API 函数时，因为指针应是不透明的，所以除了存储和传递给外部方法外，不能将它们另做它用。这种“只限存储和传递”规则的两个特例是当您需要向外部方法传递 null 指针值和需要比较 IntPtr 值与 null 值的情况。为了做到这一点，您不能将零强制转换为 System.IntPtr，而应该在 IntPtr 类型上使用 Int32.Zero 静态公共字段，以便获得用于比较或赋值的 null 值。

封送文本

在编程时经常要对文本数据进行处理。文本为 interop 制造了一些麻烦，这有两个原因。首先，底层操作系统可能使用 Unicode 来表示字符串，也可能使用 ANSI。在极少数情况下，例如 MultiByteToWideChar API 函数的两个参数在字符集上是不一致的。

第二个原因是，当需要进行 P/Invoke 时，要处理文本还需要特别了解到 C 和 CLR 处理文本的方式是不同的。在 C 中，字符串实际上只是一个字符值数组，通常以 null 作为结束符。大多数 Windows API 函数是按照以下条件处理字符串的：对于 ANSI，将其作为字符值数组；对于 Unicode，将其作为宽字符值数组。

幸运的是，CLR 被设计得相当灵活，当封送文本时问题得以轻松解决，而不用在意 Windows API 函数期望从您的应用程序得到的是什么。这里是一些需要记住的主要考虑事项：

我们首先解答最后一个问题。大多数 Windows API 函数都带有 LPTSTR 或 LPCTSTR 值。（从函数角度看）它们分别是可修改和不可修改的缓冲区，包含以 null 结束的字符数组。“C”代表常数，意味着使用该参数信息不会传递到函数外部。LPTSTR 中的“T”表明该参数可以是 Unicode 或 ANSI，取决于您选择的字符集和底层操作系统的字符集。因为在 Windows API 中大多数字符串参数都是这两种类型之一，所以只要在 DllImportAttribute 中选择 CharSet.Auto，CLR 就按默认的方式工作。

然而，有些 API 函数或自定义的 DLL 函数采用不同的方式表示字符串。如果您要用到一个这样的函数，就可以采用 MarshalAsAttribute 修饰外部方法的字符串参数，并指明一种不同于默认 LPTSTR 的字符串格式。有关 MarshalAsAttribute 的更多信息，请参阅位于 MarshalAsAttribute Class 的 Platform SDK 文档主题。

现在让我们看一下字符串信息在您的代码和非托管函数之间传递的方向。有两种方式可以知道处理字符串时信息的传递方向。第一个也是最可靠的一个方法就是首先理解参数的用途。例如，您正调用一个参数，它的名称类似 CreateMutex 并带有一个字符串，则可以想像该字符串信息是从应用程序向 API 函数传递的。同时，如果您调用 GetUserName，则该函数的名称表明字符串信息是从该函数向您的应用程序传递的。

除了这种比较合理的方法外，第二种查找信息传递方向的方式就是查找 API 参数类型中的字母“C”。例如，GetUserName API 函数的第一个参数被定义为 LPTSTR 类型，它代表一个指向 Unicode 或 ANSI 字符串缓冲区的长指针。但是 CreateMutex 的名称参数被类型化为 LTCTSTR。请注意，这里的类型定义是一样的，但增加一个字母“C”来表明缓冲区为常数，API 函数不能写入。

一旦明确了文本参数是只用作输入还是用作输入/输出，就可以确定使用哪种 CLR 类型作为参数类型。这里有一些规则。如果字符串参数只用作输入，则使用 System.String 类型。在托管代码中，字符串是不变的，适合用于不会被本机 API 函数更改的缓冲区。

如果字符串参数可以用作输入和/或输出，则使用 System.StringBuilder 类型。StringBuilder 类型是一个很有用的类库类型，它可以帮助您有效地构建字符串，也正好可以将缓冲区传递给本机函数，由本机函数为您填充字符串数据。一旦函数调用返回，您只需要调用 StringBuilder 对象的 ToString 就可以得到一个 String 对象。

GetShortPathName API 函数能很好地用于显示什么时候使用 String、什么时候使用 StringBuilder，因为它只带有三个参数：一个输入字符串、一个输出字符串和一个指明输出缓冲区的字符长度的参数。

图 3 所示为加注释的非托管 GetShortPathName 函数文档，它同时指出了输入和输出字符串参数。它引出了托管的外部方法定义，也如图 3 所示。请注意第一个参数被封送为 System.String，因为它是一个只用作输入的参数。第二个参数代表一个输出缓冲区，它使用了 System.StringBuilder。

小结

本月专栏所介绍的 P/Invoke 功能足够调用 Windows 中的许多 API 函数。然而，如果您大量用到 interop，则会最终发现自己封送了很复杂的数据结构，甚至可能需要在托管代码中通过指针直接访问内存。实际上，本机代码中的 interop 可以是一个将细节和低级比特藏在里面的真正的潘多拉盒子。CLR、C# 和托管 C++ 提供了许多有用的功能；也许以后我会在本专栏介绍高级的 P/Invoke 话题。

同时，只要您觉得 .NET Framework 类库无法播放您的声音或者为您执行其他一些功能，您可以知道如何向原始而优秀的 Windows API 寻求一些帮助。

Figure 1 MessageBeep, Interop Done Well

namespace Wintellect.Interop.Sound{

   using System;

   using System.Runtime.InteropServices;

   using System.ComponentModel;


   sealed class Sound{

      public static void MessageBeep(BeepTypes type){

         if(!MessageBeep((UInt32) type)){

            Int32 err = Marshal.GetLastWin32Error();

            throw new Win32Exception(err);

         }

      }

      [DllImport("User32.dll", SetLastError=true)]

      static extern Boolean MessageBeep(UInt32 beepType);

      private Sound(){}

   }

   enum BeepTypes{ 

      Simple = -1,

      Ok                = 0x00000000,

      IconHand          = 0x00000010,

      IconQuestion      = 0x00000020,

      IconExclamation   = 0x00000030,

      IconAsterisk      = 0x00000040

   }

}

Figure 2 Non-Pointer Data Types

Win32 Types
Specification
CLR Type
char, INT8, SBYTE, CHAR†
8-bit signed integer
System.SByte
short, short int, INT16, SHORT
16-bit signed integer
System.Int16
int, long, long int, INT32, LONG32, BOOL†, INT 
32-bit signed integer
System.Int32
__int64, INT64, LONGLONG
64-bit signed integer
System.Int64
unsigned char, UINT8, UCHAR†, BYTE
8-bit unsigned integer
System.Byte
unsigned short, UINT16, USHORT, WORD, ATOM, WCHAR†, __wchar_t
16-bit unsigned integer
System.UInt16
unsigned, unsigned int, UINT32, ULONG32, DWORD32, ULONG, DWORD, UINT
32-bit unsigned integer
System.UInt32
unsigned __int64, UINT64, DWORDLONG, ULONGLONG
64-bit unsigned integer
System.UInt64
float, FLOAT
Single-precision floating point
System.Single
double, long double, DOUBLE
Double-precision floating point
System.Double
†In Win32 this type is an integer with a specially assigned meaning; in contrast, the CLR provides a specific type devoted to this meaning.

Figure 3 GetShortPathName Declarations

// ** Documentation for Win32 GetShortPathName() API Function

// DWORD GetShortPathName(

//   LPCTSTR lpszLongPath,      // file for which to get short path 

//   LPTSTR lpszShortPath,      // short path name (output)

//   DWORD cchBuffer            // size of output buffer

// );


[DllImport("Kernel32", CharSet = CharSet.Auto)]

static extern Int32 GetShortPathName(

   String path,                // input string

   StringBuilder shortPath,    // output string

   Int32 shortPathLength);     // StringBuilder.Capacity

sysaltfiles             主数据库 保存数据库的文件
syscharsets         主数据库 字符集与排序顺序
sysconfigures      主数据库 配置选项
syscurconfigs      主数据库 当前配置选项
sysdatabases     主数据库 服务器中的数据库
syslanguages     主数据库 语言
syslogins             主数据库 登陆帐号信息
sysoledbusers    主数据库 链接服务器登陆信息
sysprocesses     主数据库 进程
sysremotelogins主数据库 远程登录帐号
syscolumns        每个数据库 列
sysconstrains     每个数据库 限制
sysfilegroups      每个数据库 文件组
sysfiles                每个数据库 文件
sysforeignkeys   每个数据库 外部关键字
sysindexs             每个数据库 索引
sysmenbers        每个数据库 角色成员
sysobjects           每个数据库 所有数据库对象
syspermissions 每个数据库 权限
systypes               每个数据库 用户定义数据类型
sysusers              每个数据库 用户

1、用BACKUP LOG database WITH NO_LOG清除日志
把数据库属性中的故障还原模型改为“简单”可以大大减慢日志

增长的速度。
   如果把还原模型调到简单，这样就不支持时间点还原了，但

是日志文件会很小，如果数据比较重要
推荐还是把数据库的还原模型调为完全

用BACKUP LOG database WITH NO_LOG命名后，会截断不活动日

志，不减小物理日志文件的大小，
但逻辑日志会减小，收缩数据库后会把不活动虚拟日志删除来释

放空间，不会损坏数据。

如果日志被截断并收缩数据库后，就不能直接用最近的一个全库

备份做时间点还原，建议立即备份
数据库，以防万一。

2、sql server运行中，是否能删除主数据库事务日志文件
步骤如下：(1)、分离数据库
企业管理器－－数据库－－右击你要删除日志的数据库－－所有

任务－－分离数据库
(2)、然后删除日志文件
(3)、然后再附加数据库
企业管理器－－数据库－－右击数据库－－所有任务－－附加数

据库
这时候只附加。mdf就可以了。

3、压缩SQL数据库及日志的详细方法

SQL Server 2000基础教程——压缩数据库
数据库在使用一段时间后，时常会出现因数据删除而造成数据库

中空闲空间太多的情况，这时就需要减少分配给数据库文件和事

务日志文件的磁盘空间，以免浪费磁盘空间。当数据库中没有数

据时，可以修改数据库文件属性直接改变其占用空间，但当数据

库中有数据时，这样做会破坏数据库中的数据，因此需要使用压

缩的方式来缩减数据库空间。可以在数据库属性选项中选择“

Auto shrink”选项，让系统自动压缩数据库，也可以用人工的

方法来压缩。人工压缩数据库有以下两种方式：
1、用Enterprise Manager 压缩数据库
在Enterprise Manager 中在所要压缩的数据库上单击右键，从

快捷菜单中的“所有任务（All Tasks）”中选择“Shrink

Database（压缩数据库）”选项，就会出现如图6-10 所示的对

话框。可以在图6-10 所示的对话框中选择数据库的压缩方式，

也可以选择使用压缩计划或压缩单个文件
 
单击图6-10 中的“Files”按钮，会出现如图6-11 所示的压缩

数据库文件对话框，可以针对每个数据库文件进行不同的压缩设

置。
 
单击图6-10 中的“Change” 按钮，会出现如图6-12 所示的压

缩计划编辑对话框，可以指定压缩计划的执行方式。单击图6-12

中的“Change” 按钮，会出现如图6-13 所示的循环工作计划编

辑对话框，可以编辑计划执行的周期或时间点。设置完成后单击

“OK” 按钮就开始压缩数据库，在压缩结束后会显示一个压缩

情况信息框。
 
 
2、用Transact-SQL 命令压缩数据库
可以使用DBCC SHRINKDATABASE 和DBCC SHRINKFILE 命令来压缩

数据库。其中DBCC SHRINKDATABASE 命令对数据库进行压缩，

DBCC SHRINKFILE 命令对数据库中指定的文件进行压缩。
（1） DBCC SHRINKDATABASE
DBCC SHRINKDATABASE 命令语法如下：
DBCC SHRINKDATABASE (database_name [, target_percent]
[, {NOTRUNCATE | TRUNCATEONLY}] )
各参数说明如下：
·target_percent 指定将数据库压缩后，未使用的空间占数据

库大小的百分之几。如果指定的百分比过大，超过了压缩前未使

用空间所占的比例，则数据库不会被压缩。并且压缩后的数据库

不能比数据库初始设定的容量小。
·NOTRUECATE
将数据库缩减后剩余的空间保留在数据库，中不返还给操作系统

。如果不选择此选项，则剩余的空间返还给操作系统。
·TRUNCATEONLY
将数据库缩减后剩余的空间返还给操作系统。使用此命令时SQL

Server 将文件缩减到最后一个文件分配，区域但不移动任何数

据文件。选择此项后，target_percent 选项就无效了。
例6-14： 压缩数据库mytest 的未使用空间为数据库大小的20%

。
dbcc shrinkdatabase (mytest, 20)
运行结果如下：
DBCC execution completed. If DBCC printed error

messages, contact your system administrator.
(2) DBCC SHRINKFILE
DBCC SHRINKFILE 命令压缩当前数据库中的文件。其语法如下：
DBCC SHRINKFILE ( {file_name | file_id }
{ [, target_size] |
[, {EMPTYFILE | NOTRUNCATE | TRUNCATEONLY}] } )
各参数说明如下：
·file_id
指定要压缩的文件的鉴别号（Identification number， 即ID）

。文件的ID 号可以通过 FILE_ID（）函数或如本章前面所讲述

的Sp_helpdb 系统存储过程来得到。
·target_size
指定文件压缩后的大小。以MB 为单位。如果不指定此选项，SQL

Server 就会尽最大可能地缩减文件。
·EMPTYFILE
指明此文件不再使用，将移动所有在此文件中的数据到同一文件

组中的其它文件中去。执行带此参数的命令后，此文件就可以用

ALTER DATABASE 命令来删除了。
其余参数NOTRUNCATE 和TRUNCATEONLY 与DBCC SHRINKDATABASE

命令中的含义相同。
例6-15: 压缩数据库mydb 中的数据库文件mydb_data2 的大小到

1MB。 use mydb dbcc shrinkfile (mydb_data2, 1)
 

企业管理器里面的方法：
1、打开企业管理器
2、打开要处理的数据库
3、点击最上面菜单>工具>SQL查询分析器，打开SQL查询分析器
4、在输入窗口里面输入:

Code:
DUMP TRANSACTION [数据库名] WITH  NO_LOG
BACKUP LOG [数据库名] WITH NO_LOG
DBCC SHRINKDATABASE([数据库名])

点击绿色的小三角（或按F5）执行查询，等状态栏提示处理完成

即可！

程序里面的方法：
压缩数据库日志
--1.清空日志
exec('DUMP TRANSACTION ['+@dbname+'] WITH  NO_LOG')
--2.截断事务日志：
exec('BACKUP LOG ['+@dbname+'] WITH NO_LOG')
--3.收缩数据库文件(如果不压缩,数据库的文件不会减小
exec('DBCC SHRINKDATABASE(['+@dbname+'])')

4、减小日志的方法：

一、用如下步做了：
1、DUMP　TRANSACTION　庫名　WITH　no_log
2、dbcc shrinkfile(logfilename)
3、收縮數據庫
4、設定自動收縮。

二、
分离数据库,删除日志文件,再附加,OK!
右击数据库－－所有任务－－分离or 附加

三、

1、backup log　庫名　WITH　no_log
2、dbcc shrinkfile(logfilename)
3、收縮數據庫
4、設定自動收縮。

身份证18位验证

     18位身份证标准在国家质量技术监督局于1999年7月1日实施的GB11643-1999《公民身份号码》中做了明确的规定。 GB11643-1999《公民身份号码》为GB11643-1989《社会保障号码》的修订版，其中指出将原标准名称"社会保障号码"更名为"公民身份号码"，另外GB11643-1999《公民身份号码》从实施之日起代替GB11643-1989。GB11643-1999《公民身份号码》主要内容如下：
一、范围
该标准规定了公民身份号码的编码对象、号码的结构和表现形式，使每个编码对象获得一个唯一的、不变的法定号码。
二、编码对象
公民身份号码的编码对象是具有中华人民共和国国籍的公民。
三、号码的结构和表示形式
1、号码的结构
公民身份号码是特征组合码，由十七位数字本体码和一位校验码组成。排列顺序从左至右依次为：六位数字地址码，八位数字出生日期码，三位数字顺序码和一位数字校验码。
2、地址码
表示编码对象常住户口所在县(市、旗、区)的行政区划代码，按GB/T2260的规定执行。
3、出生日期码
表示编码对象出生的年、月、日，按GB/T7408的规定执行，年、月、日代码之间不用分隔符。
4、顺序码
表示在同一地址码所标识的区域范围内，对同年、同月、同日出生的人编定的顺序号，顺序码的奇数分配给男性，偶数分配给女性。
5、校验码
（1）十七位数字本体码加权求和公式
S = Sum(Ai * Wi), i = 0, ... , 16 ，先对前17位数字的权求和
Ai:表示第i位置上的身份证号码数字值
Wi:表示第i位置上的加权因子
Wi: 7 9 10 5 8 4 2 1 6 3 7 9 10 5 8 4 2

（2）计算模
Y = mod(S, 11)

（3）通过模得到对应的校验码
Y:         0 1 2 3 4 5 6 7 8 9 10
校验码: 1 0 X 9 8 7 6 5 4 3 2
四、举例如下：
北京市朝阳区: 11010519491231002X
广东省汕头市: 440524188001010014

15位升18的方法

根据〖中华人民共和国国家标准 GB 11643-1999〗中有关公民身份号码的规定，公民身份号码是特征组合码，由十七位数字本体码和一位数字校验码组成。排列顺序从左至右依次为：六位数字地址码，八位数字出生日期码，三位数字顺序码和一位数字校验码。

地址码表示编码对象常住户口所在县(市、旗、区)的行政区划代码。生日期码表示编码对象出生的年、月、日，其中年份用四位数字表示，年、月、日之间不用分隔符。顺序码表示同一地址码所标识的区域范围内，对同年、月、日出生的人员编定的顺序号。顺序码的奇数分给男性，偶数分给女性。校验码是根据前面十七位数字码，按照ISO 7064:1983.MOD 11-2校验码计算出来的检验码。下面举例说明该计算方法。

15位的身份证编码首先把出生年扩展为4位，简单的就是增加一个19，但是这对于1900年出生的人不使用（这样的寿星不多了）

某男性公民身份号码本体码为34052419800101001，首先按照公式⑴计算：

∑(ai×Wi)(mod 11)……………………………………(1)

公式(1)中：
i----表示号码字符从由至左包括校验码在内的位置序号；
ai----表示第i位置上的号码字符值；
Wi----示第i位置上的加权因子，其数值依据公式Wi=2（n-1）(mod 11)计算得出。

i 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1

ai  3 4 0   5 2 4 1 9 8 0 0 1 0   1 0 0 1 a1

Wi 7 9 10 5 8 4 2 1 6 3 7 9 10 5 8 4 2 1

ai×Wi 21 36 0 25 16 16 2 9 48 0 0 9 0 5 0 0 2 a1

根据公式(1)进行计算：

∑(ai×Wi) =（21+36+0+25+16+16+2+9+48++0+0+9+0+5+0+0+2) = 189

189 ÷ 11 = 17 + 2/11

∑(ai×Wi)(mod 11) = 2

然后根据计算的结果，从下面的表中查出相应的校验码，其中X表示计算结果为10：

∑(ai×WI)(mod 11) 0 1 2 3 4 5 6 7 8 9 10
校验码字符值       ai 1 0 X 9 8 7 6 5 4 3 2
根据上表，查出计算结果为2的校验码为所以该人员的公民身份号码应该为 34052419800101001X。

C#代码：

  private string per15To18(string perIDSrc)
  {
   int iS = 0;
 
   //加权因子常数
   int[] iW=new int[]{7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2};
   //校验码常数
   string LastCode="10X98765432";
   //新身份证号
   string perIDNew;
 
   perIDNew=perIDSrc.Substring(0,6);
   //填在第6位及第7位上填上‘1’，‘9’两个数字
   perIDNew += "19";
 
   perIDNew += perIDSrc.Substring(6,9);
 
   //进行加权求和
   for( int i=0; i<17; i++)
   {
    iS += int.Parse(perIDNew.Substring(i,1)) * iW[i];
   }
    
   //取模运算，得到模值
   int iY = iS％11;
   //从LastCode中取得以模为索引号的值，加到身份证的最后一位，即为新身份证号。
   perIDNew += LastCode.Substring(iY,1);

   return perIDNew;
  }

网上比较多讲述如何操作Excel表的文章，但都是启动Excel的窗口来打开Excel数据文件。有时候需要把Excel表嵌入到自己程序的Form中，给客户一个不用切换窗口的操作界面，似乎更好。这在VC中用OLE技术很容易实现，但是在C#中方法就不一样啦。下面将就此进行阐述。

一、首先简要回顾一下如何操作Excel表

  先要添加对Excel的引用。选择项目-〉添加引用-〉COM-〉添加Microsoft Excel 9.0。（不同的office讲会有不同版本的dll文件）。
   using Excel;
   using System.Reflection;
  
   //产生一个Excel.Application的新进程
   Excel.Application app = new Excel.Application();
   if (app == null)
   {
    statusBar1.Text = "ERROR: EXCEL couldn't be started!";
    return ;
   }
  
   app.Visible = true; //如果只想用程序控制该excel而不想让用户操作时候，可以设置为false
   app.UserControl = true;
  
   Workbooks workbooks =app.Workbooks;
 
   _Workbook workbook = workbooks.Add(XlWBATemplate.xlWBATWorksheet); //根据模板产生新的workbook
//  _Workbook workbook = workbooks.Add("c:\\a.xls"); //或者根据绝对路径打开工作簿文件a.xls

   Sheets sheets = workbook.Worksheets;
   _Worksheet worksheet = (_Worksheet) sheets.get_Item(1);
   if (worksheet == null)
   {
    statusBar1.Text =  "ERROR: worksheet == null";
    return;
   }

   // This paragraph puts the value 5 to the cell G1
   Range range1 = worksheet.get_Range("A1", Missing.Value);
   if (range1 == null)
   {
    statusBar1.Text =  "ERROR: range == null";
    return;
   }
   const int nCells = 2345;
   range1.Value2 = nCells;
 
二、将Excel用户界面嵌入到自己的Windows Form中

      由于目前，C#和vb.net都不支持OLE技术(参见微软支持中心Info:304562)，，所以只有使用WebBrowser控件来完成此功能。（以下方法参见微软支持中心Howto:304662）
      1、右击工具箱，选择自定义工具箱，添加COM组件，选择“Microsoft Web 浏览器”（对应文件是\winnt\system32\shdocvw.dll），确定。在工具箱中将会出现文本为Explorer的WebBroser控件图标。
      2、在Form1中添加WebBrowser控件。（对象名却省是axWebBrowser1）
      3、假定要打开的excel文件是: c:\a.xls。
       string strFileName = @"c:\a.xls";
     Object refmissing = System.Reflection.Missing.Value;
     axWebBrowser1.Navigate(strFileName, ref refmissing , ref refmissing , ref refmissing , ref refmissing);
    值得注意的是用WebBrowser控件不支持菜单合并，也就是说无法把Excel表的菜单带入到我们的程序中。这是相对于OLE实现方法的一大缺点。幸好提供了可以把工具栏添加进来的功能，通过工具栏可以进行许多Excel专有的操作。
     //下面这句可以将excel本身的工具调添加进来
    axWebBrowser1.ExecWB(SHDocVw.OLECMDID.OLECMDID_HIDETOOLBARS, SHDocVw.OLECMDEXECOPT.OLECMDEXECOPT_DONTPROMPTUSER,ref refmissing , ref refmissing);
   
三、回到本文提出的问题，如何操作嵌入的Excel?

   首先需要明白，用WebBrowser“装载”Excel"表，实际上仍然是在新的进程空间中运行Excel.exe。可以用任务管理器观察。因此，只要我们能够获取Excel.Application对象，就能像上文一中所说的那样操作Excel数据。
   幸好可以通过WebBrowser的方法NavigateComplete提供的事件参数e来访问Excel.Application。
  public void axWebBrowser1_NavigateComplete2(object sender, AxSHDocVw.DWebBrowserEvents2_NavigateComplete2Event e)
  {
   Object o = e.pDisp;
   Object oDocument = o.GetType().InvokeMember("Document",BindingFlags.GetProperty,null,o,null);
   Object oApplication = o.GetType().InvokeMember("Application",BindingFlags.GetProperty,null,oDocument,null);
      //Object oName = o.GetType().InvokeMember("Name",BindingFlags.GetProperty ,null,oApplication,null);

   //由于打开的是excel文件，所以这里的oApplication 其实就是Excel.Application
   Excel.Application eApp =(Excel.Application)oApplication;//这样就可以象上文中所述来操作Excel了。
  }

四、包含该WebBrowser的Form退出时候，如何确保Excel进程也退出？（参见Microsoft帮助中心KB317109）

  由于WebBrowser只不过是对Excel表的浏览，而Excel在单独的进程中运行。所以要保证对该Excel对象eApp及其相应的所有成员变量都释放引用，才能保证在Form退出时excel进程跟着退出。这一点在一个程序需要多次打开关闭excel表时尤为重要。
      Excel.Application oApp;
      Excel.Workbooks oBooks;
      Excel.Workbook oBook;
      Excel.Worksheet oSheet;
      ...........
    private void ExcelExit()
    {
       NAR(oSheet);
       oBook.Close(False);
       NAR(oBook);
       NAR(oBooks);
       oApp.Quit();
       NAR(oApp);

       Debug.WriteLine("Sleeping...");
       System.Threading.Thread.Sleep(5000);
       Debug.WriteLine("End Excel");
    }
  private void NAR(Object o)
  {
        try{System.Runtime.InteropServices.Marshal.ReleaseComObject(o);}
        catch{}
        finally{o = null;}
    }
  经过试验，我发现除了释放这些变量以外，必须把该axWebBroswer1也销毁掉，Excel进程才退出。否则的话，即使让axWebBroser1去Navigate空内容"about:blank", excel进程仍然不会退出。因此应该将axWebBroser1所在的Form关闭掉，或者直接调用axWebBrowser1.Dispose();
  如果还是其它问题导致不能正常退出，就只有调用垃圾回收了。
  GC.Collect();

'压缩文件函数，dataS为源文件，dataz为目标文件，传出为一个布尔值

Private Function DataZip(ByVal Datas As String, ByVal Dataz As String) As Boolean

On Error GoTo Compact_Error

    Dim JRO As JRO.JetEngine

    Set JRO = New JRO.JetEngine

    Dim fso As New FileSystemObject

    If fso.FileExists(Dataz) = True Then

        If MsgBox("此压缩文件已存在是否将其覆盖？", vbYesNo + vbQuestion, "压缩工程数据文件") = vbYes Then

            Kill Dataz

        Else

            Exit Function

        End If

    End If

    '压缩工程文件

    JRO.CompactDatabase "Provider=Microsoft.Jet.OLEDB.4.0;Data Source=" & Datas, _

    "Provider=Microsoft.Jet.OLEDB.4.0;Data Source=" & Dataz & ";Jet OLEDB:Engine Type=5"

    DataZip = True

    MsgBox "工程数据压缩成功！", vbInformation + vbOKOnly, "压缩数据文件"

    Exit Function

Compact_Error:

    DataZip = False

    If Err.Number = -2147467259 Then

        MsgBox "数据压缩失败!(可能你的数据库正被其他程序使用，请将重新运行系统！)", vbOKOnly + vbInformation, "错误"

        Exit Function

    End If

    dbEncrypt.SaveError "MDIForm1-DataZip"

End Function

'解压缩函数，datas未压缩文件，dataz为已压缩文件

Private Function Zipext(ByVal Dataz As String, ByVal Datas As String) As Boolean

On Error GoTo Compact_Error

    Dim JRO As JRO.JetEngine

    Set JRO = New JRO.JetEngine

    Dim fso As New FileSystemObject

    If fso.FileExists(Datas) = True Then

        If MsgBox("此工程文件已存在是否将其覆盖？", vbYesNo + vbQuestion, "解压缩工程数据文件") = vbYes Then

            Kill Datas

        Else

            Exit Function

        End If

    End If

    '解压缩工程文件

    JRO.CompactDatabase "Provider=Microsoft.Jet.OLEDB.4.0;Data Source=" & Dataz, _

    "Provider=Microsoft.Jet.OLEDB.4.0;Data Source=" & Datas & ";Jet OLEDB:Engine Type=5"

    Zipext = True

    MsgBox "工程数据解压缩成功！", vbOKOnly + vbInformation, "解压缩数据文件"

    Exit Function

Compact_Error:

    Zipext = False

    If Err.Number = -2147467259 Then

        MsgBox "数据压缩失败!(可能你的数据库正被其他程序使用，请将重新运行系统！)", vbOKOnly + vbInformation, "错误"

        Exit Function

    End If

    dbEncrypt.SaveError "MDIForm1-DataZip"

End Function

       Word的“文件”菜单最下面列出了最近使用过的文件名及路径，文件名及路径会随着用户的使用不断地发生变化，这符合统计学中“最近使用”最大可能是“经常使用”的原则，方便了用户，提高了效率。它的实现方法有很多，我举一例，供大家参考。

       一、在工作目录下创建一个LastFile.ini文件，其中第一行为历史文件的总数，以下行是历史文件的全路径。当然您也可以使用数据表存储，那样编程时也许更方便一些。

       LastFile.ini文件内容如：4

"D:\程序实例\slzj\slzj源代码\2004.11.18水利造价\示例.mdb"

"C:\WINDOWS\Desktop\111\111.mdb"

"D:\程序实例\slzj\slzj源代码\2004.11.18水利造价\示例.mdb"

"D:\程序实例\slzj\slzj源代码\2004.11.3\2004.11.3\2004.11.3\2004.11.3\示例(审查).mdb"

    二、在Form_Load中编写如下代码，达到在文件菜单中显示历史文件的效果

'**************显示以往打开的文件记录***************************

    '对配置文件不存在的情况下，作出操作。

    If Dir(App.Path & "\lastfile.ini") = "" Then

        Open App.Path & "\lastfile.ini" For Output As #1

        Write #1, 0

        Close #1

End If

'打开lastfile.ini文件

    Open App.Path & "\lastfile.ini" For Input As #1

    Dim strLastfile2 As String

    '获取历史文件的数目

    Line Input #1, strLastfile2

    iMaxLastfile = Int(strLastfile2)

    Dim i As Integer

    '添加历史文件到ActiveBar菜单，先在ActiveBar中预设4各Command和一个分割线。并把他们的Visible＝False

    For i = 1 To iMaxLastfile

        Line Input #1, strLastfile2

        strLastfile(i - 1) = Mid(strLastfile2, 2, Len(strLastfile2) - 2)‘去引号

        AABar.Bands("MenuFile").Tools.item(i + 10).Caption = strLastfile(i - 1)

        AABar.Bands("MenuFile").Tools.item(i + 10).Visible = True

    Next

    '关闭文件

    Close #1

    '设置分隔条

    If iMaxLastfile <> 0 Then

        AABar.Bands("MenuFile").Tools.item(15).Visible = True

End If

三、在Form_Unload中添加如下代码，将打开文件记录写入配置文件。

    Open App.Path & "\LastFile.ini" For Output As #1

    Dim i As Integer

    Write #1, iMaxLastfile‘写入历史文件总数

    For i = 0 To iMaxLastfile - 1

        Write #1, strLastfile(i)‘写入历史文件路径

    Next

    Close #1

四、在需要更新菜单中文件历史记录的地方使用下面函数（如：打开一个文件，新建并打开一个文件等）

Private Sub UpdateLastFile(ByVal strPath As String)

    On Error GoTo SaveErr:

    Dim strDuan As String

    strDuan = strPath

    '判断要添加的文件是否时列表中的第一个文件

    If strDuan <> AABar.Bands("MenuFile").Tools.item(11).Caption Then

        '将列表中的文件依次下移一位,空出第一位

        Dim i As Integer

        For i = 3 To 1 Step -1

            strLastfile(i) = strLastfile(i - 1)

            AABar.Bands("MenuFile").Tools.item(11 + i).Caption = AABar.Bands("MenuFile").Tools.item(10 + i).Caption

        Next

        '将头一位设置为当前操作的文件路径

        strLastfile(0) = strDuan

        AABar.Bands("MenuFile").Tools.item(11).Caption = strDuan

        '如果列表文件数小于最大文件数则加一

        If iMaxLastfile < 4 Then