huyi

find dirname -type f -exec egrep "from[ ]{0,}portfolio.*? " {} \;

    .NET推崇这样一种思想：相对于框架而言，语言处于从属、次要的地位。CodeDom名称空间中包含的类是这一思想的集中体现。我们可以用CodeDom构造一个树或图，用System.CodeDom名称空间的类填充它，完成后，用对应各种.NET语言的CodeProvider对象将树结构转换成该种语言的代码。要更换一种语言，简单到只需更换一下最后用到的CodeProvider对象。
  
  　　设想一下，利用这一技术，我们至少能够：
  
  　　·查询存储过程的元数据，构造出一个负责参数绑定的类。
  
  　　·查询程序集的manifest，构造出一个对每个函数执行单元测试的类。
  
  　　·为开发组用到的每一种语言生成样板代码。
  
  　　·只需写一份范例代码，就可以让用户自由选择他们要查看哪一种语言的版本。
  
  　　·自定义模板语法，经解析后生成任意语言的代码。
  
  　　·如果要学习某种不熟悉的语言，可以生成该语言的代码，然后将它与熟悉的语言比较。
  
  　　一、基本操作
  
  　　System.CodeDom名称空间包含了许多以语言中立的形式描述常见程序结构的对象，每一种语言的细节则由与该种语言对应的CodeProvider对象负责处理。例如，CodeConditionStatement包含一个TrueStatements集合、一个FalseStatements集合和一个条件属性（Condition attribute），但不涉及条件语句块要用“end if”还是右花括号“}”结束，这部分细节由CodeProvider处理。有了这一层抽象，我们就可以描述待生成的代码结构，然后将它以任意语言的形式输出，却不必斤斤计较于各种与特定语言有关的细节问题。同时，这种抽象也为我们通过程序改变代码的结构带来了方便。例如，当我们发现某个方法需要增加一个参数时，就可以将参数加入到该方法的Parameters集合，根本无须改动已生成的代码逻辑。
  
  　　我们在本文中要用到的大部分对象来自System.CodeDom名称空间，其余对象主要来自各个与特定语言有关的名称空间，例如Microsoft.CSharp名称空间、Microsoft.VisualBasic名称空间、Microsoft.JScript名称空间和Microsoft.VJSharp名称空间。所有这些面向特定语言的名称空间都包含各自的CodeProvider对象。最后，System.CodeDom.Complier名称空间定义ICodeGenerator接口，后者用来把生成的代码输出到一个TextWriter对象。
  
  　　如果我们只要生成一些用于插件或宏的代码片断，可以利用CodeGenerator从Statement、Expression、Type等生成代码。反之，如果我们要生成的是一个完整的文件，则必须从CodeNameSpace对象入手。在本文的例子中，我们将从一个名称空间开始，示范如何加入import语句、声明类、声明方法、声明变量、实现一个循环结构、索引一个数组，最后，我们将这些技术结合起来，得到一个大家都熟悉的程序。
  
  　　1.1 初始化名称空间
  
  　　初始化名称空间的代码类似下面这种形式：
  
  private CodeNameSpace InitializeNameSpace(string Name)
  {
   // 初始化CodeNameSpace变量，指定名称空间的名称
   CodeNameSpace CurrentNameSpace = new CodeNamespace (Name);
   // 将一些名称空间加入到要导入的名称空间集合。
   // 各种语言如何导入名称空间的细节由每种语言对应
   // 的CodeProvider分别处理。
   CurrentNameSpace.Imports.Add (new CodeNamespaceImport("System"));
   CurrentNameSpace.Imports.Add (new CodeNamespaceImport("System.Text"));
   return CurrentNameSpace;
  }
  
  
  
  　　这段代码定义了一个新的名称空间，并导入System和System.Text名称空间。
  
  　　1.2 创建类
  
  　　声明一个新类的代码类似下面这种形式：
  
  private CodeTypeDeclaration CreateClass (string Name)
  {
   // 新建一个CodeTypeDeclaration对象，指定要创建的类的名称
   CodeTypeDeclaration ctd = new CodeTypeDeclaration (Name);
   // 指定这个CodeType是一个类，而不是一个枚举变量或struct
   ctd.IsClass = true;
   // 这个类的访问类型是public
   ctd.Attributes = MemberAttributes.Public;
   // 返回新创建的类
   return ctd;
  }
  
  
  
  　　CreateClass函数新建一个指定名称的类，做好为该类植入方法、属性、事件的准备。
  
  　　1.3 创建方法
  
  　　声明一个新函数的代码类似下面这种形式：
  
  private CodeEntryPointMethod CreateMethod()
  {
   // 创建一个方法
   CodeEntryPointMethod method = new CodeEntryPointMethod();
   // 指定该方法的修饰符：public，static
   method.Attributes = MemberAttributes.Public |
   MemberAttributes.Static;
   // 返回新创建的方法
   return method;
  }
  
  
  
  　　本例创建了一个CodeEntryPointMethod对象。CodeEntryPointMethod对象类似于CodeMemberMethod对象，两者的不同之处在于，CodeProvider会将CodeEntryPointMethod代表的方法作为类的入口点调用，例如作为Sub Main或void main等。对于CodeEntryPointMethod对象，方法的名称默认为Main；对于CodeMemberMethod，方法的名称必须显式指定。
  
  　　1.4 声明变量
  
  　　声明一个变量的代码类似下面这种形式：
  
  private CodeVariableDeclarationStatement
   DeclareVariables(System.Type DataType,
   string Name)
  {
   // 为将要创建的变量类型创建一个CodeTypeReference对象，
   // 这使得我们不必去关注该类数据在特定语言环境中的
   // 与数据类型有关的细节问题。
   CodeTypeReference tr = new CodeTypeReference (DataType );
   // CodeVariableDeclarationStatement对象使得我们不必纠缠于
   // 与特定语言有关的下列细节：在该语言的变量声明语句中，
   // 应该是数据类型在前，还是变量名称在前；声明变量时是
   // 否要用到Dim之类的关键词.
   CodeVariableDeclarationStatement Declaration =
   new CodeVariableDeclarationStatement(tr, Name);
   // CodeObjectCreateExpression负责处理所有调用构造器的细节。
   // 大多数情况下应该是new，但有时要使用New。但不管怎样，
   // 我们不必去关注这些由语言类型决定的细节.
   CodeObjectCreateExpression newStatement = new
   CodeObjectCreateExpression ();
   // 指定我们要调用其构造器的对象.
   newStatement.CreateType = tr;
   // 变量将通过调用其构造器的方式初始化.
   Declaration.InitExpression = newStatement;
   return Declaration;
  }
  
  
  
  　　每一种.NET语言都有其特定的数据类型名称，所有这些数据类型都被映射到公共的.NET语言类型。例如，对于C#中称为int的数据类型，在VB.NET中是Integer，公共的.NET类型是System.Int32。CodeTypeReference对象直接使用.NET公共数据类型，以后由每种语言的CodeProvider将它转换成符合各自语言规范的类型名称。
  
  　　1.5 初始化数组
  
  　　初始化一个数组的代码类似下面这种形式：
  
  private void InitializeArray (string Name,
   params char[] Characters )
  {
   // 从参数中传入的字符数组获得一个CodeTypeReference 对象，
   // 以便在生成的代码中复制该数据类型.
   CodeTypeReference tr = new CodeTypeReference (Characters.GetType());
   // 声明一个匹配原始数组的数组
   CodeVariableDeclarationStatement Declaration =
   new CodeVariableDeclarationStatement (tr, Name);
   // CodePrimitiveExpression代表“基本”或值数据类型，
   // 例如char、int、double等等。
   // 我们将用这类基本数据类型构成的一个数组来
   // 初始化我们正在声明的数组。
   CodePrimitiveExpression[] cpe = new
   CodePrimitiveExpression[Characters.Length];
   // 循环遍历原始字符数组，
   // 为CodePrimitiveExpression类型的数组创建对象。
   for (int i = 0; i < Name.Length ; i++)
   {
   // 每一个CodePrimitiveExpression将有一个字符的语言
   // 中立的表示。
   cpe[i] = new CodePrimitiveExpression (Characters[i]);
   }
   // CodeArrayCreateExpression负责调用数组中数据类型的
   // 默认构造器。
   // 由于我们还传入了一个CodePrimitiveExpression的数组，
   // 所以不必指定数组的大小，且数组中的每一个元素都将有
   // 合适的初值。
   CodeArrayCreateExpression array = new
   CodeArrayCreateExpression(tr, cpe);
   // 指定：该CodeArrayCreateExpression将初始化数组变量声明。
   Declaration.InitExpression = array;
   return Declaration;
  }
  
  
  
  　　1.6 定义循环结构
  
  　　声明一个循环结构的代码类似下面这种形式：
  
  private CodeIterationStatement CreateLoop(string LoopControlVariableName)
  {
   // 声明一个新的变量，该变量将作为
   // 循环控制变量
   CodeVariableDeclarationStatement Declaration;
   // 声明一个管理所有循环逻辑的CodeIterationStatement
   CodeIterationStatement forloop = new CodeIterationStatement();
   // 为动态声明的变量指定数据类型的另一种方法：
   // 用typeof函数获得该数据类型的Type对象，不必
   // 用到该类数据的变量
   Declaration = new CodeVariableDeclarationStatement(typeof (int),
   LoopControlVariableName);
   // 指定一个简单的初始化表达式：
   // 将新变量设置为0
   Declaration.InitExpression = new CodeSnippetExpression ("0");
   // 这个新声明的变量将用来初始化循环
   forloop.InitStatement = Declaration;
   // CodeAssignStatement用来处理赋值语句。
   // 这里使用的构造器要求提供两个表达式，第一个位于
   // 赋值语句的左边，第二个位于赋值语句的右边。
   // 另一种办法是：调用默认的构造器，然后分别显式设置
   // 左、右两个表达式。
   CodeAssignStatement assignment = new CodeAssignStatement(
   new CodeVariableReferenceExpression(LoopControlVariableName),
   new CodeSnippetExpression (LoopControlVariableName + " + 1" ));
   // 在循环迭代中使用赋值语句。
   forloop.IncrementStatement = assignment;
   // 当循环控制变量超出数组中的字符个数时，
   // 循环结束
   forloop.TestExpression = new CodeSnippetExpression
   (LoopControlVariableName + " < Characters.Length");
   return forloop;
  }
  
  
  
  　　注意，这里我们用typeof函数直接获得循环控制变量的数据类型的Type对象，而不是通过声明一个CodeTypeReference对象的方式。这是CodeVariableDeclartionStatement的又一个构造器，实际上其构造器的总数多达7种。
  
  　　1.7 索引数组
  
  　　索引一个数组的代码类似下面这种形式：
  
  private CodeArrayIndexerExpression
   CreateArrayIndex(string ArrayName, string IndexValue )
  {
   // 新建一个CodeArrayIndexerExpression
   CodeArrayIndexerExpression index = new CodeArrayIndexerExpression ();
   // Indices属性是一个能够支持多维数组的集合。不过这里我们只需要
   // 一个简单的一维数组。
   index.Indices.Add ( new CodeVariableReferenceExpression (IndexValue));
   // TargetObject指定了要索引的数组的名称。
   index.TargetObject = new CodeSnippetExpression (ArrayName);
   return index;
  }
  
  
  
  　　CodeArrayIndexerExpression对象处理数组索引方式的种种差异。例如，在C#中数组以ArrayName[IndexValue]的方式索引；但在VB.NET中，数组以ArrayName(IndexValue)的方式索引。CodeArrayIndexerExpression允许我们忽略这种差异，将注意力集中到其他更重要的问题，例如要索引哪一个数组、要访问第几个数组元素。
  
  　　二、装配出树结构
  
  　　我们可以把前面定义的所有函数加入到一个类，通过构造器初始化，例如：
  
  public CodeDomProvider()
  {
   CurrentNameSpace = InitializeNameSpace("TestSpace");
   CodeTypeDeclaration ctd = CreateClass ("HelloWorld");
   // 把类加入到名称空间
   CurrentNameSpace.Types.Add (ctd);
   CodeEntryPointMethod mtd = CreateMethod();
   // 把方法加入到类
   ctd.Members.Add (mtd);
   CodeVariableDeclarationStatement VariableDeclaration =
   DeclareVariables (typeof (StringBuilder), "sbMessage");
   // 把变量声明加入到方法
   mtd.Statements.Add (VariableDeclaration);
   CodeVariableDeclarationStatement array = InitializeArray
   ("Characters", 'H', 'E', 'L', 'L', 'O', ' ',
   'W', 'O', 'R', 'L', 'D');
   // 把数组加入到方法
   mtd.Statements.Add (array);
   CodeIterationStatement loop = CreateLoop("intCharacterIndex");
   // 把循环加入到方法
   mtd.Statements.Add (loop);
   // 数组索引
   CodeArrayIndexerExpression index = CreateArrayIndex("Characters",
   "intCharacterIndex");
   // 加入一个语句，它将调用sbMessage对象的“Append”方法
   loop.Statements.Add (new CodeMethodInvokeExpression (
   new CodeSnippetExpression ("sbMessage"),"Append",
   index));
   // 循环结束后，输出所有字符追加到sbMessage对象
   // 后得到的结果
   mtd.Statements.Add (new CodeSnippetExpression
   ("Console.WriteLine (sbMessage.ToString())"));
  }
  
  
  
  　　构造器的运行结果是一个完整的CodeDom树结构。可以看到，至此为止我们的所有操作都独立于目标语言。最后生成的代码将以属性的形式导出。
  
  　　三、输出生成结果
  
  　　构造好CodeDom树之后，我们就可以较为方便地将代码以任意.NET语言的形式输出。每一种.NET语言都有相应的CodeProvider对象，CodeProvider对象的CreateGenerator方法能够返回一个实现了ICodeGenerator接口的对象。ICodeGenerator接口定义了用来生成代码的所有方法，而且允许我们定义一个用来简化属性输出的辅助方法。下面的辅助方法GenerateCode负责设置好合适的TextWriter以供输出代码，以字符串的形式返回结果文本。
  
  private string GenerateCode (ICodeGenerator CodeGenerator)
  {
   // CodeGeneratorOptions允许我们指定各种供代码生成器
   // 使用的格式化选项
   CodeGeneratorOptions cop = new CodeGeneratorOptions();
   // 指定格式：花括号的位置
   cop.BracingStyle = "C";
   // 指定格式：代码块的缩进方式
   cop.IndentString = " ";
   // GenerateCodeFromNamespace要求传入一个TextWriter以
   // 容纳即将生成的代码。这个TextWriter可以是一个StreamWriter、
   // 一个StringWriter或一个IndentedTextWriter。
   // StreamWriter可用来将代码输出到文件。
   // StringWriter可绑定到StringBuilder，后者可作为一个变量引用。
   // 在这里，我们把一个StringWriter绑定到StringBuilder sbCode。
   StringBuilder sbCode = new StringBuilder();
   StringWriter sw = new StringWriter(sbCode);
  
   // 生成代码！
   CodeGenerator.GenerateCodeFromNamespace(CurrentNameSpace, sw,cop);
   return sbCode.ToString();
  }
  
  
  
  　　有了这个辅助函数，要获取各种语言的代码就相当简单了：
  
  public string VBCode
  {
   get
   {
   VBCodeProvider provider = new VBCodeProvider ();
   ICodeGenerator codeGen = provider.CreateGenerator ();
   return GenerateCode (codeGen);
   }
  
  }
  
  public string JScriptCode
  {
   get
   {
   JScriptCodeProvider provider = new JScriptCodeProvider ();
   ICodeGenerator codeGen = provider.CreateGenerator ();
   return GenerateCode(codeGen);
   }
  
  }
  
  public string JSharpCode
  {
   get
   {
   VJSharpCodeProvider provider = new VJSharpCodeProvider ();
   ICodeGenerator codeGen = provider.CreateGenerator ();
   return GenerateCode (codeGen);
   }
  
  }
  
  public string CSharpCode
  {
   get
   {
   CSharpCodeProvider provider = new CSharpCodeProvider();
   ICodeGenerator codeGen = provider.CreateGenerator ();
   return GeneratorCode (codeGen);
   }
  
  }
  
  
  
  　　四、显示出生成的代码
  
  　　为输出代码，我们要用到一个简单的.aspx文件，它有四个标签，分别对应一种.NET语言：
  
  <table width="800" border="1">
   <tr>
   <th>VB.NET代码</th>
   </tr>
   <tr >
   <td>
   <asp:Label ID="vbCode" Runat="server" CssClass="code">
   </asp:Label>
   </td>
   </tr>
   <tr>
   <th>
   C#代码</th></tr>
   <tr>
   <td><asp:Label ID="csharpcode" Runat="server" CssClass="code">
   </asp:Label></td>
   </tr>
   <tr>
   <th>J#代码</th></tr>
   <tr >
   <td>
   <asp:Label ID="JSharpCode" Runat="server" CssClass="code">
   </asp:Label>
   </td>
   </tr>
   <tr>
   <th>JScript.NET代码</th>
   </tr>
   <tr>
   <td><asp:Label ID="JScriptCode" Runat="server" CssClass="code">
   </asp:Label></td>
   </tr>
  </table>
  
  
  
  　　在后台执行的代码中，我们实例化一个前面创建的CodeDomProvider类的实例，把它生成的代码赋值给.aspx页面的相应标签的Text属性。为了使Web页面中显示的代码整齐美观，有必要做一些简单的格式化，替换换行符号、空格等，如下所示：
  
  private string FormatCode (string CodeToFormat)
  {
   string FormattedCode = Regex.Replace (CodeToFormat, "\n", "<br>");
   FormattedCode = Regex.Replace (FormattedCode, " " , " ");
   FormattedCode = Regex.Replace (FormattedCode, ",", ", ");
   return FormattedCode;
  }
  
  
  
  　　下面把生成的代码显示到Web页面：
  
  private void Page_Load(object sender, System.EventArgs e)
  {
  
   HelloWorld.CodeDomProvider codegen = new HelloWorld.CodeDomProvider ();
   vbCode.Text = FormatCode (codegen.VBCode);
   csharpcode.Text = FormatCode (codegen.CSharpCode);
   JScriptCode.Text = FormatCode (codegen.JScriptCode);
   JSharpCode.Text = FormatCode (codegen.JSharpCode);
   Page.EnableViewState = false;
  }
  
  
  
  　　输出结果如下：
  
  VB.NET代码
  
  Imports System
  Imports System.Text
  
  Namespace HelloWorld
  
   Public Class Hello_World
  
   Public Shared Sub Main()
   Dim sbMessage As System.Text.StringBuilder = _
   New System.Text.StringBuilder
   Dim Characters() As Char = New Char() {_
   Microsoft.VisualBasic.ChrW(72), _
   Microsoft.VisualBasic.ChrW(69), _
   Microsoft.VisualBasic.ChrW(76), _
   Microsoft.VisualBasic.ChrW(76), _
   Microsoft.VisualBasic.ChrW(79), _
   Microsoft.VisualBasic.ChrW(32), _
   Microsoft.VisualBasic.ChrW(87), _
   Microsoft.VisualBasic.ChrW(79), _
   Microsoft.VisualBasic.ChrW(82), _
   Microsoft.VisualBasic.ChrW(76), _
   Microsoft.VisualBasic.ChrW(68)}
   Dim intCharacterIndex As Integer = 0
   Do While intCharacterIndex < Characters.Length
   sbMessage.Append(Characters(intCharacterIndex))
   intCharacterIndex = intCharacterIndex + 1
   Loop
   Console.WriteLine (sbMessage.ToString())
   End Sub
   End Class
  End Namespace
  
  C#代码
  
  namespace HelloWorld
  {
   using System;
   using System.Text;
  
   public class Hello_World
   {
   public static void Main()
   {
   System.Text.StringBuilder sbMessage = new
   System.Text.StringBuilder();
   char[] Characters = new char[] {
   'H',
   'E',
   'L',
   'L',
   'O',
   ' ',
   'W',
   'O',
   'R',
   'L',
   'D'};
   for (int intCharacterIndex = 0;
   intCharacterIndex < Characters.Length;
   intCharacterIndex = intCharacterIndex + 1)
   {
   sbMessage.Append(Characters[intCharacterIndex]);
   }
   Console.WriteLine (sbMessage.ToString());
   }
   }
  }
  
  J#代码
  
  package HelloWorld;
  import System.*;
  import System.Text.*;
  
  
  public class Hello_World
  {
   public static void main(String[] args)
   {
   System.Text.StringBuilder sbMessage = new
   System.Text.StringBuilder();
   char[] Characters = new char[]
   {
   'H',
   'E',
   'L',
   'L',
   'O',
   ' ',
   'W',
   'O',
   'R',
   'L',
   'D'}
   ;
   for (int intCharacterIndex = 0;
   intCharacterIndex < Characters.Length;
   intCharacterIndex = intCharacterIndex + 1)
   {
   sbMessage.Append(Characters[intCharacterIndex]);
   }
   Console.WriteLine (sbMessage.ToString());
   }
  }
  
  
  JScript.NET代码
  
  
  //@cc_on
  //@set @debug(off)
  
  import System;
  import System.Text;
  
  package HelloWorld
  {
  
   public class Hello_World
   {
  
   public static function Main()
   {
   var sbMessage : System.Text.StringBuilder =
   new System.Text.StringBuilder();
   var Characters : char[] =
   ['H', 'E', 'L', 'L', 'O', ' ', 'W', 'O', 'R', 'L', 'D'];
   for (var intCharacterIndex : int = 0;
   ; intCharacterIndex < Characters.Length;
   intCharacterIndex = intCharacterIndex + 1)
   {
   sbMessage.Append(Characters[intCharacterIndex]);
   }
   Console.WriteLine (sbMessage.ToString());
   }
   }
  }
  HelloWorld.Hello_World.Main();
  
  
  
  　　总结：CodeDom体现了.NET中语言的重要性不如框架的思想。本文示范了如何运用一些常用的CodeDom类，几乎每一个使用CodeDom技术的应用都要用到这些类。作为一种结构化的代码生成技术，CodeDom有着无限的潜能，唯一的约束恐怕在于人们的想象力。

     一、发生的背景
  　　在开发新项目中使用了新的语言开发 C# 和新的技术方案 WEB Service，但是在新项目中，一些旧的模块需要继续使用，一般是采用 C 或 C++ 或 Delphi 编写的，如何利用旧模块对于开发人员来说，有三种可用方法供选择：第一、将 C 或 C++ 函数用 C# 彻底改写一遍，这样整个项目代码比较统一，维护也方便一些。但是尽管微软以及某些书籍说，C# 和 C++ 如何接近，但是改写起来还是很痛苦的事情，特别是 C++ 里的指针和内存操作；第二、将 C 或 C++ 函数封装成 COM，在 C# 中调用COM 比较方便，只是在封装时需要处理 C 或 C++ 类型和 COM 类型之间的转换，也有一些麻烦，另外COM 还需要注册，注册次数多了又可能导致混乱；第三、将 C 或 C++ 函数封装成动态链接库，封装的过程简单，工作量不大。因此我决定采用加载动态链接库的方法实现，于是产生了在 C# 中如何调用自定义的动态链接库问题，我在网上搜索相关主题，发现一篇调用系统 API 的文章，但是没有说明如何解决此问题，在 MSDN 上也没有相关详细说明。基于此，我决定自己从简单出发，逐步试验，看看能否达到自己的目标。
  　　（说明一点：我这里改写为什么很怕麻烦，我改写的代码是变长加密算法函数，代码有600多行，对算法本身不熟悉，算法中指针和内存操作太多，要想保证算法正确，最可行的方法就是少动代码，否则只要有一点点差错，就不能肯定算法与以前兼容）
  
  二、技术实现
  　　下面看看如何逐步实现动态库的加载，类型的匹配，动态链接库函数导出的定义，这个不需要多说，大家参考下面宏定义即可：
  
  #define LIBEXPORT_API extern "C" __declspec(dllexport)
  第一步，我先从简单的调用出发，定义了一个简单的函数，该函数仅仅实现一个整数加法求和：
  
  LIBEXPORT_API int mySum(int a,int b){ return a+b;}
  C# 导入定义：
  
  public class RefComm
  {
  [DllImport("LibEncrypt.dll",
  　　　　EntryPoint=" mySum ",
  　　　　CharSet=CharSet.Auto,CallingConvention=CallingConvention.StdCall)]
  　　　　public static extern int mySum (int a,int b);
  }
  在C#中调用测试：
  
  int iSum = RefComm.mySum(2,3);
  运行查看结果iSum为5，调用正确。第一步试验完成，说明在C#中能够调用自定义的动态链接库函数。
  
  第二步，我定义了字符串操作的函数（简单起见，还是采用前面的函数名），返回结果为字符串：
  
  LIBEXPORT_API char *mySum(char *a,char *b){sprintf(b,"%s",a); return a;}
  C# 导入定义：
  
  public class RefComm
  {
  [DllImport("LibEncrypt.dll",
  　　　　　EntryPoint=" mySum ",
  　　　　　CharSet=CharSet.Auto,
  　　　　　CallingConvention=CallingConvention.StdCall)]
  　　　　　public static extern string mySum (string a, string b);
  }
  在C#中调用测试：
  
  string strDest="";
  string strTmp= RefComm.mySum("12345", strDest);
  运行查看结果 strTmp 为"12345"，但是strDest为空。我修改动态链接库实现，返回结果为串b：
  
  LIBEXPORT_API char *mySum(char *a,char *b){sprintf(b,"%s",a) return b;}
  修改 C# 导入定义，将串b修改为ref方式：
  
  public class RefComm
  {
  [DllImport("LibEncrypt.dll",
  　　　　　EntryPoint=" mySum ",
  　　　　　CharSet=CharSet.Auto,CallingConvention=CallingConvention.StdCall)]
  　　　　　public static extern string mySum (string a, ref string b);
  }
  在C#中再调用测试：
  
  string strDest="";
  string strTmp= RefComm.mySum("12345", ref strDest);
  　　运行查看结果 strTmp 和 strDest 均不对，含不可见字符。再修改 C# 导入定义，将CharSet从Auto修改为Ansi：
  
  public class RefComm
  {
  [DllImport("LibEncrypt.dll",
  　　　　　EntryPoint=" mySum ",
  　　　　　CharSet=CharSet.Ansi,CallingConvention=CallingConvention.StdCall)]
  　　　　　public static extern string mySum (string a, string b);
  }
  在C#中再调用测试：
  
  string strDest="";
  string strTmp= RefComm. mySum("12345", ref strDest);
  　　运行查看结果 strTmp 为"12345"，但是串 strDest 没有赋值。第二步实现函数返回串，但是在函数出口参数中没能进行输出。再次修改 C# 导入定义，将串b修改为引用（ref）：
  
  public class RefComm
  {
  [DllImport("LibEncrypt.dll",
  　　　　　EntryPoint=" mySum ",
  　　　　　CharSet=CharSet.Ansi,CallingConvention=CallingConvention.StdCall)]
  　　　　　public static extern string mySum (string a, ref string b);
  }
  运行时调用失败，不能继续执行。
  
  第三步，修改动态链接库实现，将b修改为双重指针：
  
  LIBEXPORT_API char *mySum(char *a,char **b){sprintf((*b),"%s",a); return *b;}
  C#导入定义：
  
  public class RefComm
  {
  [DllImport("LibEncrypt.dll",
  　　　　　EntryPoint=" mySum ",
  　　　　　CharSet=CharSet.Ansi,CallingConvention=CallingConvention.StdCall)]
  　　　　　public static extern string mySum (string a, ref string b);
  }
  在C#中调用测试：
  
  string strDest="";
  string strTmp= RefComm. mySum("12345", ref strDest);
  　　运行查看结果 strTmp 和 strDest 均为"12345"，调用正确。第三步实现了函数出口参数正确输出结果。
  
  第四步，修改动态链接库实现，实现整数参数的输出：
  
  LIBEXPORT_API int mySum(int a,int b,int *c){ *c=a+b; return *c;}
  C#导入的定义：
  
  public class RefComm
  {
  [DllImport("LibEncrypt.dll",
  　　　　　EntryPoint=" mySum ",
  　　　　　CharSet=CharSet.Ansi,CallingConvention=CallingConvention.StdCall)]
  　　　　　public static extern int mySum (int a, int b,ref int c);
  }
  在C#中调用测试：
  
  int c=0;
  int iSum= RefComm. mySum(2,3, ref c);
  运行查看结果iSum 和c均为5，调用正确。
  　　经过以上几个步骤的试验，基本掌握了如何定义动态库函数以及如何在 C# 定义导入，有此基础，很快我实现了变长加密函数在 C# 中的调用，至此目标实现。
  
  三、结论
  　　在 C# 中调用 C++ 编写的动态链接库函数，如果需要出口参数输出，则需要使用指针，对于字符串，则需要使用双重指针，对于 C# 的导入定义，则需要使用引用（ref）定义。
  　　对于函数返回值，C# 导入定义和 C++ 动态库函数声明定义需要保持一致，否则会出现函数调用失败。定义导入时，一定注意 CharSet 和 CallingConvention 参数，否则导致调用失败或结果异常。运行时，动态链接库放在 C# 程序的目录下即可，我这里是一个 C# 的动态链接库，两个动态链接库就在同一个目录下运行。
  
  原文出处：：http://windend.blogchina.com

     摘要: 原文地址http://www.theserverside.com/articles/article.tss?l=SpringFramework You may have heard the buzz this summer around the Spring Framework. In this article, I'll try to explain what Spring sets out ...  阅读全文

一、动态加载数据源
1、通过修改注册表加载数据源：
·用户数据源：HKEY_CURRENT_USER＼SOFTWARE＼ODBC＼ODBC.INI
·系统数据源：HKEY_LOCAL_MACHINE＼SOFTWARE＼ODBC＼ODBC.INI
对于不同类型的数据源，注册表的修改也不同，但基本上要修改两个地方，一个是在ODBC.INI子键下建立一个与数据源描述名同名的子键，并在该子键下建立与数据源配置相关的项；另一个是在＼ODBC.INI＼ODBC Data Sources子键下建立一个新项以便告诉驱动程序管理器ODBC数据源的类型。
2、通过ODBC API加载：Windows系统子目录下的动态链接库Odbcinst.dll提供了一个可以动态增加、修改和删除数据源的函数SQLConfigDataSource，由于VC的默认库文件中不包含此函数，因此使用前需将Odbcinst.h文件包含在工程的头文件中，在工程的setting属性框Link页的Object/library module编辑框中增加Odbc32.lib，同时保证系统目录system32下有文件Odbccp32.dll。
3、文件数据源的连接：除了ODBC管理器，还可以通过SQLDriverConnect来添加文件数据源。
二、ODBC  API编程
如果一个ODBC API函数执行成功，则返回SQL_SUCCESS或SQL_SUCCESS_WITH_INFO，SQL_SUCCESS指示可通过诊断记录获取有关操作的详细信息，SQL_SUCCESS_WITH_INFO指示应用程序执行结果带有警告信息，可通过诊断记录获取详细信息。如果函数调用失败，返回码为SQL_ERROR。
一般，编写ODBC程序主要有一下几个步骤：
1、   分配环境句柄：声明一个SQLHENV的变量，调用函数SQLAllocHandle。
设置环境属性：完成环境分配后，用函数SQLSetEnvAttr设置环境属性，注册ODBC版本号。
释放环境句柄：完成数据访问任务时，应调用SQLFreeHandle释放前面分配的环境。
2、       分配连接句柄：声明一个SQLHDBC类型的变量，调用SQLAllocHandle函数分配句柄。
设置连接属性：所有连接属性都可通过函数SQLSetConnectAttr设置，调用函数SQLGetConnectAttr可获取这些连接属性的当前设置值。
3、   连接数据源：对于不同的程序和用户接口，可以用不同的函数建立连接
SQLConnect：该函数只要提供数据源名称、用户ID和口令，就可以进行连接了。
SQLDriverConnect：该函数用一个连接字符串建立至数据源的连接，它可以让用户输入必要的连接信息，使用系统中还没定义的数据源。
SQLBrowseConnect：该函数支持以一种迭代的方式获取到数据源的连接，直到最后建立连接，它基于客户机／服务器体系结构，因此本地数据库不支持该函数。
4、   准备并执行SQL语句
A、  分配语句句柄：语句句柄是通过调用SQLAllocHandle函数分配的。
函数SQLGetStmrrAttr和SQLSetStmrrAttr用来获取和设置一个语句句柄的选项，使用完，调用SQLFreeHandle释放该句柄。
B、  执行SQL语句
SQLExecDirect：该函数直接执行SQL语句，对于只执行一次的SQL语句来说，该函数是执行最快的方法。
SQLPrepare和SQLExecute：对于需要多次执行的SQL语句来说，可先调用SQLPrepare准备SQL语句的执行，用SQLExecute执行准备好的语句。
C、  使用参数：使用参数可以使一条SQL语句多次执行，得到不同的结果。
函数SQLBindParameter负责为参数定义变量，将一段SQL语句中的一个参数标识符("？")捆绑在一起，实现参数值的传递。
5、   获取记录集
A、   绑定列：首先必须分配与记录集中字段相对应的变量，然后通过函数SQLBindCol将记录字段同程序变量绑定在一起，对于长记录字段，可以通过调用函数SQLGetData直接取回数据。
绑定字段可以根据自己的需要全部绑定，也可以绑定其中的某几个字段。
通过调用函数SQLBindCol将变量地址值赋为NULL，可以结束对一个记录字段的绑定，通过调用函数SQLFreeStmt，将其中选项设为SQL_UNBIND，或者直接释放句柄，都会结束所有记录字段的绑定。
B、SQLFetch：该函数用于将记录集的下一行变成当前行，并把所有捆绑过的数据字段的数据拷贝到相应的缓冲区。
C、 光标：应用程序获取数据是通过光标(Cursor)来实现的，在ODBC中，主要有3种类型的光标：单向光标、可滚动光标和块光标。
有些应用程序不支持可滚动光标和块光标，ODBC SDK提供了一个光标库(ODBCCR32.DLL)，在应用程序中可通过设置连接属性(SQL_STTR_ODBC_CURSOR)激活光标库。
6、  记录的添加、删除和更新：数据源数据更新可通过3种方式：通过SQLExecDirect函数使用相应的SQL语句；调用SQLSetPos函数实现记录集定义更新；调用SQLBulkOperations函数实现数据更新。
第一种方式适用于任何ODBC数据源，后两种方式有的数据源不支持，可调用SQLGetInfo确定数据源。
SQLBulkOperations：该函数操作基于当前行集，调用前，须先调用SQLFetch或SQLFetchScroll获取。
函数调用后，块光标的位置变为未定义状况，因此，应该先调用函数SQLFetchScroll设定光标位置。
7、错误处理：每个ODBC API函数都能产生一系列反映操作信息的诊断记录，可以用SQLGetDiagField函数获取诊断记录中特定的域，另外，可以使用SQLGetDiagRec获取诊断记录中一些常用的域。
8、事务处理：事务提交有两种方式：自动提交模式和手动提交模式。应用程序可通过调用函数SQLSetConnectAttr设定连接属性SQL_ATTR_AUTOCOMMIT，自动提交模式是默认的连接属性设置，对于所有的ODBC驱动程序都能适应这种模式下，所有语句都是作为一个独立的事务进行处理的。
手动提交模式把一组SQL语句放入一个事务中，程序必须调用函数SQLEenTran明确地终止一个事务。若使用多个激活的事务，就必须建立多个连接，每一个连接包含一个事务。
9、断开数据连接并释放环境句柄：完成数据库操作后，可调用SQLDisconnect函数关闭同数据库的连接。

　　摘要： 本文针对HOOK技术在VC编程中的应用进行讨论，并着重对应用比较广泛的全局HOOK做了阐述。

　　引言

　　Windows操作系统是建立在事件驱动机制之上的，系统各部分之间的沟通也都是通过消息的相互传递而实现的。但在通常情况下，应用程序只能处理来自进程内部的消息或是从其他进程发过来的消息，如果需要对在进程外传递的消息进行拦截处理就必须采取一种被称为HOOK（钩子）的技术。钩子是Windows操作系统中非常重要的一种系统接口，用它可以轻松截获并处理在其他应用程序之间传递的消息，并由此可以完成一些普通应用程序难以实现的特殊功能。基于钩子在消息拦截处理中的强大功能，本文即以VC++ 6.0为编程背景对钩子的基本概念及其实现过程展开讨论。为方便理解，在文章最后还给出了一个简单的有关鼠标钩子的应用示例。

　　钩子的基本原理

　　钩子的本质是一段用以处理系统消息的程序，通过系统调用，将其挂入到系统。钩子的种类有很多，每一种钩子负责截获并处理相应的消息。钩子机制允许应用程序截获并处理发往指定窗口的消息或特定事件，其监视的窗口即可以是本进程内的也可以是由其他进程所创建的。在特定的消息发出，并在到达目的窗口之前，钩子程序先行截获此消息并得到对其的控制权。此时在钩子函数中就可以对截获的消息进行各种修改处理，甚至强行终止该消息的继续传递。

　　任何一个钩子都由系统来维护一个指针列表（钩子链表），其指针指向钩子的各个处理函数。最近安装的钩子放在链的开始，最早安装的钩子则放在最后，当钩子监视的消息出现时，操作系统调用链表开始处的第一个钩子处理函数进行处理，也就是说最后加入的钩子优先获得控制权。在这里提到的钩子处理函数必须是一个回调函数（callback function），而且不能定义为类成员函数，必须定义为普通的C函数。在使用钩子时可以根据其监视范围的不同将其分为全局钩子和线程钩子两大类，其中线程钩子只能监视某个线程，而全局钩子则可对在当前系统下运行的所有线程进行监视。显然，线程钩子可以看作是全局钩子的一个子集，全局钩子虽然功能强大但同时实现起来也比较烦琐：其钩子函数的实现必须封装在动态链接库中才可以使用。

　　钩子的安装与卸载

　　由于全局钩子具有相当的广泛性而且在功能上完全覆盖了线程钩子，因此下面就主要对应用较多的全局钩子的安装与使用进行讨论。前面已经提过，操作系统是通过调用钩子链表开始处的第一个钩子处理函数而进行消息拦截处理的。因此，为了设置钩子，只需将回调函数放置于链首即可，操作系统会使其首先被调用。在具体实现时由函数SetWindowsHookEx()负责将回调函数放置于钩子链表的开始位置。SetWindowsHookEx()函数原型声明如下:

HHOOK SetWindowsHookEx(int idHook;
HOOKPROC lpfn;
HINSTANCE hMod;
DWORD dwThreadId);

　　其中：参数idHook 指定了钩子的类型，总共有如下13种：

　　　WH_CALLWNDPROC 系统将消息发送到指定窗口之前的"钩子"
　　　WH_CALLWNDPROCRET 消息已经在窗口中处理的"钩子"
　　　WH_CBT 基于计算机培训的"钩子"
　　　WH_DEBUG 差错"钩子"
　　　WH_FOREGROUNDIDLE 前台空闲窗口"钩子"
　　　WH_GETMESSAGE 接收消息投递的"钩子"
　　　WH_JOURNALPLAYBACK 回放以前通过WH_JOURNALRECORD"钩子"记录的输入消息
　　　WH_JOURNALRECORD 输入消息记录"钩子"
　　　WH_KEYBOARD 键盘消息"钩子"
　　　WH_MOUSE 鼠标消息"钩子"
　　　WH_MSGFILTER 对话框、消息框、菜单或滚动条输入消息"钩子"
　　　WH_SHELL 外壳"钩子"
　　　WH_SYSMSGFILTER 系统消息"钩子"

　　参数lpfn为指向钩子处理函数的指针，即回调函数的首地址；参数hMod则标识了钩子处理函数所处模块的句柄；第四个参数dwThreadId 指定被监视的线程，如果明确指定了某个线程的ID就只监视该线程，此时的钩子即为线程钩子；如果该参数被设置为0，则表示此钩子为监视系统所有线程的全局钩子。此函数在执行完后将返回一个钩子句柄。

　　虽然对于线程钩子并不要求其象全局钩子一样必须放置于动态链接库中，但是推荐其也在动态链接库中实现。因为这样的处理不仅可使钩子可为系统内的多个进程访问，也可以在系统中被直接调用，而且对于一个只供单进程访问的钩子，还可以将其钩子处理过程放在安装钩子的同一个线程内，此时SetWindowsHookEx()函数的第三个参数也就是该线程的实例句柄。

　　在SetWindowsHookEx()函数完成对钩子的安装后，如果被监视的事件发生，系统马上会调用位于相应钩子链表开始处的钩子处理函数进行处理，每一个钩子处理函数在进行相应的处理时都要考虑是否需要把事件传递给下一个钩子处理函数。如果要传递，就通过函数CallNestHookEx()来解决。尽管如此，在实际使用时还是强烈推荐无论是否需要事件传递而都在过程的最后调用一次CallNextHookEx( )函数，否则将会引起一些无法预知的系统行为或是系统锁定。该函数将返回位于钩子链表中的下一个钩子处理过程的地址，至于具体的返回值类型则要视所设置的钩子类型而定。该函数的原型声明如下：

LRESULT CallNextHookEx(HHOOK hhk;int nCode;WPARAM wParam;LPARAM lParam);

　　其中，参数hhk为由SetWindowsHookEx()函数返回的当前钩子句柄；参数nCode为传给钩子过程的事件代码；参数wParam和lParam 则为传给钩子处理函数的参数值，其具体含义同设置的钩子类型有关。

　　最后，由于安装钩子对系统的性能有一定的影响，所以在钩子使用完毕后应及时将其卸载以释放其所占资源。释放钩子的函数为UnhookWindowsHookEx()，该函数比较简单只有一个参数用于指定此前由SetWindowsHookEx()函数所返回的钩子句柄，原型声明如下：

BOOL UnhookWindowsHookEx(HHOOK hhk);

　　鼠标钩子的简单示例

　　最后，为更清楚展示HOOK技术在VC编程中的应用，给出一个有关鼠标钩子使用的简单示例。在钩子设置时采用的是全局钩子。下面就对鼠标钩子的安装、使用以及卸载等过程的实现进行讲述：

　　由于本例程需要使用全局钩子，因此首先构造全局钩子的载体--动态链接库。考虑到　Win32 DLL与Win16 DLL存在的差别，在Win32环境下要在多个进程间共享数据，就必须采取一些措施将待共享的数据提取到一个独立的数据段，并通过def文件将其属性设置为读写共享：

#pragma data_seg("TestData") HWND glhPrevTarWnd=NULL; // 窗口句柄 HWND glhHook=NULL; // 鼠标钩子句柄 HINSTANCE glhInstance=NULL; // DLL实例句柄 #pragma data_seg() …… SECTIONS // def文件中将数据段TestData设置为读写共享 TestData READ WRITE SHARED

　　在安装全局鼠标钩子时使用函数SetWindowsHookEx()，并设定鼠标钩子的处理函数为MouseProc()，安装函数返回的钩子句柄保存于变量glhHook中：

void StartHook(HWND hWnd) { …… glhHook=(HWND)SetWindowsHookEx(WH_MOUSE,MouseProc,glhInstance,0); }

　　鼠标钩子安装好后，在移动、点击鼠标时将会发出鼠标消息，这些消息均经过消息处理函数MouseProc()的拦截处理。在此，每当捕获到系统各线程发出的任何鼠标消息后首先获取当前鼠标所在位置下的窗口句柄，并进一步通过GetWindowText()函数获取到窗口标题。在处理函数完成后，通过CallNextHookEx()函数将事件传递到钩子列表中的下一个钩子处理函数：

LRESULT WINAPI MouseProc(int nCode,WPARAM wParam,LPARAM lParam) { LPMOUSEHOOKSTRUCT pMouseHook=(MOUSEHOOKSTRUCT FAR *) lParam; if(nCode>=0) { HWND glhTargetWnd=pMouseHook->hwnd; //取目标窗口句柄 HWND ParentWnd=glhTargetWnd; while(ParentWnd !=NULL) { glhTargetWnd=ParentWnd; //取应用程序主窗口句柄 ParentWnd=GetParent(glhTargetWnd); } if(glhTargetWnd!=glhPrevTarWnd) { char szCaption[100]; //取目标窗口标题 GetWindowText(glhTargetWnd,szCaption,100); …… } } //继续传递消息 return CallNextHookEx((HHOOK)glhHook,nCode,wParam,lParam); }

　　最后，调用UnhookWindowsHookEx()函数完成对钩子的卸载：

void StopHook() { …… UnhookWindowsHookEx((HHOOK)glhHook); }

　　现在完成的是鼠标钩子的动态链接库，经过编译后需要经应用程序的调用才能实现对当前系统下各线程间鼠标消息的拦截处理。这部分同普通动态链接库的使用没有任何区别，在将其加载到进程后，首先调用动态链接库的StartHook()函数安装好钩子，此时即可对系统下的鼠标消息实施拦截处理，在动态链接库被卸载即终止鼠标钩子时通过动态链接库中的StopHook()函数卸载鼠标钩子。

　　经上述编程，在安装好鼠标钩子后，鼠标在移动到系统任意窗口上时，马上就会通过对鼠标消息的拦截处理而获取到当前窗口的标题。实验证明此鼠标钩子的安装、使用和卸载过程是正确的。

　　小结

　　钩子，尤其是系统钩子具有相当强大的功能，通过这种技术可以对几乎所有的Windows系统消息和事件进行拦截处理。这种技术广泛应用于各种自动监控系统对进程外消息的监控处理。本文只对钩子的一些基本原理和一般的使用方法做了简要的探讨，感兴趣的读者完全可以在本文所述代码基础之上用类似的方法实现对诸如键盘钩子、外壳钩子等其他类型钩子的安装与使用。本文所述代码在Windows 98下由Microsoft Visual C++ 6.0编译通过。

一、APIHOOK之dll部分
 
//////////////////////////////// APIHook_Dll.cpp ////////////////////////////////////////
//                             rivershan写于2002.9.23                                  //
/////////////////////////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "APIHook_Dll.h"

#include <ImageHlp.h>
#include <tlhelp32.h>

#pragma comment(lib,"ImageHlp") //定义全局共享数据段

#pragma data_seg("Shared")
HMODULE hmodDll=NULL;
HHOOK hHook=NULL;

#pragma data_seg()

#pragma comment(linker,"/Section:Shared,rws") //设置全局共享数据段的属性

///////////////////////////////////// DllMain 函数 /////////////////////////////////////////
//dll的入口点
BOOL APIENTRY DllMain( HMODULE hModule,
                       DWORD  ul_reason_for_call,
                       LPVOID lpReserved
      )
{
 switch(ul_reason_for_call)
 {
 case DLL_PROCESS_ATTACH:
  //if(sHook)  
  
 case DLL_PROCESS_DETACH:
  UnInstallHook();
  break;
 }
 hmodDll=hModule;
    return TRUE;
}

///////////////////////////////////// HookOneAPI 函数 /////////////////////////////////////////
//进行IAT转换的关键函数，其参数含义：
//pszCalleeModuleName：需要hook的模块名
//pfnOriginApiAddress：要替换的自己API函数的地址
//pfnDummyFuncAddress：需要hook的模块名的地址
//hModCallerModule：我们要查找的模块名称，如果没有被赋值，
//     将会被赋值为枚举的程序所有调用的模块

void WINAPI HookOneAPI(LPCTSTR pszCalleeModuleName,PROC pfnOriginApiAddress,
        PROC pfnDummyFuncAddress,HMODULE hModCallerModule)
{
 ULONG size;

 //获取指向PE文件中的Import中IMAGE_DIRECTORY_DESCRIPTOR数组的指针

 PIMAGE_IMPORT_DESCRIPTOR pImportDesc = (PIMAGE_IMPORT_DESCRIPTOR)
  ImageDirectoryEntryToData(hModCallerModule,TRUE,IMAGE_DIRECTORY_ENTRY_IMPORT,&size);

 if (pImportDesc == NULL)
  return;

 //查找记录,看看有没有我们想要的DLL

 for (;pImportDesc->Name;pImportDesc++)
 {
  LPSTR pszDllName = (LPSTR)((PBYTE)hModCallerModule+pImportDesc->Name);
  if (lstrcmpiA(pszDllName,pszCalleeModuleName) == 0)
   break;
 }

 if (pImportDesc->Name == NULL)
 {
  return;
 }

 //寻找我们想要的函数

 PIMAGE_THUNK_DATA pThunk =
  (PIMAGE_THUNK_DATA)((PBYTE)hModCallerModule+pImportDesc->FirstThunk);//IAT
 for (;pThunk->u1.Function;pThunk++)
 {
  //ppfn记录了与IAT表项相应的函数的地址

  PROC * ppfn= (PROC *)&pThunk->u1.Function;  
  if (*ppfn == pfnOriginApiAddress)
  {
   //如果地址相同，也就是找到了我们想要的函数，进行改写，将其指向我们所定义的函数

   WriteProcessMemory(GetCurrentProcess(),ppfn,&(pfnDummyFuncAddress),
    sizeof(pfnDummyFuncAddress),NULL);
   return;
  }
 }
}

//查找所挂钩的进程所应用的dll模块的

BOOL WINAPI HookAllAPI(LPCTSTR pszCalleeModuleName,PROC pfnOriginApiAddress,
        PROC pfnDummyFuncAddress,HMODULE hModCallerModule)
{
 if (pszCalleeModuleName == NULL)
 {
  return FALSE;
 }
 if (pfnOriginApiAddress == NULL)
 {
  return FALSE;
 }
 //如果没传进来要挂钩的模块名称，枚举被挂钩进程的所有引用的模块，
 //并对这些模块进行传进来的相应函数名称的查找
 
 if (hModCallerModule == NULL)
 {
  MEMORY_BASIC_INFORMATION mInfo;
  HMODULE hModHookDLL;
  HANDLE hSnapshot;
  MODULEENTRY32 me = {sizeof(MODULEENTRY32)};
  //MODULEENTRY32:描述了一个被指定进程所应用的模块的struct

  VirtualQuery(HookOneAPI,&mInfo,sizeof(mInfo));
  hModHookDLL=(HMODULE)mInfo.AllocationBase;
  
  hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE,0);
  BOOL bOk = Module32First(hSnapshot,&me);
  while (bOk)
  {
   if (me.hModule != hModHookDLL)
   {
    hModCallerModule = me.hModule;//赋值
    //me.hModule:指向当前被挂钩进程的每一个模块
    HookOneAPI(pszCalleeModuleName,pfnOriginApiAddress,
     pfnDummyFuncAddress,hModCallerModule);
   }
   bOk = Module32Next(hSnapshot,&me);
  }
  return TRUE;  
 }
 //如果传进来了，进行查找
 else
 {
  HookOneAPI(pszCalleeModuleName,pfnOriginApiAddress,
    pfnDummyFuncAddress,hModCallerModule);
  return TRUE;
 }
 return FALSE;
}

//////////////////////////////////// UnhookAllAPIHooks 函数 /////////////////////////////////////
//通过使pfnDummyFuncAddress与pfnOriginApiAddress相等的方法，取消对IAT的修改
BOOL WINAPI UnhookAllAPIHooks(LPCTSTR pszCalleeModuleName,PROC pfnOriginApiAddress,
         PROC pfnDummyFuncAddress,HMODULE hModCallerModule)
{
 PROC temp;
 temp = pfnOriginApiAddress;
 pfnOriginApiAddress = pfnDummyFuncAddress;
 pfnDummyFuncAddress = temp;
 return HookAllAPI(pszCalleeModuleName,pfnOriginApiAddress,
  pfnDummyFuncAddress,hModCallerModule);
}

////////////////////////////////// GetMsgProc 函数 ////////////////////////////////////////
//钩子子程。与其它钩子子程不大相同，没做什么有意义的事情，继续调用下一个钩子子程，形成循环
LRESULT CALLBACK GetMsgProc(int code,WPARAM wParam,LPARAM lParam)
{
 return CallNextHookEx(hHook,code,wParam,lParam);
}

//////////////////////////////////// InstallHook 函数 /////////////////////////////////////
//安装或卸载钩子，BOOL IsHook参数是标志位
//对要钩哪个API函数进行初始化
//我们这里装的钩子类型是WH_GETMESSAGE
void __declspec(dllexport) WINAPI InstallHook(BOOL IsHook,DWORD dwThreadId)
{
 if(IsHook)
 {
 hHook=SetWindowsHookEx(WH_GETMESSAGE,(HOOKPROC)GetMsgProc,hmodDll,dwThreadId);
 
 //GetProcAddress(GetModuleHandle("GDI32.dll"),"ExtTextOutA")：取得要钩的函数在所在dll中的地址
 
 HookAllAPI("GDI32.dll",GetProcAddress(GetModuleHandle("GDI32.dll"),
  "TextOutW"),(PROC)&H_TextOutW,NULL);
 HookAllAPI("GDI32.dll",GetProcAddress(GetModuleHandle("GDI32.dll"),
  "TextOutA"),(PROC)&H_TextOutA,NULL);
 }
 else
 {
  UnInstallHook();
  UnhookAllAPIHooks("GDI32.dll",GetProcAddress(GetModuleHandle("GDI32.dll"),
   "TextOutW"),(PROC)&H_TextOutW,NULL);
  UnhookAllAPIHooks("GDI32.dll",GetProcAddress(GetModuleHandle("GDI32.dll"),
   "TextOutA"),(PROC)&H_TextOutA,NULL);
 }
}

///////////////////////////////////// UnInstallHook 函数 ////////////////////////////////////
//卸载钩子
BOOL WINAPI UnInstallHook()
{
 UnhookWindowsHookEx(hHook);
 return TRUE;
}

///////////////////////////////////// H_TextOutA 函数 /////////////////////////////////////////
//我们的替换函数，可以在里面实现我们所要做的功能
//这里我做的是显示一个对话框，指明是替换了哪个函数
BOOL WINAPI H_TextOutA(HDC hdc,int nXStart,int nYStart,LPCSTR lpString,int cbString)
{
 MessageBox(NULL,"TextOutA","APIHook_Dll ---rivershan",MB_OK);
 TextOutA(hdc,nXStart,nYStart,lpString,cbString);//返回原来的函数，以显示字符
 return TRUE;
}

///////////////////////////////////// H_TextOutW 函数 /////////////////////////////////////////
//同上
BOOL WINAPI H_TextOutW(HDC hdc,int nXStart,int nYStart,LPCWSTR lpString,int cbString)
{
 MessageBox(NULL,"TextOutW","APIHook_Dll ---rivershan",MB_OK);
 TextOutW(hdc,nXStart,nYStart,lpString,cbString);//返回原来的函数，以显示字符
 return TRUE;
}

**********************************************************************************************
**********************************************************************************************

//////////////////////////////// APIHook_Dll.h ////////////////////////////////////////
//                             rivershan写于2002.9.23                                  //
/////////////////////////////////////////////////////////////////////////////////////////

//dll头文件，用于声明函数

void __declspec(dllexport) WINAPI InstallHook(BOOL,DWORD);
BOOL WINAPI UnInstallHook();
LRESULT CALLBACK GetMsgProC(int code,WPARAM wParam,LPARAM lParam);

void WINAPI HookOneAPI(LPCTSTR pszCalleeModuleName,PROC pfnOriginApiAddress,
        PROC pfnDummyFuncAddress,HMODULE hModCallerModule);
BOOL WINAPI HookAllAPI(LPCTSTR pszCalleeModuleName,PROC pfnOriginApiAddress,
        PROC pfnDummyFuncAddress,HMODULE hModCallerModule);
BOOL WINAPI UnhookAllAPIHooks(LPCTSTR pszCalleeModuleName,PROC pfnOriginApiAddress,
         PROC pfnDummyFuncAddress,HMODULE hModCallerModule);

BOOL WINAPI H_TextOutA(HDC, int, int, LPCSTR, int);
BOOL WINAPI H_TextOutW(HDC, int, int, LPCWSTR, int);
BOOL WINAPI H_ExtTextOutA(HDC, int, int, UINT, CONST RECT *,LPCSTR, UINT, CONST INT *);
BOOL WINAPI H_ExtTextOutW(HDC, int, int, UINT, CONST RECT *,LPCWSTR, UINT, CONST INT *);

**********************************************************************************************
**********************************************************************************************

;APIHook_Dll之def文件
LIBRARY APIHook_Dll
EXPORTS
  InstallHook @1
 
二、APIHOOK之exe部分

//////////////////////////// APIHook_EXEDlg.cpp /////////////////////////////////////////
//                             rivershan写于2002.9.23                                  //
/////////////////////////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "APIHook_EXE.h"
#include "APIHook_EXEDlg.h"
#include "APIHook_Dll.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// CAPIHook_EXEDlg dialog

CAPIHook_EXEDlg::CAPIHook_EXEDlg(CWnd* pParent /*=NULL*/)
: CDialog(CAPIHook_EXEDlg::IDD, pParent)
{
 //{{AFX_DATA_INIT(CAPIHook_EXEDlg)
 // NOTE: the ClassWizard will add member initialization here
 //}}AFX_DATA_INIT
 // Note that LoadIcon does not require a subsequent DestroyIcon in Win32
 m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
}

void CAPIHook_EXEDlg::DoDataExchange(CDataExchange* pDX)
{
 CDialog::DoDataExchange(pDX);
 //{{AFX_DATA_MAP(CAPIHook_EXEDlg)
 // DDX_Control(pDX, IDC_EDIT1, m_Edit);
 //}}AFX_DATA_MAP
}

BEGIN_MESSAGE_MAP(CAPIHook_EXEDlg, CDialog)
//{{AFX_MSG_MAP(CAPIHook_EXEDlg)
ON_WM_PAINT()
ON_WM_QUERYDRAGICON()
 ON_BN_CLICKED(IDC_BUTTON_OUT, OnButtonOut)
 ON_BN_CLICKED(IDC_BUTTON_BEGIN, OnButtonBegin)
 ON_BN_CLICKED(IDC_BUTTON_STOP, OnButtonStop)
 //}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CAPIHook_EXEDlg message handlers

BOOL CAPIHook_EXEDlg::OnInitDialog()
{
 CDialog::OnInitDialog();
 
 // Set the icon for this dialog.  The framework does this automatically
 // when the application's main window is not a dialog
 SetIcon(m_hIcon, TRUE);   // Set big icon
 SetIcon(m_hIcon, FALSE);  // Set small icon
 
 // TODO: Add extra initialization here
 
 return TRUE;  // return TRUE  unless you set the focus to a control
}

// If you add a minimize button to your dialog, you will need the code below
//  to draw the icon.  For MFC applications using the document/view model,
//  this is automatically done for you by the framework.

void CAPIHook_EXEDlg::OnPaint()
{
 if (IsIconic())
 {
  CPaintDC dc(this); // device context for painting
  
  SendMessage(WM_ICONERASEBKGND, (WPARAM) dc.GetSafeHdc(), 0);
  
  // Center icon in client rectangle
  int cxIcon = GetSystemMetrics(SM_CXICON);
  int cyIcon = GetSystemMetrics(SM_CYICON);
  CRect rect;
  GetClientRect(&rect);
  int x = (rect.Width() - cxIcon + 1) / 2;
  int y = (rect.Height() - cyIcon + 1) / 2;
  
  // Draw the icon
  dc.DrawIcon(x, y, m_hIcon);
 }
 else
 {
  CDialog::OnPaint();
 }
}

// The system calls this to obtain the cursor to display while the user drags
//  the minimized window.
HCURSOR CAPIHook_EXEDlg::OnQueryDragIcon()
{
 return (HCURSOR) m_hIcon;
}
///////////////////////////////////// OnButtonOut 函数 //////////////////////////////////////
//使用TextOut函数
void CAPIHook_EXEDlg::OnButtonOut()
{
 // TODO: Add your control notification handler code here
 HDC hdc = ::GetDC(GetSafeHwnd());
 ::TextOutA(hdc,0,0,"APIHOOK_EXE ---rivershan",30);
 UpdateWindow();
}

///////////////////////////////////// OnButtonBegin 函数 ////////////////////////////////////
//开始挂钩，这里我们挂的是自身这个APIHook_EXE这个程序
void CAPIHook_EXEDlg::OnButtonBegin()
{
 DWORD dwThreadId = GetWindowThreadProcessId(m_hWnd,NULL);//获得自身进程ID
 InstallHook(TRUE,dwThreadId);
}

///////////////////////////////////// OnButtonStop 函数 ////////////////////////////////////
//取消挂钩
void CAPIHook_EXEDlg::OnButtonStop()
{
 InstallHook(FALSE,0);
}

三、APIHOOK之集成

1. 用 VC++新建一个 Win32 Dynamic-Link Library 程序，命名为 APIHook_Dll。接下来选择第二项 A Simple DLL Project；
2. 新建一头文件，命名为 APIHook_Dll.h。删除工程中 APIHook_Dll.cpp文件中原来的内容，然后把上面的 APIHook_Dll.cpp 和 APIHook_Dll.h文件的内容全部复制到新建的这个工程的 .cpp及 .h文件中来；
3. 新建一 Text文件，命名为 APIHook_Dll.def。复制上面的def文件内容。
4. 编译；
5. 新建一 MFC APPWizard(exe)程序，命名为 APIHook_EXE。接着选择第三项，基于对话框的程序，其它默认；
6. 删除原来对话框上的控件，然后新建三个按钮ID分别为：IDC_BUTTON_BEGIN、IDC_BUTTON_STOP、IDC_BUTTON_OUT，Caption分别为：Bigin Hook、Stop Hook、Text Out。不要让这三个按钮出于对话框客户区的最上面就行；
7. 拷贝 APIHook_Dll.h文件到 APIHook_EXE程序目录下，然后加到 APIHook_EXE的头文件夹中。
8. 删除工程中 APIHook_EXEDlg.cpp文件中原来的内容，然后把上面的 APIHook_EXEDlg.cpp文件的内容全部复制到新建的这个工程的 .cpp文件中来；
9. 打开 Project->Setting菜单，选择第四项link，在 Object/library moduls里添加我们的dll的lib文件的路径：..\APIHook_Dll\Debug\APIHook_Dll.lib；
10. 编译；
11. 把 APIHook_Dll.dll文件放在 APIHook_Dll.exe程序的同一个文件夹内；
12. 运行程序，点击 Bigin Hook按钮，开始挂钩。再点击 Text Out按钮会跳出对话框并且会在程序中显示所要显示的字。点击 Stop Hook然后在点击 Text Out按钮就没有对话框出现了。

四、一些说明

1、我这个 HookAPI是使用了 Jeffrey Richter的改写程序的 IAT来实现的，也可以用跳转函数入口点的方法来实现，这个我没做研究。：）

2、我的一些心得：

 所谓 HookAPI，就是改写程序的 IAT，再调用我自己写的用于替换原API函数的函数。在我们自己写的API函数中，我们可以进行我们想要的工作。之后呢，可以把原来的函数传回去，也可以不传回去，只要你设计好了就行。

 而所谓调用自己的函数,就是把原函数参数都传给我的替换函数。我们就可以利用这些参数去干我们想做的事。而系统呢，我想由于微软设置的这个钩子的目的（我这么认为的），所以不会去检查替换函数是否就是原函数，只要参数、返回值符合条件就行，要不会出错。替换函数的返回值最好是原函数，否则有可能会出错

 HookAPI时，exe程序起到的作用就是进行Hook，把dll注入到要Hook的程序，并且传回要挂接的进程的ID或者全局钩子，以便查询所要挂接的模块的IAT。如果不注入进去，系统不会让你去查询IAT的。DLL做的事情是确定要挂接哪个函数和这个函数在哪个DLL中等。

 

很多朋友都用虚拟主机来做网站，将网页文件存放在虚拟空间上，但是页面内容一多，网站打开的速度就显得特别慢，如果您碰到这种情况，与其寻求更好的空间，不如通过优化网页代码来取得满意的速度。笔者总结了一些切实可行的方法，制作主页时，以下的方法可以令你的网页速度大大提高。

　　 一、记得帮页面减肥

　　我们浏览网页实际上是将虚拟主机中的网页内容下载到本地硬盘，再用浏览器解释查看的。下载网页的快慢在显示速度上占了很大比重，所以，网页本身所占的空间越小，那么浏览速度就会越快。这就要求在做网页的时候遵循一切从简的原则，如：不要使用太大的Flash动画、图片等试础８删弧⒓蚪嗟囊趁婊岣艘恢炙悸访骼实母芯酢?BR>
　　 二、如没必要，尽量使用静态HTML页面

　　众所周知，ASP、PHP、JSP等程序实现了网页信息的动态交互，运行起来的确非常方便，因为它们的数据交互性好，能很方便地存取、更改数据库的内容，使网站“动”起来，如：论坛、留言板等。但是这类程序必须先由服务器执行处理后，生成HTML页面，然后再“送”往客户端浏览，这就不得不耗费一定的服务器资源。如果在虚拟主机上过多地使用这类程序，网页显示速度肯定会慢，所以没有必要，请尽量使用静态的HTML页面。

　　 三、不要将整个页面内容塞到一个Table中

　　这是网页设计的问题了，很多站长为了追求页面统一对齐，将整个页面的内容都塞进了一个Table（表格）里，然后再由单元格td来划分各个“块”的布局，这种网站的显示速度是绝对慢的。因为Table要等里面所有的内容都加载完毕后才显示出来的，如果某些内容无法访问，就会拖延整个页面的访问速度。正确的做法是：将内容分割到几个具有相同格局的Table中去，不要全都塞到一个Table里。

　　 四、将ASP、ASPX、PHP等文件的访问改为．js引用

　　这在ASP、ASPX、PHP等程序设计时应该注意的，如果你要在静态的HTML页面里嵌入动态的数据，而这些动态的数据是由ASP、PHP等程序来提供的话，会使用以下的语句引用： < script src="http://image.ccidnet.com/ad_files/network_index.asp?orders=1">< /script>
 
这样的话，每次有一个人访问你的网站，服务器就要执行并处理一次network_index.asp文件，从数据库抽取相应的数据，再输出给网页显示，如果有几万个人同时访问，就要执行几万次，后果就可想而知。建议在这些程序中将数据动态生成到一个network_index.js文件中去，然后在首页通过
<script src="http://www.179job.com/ad_files/home_daohang/network_index.js"></script>
 
这样的代码来引用该network_index.js文件。这样，数据显示的任务就交给客户端的浏览器去做，不会耗费服务器的资源，显示速度自然就很快；前者所花的时间几乎是后者的几倍！
　 五、使用iframe嵌套另一页面

　　如果你要在网站上插入一些广告代码，又不想让这些广告网站影响速度的话，那么，使用iframe最合适不过了。方法是：将这些广告代码放到一个独立的页面去，然后在首页用如下的代码将该页面嵌入即可，这样就不会因为广告页面的延迟而拖了整个首页的显示，代码如下：

< iframe frameborder=0
   leftmargin=0
   marginheight=0
   marginwidth=0
   scrolling=no src="http://www.179job.com/pub/123.html"
   topmargin=0 width=700 height=440 >
< /iframe>
 
其中http://www.179job.com/pub/123.html是被引用文件的路径。

http://www.zahui.com/html/1/3144.htm
讲解非常详尽，有例子

来自CodeGuru的一篇文章
http://www.codeguru.com/Cpp/W-P/system/misc/article.php/c5667

http://www.codeproject.com/csharp/globalhook.asp
这篇文章更绝，没有使用非托管代码就安装上了鼠标键盘钩子

http://www.codeproject.com/csharp/GlobalSystemHook.asp
很有价值的一篇文章，有代码示例。
讲述了如何通过非托管代码和托管代码的交互来按照钩子。

　　摘要： 本文对Windows剪贴板机制作了深入、全面的阐述，具体内容包括：文本、位图、DSP、自定义格式剪贴板的使用和多数据项和延迟提交技术。

　　关键词： VC++6.0； 剪贴板机制；数据格式；延迟提交

　　Windows剪贴板

　　Windows剪贴板是一种比较简单同时也是开销比较小的IPC（InterProcess Communication，进程间通讯）机制。Windows系统支持剪贴板IPC的基本机制是由系统预留的一块全局共享内存，用来暂存在各进程间进行交换的数据：提供数据的进程创建一个全局内存块，并将要传送的数据移到或复制到该内存块；接受数据的进程（也可以是提供数据的进程本身）获取此内存块的句柄，并完成对该内存块数据的读取。

　　为使剪贴板的这种IPC机制更加完善和便于使用，需要解决好如下三个问题：提供数据的进程在结束时Windows系统将删除其创建的全局内存块，而接受数据的进程则希望在其退出后剪贴板中的数据仍然存在，可以继续为其他进程所获取；能方便地管理和传送剪贴板数据句柄；能方便设置和确定剪贴板数据格式。为完善上述功能，Windows提供了存在于USER32.dll中的一组API函数、消息和预定义数据格式等，并通过对这些函数、消息的使用来管理在进程间进行的剪贴板数据交换。

　　Windows系统为剪贴板提供了一组API函数和多种消息，基本可以满足编程的需要。而且Windows还为剪贴板预定义了多种数据格式。通过这些预定义的格式，可以使接收方正确再现数据提供方放置于剪贴板中的数据内容。

　　文本剪贴板和位图剪贴板的使用

　　这两种剪贴板是比较常用的。其中，文本剪贴板是包含具有格式CF_TEXT的字符串的剪贴板，是最经常使用的剪贴板之一。在文本剪贴板中传递的数据是不带任何格式信息的ASCII字符。若要将文本传送到剪贴板，可以先分配一个可移动全局内存块，然后将要复制的文本内容写入到此内存区域。最后调用剪贴板函数将数据放置到剪贴板：

　

DWORD dwLength = 100; // 要复制的字串长度 HANDLE hGlobalMemory = GlobalAlloc(GHND, dwLength + 1); // 分配内存 LPBYTE lpGlobalMemory = (LPBYTE)GlobalLock(hGlobalMemory); // 锁定内存 for (int i = 0; i 〈 dwLength; i++) // 将"*"复制到全局内存块 　*lpGlobalMemory++ = '*'; 　GlobalUnlock(hGlobalMemory); // 锁定内存块解锁 　HWND hWnd = GetSafeHwnd(); // 获取安全窗口句柄 　::OpenClipboard(hWnd); // 打开剪贴板 　::EmptyClipboard(); // 清空剪贴板 　::SetClipboardData(CF_TEXT, hGlobalMemory); // 将内存中的数据放置到剪贴板 　::CloseClipboard(); // 关闭剪贴板

　　这里以OpenClipboard（）打开剪贴板，并在调用了EmptyClipboard（）后使hWnd指向的窗口成为剪贴板的拥有者，一直持续到CloseClipboard（）函数的调用。在此期间，剪贴板为拥有者所独占，其他进程将无法对剪贴板内容进行修改。

　　从剪贴板获取文本的过程与之类似，首先打开剪贴板并获取剪贴板的数据句柄，如果数据存在就拷贝其数据到程序变量。由于GetClipboardData（）获取的数据句柄是属于剪贴板的，因此用户程序必须在调用CloseClipboard（）函数之前使用它：

　

HWND hWnd = GetSafeHwnd(); // 获取安全窗口句柄 ::OpenClipboard(hWnd); // 打开剪贴板 HANDLE hClipMemory = ::GetClipboardData(CF_TEXT);// 获取剪贴板数据句柄 DWORD dwLength = GlobalSize(hClipMemory); // 返回指定内存区域的当前大小 LPBYTE lpClipMemory = (LPBYTE)GlobalLock(hClipMemory); // 锁定内存 m_sMessage = CString(lpClipMemory); // 保存得到的文本数据 GlobalUnlock(hClipMemory); // 内存解锁 ::CloseClipboard(); // 关闭剪贴板

　　大多数应用程序对图形数据采取的是位图的剪贴板数据格式。位图剪贴板的使用与文本剪贴板的使用是类似的，只是数据格式要指明为CF_BITMAP，而且在使用SetClipboardData（）或GetClipboardData（）函数时交给剪贴板或从剪贴板返回的是设备相关位图句柄。下面这段示例代码将把存在于剪贴板中的位图数据显示到程序的客户区：

　

HWND hWnd = GetSafeHwnd(); // 获取安全窗口句柄 ::OpenClipboard(hWnd); // 打开剪贴板 HANDLE hBitmap = ::GetClipboardData(CF_BITMAP); // 获取剪贴板数据句柄 HDC hDC = ::GetDC(hWnd); // 获取设备环境句柄 HDC hdcMem = CreateCompatibleDC(hDC); // 创建与设备相关的内存环境 SelectObject(hdcMem, hBitmap); // 选择对象 SetMapMode(hdcMem, GetMapMode(hDC)); // 设置映射模式 BITMAP bm; // 得到位图对象 GetObject(hBitmap, sizeof(BITMAP), &bm); BitBlt(hDC, 0, 0, bm.bmWidth, bm.bmHeight, hdcMem, 0, 0, SRCCOPY); //位图复制 ::ReleaseDC(hWnd, hDC); // 释放设备环境句柄 DeleteDC(hdcMem); // 删除内存环境 ::CloseClipboard(); // 关闭剪贴板

多数据项和延迟提交技术

　　要把数据放入剪贴板，在打开剪贴板后一定要调用EmptyClipboard（）函数清除当前剪贴板中的内容，而不可以在原有数据项基础上追加新的数据项。但是，可以在EmptyClipboard（）和CloseClipboard（）调用之间多次调用SetClipboardData（）函数来放置多个不同格式的数据项。例如：

　

OpenClipboard（hWnd）; EmptyClipboardData（）; SetClipboardData（CF_TEXT, hGMemText）; SetClipboardData（CF_BITMAP, hBitmap）; CloseClipboard（）;

　　这时如果用CF_TEXT或CF_BITMAP等格式标记去调用IsClipboardFormatAvailable（）都将返回TRUE，表明这几种格式的数据同时存在于剪贴板中。以不同的格式标记去调用GetClipboardData（）函数可以得到相应的数据句柄。

　　对于多数据项的剪贴板数据，还可以用CountClipboardFormats（）和EnumClipboardFormats（）函数得到当前剪贴板中存在的数据格式数目和具体的数据格式。EnumClipboardFormats（）的函数原型为：

　

UINT EnumClipboardFormats(UINT format);

　　参数format指定了剪贴板的数据格式。如果成功执行将返回format指定的格式的下一个数据格式值，如果format为最后的数据格式值，那么将返回0。由此不难写出处理剪贴板中所有格式数据项的程序段代码：

　

UINT format = 0; // 从第一种格式值开始枚举 OpenClipboard（hWnd）; while（format = EnumClipboardFormats（format）） { …… // 对相关格式数据的处理 } CloseClipboard（）;

　　在数据提供进程创建了剪贴板数据后，一直到有其他进程获取剪贴板数据前，这些数据都要占据内存空间。如在剪贴板放置的数据量过大，就会浪费内存空间，降低对资源的利用率。为避免这种浪费，可以采取延迟提交（Delayed rendering）技术，即由数据提供进程先创建一个指定数据格式的空（NULL）剪贴板数据块，直到有其他进程需要数据或自身进程要终止运行时才真正提交数据。

　　延迟提交的实现并不复杂，只需剪贴板拥有者进程在调用SetClipboardData（）将数据句柄参数设置为NULL即可。延迟提交的拥有者进程需要做的主要工作是对WM_RENDERFORMAT、WM_DESTORYCLIPBOARD和WM_RENDERALLFORMATS等剪贴板延迟提交消息的处理。

　　当另一个进程调用GetClipboardData（）函数时，系统将会向延迟提交数据的剪贴板拥有者进程发送WM_RENDERFORMAT消息。剪贴板拥有者进程在此消息的响应函数中应使用相应的格式和实际的数据句柄来调用SetClipboardData（）函数，但不必再调用OpenClipboard（）和EmptyClipboard（）去打开和清空剪贴板了。在设置完数据有也无须调用CloseClipboard（）关闭剪贴板。如果其他进程打开了剪贴板并且调用EmptyClipboard（）函数去清空剪贴板的内容，接管剪贴板的拥有权时，系统将向延迟提交的剪贴板拥有者进程发送WM_DESTROYCLIPBOARD消息，以通知该进程对剪贴板拥有权的丧失。而失去剪贴板拥有权的进程在收到该消息后则不会再向剪贴板提交数据。另外，在延迟提交进程在提交完所有要提交的数据后也会收到此消息。如果延迟提交剪贴板拥有者进程将要终止，系统将会为其发送一条WM_RENDERALLFORMATS消息，通知其打开并清除剪贴板内容。在调用SetClipboardData（）设置各数据句柄后关闭剪贴板。

　　下面这段代码将完成对数据的延迟提交，WM_RENDERFORMAT消息响应函数OnRenderFormat（）并不会立即执行，当有进程调用GetClipboardData（）函数从剪贴板读取数据时才会发出该消息。在消息处理函数中完成对数据的提交：

　　进行延迟提交：

　

HWND hWnd = GetSafeHwnd(); // 获取安全窗口句柄 ::OpenClipboard(hWnd); // 打开剪贴板 ::EmptyClipboard(); // 清空剪贴板 ::SetClipboardData(CF_TEXT, NULL); // 进行剪贴板数据的延迟提交 ::CloseClipboard(); // 关闭剪贴板

　　在WM_RENDERFORMAT消息的响应函数中：

　

DWORD dwLength = 100; // 要复制的字串长度 HANDLE hGlobalMemory = GlobalAlloc(GHND, dwLength + 1); // 分配内存块 LPBYTE lpGlobalMemory = (LPBYTE)GlobalLock(hGlobalMemory); // 锁定内存块 for (int i = 0; i 〈 dwLength; i++) // 将"*"复制到全局内存块 *lpGlobalMemory++ = '*'; GlobalUnlock(hGlobalMemory); // 锁定内存块解锁 ::SetClipboardData(CF_TEXT, hGlobalMemory); // 将内存中的数据放置到剪贴板

    DSP和自定义数据格式的使用

　　Windows系统预定义了三个带“DSP”前缀的数据格式：CF_DSPTEXT、CF_DSPBITMAP和CF_DSPMETAFILEPICT。这是一些伪标准格式，用于表示在程序中定义的私有剪贴板数据格式。对于不同的程序，这些格式的规定是不同的，因此这些格式只针对某一具体程序的不同实例才有意义。

　　为使用DSP数据格式，必须确保进程本身与剪贴板拥有者进程同属一个程序。可以调用GetClipboardOwner（）函数来获取剪贴板拥有者窗口句柄，并调用GetClassName（）来获取窗口类名：

HWND hClipOwner = GetClipboardOwner（）; GetClassName（hClipOwner, &ClassName, 255）;

　　如果剪贴板拥有者窗口类名同本进程的窗口类名一致，就可以使用带有DSP前缀的剪贴板数据格式了。
除了使用Windows预定义的剪贴板数据格式外，也可以在程序中使用自定义的数据格式。对于自定义的数据格式lpszFormat，可以调用RegisterClipboardFormat（）函数来登记，并获取其返回的格式标识值：

UINT format = RegisterClipboardFormat（lpszFormat）;

　　对此返回的格式标识值的使用与系统预定义的格式标识是一样的。可以通过GetClipboardFormatName（）函数来获取自定义格式的ASCII名。

　　小结

　　本文主要对Windows编程中的剪贴板机制作了较为深入的讨论，对其中常用的文本、位图、DSP和自定义数据格式的使用方法以及多数据项和延迟提交等重要技术一并做了阐述。并给出了具体的程序示例代码，使读者能够更好的掌握剪贴板机制的使用。

消息，就是指Windows发出的一个通知，告诉应用程序某个事情发生了。例如，单击鼠标、改变窗口尺寸、按下键盘上的一个键都会使Windows发送一个消息给应用程序。消息本身是作为一个记录传递给应用程序的，这个记录中包含了消息的类型以及其他信息。例如，对于单击鼠标所产生的消息来说，这个记录中包含了单击鼠标时的坐标。这个记录类型叫做TMsg，

它在Windows单元中是这样声明的：
type
TMsg = packed record
hwnd: HWND; / /窗口句柄
message: UINT; / /消息常量标识符
wParam: WPARAM ; // 32位消息的特定附加信息
lParam: LPARAM ; // 32位消息的特定附加信息
time: DWORD; / /消息创建时的时间
pt: TPoint; / /消息创建时的鼠标位置
end;

消息中有什么？
是否觉得一个消息记录中的信息像希腊语一样？如果是这样，那么看一看下面的解释：
hwnd 32位的窗口句柄。窗口可以是任何类型的屏幕对象，因为Win32能够维护大多数可视对象的句柄(窗口、对话框、按钮、编辑框等)。
message 用于区别其他消息的常量值，这些常量可以是Windows单元中预定义的常量，也可以是自定义的常量。
wParam 通常是一个与消息有关的常量值，也可能是窗口或控件的句柄。
lParam 通常是一个指向内存中数据的指针。由于W P a r a m、l P a r a m和P o i n t e r都是3 2位的，
因此，它们之间可以相互转换。

WM_NULL = $0000;
WM_CREATE = $0001;
应用程序创建一个窗口
WM_DESTROY = $0002;
一个窗口被销毁
WM_MOVE = $0003;
移动一个窗口
WM_SIZE = $0005;
改变一个窗口的大小
WM_ACTIVATE = $0006;
一个窗口被激活或失去激活状态；
WM_SETFOCUS = $0007;
获得焦点后
WM_KILLFOCUS = $0008;
失去焦点
WM_ENABLE = $000A;
改变enable状态
WM_SETREDRAW = $000B;
设置窗口是否能重画
WM_SETTEXT = $000C;
应用程序发送此消息来设置一个窗口的文本
WM_GETTEXT = $000D;
应用程序发送此消息来复制对应窗口的文本到缓冲区
WM_GETTEXTLENGTH = $000E;
得到与一个窗口有关的文本的长度（不包含空字符）
WM_PAINT = $000F;
要求一个窗口重画自己
WM_CLOSE = $0010;
当一个窗口或应用程序要关闭时发送一个信号
WM_QUERYENDSESSION = $0011;
当用户选择结束对话框或程序自己调用ExitWindows函数
WM_QUIT = $0012;
用来结束程序运行或当程序调用postquitmessage函数
WM_QUERYOPEN = $0013;
当用户窗口恢复以前的大小位置时，把此消息发送给某个图标
WM_ERASEBKGND = $0014;
当窗口背景必须被擦除时（例在窗口改变大小时）
WM_SYSCOLORCHANGE = $0015;
当系统颜色改变时，发送此消息给所有顶级窗口
WM_ENDSESSION = $0016;
当系统进程发出WM_QUERYENDSESSION消息后，此消息发送给应用程序，
通知它对话是否结束
WM_SYSTEMERROR = $0017;
WM_SHOWWINDOW = $0018;
当隐藏或显示窗口是发送此消息给这个窗口
WM_ACTIVATEAPP = $001C;
发此消息给应用程序哪个窗口是激活的，哪个是非激活的；
WM_FONTCHANGE = $001D;
当系统的字体资源库变化时发送此消息给所有顶级窗口
WM_TIMECHANGE = $001E;
当系统的时间变化时发送此消息给所有顶级窗口
WM_CANCELMODE = $001F;
发送此消息来取消某种正在进行的摸态（操作）
WM_SETCURSOR = $0020;
如果鼠标引起光标在某个窗口中移动且鼠标输入没有被捕获时，就发消息给某个窗口
WM_MOUSEACTIVATE = $0021;
当光标在某个非激活的窗口中而用户正按着鼠标的某个键发送此消息给当前窗口
WM_CHILDACTIVATE = $0022;
发送此消息给MDI子窗口当用户点击此窗口的标题栏，或当窗口被激活，移动，改变大小
WM_QUEUESYNC = $0023;
此消息由基于计算机的训练程序发送，通过WH_JOURNALPALYBACK的hook程序
分离出用户输入消息
WM_GETMINMAXINFO = $0024;
此消息发送给窗口当它将要改变大小或位置；
WM_PAINTICON = $0026;
发送给最小化窗口当它图标将要被重画
WM_ICONERASEBKGND = $0027;
此消息发送给某个最小化窗口，仅当它在画图标前它的背景必须被重画
WM_NEXTDLGCTL = $0028;
发送此消息给一个对话框程序去更改焦点位置
WM_SPOOLERSTATUS = $002A;
每当打印管理列队增加或减少一条作业时发出此消息
WM_DRAWITEM = $002B;
当button，combobox，listbox，menu的可视外观改变时发送
此消息给这些空件的所有者
WM_MEASUREITEM = $002C;
当button, combo box, list box, list view control, or menu item 被创建时
发送此消息给控件的所有者
WM_DELETEITEM = $002D;
当the list box 或 combo box 被销毁 或 当 某些项被删除通过LB_DELETESTRING, LB_RESETCONTENT, CB_DELETESTRING, or CB_RESETCONTENT 消息
WM_VKEYTOITEM = $002E;
此消息有一个LBS_WANTKEYBOARDINPUT风格的发出给它的所有者来响应WM_KEYDOWN消息
WM_CHARTOITEM = $002F;
此消息由一个LBS_WANTKEYBOARDINPUT风格的列表框发送给他的所有者来响应WM_CHAR消息
WM_SETFONT = $0030;
当绘制文本时程序发送此消息得到控件要用的颜色
WM_GETFONT = $0031;
应用程序发送此消息得到当前控件绘制文本的字体
WM_SETHOTKEY = $0032;
应用程序发送此消息让一个窗口与一个热键相关连
WM_GETHOTKEY = $0033;
应用程序发送此消息来判断热键与某个窗口是否有关联
WM_QUERYDRAGICON = $0037;
此消息发送给最小化窗口，当此窗口将要被拖放而它的类中没有定义图标，应用程序能返回一个图标或光标的句柄，当用户拖放图标时系统显示这个图标或光标
WM_COMPAREITEM = $0039;
发送此消息来判定combobox或listbox新增加的项的相对位置
WM_GETOBJECT = $003D;
WM_COMPACTING = $0041;
显示内存已经很少了
WM_WINDOWPOSCHANGING = $0046;
发送此消息给那个窗口的大小和位置将要被改变时，来调用setwindowpos函数或其它窗口管理函数
WM_WINDOWPOSCHANGED = $0047;
发送此消息给那个窗口的大小和位置已经被改变时，来调用setwindowpos函数或其它窗口管理函数
WM_POWER = $0048;（适用于16位的windows）
当系统将要进入暂停状态时发送此消息
WM_COPYDATA = $004A;
当一个应用程序传递数据给另一个应用程序时发送此消息
WM_CANCELJOURNAL = $004B;
当某个用户取消程序日志激活状态，提交此消息给程序
WM_NOTIFY = $004E;
当某个控件的某个事件已经发生或这个控件需要得到一些信息时，发送此消息给它的父窗口
WM_INPUTLANGCHANGEREQUEST = $0050;
当用户选择某种输入语言，或输入语言的热键改变
WM_INPUTLANGCHANGE = $0051;
当平台现场已经被改变后发送此消息给受影响的最顶级窗口
WM_TCARD = $0052;
当程序已经初始化windows帮助例程时发送此消息给应用程序
WM_HELP = $0053;
此消息显示用户按下了F1，如果某个菜单是激活的，就发送此消息个此窗口关联的菜单，否则就
发送给有焦点的窗口，如果当前都没有焦点，就把此消息发送给当前激活的窗口
WM_USERCHANGED = $0054;
当用户已经登入或退出后发送此消息给所有的窗口，当用户登入或退出时系统更新用户的具体
设置信息，在用户更新设置时系统马上发送此消息；
WM_NOTIFYFORMAT = $0055;
公用控件，自定义控件和他们的父窗口通过此消息来判断控件是使用ANSI还是UNICODE结构
在WM_NOTIFY消息，使用此控件能使某个控件与它的父控件之间进行相互通信
WM_CONTEXTMENU = $007B;
当用户某个窗口中点击了一下右键就发送此消息给这个窗口
WM_STYLECHANGING = $007C;
当调用SETWINDOWLONG函数将要改变一个或多个 窗口的风格时发送此消息给那个窗口
WM_STYLECHANGED = $007D;
当调用SETWINDOWLONG函数一个或多个 窗口的风格后发送此消息给那个窗口
WM_DISPLAYCHANGE = $007E;
当显示器的分辨率改变后发送此消息给所有的窗口
WM_GETICON = $007F;
此消息发送给某个窗口来返回与某个窗口有关连的大图标或小图标的句柄；
WM_SETICON = $0080;
程序发送此消息让一个新的大图标或小图标与某个窗口关联；
WM_NCCREATE = $0081;
当某个窗口第一次被创建时，此消息在WM_CREATE消息发送前发送；
WM_NCDESTROY = $0082;
此消息通知某个窗口，非客户区正在销毁
WM_NCCALCSIZE = $0083;
当某个窗口的客户区域必须被核算时发送此消息
WM_NCHITTEST = $0084;//移动鼠标，按住或释放鼠标时发生
WM_NCPAINT = $0085;
程序发送此消息给某个窗口当它（窗口）的框架必须被绘制时；
WM_NCACTIVATE = $0086;
此消息发送给某个窗口 仅当它的非客户区需要被改变来显示是激活还是非激活状态；
WM_GETDLGCODE = $0087;
发送此消息给某个与对话框程序关联的控件，widdows控制方位键和TAB键使输入进入此控件
通过响应WM_GETDLGCODE消息，应用程序可以把他当成一个特殊的输入控件并能处理它
WM_NCMOUSEMOVE = $00A0;
当光标在一个窗口的非客户区内移动时发送此消息给这个窗口 //非客户区为：窗体的标题栏及窗
的边框体
WM_NCLBUTTONDOWN = $00A1;
当光标在一个窗口的非客户区同时按下鼠标左键时提交此消息
WM_NCLBUTTONUP = $00A2;
当用户释放鼠标左键同时光标某个窗口在非客户区十发送此消息；
WM_NCLBUTTONDBLCLK = $00A3;
当用户双击鼠标左键同时光标某个窗口在非客户区十发送此消息
WM_NCRBUTTONDOWN = $00A4;
当用户按下鼠标右键同时光标又在窗口的非客户区时发送此消息
WM_NCRBUTTONUP = $00A5;
当用户释放鼠标右键同时光标又在窗口的非客户区时发送此消息
WM_NCRBUTTONDBLCLK = $00A6;
当用户双击鼠标右键同时光标某个窗口在非客户区十发送此消息
WM_NCMBUTTONDOWN = $00A7;
当用户按下鼠标中键同时光标又在窗口的非客户区时发送此消息
WM_NCMBUTTONUP = $00A8;
当用户释放鼠标中键同时光标又在窗口的非客户区时发送此消息
WM_NCMBUTTONDBLCLK = $00A9;
当用户双击鼠标中键同时光标又在窗口的非客户区时发送此消息
WM_KEYFIRST = $0100;
WM_KEYDOWN = $0100;
//按下一个键
WM_KEYUP = $0101;
//释放一个键
WM_CHAR = $0102;
//按下某键，并已发出WM_KEYDOWN， WM_KEYUP消息
WM_DEADCHAR = $0103;
当用translatemessage函数翻译WM_KEYUP消息时发送此消息给拥有焦点的窗口
WM_SYSKEYDOWN = $0104;
当用户按住ALT键同时按下其它键时提交此消息给拥有焦点的窗口；
WM_SYSKEYUP = $0105;
当用户释放一个键同时ALT 键还按着时提交此消息给拥有焦点的窗口
WM_SYSCHAR = $0106;
当WM_SYSKEYDOWN消息被TRANSLATEMESSAGE函数翻译后提交此消息给拥有焦点的窗口
WM_SYSDEADCHAR = $0107;
当WM_SYSKEYDOWN消息被TRANSLATEMESSAGE函数翻译后发送此消息给拥有焦点的窗口
WM_KEYLAST = $0108;
WM_INITDIALOG = $0110;
在一个对话框程序被显示前发送此消息给它，通常用此消息初始化控件和执行其它任务
WM_COMMAND = $0111;
当用户选择一条菜单命令项或当某个控件发送一条消息给它的父窗口，一个快捷键被翻译
WM_SYSCOMMAND = $0112;
当用户选择窗口菜单的一条命令或当用户选择最大化或最小化时那个窗口会收到此消息
WM_TIMER = $0113; //发生了定时器事件
WM_HSCROLL = $0114;
当一个窗口标准水平滚动条产生一个滚动事件时发送此消息给那个窗口，也发送给拥有它的控件
WM_VSCROLL = $0115;
当一个窗口标准垂直滚动条产生一个滚动事件时发送此消息给那个窗口也，发送给拥有它的控件 WM_INITMENU = $0116;
当一个菜单将要被激活时发送此消息，它发生在用户菜单条中的某项或按下某个菜单键，它允许程序在显示前更改菜单
WM_INITMENUPOPUP = $0117;
当一个下拉菜单或子菜单将要被激活时发送此消息，它允许程序在它显示前更改菜单，而不要改变全部
WM_MENUSELECT = $011F;
当用户选择一条菜单项时发送此消息给菜单的所有者（一般是窗口）
WM_MENUCHAR = $0120;
当菜单已被激活用户按下了某个键（不同于加速键），发送此消息给菜单的所有者；
WM_ENTERIDLE = $0121;
当一个模态对话框或菜单进入空载状态时发送此消息给它的所有者，一个模态对话框或菜单进入空载状态就是在处理完一条或几条先前的消息后没有消息它的列队中等待
WM_MENURBUTTONUP = $0122;
WM_MENUDRAG = $0123;
WM_MENUGETOBJECT = $0124;
WM_UNINITMENUPOPUP = $0125;
WM_MENUCOMMAND = $0126;
WM_CHANGEUISTATE = $0127;
WM_UPDATEUISTATE = $0128;
WM_QUERYUISTATE = $0129;
WM_CTLCOLORMSGBOX = $0132;
在windows绘制消息框前发送此消息给消息框的所有者窗口，通过响应这条消息，所有者窗口可以通过使用给定的相关显示设备的句柄来设置消息框的文本和背景颜色
WM_CTLCOLOREDIT = $0133;
当一个编辑型控件将要被绘制时发送此消息给它的父窗口；通过响应这条消息，所有者窗口可以通过使用给定的相关显示设备的句柄来设置编辑框的文本和背景颜色
WM_CTLCOLORLISTBOX = $0134;
当一个列表框控件将要被绘制前发送此消息给它的父窗口；通过响应这条消息，所有者窗口可以通过使用给定的相关显示设备的句柄来设置列表框的文本和背景颜色
WM_CTLCOLORBTN = $0135;
当一个按钮控件将要被绘制时发送此消息给它的父窗口；通过响应这条消息，所有者窗口可以通过使用给定的相关显示设备的句柄来设置按纽的文本和背景颜色
WM_CTLCOLORDLG = $0136;
当一个对话框控件将要被绘制前发送此消息给它的父窗口；通过响应这条消息，所有者窗口可以通过使用给定的相关显示设备的句柄来设置对话框的文本背景颜色
WM_CTLCOLORSCROLLBAR= $0137;
当一个滚动条控件将要被绘制时发送此消息给它的父窗口；通过响应这条消息，所有者窗口可以通过使用给定的相关显示设备的句柄来设置滚动条的背景颜色
WM_CTLCOLORSTATIC = $0138;
当一个静态控件将要被绘制时发送此消息给它的父窗口；通过响应这条消息，所有者窗口可以通过使用给定的相关显示设备的句柄来设置静态控件的文本和背景颜色
WM_MOUSEFIRST = $0200;
WM_MOUSEMOVE = $0200;
// 移动鼠标
WM_LBUTTONDOWN = $0201;
//按下鼠标左键
WM_LBUTTONUP = $0202;
//释放鼠标左键
WM_LBUTTONDBLCLK = $0203;
//双击鼠标左键
WM_RBUTTONDOWN = $0204;
//按下鼠标右键
WM_RBUTTONUP = $0205;
//释放鼠标右键
WM_RBUTTONDBLCLK = $0206;
//双击鼠标右键
WM_MBUTTONDOWN = $0207;
//按下鼠标中键
WM_MBUTTONUP = $0208;
//释放鼠标中键
WM_MBUTTONDBLCLK = $0209;
//双击鼠标中键
WM_MOUSEWHEEL = $020A;
当鼠标轮子转动时发送此消息个当前有焦点的控件
WM_MOUSELAST = $020A;
WM_PARENTNOTIFY = $0210;
当MDI子窗口被创建或被销毁，或用户按了一下鼠标键而光标在子窗口上时发送此消息给它的父窗口
WM_ENTERMENULOOP = $0211;
发送此消息通知应用程序的主窗口that已经进入了菜单循环模式
WM_EXITMENULOOP = $0212;
发送此消息通知应用程序的主窗口that已退出了菜单循环模式
WM_NEXTMENU = $0213;
WM_SIZING = 532;
当用户正在调整窗口大小时发送此消息给窗口；通过此消息应用程序可以监视窗口大小和位置也可以修改他们
WM_CAPTURECHANGED = 533;
发送此消息 给窗口当它失去捕获的鼠标时；
WM_MOVING = 534;
当用户在移动窗口时发送此消息，通过此消息应用程序可以监视窗口大小和位置也可以修改他们；
WM_POWERBROADCAST = 536;
此消息发送给应用程序来通知它有关电源管理事件；
WM_DEVICECHANGE = 537;
当设备的硬件配置改变时发送此消息给应用程序或设备驱动程序
WM_IME_STARTCOMPOSITION = $010D;
WM_IME_ENDCOMPOSITION = $010E;
WM_IME_COMPOSITION = $010F;
WM_IME_KEYLAST = $010F;
WM_IME_SETCONTEXT = $0281;
WM_IME_NOTIFY = $0282;
WM_IME_CONTROL = $0283;
WM_IME_COMPOSITIONFULL = $0284;
WM_IME_SELECT = $0285;
WM_IME_CHAR = $0286;
WM_IME_REQUEST = $0288;
WM_IME_KEYDOWN = $0290;
WM_IME_KEYUP = $0291;
WM_MDICREATE = $0220;
应用程序发送此消息给多文档的客户窗口来创建一个MDI 子窗口
WM_MDIDESTROY = $0221;
应用程序发送此消息给多文档的客户窗口来关闭一个MDI 子窗口
WM_MDIACTIVATE = $0222;
应用程序发送此消息给多文档的客户窗口通知客户窗口激活另一个MDI子窗口，当客户窗口收到此消息后，它发出WM_MDIACTIVE消息给MDI子窗口（未激活）激活它；
WM_MDIRESTORE = $0223;
程序 发送此消息给MDI客户窗口让子窗口从最大最小化恢复到原来大小
WM_MDINEXT = $0224;
程序 发送此消息给MDI客户窗口激活下一个或前一个窗口
WM_MDIMAXIMIZE = $0225;
程序发送此消息给MDI客户窗口来最大化一个MDI子窗口；
WM_MDITILE = $0226;
程序 发送此消息给MDI客户窗口以平铺方式重新排列所有MDI子窗口
WM_MDICASCADE = $0227;
程序 发送此消息给MDI客户窗口以层叠方式重新排列所有MDI子窗口
WM_MDIICONARRANGE = $0228;
程序 发送此消息给MDI客户窗口重新排列所有最小化的MDI子窗口
WM_MDIGETACTIVE = $0229;
程序 发送此消息给MDI客户窗口来找到激活的子窗口的句柄
WM_MDISETMENU = $0230;
程序 发送此消息给MDI客户窗口用MDI菜单代替子窗口的菜单
WM_ENTERSIZEMOVE = $0231;
WM_EXITSIZEMOVE = $0232;
WM_DROPFILES = $0233;
WM_MDIREFRESHMENU = $0234;
WM_MOUSEHOVER = $02A1;
WM_MOUSELEAVE = $02A3;
WM_CUT = $0300;
程序发送此消息给一个编辑框或combobox来删除当前选择的文本
WM_COPY = $0301;
程序发送此消息给一个编辑框或combobox来复制当前选择的文本到剪贴板
WM_PASTE = $0302;
程序发送此消息给editcontrol或combobox从剪贴板中得到数据
WM_CLEAR = $0303;
程序发送此消息给editcontrol或combobox清除当前选择的内容；
WM_UNDO = $0304;
程序发送此消息给editcontrol或combobox撤消最后一次操作
WM_RENDERFORMAT = $0305；

WM_RENDERALLFORMATS = $0306;
WM_DESTROYCLIPBOARD = $0307;
当调用ENPTYCLIPBOARD函数时 发送此消息给剪贴板的所有者
WM_DRAWCLIPBOARD = $0308;
当剪贴板的内容变化时发送此消息给剪贴板观察链的第一个窗口；它允许用剪贴板观察窗口来
显示剪贴板的新内容；
WM_PAINTCLIPBOARD = $0309;
当剪贴板包含CF_OWNERDIPLAY格式的数据并且剪贴板观察窗口的客户区需要重画；
WM_VSCROLLCLIPBOARD = $030A;
WM_SIZECLIPBOARD = $030B;
当剪贴板包含CF_OWNERDIPLAY格式的数据并且剪贴板观察窗口的客户区域的大小已经改变是此消息通过剪贴板观察窗口发送给剪贴板的所有者；
WM_ASKCBFORMATNAME = $030C;
通过剪贴板观察窗口发送此消息给剪贴板的所有者来请求一个CF_OWNERDISPLAY格式的剪贴板的名字
WM_CHANGECBCHAIN = $030D;
当一个窗口从剪贴板观察链中移去时发送此消息给剪贴板观察链的第一个窗口；
WM_HSCROLLCLIPBOARD = $030E;
此消息通过一个剪贴板观察窗口发送给剪贴板的所有者 ；它发生在当剪贴板包含CFOWNERDISPALY格式的数据并且有个事件在剪贴板观察窗的水平滚动条上；所有者应滚动剪贴板图象并更新滚动条的值；
WM_QUERYNEWPALETTE = $030F;
此消息发送给将要收到焦点的窗口，此消息能使窗口在收到焦点时同时有机会实现他的逻辑调色板
WM_PALETTEISCHANGING= $0310;
当一个应用程序正要实现它的逻辑调色板时发此消息通知所有的应用程序
WM_PALETTECHANGED = $0311;
此消息在一个拥有焦点的窗口实现它的逻辑调色板后发送此消息给所有顶级并重叠的窗口，以此来改变系统调色板
WM_HOTKEY = $0312;
当用户按下由REGISTERHOTKEY函数注册的热键时提交此消息
WM_PRINT = 791;
应用程序发送此消息仅当WINDOWS或其它应用程序发出一个请求要求绘制一个应用程序的一部分；
WM_PRINTCLIENT = 792;
WM_HANDHELDFIRST = 856;
WM_HANDHELDLAST = 863;
WM_PENWINFIRST = $0380;
WM_PENWINLAST = $038F;
WM_COALESCE_FIRST = $0390;
WM_COALESCE_LAST = $039F;
WM_DDE_FIRST = $03E0;
WM_DDE_INITIATE = WM_DDE_FIRST + 0;
一个DDE客户程序提交此消息开始一个与服务器程序的会话来响应那个指定的程序和主题名；
WM_DDE_TERMINATE = WM_DDE_FIRST + 1;
一个DDE应用程序（无论是客户还是服务器）提交此消息来终止一个会话；
WM_DDE_ADVISE = WM_DDE_FIRST + 2;
一个DDE客户程序提交此消息给一个DDE服务程序来请求服务器每当数据项改变时更新它
WM_DDE_UNADVISE = WM_DDE_FIRST + 3;
一个DDE客户程序通过此消息通知一个DDE服务程序不更新指定的项或一个特殊的剪贴板格式的项
WM_DDE_ACK = WM_DDE_FIRST + 4;
此消息通知一个DDE（动态数据交换）程序已收到并正在处理WM_DDE_POKE, WM_DDE_EXECUTE, WM_DDE_DATA, WM_DDE_ADVISE, WM_DDE_UNADVISE, or WM_DDE_INITIAT消息
WM_DDE_DATA = WM_DDE_FIRST + 5;
一个DDE服务程序提交此消息给DDE客户程序来传递个一数据项给客户或通知客户的一条可用数据项
WM_DDE_REQUEST = WM_DDE_FIRST + 6;
一个DDE客户程序提交此消息给一个DDE服务程序来请求一个数据项的值；
WM_DDE_POKE = WM_DDE_FIRST + 7;
一个DDE客户程序提交此消息给一个DDE服务程序，客户使用此消息来请求服务器接收一个未经同意的数据项；服务器通过答复WM_DDE_ACK消息提示是否它接收这个数据项；
WM_DDE_EXECUTE = WM_DDE_FIRST + 8;
一个DDE客户程序提交此消息给一个DDE服务程序来发送一个字符串给服务器让它象串行命令一样被处理，服务器通过提交WM_DDE_ACK消息来作回应；
WM_DDE_LAST = WM_DDE_FIRST + 8;
WM_APP = $8000;
WM_USER = $0400;
此消息能帮助应用程序自定义私有消息；
/////////////////////////////////////////////////////////////////////
通知消息(Notification message)是指这样一种消息，一个窗口内的子控件发生了一些事情，需要通知父窗口。通知消息只适用于标准的窗口控件如按钮、列表框、组合框、编辑框，以及Windows 95公共控件如树状视图、列表视图等。例如，单击或双击一个控件、在控件中选择部分文本、操作控件的滚动条都会产生通知消息。
按扭
B N _ C L I C K E D //用户单击了按钮
B N _ D I S A B L E //按钮被禁止
B N _ D O U B L E C L I C K E D //用户双击了按钮
B N _ H I L I T E //用户加亮了按钮
B N _ PA I N T按钮应当重画
B N _ U N H I L I T E加亮应当去掉
组合框
C B N _ C L O S E U P组合框的列表框被关闭
C B N _ D B L C L K用户双击了一个字符串
C B N _ D R O P D O W N组合框的列表框被拉出
C B N _ E D I T C H A N G E用户修改了编辑框中的文本
C B N _ E D I T U P D AT E编辑框内的文本即将更新
C B N _ E R R S PA C E组合框内存不足
C B N _ K I L L F O C U S组合框失去输入焦点
C B N _ S E L C H A N G E在组合框中选择了一项
C B N _ S E L E N D C A N C E L用户的选择应当被取消
C B N _ S E L E N D O K用户的选择是合法的
C B N _ S E T F O C U S组合框获得输入焦点
编辑框
E N _ C H A N G E编辑框中的文本己更新
E N _ E R R S PA C E编辑框内存不足
E N _ H S C R O L L用户点击了水平滚动条
E N _ K I L L F O C U S编辑框正在失去输入焦点
E N _ M A X T E X T插入的内容被截断
E N _ S E T F O C U S编辑框获得输入焦点
E N _ U P D AT E编辑框中的文本将要更新
E N _ V S C R O L L用户点击了垂直滚动条消息含义
列表框
L B N _ D B L C L K用户双击了一项
L B N _ E R R S PA C E列表框内存不够
L B N _ K I L L F O C U S列表框正在失去输入焦点
L B N _ S E L C A N C E L选择被取消
L B N _ S E L C H A N G E选择了另一项
L B N _ S E T F O C U S列表框获得输入焦点

    WINDOWS的消息处理机制为了能在应用程序中监控系统的各种事件消息，提供了挂接 各种反调函数(HOOK)的功能。这种挂钩函数(HOOK)类似扩充中断驱动程序，挂钩上 可以挂接多个反调函数构成一个挂接函数链。系统产生的各种消息首先被送到各种 挂接函数，挂接函数根据各自的功能对消息进行监视、修改和控制等，然后交还控 制权或将消息传递给下一个挂接函数以致最终达到窗口函数。WINDOW系统的这种反 调函数挂接方法虽然会略加影响到系统的运行效率，但在很多场合下是非常有用 的，通过合理有效地利用键盘事件的挂钩函数监控机制可以达到预想不到的良好效 果。
一、在WINDOWS键盘事件上挂接监控函数的方法
WINDOW下可进行挂接的过滤函数包括11种：
WH_CALLWNDPROC 窗口函数的过滤函数
WH_CBT 计算机培训过滤函数
WH_DEBUG 调试过滤函数
WH_GETMESSAGE 获取消息过滤函数
WH_HARDWARE 硬件消息过滤函数
WH_JOURNALPLAYBACK 消息重放过滤函数
WH_JOURNALRECORD 消息记录过滤函数
WH_MOUSE 鼠标过滤函数
WH_MSGFILTER 消息过滤函数
WH_SYSMSGFILTER 系统消息过滤函数
WH_KEYBOARD 键盘过滤函数
其中键盘过滤函数是最常用最有用的过滤函数类型，不管是哪一种类型的过滤函 数，其挂接的基本方法都是相同的。 WINDOW调用挂接的反调函数时总是先调用挂接链首的那个函数，因此必须将键盘挂 钩函数利用函数SetWindowsHookEx()将其挂接在函数链首。至于消息是否传递给函 数链的下一个函数是由每个具体函数功能确定的，如果消息需要传统给下一个函 数，可调用API函数的CallNextHookEx()来实现，如果不传递直接返回即可。 挂接函数可以是用来监控所有线程消息的全局性函数，也可以是单独监控某一线程 的局部性函数。如果挂接函数是局部函数，可以将它放到一个.DLL动态链接库中， 也可以放在一个局部模块中；如果挂接函数是全局的，那么必须将其放在一个.DLL 动态链接库中。挂接函数必须严格按照下述格式进行声明，以键盘挂钩函数为例：
int FAR PASCAL KeyboardProc( int nCode,WORD wParam,DWORD lParam) 其中KeyboardProc为定义挂接函数名，该函数必须在模块定义文件中利用EXPORTS命 令进行说明；nCode决定挂接函数是否对当前消息进行处理；wParam和lParam为具体 的消息内容。

二、键盘事件挂接函数的安装与下载 在程序中可以利用函数SetWindowsHookEx()来挂接过滤函数，在挂接函数时必须指 出该挂接函数的类型、函数的入口地址以及函数是全局性的还是局部性的，挂接函 数的具体调用格式如下：
SetWindowsHookEx(iType,iProc,hInst,iCode) 其中iType为挂接函数类型，键盘类型为WH_KEYBOARD,iProc为挂接函数地址，hInst 为挂接函数链接库实例句柄，iCode为监控代码－0表示全局性函数。 如果挂接函数需要将消息传递给下一个过滤函数，则在该挂接函数返回前还需要调 用一次CallNextHookEx()函数，当需要下载挂接函数时，只要调用一次 UnhookWindowsHookEx(iProc)函数即可实现。 如果函数是全局性的，那么它必须放在一个.DLL动态链接库中，这时该函数调用方 法可以和其它普通.DLL函数一样有三种：
1.在DEF定义文件中直接用函数名或序号说明： EXPORTS WEP @1 RESIDENTNAME InitHooksDll @2 InstallFilter @3 KeyboardProc @4 用序号说明格式为：链接库名.函数名(如本例中说明方法为KEYDLL.KeyboardProc)。
2.在应用程序中利用函数直接调用： 首先在应用程序中利用LoadLibrary(LPSTR "链接库名")将动态链接库装入，并取得 装载库模块句柄hInst,然后直接利用GetProcAddress(HINSTANCE hInst,LPSTR "函 数过程名")获取函数地址，然后直接调用该地址即可，程序结束前利用函数 FreeLibrary( )释放装入的动态链接库即可。
3.利用输入库.LIB方法 利用IMPLIB.EXE程序在建立动态链接库的同时建立相应的输入库.LIB，然后直接在 项目文件中增加该输入库。

三、WINDOWS挂钩监控函数的实现步骤 WINDOWS挂钩函数只有放在动态链接库DLL中才能实现所有事件的监控功能。在.DLL 中形成挂钩监控函数基本方法及其基本结构如下：

１、首先声明DLL中的变量和过程；

２、然后编制DLL主模块LibMain()，建立模块实例；

３、建立系统退出DLL机制WEP()函数；

４、完成DLL初始化函数InitHooksDll(),传递主窗口程序句柄；

５、编制挂钩安装和下载函数InstallFilter()；

６、编制挂钩函数KeyboardProc()，在其中设置监控功能，并确定继续调下一个钩 子函数还是直接返回WINDOWS应用程序。

７、在WINDOWS主程序中需要初始化DLL并安装相应挂钩函数，由挂接的钩子函数负 责与主程序通信；

８、在不需要监控时由下载功能卸掉挂接函数。

四、WINDOWS下键盘挂钩监控函数的应用技术 目前标准的104 键盘上都有两个特殊的按键，其上分别用WINDOW程序徽标和鼠标下 拉列表标识，本文暂且分别称为Micro左键和Micro右键，前者用来模拟鼠标左键激 活开始菜单，后者用来模拟鼠标右键激活属性菜单。这两个特殊按键只有在按下后 立即抬起即完成 CLICK过程才能实现其功能，并且没有和其它按键进行组合使用。 由于WINDOWS 系统中将按键划分得更加详细，使应用程序中很难灵活定义自己的专 用快捷键，比如在开发.IME等应用程序时很难找到不与WORD8.0等其它应用程序冲突 的功能按键。如果将标准104键盘中的这两个特殊按键作为模拟CTRL和ALT 等专用按 键，使其和其它按键组合，就可以在自己的应用程序中自由地设置专用功能键，为 应用程序实现各种功能快捷键提供灵活性。正常情况下WINDOWS 键盘事件驱动程序 并不将这两个按键的消息进行正常解释，这就必须利用键盘事件的挂钩监控函数来 实现其特定的功能。其方法如下：

１、首先编制如下一个简单动态链接库程序，并编译成DLL文件。 #include "windows.h"
int FAR PASCAL LibMain(HANDLE hModule,UINT wDataSeg, UINT cbHeapSize,LPSTR lpszCmdLine);
int WINAPI WEP(int bSystemExit);
int WINAPI InitHooksDll(HWND hwndMainWindow);
int WINAPI InstallFilter(BOOL nCode);
LRESULT CALLBACK KeyHook(int nCode,WORD wParam,DWORD lParam);
static HANDLE hInstance; // 全局句柄
static HWND hWndMain; // 主窗口句柄
static int InitCalled=0; // 初始化标志
static HHOOK hKeyHook;
FARPROC lpfnKeyHook=(FARPROC)KeyHook;
BOOL HookStates=FALSE;
int FAR PASCAL LibMain( HANDLE hModule, UINT wDataSeg, UINT cbHeapSize, LPSTR lpszCmdLine)
{
if (cbHeapSize!=0)
UnlockData(0);
hInstance = hModule;
return 1;
}
int WINAPI WEP (int bSystemExit)
{ return 1;}
int WINAPI InitHooksDll(HWND hwndMainWindow)
{
hWndMain = hwndMainWindow;
InitCalled = 1;
return (0);
}

int WINAPI InstallFilter(BOOL nCode)
{ if (InitCalled==0)
return (-1);
if (nCode==TRUE)
{
hKeyHook=SetWindowsHookEx(WH_KEYBOARD, (HOOKPROC)lpfnKeyHook,hInstance,0);
HookStates=TRUE;
}
else
{
UnhookWindowsHookEx(hKeyHook);
HookStates=FALSE;
}
return(0);
}

LRESULT CALLBACK KeyHook(int nCode,WORD wParam,DWORD lParam)
{
static BOOL msflag=FALSE;
if(nCode>=0)
{
if(HookStates==TRUE)
{
if((wParam==0xff)|| //WIN3.X下按键值
(wParam==0x5b)||(wParam==0x5c)){//WIN95下按键值
if((i==0x15b)||(i==0x15c)){ //按键按下处理
msflag=TRUE;
PostMessage(hWndMain,0x7fff,0x1,0x3L);
}
else if((i==0xc15b)||(i==0xc15c)){//按键抬起处理 msflag=FALSE;
PostMessage(hWndMain,0x7fff,0x2,0x3L);
}
}
}
}
return((int)CallNextHookEx
(hKeyHook,nCode,wParam,lParam));
}
该程序的主要功能是监控键盘按键消息，将两个特殊按键Micro按下和抬起消息转换 成自定义类型的消息，并将自定义消息发送给应用程序主窗口函数。

２、在应用程序主函数中建立窗口后，调用InitHooksDll()函数来初始化动态链接 库，并将应用程序主窗口句柄传递给链接库，然后调用InstallFilter()函数挂接键 盘事件监控回调函数。
InitHooksDll(hIMEWnd); //初始化DLL
InstallFilter(TRUE); //安装键盘回调函数

３、在应用程序主窗口函数处理自定义消息时，保存Micro按键的状态，供组合按键 处理时判断使用。
switch (iMessage)
{
case 0x7fff: //自定义消息类型
if(lParam==0x3L)
{//设置Micro键的状态
if(wParam==0x1)
MicroFlag=TRUE;
else if(wParam==0x2)
MicroFlag=FALSE;
}
break;

４、在进行按键组合处理时，首先判断Micro键是否按下，然后再进行其它按键的判 断处理。
case WM_KEYDOWN: // 按键按下处理
if(MicroFlag==TRUE)
{
//Micro键按下
if((BYTE)HIBYTE(wParam)==0x5b)
{
//Micro+"["组合键 ......//按键功能处理 }
else if((BYTE)HIBYTE(wParam)==0x5d)
{
//Micro+"]"组合键 ......//按键功能处理 } } break;

５、当应用程序退出时应注意下载键盘监控函数，即调用InstallFilter(FALSE)函 数一次。

６、利用本文提供的方法设置自己的应用程序功能按键，在保证程序功能按键不会 与其它系统发生冲突的同时，有效地利用了系统中现有资源，而且在实现应用程序 功能的同时灵活应用了系统中提供的各种功能调用。

cron服务配置祥解

作者：Fred Huang 出处：www.xiaoxiang.net

刚做了一个备份的模块，后来师傅提示最好再加一个自动备份的功能，于是研究起来cron这个服务来。
cron 是linux的内置服务，但它不自动起来，可以用以下的方法启动、关闭这个服务：

引用:

/sbin/service crond start //启动服务 /sbin/service crond stop //关闭服务 /sbin/service crond restart //重启服务 /sbin/service crond reload //重新载入配置

你也可以将这个服务在系统启动的时候也自动启动：

引用:

在/etc/rc.d/rc.local这个脚本的末尾加上： /sbin/service crond start

现在cron这个服务已经在进程里面了，我们就可以用这个服务了，cron服务提供以下几种接口供大家使用：

1.直接用crontab命令编辑
cron服务提供crontab命令来设定cron服务的，以下是这个命令的一些参数与说明：

引用:

crontab -u //设定某个用户的cron服务，一般root用户在执行这个命令的时候需要此参数 crontab -l //列出某个用户cron服务的详细内容 crontab -r //删除没个用户的cron服务 crontab -e //编辑某个用户的cron服务

比如说root查看自己的cron设置：

引用:

crontab -u root -l

再例如，root想删除fred的cron设置：

引用:

crontab -u fred -r

在编辑cron服务时，编辑的内容有一些格式和约定，输入：

引用:

crontab -u root -e

进入vi编辑模式，编辑的内容一定要符合下面的格式：

引用:

*/1 * * * * ls >> /tmp/ls.txt

这个格式的前一部分是对时间的设定，后面一部分是要执行的命令，如果要执行的命令太多，可以把这些命令写到一个脚本里面，然后在这里直接调用这个脚本就可以了，调用的时候记得写出命令的完整路径。时间的设定我们有一定的约定，前面五个*号代表五个数字，数字的取值范围和含义如下：

引用:

分钟　（0-59） 小時　（0-23） 日期　（1-31） 月份　（1-12） 星期　（0-6）//0代表星期天

除了数字还有几个个特殊的符号就是"*"、"/"和"-"、","，*代表所有的取值范围内的数字，"/"代表每的意思,"*/5"表示每5个单位，"-"代表从某个数字到某个数字,","分开几个离散的数字。以下举几个例子说明问题：

引用:

每天早上6点 0 6 * * * echo "Good morning." >> /tmp/test.txt //注意单纯echo，从屏幕上看不到任何输出，因为cron把任何输出都email到root的信箱了。 每两个小时 0 */2 * * * echo "Have a break now." >> /tmp/test.txt 晚上11点到早上8点之间每两个小时，早上八点 0 23-7/2，8 * * * echo "Have a good dream：）" >> /tmp/test.txt 每个月的4号和每个礼拜的礼拜一到礼拜三的早上11点 0 11 4 * 1-3 command line 1月1日早上4点 0 4 1 1 * command line

每次编辑完某个用户的cron设置后，cron自动在/var/spool/cron下生成一个与此用户同名的文件，此用户的cron信息都记录在这个文件中，这个文件是不可以直接编辑的，只可以用crontab -e 来编辑。cron启动后每过一份钟读一次这个文件，检查是否要执行里面的命令。因此此文件修改后不需要重新启动cron服务。

2.编辑/etc/crontab 文件配置cron
cron服务每分钟不仅要读一次/var/spool/cron内的所有文件，还需要读一次/etc/crontab,因此我们配置这个文件也能运用cron服务做一些事情。用crontab配置是针对某个用户的，而编辑/etc/crontab是针对系统的任务。此文件的文件格式是：

引用:

SHELL=/bin/bash PATH=/sbin:/bin:/usr/sbin:/usr/bin MAILTO=root //如果出现错误，或者有数据输出，数据作为邮件发给这个帐号 HOME=/ # run-parts 01 * * * * root run-parts /etc/cron.hourly //每个小时去执行一遍/etc/cron.hourly内的脚本 02 4 * * * root run-parts /etc/cron.daily //每天去执行一遍/etc/cron.daily内的脚本 22 4 * * 0 root run-parts /etc/cron.weekly //每星期去执行一遍/etc/cron.weekly内的脚本 42 4 1 * * root run-parts /etc/cron.monthly //每个月去执行一遍/etc/cron.monthly内的脚本 使用者 运行的路径

大家注意"run-parts"这个参数了，如果去掉这个参数的话，后面就可以写要运行的某个脚本名，而不是文件夹名了。

http://www.pinvoke.net/

http://www.developer.com/net/csharp/article.php/3359891

import java.io.*;
public class TestRead {

 public static void main(String[] args)
 throws IOException//是系统提示才写上的。不懂为什么。
  {
  byte f = 1;
  byte b = 2;
  byte c = 3;
  byte[] a={f,b,c};
  
  File file = new File("c:\\MyClass.txt");
  FileOutputStream out=new FileOutputStream("c:\\MyClass.txt");
  
  
  out.write(a);// 这个方法只能接受数组形式。
  out.close();
  }
}

写的不像是面象对象的东西。～：（

首先让我们看两个特殊的符号'^'和'$'。他们的作用是分别指出一个字符串的开始和结束。例子如下：

"^The"：表示所有以"The"开始的字符串（"There"，"The cat"等）；
"of despair$"：表示所以以"of despair"结尾的字符串；
"^abc$"：表示开始和结尾都是"abc"的字符串——呵呵，只有"abc"自己了；
"notice"：表示任何包含"notice"的字符串。

象最后那个例子，如果你不使用两个特殊字符，你就在表示要查找的串在被查找串的任意部分——你并
不把它定位在某一个顶端。

其它还有'*'，'+'和'?'这三个符号，表示一个或一序列字符重复出现的次数。它们分别表示“没有或
更多”，“一次或更多”还有“没有或一次”。下面是几个例子：

"ab*"：表示一个字符串有一个a后面跟着零个或若干个b。（"a", "ab", "abbb",……）；
"ab+"：表示一个字符串有一个a后面跟着至少一个b或者更多；
"ab?"：表示一个字符串有一个a后面跟着零个或者一个b；
"a?b+$"：表示在字符串的末尾有零个或一个a跟着一个或几个b。

你也可以使用范围，用大括号括起，用以表示重复次数的范围。

"ab{2}"：表示一个字符串有一个a跟着2个b（"abb"）；
"ab{2,}"：表示一个字符串有一个a跟着至少2个b；
"ab{3,5}"：表示一个字符串有一个a跟着3到5个b。

请注意，你必须指定范围的下限（如："{0,2}"而不是"{,2}"）。还有，你可能注意到了，'*'，'+'和
'?'相当于"{0,}"，"{1,}"和"{0,1}"。
还有一个'¦'，表示“或”操作：

"hi¦hello"：表示一个字符串里有"hi"或者"hello"；
"(b¦cd)ef"：表示"bef"或"cdef"；
"(a¦b)*c"：表示一串"a""b"混合的字符串后面跟一个"c"；

'.'可以替代任何字符：

"a.[0-9]"：表示一个字符串有一个"a"后面跟着一个任意字符和一个数字；
"^.{3}$"：表示有任意三个字符的字符串（长度为3个字符）；

方括号表示某些字符允许在一个字符串中的某一特定位置出现：

"[ab]"：表示一个字符串有一个"a"或"b"（相当于"a¦b"）；
"[a-d]"：表示一个字符串包含小写的'a'到'd'中的一个（相当于"a¦b¦c¦d"或者"[abcd]"）；
"^[a-zA-Z]"：表示一个以字母开头的字符串；
"[0-9]%"：表示一个百分号前有一位的数字；
",[a-zA-Z0-9]$"：表示一个字符串以一个逗号后面跟着一个字母或数字结束。

你也可以在方括号里用'^'表示不希望出现的字符，'^'应在方括号里的第一位。（如："%[^a-zA-Z]%"表
示两个百分号中不应该出现字母）。

为了逐字表达，你必须在"^.$()¦*+?{\"这些字符前加上转移字符'\'。

请注意在方括号中，不需要转义字符。

正则表达式的基本语法

首先，让我们看看两个特别的字符：’^’ 和 ‘$’ 他们是分别用来匹配字符串的开始和结束，一下分别举例说明


"^The": 匹配以 "The"开头的字符串;
"of despair$": 匹配以 "of despair" 结尾的字符串;
"^abc$": 匹配以abc开头和以abc结尾的字符串，实际上是只有abc与之匹配
"notice": 匹配包含notice的字符串


你可以看见如果你没有用我们提到的两个字符（最后一个例子），就是说 模式（正则表达式） 可以出现在被检验字符串的任何地方，你没有把他锁定到两边
这里还有几个字符 '*', '+',和 '?', 他们用来表示一个字符可以出现的次数或者顺序. 他们分别表示："zero or more", "one or more", and "zero or one." 这里是一些例子:


"ab*": 匹配字符串a和0个或者更多b组成的字符串("a", "ab", "abbb", etc.);
"ab+": 和上面一样，但最少有一个b ("ab", "abbb", etc.);
"ab?":匹配0个或者一个b;
"a?b+$": 匹配以一个或者0个a再加上一个以上的b结尾的字符串.


你也可以在大括号里面限制字符出现的个数，比如


"ab{2}": 匹配一个a后面跟两个b（一个也不能少）("abb");
"ab{2,}": 最少更两个b("abb", "abbbb", etc.);
"ab{3,5}": 2－5个b("abbb", "abbbb", or "abbbbb").



你还要注意到你必须总是指定 (i.e, "{0,2}", not "{,2}").同样，你必须注意到, '*', '+', 和'?' 分别和一下三个范围标注是一样的，"{0,}", "{1,}", 和 "{0,1}"。

现在把一定数量的字符放到小括号里，比如：


"a(bc)*": 匹配 a 后面跟0个或者一个"bc";
"a(bc){1,5}": 一个到5个 "bc."


还有一个字符 '│', 相当于OR 操作:


"hi│hello": 匹配含有"hi" 或者 "hello" 的 字符串;
"(b│cd)ef": 匹配含有 "bef" 或者 "cdef"的字符串;
"(a│b)*c": 匹配含有这样 - 多个（包括0个）a或b，后面跟一个c
的字符串 的字符串;


一个点('.')可以代表所有的 单一字符:


"a.[0-9]": 一个a跟一个字符再跟一个数字的 （含有这样一个字符串的字符串将被匹配，以后省略此括号）
"^.{3}$": 以三个字符结尾 .


中括号括住的内容只匹配一个 单一的字符


"[ab]": 匹配单个的 a 或者 b ( 和 "a│b" 一样);
"[a-d]": 匹配'a' 到'd'的单个字符 (和"a│b│c│d" 还有 "[abcd]"效果一样);
"^[a-zA-Z]": 匹配以字母开头的字符串
"[0-9]%": 匹配含有 形如 x％ 的字符串
",[a-zA-Z0-9]$": 匹配以逗号在加一个数字或字母结尾的字符串


你也可以把你不想要得字符列在中括号里，你只需要在总括号里面使用'^' 作为开头 (i.e., "%[^a-zA-Z]%" 匹配含有 两个百分号里面有一个非字母 的字符串).

为了能够解释，但"^.[$()│*+?{\"作为有特殊意义的字符的时候，你必须在这些字符面前加'', 还有在php3中你应该避免在模式的最前面使用\, 比如说,正则表达式 "(\$│?[0-9]+" 应该这样调用 ereg("(\\$│?[0-9]+", $str) (不知道php4是不是一样)

不要忘记在中括号里面的字符是这条规路的例外—在中括号里面, 所有的特殊字符，包括(''), 都将失去他们的特殊性质(i.e., "[*\+?{}.]"匹配含有这些字符的字符串). 还有,正如regx的手册告诉我们: "如果列表里含有 ']', 最好把它作为列表里的第一个字符(可能跟在'^'后面). 如果含有'-', 最好把它放在最前面或者最后面, or 或者一个范围的第二个结束点(i.e. [a-d-0-9]中间的‘-’将有效.

为了完整, 我应该涉及到 collating sequences, character classes, 同埋 equivalence classes. 但我在这些方面不想讲的太详细, 这些在下面的文章仲都不需要涉及到. 你们可以在regex man pages 那里得到更多消息.

如何构建一个模式来匹配 货币数量 的输入

好了，现在我们要用我们所学的来干一些有用的事：构建一个匹配模式去检查输入的信息是否为一个表示money的数字。我们认为一个表示money的数量有四种方式： "10000.00" 和 "10,000.00",或者没有小数部分, "10000" and "10,000". 现在让我们开始构建这个匹配模式:

^[1-9][0-9]*$

这是所变量必须以非0的数字开头.但这也意味着 单一的 "0" 也不能通过测试. 以下是解决的方法:

^(0│[1-9][0-9]*)$

"只有0和不以0开头的数字与之匹配"，我们也可以允许一个负号再数字之前:

^(0│-?[1-9][0-9]*)$

这就是: "0 或者 一个以0开头可能有一个负号在前面的数字." 好了, 好了现在让我们别那么严谨，允许以0开头.现在让我们放弃 负号 , 因为我们在表示钱币的时候并不需要用到. 我们现在指定 模式 用来匹配小数部分:

^[0-9]+(\.[0-9]+)?$

这暗示匹配的字符串必须最少以一个阿拉伯数字开头. 但是注意，在上面模式中 "10." 是不匹配的, 只有 "10" 和 "10.2" 才可以. （你知道为什么吗）

^[0-9]+(\.[0-9]{2})?$

我们上面指定小数点后面必须有两位小数.如果你认为这样太苛刻,你可以改成:

^[0-9]+(\.[0-9]{1,2})?$

这将允许小数点后面有一到两个字符. 现在我们加上用来增加可读性的逗号（每隔三位）, 我们可以这样表示:

^[0-9]{1,3}(,[0-9]{3})*(\.[0-9]{1,2})?$

不要忘记加号 '+' 可以被乘号 '*' 替代如果你想允许空白字符串被输入话 (为什么?). 也不要忘记反斜杆 ’\’ 在php字符串中可能会出现错误 (很普遍的错误). 现在，我们已经可以确认字符串了, 我们现在把所有逗号都去掉 str_replace(",", "", $money) 然后在把类型看成 double然后我们就可以通过他做数学计算了.
构造检查email的正则表达式

好,让我们继续讨论怎么验证一个email地址. 在一个完整的email地址中有三个部分: POP3 用户名 (在 '@' 左边的一切), '@', 服务器名(就是剩下那部分). 用户名可以含有大小写字母阿拉伯数字,句号 ('.'), 减号('-'), and 下划线 ('_'). 服务器名字也是符合这个规则,当然下划线除外.

现在, 用户名的开始和结束都不能是句点. 服务器也是这样. 还有你不能有两个连续的句点他们之间至少存在一个字符，好现在我们来看一下怎么为用户名写一个匹配模式:

^[_a-zA-Z0-9-]+$

现在还不能允许句号的存在. 我们把它加上:

^[_a-zA-Z0-9-]+(\.[_a-zA-Z0-9-]+)*$

上面的意思就是说: "以至少一个规范字符（除.意外）开头,后面跟着0个或者多个以点开始的字符串."

简单化一点, 我们可以用 eregi()取代 ereg().eregi()对大小写不敏感, 我们就不需要指定两个范围 "a-z" 和 "A-Z" – 只需要指定一个就可以了:

^[_a-z0-9-]+(\.[_a-z0-9-]+)*$

后面的服务器名字也是一样,但要去掉下划线:

^[a-z0-9-]+(\.[a-z0-9-]+)*$

Done. 现在只需要用”@”把两部分连接:

^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*$


这就是完整的email认证匹配模式了,只需要调用

eregi(‘^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*$ ’,$eamil)

就可以得到是否为email了
正则表达式的其他用法

提取字符串

ereg() and eregi() 有一个特性是允许用户通过正则表达式去提取字符串的一部分(具体用法你可以阅读手册). 比如说,我们想从 path/URL 提取文件名 – 下面的代码就是你需要:

ereg("([^\\/]*)$", $pathOrUrl, $regs);
echo $regs[1];

高级的代换

ereg_replace() 和 eregi_replace()也是非常有用的: 假如我们想把所有的间隔负号都替换成逗号:


ereg_replace("[ \n\r\t]+", ",", trim($str));

IceCraft
VAR7ZL-819-56-54678656108018950

剪贴板是Windows中系统级的堆空间，系统中任何一个应用程序对剪贴板都有访问权，可以通过剪贴板消息和使用剪贴板API来读写剪贴板内容。因此使用剪贴板不仅可以在同一个应用程序内交互数据，也可以在不通应用程序之间交互数据。尤其是在不通应用程序之间交互时，应用程序往往需要对剪贴板内容的变化做到实时感知，即应用程序要能监视剪贴板内容的变化。

 

Windows应用是消息驱动的，同理当剪贴板内容发生变化时，Windows提供了剪贴板变化消息，因此要实时感知剪贴板内容的变化，关键是应用程序要能响应和处理Windows触发的剪贴板变化消息。

 

第一步，要将窗口注册为Clipboard Viewer

需要首先解释两个概念：Clipboard Viewer和Clipboard Viewer Chain。

Clipboard Viewer是一个需要取得并显示剪贴板内容的窗口，通过Clipboard Viewer这个机制，应用程序可以在不影响剪贴板内容的情况下获取剪贴板的变化消息。Clipboard Viewer可以显示系统定义的标准格式的剪贴板内容，也可以显示应用自定义的私有数据格式的内容。通过调用函数SetClipboardViewer将窗口注册为Clipboard Viewer。

Clipboard Viewer Chain是保存Clipboard Viewer窗口以及他们之间的前后向关系的一个Windows系统链表，当一个窗口注册为Clipboard Viewer后，他会被加入Clipboard Viewer Chain，并得到链表中下一个Viewer窗口的句柄，该句柄必须保存以在响应消息时使用，该句柄的作用在下文说明。Windows正是通过Clipboard Viewer Chain保证了所有Clipboard Viewer能接收和响应剪贴板变化消息。

 

第二步，响应剪贴板变化消息，判断和取出剪贴板内容

在消息响应里必须正确处理两个消息：WM_DRAWCLIPBOARD和WM_CHANGECBCHAIN。

 

当剪贴板内容发生变化时，Windows将触发WM_DRAWCLIPBOARD消息，并将该消息送给Clipboard Viewer Chain的第一个窗口。每一个Clipboard Viewer窗口，包括第一个窗口在响应和处理该消息后，必须根据其保存的链表中的下一个窗口的句柄将该消息发送给下一个Clipboard Viewer窗口。窗口可以在该消息中取出剪贴板内容，并判断是否是该窗口增在监视的内容，如果是就进行相应的处理。

 

当某个Clipboard Viewer窗口注销时，系统将触发WM_CHANGECBCHAIN，并将该消息送给Clipboard Viewer Chain的第一个窗口。每一个窗口必须处理该消息。

 

第三步，将窗口从Clipboard Viewer Chain中注销

当窗口不再需要监视剪贴板变化消息，或窗口要关闭时，必须调用ChangeClipboardChain函数将窗口从Clipboard Viewer Chain中注销。注销后系统会触发WM_CHANGECBCHAIN消息，同WM_DRAWCLIPBOARD消息一样，该消息会给发送给Clipboard Viewer Chain的第一个窗口处理。下面代码示例当窗口被关闭时进行注销。

 

下面的代码片断给出了监视剪贴板中是否拷贝了URL地址的例子，如果剪贴板中的内容是URL地址，则将其显示在窗口界面上。为使示例代码具有一般性，下面给出了一般Windows程序代码和基于MFC的代代码。其他语言要实现该功能可以参考Windows程序代码。两个DEMO的完成代码请见附件。

 

Windows程序示例代码

LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)

{

    int wmId, wmEvent;

    PAINTSTRUCT ps;

    HDC hdc;

    unsigned int anFormats[] = {CF_TEXT};

    unsigned int nFormat;

 

    switch (message)

    {

        //----------------------------------------------------------------  

        case WM_CREATE: 

            //将本窗口注册到Clipboard Viewer Chain，

            //并保存Clipboard Viewer Chain中下一个窗口的句柄

            hwndNextViewer = SetClipboardViewer(hWnd);

            break;

        case WM_CHANGECBCHAIN:  //Clipboard Viewer注销

            //如果注销的Clipboard Viewer窗口是本窗口的下一个窗口，

            //则修改本窗口保存的下一个窗口句柄,

            //否则将该消息传递到Clipboard Viewer Chain的下一个窗口

            if ((HWND) wParam == hwndNextViewer)

                hwndNextViewer = (HWND) lParam;

            else if (hwndNextViewer != NULL)

                SendMessage(hwndNextViewer, message, wParam, lParam); 

            break;

        case WM_DRAWCLIPBOARD:  //剪贴板内容变化

            //触发ON_PAINT显示URL内容

            InvalidateRect(hWnd, NULL, TRUE);

            UpdateWindow(hWnd);

            //否则将该消息传递到Clipboard Viewer Chain的下一个窗口

            SendMessage(hwndNextViewer, message, wParam, lParam);

            break;

        case WM_DESTROY:

            //从Clipboard Viewer Chain注销本窗口

            ChangeClipboardChain(hWnd, hwndNextViewer);

            PostQuitMessage(0);

            break;

        //----------------------------------------------------------------

        case WM_COMMAND:

            wmId    = LOWORD(wParam);

            wmEvent = HIWORD(wParam);

            // Parse the menu selections:

            switch (wmId)

            {

                case IDM_ABOUT:

                   DialogBox(hInst, (LPCTSTR)IDD_ABOUTBOX,

hWnd, (DLGPROC)About);

                   break;

                case IDM_EXIT:

                   DestroyWindow(hWnd);

                   break;

                default:

                   return DefWindowProc(hWnd, message, wParam, lParam);

            }

            break;

        case WM_PAINT:

            hdc = BeginPaint(hWnd, &ps);

            //判断剪贴板中的内容是否为URL地址，如是则显示

            nFormat = GetPriorityClipboardFormat(anFormats,sizeof(anFormats));           

            if(nFormat == CF_TEXT)

            {

                OpenClipboard(hWnd);

                HGLOBAL hMem = GetClipboardData(nFormat);

                LPTSTR lpstr = (LPTSTR)GlobalLock(hMem);

 

                if(strstr(lpstr,"http://") != NULL ||

                   strstr(lpstr,"ftp://")  != NULL ||

                   strstr(lpstr,"file://") != NULL)

                {

                    RECT rt;

                    GetClientRect(hWnd, &rt);

                    DrawText(hdc, lpstr, -1, &rt, DT_LEFT);

                }

                GlobalUnlock(hMem);

                CloseClipboard();

            }

            EndPaint(hWnd, &ps);

            break;

        default:

            return DefWindowProc(hWnd, message, wParam, lParam);

   }

   return 0;

}

 

MFC程序示例代码

首先要映射以下消息和继承以下函数

afx_msg void OnChangeCbChain(HWND hWndRemove, HWND hWndAfter);

afx_msg void OnDrawClipboard();

afx_msg void OnDestroy();

virtual void OnInitialUpdate();

 

 

void CMonitorUrlView::OnInitialUpdate()

{

    CListView::OnInitialUpdate();

 

    m_pListCtrl = &GetListCtrl();;

    m_pListCtrl->SetExtendedStyle(LVS_EX_FULLROWSELECT |

                                  LVS_EX_GRIDLINES |

                                  LVS_EX_TRACKSELECT |

                                  LVS_EX_TWOCLICKACTIVATE |

                                  LVS_EX_UNDERLINECOLD);

    m_pListCtrl->ModifyStyle(LVS_TYPEMASK, LVS_REPORT);

    m_pListCtrl->InsertColumn(0, "URL",LVCFMT_LEFT,600,1);   

 

    //将本窗口注册到Clipboard Viewer Chain，

    //并保存Clipboard Viewer Chain中下一个窗口的句柄

    m_hwndNextViewer = SetClipboardViewer();

}

 

void CMonitorUrlView::OnDestroy()

{

    CListView::OnDestroy();

   

    //从Clipboard Viewer Chain注销本窗口

    ChangeClipboardChain(m_hwndNextViewer);

}

 

//Clipboard Viewer注销

void CMonitorUrlView::OnChangeCbChain(HWND hWndRemove, HWND hWndAfter)

{

    //如果注销的Clipboard Viewer窗口是本窗口的下一个窗口，

    //则修改本窗口保存的下一个窗口句柄,

    CView::OnChangeCbChain(hWndRemove,hWndAfter);

 

    if(hWndRemove == m_hwndNextViewer)

        m_hwndNextViewer = hWndAfter;

}

 

//剪贴板内容变化,判断剪贴板中的内容是否为URL地址，如是则显示

void CMonitorUrlView::OnDrawClipboard()

{

    CView::OnDrawClipboard();

       

    unsigned int anFormats[] = {CF_TEXT};

    unsigned int nFormat =

 GetPriorityClipboardFormat(anFormats,sizeof(anFormats)); 

    if(nFormat == CF_TEXT)

    {

        HGLOBAL hMem;

        OpenClipboard();

       

        if(hMem = ::GetClipboardData(CF_TEXT))

        {

            LPTSTR lpszText = (LPTSTR) GlobalLock(hMem);

            CString strURL = lpszText;

            strURL = strURL.SpanExcluding("\r\n");

           

            if(strURL.Left(7).CompareNoCase("http://") == 0 ||

               strURL.Left(6).CompareNoCase("ftp://")  == 0 ||

               strURL.Left(7).CompareNoCase("file://") == 0)

            {               

                m_pListCtrl->InsertItem(0,lpszText);

            }

            GlobalUnlock(hMem);

        }

        CloseClipboard();

    }  

}

前言

正则表达式是烦琐的，但是强大的，学会之后的应用会让你除了提高效率外，会给你带来绝对的成就感。只要认真去阅读这些资料，加上应用的时候进行一定的参考，掌握正则表达式不是问题。

索引

1._引子
2._正则表达式的历史
3._正则表达式定义

3.1_普通字符
3.2_非打印字符
3.3_特殊字符
3.4_限定符
3.5_定位符
3.6_选择
3.7_后向引用

4._各种操作符的运算优先级
5._全部符号解释
6._部分例子
7._正则表达式匹配规则

7.1_基本模式匹配
7.2_字符簇
7.3_确定重复出现

---

1. 引子

　　目前，正则表达式已经在很多软件中得到广泛的应用，包括*nix（Linux, Unix等），HP等操作系统，PHP，C#，Java等开发环境，以及很多的应用软件中，都可以看到正则表达式的影子。

　　正则表达式的使用，可以通过简单的办法来实现强大的功能。为了简单有效而又不失强大，造成了正则表达式代码的难度较大，学习起来也不是很容易，所以需要付出一些努力才行，入门之后参照一定的参考，使用起来还是比较简单有效的。

例子： ^.+@.+\\..+$

　　这样的代码曾经多次把我自己给吓退过。可能很多人也是被这样的代码给吓跑的吧。继续阅读本文将让你也可以自由应用这样的代码。

　　注意：这里的第7部分跟前面的内容看起来似乎有些重复，目的是把前面表格里的部分重新描述了一次，目的是让这些内容更容易理解。

2. 正则表达式的历史

　

3. 正则表达式定义

　　正则表达式(regular expression)描述了一种字符串匹配的模式，可以用来检查一个串是否含有某种子串、将匹配的子串做替换或者从某个串中取出符合某个条件的子串等。

• 列目录时，　dir *.txt或ls *.txt中的*.txt就不是一个正则表达式,因为这里*与正则式的*的含义是不同的。

　　正则表达式是由普通字符（例如字符 a 到 z）以及特殊字符（称为元字符）组成的文字模式。正则表达式作为一个模板，将某个字符模式与所搜索的字符串进行匹配。

3.1 普通字符

　　由所有那些未显式指定为元字符的打印和非打印字符组成。这包括所有的大写和小写字母字符，所有数字，所有标点符号以及一些符号。

3.2 非打印字符

字符	含义
\cx	匹配由x指明的控制字符。例如， \cM 匹配一个 Control-M 或回车符。x 的值必须为 A-Z 或 a-z 之一。否则，将 c 视为一个原义的 'c' 字符。
\f	匹配一个换页符。等价于 \x0c 和 \cL。
\n	匹配一个换行符。等价于 \x0a 和 \cJ。
\r	匹配一个回车符。等价于 \x0d 和 \cM。
\s	匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。
\S	匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。
\t	匹配一个制表符。等价于 \x09 和 \cI。
\v	匹配一个垂直制表符。等价于 \x0b 和 \cK。

　

3.3 特殊字符

　　所谓特殊字符，就是一些有特殊含义的字符，如上面说的"*.txt"中的*，简单的说就是表示任何字符串的意思。如果要查找文件名中有＊的文件，则需要对＊进行转义，即在其前加一个\。ls \*.txt。正则表达式有以下特殊字符。

　

特别字符	说明
$	匹配输入字符串的结尾位置。如果设置了 RegExp 对象的 Multiline 属性，则 $ 也匹配 '\n' 或 '\r'。要匹配 $ 字符本身，请使用 \$。
( )	标记一个子表达式的开始和结束位置。子表达式可以获取供以后使用。要匹配这些字符，请使用 \( 和 \)。
*	匹配前面的子表达式零次或多次。要匹配 * 字符，请使用 \*。
+	匹配前面的子表达式一次或多次。要匹配 + 字符，请使用 \+。
.	匹配除换行符 \n之外的任何单字符。要匹配 .，请使用 \。
[	标记一个中括号表达式的开始。要匹配 [，请使用 \[。
?	匹配前面的子表达式零次或一次，或指明一个非贪婪限定符。要匹配 ? 字符，请使用 \?。
\	将下一个字符标记为或特殊字符、或原义字符、或向后引用、或八进制转义符。例如， 'n' 匹配字符 'n'。'\n' 匹配换行符。序列 '\\' 匹配 "\"，而 '\(' 则匹配 "("。
^	匹配输入字符串的开始位置，除非在方括号表达式中使用，此时它表示不接受该字符集合。要匹配 ^ 字符本身，请使用 \^。
{	标记限定符表达式的开始。要匹配 {，请使用 \{。
|	指明两项之间的一个选择。要匹配 |，请使用 \|。

• 　　构造正则表达式的方法和创建数学表达式的方法一样。也就是用多种元字符与操作符将小的表达式结合在一起来创建更大的表达式。正则表达式的组件可以是单个的字符、字符集合、字符范围、字符间的选择或者所有这些组件的任意组合。

　

3.4 限定符

　　限定符用来指定正则表达式的一个给定组件必须要出现多少次才能满足匹配。有*或+或?或{n}或{n,}或{n,m}共6种。
*、+和?限定符都是贪婪的，因为它们会尽可能多的匹配文字，只有在它们的后面加上一个?就可以实现非贪婪或最小匹配。
　　正则表达式的限定符有：
　

字符	描述
*	匹配前面的子表达式零次或多次。例如，zo* 能匹配 "z" 以及 "zoo"。* 等价于{0,}。
+	匹配前面的子表达式一次或多次。例如，'zo+' 能匹配 "zo" 以及 "zoo"，但不能匹配 "z"。+ 等价于 {1,}。
?	匹配前面的子表达式零次或一次。例如，"do(es)?" 可以匹配 "do" 或 "does" 中的"do" 。? 等价于 {0,1}。
{n}	n 是一个非负整数。匹配确定的 n 次。例如，'o{2}' 不能匹配 "Bob" 中的 'o'，但是能匹配 "food" 中的两个 o。
{n,}	n 是一个非负整数。至少匹配n 次。例如，'o{2,}' 不能匹配 "Bob" 中的 'o'，但能匹配 "foooood" 中的所有 o。'o{1,}' 等价于 'o+'。'o{0,}' 则等价于 'o*'。
{n,m}	m 和 n 均为非负整数，其中n <= m。最少匹配 n 次且最多匹配 m 次。例如，"o{1,3}" 将匹配 "fooooood" 中的前三个 o。'o{0,1}' 等价于 'o?'。请注意在逗号和两个数之间不能有空格。

3.5 定位符

　　用来描述字符串或单词的边界，^和$分别指字符串的开始与结束，\b描述单词的前或后边界，\B表示非单词边界。不能对定位符使用限定符。

3.6 选择

　　用圆括号将所有选择项括起来，相邻的选择项之间用|分隔。但用圆括号会有一个副作用，是相关的匹配会被缓存，此时可用?:放在第一个选项前来消除这种副作用。
　　其中?:是非捕获元之一，还有两个非捕获元是?=和?!，这两个还有更多的含义，前者为正向预查，在任何开始匹配圆括号内的正则表达式模式的位置来匹配搜索字符串，后者为负向预查，在任何开始不匹配该正则表达式模式的位置来匹配搜索字符串。

3.7 后向引用

　　对一个正则表达式模式或部分模式两边添加圆括号将导致相关匹配存储到一个临时缓冲区中，所捕获的每个子匹配都按照在正则表达式模式中从左至右所遇到的内容存储。存储子匹配的缓冲区编号从 1 开始，连续编号直至最大 99 个子表达式。每个缓冲区都可以使用 '\n' 访问，其中 n 为一个标识特定缓冲区的一位或两位十进制数。
　　可以使用非捕获元字符 '?:', '?=', or '?!' 来忽略对相关匹配的保存。

4. 各种操作符的运算优先级

　　相同优先级的从左到右进行运算，不同优先级的运算先高后低。各种操作符的优先级从高到低如下：
　

操作符	描述
\	转义符
(), (?:), (?=), []	圆括号和方括号
*, +, ?, {n}, {n,}, {n,m}	限定符
^, $, \anymetacharacter	位置和顺序
|	“或”操作

5. 全部符号解释

字符	描述
\	将下一个字符标记为一个特殊字符、或一个原义字符、或一个 向后引用、或一个八进制转义符。例如，'n' 匹配字符 "n"。'\n' 匹配一个换行符。序列 '\\' 匹配 "\" 而 "\(" 则匹配 "("。
^	匹配输入字符串的开始位置。如果设置了 RegExp 对象的 Multiline 属性，^ 也匹配 '\n' 或 '\r' 之后的位置。
$	匹配输入字符串的结束位置。如果设置了RegExp 对象的 Multiline 属性，$ 也匹配 '\n' 或 '\r' 之前的位置。
*	匹配前面的子表达式零次或多次。例如，zo* 能匹配 "z" 以及 "zoo"。* 等价于{0,}。
+	匹配前面的子表达式一次或多次。例如，'zo+' 能匹配 "zo" 以及 "zoo"，但不能匹配 "z"。+ 等价于 {1,}。
?	匹配前面的子表达式零次或一次。例如，"do(es)?" 可以匹配 "do" 或 "does" 中的"do" 。? 等价于 {0,1}。
{n}	n 是一个非负整数。匹配确定的 n 次。例如，'o{2}' 不能匹配 "Bob" 中的 'o'，但是能匹配 "food" 中的两个 o。
{n,}	n 是一个非负整数。至少匹配n 次。例如，'o{2,}' 不能匹配 "Bob" 中的 'o'，但能匹配 "foooood" 中的所有 o。'o{1,}' 等价于 'o+'。'o{0,}' 则等价于 'o*'。
{n,m}	m 和 n 均为非负整数，其中n <= m。最少匹配 n 次且最多匹配 m 次。例如，"o{1,3}" 将匹配 "fooooood" 中的前三个 o。'o{0,1}' 等价于 'o?'。请注意在逗号和两个数之间不能有空格。
?	当该字符紧跟在任何一个其他限制符 (*, +, ?, {n}, {n,}, {n,m}) 后面时，匹配模式是非贪婪的。非贪婪模式尽可能少的匹配所搜索的字符串，而默认的贪婪模式则尽可能多的匹配所搜索的字符串。例如，对于字符串 "oooo"，'o+?' 将匹配单个 "o"，而 'o+' 将匹配所有 'o'。
.	匹配除 "\n" 之外的任何单个字符。要匹配包括 '\n' 在内的任何字符，请使用象 '[.\n]' 的模式。
(pattern)	匹配 pattern 并获取这一匹配。所获取的匹配可以从产生的 Matches 集合得到，在VBScript 中使用 SubMatches 集合，在JScript 中则使用 $0…$9 属性。要匹配圆括号字符，请使用 '\(' 或 '\)'。
(?:pattern)	匹配 pattern 但不获取匹配结果，也就是说这是一个非获取匹配，不进行存储供以后使用。这在使用 "或" 字符 (|) 来组合一个模式的各个部分是很有用。例如， 'industr(?:y|ies) 就是一个比 'industry|industries' 更简略的表达式。
(?=pattern)	正向预查，在任何匹配 pattern 的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如，'Windows (?=95|98|NT|2000)' 能匹配 "Windows 2000" 中的 "Windows" ，但不能匹配 "Windows 3.1" 中的 "Windows"。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始。
(?!pattern)	负向预查，在任何不匹配 pattern 的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如'Windows (?!95|98|NT|2000)' 能匹配 "Windows 3.1" 中的 "Windows"，但不能匹配 "Windows 2000" 中的 "Windows"。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始
x|y	匹配 x 或 y。例如，'z|food' 能匹配 "z" 或 "food"。'(z|f)ood' 则匹配 "zood" 或 "food"。
[xyz]	字符集合。匹配所包含的任意一个字符。例如， '[abc]' 可以匹配 "plain" 中的 'a'。
[^xyz]	负值字符集合。匹配未包含的任意字符。例如， '[^abc]' 可以匹配 "plain" 中的'p'。
[a-z]	字符范围。匹配指定范围内的任意字符。例如，'[a-z]' 可以匹配 'a' 到 'z' 范围内的任意小写字母字符。
[^a-z]	负值字符范围。匹配任何不在指定范围内的任意字符。例如，'[^a-z]' 可以匹配任何不在 'a' 到 'z' 范围内的任意字符。
\b	匹配一个单词边界，也就是指单词和空格间的位置。例如， 'er\b' 可以匹配"never" 中的 'er'，但不能匹配 "verb" 中的 'er'。
\B	匹配非单词边界。'er\B' 能匹配 "verb" 中的 'er'，但不能匹配 "never" 中的 'er'。
\cx	匹配由 x 指明的控制字符。例如， \cM 匹配一个 Control-M 或回车符。x 的值必须为 A-Z 或 a-z 之一。否则，将 c 视为一个原义的 'c' 字符。
\d	匹配一个数字字符。等价于 [0-9]。
\D	匹配一个非数字字符。等价于 [^0-9]。
\f	匹配一个换页符。等价于 \x0c 和 \cL。
\n	匹配一个换行符。等价于 \x0a 和 \cJ。
\r	匹配一个回车符。等价于 \x0d 和 \cM。
\s	匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。
\S	匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。
\t	匹配一个制表符。等价于 \x09 和 \cI。
\v	匹配一个垂直制表符。等价于 \x0b 和 \cK。
\w	匹配包括下划线的任何单词字符。等价于'[A-Za-z0-9_]'。
\W	匹配任何非单词字符。等价于 '[^A-Za-z0-9_]'。
\xn	匹配 n，其中 n 为十六进制转义值。十六进制转义值必须为确定的两个数字长。例如，'\x41' 匹配 "A"。'\x041' 则等价于 '\x04' & "1"。正则表达式中可以使用 ASCII 编码。.
\num	匹配 num，其中 num 是一个正整数。对所获取的匹配的引用。例如，'(.)\1' 匹配两个连续的相同字符。
\n	标识一个八进制转义值或一个向后引用。如果 \n 之前至少 n 个获取的子表达式，则 n 为向后引用。否则，如果 n 为八进制数字 (0-7)，则 n 为一个八进制转义值。
\nm	标识一个八进制转义值或一个向后引用。如果 \nm 之前至少有 nm 个获得子表达式，则 nm 为向后引用。如果 \nm 之前至少有 n 个获取，则 n 为一个后跟文字 m 的向后引用。如果前面的条件都不满足，若 n 和 m 均为八进制数字 (0-7)，则 \nm 将匹配八进制转义值 nm。
\nml	如果 n 为八进制数字 (0-3)，且 m 和 l 均为八进制数字 (0-7)，则匹配八进制转义值 nml。
\un	匹配 n，其中 n 是一个用四个十六进制数字表示的 Unicode 字符。例如， \u00A9 匹配版权符号 (?)。

　

6. 部分例子

正则表达式	说明
/\b([a-z]+) \1\b/gi	一个单词连续出现的位置
/(\w+):\/\/([^/:]+)(:\d*)?([^# ]*)/	将一个URL解析为协议、域、端口及相对路径
/^(?:Chapter|Section) [1-9][0-9]{0,1}$/	定位章节的位置
/[-a-z]/	A至z共26个字母再加一个-号。
/ter\b/	可匹配chapter，而不能terminal
/\Bapt/	可匹配chapter，而不能aptitude
/Windows(?=95 |98 |NT )/	可匹配Windows95或Windows98或WindowsNT,当找到一个匹配后，从Windows后面开始进行下一次的检索匹配。

　

7. 正则表达式匹配规则

7.1 基本模式匹配

　　一切从最基本的开始。模式，是正规表达式最基本的元素，它们是一组描述字符串特征的字符。模式可以很简单，由普通的字符串组成，也可以非常复杂，往往用特殊的字符表示一个范围内的字符、重复出现，或表示上下文。例如：

^once

　　这个模式包含一个特殊的字符^，表示该模式只匹配那些以once开头的字符串。例如该模式与字符串"once upon a time"匹配，与"There once was a man from NewYork"不匹配。正如如^符号表示开头一样，$符号用来匹配那些以给定模式结尾的字符串。

bucket$

　　这个模式与"Who kept all of this cash in a bucket"匹配，与"buckets"不匹配。字符^和$同时使用时，表示精确匹配（字符串与模式一样）。例如：

^bucket$

　　只匹配字符串"bucket"。如果一个模式不包括^和$，那么它与任何包含该模式的字符串匹配。例如：模式

once

与字符串

There once was a man from NewYork
Who kept all of his cash in a bucket.

是匹配的。

　　在该模式中的字母(o-n-c-e)是字面的字符，也就是说，他们表示该字母本身，数字也是一样的。其他一些稍微复杂的字符，如标点符号和白字符（空格、制表符等），要用到转义序列。所有的转义序列都用反斜杠(\)打头。制表符的转义序列是：\t。所以如果我们要检测一个字符串是否以制表符开头，可以用这个模式：

^\t

类似的，用\n表示“新行”，\r表示回车。其他的特殊符号，可以用在前面加上反斜杠，如反斜杠本身用\\表示，句号.用\.表示，以此类推。

7.2 字符簇

在INTERNET的程序中，正规表达式通常用来验证用户的输入。当用户提交一个FORM以后，要判断输入的电话号码、地址、EMAIL地址、信用卡号码等是否有效，用普通的基于字面的字符是不够的。

所以要用一种更自由的描述我们要的模式的办法，它就是字符簇。要建立一个表示所有元音字符的字符簇，就把所有的元音字符放在一个方括号里：

[AaEeIiOoUu]

这个模式与任何元音字符匹配，但只能表示一个字符。用连字号可以表示一个字符的范围，如：

[a-z] //匹配所有的小写字母
[A-Z] //匹配所有的大写字母
[a-zA-Z] //匹配所有的字母
[0-9] //匹配所有的数字
[0-9\.\-] //匹配所有的数字，句号和减号
[ \f\r\t\n] //匹配所有的白字符

同样的，这些也只表示一个字符，这是一个非常重要的。如果要匹配一个由一个小写字母和一位数字组成的字符串，比如"z2"、"t6"或"g7"，但不是"ab2"、"r2d3" 或"b52"的话，用这个模式：

^[a-z][0-9]$

尽管[a-z]代表26个字母的范围，但在这里它只能与第一个字符是小写字母的字符串匹配。

前面曾经提到^表示字符串的开头，但它还有另外一个含义。当在一组方括号里使用^是，它表示“非”或“排除”的意思，常常用来剔除某个字符。还用前面的例子，我们要求第一个字符不能是数字：

^[^0-9][0-9]$

这个模式与"&5"、"g7"及"-2"是匹配的，但与"12"、"66"是不匹配的。下面是几个排除特定字符的例子：

[^a-z] //除了小写字母以外的所有字符
[^\\\/\^] //除了(\)(/)(^)之外的所有字符
[^\"\'] //除了双引号(")和单引号(')之外的所有字符

特殊字符"." (点，句号)在正规表达式中用来表示除了“新行”之外的所有字符。所以模式"^.5$"与任何两个字符的、以数字5结尾和以其他非“新行”字符开头的字符串匹配。模式"."可以匹配任何字符串，除了空串和只包括一个“新行”的字符串。

PHP的正规表达式有一些内置的通用字符簇，列表如下：

字符簇 含义
[[:alpha:]] 任何字母
[[:digit:]] 任何数字
[[:alnum:]] 任何字母和数字
[[:space:]] 任何白字符
[[:upper:]] 任何大写字母
[[:lower:]] 任何小写字母
[[:punct:]] 任何标点符号
[[:xdigit:]] 任何16进制的数字，相当于[0-9a-fA-F]

7.3 确定重复出现

到现在为止，你已经知道如何去匹配一个字母或数字，但更多的情况下，可能要匹配一个单词或一组数字。一个单词有若干个字母组成，一组数字有若干个单数组成。跟在字符或字符簇后面的花括号({})用来确定前面的内容的重复出现的次数。

字符簇 含义
^[a-zA-Z_]$ 所有的字母和下划线
^[[:alpha:]]{3}$ 所有的3个字母的单词
^a$ 字母a
^a{4}$ aaaa
^a{2,4}$ aa,aaa或aaaa
^a{1,3}$ a,aa或aaa
^a{2,}$ 包含多于两个a的字符串
^a{2,} 如：aardvark和aaab，但apple不行
a{2,} 如：baad和aaa，但Nantucket不行
\t{2} 两个制表符
.{2} 所有的两个字符

这些例子描述了花括号的三种不同的用法。一个数字，{x}的意思是“前面的字符或字符簇只出现x次”；一个数字加逗号，{x,}的意思是“前面的内容出现x或更多的次数”；两个用逗号分隔的数字，{x,y}表示“前面的内容至少出现x次，但不超过y次”。我们可以把模式扩展到更多的单词或数字：

^[a-zA-Z0-9_]{1,}$ //所有包含一个以上的字母、数字或下划线的字符串
^[0-9]{1,}$ //所有的正数
^\-{0,1}[0-9]{1,}$ //所有的整数
^\-{0,1}[0-9]{0,}\.{0,1}[0-9]{0,}$ //所有的小数

最后一个例子不太好理解，是吗？这么看吧：与所有以一个可选的负号(\-{0,1})开头(^)、跟着0个或更多的数字([0-9]{0,})、和一个可选的小数点(\.{0,1})再跟上0个或多个数字([0-9]{0,})，并且没有其他任何东西($)。下面你将知道能够使用的更为简单的方法。

特殊字符"?"与{0,1}是相等的，它们都代表着：“0个或1个前面的内容”或“前面的内容是可选的”。所以刚才的例子可以简化为：

^\-?[0-9]{0,}\.?[0-9]{0,}$

特殊字符"*"与{0,}是相等的，它们都代表着“0个或多个前面的内容”。最后，字符"+"与 {1,}是相等的，表示“1个或多个前面的内容”，所以上面的4个例子可以写成：

^[a-zA-Z0-9_]+$ //所有包含一个以上的字母、数字或下划线的字符串
^[0-9]+$ //所有的正数
^\-?[0-9]+$ //所有的整数
^\-?[0-9]*\.?[0-9]*$ //所有的小数

当然这并不能从技术上降低正规表达式的复杂性，但可以使它们更容易阅读。

 

正则表达式中的常用模式
下面是正则表达式中的一些常用模式。

/pattern/  结果 
. 匹配除换行符以外的所有字符
x? 匹配 0 次或一次 x 字符串
x* 匹配 0 次或多次 x 字符串，但匹配可能的最少次数
x+ 匹配 1 次或多次 x 字符串，但匹配可能的最少次数
.* 匹配 0 次或一次的任何字符
.+ 匹配 1 次或多次的任何字符
{m} 匹配刚好是 m 个 的指定字符串
{m,n} 匹配在 m个 以上 n个 以下 的指定字符串
{m,} 匹配 m个 以上 的指定字符串
[] 匹配符合 [] 内的字符
[^] 匹配不符合 [] 内的字符
[0-9] 匹配所有数字字符
[a-z] 匹配所有小写字母字符
[^0-9] 匹配所有非数字字符
[^a-z] 匹配所有非小写字母字符
^ 匹配字符开头的字符
$ 匹配字符结尾的字符
\d 匹配一个数字的字符，和 [0-9] 语法一样
\d+ 匹配多个数字字符串，和 [0-9]+ 语法一样
\D 非数字，其他同 \d
\D+ 非数字，其他同 \d+
\w 英文字母或数字的字符串，和 [a-zA-Z0-9] 语法一样
\w+ 和 [a-zA-Z0-9]+ 语法一样
\W 非英文字母或数字的字符串，和 [^a-zA-Z0-9] 语法一样
\W+ 和 [^a-zA-Z0-9]+ 语法一样
\s 空格，和 [\n\t\r\f] 语法一样
\s+ 和 [\n\t\r\f]+ 一样
\S 非空格，和 [^\n\t\r\f] 语法一样
\S+ 和 [^\n\t\r\f]+ 语法一样
\b 匹配以英文字母,数字为边界的字符串
\B 匹配不以英文字母,数值为边界的字符串
a|b|c 匹配符合a字符 或是b字符 或是c字符 的字符串
abc 匹配含有 abc 的字符串
(pattern) () 这个符号会记住所找寻到的字符串，是一个很实用的语法。第一个 () 内所找到的字符串
变成 $1 这个变量或是 \1 变量，第二个 () 内所找到的字符串变成 $2 这个变量或是 \2 变量，以此
类推下去。 
/pattern/i i 这个参数表示忽略英文大小写，也就是在匹配字符串的时候，不考虑英文的大小写问题。
\ 如果要在 pattern 模式中找寻一个特殊字符，如 "*"，则要在这个字符前加上 \ 符号，这样才会让特殊
字符失效
3、正则表达式的八大原则
　　如果在 Unix 中曾经使用过 sed、awk、grep 这些命令的话，相信对于正则表达式(Regular Expression)
不会感到陌生。下面给大家介绍几条正则表达式使用过程中的 8 大原则。

正则表达式在对付数据的战斗中可形成庞大的联盟——这常常是一场战争。我们要记住下面八条原则：

· 原则1：正则表达式有三种不同形式(匹配(m/ /)，替换(s/ / /eg)和转换(tr/ / /))。

· 原则2：正则表达式仅对标量进行匹配( $scalar =~ m/a/; 可以工作; @array =~ m/a/ 将把@array作为标量
对待，因此可能不会成功)。

· 原则3：正则表达式匹配一个给定模式的最早的可能匹配。缺省时，仅匹配或替换正则表达式
一次( $a = 'string string2'; $a =~ s/string/ /; 导致 $a = 'string 2')。

· 原则4：正则表达式能够处理双引号所能处理的任意和全部字符( $a =~ m/$varb/ 在匹配前把varb扩展为
变量；如果 $varb = 'a' $a = 'as'，$a =~ s/$varb/ /; 等价于 $a =~ s/a/ /; ，执行结果使 $a = " s" )。

· 原则5：正则表达式在求值过程中产生两种情况：结果状态和反向引用： $a=~ m/pattern/ 表示 $a 中是否有
子串 pattern 出现，$a =~ s/(word1)(word2)/$2$1/ 则“调换”这两个单词。

· 原则6：正则表达式的核心能力在于通配符和多重匹配运算符以及它们如何操作。$a =~ m/\w+/ 匹配一个或多个
单词字符；$a =~ m/\d/" 匹配零个或多个数字。

· 原则7：如果欲匹配不止一个字符集合，Perl使用 "|" 来增加灵活性。如果输入 m/(cat|dog)/ 则相当于“匹配
字符串 cat 或者 dog。

· 原则8：Perl用 (?..) 语法给正则表达式提供扩展功能。

（想要学习所有这些原则？我建议大家先从简单的开始，并且不断的尝试和实验。

http://www.narchitecture.net/DotNet/AspectSharp.aspx

http://www.microsoft.com/china/MSDN/library/windev/COMponentdev/AspectOrientedProgrammingEnablesBetterCodeEncapsulationandReuse.mspx

AOP（Aspect-Oriented Programming）这个领域还很新，不过我乐观地预计，将来很多大项目会采纳AOP方法。在我看来，AOP是非常重要的方向，可能会是软件开发方法发展道路上的“下一个大家伙”。当然，AOP并不是一种取代性的技术，就像现在电视没有取代收音机，电脑也没有取代电视。不过采用AOP方法后，现在许多模式就不再需要了（当然也会出现一批新的模式），软件开发过程也将会改观。

在我看来，软件开发很大程度上是从需求到实现的映射过程。用户不会在意这个系统用了哪些技术，他只会在意系统能否满足他的需求。但是系统构建者的知识结构却是以各种技术为核心的，有人擅长信息安全技术，有人对负载平衡和容错技术具有深厚知识，还有人是数据库专家。如何有效地把需求映射到实现是各种软件开发方法的核心论题。AOP的三菱镜隐喻很好地说明了AOP在这个映射中扮演何种角色，这里不好贴图我就不具体说了。

关注点（concern）的分离，可以让不同的人专注于不同的事（且是他/她擅长的事）。安全专家就带着他的团队编写事关系统安全的那个aspect好了，系统集成专家可以负责与遗产系统整合的相关部分，业务专家则可以集中注意力于business domain。那么构架师呢？他（她）可以负责总体构架，协调如何把这些各自独立的aspects编织（weave）成一个能跑的应用程序。（可以在源代码层编织，也可在byte code层编织。）

我喜欢AOP的理念，但任何技术都不能只停留在理念，其早期实现是非常重要的，甚至关系到技术的存亡。有很多很好的技术，因为一开始没有很好地实现，只好埋入了废纸堆。不仅IT技术如此，自然科学理论也是如此，优秀的理论常常需要实验科学家来验证。（举个例子，我们熟知的两位著名华裔诺贝尔奖获得者身后站着一位优秀的华裔实验科学家，这是众人皆知的美谈。）目前实现AOP的语言中最著名的当属Xerox PARC开发的AspectJ（现移交Eclipse）。我感觉，AspectJ和Java的关系有些类似于当年C with Classes（后来发展成C++）和C的关系；目前的AspectJ的实现也可类比于当年的CFront。当然，我这样说只是一种感觉而已 :)

曾有人把AOP和Interception类比。或许用Interception模式可以模拟AOP吧，但是这不能表示“没必要提出一个新的paradigm”。请问，用C可以模拟C++吗？用struct和函数指针可以模拟class吗？我猜想许多高手可以做到。那么为什么还要有C++和OOP呢？

AOP的编织规则的power不是Interception可轻易实现的。用来指定编织规则的语言和写aspect的语言可以完全不同，不过一般采取的方案是把写aspect的语言后者略作扩展后作为weaver rule specification language。AspectJ就是这样做的。现在也有AspectC，AspectC++。这种做法又让我想起了OOP implementation在C++中的引入。C++对C语言做了扩展，增加了class, private, public, friend, virtual这些新的内容来描述制定类和类间关系的规则，如果没有这些新的关键字，这个规则可不是那么好表述的。而C语言原来的部分也没有被废弃。你看，在成员函数中的如果不定义新的局部类的话，那么不就是差不多用C语言写每个成员函数吗？AspectJ也是如此。你用Java写aspects，用扩展了的Java语言（或者看作新语言也无妨）写weaving rules。这符合用最合适的语言做最适合的事的原则。

回到AOP和Interception的比较。Interception的实现往往是动态的。如果规则的粒度比较粗，指定的interception的粒度又比较细（比如说，一刀切地规定在所有函数的入口和出口intercept），那么效率损失不可忽略。 我举个简化例子，在每个函数第一行和最后一行加上“判断一个intercept函数指针是否为NULL，如果不是NULL就调用它”的代码，那么要做多少次判断呀，其中又有多少次是无功而返呢？而AOP weaver可以静态地编织代码（源代码或者byte code），就不需要付出这一额外代价了，而且intercept的粒度可更加细化。

此外，我感觉用Interception模式，关注点没有很好分离。不像AOP，甚至可以由不同的人用两种语言来做implement aspect和weave aspects这两件事，关注点分得非常清晰。

另外，关于AOP和设计模式，我有一些想法：从不同的编程语言中可以提炼出不同的代码模式（idioms，又译为惯用法），但代码模式是同特定语言相关的，可能有些模式较为通用，但也有些模式在别的语言中就不再需要。比如reference counting模式在支持GC的语言中就不再必要了吧。这不是说代码模式不好，更不是说有了模式，GC就不再必要，只不过是各得其所罢了。不能因为熟悉模式并运用自如就认为新技术没必要。代码模式如此，那么设计模式又何尝不是呢，有些模式比较通用，但也有一些设计模式是和范型相关的，其中又多数以OO相关，没有超脱于OO的框架。（不信？你用C语言或者其他非OO语言实现一遍GoF中的23个模式，看看难度如何，实现是否很自然？POSA v1,v2中的模式可作补充练习。）如果改用AOP，那么很多模式也可自然消亡了，比如interception模式应该就是吧。

http://www-128.ibm.com/developerworks/library/j-aopwork1/index.html
http://www-128.ibm.com/developerworks/library/j-aopwork2/

中文版：
http://www-900.ibm.com/developerworks/cn/java/j-aopwork1/index.shtml
http://www-900.ibm.com/developerworks/cn/java/j-aopwork2/index.shtml

Aspect＃：http://aspectsharp.sourceforge.net/

Loom：http://www.dcl.hpi.uni-potsdam.de/research/loom

http://www2.cnblogs.com/zhenyulu/articles/93152.html

http://www.discuz.net/viewthread.php?tid=94534&extra=page%3D3

http://dev.csdn.net/article/62/62859.shtm

http://dev.csdn.net/article/63/63402.shtm
http://dev.csdn.net/article/63/63401.shtm

一个搞开发的朋友，在一个小城市的电信做临时工，能力应该比我强很多，惭愧，惭愧。
原本觉得自己比同龄人强那么一点点，所以才能在英极，NEC工作，但此时只觉得自己是个幸运儿。
反思一下，技术都还没精通，就想朝管理发展，大错，特错。
毕竟，我还年轻，还有机会，努力，目标：5年后。