扩展了一些String常用的方法.

using System;
using System.Diagnostics;
using System.Security.Cryptography;
using System.Text;
using System.Text.RegularExpressions;

namespace Taolx.JuneAir.Common.Extensions
{

    /// <summary>
    /// String 扩展类
    /// </summary>
    public static class StringExtension
    {
        private static readonly Regex WebUrlExpression = new Regex(@"(http|https)://([\w-]+\.)+[\w-]+(/[\w- ./?%&=]*)?", RegexOptions.Singleline | RegexOptions.Compiled);
        private static readonly Regex EmailExpression = new Regex(@"^([0-9a-zA-Z]+[-._+&])*[0-9a-zA-Z]+@([-0-9a-zA-Z]+[.])+[a-zA-Z]{2,6}$", RegexOptions.Singleline | RegexOptions.Compiled);
        private static readonly Regex StripHTMLExpression = new Regex("<\\S[^><]*>", RegexOptions.IgnoreCase | RegexOptions.Singleline | RegexOptions.Multiline | RegexOptions.CultureInvariant | RegexOptions.Compiled);
        private static readonly char[] IllegalUrlCharacters = new[] { ';', '/', '\\', '?', ':', '@', '&', '=', '+', '$', ',', '<', '>', '#', '%', '.', '!', '*', '\'', '"', '(', ')', '[', ']', '{', '}', '|', '^', '`', '~', '–', '‘', '’', '“', '”', '»', '«' };
        /// <summary>
        /// 默认密钥-密钥的长度必须是32
        /// </summary>
        private const string PublicKey = "1qaz2wsx3edc4rfv";

        /// <summary>
        /// 默认向量
        /// </summary>
        private const string Iv = "abcdefghijklmnop";

        /// <summary>
        /// 为空或者""
        /// </summary>
        /// <param name="source"></param>
        /// <returns></returns>
        public static bool IsNullOrEmpty(this string source)
        {
            return string.IsNullOrEmpty(source);
        }

        /// <summary>
        /// ToTrim
        /// </summary>
        /// <param name="source"></param>
        /// <param name="defalutVal"></param>
        /// <returns></returns>
        public static string ToTrim(this string source, string defalutVal = "")
        {
            return (source ?? defalutVal).Trim();
        }

        /// <summary>
        /// string类型日期转换成datetiem类型
        /// </summary>
        /// <param name="str"></param>
        /// <returns>转换失败返回null</returns>
        public static DateTime? ToNullbaleDateTime(this string str)
        {
            if (string.IsNullOrEmpty(str))
                return null;
            DateTime dateTime;
            return DateTime.TryParse(str, out dateTime) ? dateTime : (DateTime?)null;
        }

        /// <summary>
        /// 将当前字符串从指定索引位置将指定长度的字符替换为新字符
        /// </summary>
        /// <param name="oldStr">当前字符串</param>
        /// <param name="index">替换起始索引位置</param>
        /// <param name="length">指定长度</param>
        /// <param name="newChar">替换的字符</param>
        /// <returns></returns>
        public static string ReplaceStr(this string oldStr, int index, int length, char newChar = '*')
        {
            if (oldStr == null)
                return "";
            if (index < )
                index = ;
            if (length > oldStr.Length)
                length = oldStr.Length;
            string keepStr = oldStr.Substring(length - index, oldStr.Length - length);
            return keepStr.PadLeft(oldStr.Length, newChar);
        }

        /// <summary>
        /// 获取32位长度的Md5摘要
        /// </summary>
        /// <param name="input"></param>
        /// <param name="encoding"></param>
        /// <returns></returns>
        public static string Get32Md5(this string input, Encoding encoding = null)
        {
            if (encoding == null) encoding = Encoding.UTF8;
            StringBuilder buff = new StringBuilder();
            MD5 md5 = new MD5CryptoServiceProvider();
            byte[] t = md5.ComputeHash(encoding.GetBytes(input));
            foreach (byte t1 in t)
                buff.Append(t1.ToString("x").PadLeft(, ''));
            return buff.ToString();
        }

        /// <summary>
        /// md5去掉"-"转成string
        /// </summary>
        public static string ToMD5(this string str)
        {
            //return System.Security.Cryptography.MD5.Create(str).ToString();
            //return FormsAuthentication.HashPasswordForStoringInConfigFile(str, "MD5");

            //System.Security.Cryptography.MD5 md55 = new System.Security.Cryptography.MD5CryptoServiceProvider();

            if (string.IsNullOrEmpty(str)) return str;
            System.Security.Cryptography.MD5 md5 = System.Security.Cryptography.MD5.Create();
            string encoded = BitConverter.ToString(md5.ComputeHash(Encoding.UTF8.GetBytes(str))).Replace("-", "");
            return encoded.ToLower();
        }

        /// <summary>
        /// 是否为WebUrl地址
        /// </summary>
        /// <param name="target"></param>
        /// <returns></returns>
        public static bool IsWebUrl(this string target)
        {
            return !string.IsNullOrEmpty(target) && WebUrlExpression.IsMatch(target);
        }

        /// <summary>
        /// 是否为Email地址
        /// </summary>
        /// <param name="target"></param>
        /// <returns></returns>
        public static bool IsEmail(this string target)
        {
            return !string.IsNullOrEmpty(target) && EmailExpression.IsMatch(target);
        }

        /// <summary>
        /// string转Guid
        /// </summary>
        /// <param name="target"></param>
        /// <returns></returns>
        public static Guid ToGuid(this string target)
        {
            Guid result = Guid.Empty;

            if ((!string.IsNullOrEmpty(target)) && (target.Trim().Length == ))
            {
                string encoded = string.Concat(target.Trim().Replace("-", "+").Replace("_", "/"), "==");

                try
                {
                    byte[] base64 = Convert.FromBase64String(encoded);

                    result = new Guid(base64);
                }
                catch (FormatException)
                {
                }
            }

            return result;
        }

        /// <summary>
        /// 是否为数字
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public static Boolean IsNumeric(this String str)
        {
            long temp_big_int;
            var is_number = long.TryParse(str, out temp_big_int);
            return is_number;
        }

        /// <summary>
        /// string to int
        /// </summary>
        /// <param name="str"></param>
        /// <param name="defVal"></param>
        /// <returns></returns>
        public static int ToInt(this String str, int defVal = )
        {
            int.TryParse(str, out defVal);
            return defVal;
        }

        /// <summary>
        /// string to long
        /// </summary>
        /// <param name="str"></param>
        /// <param name="defVal"></param>
        /// <returns></returns>
        public static long ToLong(this String str, long defVal = )
        {
            long.TryParse(str, out defVal);
            return defVal;
        }

        /// <summary>
        /// string to decimal
        /// </summary>
        /// <param name="str"></param>
        /// <param name="defVal"></param>
        /// <returns></returns>
        public static decimal ToDecimal(this String str, decimal defVal = )
        {
            decimal.TryParse(str, out defVal);
            return defVal;
        }

        /// <summary>
        /// string to float
        /// </summary>
        /// <param name="str"></param>
        /// <param name="defVal"></param>
        /// <returns></returns>
        public static float ToFloat(this String str, float defVal = )
        {
            float.TryParse(str, out defVal);
            return defVal;
        }

        /// <summary>
        /// string to double
        /// </summary>
        /// <param name="str"></param>
        /// <param name="defVal"></param>
        /// <returns></returns>
        public static double ToDouble(this String str, double defVal = )
        {
            double.TryParse(str, out defVal);
            return defVal;
        }

        private static DateTime minValue = DateTime.MinValue;

        /// <summary>
        ///  string to datetime
        /// </summary>
        /// <param name="str"></param>
        /// <param name="format">日期格式</param>
        /// <param name="defVal">默认日期</param>
        /// <returns></returns>
        public static DateTime ToDateTime(this string str, string format, DateTime defVal)
        {
            try
            {
                DateTime dt = DateTime.ParseExact(str, format, System.Globalization.CultureInfo.InvariantCulture);
                return dt;
            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex);
                return defVal;
            }
        }

        #region 加解密
        /// <summary>
        /// AES加密
        /// </summary>
        /// <param name="str">需要加密字符串</param>
        /// <returns>加密后字符串</returns>
        public static String Encrypt(this string str)
        {
            try
            {
                return Encrypt(str, PublicKey);
            }
            catch (Exception e)
            {
                return str;
            }
        }

        /// <summary>
        /// AES解密
        /// </summary>
        /// <param name="str">需要解密字符串</param>
        /// <returns>解密后字符串</returns>
        public static String Decrypt(this string str)
        {
            try
            {
                return Decrypt(str, PublicKey);
            }
            catch (Exception e)
            {
                return str;
            }
        }
        /// <summary>
        /// AES加密
        /// </summary>
        /// <param name="str">需要加密的字符串</param>
        /// <param name="key">32位密钥</param>
        /// <returns>加密后的字符串</returns>
        public static string Encrypt(this string str, string key)
        {
            Byte[] keyArray = System.Text.Encoding.UTF8.GetBytes(key);
            Byte[] toEncryptArray = System.Text.Encoding.UTF8.GetBytes(str);
            var rijndael = new System.Security.Cryptography.RijndaelManaged();
            rijndael.Key = keyArray;
            rijndael.Mode = System.Security.Cryptography.CipherMode.ECB;
            rijndael.Padding = System.Security.Cryptography.PaddingMode.PKCS7;
            rijndael.IV = System.Text.Encoding.UTF8.GetBytes(Iv);
            System.Security.Cryptography.ICryptoTransform cTransform = rijndael.CreateEncryptor();
            Byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, , toEncryptArray.Length);
            return Convert.ToBase64String(resultArray, , resultArray.Length);
        }
        /// <summary>
        /// AES解密
        /// </summary>
        /// <param name="str">需要解密的字符串</param>
        /// <param name="key">32位密钥</param>
        /// <returns>解密后的字符串</returns>
        public static string Decrypt(this string str, string key)
        {
            Byte[] keyArray = System.Text.Encoding.UTF8.GetBytes(key);
            Byte[] toEncryptArray = Convert.FromBase64String(str);
            var rijndael = new System.Security.Cryptography.RijndaelManaged();
            rijndael.Key = keyArray;
            rijndael.Mode = System.Security.Cryptography.CipherMode.ECB;
            rijndael.Padding = System.Security.Cryptography.PaddingMode.PKCS7;
            rijndael.IV = System.Text.Encoding.UTF8.GetBytes(Iv);
            System.Security.Cryptography.ICryptoTransform cTransform = rijndael.CreateDecryptor();
            Byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, , toEncryptArray.Length);
            return System.Text.Encoding.UTF8.GetString(resultArray);
        }
        /// <summary>
        /// AES加密
        /// </summary>
        /// <param name="str">需要加密字符串</param>
        /// <returns>加密后字符串</returns>
        public static String EncryptToString(this string str)
        {
            try
            {
                return EncryptToString(str, PublicKey);
            }
            catch (Exception e)
            {
                return str;
            }
        }

        /// <summary>
        /// AES加密
        /// </summary>
        /// <param name="str">需要加密的字符串</param>
        /// <param name="key">32位密钥</param>
        /// <returns>加密后的字符串</returns>
        public static string EncryptToString(this string str, string key)
        {
            Byte[] keyArray = System.Text.Encoding.UTF8.GetBytes(key);
            Byte[] toEncryptArray = System.Text.Encoding.UTF8.GetBytes(str);
            var rijndael = new System.Security.Cryptography.RijndaelManaged();
            rijndael.Key = keyArray;
            rijndael.Mode = System.Security.Cryptography.CipherMode.ECB;
            rijndael.Padding = System.Security.Cryptography.PaddingMode.PKCS7;
            rijndael.IV = System.Text.Encoding.UTF8.GetBytes(Iv);
            System.Security.Cryptography.ICryptoTransform cTransform = rijndael.CreateEncryptor();
            Byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, , toEncryptArray.Length);
            StringBuilder builder = new StringBuilder();
            int num2 = resultArray.Length - ;
            for (int i = ; i <= num2; i++)
            {
                builder.AppendFormat("{0:X2}", resultArray[i]);
            }
            return builder.ToString();
            // return Convert.ToBase64String(resultArray, 0, resultArray.Length);
        }

        /// <summary>
        /// AES解密
        /// </summary>
        /// <param name="str">需要解密字符串</param>
        /// <returns>解密后字符串</returns>
        public static String DecryptToString(this string str)
        {
            try
            {
                return DecryptToString(str, PublicKey);
            }
            catch (Exception e)
            {
                return str;
            }
        }

        /// <summary>
        /// AES解密
        /// </summary>
        /// <param name="str">需要解密的字符串</param>
        /// <param name="key">32位密钥</param>
        /// <returns>解密后的字符串</returns>
        public static string DecryptToString(this string str, string key)
        {
            Byte[] keyArray = System.Text.Encoding.UTF8.GetBytes(key);
            int halfInputLength = str.Length / ;
            Byte[] toEncryptArray = new Byte[halfInputLength];
            for (int x = ; x < halfInputLength; x++)
            {
                int i = (Convert.ToInt32(str.Substring(x * , ), ));
                toEncryptArray[x] = (byte)i;
            }

            var rijndael = new System.Security.Cryptography.RijndaelManaged();
            rijndael.Key = keyArray;
            rijndael.Mode = System.Security.Cryptography.CipherMode.ECB;
            rijndael.Padding = System.Security.Cryptography.PaddingMode.PKCS7;
            rijndael.IV = System.Text.Encoding.UTF8.GetBytes(Iv);
            System.Security.Cryptography.ICryptoTransform cTransform = rijndael.CreateDecryptor();
            Byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, , toEncryptArray.Length);
            return System.Text.Encoding.UTF8.GetString(resultArray);
            //  return UTF8Encoding.UTF8.GetString(resultArray);
        }
        #endregion

        private static readonly Regex RepalceHttpToHttpsRegex = new Regex("^http(\\:\\/\\/){1}", RegexOptions.IgnoreCase);
        /// <summary>
        /// 替换http为https
        /// </summary>
        /// <param name="url">targetProtocol: https</param>
        /// <returns></returns>
        public static string ToHttpsUrl(this string url)
        {
            url = url.ToTrim();
            string strOutput = RepalceHttpToHttpsRegex.Replace(url, "https://");
            return strOutput;
        }

       private static readonly  Regex RemoveHttpOrHttpsRegex = new Regex("^http(s?)(\\:\\/\\/){1}", RegexOptions.IgnoreCase);
        /// <summary>
        ////// </summary>
        /// <param name="url">targetProtocol: https</param>
        /// <returns></returns>
        public static string ToRemoveUrlProtocol(this string url)
        {
            url = url.ToTrim();
            string strOutput = RemoveHttpOrHttpsRegex.Replace(url, "//");
            return strOutput;
        }
    }
}