CommonMethod

共通方法一览：

public static class CommonMethod
    {
        /// <summary>
        /// 64位的MD5加密
        /// </summary>
        /// <param name="password"></param>
        /// <returns></returns>
        public static string MD5Encrypt64(string password)
        {
            string cl = password;
            //string pwd = "";
            MD5 md5 = MD5.Create(); //实例化一个md5对像
                                    // 加密后是一个字节类型的数组，这里要注意编码UTF8/Unicode等的选择　
            byte[] s = md5.ComputeHash(Encoding.UTF8.GetBytes(cl));
            return Convert.ToBase64String(s);
        }

        /// <summary>
        /// MD5加密函数
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public static string GetMD5(string input)
        {
            using (var md5 = MD5.Create())
            {
                var result = md5.ComputeHash(Encoding.UTF8.GetBytes(input));
                var strResult = BitConverter.ToString(result);
                return strResult.Replace("-", "").ToLower();
            }
        }

        public static String GetLink(String model, String action)
        {
            StringBuilder sb = new StringBuilder();
            if (HttpContext.Current.Request.ApplicationPath == "/")
            {

            }
            else
            {
                sb.Append(HttpContext.Current.Request.ApplicationPath);
            }
            if (!String.IsNullOrWhiteSpace(model))
            {
                sb.Append("/");
                sb.Append(model.Trim());
            }
            if (!String.IsNullOrWhiteSpace(action))
            {
                sb.Append("/");
                sb.Append(action.Trim());
            }
            return sb.ToString();
        }

        /// <summary>
        /// 删除文件
        /// </summary>
        /// <param name="sFilePath">文件路径</param>
        public static void DeleteFile(String sFilePath)
        {
            if (System.IO.File.Exists(sFilePath))//判断文件是否存在
            {
                System.IO.File.Delete(sFilePath);//执行IO文件删除,需引入命名空间System.IO;
            }
        }
        /// <summary>
        /// json转为对象
        /// </summary>
        /// <typeparam name="ObjType"></typeparam>
        /// <param name="JsonString"></param>
        /// <returns></returns>
        public static ObjType JsonStringToObj<ObjType>(string JsonString) where ObjType : class
        {
            try
            {
                ObjType s = JsonConvert.DeserializeObject<ObjType>(JsonString);
                return s;
            }
            catch (Exception)
            {
                return null;
            }
        }

        /// <summary>
        /// 对象转为json
        /// </summary>
        /// <typeparam name="ObjType"></typeparam>
        /// <param name="obj"></param>
        /// <returns></returns>
        public static string ObjToJsonString<ObjType>(ObjType obj) where ObjType : class
        {
            string s = JsonConvert.SerializeObject(obj);
            return s;
        }

        /// <summary>
        /// 解析JSON数组生成对象实体集合
        /// </summary>
        /// <typeparam name="T">对象类型</typeparam>
        /// <param name="json">json数组字符串(eg.[{"ID":"112","Name":"石子儿"}])</param>
        /// <returns>对象实体集合</returns>
        public static List<T> DeserializeJsonToList<T>(string json) where T : class
        {
            JsonSerializer serializer = new JsonSerializer();
            StringReader sr = new StringReader(json);
            object o = serializer.Deserialize(new JsonTextReader(sr), typeof(List<T>));
            List<T> list = o as List<T>;
            return list;
        }

        /// <summary>
        /// 判断ip地址是否正确，正确返回true 错误false
        /// </summary>
        /// <param name="strLocalIP">需要判断的字符串(IP地址)</param>
        /// <returns>TRUE OR FALSE</returns>
        public static bool IsRightIP(string strLocalIP)
        {
            bool bFlag = false;
            bool Result = true;


            Regex regex = new Regex("^[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}$");
            bFlag = regex.IsMatch(strLocalIP);
            if (bFlag == true)
            {
                string[] strTemp = strLocalIP.Split(new char[] { '.' });
                int nDotCount = strTemp.Length - 1; //字符串中.的数量，若.的数量小于3，则是非法的ip地址
                if (3 == nDotCount)//判断 .的数量
                {
                    for (int i = 0; i < strTemp.Length; i++)
                    {
                        if (Convert.ToInt32(strTemp[i]) > 255)   //大于255不符合返回false
                        {
                            Result = false;
                        }
                    }
                }
                else
                {
                    Result = false;
                }
            }
            else
            {
                //输入非数字则提示，不符合IP格式
                Result = false;
            }
            return Result;
        }

        /// <summary>
        /// 获取可空数据的数据
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public static Decimal GetValue(Decimal? input)
        {
            if (input == null)
            {
                return 0;
            }
            return input.Value;
        }

        /// <summary>
        /// 从动态类中获取数据
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public static dynamic GetDynamicValue(dynamic obj, String type)
        {
            if (obj[type] == null)
            {
                return "";
            }
            return obj[type].Value;
        }

        /// <summary>
        /// 根据固定长度截取字符串返回数组
        /// </summary>
        /// <param name="str">字符串</param>
        /// <param name="len">数组</param>
        /// <returns></returns>
        public static List<String> GetArrayFromStringByLen(String str, Int32 len)
        {
            List<String> ls = new List<String>();
            for (int iIndex = 0; iIndex < str.Length; iIndex++)
            {
                if (iIndex % len == 0)
                {
                    ls.Add(str.Substring(iIndex, len));
                }
            }
            return ls;
        }

        /// <summary>
        /// 16进制转化位二进制
        /// </summary>
        /// <param name="hex"></param>
        /// <returns></returns>
        public static String HexToBinary(String hex)
        {
            string result = string.Empty;
            foreach (char c in hex)
            {
                int v = Convert.ToInt32(c.ToString(), 16);
                int v2 = int.Parse(Convert.ToString(v, 2));
                // 去掉格式串中的空格，即可去掉每个4位二进制数之间的空格，
                result += string.Format("{0:d4}", v2);
            }
            return result;
        }

        /// <summary>
        /// 二进制转化位十六进制
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        public static String BinaryToHex(String data)
        {
            String result = "";
            result = String.Format("{0:X}", System.Convert.ToInt32(data, 2)).PadLeft(2, '0');
            return result;
        }

        /// <summary>
        /// 去除参数中所有空格
        /// </summary>
        /// <param name="param"></param>
        /// <returns></returns>
        public static String FormatParamter(String param)
        {
            return Regex.Replace(param, @"\s", "");
        }

        /// <summary>
        /// UPS value 转换
        /// </summary>
        /// <param name="strs">Data 数组</param>
        /// <param name="iFromIndex">起始位置</param>
        /// <returns></returns>
        public static Double UPSValueFromData(String[] strs, Int32 iFromIndex, Int32 iLength)
        {
            String str = String.Empty;
            for (Int32 iIndex = 0; iIndex < iLength; iIndex++)
            {
                str += strs[iFromIndex + iIndex];
            }
            // 转为二进制
            String binary = HexToBinary(str);
            Int32 signal = 1;
            if (binary.Substring(0, 1) == "1")
            {
                signal = -1;
            }
            // 二进制转十进制
            // 阶码
            Int32 orderCode = Convert.ToInt32(binary.Substring(1, 8), 2);
            // 尾数
            Int32 mantissa = Convert.ToInt32(binary.Substring(9, binary.Length - 9), 2);
            return signal * (1 + mantissa * Math.Pow(2, -23)) * Math.Pow(2, orderCode - 127);
        }

        /// <summary>
        /// ASCI码转字符
        /// </summary>
        /// <param name="asciiCode"></param>
        /// <returns></returns>
        public static string Chr(string sAsciiCode)
        {
            try
            {
                Int32 asciiCode = Int32.Parse(sAsciiCode);

                if (asciiCode >= 0 && asciiCode <= 255)
                {
                    System.Text.ASCIIEncoding asciiEncoding = new System.Text.ASCIIEncoding();
                    byte[] byteArray = new byte[] { (byte)asciiCode };
                    string strCharacter = asciiEncoding.GetString(byteArray);
                    return (strCharacter);
                }
                else
                {
                    return String.Empty;
                }
            }
            catch (Exception)
            {
                return String.Empty;
            }
        }

        /// <summary>
        /// 字符串倒序
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        public static string ReverseString(string data)
        {
            char[] ret = data.ToCharArray();
            return string.Concat<char>(ret.Reverse<char>());
        }

        /// <summary>
        /// 字符串，删除特殊字符
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public static String StringOperate(String str)
        {
            return str.Replace("-", String.Empty).Replace("_", String.Empty);
        }

        /// <summary>  
        /// 调用api返回json  
        /// </summary>  
        /// <param name="url">api地址</param>  
        /// <param name="param">接收参数</param>
        /// <returns></returns>  
        public static string HttpApiGet(string url, string param)
        {
            Encoding encoding = Encoding.UTF8;
            HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url + "?" + param);//webrequest请求api地址  
            request.Accept = "text/html,application/xhtml+xml,*/*";
            request.ContentType = "application/json";
            request.Method = "GET";
            HttpWebResponse response = (HttpWebResponse)request.GetResponse();
            using (StreamReader reader = new StreamReader(response.GetResponseStream(), Encoding.UTF8))
            {
                return reader.ReadToEnd();
            }
        }

        /// <summary>
        /// 写文件
        /// </summary>
        /// <param name="fileName">文件路径</param>
        /// <param name="content">文件内容</param>
        public static void WriteVersionLog(String fileName, String content)
        {
            if (!Directory.Exists(Path.GetDirectoryName(fileName)))
            {
                Directory.CreateDirectory(Path.GetDirectoryName(fileName));
            }
            // 创建文件
            if (!File.Exists(fileName))
            {
                File.Create(fileName).Close();
            }
            //在将文本写入文件前，处理文本行
            //StreamWriter一个参数默认覆盖
            //StreamWriter第二个参数为false覆盖现有文件，为true则把文本追加到文件末尾
            using (System.IO.StreamWriter file = new System.IO.StreamWriter(fileName, true))
            {
                file.WriteLine(content);// 直接追加文件末尾，换行
            }
        }

        /// <summary>
        /// 删除文件夹以及文件
        /// </summary>
        /// <param name="directoryPath"> 文件夹路径 </param>
        /// <param name="fileName"> 文件名称 </param>
        public static void DeleteDirectory(string directoryPath, string fileName)
        {
            if (Directory.Exists(directoryPath))
            {
                //删除文件
                for (int i = 0; i < Directory.GetFiles(directoryPath).ToList().Count; i++)
                {
                    if (Directory.GetFiles(directoryPath)[i] == fileName)
                    {
                        File.Delete(fileName);
                    }
                }

                //删除文件夹
                for (int i = 0; i < Directory.GetDirectories(directoryPath).ToList().Count; i++)
                {
                    if (Directory.GetDirectories(directoryPath)[i] == fileName)
                    {
                        Directory.Delete(fileName, true);
                    }
                }
            }
        }

        /// <summary>
        /// 获取Domain数据
        /// </summary>
        /// <param name="domain"></param>
        /// <param name="request"></param>
        /// <returns></returns>
        public static dynamic GetDomain(dynamic domain, HttpRequest request)
        {
            Type t = domain.GetType();
            PropertyInfo[] propertys = t.GetProperties();
            foreach (PropertyInfo pro in propertys)
            {
                if (HttpContext.Current.Request.Form[pro.Name] == null)
                {
                    continue;
                }
                String value = HttpContext.Current.Request.Form[pro.Name];
                if (pro.PropertyType == typeof(System.String))
                {
                    pro.SetValue(domain, value, null);
                }
                else if (pro.PropertyType == typeof(System.Int32) || pro.PropertyType == typeof(System.Int32?))
                {
                    if (!String.IsNullOrEmpty(value))
                    {
                        pro.SetValue(domain, Int32.Parse(value), null);
                    }
                }
                else if (pro.PropertyType == typeof(System.Decimal) || pro.PropertyType == typeof(System.Decimal?))
                {
                    if (!String.IsNullOrEmpty(value))
                    {
                        pro.SetValue(domain, Decimal.Parse(value), null);
                    }
                }
                else if (pro.PropertyType == typeof(System.DateTime) || pro.PropertyType == typeof(System.DateTime?))
                {
                    if (!String.IsNullOrEmpty(value) && !"null".Equals(value) && !"undefined".Equals(value))
                    {
                        pro.SetValue(domain, DateTime.Parse(value), null);
                    }
                }
            }
            return domain;
        }

        /// <summary>
        /// 获取字符串
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public static String GetString(String str)
        {
            return new string(str.Where(c => Char.IsLetterOrDigit(c)).ToArray());
        }
    }