代码改变世界

使用反射和Attribute动态显示代码中的注释内容

2010-03-23 12:32  Virus-BeautyCode  阅读(2320)  评论(5编辑  收藏  举报

  

  反射和Attribute是.NET的两种技术,可以应用在很多的地方。

  反射可以反射类中的属性,方法,实现动态调用,也经常在三层工厂中使用,反射接口的实现。

  Attribute,个人理解,就是一个特性,可以添加在任何自定义类型上面,然后添加一些注释,也是很有用的。

  本篇就示例讲解一个他们的结合使用:使用反射和Attribute动态显示代码中的注释内容。其中也杂合它一些其他的内容,一个是前几天写的一个C#的加密解密算法,包括Silverlight的MD5算法。还有就是一个商品规格的计算方法,比如给出需要购买的总量,然后计算每种规格需要购买的数量,和总的花费。

  结果如下图

 

 

  代码如下

  

 

代码
using System;
using System.Collections.Generic;
using System.Linq;
using System.
Text;
using System.Web.Security;
using System.Reflection;

namespace ConsoleApplication1
{
    
[AttributeUsage(AttributeTargets.Class)]
    class CodeReviewAttribute : System.Attribute
    {
        private string _reviewer;

        
public string Reviewer
        {
            get { 
return _reviewer; }
        }
        private string _date;

        
public string Date
        {
            get { 
return _date; }
        }
        private string _comment;

        
public string Comment
        {
            get { 
return _comment; }
            
set { _comment = value; }
        }
        
public CodeReviewAttribute(string reviewer, string date)
        {
            this._reviewer 
= reviewer;
            this._date 
= date;
        }
    }
    
[CodeReview("swb", "2009-9-9", Comment = "代码不好")]
    class MyClass
    {
    }
    
[AttributeUsage(AttributeTargets.Enum | AttributeTargets.Field)]
    class NoteAttribute : System.Attribute
    {
        private string _name;

        
public string Name
        {
            get { 
return _name; }
        }
        
public NoteAttribute(string name)
        {
            this._name 
= name;
        }
    }

    enum 
Log
    {
        
[Note("添加 用户")]
        AddUser,
        
[Note("修改 用户")]
        ModifyUser
    }
    class EnumDescription
    {
        
public static string Parse(Log type)
        {
            FieldInfo fields 
= type.GetType().GetField(type.ToString());
            object
[] objs = fields.GetCustomAttributes(true);
            
return ((NoteAttribute)objs[0]).Name;
        }
    }
    
public interface IChinese
    {
        string Speak();
    }
    
public class CNSpeaker : IChinese
    {
        #region Chinese Members

        
public string Speak()
        {
            
return "Chinese";
        }

        #endregion
    }
    
public interface IEnglish
    {
        string Speak();
    }
    
public class ENSpeaker : IEnglish
    {
        #region English Members

        string IEnglish.Speak()
        {
            
return "English";
        }

        #endregion
    }
    class Program
    {
        static void Main(string
[] args)
        {
            CNSpeaker cn 
= new CNSpeaker();
            Console.WriteLine(cn.Speak());
            IEnglish en 
= new ENSpeaker();
            Console.WriteLine(en.Speak());
            Console.WriteLine("
---------------------");
            string str = "123";
            Console.WriteLine(string.Format("
123 encrypt result: {0}", WebMD5Provider.WebFormMD5Encrypt(str)));
            Console.WriteLine("
---------------------");
            MD5CryptoServiceProvider md5Provider = new MD5CryptoServiceProvider();
            byte
[] encryptedBytes = md5Provider.ComputeHash(Encoding.UTF8.GetBytes(str));
            StringBuilder sb 
= new StringBuilder();
            
for (int i = 0; i < encryptedBytes.Length; i++)
            {
                sb.AppendFormat("{
0:x2}", encryptedBytes[i]);
            }

            Console.WriteLine(string.Format("
123 encrypt result: {0}", sb.ToString()));
            Console.WriteLine("
---------------------");

            System.Reflection.MemberInfo info 
= typeof(MyClass);
            CodeReviewAttribute att 
= (CodeReviewAttribute)Attribute.GetCustomAttribute(info, typeof(CodeReviewAttribute));
            
if (att != null)
            {
                Console.WriteLine("MyClass 代码监察人:{
0}", att.Reviewer);
                Console.WriteLine("MyClass 检查时间:{
0}", att.Date);
                Console.WriteLine("MyClass 备注:{
0}", att.Comment);
            }
            Console.WriteLine("
---------------------");
            Log log = Log.AddUser;


            Console.WriteLine(string.Format ("Enum 
Log 的 AddUser 的注释是: {0}",EnumDescription.Parse(log)));

            Console.WriteLine("
---------------------");
            Int64? bbb = 0;
            
int? aaa = 0;
            Console.WriteLine("
---------------------");

            
decimal area = 110;
            Console.WriteLine("你的土地面积是:{
0}", area);
            
decimal amount = 10m;
            Console.WriteLine("你的每亩用量是是:{
0}", amount );
            
decimal budget = 0;

            List
<pkgspec> pkgs = new List<pkgspec>();
            pkgs.
Add(new pkgspec() { amount = 200, price = 180, id = 2 });
            pkgs.
Add(new pkgspec() { amount = 100, price = 100, id = 1 });

            pkgs.
Add(new pkgspec() { amount = 250, price = 250, id = 3 });

            pkgs.Sort(new Comparison
<pkgspec>(compareDesc));

            
// pkgs.Sort(new Comparison<pkgspec>(compareAsc));

            
decimal totalAmount = area * amount;
            Console.WriteLine("你的总共用量是:{
0}", totalAmount);
            
int num = 0;

            List
<pkgselect> select = new List<pkgselect>();

            foreach (pkgspec pkg 
in pkgs)
            {
                
if (totalAmount % pkg.amount == totalAmount)
                {
                    num 
=1;
                    budget 
+= num * pkg.price;
                    
select.Add(new pkgselect() { id = pkg.id, num = num, price=pkg.price  });
                    
break;
                }
                
else if (totalAmount % pkg.amount == 0)
                {
                    num 
= (int)(totalAmount / pkg.amount);
                    budget 
+= num * pkg.price;
                    
select.Add(new pkgselect() { id = pkg.id, num = (int)(totalAmount / pkg.amount) , price=pkg.price });
                    
break;
                }
                
else
                {
                    num 
= (int)(totalAmount / pkg.amount);
                    budget 
+= num * pkg.price;
                    
select.Add(new pkgselect() { id = pkg.id, num = num , price=pkg.price });
                    totalAmount 
= totalAmount - num * pkg.amount;
                    
continue;
                }
            }

            foreach (pkgselect s 
in select)
            {
                Console.WriteLine("你需要购买的包装编号是:{
0}, 数量是 {1} 个 , 单价是 {2}", s.id, s.num, s.price);
            }
            Console.WriteLine("你购买的总价是: {
0}", budget);

            Console.ReadLine();
        }
        private static 
int compareAsc(pkgspec pkg1, pkgspec pkg2)
        {
            
if (pkg1.amount > pkg2.amount)
                
return 1;
            
if (pkg1.amount < pkg2.amount)
                
return -1;
            
else
                
return 0;
        }
        private static 
int compareDesc(pkgspec pkg1, pkgspec pkg2)
        {
            
if (pkg1.amount < pkg2.amount)
                
return 1;
            
if (pkg1.amount > pkg2.amount)
                
return -1;
            
else
                
return 0;
        }
    }
    
/// <summary>
    
/// 选中的包装
    
/// </summary>
    class pkgselect
    {
        
/// <summary>
        
/// 选中ID
        
/// </summary>
        
public int id;
        
/// <summary>
        
/// 购买数量
        
/// </summary>
        
public int num;
        
/// <summary>
        
/// 单价
        
/// </summary>
        
public decimal price;
    }
    
/// <summary>
    
/// 包装类型
    
/// </summary>
    class pkgspec : IComparable
<pkgspec>
    {
        
/// <summary>
        
/// 编号
        
/// </summary>
        
public int id;
        
/// <summary>
        
/// 包装量
        
/// </summary>
        
public decimal amount;
        
/// <summary>
        
/// 价格
        
/// </summary>
        
public decimal price;

        #region IComparable
<pkgspec> Members

        
public int CompareTo(pkgspec other)
        {
            
if (this.amount > other.amount)
                
return 1;
            
if (this.amount == other.amount)
                
return 0;
            
else
                
return -1;
        }

        #endregion
    }
}

 

 

代码
using System;
using System.Collections.Generic;
using System.Linq;
using System.
Text;
using System.Web.Security;
using System.Security.Cryptography;
using System.IO;

namespace ConsoleApplication1
{
    
/// <summary>
    
/// 字符串加解密工具类
    
/// </summary>
    
public static class EncryptUtility
    {
        #region WinForm 的MD5和SHA1哈希,使得和System.Web.Security.FormsAuthentication的结果一致

        
public static string WinFormMD5Encrypt(string data)
        {
            MD5CryptoServiceProvider md5 
= new MD5CryptoServiceProvider();
            byte
[] encryptedBytes = md5.ComputeHash(Encoding.ASCII.GetBytes(data));
            StringBuilder sb 
= new StringBuilder();

            
for (int i = 0; i < encryptedBytes.Length; i++)
            {
                sb.AppendFormat("{
0:x2}", encryptedBytes[i]);
            }
            
return sb.ToString().ToUpper();
        }
        
public static string WinFormSHA1Encrypt(string data)
        {
            SHA1CryptoServiceProvider md5 
= new SHA1CryptoServiceProvider();
            byte
[] encryptedBytes = md5.ComputeHash(Encoding.ASCII.GetBytes(data));
            StringBuilder sb 
= new StringBuilder();

            
for (int i = 0; i < encryptedBytes.Length; i++)
            {
                sb.AppendFormat("{
0:x2}", encryptedBytes[i]);
            }
            
return sb.ToString().ToUpper();
        }
        #endregion

        #region WebForm中的 MD5 和 SHA1 哈希

        
/// <summary>
        
/// 返回MD5哈希结果
        
/// </summary>
        
/// <param name="password"></param>
        
/// <returns></returns>
        
public static string WebFormMD5Encrypt(string data)
        {
            
if (string.IsNullOrEmpty(data))
                throw new Exception("加密字符串不能为空");
            
return FormsAuthentication.HashPasswordForStoringInConfigFile(data, "md5");
        }
        
/// <summary>
        
/// 返回SHA1哈希结果
        
/// </summary>
        
/// <param name="password"></param>
        
/// <returns></returns>
        
public static string WebFormSHA1Encrypt(string data)
        {
            
if (string.IsNullOrEmpty(data))
                throw new Exception("加密字符串不能为空");
            
return FormsAuthentication.HashPasswordForStoringInConfigFile(data, "sha1");
        }

        #endregion
        #region 普通的字符变换加解密
        
/// <summary>
        
/// 普通字符还变
        
/// 加密
        
/// </summary>
        
/// <param name="str"></param>
        
/// <returns></returns>
        
public static string CommonEncrypt(string data)
        {
            
if (string.IsNullOrEmpty(data))
                throw new Exception("加密字符串不能为空");
            string result 
= string.Empty;

            
int len = data.Length;
            
for (int i = 0; i < len; i++)
            {
                result 
+= (char)(data[i] + 10 - 1 * 2);
            }
            
return result;
        }
        
/// <summary>
        
/// 普通的字符变换
        
/// 解密
        
/// </summary>
        
/// <param name="str"></param>
        
/// <returns></returns>
        
public static string CommonDecrypt(string data)
        {
            
if (string.IsNullOrEmpty(data))
                throw new Exception("加密字符串不能为空");
            string result 
= string.Empty;
            
int len = data.Length;
            
for (int i = 0; i < len; i++)
            {
                result 
+= (char)(data[i] - 10 + 1 * 2);
            }
            
return result;
        }


        #endregion


        #region 带有密钥的加解密

        private static readonly string KEY_64 
= System.Configuration.ConfigurationManager.AppSettings["key_64"];
        
/// <summary>
        
/// 带有密钥的加解密
        
/// 加密
        
/// </summary>
        
/// <param name="data"></param>
        
/// <returns></returns>
        
public static string KeyEncrypt(string data)
        {
            using (DESCryptoServiceProvider provider 
= new DESCryptoServiceProvider())
            {
                byte
[] inputByteArray = Encoding.UTF8.GetBytes(data);
                provider.
Key = ASCIIEncoding.ASCII.GetBytes(KEY_64.Substring(08));
                provider.IV 
= ASCIIEncoding.ASCII.GetBytes(KEY_64);

                MemoryStream ms 
= new MemoryStream();
                using (CryptoStream cs 
= new CryptoStream(ms, provider.CreateEncryptor(), CryptoStreamMode.Write))
                {
                    cs.Write(inputByteArray, 
0, inputByteArray.Length);
                    cs.FlushFinalBlock();
                    cs.
Close();
                }
                string 
str = Convert.ToBase64String(ms.ToArray());
                ms.
Close();
                
return str;
            }
        }
        
/// <summary>
        
/// 带有密钥的加解密
        
/// 解密
        
/// </summary>
        
/// <param name="data"></param>
        
/// <returns></returns>
        
public static string KeyDecrypt(string data)
        {
            byte
[] inputByteArray = Convert.FromBase64String(data);
            using (DESCryptoServiceProvider provider 
= new DESCryptoServiceProvider())
            {

                provider.
Key = ASCIIEncoding.ASCII.GetBytes(KEY_64.Substring(08));
                provider.IV 
= ASCIIEncoding.ASCII.GetBytes(KEY_64);

                MemoryStream ms 
= new MemoryStream();
                using (CryptoStream cs 
= new CryptoStream(ms, provider.CreateDecryptor(), CryptoStreamMode.Write))
                {
                    cs.Write(inputByteArray, 
0, inputByteArray.Length);
                    cs.FlushFinalBlock();
                    cs.
Close();
                }
                string 
str = Encoding.UTF8.GetString(ms.ToArray());
                ms.
Close();
                
return str;
            }
        }
        #endregion
    }
    
public class WebMD5Provider
    {
        #region WebForm中的 MD5 和 SHA1 哈希

        
/// <summary>
        
/// 返回MD5哈希结果
        
/// </summary>
        
/// <param name="password"></param>
        
/// <returns></returns>
        
public static string WebFormMD5Encrypt(string data)
        {
            
if (string.IsNullOrEmpty(data))
                throw new Exception("加密字符串不能为空");
            
return FormsAuthentication.HashPasswordForStoringInConfigFile(data, "md5");
        }
        
/// <summary>
        
/// 返回SHA1哈希结果
        
/// </summary>
        
/// <param name="password"></param>
        
/// <returns></returns>
        
public static string WebFormSHA1Encrypt(string data)
        {
            
if (string.IsNullOrEmpty(data))
                throw new Exception("加密字符串不能为空");
            
return FormsAuthentication.HashPasswordForStoringInConfigFile(data, "sha1");
        }

        #endregion
    }
    
public class MD5CryptoServiceProvider : MD5
    {
        
public MD5CryptoServiceProvider()
            : base()
        {
        }
    }
    
/// <summary>
    
/// Summary description for MD5.
    
/// </summary>
    
public class MD5 : IDisposable
    {
        static 
public MD5 Create(string hashName)
        {
            
if (hashName == "MD5")
                
return new MD5();
            
else
                throw new NotSupportedException();
        }

        static 
public String GetMd5String(String source)
        {
            MD5 md 
= MD5CryptoServiceProvider.Create();
            byte
[] hash;

            
//Create a new instance of ASCIIEncoding to 
            
//convert the string into an array of Unicode bytes.
            UTF8Encoding enc 
= new UTF8Encoding();
            
//            ASCIIEncoding enc = new ASCIIEncoding();

            
//Convert the string into an array of bytes.
            byte
[] buffer = enc.GetBytes(source);

            
//Create the hash value from the array of bytes.
            hash 
= md.ComputeHash(buffer);

            StringBuilder sb 
= new StringBuilder();
            foreach (byte b 
in hash)
                sb.Append(b.ToString("x2"));
            
return sb.ToString();
        }

        static 
public MD5 Create()
        {
            
return new MD5();
        }

        #region base implementation 
of the MD5
        #region constants
        private const byte S11 
= 7;
        private const byte S12 
= 12;
        private const byte S13 
= 17;
        private const byte S14 
= 22;
        private const byte S21 
= 5;
        private const byte S22 
= 9;
        private const byte S23 
= 14;
        private const byte S24 
= 20;
        private const byte S31 
= 4;
        private const byte S32 
= 11;
        private const byte S33 
= 16;
        private const byte S34 
= 23;
        private const byte S41 
= 6;
        private const byte S42 
= 10;
        private const byte S43 
= 15;
        private const byte S44 
= 21;
        static private byte
[] PADDING = new byte[] {
              
0x8000000
0000000000000000,
              
0000000
0000000000000000,
              
0000000
000000000000
             };
        #endregion

        #region F, G, H 
and I are basic MD5 functions.
        static private uint F(uint x, uint y, uint z)
        {
            
return (((x) & (y)) | ((~x) & (z)));
        }
        static private uint G(uint x, uint y, uint z)
        {
            
return (((x) & (z)) | ((y) & (~z)));
        }
        static private uint H(uint x, uint y, uint z)
        {
            
return ((x) ^ (y) ^ (z));
        }
        static private uint I(uint x, uint y, uint z)
        {
            
return ((y) ^ ((x) | (~z)));
        }
        #endregion

        #region rotates x 
left n bits.
        
/// <summary>
        
/// rotates x left n bits.
        
/// </summary>
        
/// <param name="x"></param>
        
/// <param name="n"></param>
        
/// <returns></returns>
        static private uint ROTATE_LEFT(uint x, byte n)
        {
            
return (((x) << (n)) | ((x) >> (32 - (n))));
        }
        #endregion

        #region FF, GG, HH, 
and II transformations
        
/// FF, GG, HH, and II transformations 
        
/// for rounds 123and 4.
        
/// Rotation is separate from addition to prevent recomputation.
        static private void FF(ref uint a, uint b, uint c, uint d, uint x, byte s, uint ac)
        {
            (a) 
+= F((b), (c), (d)) + (x) + (uint)(ac);
            (a) 
= ROTATE_LEFT((a), (s));
            (a) 
+= (b);
        }
        static private void GG(ref uint a, uint b, uint c, uint d, uint x, byte s, uint ac)
        {
            (a) 
+= G((b), (c), (d)) + (x) + (uint)(ac);
            (a) 
= ROTATE_LEFT((a), (s));
            (a) 
+= (b);
        }
        static private void HH(ref uint a, uint b, uint c, uint d, uint x, byte s, uint ac)
        {
            (a) 
+= H((b), (c), (d)) + (x) + (uint)(ac);
            (a) 
= ROTATE_LEFT((a), (s));
            (a) 
+= (b);
        }
        static private void II(ref uint a, uint b, uint c, uint d, uint x, byte s, uint ac)
        {
            (a) 
+= I((b), (c), (d)) + (x) + (uint)(ac);
            (a) 
= ROTATE_LEFT((a), (s));
            (a) 
+= (b);
        }
        #endregion

        #region context info
        
/// <summary>
        
/// state (ABCD)
        
/// </summary>
        uint
[] state = new uint[4];

        
/// <summary>
        
/// number of bits, modulo 2^64 (lsb first)
        
/// </summary>
        uint
[] count = new uint[2];

        
/// <summary>
        
/// input buffer
        
/// </summary>
        byte
[] buffer = new byte[64];
        #endregion

        internal MD5()
        {
            Initialize();
        }

        
/// <summary>
        
/// MD5 initialization. Begins an MD5 operation, writing a new context.
        
/// </summary>
        
/// <remarks>
        
/// The RFC named it "MD5Init"
        
/// </remarks>
        
public virtual void Initialize()
        {
            
count[0] = count[1] = 0;

            
// Load magic initialization constants.
            state
[0] = 0x67452301;
            state
[1] = 0xefcdab89;
            state
[2] = 0x98badcfe;
            state
[3] = 0x10325476;
        }

        
/// <summary>
        
/// MD5 block update operation. Continues an MD5 message-digest
        
/// operation, processing another message block, and updating the
        
/// context.
        
/// </summary>
        
/// <param name="input"></param>
        
/// <param name="offset"></param>
        
/// <param name="count"></param>
        
/// <remarks>The RFC Named it MD5Update</remarks>
        protected virtual void HashCore(byte
[] input, int offset, int count)
        {
            
int i;
            
int index;
            
int partLen;

            
// Compute number of bytes mod 64
            
index = (int)((this.count[0] >> 3& 0x3F);

            
// Update number of bits
            
if ((this.count[0] += (uint)((uint)count << 3)) < ((uint)count << 3))
                this.
count[1]++;
            this.
count[1] += ((uint)count >> 29);

            partLen 
= 64 - index;

            
// Transform as many times as possible.
            
if (count >= partLen)
            {
                Buffer.BlockCopy(input, offset, this.buffer, 
index, partLen);
                Transform(this.buffer, 
0);

                
for (i = partLen; i + 63 < count; i += 64)
                    Transform(input, offset 
+ i);

                
index = 0;
            }
            
else
                i 
= 0;

            
// Buffer remaining input 
            Buffer.BlockCopy(input, offset 
+ i, this.buffer, indexcount - i);
        }

        
/// <summary>
        
/// MD5 finalization. Ends an MD5 message-digest operation, writing the
        
/// the message digest and zeroizing the context.
        
/// </summary>
        
/// <returns>message digest</returns>
        
/// <remarks>The RFC named it MD5Final</remarks>
        protected virtual byte
[] HashFinal()
        {
            byte
[] digest = new byte[16];
            byte
[] bits = new byte[8];
            
int index, padLen;

            
// Save number of bits
            Encode(bits, 
0, this.count08);

            
// Pad out to 56 mod 64.
            
index = (int)((uint)(this.count[0] >> 3& 0x3f);
            padLen 
= (index < 56) ? (56 - index) : (120 - index);
            HashCore(PADDING, 
0, padLen);

            
// Append length (before padding)
            HashCore(bits, 
08);

            
// Store state in digest 
            Encode(digest, 
0, state, 016);

            
// Zeroize sensitive information.
            
count[0] = count[1] = 0;
            state
[0] = 0;
            state
[1] = 0;
            state
[2] = 0;
            state
[3] = 0;

            
// initialize again, to be ready to use
            Initialize();

            
return digest;
        }

        
/// <summary>
        
/// MD5 basic transformation. Transforms state based on 64 bytes block.
        
/// </summary>
        
/// <param name="block"></param>
        
/// <param name="offset"></param>
        private void Transform(byte
[] block, int offset)
        {
            uint a 
= state[0], b = state[1], c = state[2], d = state[3];
            uint
[] x = new uint[16];
            Decode(x, 
0, block, offset, 64);

            
// Round 1
            FF(ref a, b, c, d, x
[0], S11, 0xd76aa478); /* 1 */
            FF(ref d, a, b, c, x
[1], S12, 0xe8c7b756); /* 2 */
            FF(ref c, d, a, b, x
[2], S13, 0x242070db); /* 3 */
            FF(ref b, c, d, a, x
[3], S14, 0xc1bdceee); /* 4 */
            FF(ref a, b, c, d, x
[4], S11, 0xf57c0faf); /* 5 */
            FF(ref d, a, b, c, x
[5], S12, 0x4787c62a); /* 6 */
            FF(ref c, d, a, b, x
[6], S13, 0xa8304613); /* 7 */
            FF(ref b, c, d, a, x
[7], S14, 0xfd469501); /* 8 */
            FF(ref a, b, c, d, x
[8], S11, 0x698098d8); /* 9 */
            FF(ref d, a, b, c, x
[9], S12, 0x8b44f7af); /* 10 */
            FF(ref c, d, a, b, x
[10], S13, 0xffff5bb1); /* 11 */
            FF(ref b, c, d, a, x
[11], S14, 0x895cd7be); /* 12 */
            FF(ref a, b, c, d, x
[12], S11, 0x6b901122); /* 13 */
            FF(ref d, a, b, c, x
[13], S12, 0xfd987193); /* 14 */
            FF(ref c, d, a, b, x
[14], S13, 0xa679438e); /* 15 */
            FF(ref b, c, d, a, x
[15], S14, 0x49b40821); /* 16 */

            
// Round 2
            GG(ref a, b, c, d, x
[1], S21, 0xf61e2562); /* 17 */
            GG(ref d, a, b, c, x
[6], S22, 0xc040b340); /* 18 */
            GG(ref c, d, a, b, x
[11], S23, 0x265e5a51); /* 19 */
            GG(ref b, c, d, a, x
[0], S24, 0xe9b6c7aa); /* 20 */
            GG(ref a, b, c, d, x
[5], S21, 0xd62f105d); /* 21 */
            GG(ref d, a, b, c, x
[10], S22, 0x2441453); /* 22 */
            GG(ref c, d, a, b, x
[15], S23, 0xd8a1e681); /* 23 */
            GG(ref b, c, d, a, x
[4], S24, 0xe7d3fbc8); /* 24 */
            GG(ref a, b, c, d, x
[9], S21, 0x21e1cde6); /* 25 */
            GG(ref d, a, b, c, x
[14], S22, 0xc33707d6); /* 26 */
            GG(ref c, d, a, b, x
[3], S23, 0xf4d50d87); /* 27 */
            GG(ref b, c, d, a, x
[8], S24, 0x455a14ed); /* 28 */
            GG(ref a, b, c, d, x
[13], S21, 0xa9e3e905); /* 29 */
            GG(ref d, a, b, c, x
[2], S22, 0xfcefa3f8); /* 30 */
            GG(ref c, d, a, b, x
[7], S23, 0x676f02d9); /* 31 */
            GG(ref b, c, d, a, x
[12], S24, 0x8d2a4c8a); /* 32 */

            
// Round 3
            HH(ref a, b, c, d, x
[5], S31, 0xfffa3942); /* 33 */
            HH(ref d, a, b, c, x
[8], S32, 0x8771f681); /* 34 */
            HH(ref c, d, a, b, x
[11], S33, 0x6d9d6122); /* 35 */
            HH(ref b, c, d, a, x
[14], S34, 0xfde5380c); /* 36 */
            HH(ref a, b, c, d, x
[1], S31, 0xa4beea44); /* 37 */
            HH(ref d, a, b, c, x
[4], S32, 0x4bdecfa9); /* 38 */
            HH(ref c, d, a, b, x
[7], S33, 0xf6bb4b60); /* 39 */
            HH(ref b, c, d, a, x
[10], S34, 0xbebfbc70); /* 40 */
            HH(ref a, b, c, d, x
[13], S31, 0x289b7ec6); /* 41 */
            HH(ref d, a, b, c, x
[0], S32, 0xeaa127fa); /* 42 */
            HH(ref c, d, a, b, x
[3], S33, 0xd4ef3085); /* 43 */
            HH(ref b, c, d, a, x
[6], S34, 0x4881d05); /* 44 */
            HH(ref a, b, c, d, x
[9], S31, 0xd9d4d039); /* 45 */
            HH(ref d, a, b, c, x
[12], S32, 0xe6db99e5); /* 46 */
            HH(ref c, d, a, b, x
[15], S33, 0x1fa27cf8); /* 47 */
            HH(ref b, c, d, a, x
[2], S34, 0xc4ac5665); /* 48 */

            
// Round 4
            II(ref a, b, c, d, x
[0], S41, 0xf4292244); /* 49 */
            II(ref d, a, b, c, x
[7], S42, 0x432aff97); /* 50 */
            II(ref c, d, a, b, x
[14], S43, 0xab9423a7); /* 51 */
            II(ref b, c, d, a, x
[5], S44, 0xfc93a039); /* 52 */
            II(ref a, b, c, d, x
[12], S41, 0x655b59c3); /* 53 */
            II(ref d, a, b, c, x
[3], S42, 0x8f0ccc92); /* 54 */
            II(ref c, d, a, b, x
[10], S43, 0xffeff47d); /* 55 */
            II(ref b, c, d, a, x
[1], S44, 0x85845dd1); /* 56 */
            II(ref a, b, c, d, x
[8], S41, 0x6fa87e4f); /* 57 */
            II(ref d, a, b, c, x
[15], S42, 0xfe2ce6e0); /* 58 */
            II(ref c, d, a, b, x
[6], S43, 0xa3014314); /* 59 */
            II(ref b, c, d, a, x
[13], S44, 0x4e0811a1); /* 60 */
            II(ref a, b, c, d, x
[4], S41, 0xf7537e82); /* 61 */
            II(ref d, a, b, c, x
[11], S42, 0xbd3af235); /* 62 */
            II(ref c, d, a, b, x
[2], S43, 0x2ad7d2bb); /* 63 */
            II(ref b, c, d, a, x
[9], S44, 0xeb86d391); /* 64 */

            state
[0] += a;
            state
[1] += b;
            state
[2] += c;
            state
[3] += d;

            
// Zeroize sensitive information.
            
for (int i = 0; i < x.Length; i++)
                x
[i] = 0;
        }

        
/// <summary>
        
/// Encodes input (uint) into output (byte). Assumes len is
        
///  multiple of 4.
        
/// </summary>
        
/// <param name="output"></param>
        
/// <param name="outputOffset"></param>
        
/// <param name="input"></param>
        
/// <param name="inputOffset"></param>
        
/// <param name="count"></param>
        private static void Encode(byte
[] output, int outputOffset, uint[] input, int inputOffset, int count)
        {
            
int i, j;
            
int end = outputOffset + count;
            
for (i = inputOffset, j = outputOffset; j < end; i++, j += 4)
            {
                output
[j] = (byte)(input[i] & 0xff);
                output
[j + 1] = (byte)((input[i] >> 8& 0xff);
                output
[j + 2] = (byte)((input[i] >> 16& 0xff);
                output
[j + 3] = (byte)((input[i] >> 24& 0xff);
            }
        }

        
/// <summary>
        
/// Decodes input (byte) into output (uint). Assumes len is
        
/// a multiple of 4.
        
/// </summary>
        
/// <param name="output"></param>
        
/// <param name="outputOffset"></param>
        
/// <param name="input"></param>
        
/// <param name="inputOffset"></param>
        
/// <param name="count"></param>
        static private void Decode(uint
[] output, int outputOffset, byte[] input, int inputOffset, int count)
        {
            
int i, j;
            
int end = inputOffset + count;
            
for (i = outputOffset, j = inputOffset; j < end; i++, j += 4)
                output
[i] = ((uint)input[j]| (((uint)input[j + 1]<< 8| (((uint)input[j + 2]<< 16| (((uint)input[j + 3]<<
24);
        }
        #endregion

        #region expose the same interface 
as the regular MD5 object

        protected byte
[] HashValue;
        protected 
int State;
        
public virtual bool CanReuseTransform
        {
            get
            {
                
return true;
            }
        }

        
public virtual bool CanTransformMultipleBlocks
        {
            get
            {
                
return true;
            }
        }
        
public virtual byte[] Hash
        {
            get
            {
                
if (this.State != 0)
                    throw new InvalidOperationException();
                
return (byte[])HashValue.Clone();
            }
        }
        
public virtual int HashSize
        {
            get
            {
                
return HashSizeValue;
            }
        }
        protected 
int HashSizeValue = 128;

        
public virtual int InputBlockSize
        {
            get
            {
                
return 1;
            }
        }
        
public virtual int OutputBlockSize
        {
            get
            {
                
return 1;
            }
        }

        
public void Clear()
        {
            Dispose(true);
        }

        
public byte[] ComputeHash(byte[] buffer)
        {
            
return ComputeHash(buffer, 0, buffer.Length);
        }
        
public byte[] ComputeHash(byte[] buffer, int offset, int count)
        {
            Initialize();
            HashCore(buffer, offset, 
count);
            HashValue 
= HashFinal();
            
return (byte[])HashValue.Clone();
        }

        
public byte[] ComputeHash(Stream inputStream)
        {
            Initialize();
            
int count = 0;
            byte
[] buffer = new byte[4096];
            
while (0 < (count = inputStream.Read(buffer, 04096)))
            {
                HashCore(buffer, 
0count);
            }
            HashValue 
= HashFinal();
            
return (byte[])HashValue.Clone();
        }

        
public int TransformBlock(
            byte
[] inputBuffer,
            
int inputOffset,
            
int inputCount,
            byte
[] outputBuffer,
            
int outputOffset
            )
        {
            
if (inputBuffer == null)
            {
                throw new ArgumentNullException("inputBuffer");
            }
            
if (inputOffset < 0)
            {
                throw new ArgumentOutOfRangeException("inputOffset");
            }
            
if ((inputCount < 0|| (inputCount > inputBuffer.Length))
            {
                throw new ArgumentException("inputCount");
            }
            
if ((inputBuffer.Length - inputCount) < inputOffset)
            {
                throw new ArgumentOutOfRangeException("inputOffset");
            }
            
if (this.State == 0)
            {
                Initialize();
                this.State 
= 1;
            }

            HashCore(inputBuffer, inputOffset, inputCount);
            
if ((inputBuffer != outputBuffer) || (inputOffset != outputOffset))
            {
                Buffer.BlockCopy(inputBuffer, inputOffset, outputBuffer, outputOffset, inputCount);
            }
            
return inputCount;
        }
        
public byte[] TransformFinalBlock(
            byte
[] inputBuffer,
            
int inputOffset,
            
int inputCount
            )
        {
            
if (inputBuffer == null)
            {
                throw new ArgumentNullException("inputBuffer");
            }
            
if (inputOffset < 0)
            {
                throw new ArgumentOutOfRangeException("inputOffset");
            }
            
if ((inputCount < 0|| (inputCount > inputBuffer.Length))
            {
                throw new ArgumentException("inputCount");
            }
            
if ((inputBuffer.Length - inputCount) < inputOffset)
            {
                throw new ArgumentOutOfRangeException("inputOffset");
            }
            
if (this.State == 0)
            {
                Initialize();
            }
            HashCore(inputBuffer, inputOffset, inputCount);
            HashValue 
= HashFinal();
            byte
[] buffer = new byte[inputCount];
            Buffer.BlockCopy(inputBuffer, inputOffset, buffer, 
0, inputCount);
            this.State 
= 0;
            
return buffer;
        }
        #endregion

        protected virtual void Dispose(bool disposing)
        {
            
if (!disposing)
                Initialize();
        }
        
public void Dispose()
        {
            Dispose(true);
        }
    }
}

 

  

 

特性attribute
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Reflection;

namespace KB.DSN.Entity
{
    
/// <summary>
    
/// 枚举值的描述信息
    
/// </summary>
    [AttributeUsage(AttributeTargets.Enum | AttributeTargets.Field| AttributeTargets.Property )]
    
public class EnumDescriptionAttribute : System.Attribute
    {
        
private string _name;

        
public string Name
        {
            
get { return _name; }
        }
        
public EnumDescriptionAttribute(string name)
        {
            
this._name = name;
        }

        
public static string GetEnumDescripton(Enum enumObj)
        {
            FieldInfo fieldInfo 
= enumObj.GetType().GetField(enumObj.ToString());
            
object[] arr = fieldInfo.GetCustomAttributes(typeof(EnumDescriptionAttribute), true);
            
// object[] arr = fieldInfo.GetCustomAttributes(true);
            if (arr.Length == 0)
            {
                
return string.Empty;
            }
            
else
            {
                EnumDescriptionAttribute enumDesc 
= arr[0as EnumDescriptionAttribute;
                
return enumDesc.Name;
            }
        }
        
public static T GetAttribute<T>(Enum enumObj)
        {
            FieldInfo fieldInfo 
= enumObj.GetType().GetField(enumObj.ToString());
            
object[] arr = fieldInfo.GetCustomAttributes(typeof(EnumDescriptionAttribute), true);
           
// object[] arr = fieldInfo.GetCustomAttributes(true);
            if (arr.Length == 0)
            {
                
return default(T);
            }
            
else
            {
                T attribute 
= (T)arr[0];
                
if (attribute != null)
                    
return attribute;
                
else
                    
return default(T);
            }
        }
    }
    [AttributeUsage(AttributeTargets.Enum 
| AttributeTargets.Field | AttributeTargets.Property)]
    
public class FieldDescriptionAttribute : System.Attribute
    {
         
private string _name;

        
public string Name
        {
            
get { return _name; }
        }
        
public FieldDescriptionAttribute(string name)
        {
            
this._name = name;
        }
        
public static string GetFieldDesciption( PropertyInfo p )
        {
 
            
object[] arr = p.GetCustomAttributes(typeof(FieldDescriptionAttribute), true);
            
// object[] arr = fieldInfo.GetCustomAttributes(true);
            if (arr.Length == 0)
            {
                
return string.Empty;
            }
            
else
            {
                FieldDescriptionAttribute enumDesc 
= arr[0as FieldDescriptionAttribute;
                
return enumDesc.Name;
            }
        }
        
public static string GetFieldDesciption(object obj)
        {

            
object[] arr = obj.GetType ().GetCustomAttributes(typeof(FieldDescriptionAttribute), true);
            
// object[] arr = fieldInfo.GetCustomAttributes(true);
            if (arr.Length == 0)
            {
                
return string.Empty;
            }
            
else
            {
                FieldDescriptionAttribute enumDesc 
= arr[0as FieldDescriptionAttribute;
                
return enumDesc.Name;
            }
        }
    }

    
/// <summary>
    
/// 枚举值的显示信息
    
/// </summary>
    [AttributeUsage(AttributeTargets.Enum | AttributeTargets.Field)]
    
public class EnumDisplayAttribute : System.Attribute
    {
        
private string _name;
        
public EnumDisplayAttribute(string displayName)
        {
            _name 
= displayName;
        }

        
public string DisplayName
        {
            
get { return _name; }
        }

        
public static string GetEnumDisplay(Enum enumObj)
        {
            FieldInfo fieldInfo 
= enumObj.GetType().GetField(enumObj.ToString());
            
object[] arr = fieldInfo.GetCustomAttributes(typeof(EnumDisplayAttribute), true);
            
if (arr.Length == 0)
            {
                
return string.Empty;
            }
            
else
            {
                EnumDisplayAttribute enumDisp 
= arr[0as EnumDisplayAttribute;
                
return enumDisp.DisplayName;
            }
        }
        
public static object GetEnumValue(Type enumType, string displayName)
        {
            FieldInfo[] fis 
= enumType.GetFields();
            
foreach (FieldInfo fi in fis)
            {
                EnumDisplayAttribute[] attributes 
=
                  (EnumDisplayAttribute[])fi.GetCustomAttributes(
                  
typeof(EnumDisplayAttribute), false);
                
if (attributes.Length > 0)
                {
                    
if (attributes[0].DisplayName == displayName)
                    {
                        
return fi.GetValue(fi.Name);
                    }
                }
                
if (fi.Name == displayName)
                {
                    
return fi.GetValue(fi.Name);
                }
            }
            
return null;
        }


    }



}

 

 

字符串工具类
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;

namespace KB.DSN.Utility.Server
{
    
/// <summary>
    
/// 字符串工具类
    
/// </summary>
    public static class StringUtility
    {
        
private static string UsernamePattern = @"^[a-zA-Z][a-zA-Z0-9_]*";
        
/// <summary>
        
/// String to Bool
        
/// </summary>
        
/// <param name="obj"></param>
        
/// <returns></returns>
        public static bool String2Bool(this string obj)
        {
            
if (!obj.Equals("1"&& !obj.Equals("0"))
                
throw new ArgumentException("参数只能是 1 或者 0 ""str");
            
if (obj.Equals("1"))
                
return true;
            
else
                
return false;
        }
        
/// <summary>
        
/// Bool to String
        
/// </summary>
        
/// <param name="obj"></param>
        
/// <returns></returns>
        public static string Bool2String(this bool obj)
        {
            
if (obj)
                
return "1";
            
else
                
return "0";
        }
        
//public static bool String2Bool(string str)
        
//{
        
//    if (!str.Equals("1") && !str.Equals("0"))
        
//        throw new ArgumentException("参数只能是 1 或者 0 ", "str");
        
//    if (str.Equals("1"))
        
//        return true;
        
//    else
        
//        return false;
        
//}
        
//public static string Bool2String(bool boolVari)
        
//{
        
//    if (boolVari)
        
//        return "1";
        
//    else
        
//        return "0";
        
//}
        /// <summary>
        
/// 是否登陆账号,登录账号必须字母开头,并且中间不能包含中划线-
        
/// </summary>
        
/// <returns></returns>
        public static bool IsUsername(string username)
        {
            
bool result = false;

            Regex regex 
= new Regex(UsernamePattern);

            result 
= Regex.IsMatch(username, UsernamePattern);

            
return result;
        }
        
/// <summary>
        
/// 使用分隔符连接字符串
        
/// 分隔符为char
        
/// </summary>
        
/// <param name="list"></param>
        
/// <param name="separator"></param>
        
/// <returns></returns>
        public static string GetString(List<string> list, char separator)
        {
            
if (list == null)
                
throw new ArgumentNullException("参数list不能为null");
            StringBuilder sb 
= new StringBuilder();
            
for (int i = 0; i < list.Count; i++)
            {
                
if (i == 0)
                {
                    sb.Append(list[i]);
                }

                
else
                {
                    sb.Append(separator);
                    sb.Append(list[i]);
                }
            }
            
return sb.ToString();
        }
        
/// <summary>
        
/// 使用分隔符连接字符串
        
/// 分隔符为char
        
/// </summary>
        
/// <param name="list"></param>
        
/// <param name="separator"></param>
        
/// <returns></returns>
        public static string GetString(List<Guid> list, char separator)
        {
            
if (list == null)
                
throw new ArgumentNullException("参数list不能为null");
            StringBuilder sb 
= new StringBuilder();
            
for (int i = 0; i < list.Count; i++)
            {
                
if (i == 0)
                {
                    sb.Append(list[i].ToString());
                }

                
else
                {
                    sb.Append(separator);
                    sb.Append(list[i].ToString());
                }
            }
            
return sb.ToString();
        }
        
/// <summary>
        
/// 使用分隔符连接字符串
        
/// 分隔符为string
        
/// </summary>
        
/// <param name="list"></param>
        
/// <param name="separator"></param>
        
/// <returns></returns>
        public static string GetString(List<string> list, string separator)
        {
            
if (list == null)
                
throw new ArgumentNullException("参数list不能为null");
            StringBuilder sb 
= new StringBuilder();
            
for (int i = 0; i < list.Count; i++)
            {
                
if (i == 0)
                {
                    sb.Append(list[i]);
                }
                
else
                {
                    sb.Append(separator);
                    sb.Append(list[i]);
                }
            }
            
return sb.ToString();
        }
        
/// <summary>
        
/// 使用分隔符连接字符串
        
/// 分隔符为string
        
/// </summary>
        
/// <param name="list"></param>
        
/// <param name="separator"></param>
        
/// <returns></returns>
        public static string GetString(List<Guid> list, string separator)
        {
            
if (list == null)
                
throw new ArgumentNullException("参数list不能为null");
            StringBuilder sb 
= new StringBuilder();
            
for (int i = 0; i < list.Count; i++)
            {
                
if (i == 0)
                {
                    sb.Append(list[i].ToString());
                }
                
else
                {
                    sb.Append(separator);
                    sb.Append(list[i].ToString());
                }
            }
            
return sb.ToString();
        }
        
/// <summary>
        
/// 分割字符串成List
        
/// 分隔符为string
        
/// </summary>
        
/// <param name="str"></param>
        
/// <param name="separator"></param>
        
/// <returns></returns>
        public static List<string> GetStringList(string str, string separator)
        {
            List
<string> list = null;

            list 
= GetStringArray(str, separator).ToList<string>();
            
return list;
        }
        
/// <summary>
        
/// 分割字符串成List
        
/// 分隔符为string
        
/// </summary>
        
/// <param name="str"></param>
        
/// <param name="separator"></param>
        
/// <returns></returns>
        public static List<Guid> GetGuidStringList(string str, string separator)
        {
            List
<Guid> list = null;

            
string[] strs = GetStringArray(str, separator);
            
foreach (string s in strs)
            {
                list.Add(
new Guid(s));
            }
            
return list;
        }
        
/// <summary>
        
/// 分割字符串成List
        
/// 分隔符为char
        
/// </summary>
        
/// <param name="str"></param>
        
/// <param name="separator"></param>
        
/// <returns></returns>
        public static List<Guid> GetGuidStringList(string str, char separator)
        {
            List
<Guid> list = null;
            
foreach (Guid id in list)
            {
            }
            
string[] strs = GetStringArray(str, separator);
            
foreach (string s in strs)
            {
                list.Add(
new Guid(s));
            }
            
return list;
        }
        
/// <summary>
        
/// 分割字符串成List
        
/// 分隔符为char
        
/// </summary>
        
/// <param name="str"></param>
        
/// <param name="separator"></param>
        
/// <returns></returns>
        public static List<string> GetStringList(string str, char separator)
        {
            List
<string> list = null;

            list 
= GetStringArray(str, separator).ToList<string>();
            
return list;
        }
        
/// <summary>
        
/// 分隔字符串成Array
        
/// 分隔符为string
        
/// </summary>
        
/// <param name="str"></param>
        
/// <param name="separator"></param>
        
/// <returns></returns>
        public static string[] GetStringArray(string str, string separator)
        {
            
return str.Split(new string[] { separator }, StringSplitOptions.None);
        }

        
/// <summary>
        
/// 分隔字符串成Array
        
/// 分隔符为char
        
/// </summary>
        
/// <param name="str"></param>
        
/// <param name="separator"></param>
        
/// <returns></returns>
        public static string[] GetStringArray(string str, char separator)
        {
            
return str.Split(new char[] { separator }, StringSplitOptions.None);
        }
        
/// <summary>
        
/// sql查询条件中的where拼凑,查询的列类型DateTime
        
/// 种植方案种植期条件查询使用
        
/// </summary>
        
/// <param name="sb"></param>
        
/// <param name="name"></param>
        
/// <param name="begin"></param>
        
/// <param name="end"></param>
        public static void SQLwhereCombineDateTime(StringBuilder sb, string beginField, string endField, DateTime? begin, DateTime? end)
        {
            
if (begin != null && begin.ToString().Contains("0001-1-1 0:00:00"&&
            end 
!= null && end.ToString().Contains("0001-1-1 0:00:00"))
                
return;
            
if (begin != null && end != null)
            {
                
if (string.IsNullOrEmpty(sb.ToString()))
                {
                    
if (end > begin)
                        sb.Append(
string.Format(" where {0} <= '{1}' and {2} >= '{3}' ", beginField, begin, endField, end));
                    
else
                        sb.Append(
string.Format(" where {0} >= '{1}' and {2} <= '{3}' ", beginField, end, endField, begin));
                }
                
else
                {
                    
if (end > begin)
                        sb.Append(
string.Format(" and {0} <= '{1}' and {2} >= '{3}' ", beginField, begin, endField, end));
                    
else
                        sb.Append(
string.Format(" and {0} >= '{1}' and {2} <= '{3}' ", beginField, end, endField, begin));
                }
            }
            
if (begin != null & end == null)
            {
                
if (string.IsNullOrEmpty(sb.ToString()))
                {
                    sb.Append(
string.Format(" where {0} >= '{1}'  ", beginField, begin));
                }
                
else
                {
                    sb.Append(
string.Format(" and {0} >= '{1}'  ", beginField, begin));
                }

                
if (begin == null & end != null)
                {
                    
if (string.IsNullOrEmpty(sb.ToString()))
                    {
                        sb.Append(
string.Format(" where  {0} <= '{1}' ", endField, end));
                    }
                    
else
                    {
                        sb.Append(
string.Format(" and  {0} <= '{1}' ", endField, end));
                    }
                }
            }
        }
        
/// <summary>
        
/// sql查询条件中的where拼凑,查询的列类型DateTime
        
/// </summary>
        
/// <param name="sb"></param>
        
/// <param name="name"></param>
        
/// <param name="begin"></param>
        
/// <param name="end"></param>
        public static void SQLwhereCombineDateTime(StringBuilder sb, string fieldName, DateTime? begin, DateTime? end)
        {
            
if (begin != null && begin.ToString().Contains("0001-1-1 0:00:00"&&
            end 
!= null && end.ToString().Contains("0001-1-1 0:00:00"))
                
return;
            
if (begin != null && end != null)
            {
                
if (string.IsNullOrEmpty(sb.ToString()))
                {
                    
if (end > begin)
                        sb.Append(
string.Format(" where {0} >= '{1}' and {0} <= '{2}' ", fieldName, begin, end));
                    
else
                        sb.Append(
string.Format(" where {0} >= '{1}' and {0} <= '{2}' ", fieldName, end, begin));
                }
                
else
                {
                    
if (end > begin)
                        sb.Append(
string.Format(" and {0} >= '{1}' and {0} <= '{2}' ", fieldName, begin, end));
                    
else
                        sb.Append(
string.Format(" and {0} >= '{1}' and {0} <= '{2}' ", fieldName, end, begin));
                }
            }
            
if (begin != null & end == null)
            {
                
if (string.IsNullOrEmpty(sb.ToString()))
                {
                    sb.Append(
string.Format(" where {0} >= '{1}'  ", fieldName, begin));
                }
                
else
                { sb.Append(
string.Format(" and {0} >= '{1}'  ", fieldName, begin)); }
            }

            
if (begin == null & end != null)
            {
                
if (string.IsNullOrEmpty(sb.ToString()))
                {
                    sb.Append(
string.Format(" where  {0} <= '{1}' ", fieldName, end));
                }
                
else
                { sb.Append(
string.Format(" and  {0} <= '{1}' ", fieldName, end)); }
            }
        }
        
/// <summary>
        
/// sql查询条件中的where拼凑,查询的列类型String
        
/// </summary>
        
/// <param name="sb"></param>
        
/// <param name="name"></param>
        
/// <param name="begin"></param>
        
/// <param name="end"></param>
        public static void SQLwhereCombineString(StringBuilder sb, string fieldName, string condition, string value)
        {
            
if (!string.IsNullOrEmpty(value))
            {
                
if (string.IsNullOrEmpty(sb.ToString()))
                {

                    
if (condition.Trim().Equals("like", StringComparison.CurrentCultureIgnoreCase))
                    { sb.Append(
string.Format(" where {0} {1} '%{2}%'", fieldName, condition, value)); }
                    
else
                    { sb.Append(
string.Format(" where {0} {1} '{2}'", fieldName, condition, value)); }

                }
                
else
                {

                    
if (condition.Trim().Equals("like", StringComparison.CurrentCultureIgnoreCase))
                    { sb.Append(
string.Format(" and {0} {1} '%{2}%'", fieldName, condition, value)); }
                    
else
                    { sb.Append(
string.Format(" and {0} {1} '{2}'", fieldName, condition, value)); }

                }
            }
        }

        
/// <summary>
        
/// sql查询条件中的where拼凑,查询的列类型Decimal
        
/// </summary>
        
/// <param name="sb"></param>
        
/// <param name="fieldName"></param>
        
/// <param name="begin"></param>
        
/// <param name="end"></param>
        public static void SQLwhereCombineDecimal(StringBuilder sb, string fieldName, decimal? begin, decimal? end)
        {
            
if (begin != null && end != null)
            {
                
if (string.IsNullOrEmpty(sb.ToString()))
                {
                    
if (end > begin)
                        sb.Append(
string.Format(" where {0} >= {1} and {0} <= {2} ", fieldName, begin, end));
                    
else
                        sb.Append(
string.Format(" where {0} >= {1} and {0} <= {2} ", fieldName, end, begin));
                }
                
else
                {
                    
if (end > begin)
                        sb.Append(
string.Format(" and {0} >= {1} and {0} <= {2} ", fieldName, begin, end));
                    
else
                        sb.Append(
string.Format(" and {0} >= {1} and {0} <= {2} ", fieldName, end, begin));
                }
            }
            
if (begin != null && end == null)
            {
                
if (string.IsNullOrEmpty(sb.ToString()))
                {
                    sb.Append(
string.Format(" where {0} >= {1} ", fieldName, begin));

                }
                
else
                {
                    sb.Append(
string.Format(" and {0} >= {1} ", fieldName, begin));
                }
            }
            
if (begin == null && end != null)
            {
                
if (string.IsNullOrEmpty(sb.ToString()))
                {
                    sb.Append(
string.Format(" where {0}  <= {1} ", fieldName, end));

                }
                
else
                {
                    sb.Append(
string.Format(" and {0} <= {1} ", fieldName, end));
                }
            }
        }
        
/// <summary>
        
/// sql查询条件中的where拼凑,查询的列类型Enum
        
/// </summary>
        
/// <param name="sb"></param>
        
/// <param name="fieldName"></param>
        
/// <param name="begin"></param>
        
/// <param name="end"></param>
        public static void SQLwhereCombineEnum<T>(StringBuilder sb, string fieldName, int enumInt)
        {
            List
<T> list = Contains<T>(enumInt);
            
if (list != null && list.Count > 0)
            {
                
for (int i = 0; i < list.Count; i++)
                {
                    
if (list.Count == 1)
                    {
                        
if (string.IsNullOrEmpty(sb.ToString()))
                        {
                            sb.Append(
string.Format(" where  {0} {1} '{2}' ", fieldName, "=", EnumUtility<T>.Type2String(list[i])));
                        }
                        
else
                        {
                            sb.Append(
string.Format(" and  {0} {1} '{2}' ", fieldName, "=", EnumUtility<T>.Type2String(list[i])));
                        }
                    }
                    
else if (i == 0)
                    {
                        
if (string.IsNullOrEmpty(sb.ToString()))
                            sb.Append(
string.Format(" where ( {0} {1} '{2}' ", fieldName, "=", EnumUtility<T>.Type2String(list[i])));
                        
else
                            sb.Append(
string.Format(" and ( {0} {1} '{2}' ", fieldName, "=", EnumUtility<T>.Type2String(list[i])));
                    }
                    
else if (i == list.Count - 1)
                        sb.Append(
string.Format(" or {0} {1} '{2}' ) ", fieldName, "=", EnumUtility<T>.Type2String(list[i])));
                    
else
                        sb.Append(
string.Format(" or {0} {1} '{2}'", fieldName, "=", EnumUtility<T>.Type2String(list[i])));
                }

            }
        }
        
/// <summary>
        
/// 返货枚举类型中的全部枚举量对应的Name
        
/// </summary>
        
/// <typeparam name="T"></typeparam>
        
/// <returns></returns>
        public static List<string> Contains<T>()
        {
            List
<string> status = new List<string>();

            
foreach (string s in Enum.GetNames(typeof(T)))
            {
                status.Add(s);
            }
            
return status;
        }
        
/// <summary>
        
/// 返回给定整数对应的枚举量的组合
        
/// </summary>
        
/// <typeparam name="T"></typeparam>
        
/// <param name="enums"></param>
        
/// <returns></returns>
        public static List<T> Contains<T>(int enumInt)
        {
            List
<T> status = new List<T>();
            
if (enumInt >= 0)
            {

                Array array 
= Enum.GetValues(typeof(T));
                
foreach (int o in array)
                {
                    
if ((enumInt & o) > 0)
                        status.Add((T)Enum.Parse(
typeof(T), o.ToString()));
                }

            }
            
return status;
        }
        
public static string GetEnum<T>(List< T> enumObjs, string separator) 
        {
            StringBuilder sb 
= new StringBuilder(0);
            
for(int i=0;i<enumObjs.Count ;i++)// T o in enumObjs)
            {
                
if (i == enumObjs.Count - 1)
                    sb.Append(((
int)Enum.Parse(typeof(T), enumObjs[i].ToString ())).ToString());
                sb.Append(
string.Format ("{0}{1}", ((int)Enum.Parse(typeof(T), enumObjs[i].ToString())).ToString(),separator )); 
            }
            
return sb.ToString();
        }
        
#region 高健用的模糊查询

        
/// <summary>
        
/// 高健的方法用到的
        
/// </summary>
        
/// <param name="sb"></param>
        
/// <param name="fieldName"></param>
        
/// <param name="condition"></param>
        
/// <param name="value"></param>
        public static void SQLwhereLinkString(StringBuilder sb, string fieldName, string condition, string value)
        {
            
if (!string.IsNullOrEmpty(value))
            {
                
if (!string.IsNullOrEmpty(sb.ToString()))
                {
                    sb.Append(
string.Format(" and {0} {1} '%{2}%'", fieldName, condition, value));

                }
                
else
                {
                    sb.Append(
string.Format("  {0} {1} '%{2}%'", fieldName, condition, value));
                }
            }
        }
        
/// <summary>
        
/// 高健用的方法
        
/// </summary>
        
/// <param name="sb"></param>
        
/// <param name="fieldName"></param>
        
/// <param name="begin"></param>
        
/// <param name="end"></param>
        public static void SQLwhereLinkDateTime(StringBuilder sb, string fieldName, DateTime? begin, DateTime? end)
        {
            
if (begin != null && end != null)
            {
                
if (string.IsNullOrEmpty(sb.ToString()))
                {
                    sb.Append(
string.Format("  {0} >= '{1}' and {0} <= '{2}' ", fieldName, begin, end));
                }
                
else
                { sb.Append(
string.Format("  and  {0}>= '{1}' and {0}<= '{2}' ", fieldName, begin, end)); }
            }
            
if (begin != null & end == null)
            {
                
if (string.IsNullOrEmpty(sb.ToString()))
                {
                    sb.Append(
string.Format("  {0}>= '{1}'  ", fieldName, begin));
                }
                
else
                { sb.Append(
string.Format(" and {0} >= '{1}'  ", fieldName, begin)); }
            }

            
if (begin == null & end != null)
            {
                
if (string.IsNullOrEmpty(sb.ToString()))
                {
                    sb.Append(
string.Format("   {0} <= '{1}' ", fieldName, end));
                }
                
else
                { sb.Append(
string.Format("  and  {0} <= '{1}' ", fieldName, end)); }
            }
        }

        
#endregion
    }
}