using System;
using System.Collections.Generic;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Drawing.Imaging;
using System.IO;
using System.Linq;
using System.Net;
using System.Reflection;
using System.Text;
using System.Security.Cryptography;
using System.Web;
using System.Net.NetworkInformation;
using System.Management;
using System.ComponentModel;
using System.Diagnostics;
using System.Collections;
using System.Text.RegularExpressions;

namespace Common
{
    public static class Tools
    {
        private static log4net.ILog logger = log4net.LogManager.GetLogger(typeof(Tools));
        /// <summary>
        /// 获取机器码
        /// </summary>
        /// <returns></returns>
        public static string GetMachineCode()
        {
            StringBuilder result = new StringBuilder();
            String[] macAddress = GetMacAddressByNetworkInformation("-").Split('-');
            //String motherBoardSerialNumber = GetMotherBoardSerialNumber();
            String diskModel = GetDiskModel();

            if (diskModel.Length < 10)
            {
                diskModel = "PIUHOUHZUW";
            }

            result.Append(macAddress[0] + diskModel.Substring(0, 2).Replace(" ", "z"));// + motherBoardSerialNumber.Substring(0, 2)).Replace(" ", "a");
            result.Append(macAddress[1] + diskModel.Substring(2, 2).Replace(" ", "x"));// + motherBoardSerialNumber.Substring(2, 2).Replace(" ", "s"));
            result.Append(macAddress[2] + diskModel.Substring(4, 2).Replace(" ", "c"));// + motherBoardSerialNumber.Substring(4, 2).Replace(" ", "d"));
            result.Append(macAddress[3] + diskModel.Substring(6, 2).Replace(" ", "v"));// + motherBoardSerialNumber.Substring(6, 2).Replace(" ", "f"));
            result.Append(macAddress[4] + diskModel.Substring(8, 2).Replace(" ", "b"));// + motherBoardSerialNumber.Substring(8, 2).Replace(" ", "g"));
            result.Append(macAddress[5]);

            return result.ToString();
        }
        /// <summary>
        /// 获取mac地址
        /// </summary>
        /// <param name="separatedFlag"></param>
        /// <returns></returns>
        public static String GetMacAddressByNetworkInformation(string separatedFlag = "")
        {
            string macAddress = "";
            NetworkInterface[] nics = NetworkInterface.GetAllNetworkInterfaces();
            foreach (NetworkInterface adapter in nics)
            {
                if (adapter.NetworkInterfaceType == NetworkInterfaceType.Ethernet &&
                    adapter.Description.ToUpper().IndexOf("WIRELESS") == -1 && adapter.Description.ToUpper().IndexOf("3G") == -1 &&
                    adapter.Description.ToUpper().IndexOf("VIRTUAL") == -1 && adapter.Description.ToUpper().IndexOf("VPN") == -1)
                {
                    macAddress = adapter.GetPhysicalAddress().ToString();
                    if (!string.IsNullOrEmpty(separatedFlag))
                    {
                        for (int i = 1; i < 6; i++)
                        {
                            macAddress = macAddress.Insert(3 * i - 1, separatedFlag);
                        }
                    }
                    break;
                }
            }
            return macAddress;
        }
        /// <summary>
        /// 获取硬盘序列号
        /// </summary>
        /// <returns></returns>
        public static String GetDiskModel()
        {
            using (ManagementClass mc = new ManagementClass("Win32_DiskDrive"))
            {
                using (ManagementObjectCollection moc = mc.GetInstances())
                {
                    string Model = "";
                    foreach (ManagementObject mo in moc)
                    {
                        Model = mo["Model"].ToString().Trim();
                        break;
                    }
                    return Model;
                }
            }
        }

        public static string GetClientIP(HttpRequestBase request)
        {
            if (request == null)
            {
                throw new ArgumentNullException("request");
            }
            string ip = null;
            if (!string.IsNullOrEmpty(request.ServerVariables["HTTP_VIA"]))
            {
                ip = Convert.ToString(request.ServerVariables["HTTP_X_FORWARDED_FOR"]);
            }
            if (string.IsNullOrEmpty(ip))
            {
                ip = Convert.ToString(request.ServerVariables["REMOTE_ADDR"]);
            }
            return ip;
        }

        public static string GetClientIP()
        {
            string userIP;
            HttpRequest request = System.Web.HttpContext.Current.Request; // 如果使用代理，获取真实IP  
            if (request.ServerVariables["HTTP_X_FORWARDED_FOR"] != "")
                userIP = request.ServerVariables["REMOTE_ADDR"];
            else
                userIP = request.ServerVariables["HTTP_X_FORWARDED_FOR"];
            if (userIP == null || userIP == "")
                userIP = request.UserHostAddress;
            return userIP;
        }

        /// <summary>
        /// 获取本地IP地址
        /// </summary>
        /// <returns></returns>
        public static string GetLocalIP()
        {
            string localIp = "";

            IPAddress[] addressList = Dns.GetHostAddresses(Dns.GetHostName());//会返回所有地址，包括IPv4和IPv6   
            foreach (IPAddress ip in addressList)
            {
                if (ip.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork)
                {
                    localIp = ip.ToString();
                    break;
                }
            }

            return localIp;
        }
        /// <summary>
        /// 将主机名或 IP 地址解析IP地址
        /// </summary>
        /// <param name="domain"></param>
        /// <returns></returns>
        public static IPAddress GetIPByDomain(string hostNameOrAddress)
        {
            IPHostEntry host = Dns.GetHostEntry(hostNameOrAddress);
            return host.AddressList[0];
        }

        /// <summary>
        /// 获取本地IP地址列表
        /// </summary>
        /// <returns></returns>
        public static IList<string> GetLocalIPList()
        {
            IList<string> localIpList = new List<string>();

            IPAddress[] addressList = Dns.GetHostAddresses(Dns.GetHostName());//会返回所有地址，包括IPv4和IPv6   
            foreach (IPAddress ip in addressList)
            {
                if (ip.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork)
                {
                    localIpList.Add(ip.ToString());
                }
            }

            return localIpList;
        }

        public static string GetApplicationPath()
        {
            return AppDomain.CurrentDomain.SetupInformation.ApplicationBase;
        }
        /// <summary>
        /// 获取记录访问量文件路径
        /// </summary>
        /// <returns></returns>
        public static string GetCounterFilePath()
        {
            return GetApplicationPath() + @"License\counter.txt";
        }

        /// <summary>
        /// 生成CRC16校验
        /// </summary>
        /// <param name="buffer"></param>
        /// <param name="len"></param>
        /// <returns></returns>
        public static ushort CRC16(byte[] buffer, int len)
        {
            uint xda, xdapoly;
            byte xdabit;
            xda = 0xFFFF;
            xdapoly = 0xA001;	// (X**16 + X**15 + X**2 + 1)

            for (int i = 0; i < len; i++)
            {
                xda ^= buffer[i];
                for (int j = 0; j < 8; j++)
                {
                    xdabit = (byte)(xda & 0x01);
                    xda >>= 1;
                    if (xdabit == 1)
                    {
                        xda ^= xdapoly;
                    }
                }
            }
            return Convert.ToUInt16(xda & 0xffff);
        }

        /// <summary>
        /// 计算文件的MD5值
        /// </summary>
        /// <param name="file"></param>
        /// <returns></returns>
        public static byte[] MD5(string file)
        {
            using (Stream stream = File.Open(file, FileMode.Open))
            {
                return MD5(stream);
            }
        }

        /// <summary>
        /// 计算流的MD5值
        /// </summary>
        /// <param name="stream"></param>
        /// <returns></returns>
        public static byte[] MD5(Stream stream)
        {
            using (MD5 md5 = new MD5CryptoServiceProvider())
            {
                return md5.ComputeHash(stream);
            }
        }
        /// <summary>
        /// 计算文件MD5
        /// </summary>
        /// <param name="stream"></param>
        /// <returns></returns>
        public static string ComputeFileHash(Stream stream)
        {
            byte[] retVal = Tools.MD5(stream);
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < retVal.Length; i++)
            {
                sb.Append(retVal[i].ToString("x2"));
            }
            return sb.ToString();
        }

        /// <summary>
        /// 将MD5字符串转换成整型数组表示
        /// </summary>
        /// <param name="md5"></param>
        /// <returns></returns>
        public static uint[] MD5StringToUIntArray(string md5)
        {
            if (String.IsNullOrWhiteSpace(md5))
            {
                throw new ArgumentException("参数不能为空。", "md5");
            }

            try
            {
                uint[] md5Arr = new uint[4] { 0, 0, 0, 0 };

                md5Arr[0] = Convert.ToUInt32(md5.Substring(0, 8), 16);
                md5Arr[1] = Convert.ToUInt32(md5.Substring(8, 8), 16);
                md5Arr[2] = Convert.ToUInt32(md5.Substring(16, 8), 16);
                md5Arr[3] = Convert.ToUInt32(md5.Substring(24, 8), 16);

                return md5Arr;
            }
            catch (Exception ex)
            {
                throw new ApplicationException("转换MD5出错。", ex);
            }
        }
        /// <summary>
        /// 用MD5加密字符串
        /// </summary>
        /// <param name="str">待加密的字符串</param>
        /// <returns></returns>
        public static string MD5Encrypt(string str)
        {
            MD5CryptoServiceProvider md5Hasher = new MD5CryptoServiceProvider();
            byte[] hashedDataBytes;
            hashedDataBytes = md5Hasher.ComputeHash(Encoding.UTF8.GetBytes(str));
            StringBuilder tmp = new StringBuilder();
            foreach (byte i in hashedDataBytes)
            {
                tmp.Append(i.ToString("x2"));
            }
            return tmp.ToString();
        }
        /// <summary>
        /// 获取指定长的的字符串对应的16进制字节码，如果长度不够，末位自动补0
        /// </summary>
        /// <param name="s"></param>
        /// <param name="length"></param>
        /// <returns></returns>
        public static byte[] GetBytes(String str, int length)
        {
            byte[] s = System.Text.Encoding.GetEncoding("gb2312").GetBytes(str);
            int fixLength = length - s.Length;
            if (s.Length < length)
            {
                byte[] S_bytes = new byte[length];
                Array.Copy(s, 0, S_bytes, 0, s.Length);
                for (int x = length - fixLength; x < length; x++)
                {
                    S_bytes[x] = 0x00;
                }
                return S_bytes;
            }
            return s;
        }

        public static string CreateValidateNumber(int length)
        {
            int[] randMembers = new int[length];
            int[] validateNums = new int[length];
            System.Text.StringBuilder validateNumberStr = new System.Text.StringBuilder();
            //生成起始序列值
            int seekSeek = unchecked((int)DateTime.Now.Ticks);
            Random seekRand = new Random(seekSeek);
            int beginSeek = (int)seekRand.Next(0, Int32.MaxValue - length * 10000);
            int[] seeks = new int[length];
            for (int i = 0; i < length; i++)
            {
                beginSeek += 10000;
                seeks[i] = beginSeek;
            }
            //生成随机数字
            for (int i = 0; i < length; i++)
            {
                Random rand = new Random(seeks[i]);
                int pownum = 1 * (int)Math.Pow(10, length);
                randMembers[i] = rand.Next(pownum, Int32.MaxValue);
            }
            //抽取随机数字
            for (int i = 0; i < length; i++)
            {
                string numStr = randMembers[i].ToString();
                int numLength = numStr.Length;
                Random rand = new Random();
                int numPosition = rand.Next(0, numLength - 1);
                validateNums[i] = Int32.Parse(numStr.Substring(numPosition, 1));
            }
            //生成验证码
            for (int i = 0; i < length; i++)
            {
                validateNumberStr.Append(validateNums[i].ToString());
            }
            return validateNumberStr.ToString();
        }

        public static byte[] CreateValidateGraphic(string validateNum)
        {
            using (Bitmap image = new Bitmap((int)Math.Ceiling(validateNum.Length * 12.5), 22))
            {
                using (Graphics g = Graphics.FromImage(image))
                {
                    //生成随机生成器
                    Random random = new Random();
                    //清空图片背景色
                    g.Clear(Color.White);
                    //画图片的干扰线
                    for (int i = 0; i < 25; i++)
                    {
                        int x1 = random.Next(image.Width);
                        int x2 = random.Next(image.Width);
                        int y1 = random.Next(image.Height);
                        int y2 = random.Next(image.Height);
                        g.DrawLine(new Pen(Color.Silver), x1, y1, x2, y2);
                    }
                    using (Font font = new Font("Arial", 14, (FontStyle.Bold | FontStyle.Italic)))
                    {
                        using (LinearGradientBrush brush = new LinearGradientBrush(new Rectangle(0, 0, image.Width, image.Height),
                         Color.Blue, Color.DarkRed, 1.2f, true))
                        {
                            g.DrawString(validateNum, font, brush, 3, 2);
                        }
                    }
                    //画图片的前景干扰点
                    for (int i = 0; i < 100; i++)
                    {
                        int x = random.Next(image.Width);
                        int y = random.Next(image.Height);
                        image.SetPixel(x, y, Color.FromArgb(random.Next()));
                    }
                    //画图片的边框线
                    g.DrawRectangle(new Pen(Color.Silver), 0, 0, image.Width - 1, image.Height - 1);
                    //保存图片数据
                    using (MemoryStream stream = new MemoryStream())
                    {
                        image.Save(stream, ImageFormat.Jpeg);
                        return stream.ToArray();
                    }
                }
            }
        }
        /// <summary>
        /// 获取一个随机数组
        /// </summary>
        /// <param name="num">数组个数</param>
        /// <param name="minValue"></param>
        /// <param name="maxValue"></param>
        /// <returns></returns>
        public static int[] GetRandomNum(int num, int minValue, int maxValue)
        {
            Random ra = new Random(unchecked((int)DateTime.Now.Ticks));
            int[] arrNum = new int[num];
            int tmp = 0;
            for (int i = 0; i <= num - 1; i++)
            {
                tmp = ra.Next(minValue, maxValue); //随机取数
                arrNum[i] = tmp;
            }
            return arrNum;
        }

        /// <summary> 
        /// 解决下载名称在IE下中文乱码 
        /// </summary> 
        /// <param name="s"></param> 
        /// <returns></returns> 
        public static String ToUtf8String(String s)
        {
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < s.Length; i++)
            {
                char c = s[i];
                if (c >= 0 && c <= 255)
                {
                    sb.Append(c);
                }
                else
                {
                    byte[] b;
                    try
                    {
                        b = Encoding.UTF8.GetBytes(c.ToString());
                    }
                    catch (Exception)
                    {
                        b = new byte[0];
                    }
                    for (int j = 0; j < b.Length; j++)
                    {
                        int k = b[j];
                        if (k < 0) k += 256;

                        sb.Append("%" + Convert.ToString(k, 16).ToUpper());
                    }
                }
            }
            return sb.ToString();
        }
        /// <summary>
        /// 字节内容转换为字符串
        /// </summary>
        /// <param name="bytesData"></param>
        /// <returns></returns>
        public static string ByteToString(byte[] bytesData)
        {
            StringBuilder result = new StringBuilder();
            foreach (byte r in bytesData)
            {
                result.Append(r.ToString("X2") + " ");
            }
            return result.ToString();
        }
        /// <summary>
        /// 把int32类型的数据转存到2个字节的byte数组中
        /// </summary>
        /// <param name="m">int32类型的数据</param>
        /// <param name="arry">2个字节大小的byte数组</param>
        /// <returns></returns>
        public static byte[] Int32ToByte(Int32 data)
        {
            byte[] arry = new byte[2];
            arry[0] = (byte)((data & 0xFF00) >> 8);
            arry[1] = (byte)(data & 0xFF);
            return arry;
        }
        /// <summary>
        /// 把int32类型的数据转存到2个字节的byte数组中：小端
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        public static byte[] Int32ToByte2(Int32 data)
        {
            byte[] arry = new byte[2];
            arry[0] = (byte)(data & 0xFF);
            arry[1] = (byte)((data & 0xFF00) >> 8);
            //arry[2] = (byte)((data & 0xFF0000) >> 16);
            //arry[3] = (byte)((data >> 24) & 0xFF);

            return arry;
        }
        /// <summary>
        /// 2位byte转换为int类型
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        public static int ByteToInt(byte[] data)
        {
            return (data[1] & 0xFF) << 8 | data[0];
        }
        /// <summary>
        /// 4位byte转换为long类型
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        public static long Byte4ToLong(byte[] data)
        {
            return (data[3] << 24) & 0xFF | (data[2] & 0xFF00) << 16 | (data[1] & 0xFF) << 8 | data[0];
        }
        /// <summary>
        /// long类型转换为4位byte
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        public static byte[] LongToByte4(long data)
        {
            byte[] arry = new byte[4];
            arry[0] = (byte)(data & 0xFF);
            arry[1] = (byte)((data & 0xFF00) >> 8);
            arry[2] = (byte)((data & 0xFF0000) >> 16);
            arry[3] = (byte)((data >> 24) & 0xFF);

            return arry;
        }
        /// <summary> 
        /// 在指定时间过后执行指定的表达式 
        /// </summary> 
        /// <param name="interval">事件之间经过的时间（以毫秒为单位）</param> 
        /// <param name="action">要执行的表达式</param> 
        public static void SetTimeout(double interval, Action action)
        {
            System.Timers.Timer timer = new System.Timers.Timer(interval);
            timer.Elapsed += delegate(object sender, System.Timers.ElapsedEventArgs e)
            {
                timer.Enabled = false;
                action();
            };
            timer.Enabled = true;
        }

        /// <summary>   
        /// 得到字符串的长度，一个汉字算2个字符   
        /// </summary>   
        /// <param name="str">字符串</param>   
        /// <returns>返回字符串长度</returns>   
        public static int GetLength(string str)
        {
            if (str.Length == 0) return 0;

            ASCIIEncoding ascii = new ASCIIEncoding();
            int tempLen = 0;
            byte[] s = ascii.GetBytes(str);
            for (int i = 0; i < s.Length; i++)
            {
                if ((int)s[i] == 63)
                {
                    tempLen += 2;
                }
                else
                {
                    tempLen += 1;
                }
            }
            return tempLen;
        }
        /// <summary>  
        /// 获取枚举描述
        /// </summary>  
        /// <param name="en">枚举</param>  
        /// <returns>返回枚举的描述 </returns>  
        public static string GetDescription(Enum en)
        {
            Type type = en.GetType();//获取类型  
            MemberInfo[] memberInfos = type.GetMember(en.ToString());   //获取成员  
            if (memberInfos != null && memberInfos.Length > 0)
            {
                DescriptionAttribute[] attrs = memberInfos[0].GetCustomAttributes(typeof(DescriptionAttribute), false) as DescriptionAttribute[];   //获取描述特性  
                if (attrs != null && attrs.Length > 0)
                {
                    return attrs[0].Description;    //返回当前描述
                }
            }
            return en.ToString();
        }
        /// <summary>
        /// 显示消息提示对话框，并进行页面跳转
        /// </summary>
        /// <param name="page">当前页面指针，一般为this</param>
        /// <param name="msg">提示信息</param>
        /// <param name="url">跳转的目标URL</param>
        /// <param name="isTop">指定是否为框架内跳转(True表示跳出框架外)</param>
        public static void ShowAndRedirect(System.Web.UI.Page page, string msg, string url, bool isTop)
        {
            StringBuilder sb = new StringBuilder();
            sb.Append("<script language='javascript' defer>");
            sb.AppendFormat("alert('{0}');", msg);
            if (isTop == true)
            {
                sb.AppendFormat("top.location.href='{0}'", url);
            }
            else
            {
                sb.AppendFormat("location.href='{0}'", url);
            }
            sb.Append("</script>");
            page.ClientScript.RegisterStartupScript(page.GetType(), "message" + System.Guid.NewGuid().ToString(), sb.ToString());
        }
        /// <summary>
        /// stream to reader
        /// </summary>
        /// <param name="stream"></param>
        /// <returns></returns>
        public static string StreamToString(Stream stream)
        {
            stream.Position = 0;
            using (StreamReader reader = new StreamReader(stream, Encoding.UTF8))
            {
                return reader.ReadToEnd();
            }
        }
        /// <summary>
        /// HEX编码转换为——>ASCII编码
        /// </summary>
        /// <param name="Msg"></param>
        /// <returns></returns>
        public static string HexToASCII(string Msg)
        {
            byte[] buff = new byte[Msg.Length / 2];
            string Message = "";
            for (int i = 0; i < buff.Length; i++)
            {
                buff[i] = byte.Parse(Msg.Substring(i * 2, 2), System.Globalization.NumberStyles.HexNumber);
            }
            System.Text.Encoding chs = System.Text.Encoding.ASCII;
            Message = chs.GetString(buff);
            return Message;
        }
        /// <summary>
        /// HEX编码转换为——>字符串
        /// </summary>
        /// <param name="Msg"></param>
        /// <returns></returns>
        public static string HexToStr(string Msg)
        {
            byte[] buff = new byte[Msg.Length / 2];
            string Message = "";
            for (int i = 0; i < buff.Length; i++)
            {
                buff[i] = byte.Parse(Msg.Substring(i * 2, 2), System.Globalization.NumberStyles.HexNumber);
            }
            System.Text.Encoding chs = System.Text.Encoding.GetEncoding("gb2312");
            Message = chs.GetString(buff);
            return Message;
        }
        /// <summary>
        /// 字符串转化为——>HEX编码
        /// </summary>
        /// <param name="Msg"></param>
        /// <returns></returns>
        public static string StrToHex(string Msg)
        {
            byte[] bytes = System.Text.Encoding.Default.GetBytes(Msg);//转换为字节（十进制）
            string str = "";
            for (int i = 0; i < bytes.Length; i++)
            {
                str += string.Format("{0:X}", bytes[i]);               //转换为十六进制
            }
            return str;
        }
        /// <summary>
        /// Hex文件解释
        /// </summary>
        /// <param name="filepath"></param>
        public static void HexFileRead(string filepath)//从指定文件目录读取HEX文件并解析，放入缓存数组buffer中
        {
            string szLine;
            int startAdr;
            int endAdr = 0;   //用于判断hex地址是否连续，不连续补充0xFF

            byte[] buffer = new byte[1024 * 1024 * 5]; // 打开文件hex to bin缓存
            int bufferAdr = 0;// 打开文件hex to bin缓存指针，用于计算bin的长度

            if (filepath == "")
            {
                return;
            }

            FileStream fsRead = new FileStream(filepath, FileMode.OpenOrCreate, FileAccess.Read);
            StreamReader HexReader = new StreamReader(fsRead); //读取数据流
            while (true)
            {
                szLine = HexReader.ReadLine(); //读取Hex中一行
                if (szLine == null) { break; } //读取完毕，退出
                if (szLine.Substring(0, 1) == ":") //判断首字符是”:”
                {
                    if (szLine.Substring(1, 8) == "00000001") { break; } //文件结束标识
                    if ((szLine.Substring(8, 1) == "0") || (szLine.Substring(8, 1) == "1"))//直接解析数据类型标识为 : 00 和 01 的格式
                    {
                        int lineLenth;
                        string hexString;

                        hexString = szLine.Substring(1, 2);
                        lineLenth = Int32.Parse(hexString, System.Globalization.NumberStyles.HexNumber); // 获取一行的数据个数值

                        hexString = szLine.Substring(3, 4);
                        startAdr = Int32.Parse(hexString, System.Globalization.NumberStyles.HexNumber); // 获取地址值

                        for (int i = 0; i < startAdr - endAdr; i++) // 补空位置
                        {
                            hexString = "FF";
                            byte value = byte.Parse(hexString, System.Globalization.NumberStyles.HexNumber);
                            buffer[bufferAdr] = value;
                            bufferAdr++;
                        }

                        for (int i = 0; i < lineLenth; i++) // hex转换为byte
                        {
                            hexString = szLine.Substring(i * 2 + 9, 2);
                            byte value = byte.Parse(hexString, System.Globalization.NumberStyles.HexNumber);
                            buffer[bufferAdr] = value;
                            bufferAdr++;
                        }
                        endAdr = startAdr + lineLenth;
                    }
                }
            }
        }
        /// <summary>
        /// 将url参数转成json
        /// </summary>
        /// <param name="urlParams"></param>
        /// <returns></returns>
        public static string UrlParamsToJson(string urlParams)
        {
            var nameValueCollection = HttpUtility.ParseQueryString(urlParams);
            var json = Newtonsoft.Json.JsonConvert.SerializeObject(nameValueCollection.AllKeys.ToDictionary(k => k, k => nameValueCollection[k]));
            return json;
        }
        //public static string GetUrl(string url)
        //{
        //    ComputeSignature();
        //    return "http://"+ url + "/?" +
        //        string.Join("&", _parameters.Select(x => x.Key + "=" + HttpUtility.UrlEncode(x.Value)));
        //}

        public static long GetCurrentTimeStamp(DateTime dt)
        {
            TimeSpan ts = dt - new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Local);
            long current_timestamp = Convert.ToInt64(ts.TotalSeconds);
            return current_timestamp;
        }
        public static DateTime GetCurrentDateTime(long timestampMilliseconds)
        {
            DateTime epoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Local);
            DateTime utcTime = epoch.AddSeconds(timestampMilliseconds);
            return utcTime;
        }

        /// <summary>
        /// 格林尼治时间
        /// </summary>
        /// <returns></returns>
        public static long GetUnixTime()
        {
            DateTime unixEpoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
            long unixTimestampMillisecondsManual = (long)(DateTime.UtcNow - unixEpoch).TotalSeconds;
            return unixTimestampMillisecondsManual;
        }
        public static DateTime GetTimeFromUnixTime(long timestampSeconds)
        {
            // Unix 时间戳的起始时间（1970-01-01 00:00:00 UTC）
            DateTime unixEpoch = new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc);

            // 加上 Unix 时间戳的秒数
            return unixEpoch.AddSeconds(timestampSeconds);
        }


        public static byte CombineBitsToByte(bool bit0, bool bit1, bool bit2, bool bit3)
        {
            byte result = (byte)((bit0 ? 1 : 0) << 3); // 将bit0移到第4位（高位）
            result |= (byte)((bit1 ? 1 : 0) << 2); // 将bit1移到第3位
            result |= (byte)((bit2 ? 1 : 0) << 1); // 将bit2移到第2位
            result |= (byte)(bit3 ? 1 : 0); // 将bit3移到第1位（低位）
            return result;
        }

        /// <summary>
        /// 16进制字符串转换成 字节数组
        /// </summary>
        /// <param name="hexString"></param>
        /// <returns></returns>
        public static byte[] GetBytesFromString(string hexString)
        {
            byte[] bytes = new byte[hexString.Length / 2]; // 计算字节数组的长度
            for (int i = 0; i < bytes.Length; i++)
            {
                bytes[i] = Convert.ToByte(hexString.Substring(i * 2, 2), 16); // 每次取两个字符转换为字节
            }
            return bytes;
        }
        /// <summary>
        /// 替换掉空白字符
        /// </summary>
        /// <param name="originalString"></param>
        /// <returns></returns>
        public static string DeleteSpaceChar(string originalString)
        {
            string result = Regex.Replace(originalString, @"\s", "");
            return result;
        }

        public static short HostNumberToHotelCode(string wer)
        {
            var v1 = wer.Substring(0, 3);
            var v2 = wer.Substring(3, 3);

            byte b12 = byte.Parse(v1);
            byte b13 = byte.Parse(v2);

            byte[] vva1 = new byte[] { b12, b13 };
            var usa = BitConverter.ToInt16(vva1, 0);
            return usa;
        }
    }
}