<![CDATA[TUPUNCO 's BLOG]]> http://zhq.ahau.edu.cn/blog/ zh-cn PBlog2 v2.4 TUPUNCO 's BLOG http://zhq.ahau.edu.cn/blog/images/logos.gif http://zhq.ahau.edu.cn/blog/ TUPUNCO 's BLOG http://zhq.ahau.edu.cn/blog/article.asp?id=487 <![CDATA[一致性哈希C#简单实现]]> tupunco@163.com(tupunco) Sat,24 Jul 2010 18:10:15 +0800 http://zhq.ahau.edu.cn/blog/default.asp?id=487 Memcached 有名的开源高效分布式缓存系统.

Consistent Hashing(一致性哈希) 算法一个几乎完美的分布式哈希算法.

博客园7月上海活动, 第二场介绍"网站缓存"方面内容, 作者附带源码内提供的真不错. 不过感觉其中关于"一致性哈希"实现部分有点问题. 作者使用了.NET类库中 List<T> 的二叉搜索函数, MSDN文档中对返回的信息作了以下说明:

如果找到 item，则为已排序的 List<T> 中 item 的从零开始的索引；否则为一个负数，该负数是大于 item 的第一个元素的索引的按位求补。如果没有更大的元素，则为 Count 的按位求补。

一致性哈希简单说明(来源):

首先求出memcached服务器（节点）的哈希值，并将其配置到0～232的圆（continuum）上。然后用同样的方法求出存储数据的键的哈希值，并映射到圆上。然后从数据映射到的位置开始顺时针查找，将数据保存到找到的第一个服务器上。如果超过232仍然找不到服务器，就会保存到第一台memcached服务器上。

好像 List<T> 提供的二叉搜索刚好满足实现, 即数据映射的节点放到大于其哈希值的顺时针的服务器节点. 下面是活动作者提供的代码核心部分:

public string Locate(string key)
{
    uint itemKeyHash = BitConverter.ToUInt32(new ModifiedFNV().ComputeHash(Encoding.Unicode.GetBytes(key)), 0);
    int foundIndex = Array.BinarySearch<uint>(this.keys, itemKeyHash);
    if (foundIndex < 0)
    {
        foundIndex = ~foundIndex;
        if (foundIndex == 0) foundIndex = this.keys.Length - 1;
        else if (foundIndex >= this.keys.Length) foundIndex = 0;
    }
    if (foundIndex < 0 || foundIndex > this.keys.Length) return null;
    return this.servers[this.keys[foundIndex]];
}

感觉代码中不应该做 -1 的处理, 另外这个函数居然会返回 null.

提供一个小强自己实现的版本, 主要代码:

/// <summary>
/// Hash 具体的节点
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public KeyValuePair<uint, string> Locate(string key)
{
    if (string.IsNullOrEmpty(key))
        return _serList[0];
 
    var hash = Hash(key);
    var index = _serList.BinarySearch(new KeyValuePair<uint, string>(hash, null), new KeyValuePairComparer());
    if (index >= 0)
        return _serList[index];
    else
    {
        var nIndex = ~index;
        if (nIndex >= _serList.Count)
            return _serList[0];
        else
            return _serList[nIndex];
    }
}

代码下载地址:

参考地址:
http://msdn.microsoft.com/zh-cn/w4e7fxsh.aspx <MSDN List<T>.BinarySearch 方法文档>

http://www.cnblogs.com/lovecindywang/archive/2010/07/19/1780589.html<7/17博客园活动浅谈网站架构中缓存的应用所有资料>

http://tech.idv2.com/2008/07/24/memcached-004/ <memcached全面剖析> 翻译版(只要介绍 memcached 的地方都会有本文中的几章'黄图')

http://www.cnblogs.com/overred/archive/2009/12/29/consistent_hashing.html <《Shuttler.Net东写西读之二》Memcached的Consistent Hashing负载算法>

http://www.codeproject.com/KB/recipes/lib-conhash.aspx

http://home.comcast.net/~bretm/hash/6.html <修改版FNV1_32 哈希函数>

]]> http://zhq.ahau.edu.cn/blog/article.asp?id=486 <![CDATA[.NET 源代码]]> tupunco@163.com(tupunco) Sun,20 Jun 2010 13:18:57 +0800 http://zhq.ahau.edu.cn/blog/default.asp?id=486 查看.NET Framework的源代码实际也不是什么新鲜的事情, 最简单的可以通过Reflector查看, 不过会有一些语法特征方面的瑕疵, 例如对使用yeild关键字的实现部分, 老赵也在其博客"人肉"过他的编译后的特征. 印象中微软在VS2008SP1前后开放了.NET Framework 的源代码在线调试, ScottGu博客也有过介绍使用的方法, Codeplex 网站也有一个可以下载.NET源代码的工具. 一直以为.NET Framework 源代码也需要那么查看, 最近博客园的一片介绍VS2010的博文使自己发现其源代码微软本身提供下载, 不过博文地址已经不记得了. 直接给出下载地址:

http://referencesource.microsoft.com/netframework.aspx

小强下载了两项: .NET 8.0/ .Net 4, 搞不清楚这个8.0 是啥意识, 两个文件包加起来大概200M, 都为MSI格式. 安装后发现这个8.0的实际就是.NET 3.5 SP1 的"所有"Framework源代码, 4 的为.NET 4 Framework源代码. 好像每个版本源代码都是完整的.

安装后文件夹搞死人, 每个.cs文件都是一个"文件名文件夹+版本号文件夹+文件"的层次存放的, 例如System.Array类的存放路径为\System\Array.cs\1305376\Array.cs, 可能是TFS的缘故吧,自己也不甚了解, 只是源代码文件路径有一个"DEVDIV_TFS"的文件夹. 写了一个剔除版本号文件夹的一段代码:

   1: using System;
   2: using System.Collections.Generic;
   3: using System.Text;
   4: using System.IO;
   5: using System.Threading.Tasks;
   6:  
   7: namespace FixSrcConsoleApplication1
   8: {
   9:     class Program
  10:     {
  11:         /// <summary>
  12:         /// 源文件夹
  13:         /// </summary>
  14:         static string srcPath = @"D:\RefSrc\Source\.Net\4.0\DEVDIV_TFS\Dev10\Releases\RTMRel";
  15:         /// <summary>
  16:         /// 目标文件夹
  17:         /// </summary>
  18:         static string destPath = @"D:\RTMRel";
  19:  
  20:         static void Main(string[] args)
  21:         {
  22:             FixPath(srcPath);
  23:         }
  24:         /// <summary>
  25:         /// 处理
  26:         /// </summary>
  27:         /// <param name="currentPath"></param>
  28:         static void FixPath(string currentPath)
  29:         {
  30:             var currentDir = new DirectoryInfo(currentPath);
  31:             var files = currentDir.GetFiles();
  32:             var dirs = currentDir.GetDirectories();
  33:             //处理文件
  34:             if (files != null && files.Length != 0)
  35:             {
  36:                 Parallel.ForEach(files, file =>
  37:                 {
  38:                     //foreach (var file in files)
  39:                     //{
  40:                     var ndestFilePath = destPath + file.FullName.Remove(0, srcPath.Length);
  41:  
  42:                     TryCreatePath(ndestFilePath);
  43:  
  44:                     File.Copy(file.FullName, ndestFilePath, true);
  45:                     //}
  46:                 });
  47:             }
  48:             //文件夹处理
  49:             if (dirs != null && dirs.Length != 0)
  50:             {
  51:                 Parallel.ForEach(dirs, dir =>
  52:                 {
  53:                     //foreach (var dir in dirs)
  54:                     //{
  55:                     //.cs结尾的文件夹特殊处理
  56:                     if (dir.FullName.EndsWith(".cs"))
  57:                     {
  58:                         var dirFile = dir.GetDirectories()[0].GetFiles()[0];
  59:                         var ndestFilePath = destPath + dir.FullName.Remove(0, srcPath.Length);
  60:  
  61:                         TryCreatePath(ndestFilePath);
  62:  
  63:                         File.Copy(dirFile.FullName, ndestFilePath, true);
  64:                     }
  65:                     else
  66:                         FixPath(dir.FullName);
  67:                     //}
  68:                 });
  69:             }
  70:         }
  71:         /// <summary>
  72:         /// 尝试创建文件所在路径
  73:         /// </summary>
  74:         /// <param name="ndestFilePath"></param>
  75:         private static void TryCreatePath(string ndestFilePath)
  76:         {
  77:             var ndestPath = Path.GetDirectoryName(ndestFilePath);
  78:             if (!Directory.Exists(ndestPath))
  79:                 Directory.CreateDirectory(ndestPath);
  80:         }
  81:     }
  82: }

代码实现上使用了.NET 4提供的并行特征, 使用并行来实现功能后发现执行效率不是一般的快.

查看源代码的另外一个发现, 好多源代码文件内都有重复代码, 还是上面的Array.cs文件2602行又蹦出了一个 clsss Array{}.

几个感兴趣的代码实现:

\RTMRel\ndp\clr\src\BCL\System\Collections\Concurrent    .NET 提供的几个并行容器实现部分

\RTMRel\ndp\fx\src\xsp\System\Web\Cache                       System.Web.Cache 实现部分部分(System.Runtime.Cache实现没有找到)

\RTMRel\ndp\fx\src\Core\System\Threading\ReaderWriterLockSlim    .NET 3.5 开始提供的读写锁实现

 

一些链接:

配置VS2008调试.NET源代码 http://www.cnblogs.com/yuyijq/archive/2008/01/17/1042521.html

]]> http://zhq.ahau.edu.cn/blog/article.asp?id=485 <![CDATA[使用异步调用来使方法等待执行]]> tupunco@163.com(tupunco) Sun,20 Jun 2010 11:32:33 +0800 http://zhq.ahau.edu.cn/blog/default.asp?id=485 .NET 开发上可能会碰到以下情况:

1.等待一个方法的调用, 判断是否过期, 如果过期, 调用被忽略;

2.调用一个外部服务接口, 如果调用过期, 停顿一段时间在调用;

3.其他调用等待.

这种需求的实现可以使用.NET提供的异步编程方式来解决. 详细查看 MSDN这里. 大致方法为:"使用 WaitHandle 等待异步调用", 代码示例直接粘贴自 MSDN 相应代码:

   1: using System;
   2: using System.Threading;
   3:  
   4: namespace Examples.AdvancedProgramming.AsynchronousOperations
   5: {
   6:     public class AsyncDemo
   7:     {
   8:         // The method to be executed asynchronously.
   9:         public string TestMethod(int callDuration, out int threadId)
  10:         {
  11:             Console.WriteLine("Test method begins.");
  12:             Thread.Sleep(callDuration);
  13:             threadId = Thread.CurrentThread.ManagedThreadId; //获取进程执行进程号
  14:             return String.Format("My call time was {0}.", callDuration.ToString());
  15:         }
  16:     }
  17:     // The delegate must have the same signature as the method
  18:     // it will call asynchronously. 这里定义一个异步回调所用的代理
  19:     public delegate string AsyncMethodCaller(int callDuration, out int threadId);
  20:  
  21:     public class AsyncMain
  22:     {
  23:         static void Main()
  24:         {
  25:             // The asynchronous method puts the thread id here.
  26:             int threadId;
  27:  
  28:             // Create an instance of the test class.
  29:             AsyncDemo ad = new AsyncDemo();
  30:  
  31:             // Create the delegate. 创建代理
  32:             AsyncMethodCaller caller = new AsyncMethodCaller(ad.TestMethod);
  33:  
  34:             // Initiate the asychronous call. 开始异步调用
  35:             IAsyncResult result = caller.BeginInvoke(3000,
  36:                 out threadId, null, null);
  37:  
  38:             Thread.Sleep(0);
  39:             Console.WriteLine("Main thread {0} does some work.",
  40:                 Thread.CurrentThread.ManagedThreadId);
  41:  
  42:             // Wait for the WaitHandle to become signaled.等待方法执行知道结束
  43:             result.AsyncWaitHandle.WaitOne(); 
  44:  
  45:             // Perform additional processing here.
  46:             // Call EndInvoke to retrieve the results.返回执行结束的结果
  47:             string returnValue = caller.EndInvoke(out threadId, result);
  48:             // 打印结果, 查看异步执行是否的进程号, 发现跟主进程号不一样, 说明是异步执行
  49:             Console.WriteLine("The call executed on thread {0}, with return value \"{1}\".",
  50:                 threadId, returnValue);
  51:         }
  52:     }
  53: }

代码43行使用System.Threading.WaitHandle.WaitOne() 来等待BeginInvoke的线程结束, WaitOne方法有一个可以设置等待时间的重载实现:"public virtual bool WaitOne(int millisecondsTimeout);", 设置等待时间,  过期后等待结束, 直接返回false, 主线程做相应处理, 如下:

   1: if (result.AsyncWaitHandle.WaitOne(1000))
   2: {
   3:     // Perform additional processing here.
   4:     // Call EndInvoke to retrieve the results.
   5:     string returnValue = caller.EndInvoke(out threadId, result);
   6:  
   7:     Console.WriteLine("The call executed on thread {0}, with return value \"{1}\".",
   8:         threadId, returnValue);
   9: }
  10: else
  11: {
  12:     Console.WriteLine("方法执行, 等待过期.");
  13: }

等待1秒, 后直接返回,  因为TestMethod方法被挂起了3秒, 所以永远返回到12行, 调用实际上'代码1'中的14行是可以执行到的, 只是在他返回的时候, 主线程不再处理而已. 本等待方法还可以用作异步执行某些行为, 但不关心执行的结果.

因为使用BeginInvoke创建的是后台线程, 所以如果主线程结束, 进程会直接结束, 如果被异步调用的方法可能会发生没有被执行结束而退出的情况.

参考地址:

http://msdn.microsoft.com/zh-cn/library/2e08f6yc(VS.80).aspx

http://msdn.microsoft.com/zh-cn/library/ms228969(VS.80).aspx

2010-06-20  补充:

最近阅读<Windows并发编程指南>, 书第八章讲到"异步编程模型"中讲到"委托类型"实现BeginInvoke和EndInvoke的方法"远程组件", 并写到"尽量不要使用它们(BeginInvoke,EndInvoke来实现异步)...他将给异步调用带来非常大的开销". 以为"远程组件"为"Remoting Components", 但印象中.NET上没有这个名称, 翻看本书的英文版才知道为"Remoting Infrastructure", 按MSDN的翻译应该为"远程处理基本结构".  不兴的是这个"远程处理基本结构"没有找到通俗讲解的地方, 只找到一下一个相关链接:

http://msdn.microsoft.com/zh-cn/library/system.runtime.remoting.messaging.messagesurrogatefilter(v=VS.90).aspx
http://msdn.microsoft.com/zh-cn/library/kwdt6w2k(v=VS.71).aspx
http://msdn.microsoft.com/zh-cn/magazine/cc301332(en-us).aspx
http://www.cnblogs.com/artech/archive/2008/01/31/1059492.html

]]> http://zhq.ahau.edu.cn/blog/article.asp?id=480 <![CDATA[编程中使用的数学(2):权重随机]]> tupunco@163.com(tupunco) Sun,02 May 2010 14:18:43 +0800 http://zhq.ahau.edu.cn/blog/default.asp?id=480 博客也停了半年多了, 半年内好多事情, 时间和机会可能都不适合写下点东西, 2010年了, 开个好头. 之前的一篇写在2008年6月份, 这篇写在一年半以后, 真是个笑话.

步入正题. '权重随机'是去年九十月份工作中一个抽奖问题引出的. 需求需要达到不同奖品需要有不同的获得几率, 在查找资料中找到了以下几篇文章:

  1. http://zzk.cnblogs.com/s?w=%e6%9d%83%e9%87%8d+%e9%9a%8f%e6%9c%ba&p=1
  2. 生成安全的随机数    http://www.cnblogs.com/rainy/archive/2006/08/05/468670.html
  3. http://www.cnblogs.com/wdfrog/archive/2007/12/14/994963.html

按'权重随机'过程假设编程平台上的提供的随机发生器产生的每个结果都是等概率的(实际上.NET平台和其他编程平台上提供了很好的满足本条件的随机发生器), 另外一个条件是'权重'以非负整形数的形式提供. 假如'待随机项'集合为 {I,…,In}, 其对应的权重结合为 {W,…,Wn}, 在产生随机数的时候随机的范围为(0, ∑Wi), 其中∑Wi表示为'所有待随机项权重的和', 使用随机器产生的随机结果假如在 (wi, wi+1] 范围了(注意开闭区间), 则当前的随机结果项为Ii. 可以简单理解为以下的文字描述: 把所有'待随机项'的权重和作为要随机的上限, '随机项'前后排好序, 生成的随机结果如果在某两个个随机项(A,B)权重区间范围内, 那么随机的结果项就取A.

经过上面几篇的文章的研读和抄袭后就出了今天文章中的代码, 下面是'权重随机'核心代码部分:

   1: /// <summary>
   2: /// 根据随机器和权重和得到随机结果项
   3: /// </summary>
   4: /// <typeparam name="T"></typeparam>
   5: /// <param name="items">权重项</param>
   6: /// <param name="rng">随机化器</param>
   7: /// <returns></returns>
   8: static WeightItem<T> GetRandowmItem<T>(IEnumerable<WeightItem<T>> items, IRNG rng)
   9: {
  10:     int sum = GetSum(items);
  11:     int rand = rng.Next(0, sum);
  12:     int cSum = 0;
  13:     foreach (var item in items)
  14:     {
  15:         cSum += item.Weight;
  16:         if (cSum > rand)
  17:             return item;
  18:     }
  19:     return new WeightItem<T>();    
  20: }
  21: /// <summary>
  22: /// 得到当前随机项权重和
  23: /// </summary>
  24: /// <typeparam name="T"></typeparam>
  25: /// <param name="items"></param>
  26: /// <returns></returns>
  27: static int GetSum<T>(IEnumerable<WeightItem<T>> items)
  28: {
  29:     int sum = 0;
  30:     foreach (var item in items)
  31:     {
  32:         sum += item.Weight;
  33:     }
  34:     return sum;
  35: }

10-18行是完成整个权重随机过程, 代码与之前某篇文章<http://www.cnblogs.com/wdfrog/archive/2007/12/14/994963.html>的实现一致, 只是这个"IRNG rng"有点不一样, IRNG是一个随机发生器的封装接口:

   1: /// <summary>
   2: /// 随机化器 接口类
   3: /// </summary>
   4: public interface IRNG
   5: {
   6:     /// <summary>
   7:     /// 返回一个指定范围内的随机数
   8:     /// </summary>
   9:     /// <param name="minValue">返回的随机数的下界(随机数可取该下界值)</param>
  10:     /// <param name="maxValue"> 返回的随机数的上界(随机数不能取该上界值), maxValue 必须大于或等于 minValue</param>
  11:     /// <returns>
  12:     /// 一个大于或等于 minValue 且小于 maxValue 的 32 位带符号整数, 即: 返回的值范围包括 minValue 但不包括 maxValue. 如果
  13:     /// minValue 等于 maxValue, 则返回 minValue
  14:     /// </returns>
  15:     int Next(int minValue, int maxValue);
  16: }

封装的目的是 .NET 中默认的 System.Random 随机可能不够完美, 或不够安全, 所以封装了使用 System.Security.Cryptography.RNGCryptoServiceProvider 来随机的随机器. int Next(int minValue, int maxValue) 实现如下:

   1: public int Next(int minValue, int maxValue)
   2: {
   3:     if (minValue > maxValue)
   4:         throw new ArgumentOutOfRangeException("minValue", "");
   5:  
   6:     int numSides = maxValue - minValue;
   7:     byte[] bn = new byte[4];
   8:     int num = 0;
   9:  
  10:     rand.GetBytes(bn);
  11:     num = BitConverter.ToInt32(bn, 0);
  12:     num = num % numSides;
  13:     if (num < 0)
  14:         num = -num;
  15:  
  16:     return num + minValue;
  17: }

上面的实现实际上来自于这里:<http://www.cnblogs.com/rainy/archive/2006/08/05/468670.html>. 由于使用 RNGCryptoServiceProvider 来随机, 可能计算有点慢, 不过没有详细测试.

为了增加本文中实现的权重随机的通用性, 还实现了一个泛型'随机项'类,  如下:

   1: /// <summary>
   2: /// 权重项
   3: /// </summary>
   4: /// <typeparam name="T"></typeparam>
   5: public class WeightItem<T>
   6: {
   7:     /// <summary>
   8:     /// 权重
   9:     /// </summary>
  10:     public int Weight { get; set; }
  11:     /// <summary>
  12:     /// 项值
  13:     /// </summary>
  14:     public T ItemValue { get; set; }
  15:     /// <summary>
  16:     /// 
  17:     /// </summary>
  18:     /// <returns></returns>
  19:     public override string ToString()
  20:     {
  21:         return string.Format("[ItemValue:{0}, Weight:{1}]", ItemValue, Weight);
  22:     }
  23: }

测试代码如下:

   1: //权重随机项-1
   2: List<WeightItem<char>> wItems = new List<WeightItem<char>>() { 
   3:     new WeightItem<char>(){ ItemValue='A', Weight=60},
   4:     new WeightItem<char>(){ ItemValue='B', Weight=30},
   5:     new WeightItem<char>(){ ItemValue='C', Weight=5},
   6:     new WeightItem<char>(){ ItemValue='D', Weight=5},
   7: };
   8: //随机器
   9: IRNG rng = new RNG.SysCspRNG();
  10: //结果保存字典
  11: Dictionary<char, int> dicResult = new Dictionary<char, int>();
  12: //根据随机项取得1000000次随机结果
  13: List<WeightItem<char>> resultList = RandomHelper.GetRandomItemsFromWeightItems(wItems, rng, 1000000);
  14: foreach (var item in resultList)
  15: {
  16:     if (dicResult.ContainsKey(item.ItemValue))
  17:         dicResult[item.ItemValue]++;
  18:     else
  19:         dicResult.Add(item.ItemValue, 0);
  20: }
  21: //打印结果
  22: foreach (var item in dicResult)
  23: {
  24:     Console.WriteLine("{0}:{1}", item.Key, item.Value);
  25: }

测试代码中随机项为 {A, B, C, D}, 权重分别为 {60, 30, 5, 5}, 为了计算方面随机 100 的倍数.次 代码中 'IRNG rng = new RNG.SysCspRNG();' 即为实现了IRNG接口使用 RNGCryptoServiceProvider 来随机的随机器. RandomHelper.GetRandomItemsFromWeightItems 是封装了之前的'权重随机'函数的一个支持批量随机的静态方法, 如下:

   1: /// <summary>
   2: /// 根据'权重项列表'和'随机次数'得到'随机项结果列表'
   3: /// </summary>
   4: /// <typeparam name="T"></typeparam>
   5: /// <param name="items">权重项</param>
   6: /// <param name="rng">随机化器</param>
   7: /// <param name="times">随机次数</param>
   8: /// <returns>随机结果项列表</returns>
   9: public static List<WeightItem<T>> GetRandomItemsFromWeightItems<T>(IEnumerable<WeightItem<T>> items, IRNG rng, int times)
  10: {
  11:     if (items == null)
  12:         throw new System.ArgumentNullException("items");
  13:     if (rng == null)
  14:         throw new System.ArgumentNullException("rng");
  15:     if (times <0)
  16:         throw new System.ArgumentException("'随机次数'必须大于0","times");
  17:  
  18:     int sum = GetSum(items);
  19:     List<WeightItem<T>> list = new List<WeightItem<T>>(times);
  20:  
  21:     for (int i = 0; i < times; i++)
  22:     {
  23:         list.Add(GetRandowmItem(items,rng, sum));
  24:     }
  25:  
  26:     return list;
  27: }

随机结果如下:

B:299348
A:600648
D:49713
C:50287

基本是按"A:60, B:30, C:5, D5" 的权重比例来的.

就这么多内容, 另外推荐以下文章作为扩展阅读:

  1. http://security.ctocio.com.cn/securitycomment/385/8082385.shtml
  2. http://zh.linuxvirtualserver.org/node/35
  3. http://zh.linuxvirtualserver.org/node/36
  4. http://zh.linuxvirtualserver.org/node/37
  5. http://mindhacks.cn/2008/09/21/the-magical-bayesian-method/
  6. http://jun.wu.googlepages.com/beautyofmathematics

2010年5月2号补充:

给出一个证明详细的文章地址:http://www.cnblogs.com/miloyip/archive/2010/04/21/1717109.html.  文章中从统计学角度详细说明了本方法的理论依据, 文章中图文并茂, 论据充分, 学术严谨(谐).

 

 

演示代码下载如下:

]]> http://zhq.ahau.edu.cn/blog/article.asp?id=484 <![CDATA[一个线程安全的FIFO缓存容器]]> tupunco@163.com(tupunco) Sun,28 Mar 2010 19:52:08 +0800 http://zhq.ahau.edu.cn/blog/default.asp?id=484 项目中需要一个缓存容器, 满足先进先出(FIFO)需求, 容量10000.  参考了几个LRU缓存容器实现, 使用字典(Dictionary)+队列(Queue)组合的方式来达到'插入/删除/读取'复杂度都为O(1), 缓存容器所以需要保持线程安全, 使用简单的lock语句来实现. 下面是实现代码:

   1: /// <summary>
   2: /// LIFO 容器
   3: /// </summary>
   4: /// <typeparam name="TKey"></typeparam>
   5: /// <typeparam name="TValue"></typeparam>
   6: public class ThreadSafeLifoDictionary<TKey, TValue>
   7: {
   8:     private Dictionary<TKey, TValue> _Dict = new Dictionary<TKey, TValue>();
   9:     private Queue<TKey> _Queue = new Queue<TKey>();
  10:     private object _LockObj = new object();
  11:  
  12:     /// <summary>
  13:     /// 容量
  14:     /// </summary>
  15:     public int Capacity { get; private set; }
  16:  
  17:     public ThreadSafeLifoDictionary() : this(10000) { }
  18:     public ThreadSafeLifoDictionary(int capacity)
  19:     {
  20:         this.Capacity = capacity;
  21:     }
  22:  
  23:     /// <summary>
  24:     /// 当前项数
  25:     /// </summary>
  26:     public int Count
  27:     {
  28:         get
  29:         {
  30:             lock (_LockObj)
  31:             {
  32:                 return _Queue.Count;
  33:             }
  34:         }
  35:     }
  36:     /// <summary>
  37:     /// 清空
  38:     /// </summary>
  39:     public void Clear()
  40:     {
  41:         lock (_LockObj)
  42:         {
  43:             _Queue.Clear();
  44:             _Dict.Clear();
  45:         }
  46:     }
  47:     /// <summary>
  48:     /// 添加或更新已有项
  49:     /// </summary>
  50:     /// <param name="key"></param>
  51:     /// <param name="value"></param>
  52:     /// <returns>添加操作返回true, 更新操作返回false</returns>
  53:     public bool AddOrUpdate(TKey key, TValue value)
  54:     {
  55:         lock (_LockObj)
  56:         {
  57:             CheckAndTruncate();
  58:  
  59:             if (this._Dict.ContainsKey(key))
  60:             {
  61:                 this._Dict[key] = value;
  62:                 return false;
  63:             }
  64:             else
  65:             {
  66:                 this._Dict.Add(key, value);
  67:                 this._Queue.Enqueue(key);
  68:                 return true;
  69:             }
  70:         }
  71:     }
  72:     /// <summary>
  73:     /// 包含指定项
  74:     /// </summary>
  75:     /// <param name="key"></param>
  76:     /// <returns></returns>
  77:     public bool ContainsKey(TKey key)
  78:     {
  79:         lock (_LockObj)
  80:         {
  81:             return _Dict.ContainsKey(key);
  82:         }
  83:     }
  84:     /// <summary>
  85:     /// 获取指定项
  86:     /// </summary>
  87:     /// <param name="key"></param>
  88:     /// <param name="value"></param>
  89:     /// <returns></returns>
  90:     public bool TryGetValue(TKey key, out TValue value)
  91:     {
  92:         lock (_LockObj)
  93:         {
  94:             return this._Dict.TryGetValue(key, out value);
  95:         }
  96:     }
  97:     /// <summary>
  98:     /// 达到容量值后删除十分之一的元素
  99:     /// </summary>
 100:     private void CheckAndTruncate()
 101:     {
 102:         int count = _Dict.Count;
 103:         if (count >= Capacity)
 104:         {
 105:             int needRemoveCount = count / 10;
 106:             for (int i = 0; i < needRemoveCount; i++)
 107:             {
 108:                 _Dict.Remove(_Queue.Peek());
 109:                 _Queue.Dequeue();
 110:             }
 111:         }
 112:     }
 113: }

对于容量控制部分直接使用了"蛙蛙推荐 LRU"的删除策略, 如果一下只删除一个容量的方式, 会因为频繁创建销毁对象, 而给垃圾回收带来压力.

一个例子: 

   1: /// <summary>
   2: /// 一个使用的例子
   3: /// 订阅缓存, 缓存UserID, ChapterID
   4: /// </summary>
   5: public class SubscribeCacheDemo
   6: {
   7:     ThreadSafeLifoDictionary<string, string> _LifoDict = null;
   8:     private SubscribeCacheDemo(int capacity)
   9:     {
  10:         _LifoDict = new ThreadSafeLifoDictionary<string, string>(capacity);
  11:     }
  12:     /// <summary>
  13:     /// 实例(单件模式访问本缓存对象)
  14:     /// </summary>
  15:     public static readonly SubscribeCacheDemo Instance = new SubscribeCacheDemo(100000);
  16:     /// <summary>
  17:     /// 订阅
  18:     /// </summary>
  19:     /// <param name="userID"></param>
  20:     /// <param name="ChapterID"></param>
  21:     /// <returns></returns>
  22:     public bool Subscribe(int userID, int ChapterID)
  23:     {
  24:         return _LifoDict.AddOrUpdate(string.Format("{0}-{1}", userID, ChapterID), string.Empty);
  25:     }
  26:     /// <summary>
  27:     /// 是否订阅过
  28:     /// </summary>
  29:     /// <param name="userID"></param>
  30:     /// <param name="ChapterID"></param>
  31:     /// <returns></returns>
  32:     public bool HasSubscribe(int userID, int ChapterID)
  33:     {
  34:         return _LifoDict.ContainsKey(string.Format("{0}-{1}", userID, ChapterID));
  35:     }
  36: }

本缓存容器的性能上一个不好的地方是直接使用lock方式的锁, 频繁的锁缓存容器, 没有读写分开. 一个好的改进应该使用"ReaderWriterLock/ReaderWriterLockSlim"来读写分开, 关于这两种锁的性能对比可以参看老赵的博文.

 

参考地址:

http://www.cnblogs.com/onlytiancai/archive/2009/07/22/wawa_lru.html  蛙蛙推荐 LRU

http://stackoverflow.com/questions/581119/object-cache-for-c

http://www.cnblogs.com/JeffreyZhao/archive/2009/11/16/concurrent-cache-performance-improvement-2-benchmark.html

http://nintegrate.com

]]> http://zhq.ahau.edu.cn/blog/article.asp?id=482 <![CDATA[验证码上的高效正弦扭曲函数]]> tupunco@163.com(tupunco) Sat,30 Jan 2010 17:58:13 +0800 http://zhq.ahau.edu.cn/blog/default.asp?id=482 c#上, 但凡需要给验证码添加扭曲的地方感觉都是一个函数:

#region 产生波形滤镜效果
 
 private const double PI = 3.1415926535897932384626433832795;
 private const double PI2 = 6.283185307179586476925286766559;
 
 /// <summary>
 /// 正弦曲线Wave扭曲图片
 /// </summary>
 /// <param name="srcBmp">图片路径</param>
 /// <param name="bXDir">如果扭曲则选择为True</param>
 /// <param name="nMultValue">波形的幅度倍数，越大扭曲的程度越高，一般为3</param>
 /// <param name="dPhase">波形的起始相位，取值区间[0-2*PI)</param>
 /// <returns></returns>
 public System.Drawing.Bitmap TwistImage(Bitmap srcBmp, bool bXDir, double dMultValue, double dPhase)
 {
     System.Drawing.Bitmap destBmp = new Bitmap(srcBmp.Width, srcBmp.Height);
 
     // 将位图背景填充为白色
     System.Drawing.Graphics graph = System.Drawing.Graphics.FromImage(destBmp);
     graph.FillRectangle(new SolidBrush(System.Drawing.Color.White), 0, 0, destBmp.Width, destBmp.Height);
     graph.Dispose();
 
     double dBaseAxisLen = bXDir ? (double)destBmp.Height : (double)destBmp.Width;
 
     for (int i = 0; i < destBmp.Width; i++)
     {
         for (int j = 0; j < destBmp.Height; j++)
         {
             double dx = 0;
             dx = bXDir ? (PI2 * (double)j) / dBaseAxisLen : (PI2 * (double)i) / dBaseAxisLen;
             dx += dPhase;
             double dy = Math.Sin(dx);
 
             // 取得当前点的颜色
             int nOldX = 0, nOldY = 0;
             nOldX = bXDir ? i + (int)(dy * dMultValue) : i;
             nOldY = bXDir ? j : j + (int)(dy * dMultValue);
 
             System.Drawing.Color color = srcBmp.GetPixel(i, j);
             if (nOldX >= 0 && nOldX < destBmp.Width
              && nOldY >= 0 && nOldY < destBmp.Height)
             {
                 destBmp.SetPixel(nOldX, nOldY, color);
             }
         }
     }
 
     return destBmp;
 }
 
 #endregion

这个函数实在效率不高, 但还是很多人用. 可以从下面的地址得到结果:

http://www.google.cn/search?hl=zh-CN&newwindow=1&q=Bitmap+TwistImage%28Bitmap+srcBmp&btnG=Google+%E6%90%9C%E7%B4%A2&aq=f&oq=

下面是改进的这个函数:

 

#region 波浪函数
//正弦起始点
private const double PI = 3.141592;
//正弦扭曲率
private const double PI2 = 6.28318;
/// <summary>
/// 正弦曲线Wave扭曲图片
/// </summary>
/// <param name="srcBmp">图片路径</param>
/// <param name="bXDir">沿Y轴扭曲则选择为True</param>
/// <param name="dMultValue">波形的幅度倍数，越大扭曲的程度越高，一般为3</param>
/// <param name="dPhase">波形的起始相位，取值区间[0-2*PI)</param>
/// <returns></returns>
private static Bitmap TwistImage(Bitmap srcBmp, bool bXDir, double dMultValue, double dPhase)
{
    return TwistImage(srcBmp, bXDir, dMultValue, dPhase, 1f);
}
/// <summary>
/// 正弦曲线Wave扭曲图片
/// </summary>
/// <param name="srcBmp">图片路径</param>
/// <param name="bXDir">沿Y轴扭曲则选择为True</param>
/// <param name="dMultValue">波形的幅度倍数，越大扭曲的程度越高，一般为3</param>
/// <param name="dPhase">波形的起始相位，取值区间[0-2*PI)</param>
/// <param name="times">应用几个周期</param>
/// <returns></returns>
private static Bitmap TwistImage(Bitmap srcBmp, bool bXDir, double dMultValue, double dPhase, float times)
{
    int w = srcBmp.Width;
    int h = srcBmp.Height;
    System.Drawing.Bitmap destBmp = new Bitmap(w, h, PixelFormat.Format24bppRgb);
 
    // 将位图背景填充为白色
    using (System.Drawing.Graphics graph = System.Drawing.Graphics.FromImage(destBmp))
    {
        graph.Clear(Color.White);
    }
 
    double dBaseAxisLen = bXDir ? (double)h : (double)w;
    BitmapData destData = destBmp.LockBits(new Rectangle(0, 0, w, h), ImageLockMode.WriteOnly, destBmp.PixelFormat);
    BitmapData srcData = srcBmp.LockBits(new Rectangle(0, 0, w, h), ImageLockMode.ReadOnly, srcBmp.PixelFormat);
    unsafe
    {
        byte* p = (byte*)(void*)srcData.Scan0;
        byte* p2 = (byte*)(void*)destData.Scan0;
        for (int i = 0; i < w; i++)
        {
            for (int j = 0; j < h; j++)
            {
                double dx = 0;
                dx = bXDir ? (PI2 * (double)j * times) / dBaseAxisLen : (PI2 * (double)i * times) / dBaseAxisLen;
                dx += dPhase;
                double dy = Math.Sin(dx);
 
                // 取得当前点的颜色
                int nOldX = 0, nOldY = 0;
                nOldX = bXDir ? i + (int)(dy * dMultValue) : i;
                nOldY = bXDir ? j : j + (int)(dy * dMultValue);
 
                if (nOldX >= 0 && nOldX < w
                 && nOldY >= 0 && nOldY < h)
                {
                    p2[(nOldY * destData.Stride) + (nOldX * 3)] = p[(j * srcData.Stride) + (i * 3)];
                    p2[(nOldY * destData.Stride) + (nOldX * 3) + 1] = p[(j * srcData.Stride) + (i * 3) + 1];
                    p2[(nOldY * destData.Stride) + (nOldX * 3) + 2] = p[(j * srcData.Stride) + (i * 3) + 2];
                }
            }
        }
    }
    destBmp.UnlockBits(destData);
    srcBmp.UnlockBits(srcData);
    if (srcBmp != null)
        srcBmp.Dispose();
    return destBmp;
}

调整了PI值, 测试发现这个值小了效率有所提高. 另外使用unsafe代码绘制波纹, 这个效率基本可以提高10倍之上. 另外扩展了这个函数可以支持多个周期的正弦扭曲. 需要注意的地方是:

System.Drawing.Bitmap destBmp = new Bitmap(w, h, PixelFormat.Format24bppRgb);

强制使用24位, 原因可以参看以下解释:

  1. http://www.bobpowell.net/lockingbits.htm
  2. http://notebk.gofreeserve.com/?p=206(上文翻译)
  3. http://msdn.microsoft.com/zh-cn/library/5ey6h79d(VS.80).aspx
  4. http://msdn.microsoft.com/zh-cn/library/system.drawing.imaging.pixelformat.aspx

另外提供一个不用unsafe的实现版本:

/// <summary>
/// 正弦曲线Wave扭曲图片
/// </summary>
/// <param name="srcBmp">图片路径</param>
/// <param name="bXDir">沿Y轴扭曲则选择为True</param>
/// <param name="dMultValue">波形的幅度倍数，越大扭曲的程度越高，一般为3</param>
/// <param name="dPhase">波形的起始相位，取值区间[0-2*PI)</param>
/// <param name="times">应用几个周期</param>
/// <returns></returns>
private static Bitmap TwistImage2(Bitmap srcBmp, bool bXDir, double dMultValue, double dPhase, float times)
{
    int w = srcBmp.Width;
    int h = srcBmp.Height;
    System.Drawing.Bitmap destBmp = new Bitmap(w, h, PixelFormat.Format24bppRgb);
 
    // 将位图背景填充为白色
    using (System.Drawing.Graphics graph = System.Drawing.Graphics.FromImage(destBmp))
    {
        graph.Clear(Color.White);
    }
 
    double dBaseAxisLen = bXDir ? (double)h : (double)w;
    BitmapData destData = destBmp.LockBits(new Rectangle(0, 0, w, h), ImageLockMode.WriteOnly, destBmp.PixelFormat);
    BitmapData srcData = srcBmp.LockBits(new Rectangle(0, 0, w, h), ImageLockMode.ReadOnly, srcBmp.PixelFormat);
    byte[] rgbValues = new byte[3];
    for (int i = 0; i < w; i++)
    {
        for (int j = 0; j < h; j++)
        {
            double dx = 0;
            dx = bXDir ? (PI2 * (double)j * times) / dBaseAxisLen : (PI2 * (double)i * times) / dBaseAxisLen;
            dx += dPhase;
            double dy = Math.Sin(dx);
 
            // 取得当前点的颜色
            int nOldX = 0, nOldY = 0;
            nOldX = bXDir ? i + (int)(dy * dMultValue) : i;
            nOldY = bXDir ? j : j + (int)(dy * dMultValue);
 
            if (nOldX >= 0 && nOldX < w
             && nOldY >= 0 && nOldY < h)
            {
                Marshal.Copy((IntPtr)((int)srcData.Scan0 + ((j * srcData.Stride) + (i * 3))), rgbValues, 0, 3);
                Marshal.Copy(rgbValues, 0, (IntPtr)((int)destData.Scan0 + ((nOldY * destData.Stride) + (nOldX * 3))), 3);
            }
        }
    }
    destBmp.UnlockBits(destData);
    srcBmp.UnlockBits(srcData);
    if (srcBmp != null)
        srcBmp.Dispose();
    return destBmp;
}
#endregion

这下"#region "关闭了就.

]]> http://zhq.ahau.edu.cn/blog/article.asp?id=483 <![CDATA[KCAPTCHA 验证码波纹扭曲函数 C# 实现]]> tupunco@163.com(tupunco) Sat,30 Jan 2010 17:56:57 +0800 http://zhq.ahau.edu.cn/blog/default.asp?id=483 KCAPTCHA  一个不错的验证码实现, 官方网站:http://www.captcha.ru/en/kcaptcha/. 因为工作原因, 需要改进验证码所有有机会把波纹扭曲部分使用 C# 实现. 

#region  KCAPTCHA 波纹扭曲
/// <summary>
/// # KCAPTCHA PROJECT VERSION 1.2.6
/// www.captcha.ru, www.kruglov.ru
/// 波形扭曲 FROM KCAPTCHA
/// </summary>
/// <param name="srcBmp">待扭曲的图像 必须为 PixelFormat.Format24bppRgb 格式图像</param>
/// <returns></returns>
private static Bitmap WaveDistortion(Bitmap srcBmp)
{
    if (srcBmp == null)
        return null;
    if (srcBmp.PixelFormat != PixelFormat.Format24bppRgb)
        throw new ArgumentException("srcBmp PixelFormat.Format24bppRgb 格式图像", "srcBmp");
 
    var width = srcBmp.Width;
    var height = srcBmp.Height;
 
    Bitmap destBmp = new Bitmap(width, height, PixelFormat.Format24bppRgb);
    {
        //前景色
        Color foreground_color = Color.FromArgb(randx.Next(10, 100), randx.Next(10, 100), randx.Next(10, 100));
        //背景色
        Color background_color = Color.FromArgb(randx.Next(200, 250), randx.Next(200, 250), randx.Next(200, 250));
 
        using (Graphics newG = Graphics.FromImage(destBmp))
        {
            newG.Clear(background_color);
            // periods 时间
            double rand1 = randx.Next(710000, 1200000) / 10000000.0;
            double rand2 = randx.Next(710000, 1200000) / 10000000.0;
            double rand3 = randx.Next(710000, 1200000) / 10000000.0;
            double rand4 = randx.Next(710000, 1200000) / 10000000.0;
            // phases  相位
            double rand5 = randx.Next(0, 31415926) / 10000000.0;
            double rand6 = randx.Next(0, 31415926) / 10000000.0;
            double rand7 = randx.Next(0, 31415926) / 10000000.0;
            double rand8 = randx.Next(0, 31415926) / 10000000.0;
            // amplitudes 振幅
            double rand9 = randx.Next(330, 420) / 110.0;
            double rand10 = randx.Next(330, 450) / 110.0;
            double amplitudesFactor = randx.Next(5, 6) / 10.0;//振幅小点防止出界
            double center = width / 2.0;
 
            //wave distortion 波纹扭曲
            BitmapData destData = destBmp.LockBits(new Rectangle(0, 0, width, height), ImageLockMode.WriteOnly, destBmp.PixelFormat);
            BitmapData srcData = srcBmp.LockBits(new Rectangle(0, 0, width, height), ImageLockMode.ReadOnly, srcBmp.PixelFormat);
            for (var x = 0; x < width; x++)
            {
                for (var y = 0; y < height; y++)
                {
                    var sx = x + (Math.Sin(x * rand1 + rand5)
                                + Math.Sin(y * rand3 + rand6)) * rand9 - width / 2 + center + 1;
                    var sy = y + (Math.Sin(x * rand2 + rand7)
                                + Math.Sin(y * rand4 + rand8)) * rand10 * amplitudesFactor; //振幅小点防止出界
 
                    int color, color_x, color_y, color_xy;
                    Color overColor = Color.Empty;
 
                    if (sx < 0 || sy < 0 || sx >= width - 1 || sy >= height - 1)
                    {
                        continue;
                    }
                    else
                    {
                        color = BitmapDataColorAt(srcData, (int)sx, (int)sy).B;
                        color_x = BitmapDataColorAt(srcData, (int)(sx + 1), (int)sy).B;
                        color_y = BitmapDataColorAt(srcData, (int)sx, (int)(sy + 1)).B;
                        color_xy = BitmapDataColorAt(srcData, (int)(sx + 1), (int)(sy + 1)).B;
                    }
 
                    if (color == 255 && color_x == 255 && color_y == 255 && color_xy == 255)
                    {
                        continue;
                    }
                    else if (color == 0 && color_x == 0 && color_y == 0 && color_xy == 0)
                    {
                        overColor = Color.FromArgb(foreground_color.R, foreground_color.G, foreground_color.B);
                    }
                    else
                    {
                        double frsx = sx - Math.Floor(sx);
                        double frsy = sy - Math.Floor(sy);
                        double frsx1 = 1 - frsx;
                        double frsy1 = 1 - frsy;
 
                        double newColor =
                             color * frsx1 * frsy1 +
                             color_x * frsx * frsy1 +
                             color_y * frsx1 * frsy +
                             color_xy * frsx * frsy;
 
                        if (newColor > 255) newColor = 255;
                        newColor = newColor / 255;
                        double newcolor0 = 1 - newColor;
 
                        int newred = Math.Min((int)(newcolor0 * foreground_color.R + newColor * background_color.R), 255);
                        int newgreen = Math.Min((int)(newcolor0 * foreground_color.G + newColor * background_color.G), 255);
                        int newblue = Math.Min((int)(newcolor0 * foreground_color.B + newColor * background_color.B), 255);
 
                        overColor = Color.FromArgb(newred, newgreen, newblue);
                    }
                    BitmapDataColorSet(destData, x, y, overColor);
                }
            }
            destBmp.UnlockBits(destData);
            srcBmp.UnlockBits(srcData);
        }
        if (srcBmp != null)
            srcBmp.Dispose();
    }
    return destBmp;
}
/// <summary>
/// 获得 BitmapData 指定坐标的颜色信息
/// 实现 PHP imagecolorat
/// </summary>
/// <param name="srcData">从图像数据获得颜色 必须为 PixelFormat.Format24bppRgb 格式图像数据</param>
/// <param name="x"></param>
/// <param name="y"></param>
/// <returns>x,y 坐标的颜色数据</returns>
/// <remarks>
/// Format24BppRgb 已知X，Y坐标，像素第一个元素的位置为Scan0+(Y*Stride)+(X*3)。
/// 这是blue字节的位置，接下来的2个字节分别含有green、red数据。
/// </remarks>
static Color BitmapDataColorAt(BitmapData srcData, int x, int y)
{
    if (srcData.PixelFormat != PixelFormat.Format24bppRgb)
        throw new ArgumentException("srcData PixelFormat.Format24bppRgb 格式图像数据", "srcData");
 
    byte[] rgbValues = new byte[3];
    Marshal.Copy((IntPtr)((int)srcData.Scan0 + ((y * srcData.Stride) + (x * 3))), rgbValues, 0, 3);
    return Color.FromArgb(rgbValues[2], rgbValues[1], rgbValues[0]);
}
/// <summary>
/// 设置 BitmapData 指定坐标的颜色信息
/// 实现 PHP ImageColorSet
/// </summary>
/// <param name="destData">设置图像数据的颜色 必须为 PixelFormat.Format24bppRgb 格式图像数据</param>
/// <param name="x"></param>
/// <param name="y"></param>
/// <param name="color">待设置颜色</param>
/// <remarks>
/// Format24BppRgb 已知X，Y坐标，像素第一个元素的位置为Scan0+(Y*Stride)+(X*3)。
/// 这是blue字节的位置，接下来的2个字节分别含有green、red数据。
/// </remarks>
static void BitmapDataColorSet(BitmapData destData, int x, int y, Color color)
{
    if (destData.PixelFormat != PixelFormat.Format24bppRgb)
        throw new ArgumentException("destData PixelFormat.Format24bppRgb 格式图像数据", "destData");
 
    byte[] rgbValues = new byte[3] { color.B, color.G, color.R };
    Marshal.Copy(rgbValues, 0, (IntPtr)((int)destData.Scan0 + ((y * destData.Stride) + (x * 3))), 3);
}
#endregion

另外一些验证码游优化有关的链接:

  1. http://www.captcha.ru/en/kcaptcha/   (KCAPTCHA 官方)
  2. http://zh.wikipedia.org/wiki/CAPTCHA
  3. http://en.wikipedia.org/wiki/CAPTCHA
  4. http://caca.zoy.org/wiki/PWNtcha
  5. http://www.brains-n-brawn.com/default.aspx?vDir=aicaptcha
  6. http://www.captcha.net/

还有一些验证码识别的链接:

  1. http://www.cnblogs.com/xiaotie/archive/2009/01/15/1376677.html
  2. http://www.codeproject.com/KB/recipes/Shape_context_matching.aspx
  3. http://en.wikipedia.org/wiki/Shape_context
  4. http://www.eecs.berkeley.edu/Research/Projects/CS/vision/shape/sc_digits.html
]]> http://zhq.ahau.edu.cn/blog/article.asp?id=475 <![CDATA[软件开发经典书籍的魅力]]> tupunco@163.com(tupunco) Mon,06 Apr 2009 10:07:26 +0800 http://zhq.ahau.edu.cn/blog/default.asp?id=475 读软件开发方面书籍自己似乎有偏好，不喜欢看国内作者写的（不过有好书也是看的，比如博文视点的好多原创经典书籍）大部分看的是国外书籍的译本（英语不好只能看译本），译本也是有选择的，如果是一堆人翻译的基本也不看，除非这本书讲的方面确实就这么一本书，并且翻译的也不赖。博客园有一.NET方面的牛人名叫“老赵”，他的博客格言是“让老外看中国人写的计算机书籍”，甚是敬仰。

过年前后接手的项目是一个“客户端数据录入”的软件，之前开发的都是B/S软件，对WinForm开发中的某些要求也不甚了解，所以按着WEB软件的模式来建立“数据连接层”、“业务逻辑层”。其实自己使用了一个“SocanCode”的代码生成器来生成了“数据连接层”和“业务逻辑层”，由于客户要求的这个客户端软件除了要有一个“中心版”还要一个“部门版”的（软件为什么没有直接设计成B/S版的呢？因为客户的理由是“部门版”的用户可能没有网络，并且点名要搞两个版本），考虑到性能方面的要求所以“部门版”数据库用Access，“中心版”使用SQL Server 2000 个人版，所以这个“代码生成器”生成了两套“数据连接层”代码，真是不错的东西。

“SocanCode”生成的代码类似于“PetShop 4”，模式的代码，“数据实体模型”部分直接就是实体类，软件在实现的时候碰到一个问题：数据库的某些字段的值与其他字段有隐藏的“关联”关系，比如一个XX号=某些字典字段+某些字典字段+自编号。数据库在设计的时候实际上已经违背了某些“数据库设计范式”，因为为了最后呈现的时候方便，也为了客户在导出数据的时候方便。为了实现这个“关联”最后每个“数据实体模型”实现了“System.ComponentModel.INotifyPropertyChanged”接口，来“通知”某些列的更改，通过“PropertyChanged”事件来捕捉“通知”，再“Remove”事件，更改某些“关联”关系的字段值，再“Add”事件来完成整一个“关联”关系字段的控制。虽然实现起来麻烦了点，但客户再提“关联”关系字段更改的需求改的就很方便了。

软件交付之后，经过几次的BUG修改，客户数据录入接近尾声之后，客户要求“中心版”软件“数据横表（起始就是一个GridView）”部分要有可编辑功能，因为“部门”录入的数据太乱了，需要快速编辑修改功能。问题出来了“得到数据横表更改，保存数据横表更改的数据”怎么解决？记得学习.NET的时候使用DataSet+DataAdapter来完成数据绑定到表格，批量更改后“DataTable.GetChanges()”更改，保存数据，再“DataTable.AcceptChanges()”更改，就可以了。事情到了这个步骤更改成DataSet来实现肯定软件动的地方不少。最后解决的办法是“数据横表”绑定的“数据实体列表”转换成“DataTable”，修改完成后再转换成“List<>”类型的数据列表，再保存数据。在更改这个“横表”编辑功能的时候又发现一个问题“用户录入表单编辑的数据撤销操作后无法回复原来数据”，记得一本好像是“Expert C# 2005 Business Objects”书籍上讲到“多层撤销”的问题，解决的方法是“数据实体模型”实现了“System.ComponentModel.IEditableObject”结构，使得实体模型对象具有了“BeginEdit、CancelEdit、EndEdit”功能，为了期间的一个数据拷贝功能“数据实体模型”又实现了“System.ICloneable”接口。最后总算所有的问题都解决来了，好像很累人，还好在处理数据“关联”问题时没有去实现“System.ComponentModel.IBindingList”接口。

似乎自己在开发WinForm软件的时候犯了很大错误——把WinForm当成了WEB程序来开发，结构一开始就错了。如果一开始使用“强类型数据集”也没有多少错误（没有用的原因是自己在原先的WEB开发中因为使用“强类型数据集”，在后期给自己维护造成了很大的麻烦），最后为了实现某些功能自己实现了一个超级简化版的“DataTable”，自己在为了实现“数据实体模型”可以“GetChanges()”的时候差一点把“数据实体模型”进行了一个大规模的代码重构（因为在CodeProject上一篇文章讲到了可以使得得到“实体模型类表”具有“GetChanges()”功能的方法）。

清明节到图书城看到了《Effective C#》这本书，其实自己从前看过这本书，只是没有认真的看，其中的的第41条：《选择DataSet而不是自定义的数据结构（Prefer DataSets to Custom Structures）》，看了之后真是羞愧万千，怪自己没有认真的领悟书中的东西，下面是内容摘要：

因为两个原则，把DataSet的名声搞的不好。首先就是使用XML序列化的DataSet与其它的非.Net代码进行交互时不方便。如果在Web服务的API中使用DataSet时，在与其它没有使用.Net框架的系统进行交互时会相当困难。其次，它是一个很一般的容器。你可以通过欺骗.Net框架里的一些安全类型来错误DataSet。但在现代软件系统中，DataSet还可以解决很多常规的问题。如果你明白它的优势，避免它的缺点，你就可以扩展这个类型了。

DataSet类设计出来是为了离线使用一些存储在相关数据库里的数据。你已经知道它是用来存储DataTable的，而DataTable就是一个与数据库里的结构在行和列上进行匹配的内存表。或许你已经看到过一些关于DataSet支持在内部的表中建立关系的例子。甚至还有可能，你已经见过在DataSet里验证它所包含的数据，进行数据约束的例子。

但不仅仅是这些，DataSet还支持AcceptChanges 和RejectChanges 方法来进行事务处理，而且它们可以做为DiffGrams存储，也就是包含曾经修改过的数据。多个DataSet还可以通过合并成为一个常规的存储库。DataSet还支持视图，这就是说你可以通过标准的查询来检测数据里的部份内容。而且视图是可以建立在多个表上的。

然而，有些人想开发自己的存储结构，而不用DataSet。因DataSet是一个太一般的容器，这会在性能上有所损失。一个DataSet并不是一个强类型的存储容器，其实存储在里面的对象是一个字典。而且在里的表中的列也是字典。存储在里的元素都是以System.Object的引用形式存在。这使得我们要这样写代码：

…省略中间部分…

花了几页的代码来支持一些已经在DataSet里实现的了的功能。实际上，这还不能像DataSet那样恰当的工作。例如，交互式的添加一个新记录到集合中，以及支持事务所要求的BeginEdit, CancelEdit, 和EndEdit等。 你要在CancelEdit 调用时检测一个新的对象而不是一个已经修改了的对象。CancelEdit 必须从集合上移除这个新的对象，该对象应该是上次调用BeginEdit时创建的。对于AddressRecord 来说，还有很多修改要完成，而且一对事件还要添加到AddressList 类上。

最后，就是这个IBindingList接口。这个接口至少包含了20个方法和属性，用于控件查询列表上的功能描述。你必须为只读列表实现IBindingList 或者交互排序，或者支持搜索。在你取得内容之前就陷于层次关系和导航关系中了。我也不准备为上面所有的代码添加任何例子了。
几页过后，再问问你自己，还准备创建你自己的特殊集合吗？或者你想使用一个DataSet吗？除非你的集合是一个基于某些算法，对性能要求严格的集合，或者必须有轻便的格式，就要使用自己的DataSet，特别是类型化的DataSet。这将花去你大量的时间，是的，你可以争辩说DataSet并不是一个基于面向对象设计的最好的例子。类型化的DataSet甚至会破坏更多的规则。但，使用它所产生的代码开发效率，比起自己手写更优美的代码所花的时间，

这只是其中一小部分。

经典的书籍往往就是经典，C++方面经典的书籍一版一版的发布，一次一次的印刷，看得人津津乐道，JAVA方面的书籍也是这样。C#方面因为也就八九年的时间，经典的书籍似乎少了点，大概是翻译成中文的不多（国人写的似乎流行不起来），但一本《Effective C#》虽然讲解的是“C# 1.0”方面的内容，但毕竟是.NET方面的，内容很经典。这些天闲了在看一本《企业应用架构模式》的书籍，书籍至少是03年之前的写的，到现在.NET软件开发设计方面的内容也有很多进步，但这本书讲的确实很不错，用现在的眼光来看作者讲的确实很有前瞻性，应该是自己并不了解企业软件开发方面的内容，这么多年自己只能从七七八八的书籍上来自己体会企业软件开发，看到这本书真是眼前一亮。

 

万物变化的季节

TUPUNCO

2009.04.05

好运每一天

]]> http://zhq.ahau.edu.cn/blog/article.asp?id=474 <![CDATA[ASP.NET MVC CRUD 实例]]> tupunco@163.com(tupunco) Tue,24 Mar 2009 10:01:20 +0800 http://zhq.ahau.edu.cn/blog/default.asp?id=474 1.0 已经于上周发布了, RC1的时候写了两个例子, 一个是一个CRUD的例子, 一个是仿URL路径的例子. CRUD例子是一个拥有完整的从"数据源"查询数据列表/单条详细/删除/更新添加的功能的列子, 仿蓝色梦想作品集URL路径的例子是模仿作品集的URL切换方式, 展示了ASP.NET MVC 功能强大的路由功能, 自定义控件的列子. 本文事CRUD例子的说明和技术细节.

ASP.NET MVC安装/创建项目的方法可以参看http://www.asp.net/mvc的说明教程.

创建项目完毕后, 创建一个数据模型(实际为一数据实体)和数据服务(Fake的数据仓库)部分代码:

namespace MvcApplicationCRUD.Models
{
    public class People
    {
        public int Id { get; set; }
        public int Age { get; set; }
        public string Name { get; set; }
    }
}

 

using System.Collections.Generic;
 
namespace MvcApplicationCRUD.Models
{
    public class PeopleDataService
    {
        public static List<People> PeopleList = null;
 
        static PeopleDataService()
        {
            PeopleList = new List<People>();
            for (int i = 0; i < 20; i++)
                PeopleList.Add(new People() { Id = i + 1, Name = "name" + i * i, Age = i + 10 });
        }
    }
}

实现Controller内各个Action:

using System;
using System.Linq;
using System.Web.Mvc;
 
namespace MvcApplicationCRUD.Controllers
{
    using MvcPaging;
    using Models;
 
    public class PeopleController : Controller
    {
        private const int defaultPageSize = 10;
        //
        // GET: /People/
        /// <summary>
        /// 列表分页显示
        /// </summary>
        /// <param name="page"></param>
        /// <returns></returns>
        public ActionResult Index(int? page)
        {
            var peopleList = PeopleDataService.PeopleList;
            int currentPageIndex = page.HasValue ? page.Value - 1 : 0;
            return View(peopleList.ToPagedList(currentPageIndex, defaultPageSize));
        }
 
        //
        // GET: /People/Details/5
        /// <summary>
        /// 单条详细显示
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public ActionResult Details(int id)
        {
            var people = PeopleDataService.PeopleList.First(p => p.Id == id);
            return View(people);
        }
 
        //
        // GET: /People/Create
        /// <summary>
        /// 创建
        /// </summary>
        /// <returns></returns>
        public ActionResult Create()
        {
            var people = new People();
            return View(people);
        }
 
        //
        // POST: /People/Create
        /// <summary>
        /// 保存创建内容
        /// </summary>
        /// <param name="people"></param>
        /// <returns></returns>
        [AcceptVerbs(HttpVerbs.Post)]
        public ActionResult Create([Bind(Include = "Age,Name")] People people)
        {
            try
            {
                //得到当前数据服务内ID最大值并生成当前记录的ID
                people.Id = PeopleDataService.PeopleList.Max(p => p.Id) + 1;
 
                //Valid
                GetValidation(people);
 
                if (!ModelState.IsValid)
                    throw new Exception();
                else
                {
                    PeopleDataService.PeopleList.Add(people);
                    return RedirectToAction("Index");
                }
            }
            catch
            {
                return View(people);
            }
        }
 
        //
        // GET: /People/Edit/5
        /// <summary>
        /// 编辑某条记录
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public ActionResult Edit(int id)
        {
            var people = PeopleDataService.PeopleList.First(p => p.Id == id);
            return View(people);
        }
 
        //
        // POST: /People/Edit/5
        /// <summary>
        /// 保存内容
        /// </summary>
        /// <param name="id"></param>
        /// <param name="people"></param>
        /// <returns></returns>
        [AcceptVerbs(HttpVerbs.Post)]
        public ActionResult Edit(int id, [Bind(Include = "Age,Name")] People people)
        {
            var oPeople = PeopleDataService.PeopleList.First(p => p.Id == id);
            try
            {
                if (oPeople != null)
                {
                    oPeople.Age = people.Age;
                    oPeople.Name = people.Name;
                }
                //Valid
                GetValidation(oPeople);
 
                if (!ModelState.IsValid)
                    throw new Exception();
                else
                    return RedirectToAction("Index");
            }
            catch
            {
                return View(oPeople);
            }
        }
        /// <summary>
        /// 数据验证之用
        /// </summary>
        /// <param name="oPeople"></param>
        private void GetValidation(People oPeople)
        {
            //if (oPeople.Age < 10)
            //    ModelState.AddModelError("Age", "Age 必须大于等于10...");
            if (string.IsNullOrEmpty(oPeople.Name))
                ModelState.AddModelError("Name", "Name 不能为空...");
        }
    }
}

控制器代码中使用了一个叫"MvcPaging"的分页类库, 这个可能是现在碰到的最优美的ASP.NET MVC上分页类库. ASP.NET MVC 中错误处理使用ModelState.AddModelError方法来设置, 调用ModelState.IsValid来验证验证通过与否. 通过设置某一个Action的AcceptVerbs属性来使得其可以接受特定Verbs的外部数据, 这个功能比CTP版中的实现不知道好了多少倍(CTP版中搞得莫名其妙), 这个功能也是实现REST风格URL的完备解决. 通过设置Action参数为一自定义的类来接受前台视图内的复杂数据, 并设置[Bind]属性来设置那些数据可以接受.

控制器代码写好后, VS IDE内使用右键"Add View"方式来快速生成视图部分, 期间注意设置强类型视图就可以了. Index内添加分页部分功能:

<div class="pager">
    <%
   1: = Html.Pager(ViewData.Model.PageSize, ViewData.Model.PageNumber, ViewData.Model.TotalItemCount) 
%>
</div>

 

代码下载:

 

春暖花开的季节.

TUPUNCO

2009.03.23

好运每一天.

]]> http://zhq.ahau.edu.cn/blog/article.asp?id=473 <![CDATA[[原创]C#中使用反射]]> tupunco@163.com(tupunco) Mon,09 Mar 2009 09:02:28 +0800 http://zhq.ahau.edu.cn/blog/default.asp?id=473 过了年到现在忙了起来, 不像年前, 可以整月的闲着, 不过闲着也有好处, 学习了好多东西. 过了年的项目中多次用到了 .Net 反射机制, 使得其间巧妙地解决了很多问题. 总结一下使用到的地方.

1.使用工厂模式来抽象数据连接层之用(PetShop模式的三层结构内的使用方式).

   1: System.Reflection.Assembly assembly = Assembly.LoadFile("Assembly Path");
   2: IXXXXXDAL dal = (IXXXXXDAL)assembly.CreateInstance("Namespace.DAL.XXXXXDAL");

2.使用 "System.Activator.CreateInstance()" 方式来创建对象.

   1: //
   2: // 摘要:
   3: //     创建类型的一个实例，该类型由指定的泛型类型参数指定。
   4: //
   5: // 类型参数:
   6: //   T:
   7: //     要创建的类型。
   8: //
   9: // 返回结果:
  10: //     对新创建对象的引用。
  11: public static T CreateInstance<T>();
  12: //
  13: // 摘要:
  14: //     使用指定类型的默认构造函数来创建该类型的实例。
  15: //
  16: // 参数:
  17: //   type:
  18: //     要创建的对象的类型。
  19: //
  20: // 返回结果:
  21: //     对新创建对象的引用。
  22: public static object CreateInstance(Type type);

3.显示某对象的子级属性值.

   1: public static string DisplayPropertyInfo(object obj)
   2: {
   3:     StringBuilder sb = new StringBuilder();
   4:     Type type = obj.GetType();
   5:     sb.AppendFormat("[{0}]\r\n",obj);
   6:     foreach (var item in type.GetProperties())
   7:     {
   8:         sb.AppendFormat("\t[{0}:{1}]\r\n", item.Name,
   9:             item.GetValue(obj, null));
  10:     }
  11:     return sb.ToString();
  12: }

4.转换一个DataTable类型的对象成为一个实体集合(Table的列与实体类的属性是一一对应的).

/// <summary>
/// 数据服务基类对象
/// </summary>
public abstract class DataServiceBase
{
    #region DB 处理
    /// <summary>
    /// 执行SQL字符串返回一个DataTable
    /// </summary>
    /// <param name="sql"></param>
    /// <returns></returns>
    protected DataTable ExecuteSQL(string sql)
    {
        //*****返回一个DataTable****
       return null;
    }
    #endregion
    #region Tabel 类型转换相关
    /// <summary>
    /// 转化Table成一个相对应的实体类集合
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="table"></param>
    /// <returns></returns>
    protected List<T> ConvertDataTableToEntityCollections<T>(DataTable table)
        where T : class, new()
    {
        if (table != null)
        {
            PropertyInfo[] pInfos = GetTypePropertyInfo(typeof(T));
            List<T> list = new List<T>(table.Rows.Count);
 
            foreach (DataRow row in table.Rows)
            {
                T t = new T();
                foreach (var pInfo in pInfos)
                {
                    if (table.Columns.Contains(pInfo.Name))
                    {
                        //HACK: 对象转换成指定的类型使用 Convert.ChangeType
                        // Convert.ChangeType(row[pInfo.Name], pInfo.PropertyType);
                        try
                        {
                            pInfo.SetValue(t, ChangeType(row[pInfo.Name], pInfo.PropertyType), null);
                        }
                        catch(Exception ex){
                            throw ex;
                        }
                    }
                }
                list.Add(t);
            }
            return list;
        }
        return null;
    }
    /// <summary>
    /// 得到指定SQL执行的结果并返回结果的实体类集合对象
    /// 本方法综合了 ConvertDataTableToEntityCollections/ExecuteSQL 方法
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="sql">待执行的SQL</param>
    /// <returns></returns>
    protected List<T> GetEntityConllectionsFromSQL<T>(string sql)
        where T : class, new()
    {
        if (string.IsNullOrEmpty(sql))
            return null;
        else
            return ConvertDataTableToEntityCollections<T>(ExecuteSQL(sql));
    }
    /// <summary>
    /// 得到指定类型公开的属性
    /// </summary>
    /// <param name="type"></param>
    /// <returns></returns>
    private PropertyInfo[] GetTypePropertyInfo(Type type)
    {
        PropertyInfo[] infos = null;
        //锁定防止 多次 ADD 进缓存
        lock (_PROPERTYINFO_READ_LOCK)
        {
            _PropertyInfoCache.TryGetValue(type, out infos);
            if (infos == null)
            {
                infos = type.GetProperties();
                _PropertyInfoCache.Add(type, infos);
            }
        }
        return infos;
    }
    /// <summary>
    /// 类型转换
    /// FROM: http://www.cnblogs.com/cnee5/archive/2006/05/21/405403.html
    /// </summary>
    /// <param name="value"></param>
    /// <param name="conversionType"></param>
    /// <returns></returns>
    public object ChangeType(object value, Type conversionType)
    {
        //INFO 对DBNull类型特殊处理
        if (Convert.IsDBNull(value))
        {
            //非可空类型的值类型处理
            if (!(conversionType.IsGenericType &&
                conversionType.GetGenericTypeDefinition().Equals(typeof(Nullable<>))))
                return Activator.CreateInstance(conversionType);
            else
                return null;
        }
        //可空类型类型处理
        if (conversionType.IsGenericType &&
                conversionType.GetGenericTypeDefinition().Equals(typeof(Nullable<>)))
        {
            if (value == null)
                return null;
 
            System.ComponentModel.NullableConverter nullableConverter
                = new System.ComponentModel.NullableConverter(conversionType);
 
            conversionType = nullableConverter.UnderlyingType;
        }
 
        return Convert.ChangeType(value, conversionType);
    }
    private object _PROPERTYINFO_READ_LOCK = new object();
    /// <summary>
    /// 实体类属性缓存
    /// </summary>
    private static Dictionary<Type, PropertyInfo[]> _PropertyInfoCache = new Dictionary<Type, PropertyInfo[]>();
    #endregion
}

使用GetEntityConllectionsFromSQL<T>(string sql)方法直接执行一个返回DataTable的ExecuteSQL(sql)方法来快捷完成转换. 在不用ORM框架的情况下就是简单的取得数据变成实体对象集合时很方便, 当然前提是不使用强类型数据集.

5.转换WebServices生成的实体数据到三层结构已经定义好的实体数据.

public class DataServiceBase
{
    #region 类型转换之用
    /// <summary>
    /// 转换一个WebServices Entity
    /// 此类实体的特点 对于目标实体"属性字段"和现在的实体"属性字段"名称一致,
    /// 但对于列表实体会是数组保存
    /// </summary>
    /// <typeparam name="TTarget"></typeparam>
    /// <typeparam name="TSource"></typeparam>
    /// <param name="entity"></param>
    /// <returns></returns>
    protected TTarget ConvertWebServiceEntity<TTarget, TSource>(TSource entity)
        where TTarget : class, new()
        where TSource : class, new()
    {
        return (TTarget)ConvertWebServiceEntity(typeof(TTarget), typeof(TSource), (object)entity);
    }
    /// <summary>
    /// 转换一个WebServices Entity
    /// 此类实体的特点 对于目标实体"属性字段"和现在的实体"属性字段"名称一致,
    /// 但对于列表实体会是数组保存
    /// </summary>
    /// <param name="tType"></param>
    /// <param name="sType"></param>
    /// <param name="sEntity"></param>
    /// <returns></returns>
    protected object ConvertWebServiceEntity(Type tType, Type sType, object sEntity)
    {
        if (sEntity != null)
        {
            object t = Activator.CreateInstance(tType);
            PropertyInfo[] pTInfos = GetTypePropertyInfo(tType);
            PropertyInfo[] pSInfos = GetTypePropertyInfo(sType);
            int i = 0;
            foreach (var item in pSInfos)
            {
                if (!item.PropertyType.IsArray)
                    pTInfos[i].SetValue(t, item.GetValue(sEntity, null), null);
                else
                {
                    //tgType 肯定为泛型
                    //taType 肯定为 数组类型
                    Type tgType = pTInfos[i].PropertyType.GetGenericArguments()[0];
                    Type taType = item.PropertyType.GetElementType();
                    object tList = ConverWebServiceEntityCollections(tgType, taType, (object[])item.GetValue(sEntity, null));
                    pTInfos[i].SetValue(t, tList, null);
                }
                i++;
            }
            return t;
        }
        return null;
    }
    /// <summary>
    /// 转换一个WebServices Entity
    /// 此类实体的特点 对于目标实体"属性字段"和现在的实体"属性字段"名称一致,
    /// 但对于列表实体会是数组保存
    /// </summary>
    /// <param name="tTarget"></param>
    /// <param name="tSource"></param>
    /// <param name="sCollections"></param>
    /// <returns></returns>
    protected object ConverWebServiceEntityCollections(
        Type tTarget, Type tSource,
        object[] sCollections)
    {
        //HACK 创建一个目标类型的泛型列表
        Type gListType = typeof(List<>).MakeGenericType(new Type[] { tTarget });
        object tgListObj = Activator.CreateInstance(gListType);
        MethodInfo tgAddMi = gListType.GetMethod("Add");
        foreach (var item in sCollections)
            tgAddMi.Invoke(tgListObj, new object[] { ConvertWebServiceEntity(tTarget, tSource, item) });
        return tgListObj;
    }
    /// <summary>
    /// 从列表到列表
    /// </summary>
    /// <typeparam name="TTarget"></typeparam>
    /// <typeparam name="TSource"></typeparam>
    /// <param name="collections"></param>
    /// <returns></returns>
    protected List<TTarget> ConverWebServiceEntityCollections<TTarget, TSource>(IEnumerable<TSource> collections)
        where TTarget : class, new()
        where TSource : class, new()
    {
        List<TTarget> tList = new List<TTarget>();
        foreach (var item in collections)
            tList.Add(ConvertWebServiceEntity<TTarget, TSource>(item));
        return tList;
    }
    /// <summary>
    /// 得到指定类型公开的属性
    /// </summary>
    /// <param name="type"></param>
    /// <returns></returns>
    private PropertyInfo[] GetTypePropertyInfo(Type type)
    {
        PropertyInfo[] infos = null;
        //锁定防止 多次 ADD 进缓存
        lock (_PROPERTYINFO_READ_LOCK)
        {
            _PropertyInfoCache.TryGetValue(type, out infos);
            if (infos == null)
            {
                infos = type.GetProperties();
                _PropertyInfoCache.Add(type, infos);
            }
        }
        return infos;
    }
    private object _PROPERTYINFO_READ_LOCK = new object();
    /// <summary>
    /// 实体类属性缓存
    /// </summary>
    private static Dictionary<Type, PropertyInfo[]> _PropertyInfoCache = new Dictionary<Type, PropertyInfo[]>();
    #endregion
}

Web Services 生成实体数据会把List类型的数据转换成数组, 也不知道自己写这个东西是不是正确, 反正是可以使用. 另外NBear4中提供一个ObjectConvertor的东西, 很好用可以支持不同类型之间的转换, 并且还可以自定义转换映射关系.

]]>