C#常用工具类——字符串处理

已于 2024-06-04 10:15:45 修改
阅读量331 收藏 1
点赞数 1
分类专栏： 程序基础 文章标签： c# 开发语言 字符串
于 2024-05-17 16:00:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/liweizhao/article/details/138096768
版权

  大家好，我是阿赵。
  在做Unity项目的时候，会用到C#脚本编写功能。其中字符串的处理经常会用到。这里我整理了一个工具类，里面包括了一些常用的功能，比如说一些常用的正则匹配、字符串格式化、切割字符串、版本对比等。

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Security.Cryptography;
using System.Text;
using System.Text.RegularExpressions;

    public class StringTools
    {
        static private StringTools _instance;

        public static StringTools Instance
        {
            get { 
                if(_instance==null)
                {
                    _instance = new StringTools();
                }
                return _instance;
            }
        }

    #region 正则匹配方法
    /// <summary>
    /// 获取第一个匹配
    /// </summary>
    /// <param name="str"></param>
    /// <param name="regexStr"></param>
    /// <returns></returns>
    static public string GetFirstMatch(string str, string regexStr)
    {
        if (string.IsNullOrEmpty(str) || string.IsNullOrEmpty(regexStr))
        {
            return null;
        }
        Match m = Regex.Match(str, regexStr);
        if (!string.IsNullOrEmpty(m.ToString()))
        {
            return m.ToString();
        }
        else
        {
            return null;
        }
    }
    /// <summary>
    /// 获取第一个匹配，返回match
    /// </summary>
    /// <param name="str"></param>
    /// <param name="regexStr"></param>
    /// <returns></returns>
    static public Match GetFirstMatchStruct(string str, string regexStr)
    {
        if (string.IsNullOrEmpty(str) || string.IsNullOrEmpty(regexStr))
        {
            return null;
        }
        Match m = Regex.Match(str, regexStr);
        if (!string.IsNullOrEmpty(m.ToString()))
        {
            return m;
        }
        else
        {
            return null;
        }
    }


    /// <summary>
    /// 获取所有匹配,返回string[]
    /// </summary>
    /// <param name="str"></param>
    /// <param name="regexStr"></param>
    /// <returns></returns>
    static public string[] GetAllMatchs(string str, string regexStr)
    {
        if (string.IsNullOrEmpty(str) || string.IsNullOrEmpty(regexStr))
        {
            return null;
        }
        MatchCollection mc = Regex.Matches(str, regexStr);
        if (mc.Count == 0)
        {
            return null;
        }
        string[] matchs = new string[mc.Count];
        for (int i = 0; i < mc.Count; i++)
        {
            matchs[i] = mc[i].Value.ToString();
        }
        return matchs;
    }
    /// <summary>
    /// 获取所有匹配,返回List<string>
    /// </summary>
    /// <param name="str"></param>
    /// <param name="regexStr"></param>
    /// <returns></returns>
    static public List<string> GetAllMatchs2(string str, string regexStr)
    {
        if (string.IsNullOrEmpty(str) || string.IsNullOrEmpty(regexStr))
        {
            return null;
        }
        MatchCollection mc = Regex.Matches(str, regexStr);
        if (mc.Count == 0)
        {
            return null;
        }
        List<string> matchs = new List<string>();
        for (int i = 0; i < mc.Count; i++)
        {
            matchs.Add(mc[i].Value.ToString());
        }
        return matchs;
    }

    /// <summary>
    /// 获取所有匹配，返回match
    /// </summary>
    /// <param name="str"></param>
    /// <param name="regexStr"></param>
    /// <returns></returns>
    static public Match[] GetAllMatchsStruct(string str, string regexStr)
    {
        if (string.IsNullOrEmpty(str) || string.IsNullOrEmpty(regexStr))
        {
            return null;
        }
        MatchCollection mc = Regex.Matches(str, regexStr);
        if (mc.Count == 0)
        {
            return null;
        }
        Match[] matchs = new Match[mc.Count];
        for (int i = 0; i < mc.Count; i++)
        {
            matchs[i] = mc[i];
        }
        return matchs;
    }
    #endregion

    #region 匹配字符串内容

    /// <summary>
    /// 判断是否是合法的IP地址
    /// </summary>
    /// <param name="ip"></param>
    /// <returns></returns>
    public static bool GetLegitimateIP(string ip)
    {
        if(string.IsNullOrEmpty(ip))
        {
            return false;
        }
        Regex rx = new Regex(@"((?:(?:25[0-5]|2[0-4]\d|((1\d{2})|([1-9]?\d)))\.){3}(?:25[0-5]|2[0-4]\d|((1\d{2})|([1-9]?\d))))");
        if (rx.IsMatch(ip))
        {
            return true;
        }
        return false;
    }


    /// <summary>
    /// 获取是否为纯数字
    /// </summary>
    /// <param name="str"></param>
    /// <returns></returns>
    static public bool IsNumber(string expression)
    {
        string getIsNumber = @"^\-?[0-9]+(\.[0-9]*)?$";
        MatchCollection mc = Regex.Matches(expression, getIsNumber);
        if (mc.Count > 0)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
    #endregion

    #region 处理字符串

    /// <summary>
    /// 格式化字符串，替代{数字}内容
    /// </summary>
    /// <param name="str"></param>
    /// <param name="args"></param>
    /// <returns></returns>
    static public string Format(string str, params object[] args)
        {
            string newStr = str;
            string rexStr = @"\{[0-9]+\}";
            MatchCollection mc = Regex.Matches(str, rexStr);
            if (mc.Count > 0)
            {
                for (int i = 0; i < mc.Count; i++)
                {
                    string subStr = "{" + i + "}";
                    if (i < args.Length)
                    {
                        Type t = args[i].GetType();
                        newStr = newStr.Replace(subStr, args[i].ToString());
                    }
                    else
                    {
                        newStr = newStr.Replace(subStr,"");
                    }

                }


            }
            return newStr;
        }

        
        /// <summary>
        /// 切割字符串，返回string[]
        /// </summary>
        /// <param name="str"></param>
        /// <param name="splitStr"></param>
        /// <returns></returns>
        static public string[] Split(string str,string splitStr)
        {
            if (string.IsNullOrEmpty(str) || string.IsNullOrEmpty(splitStr))
            {
                return null;
            }
            string[] newStrs = Regex.Split(str, splitStr);
            return newStrs;
        }
        /// <summary>
        /// 切割字符串，返回List<string>
        /// </summary>
        /// <param name="str"></param>
        /// <param name="splitStr"></param>
        /// <returns></returns>
        static public List<string> Split2(string str, string splitStr)
        {
            if (string.IsNullOrEmpty(str) || string.IsNullOrEmpty(splitStr))
            {
                return null;
            }
            string[] newStrs = Regex.Split(str, splitStr);
            List<string> strs = new List<string>();

            for(int i = 0;i<newStrs.Length;i++)
            {
                strs.Add(newStrs[i]);
            }
            return strs;
        }
        /// <summary>
        /// 切割字符串，返回数组
        /// </summary>
        /// <param name="str"></param>
        /// <param name="splitStr"></param>
        /// <returns></returns>
        static public string[] SplitStr(string str,char splitStr)
        {
            if (string.IsNullOrEmpty(str))
            {
                return null;
            }
            return str.Split(splitStr);
        }


        /// <summary>
        /// 去掉换行符
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        static public string RemoveReturn(string str)
        {
            return StringTools.Replace(str, "\r\n|\r|\n", "");
        }

        /// <summary>
        /// 用正则表达式替换字符串
        /// </summary>
        /// <param name="str"></param>
        /// <param name="str1"></param>
        /// <param name="str2"></param>
        /// <returns></returns>
        static public string Replace(string str,string str1,string str2)
        {
            if (string.IsNullOrEmpty(str) || string.IsNullOrEmpty(str1)||str2==null)
            {
                return null;
            }
            Regex rgx = new Regex(str1);
            string result = rgx.Replace(str, str2);
            return result;
        }
    /// <summary>
    /// 获得扩展名
    /// </summary>
    /// <param name="str"></param>
    /// <returns></returns>
    static public string GetExName(string str)
    {
        string regexStr = @"(?<=\.)[^\.]+$";
        string strs = GetFirstMatch(str, regexStr);
        return strs;
    }

    /// <summary>
    /// 移除扩展名
    /// </summary>
    /// <param name="str"></param>
    /// <returns></returns>
    static public string RemoveExName(string str)
    {
        string regexStr = @".+(?=\.)";
        string strs = GetFirstMatch(str, regexStr);
        if (string.IsNullOrEmpty(strs))
        {
            strs = str;
        }
        return strs;
    }

    /// <summary>
    /// 处理路径格式，把\\统一换成/
    /// </summary>
    /// <param name="path"></param>
    /// <returns></returns>
    static public string ChangePathFormat(string path)
    {
        string newPath = path.Replace('\\', '/');
        return newPath;
    }
    /// <summary>
    /// 字符串进行UrlEncode
    /// </summary>
    /// <param name="str"></param>
    /// <returns></returns>
    public static string UrlEncode(string str)
    {
        return Uri.EscapeUriString(str);
    }

    #endregion

    #region 版本字符串对比
    /// <summary>
    /// 检查版本是否需要更新
    /// </summary>
    /// <param name="wwwVer"></param>
    /// <param name="localVer"></param>
    /// <returns></returns>
    static public bool isNeedUpdata(string wwwVer, string localVer)
    {
        if (string.IsNullOrEmpty(localVer))
        {
            return true;
        }
        string[] wwwVers = wwwVer.Split('.');
        string[] localVers = localVer.Split('.');
        int len = wwwVers.Length > localVers.Length ? wwwVers.Length : localVers.Length;
        bool needUpdata = false;
        int wwwValue;
        int localValue;
        for (int i = 0; i < len; i++)
        {
            wwwValue = GetValue(wwwVers, i);
            localValue = GetValue(localVers, i);
            if (wwwValue > localValue)
            {
                needUpdata = true;
                break;
            }
            if (localValue > wwwValue)
            {
                break;
            }
        }
        return needUpdata;
    }

    static private int GetValue(string[] strs, int ind)
    {
        if (strs.Length > ind)
        {
            int val = System.Int32.Parse(strs[ind]);
            return val;
        }
        else
        {
            return 0;
        }
    }
    /// <summary>
    /// 判断ver1是否比ver2版本号大
    /// </summary>
    /// <param name="ver1"></param>
    /// <param name="ver2"></param>
    /// <returns></returns>
    public static bool CompareVer(string ver1, string ver2)
    {
        string[] verStr1 = ver1.Split('.');
        string[] verStr2 = ver2.Split('.');
        int vn1 = 0;
        int vn2 = 0;
        for (int i = 0; i < verStr1.Length; i++)
        {
            if (i >= verStr2.Length)
            {
                return true;
            }
            vn1 = int.Parse(verStr1[i]);
            vn2 = int.Parse(verStr2[i]);
            if (vn1 > vn2)
            {
                return true;
            }
            if (vn1 < vn2)
            {
                return false;
            }
        }
        return false;
    }
    #endregion

    #region 字符串和Unicode码
    /// <summary>
    /// 从字符串获取unicode码
    /// </summary>
    /// <param name="str"></param>
    /// <returns></returns>
    static public int String2Unicode(string str)
        {
            System.Text.UnicodeEncoding unicodeEncodeing = new System.Text.UnicodeEncoding();
            byte[] bs = unicodeEncodeing.GetBytes(str);
            int ts = 0;
            for (int i = 0; i < bs.Length; i++)
            {
                int sub = bs[i];
                int addSub = (int)Math.Pow(256, i) * sub;
                ts += addSub;
            }
            return ts;
        }

        /// <summary>
        /// 把字符串拆分再分别获取unicode码
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        static public int[] String2Unicodes(string str)
        {
            int[] res = new int[str.Length];
            for(int i = 0;i<str.Length;i++)
            {
                string subStr = str.Substring(i, 1);
                res[i] = String2Unicode(subStr);
            }
            return res;
        }


    #endregion


}
C#上位机开发（十五）—— 计算字符串哈希值和文件哈希值
Mculover666的博客（嵌入式）
05-17 1758
一、C#计算哈希值方法 1. 引用类库 using System.Security.Cryptography; 2. 计算哈希值 //Compute hash based on source data. tmpHash = new MD5CryptoServiceProvider().ComputeHash(tmpSource); 二、计算字符串哈希 （1）声明用于保存源数据的字符串变量，以及两个字节数组 (未定义的大小) 保存源字节和生成的哈希值。 string sSourceData; byte[]
C#常用工具类
hahahahei123的博客
08-13 1415
C#常用工具类 常用类String string类用法 ( 实为 System.String ) ： String Class // 是否以x结尾 a.EndsWith(x) // 判断a,b是否相同 a.Equals(b) // 格式化 a = String.Format(fmt, args) // 判断子串是否存在 index = a.IndexOf(sub) // 插入一个子串 a.Insert(index , sub) // 判断是否null或为空串 Stri
字符串处理工具
最新发布
m0_72616483的博客
05-15 81
处理字符串感到麻烦？这款字符串处理工具提供了字符串反转、大小写转换和子字符串统计等常用功能，让字符串处理变得轻松简单！
C# 常用工具类
10-20
C# 常用工具类:时间转化，获取网页源码，按照一定比例保存图片,获取四位随机数,下载到本地的文件完整路径, unicode转中文（符合js规则的）, 移动文件,UBBHelper代码处理函数 等等
C# 常用的工具类
weixin_30786617的博客
07-03 629
编码解码、图片与byte[]、日志文件写入和读取 1 /// <summary> 2 /// 将字符串编码为Base64字符串 3 /// </summary> 4 /// <param name="str"></param> 5 /// ...
C#实现简易的加密、解密字符串工具类实例
09-03
本实例介绍了一个简单的C#字符串加密和解密工具类——CypherHelper，适用于对长度较短的密码或字符串进行加密保护。虽然C#已经提供了System.Security.Cryptography库，它更适合处理较长的字符串或流，但这个工具类...
c# 串口工具——练习1
02-23
- 练习1可能涉及到创建一个简单的串口通信工具，实现打开指定的串口，设置波特率和其他参数，然后能够发送和接收字符串或特定格式的数据。 通过以上知识点的学习，开发者可以构建一个基本的C#串口通信程序，实现...
C#实现过滤sql特殊字符的方法集合
09-03
// 如果字符串为空，直接返回空 if (str == String.Empty) return String.Empty; // 替换各种可能的SQL特殊字符 str = str.Replace("'", "‘").Replace(";", "；").Replace(",", ",").Replace("?", "?").Replace...
个人练习工具——鼠标连点器(c#编写)
10-09
压缩包中的文件包含"MouseClicker.exe.Config"，这是C#应用程序的配置文件，用于存储应用程序的运行时配置信息，如连接字符串、日志设置等。"MouseClicker.exe"是实际的可执行文件，包含了编译后的代码和资源，可以...
常用的C#工具类
01-03
整理了一些C#开发常用工具类，方便开发者在日常开发中使用。
自己整理的C#常用工具类
04-08
自己整理的C#常用工具类 自己整理的C#常用工具类
C#.net常用工具类
08-19
.net|NPOI|Excel 导入|Excel导出
C#之Common工具类
04-12
多种多样的工具类可以让web开发事半功倍，节省了开发时间，提高了开发的效率。。。
C#常用工具类代码集合Util（自己工作总结）
05-18
C#常用工具类代码集合Util（自己工作总结），欢迎分享给大家，一起进步，有什么问题可以找我沟通，谢谢大家。
c# 工具类
zhougengxu2009的博客
02-24 480
一、c#基础 1、xmal Regex rgx = new Regex(@"^(?![0-9]+$)(?![a-zA-Z]+$)"); rgx.IsMatch(...)
C#工具类
SSOA6的博客
12-01 965
Dbhelper 使用时要修改 namespace 和 数据库 using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; using System.Data.SqlClient; using System.Data; namespace DbHelper { class DbHelper { // 连
C#开发中一些常用的工具类分享
扣丁曼
04-02 1518
在项目开发中我们经常要对业务进行日志记录，方便出现问题后对于故障的排查。这里我们使用C#实现了简单的日志记录功能。数据缓存类是一个用C#实现的对数据进行缓存的简单功能。用于在开发时候C#操作配置文件读写信息。
实用C#字符串截取工具：提取文本中的网址
结合标签中的“字符串 C# 索引 截取 IO”，我们可以推断出该工具可能是用C#编程语言实现的，且涉及到字符串处理、索引操作和输入/输出（IO）操作。字符串处理是编程中常见的任务，尤其是当需要从大量文本数据中提取...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值