构建一个.net的干货类库，以便于快速的开发

　　相信每一个开发的框架都会有一个工具类，工具类的作用有很多，通常我会将最常用的方法放在工具类里

1. 取得用户IP
2. 取得网站根目录的物理路径
3. 枚举相关
4. 非法关键字检查
5. 绝对路径改为相对路径
6. 获取小数位（四舍五入 ，保留小数）
7. 生成缩略图

　　当然每个开发框架的工具类都会不同，这里我只收录了这些方法，希望有更多需求的小伙伴也可以收录进工具类里

　　

　　1.取得用户IP

　　做Web开发的一定会遇到获取用户IP的需求的，无论是用来记录登录时间，还是日志的记录，都要用到IP这个东西，而IP的记录一直是程序员开发的难题，因为这个IP是可以改的，也可以代理，所以在一定程度上会有偏差（IP这东西没用百分百的正确，如果有心不想让你知道的话总有办法不让你知道），所以这个方法只是说比较精确的一个获取IP的方法。

 /// <summary>
        /// 取得用户IP
        /// </summary>
        /// <returns></returns>
        public static string GetAddressIP()
        {
            ///获取本地的IP地址
            string AddressIP = string.Empty;
            if (System.Web.HttpContext.Current.Request.ServerVariables["HTTP_VIA"] != null) 
            {
                AddressIP = System.Web.HttpContext.Current.Request.ServerVariables["HTTP_X_FORWARDED_FOR"].ToString(); 
            }
            else 
            {
                AddressIP = System.Web.HttpContext.Current.Request.ServerVariables["REMOTE_ADDR"].ToString();  
            }
            return AddressIP;
        }

　　

　　2.取得网站根目录的物理路径

　　

/// <summary>
        /// 取得网站根目录的物理路径
        /// </summary>
        /// <returns></returns>
        public static string GetRootPath()
        {
            string AppPath = "";
            HttpContext HttpCurrent = HttpContext.Current;
            if (HttpCurrent != null)
            {
                AppPath = HttpCurrent.Server.MapPath("~");
            }
            else
            {
                AppPath = AppDomain.CurrentDomain.BaseDirectory;
                if (Regex.Match(AppPath, @"\$", RegexOptions.Compiled).Success)
                    AppPath = AppPath.Substring(0, AppPath.Length - 1);
            }
            return AppPath;
        }

　　

　　3.枚举相关

　　枚举在开发中的使用也是非常频繁的，毕竟枚举能够使代码更加清晰，也提高了代码的维护性，所以枚举相关的方法就显得很是实用。

/// <summary>
        /// 获取枚举列表
        /// </summary>
        /// <param name="enumType">枚举的类型</param>
        /// <returns>枚举列表</returns>
        public static Dictionary<int, string> GetEnumList(Type enumType)
        {
            Dictionary<int, string> dic = new Dictionary<int, string>();
            FieldInfo[] fd = enumType.GetFields();
            for (int index = 1; index < fd.Length; ++index)
            {
                FieldInfo info = fd[index];
                object fieldValue = Enum.Parse(enumType, fd[index].Name);
                object[] attrs = info.GetCustomAttributes(typeof(EnumTextAttribute), false);
                foreach (EnumTextAttribute attr in attrs)
                {
                    int key = (int)fieldValue;
                    if (key != -100)//-100为NULL项
                    {
                        string value = attr.Text;
                        dic.Add(key, value);
                    }
                }
            }
            return dic;
        }

        /// <summary>
        /// 获取枚举名称
        /// </summary>
        /// <param name="enumType">枚举的类型</param>
        /// <param name="id">枚举值</param>
        /// <returns>如果枚举值存在，返回对应的枚举名称，否则，返回空字符</returns>
        public static string GetEnumTextById(Type enumType, int id)
        {
            string ret = "";
            Dictionary<int, string> dic = GetEnumList(enumType);
            foreach (var item in dic)
            {
                if (item.Key == id)
                {
                    ret = item.Value;
                    break;
                }
            }

            return ret;
        }

        /// <summary>
        /// 根据枚举值获取对应中文描述
        /// </summary>
        /// <param name="enumValue">枚举值</param>
        /// <returns>枚举值中文描述</returns>
        public static string GetEnumTextByEnum(object enumValue)
        {
            string ret = "";
            if ((int)enumValue != -1)
            {
                Dictionary<int, string> dic = GetEnumList(enumValue.GetType());
                foreach (var item in dic)
                {
                    if (item.Key == (int)enumValue)
                    {
                        ret = item.Value;
                        break;
                    }
                }
            }

            return ret;
        }



        /// <summary>
        /// 获取枚举名称
        /// </summary>
        /// <param name="enumType">枚举的类型</param>
        /// <param name="index">枚举值的位置编号</param>
        /// <returns>如果枚举值存在，返回对应的枚举名称，否则，返回空字符</returns>
        public static string GetEnumTextByIndex(Type enumType, int index)
        {
            string ret = "";

            Dictionary<int, string> dic = GetEnumList(enumType);

            if (index < 0 ||
                index > dic.Count)
                return ret;

            int i = 0;
            foreach (var item in dic)
            {
                if (i == index)
                {
                    ret = item.Value;
                    break;
                }
                i++;
            }

            return ret;
        }

        /// <summary>
        /// 获取枚举值
        /// </summary>
        /// <param name="enumType">枚举的类型</param>
        /// <param name="name">枚举名称</param>
        /// <returns>如果枚举名称存在，返回对应的枚举值，否则，返回-1</returns>
        public static int GetEnumIdByName(Type enumType, string name)
        {
            int ret = -1;

            if (string.IsNullOrEmpty(name))
                return ret;

            Dictionary<int, string> dic = GetEnumList(enumType);
            foreach (var item in dic)
            {
                if (item.Value.CompareTo(name) == 0)
                {
                    ret = item.Key;
                    break;
                }
            }

            return ret;
        }

        /// <summary>
        /// 获取名字对应枚举值
        /// </summary>
        /// <typeparam name="T">枚举类型</typeparam>
        /// <param name="name">枚举名称</param>
        /// <returns></returns>
        public static T GetEnumIdByName<T>(string name) where T : new()
        {
            Type type = typeof(T);
            T enumItem = new T();
            enumItem = (T)TypeDescriptor.GetConverter(type).ConvertFrom("-1");
            if (string.IsNullOrEmpty(name))
                return enumItem;
            FieldInfo[] fd = typeof(T).GetFields();
            for (int index = 1; index < fd.Length; ++index)
            {
                FieldInfo info = fd[index];
                object fieldValue = Enum.Parse(type, fd[index].Name);
                object[] attrs = info.GetCustomAttributes(typeof(EnumTextAttribute), false);
                if (attrs.Length == 1)
                {
                    EnumTextAttribute attr = (EnumTextAttribute)attrs[0];
                    if (name.Equals(attr.Text))
                    {
                        enumItem = (T)fieldValue;
                        break;
                    }
                }
            }
            return enumItem;
        }


        /// <summary>
        /// 获取枚举值所在的位置编号
        /// </summary>
        /// <param name="enumType">枚举的类型</param>
        /// <param name="name">枚举名称</param>
        /// <returns>如果枚举名称存在，返回对应的枚举值的位置编号，否则，返回-1</returns>
        public static int GetEnumIndexByName(Type enumType, string name)
        {
            int ret = -1;

            if (string.IsNullOrEmpty(name))
                return ret;

            Dictionary<int, string> dic = GetEnumList(enumType);
            int i = 0;
            foreach (var item in dic)
            {
                if (item.Value.CompareTo(name) == 0)
                {
                    ret = i;
                    break;
                }
                i++;
            }

            return ret;
        }

　　4.非法关键字检查

　　非法关键字检查在很多网站上也有用到，这里我收录的方法并不是最好的，但也能满足一般的需求，我觉得最好是用一个文件来保存字库去维护是最好的，有需求的小伙伴可以去搜索一下。

　　

/// <summary>
        /// 非法关键字检查
        /// </summary>
        /// <param name="Emtxt">要检查的字符串</param>
        /// <returns>如果字符串里没有非法关键字，返回true，否则，返回false</returns>
        public static bool CheckWord(string Emtxt)
        {
            string keyword = @"";//因为论坛也有关键字检查所以这里的字库就小伙伴们自己去找^_^
            Regex regex = new Regex(keyword, RegexOptions.IgnoreCase);
            if (regex.IsMatch(Emtxt))
            {
                return false;
            }
            return true;
        }

        /// <summary>
        /// SQL注入关键字过滤
        /// </summary>
        private const string StrKeyWord = @"^s*select | select |^s*insert | insert |^s*delete | delete |^s*from | from |^s*declare | declare |^s*exec | exec | count(|drop table|^s*update | update |^s*truncate | truncate |asc(|mid(|char(|xp_cmdshell|^s*master| master |exec master|netlocalgroup administrators|net user|""|^s*or | or |^s*and | and |^s*null | null ";

        /// <summary>
        /// 关键字过滤
        /// </summary>
        /// <param name="_sWord"></param>
        /// <returns></returns>
        public static string ResplaceSql(string _sWord)
        {
            if (!string.IsNullOrEmpty(_sWord))
            {
                Regex regex = new Regex(StrKeyWord, RegexOptions.IgnoreCase);
                _sWord = regex.Replace(_sWord, "");
                _sWord = _sWord.Replace("'", "''");
                return _sWord;
            }
            else
            {
                return "";
            }
        }

　　5.绝对路径改为相对路径

　　这个方法相对于前面的使用率并不是很高，在特定的情况下这个方法还是很有用的

/// <summary>
        /// 绝对路径改为相对路径
        /// </summary>
        /// <param name="relativeTo"></param>
        /// <returns></returns>
        public static string RelativePath(string relativeTo)
        {
            string absolutePath = GetRootPath();
            string[] absoluteDirectories = absolutePath.Split('\');
            string[] relativeDirectories = relativeTo.Split('\');

            //获得这两条路径中最短的
            int length = absoluteDirectories.Length < relativeDirectories.Length ? absoluteDirectories.Length : relativeDirectories.Length;

            //用于确定退出的循环中的地方
            int lastCommonRoot = -1;
            int index;

            //找到共同的根目录
            for (index = 0; index < length; index++)
                if (absoluteDirectories[index] == relativeDirectories[index])
                    lastCommonRoot = index;
                else
                    break;

            //如果我们没有找到一个共同的前缀，然后抛出
            if (lastCommonRoot == -1)
                throw new ArgumentException("Paths do not have a common base");

            //建立相对路径
            StringBuilder relativePath = new StringBuilder();

            //加上 ..
            for (index = lastCommonRoot + 1; index < absoluteDirectories.Length; index++)
                if (absoluteDirectories[index].Length > 0)
                    relativePath.Append("..\");

            //添加文件夹
            for (index = lastCommonRoot + 1; index < relativeDirectories.Length - 1; index++)
                relativePath.Append(relativeDirectories[index] + "\");
            relativePath.Append(relativeDirectories[relativeDirectories.Length - 1]);

            return relativePath.ToString();
        }

　　6.获取小数位（四舍五入 ，保留小数）

　　在日常处理数字相关的时候经常会用到的方法

       /// <summary>
        /// 四舍五入，保留2位小数
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public static decimal Rounding(decimal obj)
        {
            return Rounding(obj, 2);
        }
        /// <summary>
        /// 四舍五入，保留n位小数
        /// </summary>
        /// <param name="obj"></param>
        /// <param name="len">保留几位小数</param>
        /// <returns></returns>
        public static decimal Rounding(decimal obj, int len)
        {
            return Math.Round(obj, len, MidpointRounding.AwayFromZero);
        }

        /// <summary>
        /// 只舍不入，保留2位小数
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public static decimal RoundingMin(decimal obj)
        {
            return RoundingMin(obj, 2);
        }

        /// <summary>
        /// 只舍不入，保留n位小数
        /// </summary>
        /// <param name="obj"></param>
        /// <param name="len"></param>
        /// <returns></returns>
        public static decimal RoundingMin(decimal obj, int len)
        {
            var str = "0." + "".PadLeft(len, '0') + "5";
            decimal dec = Convert.ToDecimal(str);
            return Rounding(obj - dec, len);
        }


        /// <summary>
        /// 只舍不入，保留2位小数
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public static decimal RoundingMax(decimal obj)
        {
            return RoundingMax(obj, 2);
        }

        /// <summary>
        /// 只舍不入，保留n位小数
        /// </summary>
        /// <param name="obj"></param>
        /// <param name="len"></param>
        /// <returns></returns>
        public static decimal RoundingMax(decimal obj, int len)
        {
            var str = "0." + "".PadLeft(len, '0') + "4";
            decimal dec = Convert.ToDecimal(str);
            return Rounding(obj + dec, len);
        }

　　7.生成缩略图

　　对于Web的开发来说，网站的空间是非常有限的，所以压缩图片就使得尤为重要。一张高清的图片对于网站的带宽来说是奢侈的，而且也占据非常大的空间，所以上传图片的时候经过一定的压缩对网站的各方面都会有更好的效果。

/// <summary>  
        /// 生成缩略图  
        /// </summary>  
        /// <param name="sourceFile">原始图片文件</param>  
        /// <param name="quality">质量压缩比</param>  
        /// <param name="multiple">收缩倍数</param>  
        /// <param name="outputFile">输出文件名</param> 
        /// <returns>成功返回true,失败则返回false</returns>  
        public static bool ThumImage(string sourceFile, long quality, int multiple, string outputFile)
        {
            try
            {
                long imageQuality = quality;
                Bitmap sourceImage = new Bitmap(sourceFile);
                ImageCodecInfo myImageCodecInfo = GetEncoderInfo("image/jpeg");
                System.Drawing.Imaging.Encoder myEncoder = System.Drawing.Imaging.Encoder.Quality;
                EncoderParameters myEncoderParameters = new EncoderParameters(1);
                EncoderParameter myEncoderParameter = new EncoderParameter(myEncoder, imageQuality);
                myEncoderParameters.Param[0] = myEncoderParameter;
                float xWidth = sourceImage.Width;
                float yWidth = sourceImage.Height;
                Bitmap newImage = new Bitmap((int)(xWidth / multiple), (int)(yWidth / multiple));
                Graphics g = Graphics.FromImage(newImage);

                g.DrawImage(sourceImage, 0, 0, xWidth / multiple, yWidth / multiple);
                g.Dispose();
                newImage.Save(outputFile, myImageCodecInfo, myEncoderParameters);
                sourceImage.Dispose();
                System.IO.File.Delete(sourceFile);
                return true;
            }
            catch (Exception e)
            {
                return false;
            }

        }

        /// <summary>  
        /// 获取图片编码信息  
        /// </summary>  
        private static ImageCodecInfo GetEncoderInfo(String mimeType)
        {
            int j;
            ImageCodecInfo[] encoders;
            encoders = ImageCodecInfo.GetImageEncoders();
            for (j = 0; j < encoders.Length; ++j)
            {
                if (encoders[j].MimeType == mimeType)
                    return encoders[j];
            }
            return null;
        }