一些公共方法

namespace Smc20.Common.Public
{
    /// <summary>
    /// SMC中需要的公共的方法
    /// </summary>
    public class SMCPublicFunction
    {
        /// <summary>
        /// 数据序列化到xml文档中
        /// </summary>
        /// <param name="tData">tData</param>
        /// <param name="XmlResult">XmlResult</param>
        public static void SerializeXML<T>(T tData, out XmlNode XmlResult)
        {
            XmlDocument xmldoc = new XmlDocument();

            //利用xml序列化器和MemoryStream，将数据序列化到xml文档中
            XmlSerializer s = new XmlSerializer(tData.GetType());
            MemoryStream stream = new MemoryStream();
            try
            {
                s.Serialize(stream, tData);
                stream.Position = 0; //注意这个位置，需要将Memorystream重新定位到起点。
                xmldoc.Load(stream); //将xml流加载到xml文档对象。

                XmlResult = xmldoc.LastChild;
            }
            catch (Exception)
            {
                throw;
            }
            finally
            {
                stream.Close();
                stream.Dispose();
            }
        }

        /// <summary>
        /// 将.net时间转换为JS时间
        /// </summary>
        /// <param name="inputTime">输入时间</param>
        /// <param name="mTime">转换后的时间</param>
        public static void GetJsTime(DateTime inputTime, out long mTime)
        {
            mTime = 0;
            long jsBeginTick = DateTime.Parse("1970-1-1 0:00:00").Ticks;
            long dtTicks = inputTime.Ticks;
            mTime = (dtTicks - jsBeginTick) / 10000000;
        }

        /// <summary>
        /// 反序列化
        /// </summary>
        /// <param name="typeNameFormat">类型的格式字符串</param>
        /// <param name="tData">tData</param>
        /// <param name="XmlResult">XmlResult</param>
        /// <remarks>typeNameFormat的格式为"命名空间.{0},程序集名称"</remarks>
        public static void DesSerializeXML<T>(string typeNameFormat, XmlNode tData, out T XmlResult)
        {
            Type type = Type.GetType(string.Format(typeNameFormat, tData.Name));

            XmlSerializer serial = new XmlSerializer(type);
            XmlNodeReader reader = new XmlNodeReader(tData);

            T test = (T)serial.Deserialize(reader);
            XmlResult = test;
        }

        /// <summary>
        /// 序列化通知消息
        /// </summary>
        /// <param name="tData">tData</param>
        /// <param name="XmlResult">XmlResult</param>
        public static void SerializeNotification(NotificationBase tData, out XmlNode XmlResult)
        {
            MemoryStream stream = null;
            try
            {
                XmlDocument xmldoc = new XmlDocument();
                //利用xml序列化器和MemoryStream，将数据序列化到xml文档中
                XmlSerializer s = new XmlSerializer(tData.GetType(), tData.GetType().Assembly.GetName().Name);
                stream = new MemoryStream();

                s.Serialize(stream, tData);
                stream.Position = 0; //注意这个位置，需要将Memorystream重新定位到起点。
                xmldoc.Load(stream); //将xml流加载到xml文档对象。

                XmlResult = xmldoc.LastChild;
            }
            catch (Exception e)
            {
                throw;
            }
            finally
            {
                if (null != stream)
                {
                    stream.Close();
                    stream.Dispose();
                }
            }
        }

        /// <summary>
        /// 反序列化通知消息
        /// </summary>
        /// <param name="tData">tData</param>
        /// <param name="XmlResult">XmlResult</param>
        /// <remarks>typeNameFormat的格式为"命名空间.{0},程序集名称"</remarks>
        public static void DesSerializeNotification(XmlNode tData, out NotificationBase XmlResult)
        {
            XmlResult = null;
            if (string.IsNullOrEmpty(tData.Name) || string.IsNullOrEmpty(tData.NamespaceURI))
            {
                return;
            }

            string typeNameFormat = SMCConst.NAMESPACE_NOTIFICATION + ".{0},{1}";
            Type type = Type.GetType(string.Format(typeNameFormat, tData.Name, tData.NamespaceURI));

            XmlSerializer serial = new XmlSerializer(type, tData.NamespaceURI);

            XmlNodeReader reader = new XmlNodeReader(tData);

            NotificationBase test = (NotificationBase)serial.Deserialize(reader);
            XmlResult = test;
        }

        /// <summary>
        /// 解析绑定方式
        /// </summary>
        /// <param name="bindname">绑定方式字符串</param>
        /// <param name="bind">绑定的句柄</param>
        public static void PraseBindManner(string bindname, out Binding bind)
        {
            Binding binding = null;

            switch (bindname)
            {
                case SMCConst.REG_BASIC_HTTP_BINDING:
                case "BasicHttpBinding":
                    binding = new BasicHttpBinding();
                    break;

                case SMCConst.REG_WSHTTP_BINDING:
                case "WSHttpBinding":
                    //binding = new WSHttpBinding();
                    WSHttpBinding wsHttpBinding = new WSHttpBinding("WSHttpBinding_ISMC");
                    //wsHttpBinding.MaxReceivedMessageSize = 2147483647;
                    //wsHttpBinding.MaxBufferPoolSize = 2147483647;
                    //wsHttpBinding.ReceiveTimeout = new TimeSpan(1, 0, 0);
                    binding = wsHttpBinding;
                    break;

                default:
                    //todo
                    binding = new WSHttpBinding();
                    break;
            }

            bind = binding;
        }

        /// <summary>
        /// MD5加密
        /// </summary>
        /// <param name="password">密码</param>
        /// <returns>密文</returns>
        public static string MD5EncryptPassword(string password)
        {
            //加密
            MD5 md5Hasher = MD5.Create();

            // 将输入的字符串转换成字节数组，并计算哈希值
            byte[] dataPass = md5Hasher.ComputeHash(Encoding.Unicode.GetBytes(password));

            // 创建一个新的Stringbuilder来保存字节，并且创建一个字符串。
            StringBuilder sBuilder = new StringBuilder();

            // 循环哈希值的每一个字节，并以十六进制格式保存为字符串
            for (int i = 0; i < dataPass.Length; i++)
            {
                sBuilder.Append(dataPass[i].ToString("x2"));
            }

            return sBuilder.ToString();
        }

        /// <summary>
        /// 生成用户密码
        /// </summary>
        /// <returns>随机密码，明文</returns>
        public static string GenerateRandomPassword()
        {
            // 密码长度，以后应该通过配置参数确定
            int passwordLength = SMCConst.DEFAULT_MAX_PASSWORD_LENGTH;

            // 创建一个局部数组，包含的支持密码的字符按照类型分成组。
            char[][] charGroups = new char[][] 
            {
                SMCConst.PASSWORD_CHARS_LCASE.ToCharArray(),
                SMCConst.PASSWORD_CHARS_UCASE.ToCharArray(),
                SMCConst.PASSWORD_CHARS_NUMERIC.ToCharArray(),
                SMCConst.PASSWORD_CHARS_SPECIAL.ToCharArray()
            };

            // 利用这个数组去追踪每一个组里面还没有被使用的字符的数量。 
            int[] charsLeftInGroup = new int[charGroups.Length];

            //最开始，所有的字符都没有被使用
            for (int i = 0; i < charsLeftInGroup.Length; i++)
            {
                charsLeftInGroup[i] = charGroups[i].Length;
            }

            //利用这个数组追踪还没有被使用的字符组。
            int[] leftGroupsOrder = new int[charGroups.Length];

            //最开始，每一组都没有被使用
            for (int i = 0; i < leftGroupsOrder.Length; i++)
            {
                leftGroupsOrder[i] = i;
            }

            //我们不能使用默认的随机发生器，因为他是以时间为基础的
            //（他在一秒中内会产生相同的数字）。
            //我们要利用随机数发生器种子去产生一个随机数。

            //利用4字节数组去填充随机数，并且将它转换成一个int值
            byte[] randomBytes = new byte[4];

            // 产生4组随机字节。Generate 4 random bytes.
            RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider();
            rng.GetBytes(randomBytes);

            // 将4字节转换成32位的int值.
            int seed = (randomBytes[0] & 0x7f) << 24 |
                             randomBytes[1] << 16 |
                             randomBytes[2] << 8 |
                             randomBytes[3];

            Random random = new Random(seed);
            char[] password = null;

            // 为这个密码申请适当的内存。
            password = new char[passwordLength];

            //索引下一个字符用于添加到密码中
            int nextCharIdx;

            //索引下一个字符组
            int nextGroupIdx;

            int nextLeftGroupsOrderIdx;

            //索引在字符组里面最后一个没有被用到的字符。
            int lastCharIdx;

            //索引最后一个没有被用到的组
            int lastLeftGroupsOrderIdx = leftGroupsOrder.Length - 1;

            // 在同一个时间产生一个密码字符
            for (int i = 0; i < password.Length; i++)
            {
                if (lastLeftGroupsOrderIdx == 0)
                {
                    nextLeftGroupsOrderIdx = 0;
                }
                else
                {
                    nextLeftGroupsOrderIdx = random.Next(0, lastLeftGroupsOrderIdx);
                }

                nextGroupIdx = leftGroupsOrder[nextLeftGroupsOrderIdx];

                lastCharIdx = charsLeftInGroup[nextGroupIdx] - 1;

                if (lastCharIdx == 0)
                {
                    nextCharIdx = 0;
                }
                else
                {
                    nextCharIdx = random.Next(0, lastCharIdx + 1);
                }

                // 将这些字符保存成密码字符串
                password[i] = charGroups[nextGroupIdx][nextCharIdx];

                if (lastCharIdx == 0)
                {
                    charsLeftInGroup[nextGroupIdx] = charGroups[nextGroupIdx].Length;
                }
                else
                {
                    if (lastCharIdx != nextCharIdx)
                    {
                        char temp = charGroups[nextGroupIdx][lastCharIdx];
                        charGroups[nextGroupIdx][lastCharIdx] =
                                    charGroups[nextGroupIdx][nextCharIdx];
                        charGroups[nextGroupIdx][nextCharIdx] = temp;
                    }
                    // 在一组里还没有被使用字符次序依次递减。
                    charsLeftInGroup[nextGroupIdx]--;
                }
                // If we processed the last group, start all over.
                if (lastLeftGroupsOrderIdx == 0)
                {
                    lastLeftGroupsOrderIdx = leftGroupsOrder.Length - 1;
                }
                else
                {
                    if (lastLeftGroupsOrderIdx != nextLeftGroupsOrderIdx)
                    {
                        int temp = leftGroupsOrder[lastLeftGroupsOrderIdx];
                        leftGroupsOrder[lastLeftGroupsOrderIdx] = leftGroupsOrder[nextLeftGroupsOrderIdx];
                        leftGroupsOrder[nextLeftGroupsOrderIdx] = temp;
                    }
                    // 没有被使用到的组的次序依次递减。
                    lastLeftGroupsOrderIdx--;
                }
            }
            // 将字符密码转换成字符串并将该字符串返回。
            return new string(password);
        }

        /// <summary>
        /// 截取字符串最后一个字符
        /// </summary>
        /// <param name="cutChar">要截取的字符</param>
        /// <param name="str">输出的字符串</param>
        public static string CutEndChar(char cutChar, string str)
        {
            char[] c = { cutChar };

            return str.TrimEnd(c);
        }

        /// <summary>
        /// 是否包含指定的字符串
        /// </summary>
        /// <param name="str">str</param>
        /// <param name="reg">reg</param>
        /// <returns>状态</returns>
        public static bool ContaninStr(string str, string reg)
        {
            if (true == string.IsNullOrEmpty(str)
                || true == string.IsNullOrEmpty(reg))
            {
                return false;
            }

            //return Regex.IsMatch(str, @reg, RegexOptions.IgnoreCase);
            string upStr = str.ToUpper();
            string lowStr = str.ToLower();
            string upRegStr = reg.ToUpper();
            string lowRegStr = reg.ToLower();

            if (upStr.Contains(upRegStr) || upStr.Contains(lowRegStr)
                || lowStr.Contains(upRegStr) || lowStr.Contains(lowRegStr))
            {
                return true;
            }

            return false;
        }

        /// <summary>
        /// SHA256加密
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public static string SHA256Encrypt(string str)
        {
            System.Security.Cryptography.SHA256 s256 = new SHA256Managed();
            byte[] bytes;
            bytes = s256.ComputeHash(ASCIIEncoding.Default.GetBytes(str));
            s256.Clear();
            // 创建一个新的Stringbuilder来保存字节，并且创建一个字符串。
            StringBuilder sBuilder = new StringBuilder();

            // 循环哈希值的每一个字节，并以十六进制格式保存为字符串
            for (int i = 0; i < bytes.Length; i++)
            {
                sBuilder.Append(bytes[i].ToString("x2"));
            }
            return sBuilder.ToString();
        }
    }
}