博客园_Leepy's Blogs

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

本文链接

NLayerApp分层架构学习笔记

2011-07-07T01:07:00Z

1、crossdomain.xml主要是为了让RIA（Flash、Silverlight）跨域来访问文件。

2、SOAPAction HTTP request header被用来标识SOAP HTTP请求的目的地，其值是个URI地址。SOAP发送并不限制格式、URI特征或其必须可解析，那么在这种情况下，发送一个HTTP SOAP请求时，其HTTP客户端必须使用/指明SOAPAction HTTP request header。

SOAPAction header的内容可以被用在服务端，诸如：防火墙适当的过滤基于HTTP的SOAP请求消息等场景。SOAPAction header的值为空串("")表示SOAP消息的目的地由HTTP请求的URI标识；无值则表示没有指定这条消息的目的地。

3、MVC.Client中

Global.asax注册路由映射；

routes.MapRoute( 
"Paged", // Route name 
"{controller}/{action}/{page}/{pageSize}", // URL with parameters 
new { controller = "Home", action = "Index" }, // Parameter defaults 
new { page = @"\d+", pageSize = @"\d+"} 
);

page和pageSize正则约束；

IoCFactory(IOC工厂)单例类，默认创建一个IoCUnityContainer类；

IBootStrapper Boot包装接口，默认创建一个DefaultBootStrapper类，里面可以通过Boot方法来注册MV的相关绑定，包括Controller，Model，以及工厂。

public void Boot() 
{ 
    //Register controllers into MVC infrastructure 
    RegisterControllers();

    //Register new model binders 
    RegisterModelBinders();

    //register factories 
    RegisterFactories(); 
}

RegisterControllers注册相关Controller类。

其中RegisterModelBinders注册SelfTrackingEntityModelBinder<Customer>，SelfTrackingEntityModelBinder作为一个自定义的模型绑定器。将Hidden的Base64值反序列化为实体。然后通过Action的参数获取该实体，如Edit/Customer的实现。

RegisterFactories

IControllerFactory默认使用IoCControllerFactory，并且设置ControllerBuilder.Current.SetControllerFactory(factory);

MvcHandler类通过使用单例类ControllerBuilder的GetControllerFactory方法获取当前指定的IControllerFactory对象，通过此对象来生成具体的IController控制器。

通过ControllerBuilder的SetControllerFactory方法我们可以指定自定义的控制器工厂，自定义工厂可以直接实现IControllerFactory接口，也可以从DefaultControllerFactory类继承

通过IoCUnityContainer，注册其他层组件中的相关服务以及仓储：

public IoCUnityContainer() 
{ 
    _ContainersDictionary = new Dictionary();

        //Create root container 
    IUnityContainer rootContainer = new UnityContainer(); 
    _ContainersDictionary.Add("RootContext", rootContainer);

        //Create container for real context, child of root container 
    IUnityContainer realAppContainer = rootContainer.CreateChildContainer(); 
    _ContainersDictionary.Add("RealAppContext", realAppContainer);

        //Create container for testing, child of root container 
    IUnityContainer fakeAppContainer = rootContainer.CreateChildContainer(); 
    _ContainersDictionary.Add("FakeAppContext", fakeAppContainer);

   
    ConfigureRootContainer(rootContainer); 
    ConfigureRealContainer(realAppContainer); 
    ConfigureFakeContainer(fakeAppContainer); 
}

RootContainer作为公共的容器。RealAppContainer作为真实场景的容器；FakeAppContainer作为模拟场景的容器。

这里采用层级容器的好处是我们可以对于有不同生命周期的对象放在不同的容器中，如果一个子容器被释放，不会影响到其它子容器中的对象，但是如果根节点处父容器释放后，所有的子容器都将被释放。
这样以后可以直接通过Resolve<T>获得接口服务。

ISalesManagementService salesManagement = IoCFactory.Instance.CurrentContainer.Resolve();

4、使用Html.RenderAction方法

呈现用户控件内容的方式和一般情况下呈现视图的方式相同，即通过控制器决定呈现哪个具体的用户控件内容。RenderAction方法可以灵活的通过控制器选择呈现特定的视图、用户控件或部分内容。

5、<%= Html.DisplayFor(x => x.PageItems) %>

由于在IPagedView中，有一个属性：

///  
/// Gets the page items. 
///  
/// The page items. 
[UIHint("IEnumerable")] 
IEnumerable PageItems { get; }

这样视图引擎就会去遍历目录，从Shared的DisplayTemplate中去查找IEnumerable.ascx：

1 <% foreach (var item in Model)
2 {
3 ViewData["item"] = item;
4 string templateName = (string)string.Concat(item.GetType().Name,"Item");
5 %>
6 <%: Html.Display("item",templateName) %>
7 <% } %>

6、tml.Display("item",templateName)从而从CustomerItem.ascx模板中去加载表达式为item的数据（ViewData[“item”]=item;

7、File(photo.Photo, "img") Controller基类中的File方法可以返回一个文件内容和文件类型的FileContentResult对象。

8、使用的 SQL Server 版本不支持数据类型“datetime2”的解决办法

错误原因，在使用ado.net entity的时候，entity使用的数据库是sqlserver 2008，

但后来实际使用中使用的数据库是sqlserver 2005，

使用的 SQL Server 版本不支持数据类型“datetime2”

The version of SQL Server in use does not support datatype ‘datetime2
解决办法
Open your EDMX in a file editor (or “open with…” in Visual Studio and select XML Editor). At the top you will find the storage model and it has an attribute ProviderManifestToken. This has should have the value 2008. Change that to 2005, recompile and everything works.

就是打开你的edmx文件，搜索ProviderManifestToken值，改为2005就ok了

9、T4模板引擎的使用，自动生成ADO.NET 实体数据类型类。

10、Silverlight项目

MenuControl.xaml为右上角的菜单条；((MainPage)App.Current.RootVisual).actualState 可以获得MainPage中的actureState变量。VisualStateManager.GoToState(mainPage, "ToCustomer", true);对当前功能状态进行切换。

11、MainPage中的初始化函数中

this.MouseWheel += new MouseWheelEventHandler(MainPage_MouseWheel); 
actualState = "ToCustomer";

MouseWheel方法对用鼠标滚轮使用时候，对当前功能状态的切换。

12、M-V-VM模式，例如视图中CustomerListView后台中与VMCustomerListView进行双向绑定，其中VMCustomerListView为ViewModels中的类

ListBox中的属性SelectedItem="{Binding SelectedCustomer, Mode=TwoWay}"绑定VMCustomerListView的SelectedCustomer；

属性ItemsPanel="{StaticResource ItemsPanelTemplate}"设置每一条项（Customer）的UI显示方式（这里为StackPanel）；

ItemTemplate="{StaticResource CustomerDataTemplate}"设置他的自定义数据模板，其中CustomerDataTemplate对应：

1 <DataTemplate x:Key="CustomerDataTemplate">
2 <Border Padding="2" Width="786">
3 <Grid ToolTipService.ToolTip="{Binding ContactName}" Cursor="Hand">
4 <Grid.ColumnDefinitions>
5 <ColumnDefinition/>
6 <ColumnDefinition Width="Auto" MinWidth="295"/>
7 </Grid.ColumnDefinitions>
8 <Image Height="91" Margin="0,0,23,0" Source="/Microsoft.Samples.NLayerApp.Presentation.Silverlight.Client;component/Resources/Images/ListBackground.png" Stretch="Fill" VerticalAlignment="Bottom" Grid.ColumnSpan="2"/>
9 <Grid Margin="5,21,12,21" Grid.Column="1">
10 <Rectangle Fill="#FF007DAC" Margin="0,0,0,9"/>
11 <Image Margin="0" Source="/Microsoft.Samples.NLayerApp.Presentation.Silverlight.Client;component/Resources/Images/TitleRibbon.png" Stretch="Fill" Height="49" VerticalAlignment="Center" Width="157" HorizontalAlignment="Right">
12 <Image.OpacityMask>
13 <LinearGradientBrush EndPoint="0.026,0.5" StartPoint="0.981,0.5">
14 <GradientStop Color="Black" Offset="0"/>
15 <GradientStop Color="#33FFFFFF" Offset="1"/>
16 </LinearGradientBrush>
17 </Image.OpacityMask>
18 </Image>
19 <TextBlock Foreground="White" Text="{Binding CompanyName}" FontSize="21.333" FontFamily="/Microsoft.Samples.NLayerApp.Presentation.Silverlight.Client;component/Resources/Fonts/HelveticaThn.ttf#Helvetica35-Thin" FontWeight="Bold" HorizontalAlignment="Left" VerticalAlignment="Center" d:LayoutOverrides="HorizontalAlignment" Margin="9,2,2,12"/>
20 </Grid>
21 <StackPanel Grid.Row="2" Margin="118,0,0,0" HorizontalAlignment="Left" VerticalAlignment="Center" d:LayoutOverrides="GridBox">
22 <TextBlock d:LayoutOverrides="Width" Foreground="White" Text="{Binding ContactName}" FontSize="26.667" FontFamily="/Microsoft.Samples.NLayerApp.Presentation.Silverlight.Client;component/Resources/Fonts/HelveticaThn.ttf#Helvetica35-Thin" TextWrapping="Wrap"/>
23 <TextBlock Foreground="#FF959595" Text="{Binding Address.City}" FontSize="18.667" FontFamily="/Microsoft.Samples.NLayerApp.Presentation.Silverlight.Client;component/Resources/Fonts/HelveticaThn.ttf#Helvetica35-Thin" FontWeight="Bold" HorizontalAlignment="Left" Margin="0,2,0,0" VerticalAlignment="Bottom"/>
24 </StackPanel>
25 </Grid>
26 </Border>
27 </DataTemplate>

体现了页面的UI展示。

ItemsSource="{Binding Customers}" ListBox的数据源绑定到Customers中，其中Customers的类型为ObservableCollection<Customer>，它是个动态数据集合，当列表有变化时，可以发送通知，通过RaisePropertyChanged来触发变动事件。

VMCustomerListView继承ObservableObject基类，ObservableObject继承INotifyPropertyChanged接口。

1 <Button x:Name="BTN_AddCustomer"
2 VerticalAlignment="Top"
3 Style="{StaticResource ButtonStyle2}"
4 Foreground="White"
5 FontFamily="/Microsoft.Samples.NLayerApp.Presentation.Silverlight.Client;component/Resources/Fonts/HelveticaThn.ttf#Helvetica35-Thin"
6 FontSize="12"
7 Height="40"
8 Margin="0,0,62,0"
9 HorizontalAlignment="Right"
10 Width="40" Cursor="Hand">
11 <i:Interaction.Triggers>
12 <i:EventTrigger EventName="Click">
13 <i:InvokeCommandAction Command="{Binding AddCommand}"/>
14 </i:EventTrigger>
15 </i:Interaction.Triggers>
16 <Grid>
17 <Path x:Name="Shape_AddCustomer"
18 Data="F1M36.622,28.377C36.622,28.377 43.42,28.377 43.42,28.377 43.42,28.377 43.42,34.35 43.42,34.35 43.42,34.35 49.394,34.35 49.394,34.35 49.394,34.35 49.394,41.147 49.394,41.147 49.394,41.147 43.42,41.147 43.42,41.147 43.42,41.147 43.42,47.533 43.42,47.533 43.42,47.533 36.622,47.533 36.622,47.533 36.622,47.533 36.622,41.147 36.622,41.147 36.622,41.147 30.855,41.147 30.855,41.147 30.855,41.147 30.855,34.35 30.855,34.35 30.855,34.35 36.622,34.35 36.622,34.35 36.622,34.35 36.622,28.377 36.622,28.377z M23.868,1.019C30.444,1.019 35.775,6.35 35.775,12.926 35.775,18.982 32.448,23.97 26.597,24.723 28.748,24.917 31.102,25.503 33.399,26.387 33.399,26.387 33.399,32.519 33.399,32.519 33.399,32.519 27.481,32.519 27.481,32.519 27.481,32.519 27.481,43.698 27.481,43.698 27.481,43.698 33.399,43.698 33.399,43.698 33.399,43.698 33.399,49.304 33.399,49.304 30.83,49.235 27.689,49.35 23.864,49.327 1.204,49.189 3.217,51.085 3.217,39.255 3.217,31.681 13.217,25.455 21.248,24.724 15.395,23.974 11.962,18.984 11.962,12.926 11.962,6.35 17.293,1.019 23.868,1.019z"
19 Fill="#FFFFFFFF"
20 UseLayoutRounding="False"
21 Stretch="Fill"
22 HorizontalAlignment="Center"
23 VerticalAlignment="Center"
24 Width="20"
25 Height="20" />
26 </Grid>
27 </Button>

当点击AddCustomer按钮时候，这里使用了Interaction.Triggers可以绑定自定义事件。这里事件名为“Click”，命令动作绑定AddCommand，在VMCustomerListView中，它调用了AddExecute方法：

private void AddExecute(Object o) 
{

Customer current = (Customer)o; 
((MainPage)App.Current.RootVisual).addCustomer.DataContext = new ViewModels.VMAddCustomer(); 
((MainPage)App.Current.RootVisual).GotoAddCustomer.Begin();

Debug.WriteLine("Add Customer."); 
}

GotoAddCustomer是个Storyboard动画对象的Name名称，它的动画主要把当前CustomerList的Grid隐藏，将AddCustomer的Grid显示，然后就可以同样通过DataContext对应的VMAddCustomer去绑定视图中的AddCustomerView。

FlowGrid继承Grid，作为Silverlight中间内容的自定义控件，它加入了一些页面的特效，例如当鼠标移入该区域的时候，有一个悬浮蠕动的效果。

MouseMove += (FloatingGrid_MouseMove); 
MouseEnter += (FloatingGrid_MouseEnter); 
MouseLeave += (FloatingGrid_MouseLeave);

这些代码产生鼠标移动触发的事件。

13、BinaryImageConverter通过二进制字节的图像类型绑定图片的显示，它继承IValueConverter。具体它的原理可以参考我之前的一篇文章：《Silverlight渐进学习系列(1)——IValueConverter的使用》

14、CustomerListView中TextBlock属性Text="{Binding CurrentPage, Converter={StaticResource CurrentPageConverter}}"，通过当前页面绑定页码。

（NLayerApp相关文章索引：http://kb.cnblogs.com/tag/NLayerApp/）

后面再补充！

本文链接

通过COM组件在Web上实现Kinect骨骼追踪、声控截屏保存的功能

2011-06-27T17:50:00Z

前些天在淘宝上订购了Kinect，刚刚到货，对于这个新鲜的玩意儿，自己赶紧卸开包裹，插上PC机，先前已经装好了Kinect SDK（官方下载地址：http://research.microsoft.com/en-us/um/redmond/projects/kinectsdk/download.aspx）

希望自己的机子能够跑得动DEMO，最后送了一口气，正常运行：）。当然了，既然Kinect已经入手，自己打算也小小地练一下手，因为自己目前主要从事Web方面的开发，自然想到，如果能够在网页上能够运行Kinect该有多好啊！后来考虑了三种方案：

1）在Web应用程序上引用Kinect SDK的DLL（Microsoft.Research.Kinect.dll），可以正常引用，通过img标签或者页面输出图像流的方式显示Bitmap图像，当然你还需要定时刷新页面，当然这种方式的缺点可想而知，就是不够实时性。并且增加了服务器的负担。

2）通过Silverlight应用程序的方式，但是目前SL4/5均不支持Kinect的dll，这是由于Kinect是个.Net Framework的类库，非SL支持的客户端类库。另外，在非OOB的模式下，也SL目前不支持自定义的COM组件，希望微软团队将来能够让SL也支持Kinect。

3）通过ActiveX的COM组件技术，通过开发窗体组件，产生ActiveX插件，嵌套在IE浏览器中进行显示。

于是，我考虑了最简单的方式，通过ActiveX的技术在网页上对Kinect相关基本功能进行展示。

本文会分成三个部分来叙述：

一、ActiveX插件的实现；

二、Kinect基本功能的实现；

三、ActiveX的安装；

具体实现

第一部分 ActiveX插件的实现

1）创建一个新的解决方案，叫做MyFirstKinect。

2）接着创建一个Windows窗体控件库，用于做ActiveX的插件，项目叫做MyFirstKinectControl

3）在MyFirstKinectControl项目的右键点击“属性”，选择“生成”项：

将”为COM互操作注册”勾上，然后关闭。

4）打开AssemblyInfo.cs：

将ComVisible设置为true，并将下面这行注释掉（这个很重要，切记！）

对应地，需要在自定义窗体控件上加上该Guid：

至此，一个基本的COM组件已经实现了，现在来看下该如何在浏览器上显示ActiveX插件。

5）打开Visual Studio的命令提示符：输入“oleview”，页面会打开一个“OLE/COM Object Viewer”应用程序：

由于我是使用C#创建的COM组件,于是在“.NET Category”寻找刚才创建的”MyFirstKinectControl”：

右键选择“Copy HTML<object> Tag to Clipboard”，得到：

6）然后我在自定义窗体控件上（SkeletalControl.cs），随便加入点东西上去，比如按钮、标签等等。

7）然后新创建一个Web应用程序的项目（WebApp），重新编译。将上面的代码复制到Html或相关页面中。

在IE正常状态下，发现插件无法正常显示。于是，把浏览器的安全级别调低：

继续运行：

就可以正常显示插件了。当然这种方式造成了浏览器使用上的危害性，所以不建议这样来使用。

8）如果想要在不调整浏览器安全级别的情况下，又能够在浏览器上正常显示插件，这样就必须调整一些代码：

[Guid("CB5BDC81-93C1-11CF-8F20-00805F2CD064"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
public interface IObjectSafety
{
    // methods 
    void GetInterfacceSafyOptions(
        System.Int32 riid,
        out System.Int32 pdwSupportedOptions,
        out System.Int32 pdwEnabledOptions);
    void SetInterfaceSafetyOptions(
        System.Int32 riid,
        System.Int32 dwOptionsSetMask,
        System.Int32 dwEnabledOptions);
}

添加一个IObjectSafety的接口，并且Guid是固定的。

SkeletalControl继承这个接口：

[Guid("d678c286-b26f-4f72-ae22-2dcb1952851b")]
public partial class SkeletalControl : UserControl, IObjectSafety
{
    public SkeletalControl()
    {
        InitializeComponent();
    }

    #region IObjectSafety 成员

    public void GetInterfacceSafyOptions(Int32 riid, out Int32 pdwSupportedOptions, out Int32 pdwEnabledOptions)
    {
        pdwSupportedOptions = 1;
        pdwEnabledOptions = 2;
    }

    public void SetInterfaceSafetyOptions(Int32 riid, Int32 dwOptionsSetMask, Int32 dwEnabledOptions)
    {
    
    }

    #endregion
}

接着重新编译并运行Web程序，运行结果为：

这样，你就不需要调整浏览器的安全级别，就可以正常显示ActiveX插件了。

第二部分 Kinect的基本功能实现

从这一部分起，我将开始介绍Kinect如何实现一些基本功能：包括视频监控、骨骼追踪以及声控截屏的功能。

1）项目中引用以下的Dll：

其中Microsoft.Research.Kinect就是在电脑上装好Kinect SDK后可以引用的类库；

另外地，Coding4Fun.Kinect.WinForm是一个基于SDK的DLL的相关封装好的一些功能类库，网上开源地址为：http://c4fkinect.codeplex.com/；

Microsoft.Speech是一个微软提供的语音识别的基本类库，也包含相关的SDK，并且和Kinect进行绑定的相关类库，具体地址在Kinect SDK中的相关文档也有说明：

- Speech Platform Runtime (v10.2) x86. Even on x64 platforms the x86 needs to be used because the MSR Kinect SDK runtime is x86
http://www.microsoft.com/downloads/en/details.aspx?FamilyID=bb0f72cb-b86b-46d1-bf06-665895a313c7
- Speech Platform SDK (v10.2)
http://www.microsoft.com/downloads/en/details.aspx?FamilyID=1b1604d3-4f66-4241-9a21-90a294a5c9a4&displaylang=en
- Kinect English Language Pack: MSKinectLangPack_enUS.msi (available in the same location as the Kinect For Windows SDK)

2）在控件页面上创建三个PictureBox的控件：

三个图片框将分别用来存放：深度图视频、普通视频、以及骨骼追踪。

3）编写相关代码：

using Microsoft.Research.Kinect.Nui;
using Coding4Fun.Kinect.WinForm;

Runtime nui;

private void SkeletalControl_Load(object sender, EventArgs e)
{
    nui = new Runtime();

    try
    {
        nui.Initialize(
            RuntimeOptions.UseDepthAndPlayerIndex 
            | RuntimeOptions.UseSkeletalTracking 
            | RuntimeOptions.UseColor);
    }
    catch (InvalidOperationException)
    {
        MessageBox.Show("Runtime initialization failed. Please make sure Kinect device is plugged in.");
        return;
    }

    try
    {
        nui.VideoStream.Open(ImageStreamType.Video, 2, ImageResolution.Resolution640x480, ImageType.Color);
        nui.DepthStream.Open(ImageStreamType.Depth, 2, ImageResolution.Resolution320x240, ImageType.DepthAndPlayerIndex);
    }
    catch (InvalidOperationException)
    {
        MessageBox.Show("Failed to open stream. Please make sure to specify a supported image type and resolution.");
        return;
    }

    nui.DepthFrameReady += new EventHandler(nui_DepthFrameReady);
    nui.SkeletonFrameReady += new EventHandler(nui_SkeletonFrameReady);
    nui.VideoFrameReady += new EventHandler(nui_VideoFrameReady);
}

其中DepthFrameReady，VideoFrameReady，SkeletonFrameReady分别用来追踪深度图、普通视图、骨骼图所产生的事件。

void nui_DepthFrameReady(object sender, ImageFrameReadyEventArgs e)
 {
     pictureBoxDepth.Image = e.ImageFrame.ToBitmap();
 }

 void nui_VideoFrameReady(object sender, ImageFrameReadyEventArgs e)
 {
     pictureBoxVideo.Image = e.ImageFrame.ToBitmap();
 }

 void nui_SkeletonFrameReady(object sender, SkeletonFrameReadyEventArgs e)
 {
     Graphics graphics = this.pictureBoxSkeleton.CreateGraphics();

     pictureBoxSkeleton.Refresh();

     SkeletonFrame skeletonFrame = e.SkeletonFrame;
     int iSkeleton = 0;

     foreach (SkeletonData data in skeletonFrame.Skeletons)
     {
         if (SkeletonTrackingState.Tracked == data.TrackingState)
         {
             // Draw bones
             graphics.DrawLines(pen, getBodySegment(data.Joints, JointID.HipCenter, JointID.Spine, JointID.ShoulderCenter, JointID.Head));
             graphics.DrawLines(pen, getBodySegment(data.Joints, JointID.ShoulderCenter, JointID.ShoulderLeft, JointID.ElbowLeft, JointID.WristLeft, JointID.HandLeft));
             graphics.DrawLines(pen, getBodySegment(data.Joints, JointID.ShoulderCenter, JointID.ShoulderRight, JointID.ElbowRight, JointID.WristRight, JointID.HandRight));
             graphics.DrawLines(pen, getBodySegment(data.Joints, JointID.HipCenter, JointID.HipLeft, JointID.KneeLeft, JointID.AnkleLeft, JointID.FootLeft));
             graphics.DrawLines(pen, getBodySegment(data.Joints, JointID.HipCenter, JointID.HipRight, JointID.KneeRight, JointID.AnkleRight, JointID.FootRight));
         }
         iSkeleton++;
     } // for each skeleton
 }

 private Point getDisplayPosition(Joint joint)
 {
     float depthX, depthY;
     nui.SkeletonEngine.SkeletonToDepthImage(joint.Position, out depthX, out depthY);
     depthX = Math.Max(0, Math.Min(depthX * 320, 320));  //convert to 320, 240 space
     depthY = Math.Max(0, Math.Min(depthY * 240, 240));  //convert to 320, 240 space
     int colorX, colorY;
     ImageViewArea iv = new ImageViewArea();
     // only ImageResolution.Resolution640x480 is supported at this point
     nui.NuiCamera.GetColorPixelCoordinatesFromDepthPixel(ImageResolution.Resolution640x480, iv, (int)depthX, (int)depthY, (short)0, out colorX, out colorY);

     // map back to skeleton.Width & skeleton.Height
     return new Point((int)(this.pictureBoxSkeleton.Width * colorX / 640.0), (int)(this.pictureBoxSkeleton.Height * colorY / 480));
 }

 Point[] getBodySegment(Microsoft.Research.Kinect.Nui.JointsCollection joints, params JointID[] ids)
 {
     Point[] points = new Point[ids.Length];
     for (int i = 0; i < ids.Length; ++i)
     {
         points[i] = getDisplayPosition(joints[ids[i]]);
     }

     return points;
 }

其中，getBodySegment，getDisplayPosition方法将确定骨骼追踪中的20个骨骼点的具体位置。

4）接着编译并运行程序，查看Web页面，连上Kinect传感设备，运行结果为：

5）接着，来实现一些声控截屏功能：

using Microsoft.Research.Kinect.Audio;
using Microsoft.Speech.AudioFormat;
using Microsoft.Speech.Recognition;



private const string RecognizerId = "SR_MS_en-US_Kinect_10.0";
private KinectAudioSource kinectSource;
private SpeechRecognitionEngine sre;



// 声控截屏功能
RecognizerInfo ri = SpeechRecognitionEngine.InstalledRecognizers().Where(r => r.Id == RecognizerId).FirstOrDefault();
if (ri == null)
{
    MessageBox.Show("Could not find speech recognizer: {0}. Please refer to the sample requirements.", RecognizerId);
    return;
}

sre = new SpeechRecognitionEngine(ri.Id);

var colors = new Choices();
colors.Add("cut"); //添加cut的英文发音

var gb = new GrammarBuilder();                          
gb.Culture = ri.Culture; //本地化处理
gb.Append(colors);

var g = new Grammar(gb);

sre.LoadGrammar(g);
sre.SpeechRecognized += SreSpeechRecognized;                    //发音匹配以后的后续处理事件
sre.SpeechHypothesized += SreSpeechHypothesized;                //发音的英文识别事件
sre.SpeechRecognitionRejected += SreSpeechRecognitionRejected;  //拒绝之后的后续处理事件

var thread = new Thread(StartDMO);
thread.Start();




private void StartDMO()
 {
     kinectSource = new KinectAudioSource();
     kinectSource.SystemMode = SystemMode.OptibeamArrayOnly;
     kinectSource.FeatureMode = true;
     kinectSource.AutomaticGainControl = false;
     kinectSource.MicArrayMode = MicArrayMode.MicArrayAdaptiveBeam;
     var kinectStream = kinectSource.Start();
     sre.SetInputToAudioStream(kinectStream, new SpeechAudioFormatInfo(
                                           EncodingFormat.Pcm, 16000, 16, 1,
                                           32000, 2, null));
     sre.RecognizeAsync(RecognizeMode.Multiple);
 }

 void SreSpeechRecognitionRejected(object sender, SpeechRecognitionRejectedEventArgs e)
 {

 }

 void SreSpeechHypothesized(object sender, SpeechHypothesizedEventArgs e)
 {

 }

 void SreSpeechRecognized(object sender, SpeechRecognizedEventArgs e)
 {
     lblSpeech.Text = e.Result.Text;

     //屏幕截屏
     Bitmap bmp = new Bitmap(Screen.PrimaryScreen.Bounds.Width, Screen.PrimaryScreen.Bounds.Height);
     Graphics g = Graphics.FromImage(bmp);
     g.CopyFromScreen(0, 0, 0, 0, bmp.Size);
     g.Dispose();

     SaveFileDialog fileDialog = new SaveFileDialog();
     fileDialog.Filter = "JPG File(*.jpg)|*.jpg||";
     DialogResult result = fileDialog.ShowDialog();
     if (result == DialogResult.OK)
     {
         bmp.Save(fileDialog.FileName, System.Drawing.Imaging.ImageFormat.Jpeg);
     }
 }

在代码中发现，var colors = new Choices(); colors.Add("cut"); //添加cut的英文发音，这样当你在传感器前发音“cut”就会进行相关事件的触发，当发音和英文库的单词语音识别向匹配时，将触发SreSpeechRecognized事件。

执行屏幕截图的相关操作。

（注：记得这里需要添加代码gb.Culture = ri.Culture; 如果没有这句代码，有可能导致sre.LoadGrammar(g); 语法加载失败！）

6. 运行结果：

我将刚才发的英文单词，通过文本的方式显示在页面中。

第三部分 ActiveX插件的安装

由于本文使用的是C#来开发ActiveX插件，所以当你需要安装插件的时候，需要使用regasm命令。那么开始编写脚本：

1）安装脚本：

@echo off
echo 开始安装MyFirstKinectControl......
echo.
set FrameworkPath=%SystemRoot%\Microsoft.NET\Framework\v4.0.30319
if exist "%FrameworkPath%\regasm.exe" goto :Start
set FrameworkPath=%SystemRoot%\Microsoft.NET\Framework\v3.5
if exist "%FrameworkPath%\regasm.exe" goto :Start
set FrameworkPath=%SystemRoot%\Microsoft.NET\Framework\v3.0
if exist "%FrameworkPath%\regasm.exe" goto :Start
set FrameworkPath=%SystemRoot%\Microsoft.NET\Framework\v2.0.50727
if exist "%FrameworkPath%\regasm.exe" goto :Start
set FrameworkPath=%SystemRoot%\Microsoft.NET\Framework\v1.1.4322
if exist "%FrameworkPath%\regasm.exe" goto :Startv
set FrameworkPath=%SystemRoot%\Microsoft.NET\Framework\1.0.3705
if exist "%FrameworkPath%\regasm.exe" goto :Start

:Start
%FrameworkPath%\regasm.exe MyFirstKinectControl.dll /codebase MyFirstKinectControl.dll

echo 安装完成！
echo.

pause

2）卸载脚本：

@echo off
echo 开始卸载MyFirstKinectControl......
echo.
set FrameworkPath=%SystemRoot%\Microsoft.NET\Framework\v4.0.30319
if exist "%FrameworkPath%\regasm.exe" goto :Start
set FrameworkPath=%SystemRoot%\Microsoft.NET\Framework\v3.5
if exist "%FrameworkPath%\regasm.exe" goto :Start
set FrameworkPath=%SystemRoot%\Microsoft.NET\Framework\v3.0
if exist "%FrameworkPath%\regasm.exe" goto :Start
set FrameworkPath=%SystemRoot%\Microsoft.NET\Framework\v2.0.50727
if exist "%FrameworkPath%\regasm.exe" goto :Start
set FrameworkPath=%SystemRoot%\Microsoft.NET\Framework\v1.1.4322
if exist "%FrameworkPath%\regasm.exe" goto :Startv
set FrameworkPath=%SystemRoot%\Microsoft.NET\Framework\1.0.3705
if exist "%FrameworkPath%\regasm.exe" goto :Start

:Start
%FrameworkPath%\regasm.exe /u MyFirstKinectControl.dll

echo 卸载完成！
echo.

pause

这样通过注册COM组件就可以实现Kinect的插件在浏览器上的展示。

附上本文的源代码：MyFirstKinect.rar 谢谢大家阅读！

本文链接

金融系统中PBOC/EMV的TLV的算法实现（含C++/C#）

2011-06-15T06:02:00Z

TLV即Tag-Length-Value，常在IC卡与POS终端设备中通过这样的一个应用通信协议进行数据交换。在金融系统以及认证中，PBOC以及EMV的认证规范文档上面也有对TLV做了一些说明，由于认证规范都是英文文档，所以有些人可能不易于理解。首先我先介绍下什么是TLV，TLV的用途是什么，以及如何实现它的打包解包算法。

金融系统中的TLV是BER-TLV编码的一个特例编码规范，而BER-TLV是ISO定义中的规范。在TLV的定义中，可以知道它包括三个域，分别为：标签域（Tag），长度域（Length），内容域（Value）。这里的长度域的值实际上就是内容域的长度。

其实，在BER编码的方式有两种情况，一种是确定长度的方式，一种是不确定长度的方式，而金融TLV选择了确定长度的方式，这样在设备之间的数据传输量上就可以减少。

Tag域说明：

先来看下TLV的Tag是如何编码的，先看下图：

这张图说明了Tag域第一个字节的编码格式。其中b8-b1代表1个字节中的8个位。

其中b8,b7代表数据的类别。根据2个位的组合，有四种类别：通用类别，应用类别，上下文语境类别，专用类别。这个主要用于在于终端设备交互的时候，确定数据处理的类型。

b6代表的是数据元结构，也就是说它是属于简单数据元结构，还是属于结构（复合）数据元结构。当b6为1的时候，就需要后续的字节进行扩展。也就是说复合的TLV中，value域里也包含一个或多个TLV，这个稍后接着介绍。

当b5-b1代表串行号，当5个位都为1时，需要将tag域扩展到下一个字节中，也就是Tag占2个字节；而当5个位都不全为1时，该Tag域就只占1个字节。

现在，看下b5-b1：11111的情况：

从图中我们看到BER-TLV编码中，当b8为1时，Tag还需要有后续字节，直到b8为0为止。从EMV文档中的说明，Tag最多只占用2个字节，所以这样就相对比较简单一些了。当b8为0时，该Tag域结束，总共就占用2个字节。

Length域说明：

在文档中没有图片叙述，我自绘一个：

当b8为0时，该字节的b7-b1作为value域的长度；当b8为1时，b7-b1作为后续字节的长度，也就是说，例如有这样一个值：10000011，代表后续还有3个字节作为value域的长度（本字节不算，本字节变为作为一个Length的索引）。3个字节代表value的长度，意味着什么呢，意味着内容的长度当需要很大的时候，字节的位数就会跟着越高，3个字节就代表最大可以有256*256*256的长度。

Value域说明：

也是分成两种情况考虑，就是前面说到的Tag分成两个数据元结构，一种是简单数据元结构，一种是复合数据元架构：

先来看看简单数据元结构：

Tag就是Tag,没有子标签Tag，基本结构就是T-L-V。

再看下符合数据元结构：

后面的Value说明：Primitive or constructed BER-TLV data object number，包含一个简单数据元结构或者也可以是一个符合数据元结构。这样可以看出，算法中必须要实现Tag的嵌套功能，递归算法不可少。

算法实现：

根据以上的说明现在来实现它的打包解包的算法（打包的目的是将一个从终端上发的请求数据——字节数组，构造成一系列的TLV结构实体；解包的目的刚好相反，就是将TLV结构实体解析成字节数组，然后通过IC卡发送到终端上）。

首先定义一个TLV结构实体：

// TLV结构体
struct TLVEntity {
	unsigned char* Tag;			//标记
	unsigned char* Length;		//数据长度
	unsigned char* Value;		//数据
	unsigned int TagSize;		//标记占用字节数
	unsigned int LengthSize;	//数据长度占用字节数
	TLVEntity* Sub_TLVEntity;	//子嵌套TLV实体
};

其中TagSize代表Tag字段的字节长度，LengthSize代表Length的字节长度，这里的Length记住要使用char*，由于前面说过，Length可能包含多个字节，通过多个字节确定Value域的长度，Sub_TLVEntity作为子嵌套的TLV结构体。

定义一个TLVPackage的打包类：

TLVPackage.h：

// TLV打包类
class TLVPackage
{
public:
	TLVPackage();
	virtual ~TLVPackage();
	//构造TLV实体
	static void Construct(unsigned char* buffer, unsigned int bufferLength, TLVEntity* tlvEntity, unsigned int& entityLength, unsigned int status=0);
	//解析TLV字节数组
	static void Parse(TLVEntity* tlvEntity, unsigned int entityLength, unsigned char* buffer, unsigned int& bufferLength);
};

具体方法实现：

// 构造TLV
void TLVPackage:: Construct(
	unsigned char* buffer, 
	unsigned int bufferLength, 
	TLVEntity* tlvEntity, 
	unsigned int& entityLength,
	unsigned int status
	)
{
	int currentTLVIndex = 0;
	int currentIndex = 0;
	int currentStatus = 'T'; //状态字符
	unsigned long valueSize = 0;

	while(currentIndex < bufferLength)
	{
		switch(currentStatus)
		{
		case 'T':
			valueSize = 0;
			//判断是否单一结构
			if((status == 1 && buffer[currentIndex] & 0x20) != 0x20)
			{
				tlvEntity[currentTLVIndex].Sub_TLVEntity = NULL; //单一结构时将子Tag置空
				//判断是否多字节Tag
				if((buffer[currentIndex] & 0x1f) == 0x1f)
				{
					int endTagIndex = currentIndex;
					while((buffer[++endTagIndex] & 0x80) == 0x80); //判断第二个字节的最高位是否为1
					int tagSize = endTagIndex - currentIndex + 1; //计算Tag包含多少字节

					tlvEntity[currentTLVIndex].Tag = new unsigned char[tagSize];
					memcpy(tlvEntity[currentTLVIndex].Tag, buffer + currentIndex, tagSize); 
					tlvEntity[currentTLVIndex].Tag[tagSize] = 0;

					tlvEntity[currentTLVIndex].TagSize = tagSize;

					currentIndex += tagSize;
				}
				else
				{
					tlvEntity[currentTLVIndex].Tag = new unsigned char[1];
					memcpy(tlvEntity[currentTLVIndex].Tag, buffer + currentIndex, 1);
					tlvEntity[currentTLVIndex].Tag[1] = 0;

					tlvEntity[currentTLVIndex].TagSize = 1;

					currentIndex += 1;
				}
			}
			else
			{
				//判断是否多字节Tag
				if((buffer[currentIndex] & 0x1f) == 0x1f)
				{
					int endTagIndex = currentIndex;
					while((buffer[++endTagIndex] & 0x80) == 0x80); //判断第二个字节的最高位是否为1
					int tagSize = endTagIndex - currentIndex + 1; //计算Tag包含多少字节

					tlvEntity[currentTLVIndex].Tag = new unsigned char[tagSize];
					memcpy(tlvEntity[currentTLVIndex].Tag, buffer + currentIndex, tagSize); 
					tlvEntity[currentTLVIndex].Tag[tagSize] = 0;

					tlvEntity[currentTLVIndex].TagSize = tagSize;

					currentIndex += tagSize;
				}
				else
				{
					tlvEntity[currentTLVIndex].Tag = new unsigned char[1];
					memcpy(tlvEntity[currentTLVIndex].Tag, buffer + currentIndex, 1);
					tlvEntity[currentTLVIndex].Tag[1] = 0;

					tlvEntity[currentTLVIndex].TagSize = 1;

					currentIndex += 1;				
				}

				//分析SubTag
				int subLength = 0;	
				
				unsigned char* temp;
				if((buffer[currentIndex] & 0x80) == 0x80)
				{
					for (int index = 0; index < 2; index++)
					{
						subLength += buffer[currentIndex + 1 + index] << (index * 8); //计算Length域的长度
					}

					temp = new unsigned char[subLength];

					memcpy(temp, buffer + currentIndex + 3, subLength);
				}
				else
				{
					subLength = buffer[currentIndex];

					temp = new unsigned char[subLength];

					memcpy(temp, buffer + currentIndex + 1, subLength);
				}
				temp[subLength] = 0;
				
				//memcpy(temp, buffer + currentIndex + 1, subLength);
				unsigned int oLength;
				tlvEntity[currentTLVIndex].Sub_TLVEntity = new TLVEntity[1];
				Construct(temp, subLength, tlvEntity[currentTLVIndex].Sub_TLVEntity, oLength);
			}

			currentStatus = 'L';
			break;
		case 'L':		
			//判断长度字节的最高位是否为1，如果为1，则该字节为长度扩展字节，由下一个字节开始决定长度
			if((buffer[currentIndex] & 0x80) != 0x80)
			{
				tlvEntity[currentTLVIndex].Length = new unsigned char[1];
				memcpy(tlvEntity[currentTLVIndex].Length, buffer + currentIndex, 1);
				tlvEntity[currentTLVIndex].Length[1] = 0;
				tlvEntity[currentTLVIndex].LengthSize = 1;

				valueSize = tlvEntity[currentTLVIndex].Length[0];

				currentIndex += 1;
			}
			else
			{
				//为1的情况

				unsigned int lengthSize = buffer[currentIndex] & 0x7f;
				
				currentIndex += 1; //从下一个字节开始算Length域

				for (int index = 0; index < lengthSize; index++)
				{
					valueSize += buffer[currentIndex + index] << (index * 8); //计算Length域的长度
				}

				tlvEntity[currentTLVIndex].Length = new unsigned char[lengthSize];
				memcpy(tlvEntity[currentTLVIndex].Length, buffer + currentIndex, lengthSize);
				tlvEntity[currentTLVIndex].Length[lengthSize] = 0;

				tlvEntity[currentTLVIndex].LengthSize = lengthSize;

				currentIndex += lengthSize;
			}

			currentStatus = 'V';
			break;
		case 'V':
			tlvEntity[currentTLVIndex].Value = new unsigned char[valueSize];
			memcpy(tlvEntity[currentTLVIndex].Value, buffer + currentIndex, valueSize);
			tlvEntity[currentTLVIndex].Value[valueSize] = 0;

			currentIndex += valueSize;
			
			//进入下一个TLV构造循环
			currentTLVIndex += 1;

			currentStatus = 'T';
			break;
		default:
			return;
		}
	}

	entityLength = currentTLVIndex;
}

// 解析TLV
void TLVPackage::Parse(
	TLVEntity* tlvEntity, 
	unsigned int entityLength, 
	unsigned char* buffer, 
	unsigned int& bufferLength
	)
{
	int currentIndex = 0;
	int currentTLVIndex = 0;
	unsigned long valueSize = 0;

	while(currentTLVIndex < entityLength)
	{
		valueSize = 0;
		TLVEntity entity = tlvEntity[currentTLVIndex];
		
		memcpy(buffer + currentIndex, entity.Tag, entity.TagSize);	//解析Tag
		currentIndex += entity.TagSize;

		for (int index = 0; index < entity.LengthSize; index++)
		{
			valueSize += entity.Length[index] << (index * 8); //计算Length域的长度
		}
		if(valueSize > 127)
		{
			buffer[currentIndex] = 0x80 | entity.LengthSize;
			currentIndex += 1;
		}
		
		memcpy(buffer + currentIndex, entity.Length, entity.LengthSize);	//解析Length
		currentIndex += entity.LengthSize;
		//判断是否包含子嵌套TLV
		if(entity.Sub_TLVEntity == NULL)
		{
			memcpy(buffer + currentIndex, entity.Value, valueSize);	//解析Value
			currentIndex += valueSize;
		}
		else
		{
			unsigned int oLength;
			Parse(entity.Sub_TLVEntity, 1, buffer + currentIndex, oLength);	//解析子嵌套TLV
			currentIndex += oLength;
		}

		currentTLVIndex++;
	}
	buffer[currentIndex] = 0;
	bufferLength = currentIndex;
}

然后写测试程序：

// 上发测试数据
unsigned char requestBuf[] = {
		0x9F, 0x1C, 0x12, 0x33, 0x33, 0x30, 0x32, 0x32, 0x37, 0x31, 0x39, 0x36, 0x32, 0x30, 0x34, 0x30, 0x34, 
		0x32, 0x37, 0x31, 0x38, 0x9F, 0x62, 0x01, 0x01, 0x57, 0x12, 0x62, 0x22, 0x89, 0x00, 0x00, 0x02, 0x91, 
		0x01, 0xD0, 0x90, 0x32, 0x01, 0x02, 0x47, 0x17, 0x13, 0x00, 0x0F, 0x5F, 0x20, 0x0A, 0x48, 0x55, 0x47, 
		0x55, 0x4F, 0x20, 0x4D, 0x49, 0x4E, 0x47, 0x9F, 0x1F, 0x3C, 0x25, 0x39, 0x39, 0x36, 0x32, 0x32, 0x32, 
		0x38, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x39, 0x31, 0x30, 0x31, 0x5E, 0x47, 0x55, 0x4F, 0x20, 
		0x4D, 0x49, 0x4E, 0x47, 0x2F, 0x48, 0x55, 0x5E, 0x30, 0x39, 0x30, 0x33, 0x32, 0x30, 0x31, 0x30, 0x32, 
		0x34, 0x37, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x38, 0x39, 0x30, 
		0x30, 0x3F
}; 

	TLVEntity tlvEntity[TLV_MAX_LENGTH];
	unsigned int tlv_count;
	//构造TLV
	TLVPackage::Construct(requestBuf, sizeof(requestBuf), tlvEntity, tlv_count);

	unsigned char parseBuf[1024];
	unsigned int buf_count;
	//解析TLV
	TLVPackage::Parse(tlvEntity, tlv_count, parseBuf, buf_count);

	if(strncmp((char*)parseBuf, (char*)requestBuf, sizeof(requestBuf)) == 0)
	{
		AfxMessageBox("TRUE");
	}
	else
	{
		AfxMessageBox("FALSE");
	}

最后测试结果中，可以得到最后将弹出“TRUE”的对话框。证明构造TLV得到的TLVEntity，再对这个实体进行解析，可以的到解析后的字节数组，最后通过strncmp的方法比较判断，是否原始字节数组和解析后的字节数组是否一致。

另外，为了方便C#程序员的使用，我对该C++程序重新改写了一下，得出的结果也是一样的。

TLVEntity.cs

/// 
    /// 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; }
    }

以及TLVPackage.cs

/// 
    /// TLV打包类
    /// 
    public class TLVPackage
    {
        /// 
        /// 构造TLV
        /// 
        /// 
        public static List Construct(byte[] buffer)
        {
            List list = new List();
            int currentTLVIndex = 0;
            int currentIndex = 0;
            int currentStatus = 'T'; //状态字符
            int valueSize = 0;

            TLVEntity tlvEntity = null;

            while (currentIndex < buffer.Length)
            {
                switch (currentStatus)
                {
                    case 'T':
                        tlvEntity = new TLVEntity();
                        valueSize = 0;
                        //判断是否单一结构
                        if ((buffer[currentIndex] & 0x20) != 0x20)
                        {
                            tlvEntity.Sub_TLVEntity = null; //单一结构时将子Tag置空【】
                            //判断是否多字节Tag
                            if ((buffer[currentIndex] & 0x1f) == 0x1f)
                            {
                                int endTagIndex = currentIndex;
                                while ((buffer[++endTagIndex] & 0x80) == 0x80) ; //判断第二个字节的最高位是否为1
                                int tagSize = endTagIndex - currentIndex + 1; //计算Tag包含多少字节

                                tlvEntity.Tag = new byte[tagSize];
                                Array.Copy(buffer, currentIndex, tlvEntity.Tag, 0, tagSize);

                                tlvEntity.TagSize = tagSize;

                                currentIndex += tagSize;
                            }
                            else
                            {
                                tlvEntity.Tag = new byte[1];
                                Array.Copy(buffer, currentIndex, tlvEntity.Tag, 0, 1);

                                tlvEntity.TagSize = 1;

                                currentIndex += 1;
                            }
                        }
                        else
                        {
                            //判断是否多字节Tag
                            if ((buffer[currentIndex] & 0x1f) == 0x1f)
                            {
                                int endTagIndex = currentIndex;
                                while ((buffer[++endTagIndex] & 0x80) == 0x80) ; //判断第二个字节的最高位是否为1
                                int tagSize = endTagIndex - currentIndex + 1; //计算Tag包含多少字节

                                tlvEntity.Tag = new byte[tagSize];
                                Array.Copy(buffer, currentIndex, tlvEntity.Tag, 0, tagSize);

                                tlvEntity.TagSize = tagSize;

                                currentIndex += tagSize;
                            }
                            else
                            {
                                tlvEntity.Tag = new byte[1];
                                Array.Copy(buffer, currentIndex, tlvEntity.Tag, 0, 1);

                                tlvEntity.TagSize = 1;

                                currentIndex += 1;
                            }

                            //分析SubTag
                            int subLength = 0;

                            byte[] temp;
                            if ((buffer[currentIndex] & 0x80) == 0x80)
                            {
                                for (int index = 0; index < 2; index++)
                                {
                                    subLength += buffer[currentIndex + 1 + index] << (index * 8); //计算Length域的长度
                                }

                                temp = new byte[subLength];

                                Array.Copy(buffer, currentIndex + 3, temp, 0, subLength);
                            }
                            else
                            {
                                subLength = buffer[currentIndex];

                                temp = new byte[subLength];

                                Array.Copy(buffer, currentIndex + 1, temp, 0, subLength);
                            }

                            int oLength;
                            tlvEntity.Sub_TLVEntity = new TLVEntity();
                            List tempList = Construct(temp);
                            tlvEntity.Sub_TLVEntity = tempList[0];
                        }

                        currentStatus = 'L';
                        break;
                    case 'L':
                        //判断长度字节的最高位是否为1，如果为1，则该字节为长度扩展字节，由下一个字节开始决定长度
                        if ((buffer[currentIndex] & 0x80) != 0x80)
                        {
                            tlvEntity.Length = new byte[1];
                            Array.Copy(buffer, currentIndex, tlvEntity.Length, 0, 1);

                            tlvEntity.LengthSize = 1;

                            valueSize = tlvEntity.Length[0];
                            currentIndex += 1;
                        }
                        else
                        {
                            //为1的情况

                            int lengthSize = buffer[currentIndex] & 0x7f;

                            currentIndex += 1; //从下一个字节开始算Length域

                            for (int index = 0; index < lengthSize; index++)
                            {
                                valueSize += buffer[currentIndex + index] << (index * 8); //计算Length域的长度
                            }

                            tlvEntity.Length = new byte[lengthSize];
                            Array.Copy(buffer, currentIndex, tlvEntity.Length, 0, lengthSize);

                            tlvEntity.LengthSize = lengthSize;

                            currentIndex += lengthSize;
                        }

                        currentStatus = 'V';
                        break;
                    case 'V':
                        tlvEntity.Value = new byte[valueSize];
                        Array.Copy(buffer, currentIndex, tlvEntity.Value, 0, valueSize);

                        currentIndex += valueSize;

                        //进入下一个TLV构造循环
                        list.Add(tlvEntity);

                        currentStatus = 'T';
                        break;
                    default:
                        return new List();
                }
            }

            return list;
        }

        /// 
        /// 解析TLV
        /// 
        /// 
        /// 
        public static byte[] Parse(List list)
        {
            byte[] buffer = new byte[4096];
            int currentIndex = 0;
            int currentTLVIndex = 0;
            int valueSize = 0;

            while (currentTLVIndex < list.Count())
            {
                valueSize = 0;
                TLVEntity entity = list[currentTLVIndex];

                Array.Copy(entity.Tag, 0, buffer, currentIndex, entity.TagSize);	//解析Tag

                currentIndex += entity.TagSize;

                for (int index = 0; index < entity.LengthSize; index++)
                {
                    valueSize += entity.Length[index] << (index * 8); //计算Length域的长度
                }
                if (valueSize > 127)
                {
                    buffer[currentIndex] = Convert.ToByte(0x80 | entity.LengthSize);
                    currentIndex += 1;
                }

                Array.Copy(entity.Length, 0, buffer, currentIndex, entity.LengthSize);	//解析Length

                currentIndex += entity.LengthSize;
                //判断是否包含子嵌套TLV
                if (entity.Sub_TLVEntity == null)
                {
                    Array.Copy(entity.Value, 0, buffer, currentIndex, valueSize); 	//解析Value
                    currentIndex += valueSize;
                }
                else
                {
                    byte[] tempBuffer = Parse(new List { entity.Sub_TLVEntity });
                    Array.Copy(tempBuffer, 0, buffer, currentIndex, tempBuffer.Length);	//解析子嵌套TLV
                    currentIndex += tempBuffer.Length;
                }

                currentTLVIndex++;
            }

            byte[] resultBuffer = new byte[currentIndex];
            Array.Copy(buffer, 0, resultBuffer, 0, currentIndex);

            return resultBuffer;
        }
    }

接着，写测试程序：

static byte[] requestBuffer = 
        {
            0x9F, 0x1C, 0x82, 0x2C, 0x01,
            0x33, 0x33, 0x30, 0x32, 0x32, 0x37, 0x31, 0x39, 0x36, 0x32,0x33, 0x33, 0x30, 0x32, 0x32, 0x37, 0x31, 0x39, 0x36, 0x32,0x33, 0x33, 0x30, 0x32, 0x32, 0x37, 0x31, 0x39, 0x36, 0x32,
            0x33, 0x33, 0x30, 0x32, 0x32, 0x37, 0x31, 0x39, 0x36, 0x32,0x33, 0x33, 0x30, 0x32, 0x32, 0x37, 0x31, 0x39, 0x36, 0x32,0x33, 0x33, 0x30, 0x32, 0x32, 0x37, 0x31, 0x39, 0x36, 0x32,
            0x33, 0x33, 0x30, 0x32, 0x32, 0x37, 0x31, 0x39, 0x36, 0x32,0x33, 0x33, 0x30, 0x32, 0x32, 0x37, 0x31, 0x39, 0x36, 0x32,0x33, 0x33, 0x30, 0x32, 0x32, 0x37, 0x31, 0x39, 0x36, 0x32,
            0x33, 0x33, 0x30, 0x32, 0x32, 0x37, 0x31, 0x39, 0x36, 0x32,0x33, 0x33, 0x30, 0x32, 0x32, 0x37, 0x31, 0x39, 0x36, 0x32,0x33, 0x33, 0x30, 0x32, 0x32, 0x37, 0x31, 0x39, 0x36, 0x32,
            0x33, 0x33, 0x30, 0x32, 0x32, 0x37, 0x31, 0x39, 0x36, 0x32,0x33, 0x33, 0x30, 0x32, 0x32, 0x37, 0x31, 0x39, 0x36, 0x32,0x33, 0x33, 0x30, 0x32, 0x32, 0x37, 0x31, 0x39, 0x36, 0x32,
            0x33, 0x33, 0x30, 0x32, 0x32, 0x37, 0x31, 0x39, 0x36, 0x32,0x33, 0x33, 0x30, 0x32, 0x32, 0x37, 0x31, 0x39, 0x36, 0x32,0x33, 0x33, 0x30, 0x32, 0x32, 0x37, 0x31, 0x39, 0x36, 0x32,
            0x33, 0x33, 0x30, 0x32, 0x32, 0x37, 0x31, 0x39, 0x36, 0x32,0x33, 0x33, 0x30, 0x32, 0x32, 0x37, 0x31, 0x39, 0x36, 0x32,0x33, 0x33, 0x30, 0x32, 0x32, 0x37, 0x31, 0x39, 0x36, 0x32,
            0x33, 0x33, 0x30, 0x32, 0x32, 0x37, 0x31, 0x39, 0x36, 0x32,0x33, 0x33, 0x30, 0x32, 0x32, 0x37, 0x31, 0x39, 0x36, 0x32,0x33, 0x33, 0x30, 0x32, 0x32, 0x37, 0x31, 0x39, 0x36, 0x32,
            0x33, 0x33, 0x30, 0x32, 0x32, 0x37, 0x31, 0x39, 0x36, 0x32,0x33, 0x33, 0x30, 0x32, 0x32, 0x37, 0x31, 0x39, 0x36, 0x32,0x33, 0x33, 0x30, 0x32, 0x32, 0x37, 0x31, 0x39, 0x36, 0x32,
            0x33, 0x33, 0x30, 0x32, 0x32, 0x37, 0x31, 0x39, 0x36, 0x32,0x33, 0x33, 0x30, 0x32, 0x32, 0x37, 0x31, 0x39, 0x36, 0x32,0x33, 0x33, 0x30, 0x32, 0x32, 0x37, 0x31, 0x39, 0x36, 0x32,
            0x71, 0x07, 0x9f, 0x19, 0x04, 0x11, 0x22, 0x33, 0x44
        };

        static void Main(string[] args)
        {
            Console.WriteLine("待组装的数据包：");
            requestBuffer.ToList().ForEach(o => { Console.Write("{0},", "0x" + o.ToString("X")); });

            Console.WriteLine("\r\n\r\n开始构造TLV");
            //构造TLV
            List list = TLVPackage.Construct(requestBuffer);
            Console.WriteLine("\r\n构造结束!");

            Console.WriteLine("\r\n开始解析TLV");
            //解析TLV
            byte[] responseBuffer = TLVPackage.Parse(list);
            Console.WriteLine("\r\n解析结束!");

            Console.WriteLine("\r\n解析结果：");

            if (ByteEquals(requestBuffer, responseBuffer))
            {
                Console.WriteLine("Equal!");
            }
            else
            {
                Console.WriteLine("Not Equal!");
            }

            Console.ReadKey();
        }

运行结果：

总结

TLV在数据通信方面，其实运用得很广泛，在应用层数据通信中，如HTTP协议，HTML，XML语言本身定义了一些标签（Body，Head，Script）对数据串行化，接收方再根据标签解析原始数据，通过浏览器展现出来。因此本质上也是属于TLV协议的设计模式。甚至在传输层的TCP，UDP协议，你完全可以通过TLV实现自定义的应用协议。

附上C#源代码：TLVPackageDemo.rar

本文链接

项目管理理论与实践系列文章索引

2011-05-31T03:59:00Z

项目管理理论与实践（1）——企业项目管理介绍

项目管理理论与实践（2）——软件需求分析

项目管理理论与实践（3）——如何进行有效的项目管理

项目管理理论与实践（4）——UML应用（上）

项目管理理论与实践（5）——UML应用（下）

项目管理理论与实践（6）——利用Excel制作项目文档的设计技巧

项目管理理论与实践（7）——软件开发报价的计算方法

待续

本文链接