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

代码

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(0, 8));
                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(0, 8));
                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[] {
              0x80, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
              0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
              0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
             };
        #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 1, 2, 3, and 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, index, count - 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.count, 0, 8);

            // 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, 0, 8);

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

            // 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, 0, 4096)))
            {
                HashCore(buffer, 0, count);
            }
            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[0] as 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[0] as 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[0] as 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[0] as 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
    }
}