C#字符串的常用操作工具类代码分享

实现以下功能：

验证字符串是否由正负号（+-）、数字、小数点构成，并且最多只有一个小数点
验证字符串是否仅由[0-9]构成
验证字符串是否由字母和数字构成
验证是否为空字符串。若无需裁切两端空格，建议直接使用 string.isnullorempty(string)
裁切字符串（中文按照两个字符计算）
裁切字符串（中文按照两个字符计算，裁切前会先过滤 html 标签）
过滤html标签
获取字符串长度。与string.length不同的是，该方法将中文作 2 个字符计算。
将形如 10.1mb 格式对用户友好的文件大小字符串还原成真实的文件大小，单位为字节。
根据文件夹命名规则验证字符串是否符合文件夹格式
根据文件名命名规则验证字符串是否符合文件名格式
验证是否为合法的rgb颜色字符串

c#代码：

public static class extendedstring
{
    /// <summary>
    /// 验证字符串是否由正负号（+-）、数字、小数点构成，并且最多只有一个小数点
    /// </summary>
    /// <param name="str"></param>
    /// <returns></returns>
    public static bool isnumeric(this string str)
    {
        regex regex = new regex(@"^[+-]?\d+[.]?\d*$");
        return regex.ismatch(str);           
    }

    /// <summary>
    /// 验证字符串是否仅由[0-9]构成
    /// </summary>
    /// <param name="str"></param>
    /// <returns></returns>
    public static bool isnumericonly(this string str)
    {
        regex regex = new regex("[0-9]");
        return regex.ismatch(str);
    }

    /// <summary>
    /// 验证字符串是否由字母和数字构成
    /// </summary>
    /// <param name="str"></param>
    /// <returns></returns>
    public static bool isnumericorletters(this string str)
    {
        regex regex = new regex("[a-za-z0-9]");
        return regex.ismatch(str);
    }

    /// <summary>
    /// 验证是否为空字符串。若无需裁切两端空格，建议直接使用 string.isnullorempty(string)
    /// </summary>
    /// <param name="str"></param>
    /// <returns></returns>
    /// <remarks>
    /// 不同于string.isnullorempty(string)，此方法会增加一步trim操作。如 isnulloremptystr(" ") 将返回 true。
    /// </remarks>
    public static bool isnulloremptystr(this string str)
    {
        if (string.isnullorempty(str)) { return true; }
        if (str.trim().length == 0) { return true; }
        return false;
    }

    /// <summary>
    /// 裁切字符串（中文按照两个字符计算）
    /// </summary>
    /// <param name="str">旧字符串</param>
    /// <param name="len">新字符串长度</param>
    /// <param name="htmlenable">为 false 时过滤 html 标签后再进行裁切，反之则保留 html 标签。</param>
    /// <remarks>
    /// <para>注意：<ol>
    /// <li>若字符串被截断则会在末尾追加“...”，反之则直接返回原始字符串。</li>
    /// <li>参数 <paramref name="htmlenable"/> 为 false 时会先调用<see cref="uolib.common.functions.htmlfilter"/>过滤掉 html 标签再进行裁切。</li>
    /// <li>中文按照两个字符计算。若指定长度位置恰好只获取半个中文字符，则会将其补全，如下面的例子：<br/>
    /// <code><![cdata[
    /// string str = "感谢使用uolib。";
    /// string a = cutstr(str,4);   // a = "感谢..."
    /// string b = cutstr(str,5);   // b = "感谢使..."
    /// ]]></code></li>
    /// </ol>
    /// </para>
    /// </remarks>
    public static string cutstr(this string str, int len, bool htmlenable)
    {
        if (str == null || str.length == 0 || len <= 0) { return string.empty; }

        if (htmlenable == false) str = htmlfilter(str);
        int l = str.length;

        #region 计算长度
        int clen = 0;//当前长度
        while (clen < len && clen < l)
        {
            //每遇到一个中文，则将目标长度减一。
            if ((int)str[clen] > 128) { len--; }
            clen++;
        }
        #endregion

        if (clen < l)
        {
            return str.substring(0, clen) + "...";
        }
        else
        {
            return str;
        }
    }
    /// <summary>
    /// 裁切字符串（中文按照两个字符计算，裁切前会先过滤 html 标签）
    /// </summary>
    /// <param name="str">旧字符串</param>
    /// <param name="len">新字符串长度</param>
    /// <remarks>
    /// <para>注意：<ol>
    /// <li>若字符串被截断则会在末尾追加“...”，反之则直接返回原始字符串。</li>
    /// <li>中文按照两个字符计算。若指定长度位置恰好只获取半个中文字符，则会将其补全，如下面的例子：<br/>
    /// <code><![cdata[
    /// string str = "感谢使用uolib模块。";
    /// string a = cutstr(str,4);   // a = "感谢..."
    /// string b = cutstr(str,5);   // b = "感谢使..."
    /// ]]></code></li>
    /// </ol>
    /// </para>
    /// </remarks>
    public static string cutstr(this string str, int len)
    {
        if (isnulloremptystr(str)) { return string.empty; }
        else
        {
            return cutstr(str, len, false);
        }
    }
    /// <summary>
    /// 过滤html标签
    /// </summary>
    public static string htmlfilter(this string str)
    {
        if (isnulloremptystr(str)) { return string.empty; }
        else
        {
            regex re = new regex(regexpatterns.htmltag, regexoptions.ignorecase);
            return re.replace(str, "");
        }
    }

    /// <summary>
    /// 获取字符串长度。与string.length不同的是，该方法将中文作 2 个字符计算。
    /// </summary>
    /// <param name="str">目标字符串</param>
    /// <returns></returns>
    public static int getlength(this string str)
    {
        if (str == null || str.length == 0) { return 0; }

        int l = str.length;
        int reallen = l;

        #region 计算长度
        int clen = 0;//当前长度
        while (clen < l)
        {
            //每遇到一个中文，则将实际长度加一。
            if ((int)str[clen] > 128) { reallen++; }
            clen++;
        }
        #endregion

        return reallen;
    }

    /// <summary>
    /// 将形如 10.1mb 格式对用户友好的文件大小字符串还原成真实的文件大小，单位为字节。
    /// </summary>
    /// <param name="formatedsize">形如 10.1mb 格式的文件大小字符串</param>
    /// <remarks>
    /// 参见：<see cref="uolib.common.functions.formatfilesize(long)"/>
    /// </remarks>
    /// <returns></returns>
    public static long getfilesizefromstring(this string formatedsize)
    {
        if (isnulloremptystr(formatedsize)) throw new argumentnullexception("formatedsize");

        long size;
        if (long.tryparse(formatedsize, out size)) return size;

        //去掉数字分隔符
        formatedsize = formatedsize.replace(",", "");

        regex re = new regex(@"^([\d\.]+)((?:tb|gb|mb|kb|bytes))$");
        if (re.ismatch(formatedsize))
        {
            matchcollection mc = re.matches(formatedsize);
            match m = mc[0];
            double s = double.parse(m.groups[1].value);

            switch (m.groups[2].value)
            {
                case "tb":
                    s *= 1099511627776;
                    break;
                case "gb":
                    s *= 1073741824;
                    break;
                case "mb":
                    s *= 1048576;
                    break;
                case "kb":
                    s *= 1024;
                    break;
            }

            size = (long)s;
            return size;
        }

        throw new argumentexception("formatedsize");
    }

    /// <summary>
    /// 根据文件夹命名规则验证字符串是否符合文件夹格式
    /// </summary>
    public static bool isfoldername(this string foldername)
    {
        if (isnulloremptystr(foldername)) { return false; }
        else
        {
            // 不能以 “.” 开头
            foldername = foldername.trim().tolower();

            // “nul”、“aux”、“con”、“com1”、“lpt1”不能为文件夹/文件的名称
            // 作为文件夹，只需满足名称不为这几个就行。
            switch (foldername)
            {
                case "nul":
                case "aux":
                case "con":
                case "com1":
                case "lpt1":
                    return false;
                default:
                    break;
            }

            regex re = new regex(regexpatterns.foldername, regexoptions.ignorecase);
            return re.ismatch(foldername);
        }
    }

    /// <summary>
    /// 根据文件名命名规则验证字符串是否符合文件名格式
    /// </summary>
    public static bool isfilename(this string filename)
    {
        if (isnulloremptystr(filename)) { return false; }
        else
        {
            filename = filename.trim().tolower();
            // 不能以 “.” 开头
            // 作为文件名，第一个“.” 之前不能是“nul”、“aux”、“con”、“com1”、“lpt1”
            if (filename.startswith(".")
                || filename.startswith("nul.")
                || filename.startswith("aux.")
                || filename.startswith("con.")
                || filename.startswith("com1.")
                || filename.startswith("lpt1.")
                ) return false;

            regex re = new regex(regexpatterns.filename, regexoptions.ignorecase);
            return re.ismatch(filename);
        }
    }

    /// <summary>
    /// 验证是否为合法的rgb颜色字符串
    /// </summary>
    /// <param name="color">rgb颜色，如：#00ccff | #039 | ffffcc</param>
    /// <returns></returns>
    public static bool isrgbcolor(this string color)
    {
        if (isnulloremptystr(color)) { return false; }
        else
        {
            regex re = new regex(regexpatterns.htmlcolor, regexoptions.ignorecase);
            return re.ismatch(color);
        }
    }

    public static string getjssafestr(this string str)
    {
        if (string.isnullorempty(str))
            return string.empty;

        return str.replace("\\", "\\\\").replace("\"", "\\\"");
    }
}