C#分享辅助类：正则表达式（RegexHandler）

最新推荐文章于 2026-06-20 15:56:51 发布
原创 最新推荐文章于 2026-06-20 15:56:51 发布 · 147 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#c# #开发语言

名称

方法

验证字符是否在4至12之间

IsValidString

验证后缀名

IsValidPostfix

没有特殊字符

NoneSpecialChar

是否十六进制颜色字符

IsColor

是否数字

IsNum

是不是Int型的

IsInt

验证是否为小数

IsFloat

验证邮箱

IsEmail

HasEmail

验证网址

IsUrl

HasUrl

验证日期

IsDateTime

IsValidDateTime

IsDate

IsTime

是不是中国电话

IsTel

IsMobile

验证中文

IsCn

HasCn

验证IP

IsIP

HasIP

IsValidIP

IsPort

验证身份证是否有效

IsIDCard

IsIDCard18

IsIDCard15

IsValidID

看字符串的长度是不是在限定数之间 一个中文为两个字符

IsLengthStr

邮政编码 6个数字

IsPostCode

验证是不是正常字符 字母，数字，下划线的组合

IsNormalChar

HasSpecialChar

是否有特殊符号

HasSpecialChar

是否是英文域名

IsEnDomain

是否中文域名

IsCnDomain

获取页面编码格式

GetCharSet

获取域名中间的内容

GetDomain

using System;
using System.Collections.Generic;
using System.Text;
using System.Text.RegularExpressions;

namespace Wsfly
{
    /// <summary> 
    /// 各种正则表达式验证
    /// </summary> 
    public class RegexHandler
    {
        #region 验证

        #region 验证字符

        /// <summary>
        /// 验证字符是否在指定长度之间
        /// </summary>
        /// <returns></returns>
        public static bool IsValidString(string value, int minSize, int maxSize)
        {
            return Regex.IsMatch(value, @"^[a-zA-Z0-9_]{" + minSize + "," + maxSize + "}$");
        }

        /// <summary>
        /// 验证后缀名
        /// </summary>
        /// <param name="value"></param>
        /// <returns></returns>
        public static bool IsValidPostfix(string value)
        {
            return Regex.IsMatch(value, @"\.(?i:gif|jpg|png|bmp|icon)$",RegexOptions.IgnoreCase);
        }
        /// <summary>
        /// 没有特殊字符
        /// </summary>
        /// <param name="source"></param>
        /// <returns></returns>
        public static bool NoneSpecialChar(string source)
        {
            return Regex.IsMatch(source, "^[a-zA-Z0-9]+$"); 
        }
        /// <summary>
        /// 是否颜色字符
        /// </summary>
        /// <param name="source"></param>
        /// <returns></returns>
        public static bool IsColor(string source)
        {
            return Regex.IsMatch(source, "^#?([a-f]|[A-F]|[0-9]){3}(([a-f]|[A-F]|[0-9]){3})?$");
        }
        #endregion
        
        #region 验证数字
        /// <summary>
        /// 是否数字
        /// </summary>
        /// <param name="source"></param>
        /// <returns></returns>
        public static bool IsNum(object source)
        {
            try
            {
                Regex regex = new Regex(@"^\d+$");

                if (regex.IsMatch(source.ToString()))
                {
                    return true;
                }

                return false;
            }
            catch
            {
                return false;
            }
        }
        /// <summary>
        /// 是不是Int型的
        /// </summary>
        /// <param name="source"></param>
        /// <returns></returns>
        public static bool IsInt(object source)
        {
            try
            {
                Regex regex = new Regex(@"^[+|-]{0,1}\d+$");

                if (regex.Match(source.ToString()).Success)
                {
                    if ((long.Parse(source.ToString()) > 0x7fffffffL) || (long.Parse(source.ToString()) < -2147483648L))
                    {
                        return false;
                    }

                    return true;
                }

                return false;
            }
            catch
            {
                return false;
            }
        }
        /// <summary>
        /// 验证是否为小数
        /// </summary>
        /// <param name="value"></param>
        /// <returns></returns>
        public static bool IsFloat(string value)
        {
            return Regex.IsMatch(value, @"^[+|-]?\d*\.?\d*$");
        }
        #endregion

        #region 验证邮箱
        /// <summary>
        /// 验证邮箱
        /// </summary>
        /// <param name="source"></param>
        /// <returns></returns>
        public static bool IsEmail(string source)
        {
            return Regex.IsMatch(source, @"^[A-Za-z0-9](([_\.\-]?[a-zA-Z0-9]+)*)@([A-Za-z0-9]+)(([\.\-]?[a-zA-Z0-9]+)*)\.([A-Za-z]{2,})$", RegexOptions.IgnoreCase);
        }
        public static bool HasEmail(string source)
        {
            return Regex.IsMatch(source, @"[A-Za-z0-9](([_\.\-]?[a-zA-Z0-9]+)*)@([A-Za-z0-9]+)(([\.\-]?[a-zA-Z0-9]+)*)\.([A-Za-z]{2,})", RegexOptions.IgnoreCase);
        }
        #endregion

        #region 验证网址
        /// <summary>
        /// 验证网址
        /// </summary>
        /// <param name="source"></param>
        /// <returns></returns>
        public static bool IsUrl(string source)
        {
            return Regex.IsMatch(source, @"^(((file|gopher|news|nntp|telnet|http|ftp|https|ftps|sftp)://)|(www\.))+(([a-zA-Z0-9\._-]+\.[a-zA-Z]{2,6})|([0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}))(/[a-zA-Z0-9\&amp;%_\./-~-]*)?$", RegexOptions.IgnoreCase);
        }
        public static bool HasUrl(string source)
        {
            return Regex.IsMatch(source, @"(((file|gopher|news|nntp|telnet|http|ftp|https|ftps|sftp)://)|(www\.))+(([a-zA-Z0-9\._-]+\.[a-zA-Z]{2,6})|([0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}))(/[a-zA-Z0-9\&amp;%_\./-~-]*)?", RegexOptions.IgnoreCase);
        }
        #endregion

        #region 验证日期
        /// <summary>
        /// 验证日期
        /// </summary>
        /// <param name="source"></param>
        /// <returns></returns>
        public static bool IsDateTime(string source)
        {
            if (string.IsNullOrWhiteSpace(source)) return false;

            return Regex.IsMatch(source, @"^2\d{3}-(?:0?[1-9]|1[0-2])-(?:0?[1-9]|[1-2]\d|3[0-1])\s(?:0?[1-9]|1\d|2[0-3]):(?:0?[1-9]|[1-5]\d):(?:0?[1-9]|[1-5]\d)$");
        }

        /// <summary>
        /// 判断是否是日期+时间格式
        /// </summary>
        /// <param name="source"></param>
        /// <returns></returns>
        public static bool IsValidDateTime(string source)
        {
            if (string.IsNullOrWhiteSpace(source)) return false;

            return Regex.IsMatch(source, @"^(19|20)\d{2}[/\s\-\.]*(0[1-9]|1[0-2]|[1-9])[/\s\-\.]*(0[1-9]|3[01]|[12][0-9]|[1-9])[\s] *(2[0-3]|[01]?\d)(:[0-5]\d){0,2}$");
        }
        /// <summary>
        /// 是否是日期格式
        /// </summary>
        /// <param name="source"></param>
        /// <returns></returns>
        public static bool IsDate(string source)
        {
            if (string.IsNullOrWhiteSpace(source)) return false;

            return Regex.IsMatch(source, @"^((((1[6-9]|[2-9]\d)\d{2})[-|/]+(0?[13578]|1[02])[-|/]+(0?[1-9]|[12]\d|3[01]))|(((1[6-9]|[2-9]\d)\d{2})-(0?[13456789]|1[012])-(0?[1-9]|[12]\d|30))|(((1[6-9]|[2-9]\d)\d{2})-0?2-(0?[1-9]|1\d|2[0-8]))|(((1[6-9]|[2-9]\d)(0[48]|[2468][048]|[13579][26])|((16|[2468][048]|[3579][26])00))-0?2-29-))$");
        }
        /// <summary>
        /// 是否为时间格式
        /// </summary>
        /// <param name="source"></param>
        /// <returns></returns>
        public static bool IsTime(string source)
        {
            if (string.IsNullOrWhiteSpace(source)) return false;

            return Regex.IsMatch(source, @"^((20|21|22|23|[0-1]?\d):[0-5]?\d:[0-5]?\d)$");
        }
        #endregion
        
        #region 验证电话
        /// <summary>
        /// 是不是中国电话，格式010-85849685/13813800000
        /// </summary>
        /// <param name="source"></param>
        /// <returns></returns>
        public static bool IsTel(string source)
        {
            if (string.IsNullOrWhiteSpace(source)) return false;

            return Regex.IsMatch(source, @"(^(\d{3,4}-)?\d{7,8}$)|(^1[3456789][0-9]{9}$)", RegexOptions.IgnoreCase);
        }
        /// <summary>
        /// 验证手机号
        /// </summary>
        /// <param name="source"></param>
        /// <returns></returns>
        public static bool IsMobile(string source)
        {
            if (string.IsNullOrWhiteSpace(source)) return false;

            return Regex.IsMatch(source, @"^1[3456789][0-9]{9}$", RegexOptions.IgnoreCase);
        }
        #endregion
        
        #region 验证中文
        /**/
        /// <summary>
        /// 中文
        /// </summary>
        /// <param name="source"></param>
        /// <returns></returns>
        public static bool IsCn(string source)
        {
            return Regex.IsMatch(source, @"^[\u4e00-\u9fa5]+$", RegexOptions.IgnoreCase);
        }
        public static bool HasCn(string source)
        {
            return Regex.IsMatch(source, @"[\u4e00-\u9fa5]+", RegexOptions.IgnoreCase);
        }
        #endregion

        #region 验证IP
        /// <summary>
        /// 验证IP
        /// </summary>
        /// <param name="source"></param>
        /// <returns></returns>
        public static bool IsIP(string source)
        {
            return Regex.IsMatch(source, @"^(25[0-5]|2[0-4][0-9]|[0-1]{1}[0-9]{2}|[1-9]{1}[0-9]{1}|[1-9])\.(25[0-5]|2[0-4][0-9]|[0-1]{1}[0-9]{2}|[1-9]{1}[0-9]{1}|[1-9]|0)\.(25[0-5]|2[0-4][0-9]|[0-1]{1}[0-9]{2}|[1-9]{1}[0-9]{1}|[1-9]|0)\.(25[0-5]|2[0-4][0-9]|[0-1]{1}[0-9]{2}|[1-9]{1}[0-9]{1}|[0-9])$", RegexOptions.IgnoreCase);
        }
        public static bool HasIP(string source)
        {
            return Regex.IsMatch(source, @"(25[0-5]|2[0-4][0-9]|[0-1]{1}[0-9]{2}|[1-9]{1}[0-9]{1}|[1-9])\.(25[0-5]|2[0-4][0-9]|[0-1]{1}[0-9]{2}|[1-9]{1}[0-9]{1}|[1-9]|0)\.(25[0-5]|2[0-4][0-9]|[0-1]{1}[0-9]{2}|[1-9]{1}[0-9]{1}|[1-9]|0)\.(25[0-5]|2[0-4][0-9]|[0-1]{1}[0-9]{2}|[1-9]{1}[0-9]{1}|[0-9])", RegexOptions.IgnoreCase);
        }
        public static bool IsValidIP(string value)
        {
            return Regex.IsMatch(value, @"^(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])$");
        }
        /// <summary>
        /// 是否端口号
        /// </summary>
        /// <param name="value"></param>
        /// <returns></returns>
        public static bool IsPort(string value)
        {
            string pattern = @"^((\d{0,4})|([1-5]\d{1,4})|(6[0-4]\d{1,3})|(65[0-4]\d{1,2})|(655[0-2]\d)|(6553[0-5]))$";

            return Regex.IsMatch(value, pattern);
        }
        #endregion

        #region 验证身份证
        /// <summary>
        /// 验证身份证是否有效
        /// </summary>
        /// <param name="Id"></param>
        /// <returns></returns>
        public static bool IsIDCard(string Id)
        {
            if (Id.Length == 18)
            {
                bool check = IsIDCard18(Id);
                return check;
            }
            else if (Id.Length == 15)
            {
                bool check = IsIDCard15(Id);
                return check;
            }
            else
            {
                return false;
            }
        }

        private static bool IsIDCard18(string Id)
        {
            long n = 0;
            if (long.TryParse(Id.Remove(17), out n) == false || n < Math.Pow(10, 16) || long.TryParse(Id.Replace('x', '0').Replace('X', '0'), out n) == false)
            {
                return false;//数字验证
            }
            string address = "11x22x35x44x53x12x23x36x45x54x13x31x37x46x61x14x32x41x50x62x15x33x42x51x63x21x34x43x52x64x65x71x81x82x91";
            if (address.IndexOf(Id.Remove(2)) == -1)
            {
                return false;//省份验证
            }
            string birth = Id.Substring(6, 8).Insert(6, "-").Insert(4, "-");
            DateTime time = new DateTime();
            if (DateTime.TryParse(birth, out time) == false)
            {
                return false;//生日验证
            }
            string[] arrVarifyCode = ("1,0,x,9,8,7,6,5,4,3,2").Split(',');
            string[] Wi = ("7,9,10,5,8,4,2,1,6,3,7,9,10,5,8,4,2").Split(',');
            char[] Ai = Id.Remove(17).ToCharArray();
            int sum = 0;
            for (int i = 0; i < 17; i++)
            {
                sum += int.Parse(Wi[i]) * int.Parse(Ai[i].ToString());
            }
            int y = -1;
            Math.DivRem(sum, 11, out y);
            if (arrVarifyCode[y] != Id.Substring(17, 1).ToLower())
            {
                return false;//校验码验证
            }
            return true;//符合GB11643-1999标准
        }

        private static bool IsIDCard15(string Id)
        {
            long n = 0;
            if (long.TryParse(Id, out n) == false || n < Math.Pow(10, 14))
            {
                return false;//数字验证
            }
            string address = "11x22x35x44x53x12x23x36x45x54x13x31x37x46x61x14x32x41x50x62x15x33x42x51x63x21x34x43x52x64x65x71x81x82x91";
            if (address.IndexOf(Id.Remove(2)) == -1)
            {
                return false;//省份验证
            }
            string birth = Id.Substring(6, 6).Insert(4, "-").Insert(2, "-");
            DateTime time = new DateTime();
            if (DateTime.TryParse(birth, out time) == false)
            {
                return false;//生日验证
            }
            return true;//符合15位身份证标准
        }

        /// <summary>
        /// 判断身份证是否合法
        /// </summary>
        /// <param name="str">身份证号码</param>
        /// <returns>bool</returns>
        public static bool IsValidID(string id)
        {
            bool error = true;

            string reg = @"^(\d{15}$|^\d{18}$|^\d{17}(\d|X|x))$";    //设置正则表达式        
            Match m = Regex.Match(id, reg);                         //判断并得到结果

            if (!m.Success)
            {//判断如果不符合正则表达式规则设置error为false;
                error = false; ;
            }

            return error;
        }
        #endregion

        #region 看字符串的长度是不是在限定数之间 一个中文为两个字符
        /**/
        /// <summary>
        /// 看字符串的长度是不是在限定数之间 一个中文为两个字符
        /// </summary>
        /// <param name="source">字符串</param>
        /// <param name="begin">大于等于</param>
        /// <param name="end">小于等于</param>
        /// <returns></returns>
        public static bool IsLengthStr(string source, int begin, int end)
        {
            int length = Regex.Replace(source, @"[^\x00-\xff]", "OK").Length;
            if ((length <= begin) && (length >= end))
            {
                return false;
            }
            return true;
        }
        #endregion

        #region 邮政编码 6个数字
        /**/
        /// <summary>
        /// 邮政编码 6个数字
        /// </summary>
        /// <param name="source"></param>
        /// <returns></returns>
        public static bool IsPostCode(string source)
        {
            return Regex.IsMatch(source, @"^\d{6}$", RegexOptions.IgnoreCase);
        }
        #endregion
        
        #region 验证是不是正常字符 字母，数字，下划线的组合
        /**/
        /// <summary>
        /// 验证是不是正常字符 字母，数字，下划线的组合
        /// </summary>
        /// <param name="source"></param>
        /// <returns></returns>
        public static bool IsNormalChar(string source)
        {
            if (HasCn(source)) return false;

            return Regex.IsMatch(source, @"[\w\d_]+", RegexOptions.IgnoreCase);
        }
        /// <summary>
        /// 是否有特殊符号
        /// </summary>
        /// <param name="domain"></param>
        /// <returns></returns>
        public static bool HasSpecialChar(string domain)
        {
            if (HasCn(domain)) return false;

            string pattern = "[`~!@#$%^&*()+=|{}':;',//\"\\[\\].<>/?~！@#￥%……&*（）——+|{}【】‘；：”“’。，、？]";
            Regex reg = new Regex(pattern);

            return reg.IsMatch(domain);
        }
        #endregion

        #region 验证域名
        /// <summary>
        /// 是否是英文域名
        /// 例：google.com
        /// </summary>
        /// <param name="domain"></param>
        /// <returns></returns>
        public static bool IsEnDomain(string domain)
        {
            string pattern = @"^[a-zA-Z0-9][-a-zA-Z0-9]{1,62}(\.[a-zA-Z0-9][-a-zA-Z0-9]{0,62})+\.?";

            Regex reg = new Regex(pattern);

            return reg.IsMatch(domain);
        }
        /// <summary>
        /// 是否中文域名
        /// </summary>
        /// <param name="domain"></param>
        /// <returns></returns>
        public static bool IsCnDomain(string domain)
        {
            string pattern = @"[\u4e00-\u9fa5][a-zA-Z0-9][-a-zA-Z0-9]{1,20}(\.[a-zA-Z0-9][-a-zA-Z0-9]{0,62})+\.?";

            Regex reg = new Regex(pattern);

            return reg.IsMatch(domain);
        }
        
        #endregion

        #endregion

        #region 获取

        /// <summary>
        /// 获取页面编码格式
        /// </summary>
        /// <param name="source"></param>
        public static string GetCharSet(string source)
        {
            Match reg = Regex.Match(source, "<meta([^<]*)charset=([^<]*)\"", RegexOptions.IgnoreCase | RegexOptions.Multiline);

            return reg.Groups[2].Value.Trim();
        }
        /// <summary>
        /// 获取域名中间的内容
        /// </summary>
        /// <param name="domain"></param>
        /// <returns></returns>
        public static string GetDomain(string domain)
        {
            Regex reg = new Regex(@"(www.)?(?<value>[a-zA-Z0-9][-a-zA-Z0-9]{1,62})", RegexOptions.IgnoreCase);

            domain = reg.Match(domain).Groups["value"].Value.ToString().Trim();

            return domain;
        }
        #endregion
    }

}
c# 工具类
zhougengxu2009的博客
02-24 543
一、c#基础 1、xmal Regex rgx = new Regex(@"^(?![0-9]+$)(?![a-zA-Z]+$)"); rgx.IsMatch(...)
C#正则表达式 - Regex类用法实操使用
Aries·Zhao
05-05 633
使用Regex类需要引用命名空间： using System.Text.RegularExpressions; C#正则表达式符号模式 字　　符 描　　述 \ 转义字符，将一个具有特殊功能的字符转义为一个普通字符，或反过来 ^ 匹配输入字符串的开始位置 $ ...
C#正则表达式工具库
爱软件-从懂得生活开始。
01-08 1329
namespace TouTou.RegexTool {     using System.Collections.Generic;     using System.Text.RegularExpressions;     ///     /// 正则表达式工具,满足各种需要使用正则的需求     ///     public class TouTouRegex    
C#底层库--RegexHelper正则表达式辅助类
花北城的博客
11-17 1373
本专栏为【底层库】，主要介绍编程过程中 通用函数。我们将这些通用固化的源码，进行重写、封装、拓展，再进行单元测试、集成测试、beta测试，最终形成通用化模板，这里我们称为“底层库”。作为研发人员的你，并不需要花大量时间，研究“底层库”的含义，及“底层库”的实现方法。你只需要几行调用代码，就可以解决项目上碰到的难题。而底层库使用方法，本专栏均有详细介绍，也有项目应用场景。
C#验证：正则表达式 验证类和界面处理（手机号码，邮箱，IP地址）
weixin_33857679的博客
12-17 151
使用步骤: 1.创建验证类 2.界面调用验证类中的方法进行验证 实例代码演示如下 1.创建验证类 using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Text.RegularExpressions; namespace Mob...
js 实现千分位
hzxOnlineOk的博客
08-05 8074
如何对一大串数值进行千分位分隔，使用户阅读更加便利，以下介绍3种方法。
Visual Studio的正则表达式插件Regex Editor
weixin_34007879的博客
06-10 402
名称：Regex Editor 地址：http://visualstudiogallery.msdn.microsoft.com/en-us/55c24bf1-2636-4f94-831d-28db8505ce00 转载于:https://www.cnblogs.com/bmate/archive/2010/06/10/1755323.html
一款免费好用的正则表达式工具：Regex Match Tracer
热门推荐
keenweiwei的专栏
07-25 4万+
推荐分享：一款免费好用的正则表达式工具：Regex Match Tracer  v2.1.5  free version 下载地址：http://pan.baidu.com/s/1hqKKrre    约340KB 长相：
C# 操作 JSON
GuoGuoABC
06-18 253
本文介绍了C#中处理JSON数据的常用方法，主要使用.NET自带的System.Text.Json库。内容涵盖：1）基本序列化/反序列化操作；2）处理集合数据；3）JSON文件读写；4）大小写问题处理；5）自定义属性名映射；6）动态JSON解析；7）结合MQTT应用示例。文章还对比了System.Text.Json与Newtonsoft.Json的使用场景，推荐新项目优先使用System.Text.Json。通过多个代码示例演示了JSON与C#对象转换的核心方法：JsonSerializer.Seriali
C# 使用 Spire.PDF 实现 PDF 到 JPG 图片的高保真转换
asdzx67的博客
06-17 381
Spire.PDF for .NET 通过方法为 .NET 开发者提供了一套完整、灵活的 PDF 转图片解决方案。从单页面的基础转换到多页面的批量处理，从 DPI 分辨率控制到内存流式输出，该库覆盖了不同业务场景下的多样化需求。开发者可根据实际应用场景，灵活组合上述技术手段，在保证输出质量的同时兼顾系统性能，实现高效、稳定的 PDF 到 JPG 图片转换功能。
C# Muai的文本控件
xiaoshuaishuais的博客
06-18 349
Xamarin.Forms输入控件对比摘要 Entry和Editor是Xamarin.Forms中常用的文本输入控件，主要区别在于： Entry适用于单行短文本（如用户名/密码），支持密码模式；Editor支持多行长文本（如评论），可自动调整高度。 两者都支持自定义键盘，但Editor通常需要更灵活的输入选项。 事件处理方面均支持文本变更和完成输入等事件。 扩展控件如Autocomplete（联想输入）和MaskedEntry（格式校验）可满足特定场景需求。开发者应根据具体输入需求（文本长度、格式要求等）选
商业软件合规证明方法论 — 多云 VMware 场景实战
探索云原生与智能化驱动下的安全运维新范式。关注DevSecOps、可观测性、AIOps等前沿领域，与您共赴技术前沿。
06-16 143
本文档为脱敏版方法论，适用于 IPO 尽调、律师函响应、年度合规自查等场景。
不挑显卡也能 GPU 加速：基于 DirectML 的 Windows OCR 推理方案
.NET 人工智能实践
06-17 317
摘要： lw.OnnxRuntime.PPOCRSharp_dml是基于ONNXRuntime与DirectML的OCR解决方案，专为Windows环境设计，支持多品牌GPU（NVIDIA/AMD/Intel），解决TensorRT仅限NVIDIA的局限。特点包括： 跨平台兼容：通过DirectML调用各类显卡，无需CUDA/TensorRT依赖； 高效部署：ONNX模型直接推理，省去TensorRT引擎转换； 灵活调用：C++封装DLL，C#通过P/Invoke集成，支持PP-OCRv5/v6多版本模型切
C#异步编程async与await
ceclar123的专栏
06-13 392
本文介绍了C#中async和await的异步编程机制
C#游戏脚本开发全流程（Unity通用完整版）
2401_84552999的博客
06-14 280
本文系统介绍了Unity引擎+C#脚本开发2D/3D游戏的完整流程，包含环境配置、脚本基础、核心功能实现及调试方法。重点讲解了Unity脚本生命周期、玩家移动控制、角色属性管理、碰撞检测和相机跟随等核心模块开发，提供可直接运行的工程代码。文章详细说明了脚本间的交互方式、场景资源加载以及常见错误排查技巧，适合零基础开发者按步骤实践，最终完成游戏开发全流程并打包发布。
基于C# winform PP-OCRv5/v6 TensorRT 推理部署
FL1623863129的博客
06-16 266
这是一个基于 Windows Forms 的光学字符识别（OCR）桌面应用程序，集成百度 PaddleOCR PP-OCRv5 和 PP-OCRv6 系列模型，使用TensorRT推理引擎在 NVIDIA GPU 上实现高性能加速推理。项目支持多种模型规格（mobile、server、tiny、small、medium），并提供可视化的检测结果展示。FIRC/├── FIRC.sln # Visual Studio 解决方案文件。
C# 与 PyTorch 互操作：TorchSharp 实战指南
最新发布
痴迷于AI技术，AI 生态的小猿猴
06-20 307
TorchSharp是PyTorch的.NET绑定，基于libtorch 2.10.0构建，让开发者能在C#中使用与Python PyTorch相同的深度学习引擎。从环境搭建讲起，详细介绍了TorchSharp的安装配置、神经网络构建（继承式和Sequential两种方式）、梯度下降原理、autograd机制和优化器选择。文章通过MNIST分类器实战案例，展示了完整的训练流程和内存管理技巧。
C# SetRegionManager 的注意事项
xiaoshuaishuais的博客
06-16 359
本文介绍了C#中Prism框架的SetRegionManager用法，包括通过IRegionManager注册视图到指定区域的基本操作，以及动态设置区域管理器的方法。重点分析了四个常见误区：1）未正确注入IRegionManager导致空引用；2）重复设置RegionManager；3）区域名称重复问题；4）未处理区域未定义异常。针对每个误区提供了具体示例和解决方案，强调依赖注入、单次设置、名称唯一性检查和区域存在性验证的重要性。
C# FileStream文件流读取文件
2501_91389120的博客
06-16 431
程序启动，窗体加载，自动执行构造方法；初始化窗体控件，创建FileStream对象绑定目标txt文件，设置只读权限；初始化5MB字节数组，作为数据缓存区；通过Read方法读取文件字节数据，存入数组，记录有效数据长度；以UTF8编码格式，将有效字节数据转为字符串；控制台打印文本内容；手动关闭文件、释放IO与内存资源，读取流程结束。FileStream基于字节操作，支持所有格式文件，通用性极强；相对路径优先于绝对路径，提升项目可移植性；
C# 预处理器指令语言 - 完整语法速查
qq_35624605的博客
06-18 192
C# 预处理器指令的完整语言参考，涵盖所有指令的精确语法、使用规则和边界条件。与前一篇教程风格的文章不同，这篇侧重语法规范和细节，适合需要精确查阅特定指令的开发者。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

MOZ-Soft

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值