博客园_Leepy's Blogs

Silverlight实现对Sql Server Profiler的SQL实时监控

2012-05-30T11:59:00Z

Sql Server Profiler作为Microsoft Sql Server数据库系列的性能工具，通过它可以对数据库的运行状况进行实时跟踪，从中可以找到慢查询或者死锁的SQL语句，从而去优化系统。本文介绍如果通过Silverlight来对Sql Server Profiler进行实时监控（数据库环境以Sql Server 2005为例）

首先，先来看下SqlServer数据库自带的性能工具Sql Server Profiler，新建一个跟踪：

我们选择默认的模板Standard，其他都不变，点击运行：

从中可以看到数据库中的SQL的运行状态，EventClass作为事件类型，TextData作为运行的SQL脚本，ApplicationName作为一个应用程序的执行源的名称，比如说，从.Net应用程序执行的SQL脚本就是.Net SqlClient Data Provider，再比如说，我直接从数据库客户端工具执行一条SQL语句，可以看到ApplicationName为 ”Microsoft SQL Server Management Studio - 查询“，因此我们通过ApplicationName字段得到程序的执行源，LoginName作为一个数据库的账户，一般系统用户为sa，包括CPU/Reads/Writes在此上面也是一目了然，Duration比较有用，可以查看执行语句的耗时，后面还包括StartTime的开始时间和EndTime的结束时间，当然一些隐藏的列我就不一一列举了，有兴趣大家可以勾选查看下。

如果我要定义一个符合自己需要的模板呢，那么可以通过新建/编辑模板来实现：

上面有很多的事件类型的选择，可以根据自己的需要定制Event，这里我以最简单的方式，就选择了TSQL：SQL BatchCompleted：

并且列选择一个数据库DatabaseName，类似于编辑 MyEnt，这样该模板文件只会在MyEnt为名称的数据库中进行SQL执行跟踪了：

最后点击保存即可

那么，在.Net上怎么实现对于Sql Server Profiler的使用和监控，实际上，Sql ServerProfiler本身为.Net开发的，后来我在SqlServer2005数据库的安装目录 C:\Program Files\Microsoft SQL Server\90\SDK\Assemblies 中，找到一个Microsoft.SqlServer.ConnectionInfo.dll，这个dll就可以实现执行Sql的监控。

开始创建项目，其中，监控程序是一个控制台程序，而Silverlight客户端程序是一个对于SqlServerProfiler实时监控的展示，Silverlight的客户端程序通过Socket和监控程序进行通信。由于Silverlight对于TCP通信的限制，必须往监控程序发送策略请求，并且对于TCP通信来说，目前Silverlight的使用端口必须为4502-4530，于是必须在监控端先设置一个Policy.xml的策略文件：

<?xml version="1.0" encoding ="utf-8"?>
<access-policy>
  <cross-domain-access>
    <policy>
      <allow-from>
        <domain uri="*" />
      </allow-from>
      <grant-to>
        <socket-resource port="4502-4530" protocol="tcp" />
      </grant-to>
    </policy>
  </cross-domain-access>
</access-policy>

现在我将策略请求，监听SL客户端连接/数据收发请求，数据库监听跟踪请求，分别创建3个线程：

//创建Socket来监听策略请求和发送

this._policyThread = this.CreateThread(this.PolicyRequest);
//创建Socket来监听信息请求和发送
this._infoThread = this.CreateThread(this.InfoRequest);
//创建Socket来监听数据库跟踪请求和发送
this._traceServerThread = this.CreateThread(this.TraceServerRequest);

PolicyRequest，InfoRequest的方法具体看文章末尾的附件源代码，这里主要说一下TraceServerRequest的方法：

SqlConnectionInfo conninfo = new SqlConnectionInfo();
conninfo.ServerName = "机器名";
conninfo.UserName = "数据库账户";
conninfo.Password = "数据库密码";
conninfo.UseIntegratedSecurity = false;
TraceServer trace = new TraceServer();
trace.InitializeAsReader(conninfo, TDF_FILE);
SqlConnectionInfo， TraceServer类来自于对Microsoft.SqlServer.ConnectionInfo的引用，其中TDF_FILE就是我前面说的跟踪模板文件名，它的文件后缀为tdf。
while (trace.Read())
{
    var eventData = new EventData()
    {
        EventClass = trace["EventClass"].ToString(),
        TextData = trace["TextData"] != null ? trace["TextData"].ToString() : "",
        ApplicationName = trace["ApplicationName"] != null ? trace["ApplicationName"].ToString() : "",
        NTUserName = trace["NTUserName"] != null ? trace["NTUserName"].ToString() : "",
        LoginName = trace["LoginName"] != null ? trace["LoginName"].ToString() : "",
        CPU = trace["CPU"] != null ? trace["CPU"].ToString() : "",
        Reads = trace["Reads"] != null ? trace["Reads"].ToString() : "",
        Writes = trace["Writes"] != null ? trace["Writes"].ToString() : "",
        Duration = trace["Duration"] != null ? trace["Duration"].ToString() : "",
        ClientProcessID = trace["ClientProcessID"] != null ? trace["ClientProcessID"].ToString() : "",
        SPID = trace["SPID"] != null ? trace["SPID"].ToString() : "",
        StartTime = trace["StartTime"] != null ? trace["StartTime"].ToString() : "",
        EndTime = trace["EndTime"] != null ? trace["EndTime"].ToString() : "",
    };
    var sendData = JsonConvert.SerializeObject(eventData);
    if (string.IsNullOrEmpty(sendData))
        continue;
    lock (_lock)
    {
        this._queues.Enqueue(sendData);
    }
}

通过trace.Read()方法来得到trace的跟踪记录，这里我不会马上通过Socket发送到SL客户端，而是通过一个队列对跟踪记录进行人队，通过InfoRequest从队列中取出数据，发送给SL客户端：

while (true)
{
     lock (_lock)
     {
         if (this._queues.Count == 0)
         {
             Thread.Sleep(200);
             continue;
         }
         var sendData = this._queues.Dequeue();
         Console.WriteLine(sendData);
         byte[] data = Encoding.GetEncoding("gb2312").GetBytes(sendData);
         // 移除已断开的套接字
         this._clientList.RemoveAll(o => o.Connected == false);
         foreach (Socket s in this._clientList)
         {
             if (s.Connected)
             {
                 try
                 {
                     //发送数据
                     s.Send(data);
                 }
…

SL客户端通过Socket异步编程接收数据

/// <summary>
/// 当接收完成
/// </summary>
/// <param name="e"></param>
void ProcessReceive(SocketAsyncEventArgs e)
{
     if (e.SocketError == SocketError.Success)
     {
         try
         {
             Gb2312Encoding encoding = new Gb2312Encoding();

             string data = Regex.Replace(encoding.GetString(e.Buffer, 0, e.Buffer.Length), @"\0", "");

             EventData eventData = JsonConvert.DeserializeObject<EventData>(data);
             byte[] bytes = new byte[1024];
             e.SetBuffer(bytes, 0, bytes.Length);
             this._syn.Send(this.GetText, eventData);
             //执行连接
             this._socket.ReceiveAsync(this._socketArgs);
         }
…
//同步上下文调用的方法
private void GetText(object data)
{
    if (data == null)
        return;
    EventData eventData = (EventData)data;
    _list.Add(eventData);
    this.Dispatcher.BeginInvoke(new Action(() =>
    {
        this.dataGridRecords.ItemsSource = null;
        this.dataGridRecords.ItemsSource = _list;
        this.dataGridRecords.UpdateLayout();
        this.dataGridRecords.SelectedIndex = _list.Count - 1;
        this.dataGridRecords.ScrollIntoView(this.dataGridRecords.SelectedItem, null);
    }));
}

这样就实现了Silverlight客户端对于Sql Server Profiler的实时监控。

两个项目很简单：

先运行 SqlServerProfier.Host程序：

正在对外发送监控数据，

然后运行宿主SL客户端程序的Web端：

如果是慢查询的部分，我会用红色把它标红，从而确定慢查询语句，优化系统

总结：

当然，你还可以在监控程序中，对于跟踪记录进行Log写入或者一个特定Log表的插入，通过Web端（不管是Silverlight还是asp.net mvc均可以查询相关的跟踪记录），从而达到对于数据库SQL执行的监控。

附上源代码：SqlServerProfiler.rar

本文链接

利用Mono.Cecil动态修改程序集来破解商业组件（仅用于研究学习）

2012-05-13T17:16:00Z

Mono.Cecil是一个强大的MSIL的注入工具，利用它可以实现动态创建程序集，也可以实现拦截器横向切入动态方法，甚至还可以修改已有的程序集，并且它支持多个运行时框架上例如：.net2.0/3.5/4.0，以及silverlight程序

官方地址：http://www.mono-project.com/Cecil

首先，我先假想有一个这样的商业组件，该组件满足了以下条件：

1. 该程序集的代码被混淆过了

2. 该程序集被强命名签名过了

3. 该程序集的UI界面被加上了版权信息，例如水印等等

这里我引用的是之前写的一篇文章中的用户登录的组件（http://www.cnblogs.com/liping13599168/archive/2010/05/07/1729357.html），并将其进行改造成一个Silverlight组件，项目结构如图：

其中BusinessComponent类库作为选定的”商业组件"，这里编写一个CopyRight类，作为水印的打印信息：

internal sealed class Copyright
{
    internal void SetRightInfo(TextBlock textBlock)
    {
        textBlock.Text = "This is a watermark.";
    }
}

运行效果为：

可以看到组件上面附带一个版权信息效果

接着，要对BusinessComponent进行强命名签名，选择项目右键，如下设置：

新建一个snk文件，这个文件利用RSA加密包含着公钥和私钥的信息，对该组件编译会把它编译进去了。

这个snk到底做什么用的呢？一会儿大家看着就知道了。

最后，我要利用Dotfuscator混淆工具，对于BusinessComponent.dll进行代码混淆

由于我这里的Dotfuscator使用的老版本的4.2，所以不支持对于Sliverlight程序集的混淆，有兴趣的朋友可以自己下载试试，官方地址是：http://www.preemptive.com

好了，到这里，一个BusinessComponent商业组件的雏形设计好了。现在拿起手上的工具——Mono.Cecil去改造它了。

首先官方下载了一个mono.cecil的项目，打开工程主动去编译一下，在目录Silverlight_Release就能够获取Mono.Cecil.dll

那么，把它引入到项目中来，在页面中加入一个按钮，点击触发事件程序：

var entryPointPart = Deployment.Current.Parts.First(asmPart => asmPart.Source == "BusinessComponent.dll");
var entryPointResourceInfo = Application.GetResourceStream(new Uri(entryPointPart.Source, UriKind.Relative));
var module = ModuleDefinition.ReadModule(entryPointResourceInfo.Stream);
var type = module.Types.FirstOrDefault(o => o.Name == "Copyright");
var method = type.Methods.FirstOrDefault(o => o.Name == "SetRightInfo");
Instruction instruction = method.Body.Instructions[2];
instruction.Operand = "";
module.Write("C:\\BusinessComponent.dll");

其中module获取程序集中的Module模块，module.Types可以得到程序集中的所有类型：

选择Type的类型名称为Copyright，通过type.Methods可以得到该类型得到的所有方法：

选择Method的名称为SetRightInfo，method.Body.Instructions可以得到该方法里面的IL堆栈调用信息：

我们看到索引2这行的信息，ldstr是定义一个字符串常量的方式，而索引3通过索引2行的值，赋值给TextBlock中，请查看Copyright的代码就可以知道。于是：

Instruction instruction = method.Body.Instructions[2];
instruction.Operand = "";

这样就可以把该水印信息去除了，是不是很简单呢：）

最后一行module.Write("C:\\BusinessComponent.dll");就是将修改过后的程序集重新写入到一个新的程序集中；

执行程序，在C盘就得到一个BusinessComponent的新程序集了。

现在，我重新引入该新的程序集，看是否水印信息会被去掉，重新编译，发现编译出错：

这是为什么？这就是我上面提到的利用snk的强命名签名了，它的目的是为了防止你的程序集被非法篡改而设置的，而需要破解它就需要它的私钥了，可是作为一个真正的商业组件，我们是没有办法得到它的私钥，那是不是意味着没办法破解了呢。

那么我重新通过sn.exe进行重新签名：

sn –R BusinessComponent.dll mykey.snk

显示公钥不配对。这个是显然的，因为之前通过VS的Sign标签人工设置business.snk，它采用的是这个文件的公钥，而mykey.snk就要采用它自己的公钥了。

既然无法破解，那我就去改掉它的签名，利用我自定义的公钥和私钥去做签名，而恰恰好，Mono.Cecil就可以满足你的需要。

打开VS2010命令提示窗口，在C盘上输入：

sn -k mykey.snk

这样就随机产生了一条包含公钥和私钥的RSA文件，接着要抽取出它的公钥，输入：

sn –p mykey.snk mykey.PublicKey

紧接着输入：

sn –tp mykey.PublicKey

就可以得到公钥的数据，例如publicKey以及publicKeyToken

得到了两串字符串，把它们都复制出来，继续在刚才的按钮代码中补充：

var entryPointPart = Deployment.Current.Parts.First(asmPart => asmPart.Source == "BusinessComponent.dll");
var entryPointResourceInfo = Application.GetResourceStream(new Uri(entryPointPart.Source, UriKind.Relative));
var module = ModuleDefinition.ReadModule(entryPointResourceInfo.Stream);
module.Assembly.Name.PublicKey = this.GetPublicKey();
module.Assembly.Name.PublicKeyToken = this.GetPubliKeyToken();

private byte[] GetPublicKey()
{
    string s = "0024000004800000940000000602000000240000525341310004000001000100c5f2c7d8057257ea3640b93b7a98b1a5501718196589973b09b94cf47fb246c8ad86ae688caa36959d9793702c27ce198a447d69ba0ddac70075fab16748999f066795de472dfb5cd9347a10f967e750ca388aaa9a66619291003345b0176dec0008d3d88986c4605c0d60e3b6563f96984c6d28aeb4bf2d672e8d2d2123c394";
    return this.StrToHexBytes(s);
}
private byte[] GetPubliKeyToken()
{
    string s = "d2850434514ae5ca";
    return this.StrToHexBytes(s);
}
private byte[] StrToHexBytes(string hexString)
{
    hexString = hexString.Replace(" ", "");
    if ((hexString.Length % 2) != 0)
        hexString += " ";
    byte[] returnBytes = new byte[hexString.Length / 2];
    for (int i = 0; i < returnBytes.Length; i++)
        returnBytes[i] = Convert.ToByte(hexString.Substring(i * 2, 2), 16);
    return returnBytes;
}

其中StrToHexBytes方法，将字符串转换为十六进制的字节数组

重新编译执行，它的公钥信息就已经编译进去了，同样在C盘生成BusinessComponent.dll新程序集

这个时候，先不着急引入程序集，先对新程序集通过私密对其进行重新签名，输入命令：

sn –R BusinessComponent.dll mykey.snk

OK，现在就可以重新引入了，这个时候再重新编译代码：

编译通过了。

现在运行下程序（这里要注意，你必须将SilverlightApp程序切换到OOB模式，才可以修改程序集）：

水印信息已经被去除了：）

Mono.Cecil还可以用来做很多东西，比如说可以在一个方法中增加其他代码，能够细到IL中的每一个执行步骤，所以通过它可以做很多有意思的东西，比如说单元测试中的Mock对象以及性能上更佳的反射功能。

附上本文源代码：SilverlightMonoCecilDemo.rar

本文链接

Silverlight 4以下版本模拟鼠标双击事件

2012-03-16T05:57:00Z

在Silverlight 5的新特性中已经包含了鼠标双击的事件，看以下的代码

在事件实现中：

private void ellipse1_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
        {
            //判断鼠标在系统设置的双击间隔时间之内被点击了两次则弹出窗口显示
            if (e.ClickCount == 2)
            {
                MessageBox.Show("鼠标左键点击"+e.ClickCount.ToString());
            }
        }

而在Silverlight4以下版本均不包含ClickCount的属性，那么只能自己实现，于是，实现了一个模拟鼠标双击的功能：

    public class MouseTool
    {
        //双击事件定时器
        private DispatcherTimer _timer;
        //是否单击过一次
        private bool _isFirst;

        public MouseTool()
        {
            this._timer = new DispatcherTimer();
            this._timer.Interval = new TimeSpan(0, 0, 0, 0, 400);
            this._timer.Tick += new EventHandler(this._timer_Tick);
        }

        /// <summary>
        /// 判断是否双击
        /// </summary>
        /// <returns></returns>
        public bool IsDoubleClick()
        {
            if (!this._isFirst)
            {
                this._isFirst = true;
                this._timer.Start();
                return false;
            }
            else
                return true;
        }

        //间隔时间
        void _timer_Tick(object sender, EventArgs e)
        {
            this._isFirst = false;
            this._timer.Stop();
        }
    }

在事件调用中如下：

private MouseTool _mouseTool = new MouseTool();

public void GridSplitter_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
        {
            if (this._mouseTool.IsDoubleClick())
            {
//...

就是这么简单！

本文链接

利用Nginx+Mono+Fastcgi代替IIS对Asp.Net进行反向代理

2012-03-04T08:31:00Z

Nginx的好处相信我不必多说了，它作为一个相当轻量级的开源Web 服务器以及反向代理服务器而深受欢迎。越来越多的公司已经对它产生兴趣，包括我们公司的许多部门，利用它进行负载均衡和资源管理，之前写过一篇关于利用Nginx进行负载均衡的文章（http://www.cnblogs.com/liping13599168/archive/2011/04/15/2017369.html）。

本篇文章介绍怎样通过Nginx进行反向代理，并运行asp.net网站，测试环境我使用的是Win7系统。

首先，需要下载Nginx的安装包：

http://nginx.org/en/download.html，这里我下载最新版本：nginx/Windows-1.1.16

解压包可以看到目录：

nginx就是执行文件的入口，打开conf目录，可以看到nginx.conf文件，这个作为Nginx主要的配置入口：

server {
listen 8000;
server_name 127.0.0.1;

#charset koi8-r;

…

}

这里我将默认的80改成8000，作为nginx的Web服务器的默认端口，从这里我们可以这样理解，8000作为网站对外公布的Web端口，即代理服务的端口，现在，我就可以让它承载内网中的相关Web站点。

现在我在IIS服务器上添加一个新站点：

在上面部署一个asp.net网站，端口设置为88，88端口可以看作内网中的一个非开放的端口，网站放在目录 D:\WebApplication\WebApplication 中，现在修改nginx.conf中的配置为：

        location / {
               root D:\WebApplication\WebApplication;
               index index.html index.htm default.aspx Default.aspx;
               proxy_pass http://127.0.0.1:88;
                        proxy_set_header X-Real-IP $remote_addr;
        }

其中，root参数可以设置对应网站的目录，index可以设置站点的默认页面，proxy_pass对于IIS中的88端口对应站点进行代理；

现在启动nginx，命令为：start nginx；而停止命令为：nginx –s stop

现在在浏览器中输入：http://127.0.0.1:8000/，显示：

OK!测试成功,这样就是实现了对IIS中站点的反向代理,当然您也可以通过对其他Web服务器进行反向代理，如Apache，Resin，Fastcgi等等。这里我想要分享一个Fastcgi代替IIS作为Web服务器的方案。

我们可能知道在Linux上Mono的部署运行，可以通过非IIS的方式进行运行，包括Apache，Resin，Fastcgi，Lighttpd等等，现在我们就在Windows上利用Mono的Fastcgi模块实现在非IIS宿主情况下运行asp.net网站。

去Mono官方网站下载Mono for windows版本安装包：

http://www.go-mono.com/mono-downloads/download.html

下载包为mono-2.10.8-gtksharp-2.12.11-win32-1.exe，安装一下，在我们本地的GAC上包括了Mono的相关DLL；

继续创建一个asp.net站点，这次不需要把站点部署的IIS上面，这次利用nginx通过fastcgi进行反向代理。修改nginx.conf配置文件为：

location / {
    root Web;
    index index.html index.htm default.aspx Default.aspx;
        fastcgi_index Default.aspx;
       fastcgi_pass 127.0.0.1:9000;
       include fastcgi_params;
}

其中，Web是站点存放的目录，fastcgi_index作为fastcgi的默认页面，fastcgi_pass 设置它的站点，这里设置一个端口9000，实际上它是一个tcp协议的端口。

另外需要在fastcgi_params配置文件中添加这两行：

fastcgi_param PATH_INFO "";
fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;

现在运行Mono-2.10.8 Command Prompt：

输入mono中的fastcgi-mono-server命令，可以使用两种方式：fastcgi-mono-server2和fastcgi-mono-server4，其中前者对应CLR2.0运行时宿主，后者对应CLR4.0运行时宿主：

fastcgi-mono-server2 /applications=/:. /socket=tcp:127.0.0.1:9000 /port=8000 /root="F:\nginx-1.1.16\Web"

执行一下，接着重新执行nginx，在浏览器再次输入：http://127.0.0.1:8000/default.aspx，显示：

显示正常！说明配置的asp.net站点已经在非IIS的情况下运行良好了：）

本文链接

Thrift初探：简单实现C#通讯服务程序

2011-09-15T00:43:00Z

      好久没有写文章了，由于换工作了，所以一直没有时间来写博。今天抽个空练练手下~最近接触了下Thrift，网上也有很多文章对于Thrift做了说明：
      Thrift是一种可伸缩的跨语言服务框架，它结合了功能强大的软件堆栈的代码生成引擎，以建设服务，工作效率和无缝地与C++，C#，Java，Python和PHP和Ruby结合。thrift允许你定义一个简单的定义文件中的数据类型和服务接口。以作为输入文件，编译器生成代码用来方便地生成RPC客户端和服务器通信的无缝跨编程语言。
      它的好处是什么？当然是它支持大多数时下流行的语言。通过Thrift命令自动生成相应的语言脚本。而进行一些性能对比中，它的好处显而易见。

以上是传输相同的内容时内容大小的对比。

以上是运行开销比较结果。

TCompactProtocol和TBinaryProtocol是Thrift支持的两种协议，其中TCompactProtocol使用Variable-Length Quantity (VLQ) 编码对数据进行压缩。

详细可以查看：http://www.javabloger.com/article/apache-thrift-architecture.html

接下来，我想讲述一下如何使用Thrift搭建C#版的客户端以及服务端通讯的程序。

1. 先从官网下载Thrift安装包以及签出SVN源码：

官网下载地址：http://thrift.apache.org/download/

这里我下载了一个Thrift compiler for Windows版本的EXE文件(thrift-0.7.0.exe)

签出SVN源码地址：http://svn.apache.org/repos/asf/thrift/trunk

2. 这里我利用文章（http://www.javabloger.com/article/thrift-java-code-example.html）的例子（该例子生成Java源码的），完成一个C#版本的示例。

3. 首先创建脚本，命名为textCsharp.thrift，脚本内容如下：

namespace java com.javabloger.gen.code   #  注释1

struct Blog {   #  注释2
    1: string topic
    2: binary content
    3: i64    createdTime
    4: string id
    5: string ipAddress
    6: map<string,string> props
  }

service ThriftCase {  #  注释3
    i32 testCase1(1:i32 num1, 2:i32 num2, 3:string  num3)  #  注释4

    list<string> testCase2(1:map<string,string>  num1)

    void testCase3()

   void testCase4(1:list<Blog> blog)
}

4. 执行thrift命令：thrift -gen csharp testCsharp.thrift，这里说明一下：参数"csharp”意味着这里将自动生成C#代码，如果这里写java，python等等，可以用"java"或者"py”代替。

于是得到gen-csharp的目录，这个目录里面就包含支持Thrift的Blog以及ThriftCase的源代码，具体里面都生成什么代码，后面会做出介绍。

5. 然后，我现在打开SVN源码中的 trunk\lib\csharp\ 路径，我用项目打开

编译后，得到Thrift.dll文件，为了后面使用Thrift做准备。

6.新建工程，添加Server以及Client项目，把刚才生成的代码文件放入Common项目中。让Client和Server项目引用Thrift.dll类库。

7. 编写服务端程序：

public class Server
{
    public void Start()
    {
        TServerSocket serverTransport = new TServerSocket(7911, 0, false);
        ThriftCase.Processor processor = new ThriftCase.Processor(new BusinessImpl());
        TServer server = new TSimpleServer(processor, serverTransport);
        Console.WriteLine("Starting server on port 7911 ...");
        server.Serve();
    }
}

其中BusinessImpl具体提供业务逻辑的实现：

public class BusinessImpl : ThriftCase.Iface
    {
        public int testCase1(int num1, int num2, String num3)
        {
             int i = num1 + num2;
             Console.Write( "testCase1  num1+num2 is :"+ i);
            Console.WriteLine( "   num3 is :"+ num3);
             return i;
        }

        public List<String> testCase2(Dictionary<String, String> num1)
        {
            Console.WriteLine("testCase2 num1 :" + num1);
            List<String> list = new List<String>();
            list.Add("num1");
            return list;
        }

        public void testCase3()
        {
            Console.WriteLine("testCase3 ..........." + DateTime.Now);
        }

        public void testCase4(List<Blog> blogs)
        {
            Console.WriteLine("testCase4 ...........");

            for (int i = 0; i < blogs.Count; i++)
            {
                Blog blog = blogs[i];
                Console.Write("id:" + blog.Id);
                Console.Write(",IpAddress:" + blog.IpAddress);
                //Console.Write (",Content:" + new String(blog.Content));
                Console.Write(",topic:" + blog.Topic);
                Console.Write(",time:" + blog.CreatedTime);
            }
            Console.WriteLine("\n");
        }
    }

让它继承ThriftCase.Iface接口。

8. 编写客户端程序：

class Client
    {
        static Dictionary<String, String> map = new Dictionary<String, String>();
        static List<Blog> blogs = new List<Blog>();

        static void Main(string[] args)
        {
            TTransport transport = new TSocket("localhost", 7911);
            TProtocol protocol = new TBinaryProtocol(transport);
            ThriftCase.Client client = new ThriftCase.Client(protocol);
            transport.Open();
            Console.WriteLine("Client calls .....");
            map.Add("blog", "http://www.javabloger.com%22);/

            client.testCase1(10, 21, "3");
            client.testCase2(map);
            client.testCase3();

            Blog blog = new Blog();
            //blog.setContent("this is blog content".getBytes());
            blog.CreatedTime = DateTime.Now.Ticks;
            blog.Id = "123456";
            blog.IpAddress = "127.0.0.1";
            blog.Topic = "this is blog topic";
            blogs.Add(blog);

            client.testCase4(blogs);

            transport.Close();

            Console.ReadKey();
        }
    }

9. 运行Server以及Client：

从客户端调用的方法，服务端已经接收到了数据。

源代码下载：ThriftCSharp.rar

后面的文章，我会具体介绍下Thrift的工作机制和原理。

本文链接

对于.Net中C#指针的研究

2011-07-28T03:55:00Z

在C/C++中，对于指针的使用是很普遍的，可以这么说，如果没有指针的运用，都不知道程序如何来写。在.Net中，同样也是可以使用指针的，不过必须通过开启不安全的代码来使用。在默认情况下，新建的项目是不允许使用不安全的代码，这样，就必须通过设置项目来开启使用，通过设置项目“属性”的“生成”来达到：

勾选“允许不安全代码”的选项就OK了。

1、unsafe

要使用指针，还不必须在你的方法体或者是某个作用域中添加unsafe关键字，如：

unsafe static void Main(string[] args)
{

// 不安全代码编写

}

或者：

unsafe
{

// 不安全代码编写

}

2、stackalloc

关键字stackalloc是用于申请栈内存。stackalloc类似于C库中的_alloca。通过使用stackalloc可以自动启用CLR中的缓冲区溢出检测功能。当函数执行完毕后，内存会被自动回收。

使用它的目的通过它来实现对栈内存的使用，从而减少对堆的使用，减少系统开销。

如下参考程序：

int* array = stackalloc int[10];
for (int index = 0; index < 10; index++)
{
array[index] = index;
}
for (int index = 0; index < 10; index++)
{
Console.WriteLine(array[index].ToString());
}

代替了程序：int[] array = new int[10]; 等同于System.Array的数据存在堆中，这里通过指针的方式减少系统的开销。

3、IntPtr 和 ref

IntPtr是.Net提供的托管指针，ref是C#语言中的关键字，和IntPtr没有关系，尽管它们使用起来很类似。区别在于，使用ref可以引用Class，共同点它们都可以引用值类型，包括Struct结构体等等。

接着，编写一个Struct结构体：

    [StructLayout(LayoutKind.Sequential)]
    public struct ST_TERMPARA
    {
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 6)]
        public byte[] szAcqID_n_9F01;                /**<(TERM)收单行标识*/
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 5)]
        public byte[] szAddTermCap_b_9F40;        /**<(TERM)附加终端性能*/
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 2)]
        public byte[] szMerCateCode_n_9F15;        /**<(TERM)商户分类码*/
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 15)]
        public byte[] szMerID_ans_9F16;            /**<(TERM)商户标识*/
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 40)]
        public byte[] szMerNameLoc_ans;            /**<(TERM)商户名称和位置*/
        public byte cMessageType_n;                /**<(TERM)报文类别*/
        public byte cEntryMode_n_9F39;                /**<(TERM)销售点（POS）输入方式*/
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)]
        public byte[] szTermCap_b_9F33;            /**<(TERM)终端性能*/
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 2)]
        public byte[] szTermCountryCode_b_9F1A;    /**<(TERM)终端国家代码*/
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)]
        public byte[] szTermId_an_9F1C;            /**<(TERM)终端号*/
        public byte cTypeTerm_n_9F35;                /**<(TERM)终端类型*/
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 2)]
        public byte[] szCurCode_n_5F2A;            /**<(TERM)交易货币代码*/
        public byte cCurExp_n_5F36;                /**<(TERM)交易货币指数*/
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 2)]
        public byte[] szRefCurrCode_n_9F3C;        /**<(TERM)交易参考货币代码*/
        public byte cRefCurrExp_n_9F3D;            /**<(TERM)交易参考货币指数*/
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
        public byte[] szRefRate_n;                    /**<(TERM)交易参考货币兑换比率*/
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)]
        public byte[] szIFD_an_9F1E;                /**<(TERM)接口设备（IFD）序列号*/
    }

这里我引用项目中的一个结构体，具体字段不多说了，就是一些为字节数字的参数字段。另外MarshalAs特性可以设置非托管数组时的长度。

为了方便，这里编写一个初始化的结构体：

ST_TERMPARA para;
para.szAcqID_n_9F01 = Enumerable.Repeat<byte>(0x01, 6).ToArray();
para.szAddTermCap_b_9F40 = Enumerable.Repeat<byte>(0x02, 5).ToArray();
para.szMerCateCode_n_9F15 = Enumerable.Repeat<byte>(0x03, 2).ToArray();
para.szMerID_ans_9F16 = Enumerable.Repeat<byte>(0x04, 15).ToArray();
para.szMerNameLoc_ans = Enumerable.Repeat<byte>(0x05, 40).ToArray();
para.cMessageType_n = 0x06;
para.cEntryMode_n_9F39 = 0x07;
para.szTermCap_b_9F33 = Enumerable.Repeat<byte>(0x08, 3).ToArray();
para.szTermCountryCode_b_9F1A = Enumerable.Repeat<byte>(0x09, 2).ToArray();
para.szTermId_an_9F1C = Enumerable.Repeat<byte>(0x0a, 8).ToArray();
para.cTypeTerm_n_9F35 = 0x0b;
para.szCurCode_n_5F2A = Enumerable.Repeat<byte>(0x0c, 2).ToArray();
para.cCurExp_n_5F36 = 0x0d;
para.szRefCurrCode_n_9F3C = Enumerable.Repeat<byte>(0x0e, 2).ToArray();
para.cRefCurrExp_n_9F3D = 0x0f;
para.szRefRate_n = Enumerable.Repeat<byte>(0x10, 4).ToArray();
para.szIFD_an_9F1E = Enumerable.Repeat<byte>(0x10, 8).ToArray();

获取它的句柄，也就是指针IntPtr：

int size = Marshal.SizeOf(para);
IntPtr intPtr = Marshal.AllocHGlobal(size);
Marshal.StructureToPtr(para, intPtr, true);
byte* bytes = (byte*)intPtr.ToPointer();

通过对于bytes指针的内存地址的遍历：

for (int index = 0; index < size; index++)
{
Console.Write(*(bytes + index) + ",");
}

写法是不是和C指针的写法一样呢。运行结果，可以输出初始化的值。

比较函数调用，数据传递效率：

编写测试程序：

CodeTimer.Time("结构体的数据传递", 10000000, () => { GetValue(para); });

CodeTimer.Time("结构体Ref的数据传递", 10000000, () => { GetValue(ref para); });

CodeTimer.Time("结构体IntPtr的数据传递", 10000000, () => { GetValue(intPtr); });

其中：

static void GetValue(ST_TERMPARA para)
{
    // ...
}

static void GetValue(ref ST_TERMPARA para)
{
    // ...
}

static void GetValue(IntPtr intPtr)
{
    // ...
}

运行结果：

从结果上看，结构体的直接传递耗时最长，因为Struct是个值类型，在进行函数传值时，会在参数上拷贝一份新的Struct对象，而结构体ref的数据传递，由于只需要传递引用该结构体的“指针”，而IntPtr同样本身作为结构体的指针，所以效率上后两者比第一个要高。

另外，从多次的运行结果上来看，Ref比IntPtr的传递效率总是高一些，至于为什么，不是很了解其中的机制，看哪些朋友能够给我些指点，感谢。

本文链接

各大主流.Net的IOC框架性能测试比较

2011-07-17T09:34:00Z

在上一篇中，我简单介绍了下Autofac的使用，有人希望能有个性能上的测试，考虑到有那么多的IOC框架，而主流的有：Castle Windsor、微软企业库中的Unity、Spring.NET、StructureMap、Ninject等等。本篇文章主要针对这些IOC框架编写测试程序。

Autofac下载地址：http://code.google.com/p/autofac/

Castle Windsor下载地址：http://sourceforge.net/projects/castleproject/files/Windsor/2.5/Castle.Windsor.2.5.3.zip/download

Unity下载地址：http://entlib.codeplex.com/

Spring.NET下载地址：http://www.springframework.net/

StructureMap下载地址：http://sourceforge.net/projects/structuremap/files/

Ninject下载地址：http://ninject.org/download

其中，测试程序均采用最新的类库。

基础工作

1、程序还是引用上一篇的示例作为测试背景。

2、编写一个性能计数器，这里我采用老赵写的一个CodeTimer的类，具体介绍见：http://www.cnblogs.com/JeffreyZhao/archive/2009/03/10/codetimer.html

使用方式类似于：

int iteration = 100 * 1000;string s = "";
CodeTimer.Time("String Concat", iteration, () => { s += "a"; });
StringBuilder sb = new StringBuilder();
CodeTimer.Time("StringBuilder", iteration, () => { sb.Append("a"); });

3、编写一个IRunner运行接口：

public interface IRunner
{
void Start(RunType runType);
}

以及RunnerBase抽象基础运行类：

public abstract class RunnerBase
{
    private int _iteration = Convert.ToInt32(System.Configuration.ConfigurationSettings.AppSettings["Iteration"] ?? "10000");
    internal int Iteration
    {
        get { return _iteration; }
    }

    internal void Time(Action action)
    {
        CodeTimer.Time(Name, Iteration, action);
    }

    protected abstract string Name { get; }
}

这里_iteration表示测试运行次数，通过配置文件来设置值。Time方法通过计数器对action方法进行Iteration次迭代。

编写一个RunManager的运行管理器：

public class RunManager
{
    public static void Start(IRunner runner)
    {
        Start(runner, RunType.Transient);
    }

    public static void Start(IRunner runner, RunType runType)
    {
        runner.Start(runType);
    }
}

在测试中，我采用两种方式的性能比较，一个是单例状态，一个是非单例状态：

/// <summary>
/// 运行状态
/// </summary>
public enum RunType
{
    /// <summary>
    /// 单例
    /// </summary>
    Singleton,

    /// <summary>
    /// 瞬时
    /// </summary>
    Transient
}

好了，现在我的程序只要继承RunnerBase以及IRunnre接口，就可以实现各个IOC框架的初始化装配的工作了。基础工作已经做好。

各个IOC框架测试程序

1、Autofac：

public class AutofacRunner : RunnerBase, IRunner
{
    protected override string Name
    {
        get { return "Autofac"; }
    }

    public void Start(RunType runType)
    {
        var builder = new ContainerBuilder();

        //if (runType == RunType.Singleton)
        //    builder.RegisterType<DatabaseManager>().SingleInstance();
        //else
        //    builder.RegisterType<DatabaseManager>();
        //builder.RegisterType<SqlDatabase>().As<IDatabase>();
        ////builder.RegisterModule(new ConfigurationSettingsReader("autofac"));

        builder.RegisterType<SqlDatabase>().As<IDatabase>();
        if (runType == RunType.Singleton)
            builder.Register(c => new DatabaseManager(c.Resolve<IDatabase>())).SingleInstance();
        else
            builder.Register(c => new DatabaseManager(c.Resolve<IDatabase>()));

        var container = builder.Build();

        Time(() =>
        {
            var manager = container.Resolve<DatabaseManager>();
            manager.Search("SELECT * FROM USER");
        });

        container.Dispose();
    }
}

2、Castle Windsor：

public class WindsorRunner : RunnerBase, IRunner
{
    protected override string Name
    {
        get { return "Castle Windsor"; }
    }

    public void Start(RunType runType)
    {
        var container = new WindsorContainer();
        if(runType == RunType.Singleton)
            container.Register(Component.For(typeof(DatabaseManager)).LifeStyle.Singleton);
        else
            container.Register(Component.For(typeof(DatabaseManager)).LifeStyle.Transient);

        container.Register(Component.For(typeof(IDatabase)).ImplementedBy(typeof(SqlDatabase)));

        Time(() =>
        {
            var manager = container.Resolve<DatabaseManager>();
            manager.Search("SELECT * FROM USER");
        });
    }
}

3、Unity：

public class UnityRunner : RunnerBase, IRunner
{
    protected override string Name
    {
        get { return "Unity"; }
    }

    public void Start(RunType runType)
    {
        var container = new UnityContainer();
        if(runType == RunType.Singleton)
            container.RegisterType<DatabaseManager>(new ContainerControlledLifetimeManager());
        else
            container.RegisterType<DatabaseManager>(new TransientLifetimeManager());
        container.RegisterType<IDatabase, SqlDatabase>();

        Time(() =>
            {
                var manager = container.Resolve<DatabaseManager>();
                manager.Search("SELECT * FROM USER");
            });
    }
}

4、Spring.NET：

public class SpringRunner : RunnerBase, IRunner
{
    protected override string Name
    {
        get { return "Spring.NET"; }
    }

    public void Start(RunType runType)
    {
        string databaseManagerName;
        if (runType == RunType.Singleton)
            databaseManagerName = "DatabaseManager_Singleton";
        else
            databaseManagerName = "DatabaseManager_Transient";

        Time(() =>
        {
            IApplicationContext context = ContextRegistry.GetContext();
            var manager = (DatabaseManager)context.GetObject(databaseManagerName);
            manager.Search("SELECT * FROM USER");
        });
    }
}

5、StructureMap：

public class StructureMapRunner : RunnerBase, IRunner
{
    protected override string Name
    {
        get { return "StructureMap"; }
    }

    public void Start(RunType runType)
    {
        ObjectFactory.Initialize(container =>
        {
            if (runType == RunType.Singleton)
                container.ForRequestedType<DatabaseManager>().Singleton();
            else
                container.ForRequestedType<DatabaseManager>();
            container.ForRequestedType<IDatabase>().TheDefaultIsConcreteType<SqlDatabase>();
        });

        Time(() =>
            {
                var manager = ObjectFactory.GetInstance<DatabaseManager>();
                manager.Search("SELECT * FROM USER");
            });
    }
}

6、Ninject：

public class NinjectRunner : RunnerBase, IRunner
{
    protected override string Name
    {
        get { return "Ninject"; }
    }

    public void Start(RunType runType)
    {
        IKernel kernel = new StandardKernel(new MyNinjectModule(runType));

        Time(() =>
        {
            var manager = kernel.Get<DatabaseManager>();
            manager.Search("SELECT * FROM USER");
        });
    }
}

客户端测试程序

static void Main(string[] args)
{
    CodeTimer.Initialize();

    Console.WriteLine("IOC - Singleton");
    // Autofac Singleton
    RunManager.Start(new AutofacRunner(), RunType.Singleton);
    // Castle Windsor
    RunManager.Start(new WindsorRunner(), RunType.Singleton);
    // Unity
    RunManager.Start(new UnityRunner(), RunType.Singleton);
    // Spring.NET
    RunManager.Start(new SpringRunner(), RunType.Singleton);
    // StructureMap
    RunManager.Start(new StructureMapRunner(), RunType.Singleton);
    // Ninject
    RunManager.Start(new NinjectRunner(), RunType.Singleton);

    Console.WriteLine("===================================");
    Console.WriteLine("IOC - Transient");
    // Autofac Singleton
    RunManager.Start(new AutofacRunner(), RunType.Transient);
    // Castle Windsor
    RunManager.Start(new WindsorRunner(), RunType.Transient);
    // Unity
    RunManager.Start(new UnityRunner(), RunType.Transient);
    // Spring.NET
    RunManager.Start(new SpringRunner(), RunType.Transient);
    // StructureMap
    RunManager.Start(new StructureMapRunner(), RunType.Transient);
    // Ninject
    RunManager.Start(new NinjectRunner(), RunType.Transient);

    Console.ReadKey();
}

通过修改App.config的Iteration配置值，来设置迭代次数。

运行结果

1、Iteration=1000：

分析：在千数量级时，Autofac，CastleWindsor、StructureMap基本差不多，效率上比其他的要高。

2、Iteration=10000：

分析：在万数量级时，Autofac，CastleWindsor，StructureMap基本效率还是差不多，其中StructureMap效率稍稍有些下降；Spring.NET以及Ninject的性能比较低。

3、Iteration=100000：

分析：在十万数量级时，CastleWindsor的效率开始下降，而在Transient方面，StructureMap和Autofac基本差不多。

4、Iteration=1000000：

分析：在百万数量级时，Autofac和StructureMap两者还是保持比较高的效率，并且在Transient方面，StructureMap已经超过了Autofac。

总结：从测试中，可以看出Autofac和StructureMap在性能上面还是体现出比较大的优势，Ninject可以说性能上较低。而Spring.NET不仅仅专注于IOC方面，它还专注于其他方方面面的功能，所以在IOC方面的性能不是太高。另外，微软的Unity中规中矩，性能较为稳定，也是一个不错的选择。另外，可能测试程序会有所偏差，希望大家也能够指出问题！

测试程序源代码：IOCPerformanceTest.rar

本文链接

依赖注入框架Autofac的简单使用

2011-07-16T08:34:00Z

Autofac是一款IOC框架，比较于其他的IOC框架，如Spring.NET，Unity，Castle等等所包含的，它很轻量级性能上也是很高的。于是，今天抽空研究了下它。下载地址：http://code.google.com/p/autofac/downloads/list

1）解压它的压缩包，主要看到Autofac.dll，Autofac.Configuration.dll，这也是本篇文章重点使用的Autofac的类库。

2）创建一个控制台工程，并且引用以上的DLL文件。创建一个数据库操作接口IDatabase.cs：

/// <summary>
/// Database operate interface
/// </summary>
public interface IDatabase
{
string Name { get; }

void Select(string commandText);

void Insert(string commandText);

void Update(string commandText);

void Delete(string commandText);
}

这里包含CRUD四种操作的方法。

3）创建两种数据库的操作类，SqlDatabase.cs以及OracleDatabase.cs：

public class SqlDatabase : IDatabase
{
    public string Name
    {
        get { return "sqlserver"; }
    }

    public void Select(string commandText)
    {
        Console.WriteLine(string.Format("'{0}' is a query sql in {1}!", commandText, Name));
    }

    public void Insert(string commandText)
    {
        Console.WriteLine(string.Format("'{0}' is a insert sql in {1}!", commandText, Name));
    }

    public void Update(string commandText)
    {
        Console.WriteLine(string.Format("'{0}' is a update sql in {1}!", commandText, Name));
    }

    public void Delete(string commandText)
    {
        Console.WriteLine(string.Format("'{0}' is a delete sql in {1}!", commandText, Name));
    }
}

以及

public class OracleDatabase : IDatabase
{
    public string Name
    {
        get { return "oracle"; }
    }

    public void Select(string commandText)
    {
        Console.WriteLine(string.Format("'{0}' is a query sql in {1}!", commandText, Name));
    }

    public void Insert(string commandText)
    {
        Console.WriteLine(string.Format("'{0}' is a insert sql in {1}!", commandText, Name));
    }

    public void Update(string commandText)
    {
        Console.WriteLine(string.Format("'{0}' is a update sql in {1}!", commandText, Name));
    }

    public void Delete(string commandText)
    {
        Console.WriteLine(string.Format("'{0}' is a delete sql in {1}!", commandText, Name));
    }
}

4）接着创建一个数据库管理器DatabaseManager.cs：

public class DatabaseManager
{
    IDatabase _database;

    public DatabaseManager(IDatabase database)
    {
        _database = database;
    }

    public void Search(string commandText)
    {
        _database.Select(commandText);
    }

    public void Add(string commandText)
    {
            _database.Insert(commandText);
    }

    public void Save(string commandText)
    {
            _database.Update(commandText);
    }

    public void Remove(string commandText)
    {
            _database.Delete(commandText);
    }

}

5）在控制台中，编写以下测试程序：

var builder = new ContainerBuilder();
builder.RegisterType<DatabaseManager>();
builder.RegisterType<SqlDatabase>().As<IDatabase>();
using (var container = builder.Build())
{
var manager = container.Resolve<DatabaseManager>();
manager.Search("SELECT * FORM USER");
}

运行结果：

分析：

这里通过ContainerBuilder方法RegisterType对DatabaseManager进行注册，当注册的类型在相应得到的容器中可以Resolve你的DatabaseManager实例。

builder.RegisterType<SqlDatabase>().As<IDatabase>();通过AS可以让DatabaseManager类中通过构造函数依赖注入类型相应的接口。

Build()方法生成一个对应的Container实例，这样，就可以通过Resolve解析到注册的类型实例。

同样地，如果你修改数据库类型注册为：

builder.RegisterType<OracleDatabase>().As<IDatabase>();

运行结果：

6）显然以上的程序中，SqlDatabase或者OracleDatabase已经暴露于客户程序中了，现在我想将该类型选择通过文件配置进行读取。Autofac自带了一个Autofac.Configuration.dll 非常方便地对类型进行配置，避免了程序的重新编译。

修改App.config：

通过Autofac.Configuration.SectionHandler配置节点对组件进行处理。

对应的客户端程序改为：

var builder = new ContainerBuilder();
builder.RegisterType<DatabaseManager>();
builder.RegisterModule(new ConfigurationSettingsReader("autofac"));
using (var container = builder.Build())
{
var manager = container.Resolve<DatabaseManager>();
manager.Search("SELECT * FORM USER");
}

运行结果：

7）另外还有一种方式，通过Register方法进行注册：

var builder = new ContainerBuilder();
//builder.RegisterType<DatabaseManager>();
builder.RegisterModule(new ConfigurationSettingsReader("autofac"));
builder.Register(c => new DatabaseManager(c.Resolve<IDatabase>()));
using (var container = builder.Build())
{
var manager = container.Resolve<DatabaseManager>();
manager.Search("SELECT * FORM USER");
}

得到结果也是一样的。

8）现在我想通过一个用户类来控制操作权限，比如增删改的权限，创建一个用户类：

/// <summary>
/// Id Identity Interface
/// </summary>
public interface Identity
{
    int Id { get; set; }
}

public class User : Identity
{
    public int Id { get; set; }
    public string Name { get; set; }
}

修改DatabaseManager.cs代码：

public class DatabaseManager
{
    IDatabase _database;
    User _user;

    public DatabaseManager(IDatabase database) : this(database, null)
    {
    }

    public DatabaseManager(IDatabase database, User user)
    {
        _database = database;
        _user = user;
    }

    /// <summary>
    /// Check Authority
    /// </summary>
    /// <returns></returns>
    public bool IsAuthority()
    {
        bool result = _user != null && _user.Id == 1 && _user.Name == "leepy" ? true : false;
        if (!result)
            Console.WriteLine("Not authority!");

        return result;
    }

    public void Search(string commandText)
    {
        _database.Select(commandText);
    }

    public void Add(string commandText)
    {
        if (IsAuthority())
            _database.Insert(commandText);
    }

    public void Save(string commandText)
    {
        if (IsAuthority())
            _database.Update(commandText);
    }

    public void Remove(string commandText)
    {
        if (IsAuthority())
            _database.Delete(commandText);
    }
}

在构造函数中增加了一个参数User，而Add,Save,Remove增加了权限判断。

修改客户端程序：

User user = new User { Id = 1, Name = "leepy" };
var builder = new ContainerBuilder();
builder.RegisterModule(new ConfigurationSettingsReader("autofac"));
builder.RegisterInstance(user).As<User>();
builder.Register(c => new DatabaseManager(c.Resolve<IDatabase>(), c.Resolve<User>()));

using (var container = builder.Build())
{
var manager = container.Resolve<DatabaseManager>();

manager.Add("INSERT INTO USER ...");
}

运行结果：

分析：

builder.RegisterInstance(user).As<User>();注册User实例。

builder.Register(c => new DatabaseManager(c.Resolve<IDatabase>(), c.Resolve<User>()));通过Lampda表达式注册DatabaseManager实例。

如果这里我修改User的属性值：

User user = new User { Id = 2, Name = "zhangsan" };

运行结果：

说明该用户无权限操作。

源代码下载：AutofacDemo.rar

本文链接

中国金融集成电路(IC)卡规范备注

2011-07-12T01:48:00Z

学习PBOC借记贷记应用终端规范文档，对名词解释备注一下。

应用 application
卡片和终端之间的应用协议和相关的数据集。

命令 command
终端向IC卡发出的一条报文，该报文启动一个操作或请求一个响应。

密文 cryptogram
加密运算的结果。

金融交易 financial transaction
由于持卡者和商户之间的商品或服务交换行为而在持卡者、发卡机构、商户和收单行之间产生的信
息交换、资金清算和结算行为。

集成电路（IC） integrated circuit (IC)
具有处理和/或存储功能的电子器件。

集成电路卡（IC 卡） integrated circuit(s) card (ICC)
内部封装一个或多个集成电路用于执行处理和存储功能的卡片。

接口设备 interface device
终端上插入IC卡的部分，包括其中的机械和电气部分。

发卡行行为代码 issuer action code
发卡行根据TVR的内容选择的动作。

磁条 magstripe
包括磁编码信息的条状物。

支付系统环境 payment system environment
当符合JR/T 0025的支付系统应用被选择，或者用于支付系统应用目的的目录定义文件（DDF）被选
择后，IC卡中所确立的逻辑条件集合。

响应 response
IC卡处理完成收到的命令报文后，返回给终端的报文。

脚本 script
发卡行向终端发送的命令或命令序列，目的是向IC卡连续输入命令。

终端 terminal
在交易点安装、用于与IC卡配合共同完成金融交易的设备。它应包括接口设备，也可包括其它的部
件和接口（如与主机的通讯）。

终端行为代码 terminal action code
收单行根据TVR的内容选择的动作。

下列符号和缩略语适用于JR/T 0025的本部分。
AAC 应用认证密文(Application Authentication Cryptogram)
AC 应用密文(Application Cryptogram)
ADF 应用定义文件(Application Definition File)
AEF 应用基本文件(Application Elementary File)
AFL 应用文件定位器(Application File Locator)
AID 应用标识符(Application Identifier)
AIP 应用交互特征(Application Interchange Profile)
ARPC 授权响应密文(Authorization Response Cryptogram)
ARQC 授权请求密文(Authorization Request Cryptogram)
ATC 应用交易计数器(Application Transaction Counter)
ATM 自动柜员机(Automated Teller Machine)
AUC 应用用途控制(Application Usage Control)
BER 基本编码规则(Basic Encoding Rules)
CA 认证中心(Certificate Authority)
CAM 卡片认证方法(Card Authentication Method)
CDA 复合动态数据认证/应用密文生成(Combined DDA/AC Generation)
CDOL 卡片风险管理数据对象列表（Card Rish Management Data Object List）
CID 密文信息数据(Cryptogram Information Data)
cn 压缩数字型(Compressed Numeric)
CVM 持卡人验证方法（Cardholder Verification Method）
CVR 卡片验证结果(Card Verification Results)
DDA 动态数据认证(Dynamic Data Authentication)
DDF 目录定义文件(Directory Definition File)
DDOL 动态数据认证数据对象列表（Dynamic Data Authentication Data Object List）
DF 专用文件(Dedicated File)
DOL 数据对象列表(Data Object List)
EF 基本文件(Elementary File)
EMV Europay、MasterCard和VISA
FCI 文件控制信息(File Control Information)
GPO 获取处理选项（Get Processing Options）
IAC 发卡行行为代码(Issuer Action Code)
IC 集成电路(Integrated Circuit)
M 必备(Mandatory)
n 数字型(Numeric)
O 可选(Optional)
P1 参数 1(Parameter 1)
P2 参数 2(Parameter 2)
PAN 主账号(Primary Account Number)
PKI 公钥基础设施(Public Key Infrastructure)
PIN 个人识别码(Personal Identification Number)
PIX 扩展的专用应用标识符(Proprietary Application Identifier Extension)
RFU 预留(Reserved for Future Use)
RID 注册的应用提供商标识(Registered Application Provider Identifier)
SAD 签名的静态应用数据(Signed Static Application Data)
SDA 静态数据认证(Static Data Authentication)
SFI 短文件标识符(Short File Identifier)
SW1 状态字 1(Status Word One)
SW2 状态字 2(Status Word Two)
TAC 终端行为代码(Terminal Action Code)
TC 交易证书(Transaction Certificate)
TDOL 交易证书数据对象列表(Transaction Certificate Data Object List)
TLV 标签、长度、值(Tag Length Value)
TSI 交易状态信息(Transaction Status Information)
TVR 终端验证结果(Terminal Verification Results)

本文链接

使用SuperSocket实现TLV自定义协议网络通信的Demo

2011-07-09T12:24:00Z

前些天看到江大鱼发布了SuperSocket 1.4正式版，由于最近项目使用到了网口的通讯编程，于是，也查看了下SuperSocket源代码，发现架构还是很清晰的，并且易于扩展，具体中文文档详见：http://www.cnblogs.com/jzywh/archive/2011/04/19/SuperSocketDocument.html。

今天我要说的是，如果通过SuperSocket自定义一个应用协议。由于项目中的服务通过TLV的协议进行数据传输，而通过网口是其中的一个通讯方式，当然项目中还包括通过串口、USB设备、USB数据线等等进行数据传输。其中网口通讯，采用TCP通讯的方式。什么是TLV呢，可以参考一下我之前写的一篇文章：《金融系统中PBOC/EMV的TLV的算法实现》，里面对于TLV有了详细的介绍，这里不再敖述。由于项目中的TLV协议还要涉及到一些报文头以及校验码的考虑，本篇文章将跳过这些考虑，直接谈核心的数据包TLV的传输。

具体思路

1、创建一个解决方案TLVSocketDemo。

2、创建项目TLVSocketDemo.Server，这个项目主要作为服务端的基本类库，包含一些AppServer，AppSession的扩展实现。当然SuperSocket 提供了一个名叫"SocketService"的项目，它是一个能够让AppServer运行于其中的容器。于是需要把SocketService相关的一些文件复制到生成输出目录中。

3、AppServer的子类实现：

public class TLVProtocolServer : AppServer
{
    public TLVProtocolServer()
        : base(new TLVProtocol())
    {

    }
}

4、AppSession的子类实现：

public class TLVProtocolSession : AppSession
{
    public override void HandleExceptionalError(Exception e)
    {

    }
}

5、TLVEntityListCommandInfo是服务器端收到的一个命令实体类，这个类必须继承于CommandInfo：

public class TLVEntityListCommandInfo : CommandInfo>
{
    public TLVEntityListCommandInfo(string key, List data)
        : base(key, data)
    {

    }
}

实际上，TLVEntity就是一个TLV的实体结构。TLVEntity类的实现：

    [Serializable]
    ///
    /// TLV实体
    ///
    public class TLVEntity
    {
        ///
        /// 标记
        ///
        public byte[] Tag { get; set; }

        ///
        /// 数据长度
        ///
        public byte[] Length { get; set; }

        ///
        /// 数据
        ///
        public byte[] Value { get; set; }

        ///
        /// 标记占用字节数
        ///
        public int TagSize { get; set; }

        ///
        /// 数据长度占用字节数
        ///
        public int LengthSize { get; set; }

        ///
        /// 子嵌套TLV实体
        ///
        public TLVEntity Sub_TLVEntity { get; set; }
    }

6、自定义协议：TLVProtocol.cs，继承于ICustomProtocol的范型接口：

public class TLVProtocol : ICustomProtocol
{
    public ICommandReader CreateCommandReader(IAppServer appServer)
    {
        return new TLVCommandReader(appServer);
    }
}

通过创建(CreateCommandReader方法)来得到字节数组数据的的读取方式。

而TLVCommandReader主要就是作为进行命令解析。

public class TLVCommandReader : CommandReaderBase
    {
        public TLVCommandReader(IAppServer appServer)
            : base(appServer)
        {

        }

        public override TLVEntityListCommandInfo FindCommandInfo(IAppSession session, byte[] readBuffer, int offset, int length, bool isReusableBuffer, out int left)
        {
            left = 0;

            AddArraySegment(readBuffer, offset, length, isReusableBuffer);

            byte[] source = BufferSegments.ToArrayData();

            List list = TLVPackage.Construct(source);

            return new TLVEntityListCommandInfo("ECHO", list);
        }
    }
}

注意到FindCommandInfo方法可以对字节数组数据进行读取以及构造TLV实体。

TLVPackage.Construct的实现在上一篇文章有提到。

7、编写命令类：

public class ECHO : CommandBase
{
    public override void ExecuteCommand(TLVProtocolSession session, TLVEntityListCommandInfo commandInfo)
    {
        string data = BinaryUtil.BinarySerialize(commandInfo.Data);
        session.SendResponse(data);
    }
}

这里发送给客户端的数据，会先将List<Entity>列表通过序列化，并且再进行Base64编码。通过SendResponse发送到客户端。

8、修改SuperSocket.SocketService.exe.configTLV服务的相关配置。

9、最后将项目生成后，项目的路径输出到SuperSocket.SocketServer.exe对应目录中。至此编译通过以后，TLV服务的服务端已经写好了。是不是很容易呢。

10、接着创建一个TLVSocketDemo.Client的客户端程序：

static int port = 911;
static void Main(string[] args)
{
    EndPoint serverAddress = new IPEndPoint(IPAddress.Parse("127.0.0.1"), port);

    using (Socket socket = new Socket(serverAddress.AddressFamily, SocketType.Stream, ProtocolType.Tcp))
    {
        socket.Connect(serverAddress);

        byte[] data = new byte[0];
        using (FileStream stream = new FileStream(Application.StartupPath + "\\tlvdata.dat", FileMode.Open, FileAccess.Read))
        {
            using (BinaryReader reader = new BinaryReader(stream))
            {
                reader.BaseStream.Seek(0, SeekOrigin.Begin);
                data = reader.ReadBytes((int)reader.BaseStream.Length);
            }
        }

        socket.Send(data, data.Length, SocketFlags.None);

        byte[] temp = new byte[5000];

        int read = socket.Receive(temp, 0, 5000, SocketFlags.None);

        byte[] response = new byte[read];
        Array.Copy(temp, 0, response, 0, read);

        string responseText = Encoding.ASCII.GetString(response);

        List list = BinaryUtil.BinaryDeserialize>(responseText);

        Console.WriteLine("服务端已经构造{0}个TLV结构.", list.Count);

        Console.ReadKey();
    }
}

这里说明有一下，通过tlvdata.dat文件读取字节数组数据，然后发送数据到服务端，服务端处理完以后，回发给客户端，返回的是一个Base64编码。然后编译Client的代码，通过完成。

11、最后运行程序，首先运行SuperSocket.SocketService的服务，直接可以点开RunServer.bat，或者也可以通过InstallService.bat进行Windows服务的安装；接着运行客户端程序TLVSocketDemo.Client：

Server端：

Client端：

说明服务端对TLV字节数组数据已经构造了2个TLV结构。通过ExecuteCommand的参数可以得到CommandInfo的Data数据，它就是List<TLVEntity>。

总结：SuperSocket的自定义协议的扩展还是很容易使用的，大家也可以通过该扩展方式自定义你自己的应用协议。

附上Server和Client的Demo源代码：TLVSocketDemo.rar

本文链接