Utility 公用使用代码收集

最新推荐文章于 2022-08-28 15:32:20 发布

Jeffery-Lee

最新推荐文章于 2022-08-28 15:32:20 发布

阅读量998

点赞数

CC 4.0 BY-SA版权

分类专栏： Asp.Net 文章标签： string random null encoding 加密 url

本文链接：https://blog.youkuaiyun.com/jayfery/article/details/6932285

Asp.Net 专栏收录该内容

12 篇文章

订阅专栏

本文探讨了代码之美的核心要素——规范、通用性和开闭原则，并通过实例展示了如何实现HTML标签过滤、精确截取字符串、数据类型转换封装、URL响应获取、页面编码获取和随机生成字母等功能，旨在提升代码质量和可维护性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

备注：代码之美源于它的规范，通用，开闭...

    /// <summary>
    /// 过滤所有HTML 标签
    /// </summary>
    /// <param name="htm">需要被过滤的字符</param>
    /// <returns></returns>
    public static string FilterHtml(string htm)
    {
        string str1 = htm;
        str1 = Regex.Replace(str1, @"<(.|\n)+?>", "");//例如<a>
        return str1;
    }

/// <summary>
    /// 精确截取字符串(一个中文=2个英文)
    /// </summary>
    /// <param name="sText">被处理字符串</param>
    /// <param name="iLength">所需字符长度</param>
    /// <param name="mark">特殊尾符处理</param>
    /// <returns></returns>
    public string GetString(string sText, int iLength, bool mark)
    {
        if (iLength < 1) return sText;
        if (sText==null || string.Empty == sText) return "";
        byte[] b = System.Text.Encoding.Default.GetBytes(sText);
        double n = 0.0;
        int m = 0;
        bool is0 = false, is1 = false, is2 = false;//is0-中文；is1-中间量；is2表示最后是中文与否
        for (int i = 0; i < b.Length; i++)
        {
            is0 = ((int)b[i] > 128);
            if (is0) i++;
            n += (is0 ? 1.0 : 0.5);
            if (n > iLength)
            {
                string strOut = (is2 ? sText.Substring(0, m - 1) : sText.Substring(0, m - 2));
                if (System.Text.Encoding.GetEncoding("GB2312").GetByteCount(strOut) + 2 > iLength * 2)

{

//长度超出

strOut = strOut.Substring(0, strOut.Length - 1);

               {
                if (mark)
                    return strOut + "..";
                else
                    return strOut;
            }
            m++;
            is2 = is1;
            is1 = is0;
        }
        return sText;
    }

#region 数据类型转换封装

   /// <summary>
    /// 将任何对象转换数据为int型
    /// 1、可以防止转换时抛异常
    /// </summary>
    /// <typeparam name="T">泛型类(即传进来是啥类就指定为啥类型)</typeparam>
    /// <param name="source"></param>
    /// <returns></returns>
    public static int ConvertObjectToInt32<T>(T source)
    {
        int result;

        if (source == null)
        {
            return 0;
        }
        else if (int.TryParse(String.Format("{0:f0}", source), out result))
        {
            return result;
        }
        else
        {
            return 0;
        }
    }

/// <summary>
    /// 转换数据为int?型(int 可为空)
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="source"></param>
    /// <returns></returns>
    public static int? ConvertObjectToInt<T>(T source)
    {
        int result;

        if (source == null)
        {
            return null;
        }
        else if (int.TryParse(source.ToString(), out result))
        {
            return result;
        }
        else
        {
            return null;
        }
    }

    /// <summary>
        /// 转换数据为Double类型
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="source"></param>
        /// <returns></returns>
        public static Double ConvertObjectToDouble<T>(T source)
        {
            Double result;
            if (source == null)
            {
                return 0.0;
            }
            else if (Double.TryParse(source.ToString(), out result))
            {
                return result;
            }
            else
            {
                return 0.0;
            }
        }

     /// <summary>
        /// 转换数据为decimal型
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="source"></param>
        /// <returns></returns>
        public static decimal ConvertObjectToDecimalSingle<T>(T source)
        {
            decimal? result = ConvertObjectToDecimal(source);

            if (result != null)
            {
                return result.Value;
            }
            else
            {
                return 0M;
            }
        }

     /// <summary>
        /// 转换数据为DateTime类型
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="source"></param>
        /// <returns></returns>
        public static DateTime ConvertDateTime<T>(T source)
        {
            DateTime result;

            if (source == null)
            {
                return default(DateTime);
            }
            else if (DateTime.TryParse(source.ToString(), out result))
            {
                return result;
            }
            else
            {
                return default(DateTime);
            }
        }

    /// <summary>
        /// 转换数据为bool类型
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="source"></param>
        /// <returns></returns>
        public static bool ConvertToBool<T>(T source)
        {
            bool result;

            if (source == null)
            {
                return false;
            }
            if (source.ToString().ToUpper().Equals("T"))
            {
                return true;
            }
            if (source.ToString().ToUpper().Equals("F"))
            {
                return false;
            }
            if (Boolean.TryParse(source.ToString().ToLower(), out result))
            {
                return result;
            }
            else
            {
                return false;
            }
        }

   /// <summary>
        /// 转换数据为string类型
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="source"></param>
        /// <returns></returns>
        public static String ConvertObjectToString<T>(T source)
        {
            return source == null ? String.Empty : source.ToString();
        }

#endregion 数据类型转换封装

  /// <summary>
    /// 获取编码格式
    /// </summary>
    /// <param name="characterSet">编码格式字符</param>
    /// <returns></returns>
    public static Encoding GetEncoding(string characterSet)
    {
        string charset = characterSet;
        if (charset == "ISO-8859-1")
            charset = "gb2312";
        if (charset != "" && charset != "text/html")
            return Encoding.GetEncoding(charset);
        else
            return System.Text.Encoding.Default;
    }

/// <summary>
    /// 获取url响应对象response
    /// </summary>
    /// <param name="url">请求的url 地址</param>
    /// <returns></returns>
    public static HttpWebResponse GetHttpWebResponse(string url)
    {
        Regex gex = new Regex(@"^http://\s*", RegexOptions.IgnoreCase);
        if (gex.IsMatch(url))
        {
            try
            {
                HttpWebResponse response = (HttpWebResponse)HttpWebRequest.Create(url).GetResponse();
                return response;
            }
            catch (Exception)
            {

            }
        }
        return null;
    }

    /// <summary>
    /// 根据链接地址得到整个页面编码的html
    /// </summary>
    /// <param name="url">链接地址</param>
    /// <returns>整个页面编码的html</returns>
    public static string HtmltoString(string url)
    {
        HttpWebResponse respose = GetHttpWebResponse(url);
        if (respose != null)
        {
            string contenttype = respose.Headers["Content-Type"];
            string encode = string.Empty; ;
            if (contenttype != "")
            {
                encode = contenttype.Substring(contenttype.LastIndexOf("=") + 1);
            }
            Encoding encoding = GetEncoding(encode);
            using (StreamReader sr = new StreamReader(respose.GetResponseStream(), encoding))
            {
                return sr.ReadToEnd();
            }

        }
        else
            return "";
    }

   /// <summary>
    /// 随机生成字母(尽量避免生产几个一样的随机数)
    /// </summary>
    /// <param name="VcodeNum">生成字母的个数</param>
    /// <returns>string</returns>
    public static string RndNum(int VcodeNum)
    {
        string Vchar = "0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z";
        string[] VcArray = Vchar.Split(',');
        StringBuilder VNum = new StringBuilder();
        int temp = -1; //记录上次随机数值，
        //采用一个简单的算法以保证生成随机数的不同
        Random rand = new Random();
        for (int i = 1; i < VcodeNum + 1; i++)
        {
            if (temp != -1)
            {
                rand = new Random(i * temp * unchecked((int)DateTime.Now.Ticks));
            }
            int t = rand.Next(VcArray.Length);
            if (temp != -1 && temp == t)
            {
                return RndNum(VcodeNum);
            }
            temp = t;
            VNum.Append(VcArray[t]);
        }
        return VNum.ToString();
    }

    /// <summary>
    /// 随机生成不同的字母
    /// </summary>
    /// <param name="VcodeNum">生成字母的个数</param>
    /// <returns>string</returns>
    public static string RndDiffNum(int VcodeNum)
    {
        string Vchar = "0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z";//参考字符
        string[] VcArray = Vchar.Split(',');
        StringBuilder VNum = new StringBuilder();
        int temp = -1; //记录上次随机数值，避免生产相同随机数

        //采用一个简单的算法(填补)
        Random rand = new Random();
        for (int i = 1; i < VcodeNum + 1; i++)
        {

            int t = rand.Next(VcArray.Length-i);
            temp = t;
            VNum.Append(VcArray[t]);
            //以最后一位去填补已经被选择的位置(即上次的位置的内容会被踢出)
            VcArray[t]=VcArray[VcArray.Length-i];
        }
        return VNum.ToString();
    }

/// <summary>
    /// 对称加密(加密字符串)
    /// </summary>
    /// <param name="oldString">被加密的字符串</param>
    /// <param name="key">密钥</param>
    /// <returns>密文</returns>
    public static string StrEncode(string oldString, string key)
    {
        if (string.IsNullOrEmpty(oldString))
            return string.Empty;
        //初始化随机数序列
        StringBuilder getValue = new StringBuilder();
        Random rand = new Random(key.GetHashCode());
        //将随机数与原始字符进行异或操作
        foreach (char c in oldString.ToCharArray())
        {
            getValue.Append(string.Format("{0:000}", c ^ rand.Next(256)));
        }
        return getValue.ToString();
    }
    /// <summary>
    /// 对称加密(解密字符串)
    /// </summary>
    /// <param name="oldString">被解密的字符串</param>
    /// <param name="key">密钥</param>
    /// <returns>原文</returns>
    public static string StrDecode(string oldString, string key)
    {
        if (string.IsNullOrEmpty(oldString))
            return string.Empty;
        //初始化随机数序列
        StringBuilder getValue = new StringBuilder();
        Random rand = new Random(key.GetHashCode());
        //将随机数与原始字符进行异或操作
        for (int i = 0; i < oldString.Length; i += 3)
        {
            char c = Convert.ToChar(Convert.ToInt32(oldString.Substring(i, 3)));
            getValue.Append(Convert.ToChar(c ^ rand.Next(256)));
        }
        return getValue.ToString();
    }

       /// <summary>
    /// 字符编码成HEX
    /// </summary>
    /// <param name="dataCoding">编码格式</param>

/// <param name="realStr">被加密的字符串</param>

/// <returns>加密后的字符串</returns>
        private string encodeHexStr(int dataCoding, string realStr)
        {
            string strhex = "";
            try
            {
                Byte[] bytSource = null;
                if (dataCoding == 15)
                {
                    bytSource = Encoding.GetEncoding("GBK").GetBytes(realStr);
                }
                else if (dataCoding == 8)
                {
                    bytSource = Encoding.BigEndianUnicode.GetBytes(realStr);
                }
                else
                {
                    bytSource = Encoding.ASCII.GetBytes(realStr);
                }
                for (int i = 0; i < bytSource.Length; i++)
                {
                    strhex = strhex + bytSource[i].ToString("X2");

                }
            }
            catch (System.Exception err)
            {
                WriteErrLog(err.ToString());
            }
            return strhex;
        }
        //

       /// <summary>
    /// hex编码还原成字符
    /// </summary>
    /// <param name="dataCoding">编码格式</param>

/// <param name="realStr">被解密的字符串</param>

/// <returns>原来的字符串</returns>

        private string decodeHexStr(int dataCoding, String hexStr)
        {
            string strReturn = "";
            try
            {
                int len = hexStr.Length / 2;
                byte[] bytSrc = new byte[len];
                for (int i = 0; i < len; i++)
                {
                    string s = hexStr.Substring(i * 2, 2);
                    bytSrc[i] = Byte.Parse(s, System.Globalization.NumberStyles.AllowHexSpecifier);
                }

                if (dataCoding == 15)
                {
                    strReturn = Encoding.GetEncoding("GBK").GetString(bytSrc);
                }
                else if (dataCoding == 8)
                {
                    strReturn = Encoding.BigEndianUnicode.GetString(bytSrc);
                }
                else
                {
                    strReturn = System.Text.ASCIIEncoding.ASCII.GetString(bytSrc);
                }
            }
            catch (System.Exception err)
            {
                WriteErrLog(err.ToString());

            }
            return strReturn;
        }

------《待续2011-11-8》-------