C#中常用的扩展类

已于 2024-08-13 17:14:35 修改
阅读量134 收藏
点赞数 3
文章标签： c#
于 2024-08-13 15:37:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bazinga_y/article/details/141165499
版权 
    /// <summary>
    /// 常用扩展
    /// </summary>
    public static class UsualExtension
    {

        public static string[] chineseNumbers = { "零", "一", "二", "三", "四", "五", "六", "七", "八", "九" };
        public static string[] chineseUnits = { "", "十", "百", "千", "万", "亿" };

        /// <summary>                 
        /// 集合是否为空或返回元素个数为0
        /// </summary>
        /// <typeparam name="TSource">集合类型</typeparam>
        /// <param name="source">集合</param>
        /// <returns></returns>
        public static bool IsNullorZero<TSource>(this IEnumerable<TSource> source)
        {
            if (source == null || source.Count() == 0)
            {
                return true;
            }
            return false;
        }

        /// <summary>
        /// 集合转换为object数组
        /// </summary>
        /// <typeparam name="TSource">集合类型</typeparam>
        /// <param name="source">集合</param>
        /// <returns></returns>
        public static object[] ToObjectArray<TSource>(this IEnumerable<TSource> source)
        {
            return Array.ConvertAll<TSource, object>(source.ToArray(), x => (object)x);
        }

        /// <summary>
        /// 集合转换为object集合
        /// </summary>
        /// <typeparam name="TSource">集合类型</typeparam>
        /// <param name="source">集合</param>
        /// <returns></returns>
        public static List<object> ToObjectList<TSource>(this IEnumerable<TSource> source)
        {
            return source.ToObjectArray().ToList();
        }

        /// <summary>
        /// 按分隔符拼接为字符串，(字符串取类型ToString方法)
        /// </summary>
        /// <typeparam name="TSource">集合类型</typeparam>
        /// <param name="source">集合</param>
        /// <param name="separator">分隔符</param>
        /// <returns></returns>
        public static string ToSplitString<T>(this IEnumerable<T> source, string separator = ",")
        {
            if (source.IsNullorZero())
            {
                return string.Empty;
            }
            var targetArr = Array.ConvertAll<T, string>(source.ToArray(), x => x.ToString());
            return string.Join(separator, targetArr);
        }

     
        /// <summary>
        /// 日期转换成中文格式 例如：2023年7月17日10时25分01秒
        /// </summary>
        /// <param name="dt">待转化的时间</param>
        /// <returns></returns>
        public static string ConvertDateTimeToCN(this DateTime dt)
        {
            var result = string.Empty;
            if (dt != null && dt != WonderFramework.Common.BaseConst.MIN_DATE && dt != DateTime.MinValue)
            {
                result = dt.ToString("yyyy年MM月dd日HH时mm分ss秒");
            }
            return result;
        }

        /// <summary>
        /// 动态对象转换为实体对象
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="obj"></param>
        /// <returns></returns>

        public static T DynamicToEntity<T>(dynamic obj)
        {
            string json = JsonConvert.SerializeObject(obj);
            return JsonConvert.DeserializeObject<T>(json);
        }

        /// <summary>
        /// 阿拉伯数字转中文数字
        /// </summary>
        /// <param name="number"></param>
        /// <returns></returns>
        /// <exception cref="ArgumentOutOfRangeException"></exception>
        public static string ConvertToCNNumber(this int number)
        {
            if (number < 0 || number > 999999999)
                throw new ArgumentOutOfRangeException("Number out of range");

            if (number == 0)
                return chineseNumbers[0];

            string result = "";
            int unitIndex = 0;

            while (number > 0)
            {
                int digit = number % 10;
                if (digit != 0)
                {
                    result = chineseNumbers[digit] + chineseUnits[unitIndex] + result;
                }
                else
                {
                    // Add zero only if it's not already the first character
                    if (result.Length > 0 && result[0] != chineseNumbers[0][0])
                        result = chineseNumbers[digit] + result;
                }

                number /= 10;
                unitIndex++;
            }

            return result;
        }

        /// <summary>
        /// 日期时间格式成yyyy-MM-dd HH:mm:ss 格式
        /// </summary>
        /// <param name="sourceDate"></param>
        /// <returns></returns>
        public static string ToLongDateTimeFormat(this DateTime sourceDate)
        {
            return sourceDate.ToString("yyyy-MM-dd HH:mm:ss");
        }


        /// <summary>
        /// 日期时间格式成yyyy-MM-dd格式
        /// </summary>
        /// <param name="sourceDate"></param>
        /// <returns></returns>
        public static string ToShortDateTimeFormat(this DateTime sourceDate)
        {
            return sourceDate.ToString("yyyy-MM-dd");
        }

        /// <summary>
        /// 通过反射动态给实体某个字段赋值
        /// </summary>
        /// <param name="obj">实体对象</param>
        /// <param name="propertyName">字段名称</param>
        /// <param name="value">具体值</param>
        /// <exception cref="ArgumentException"></exception>
        public static void SetPropertyValue(this object obj, string propertyName, object value)
        {
            // 获取obj的类型  
            Type type = obj.GetType();

            if (string.IsNullOrEmpty(propertyName))
            {
                return;
            }
            // 获取该类型上名为propertyName的属性  
            PropertyInfo property = type.GetProperty(propertyName);

            // 检查属性是否存在且可写  
            if (property != null && property.CanWrite)
            {
                // 尝试将值转换为属性的类型（如果需要的话）  
                value = Convert.ChangeType(value, property.PropertyType);

                // 设置属性值  
                property.SetValue(obj, value, null);
            }
            else
            {
                // 属性不存在或不可写，你可以根据需要抛出异常或记录日志  
                throw new ArgumentException($"Property {propertyName} does not exist or is not writable on object of type {type.Name}.");
            }
        }

        public static List<T> ToEntityList<T>(this DataTable dataTable) where T : new()
        {
            var list = new List<T>();
            var properties = typeof(T).GetProperties();

            // 创建一个映射字典
            var mapping = properties.ToDictionary(
                p => p.Name,
                p => dataTable.Columns.Cast<DataColumn>()
                                      .Select(c => c.ColumnName)
                                      .FirstOrDefault(colName => colName.Replace("_", "").ToLower() == p.Name.Replace("_", "").ToLower())
            );

            foreach (DataRow row in dataTable.Rows)
            {
                var item = new T();
                foreach (var prop in properties)
                {
                    var columnName = mapping[prop.Name];
                    if (columnName != null && row.Table.Columns.Contains(columnName))
                    {
                        var value = row[columnName];
                        // 检查 DBNull.Value
                        if (value == DBNull.Value)
                        {
                            prop.SetValue(item, prop.PropertyType.IsValueType ? Activator.CreateInstance(prop.PropertyType) : null);
                        }
                        else
                        {
                            try
                            {  //Eps类型的属性不需要动态赋值,bug1208201038
                                if (prop.PropertyType.ToString().IndexOf("Eps") >= 0
                                    || prop.PropertyType.ToString().IndexOf("IList") >= 0)
                                    continue;

                                Type tempObj = prop.PropertyType;
                                if (tempObj != typeof(System.String) && value == null)
                                {
                                    continue;
                                }
                                if (tempObj != typeof(System.String) && value.ToString() == "")
                                {
                                    continue;
                                }
                                // 特殊类型处理
                                if (prop.PropertyType == typeof(DateTime))
                                {
                                    prop.SetValue(item, DateTime.Parse(value.ToString()));
                                }
                                else if (prop.PropertyType == typeof(double))
                                {
                                    prop.SetValue(item, double.Parse(value.ToString()));
                                }
                                else if (prop.PropertyType == typeof(int))
                                {
                                    prop.SetValue(item, int.Parse(value.ToString()));
                                }
                                else
                                {
                                    // 使用 Convert.ChangeType 处理其他类型
                                    prop.SetValue(item, Convert.ChangeType(value, Nullable.GetUnderlyingType(prop.PropertyType) ?? prop.PropertyType));
                                }
                            }
                            catch (Exception ex)
                            {
                                throw new InvalidOperationException($"Failed to convert property '{prop.Name}' from type '{value?.GetType() ?? typeof(object)}' to '{prop.PropertyType}'", ex);
                            }
                        }
                    }
                }
                list.Add(item);
            }

            return list;
        }


        /// <summary>
        /// 获取你能提交的天数集合
        /// </summary>
        /// <param name="startDay"></param>
        /// <param name="endDay">采取硬编码 31号</param>
        /// <returns></returns>
        public static List<int> GetCanSubmitDaysSimplified(int startDay, int endDay)
        {
            if (startDay == endDay) // 表示当天
            {
                return new List<int> { startDay };
            }
            else if (endDay < startDay)
            {
                // 跨月情况
                return Enumerable.Range(startDay, 31 - startDay + 1)
                                 .Concat(Enumerable.Range(1, endDay))
                                 .ToList();
            }
            else
            {
                // 同一个月内
                return Enumerable.Range(startDay, endDay - startDay + 1).ToList();
            }
        }

        /// <summary>
        /// 判断数组是否相等
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="array1"></param>
        /// <param name="array2"></param>
        /// <returns></returns>
        public static bool AreArraysEqual<T>(T[] array1, T[] array2)
        {
            if (array1.Length != array2.Length)
                return false;

            for (int i = 0; i < array1.Length; i++)
            {
                if (!array1[i].Equals(array2[i]))
                    return false;
            }

            return true;
        }

        /// <summary>
        /// 比较两个实体对象的属性值。
        /// </summary>
        /// <typeparam name="T">实体类的类型。</typeparam>
        /// <param name="entity1">第一个实体对象。</param>
        /// <param name="entity2">第二个实体对象。</param>
        /// <returns>如果所有属性值相同返回true，否则返回false并记录不同的属性。</returns>
        public static Tuple<bool, Dictionary<string, Tuple<object, object>>> CompareEntities<T>(T entity1, T entity2)
            where T : class
        {
            var propertyDifferences = new Dictionary<string, Tuple<object, object>>();
            bool isEqual = true;

            foreach (var property in typeof(T).GetProperties())
            {
                // 检查属性上是否有 [WonderProperty] 注解
                var hasWonderPropertyAttribute = property.GetCustomAttribute<WonderPropertyAttribute>() != null;

                if (hasWonderPropertyAttribute)
                {
                    var value1 = property.GetValue(entity1);
                    var value2 = property.GetValue(entity2);

                    if ((value1 == null && value2 != null) || (value1 != null && value2 == null) || (value1 != null && !value1.Equals(value2)))
                    {
                        propertyDifferences.Add(property.Name, Tuple.Create(value1, value2));
                        isEqual = false;
                    }
                }
            }

            return Tuple.Create(isEqual, propertyDifferences);
        }
    }
    ```
贰貮
关注
C#中的字符串, String类和StringBuilder类
苏州程序大白的博客
05-14 2450
C#中的字符串, String类和StringBuilder类 1、简介 字符串对大多数计算机程序而言非常普遍. 像文字处理软件和网页应用程序这些程序类型 都广泛采用了字符串. 这使得处理这类应用程序的程序员在字符串处理的效率问题上需要花费额外的心思. 本章会研究C#处理字符串的方法, 分析如何使用String类, 最后还会介绍如何用StringBuilder类. 当程序需要对String对象进行许多改变时会用到StringBuilder类. 这是因为字符串和String对象都是不可改变的,
常用的公共类C#_非常好用
01-02
真很不错！ 用了就知道啊 用了就知道啊
C# Static与拓展方法
weixin_43735634的博客
01-20 688
当我们声明一个类成员为静态时，意味着无论有多少个类的对象被创建，只会有一个静态成员。静态成员属于类，类的静态成员变量常用于用于定义常量，因为它们的值可以通过直接调用类而不需要创建类的实例来获取。（当然类的实例化对象也可以获取静态成员）当静态成员变量没有初始化时，系统会生成一个默认静态构造函数为静态成员变量赋值（数值类型是0，引用类型是null）。因为普通的成员变量只有在类实例化对象时才分配内存，当调用静态成员函数时不能去使用没有分配内存的成员变量。**静态类不能被实例化，不能被继承，只能包含静态成员。
C#中常用的单词
weixin_30938149的博客
02-13 874
visual 可见的 studio 工作室 dot 点 net 网 sharp 尖端的，锋利的。 framework 骨架，构架，框架 beta 测试版，试用版 XML（全称：eXtensible Markup Language） 可扩展标记语言 extensible 可扩展的 ASP（全称：Active Server Page） 活动服务器网页 activ...
c# 常用框架收藏
爱技术、爱生活、爱健康
07-05 1087
Json.NET Math.NET Faker.Net Html Agility Pack NCrawler SuperWebSocket SuperSocket Quartz.NET Lucene.Net HttpLib Smart Thread Pool DocX PDFsharp Dapper NHibernate log4net SharpSerializer XProxy nopCommerce Enterprise Library Autofac ...
C#中常用单词
weixin_30819085的博客
03-27 342
一 　 visual 可见的 studio 工作室 dot 点 net 网 sharp 尖端的，锋利的。 framework 骨架，构架，框架 beta 测试版，试用版 XML（全称：eXtensible Markup Language） 可扩展标记语言 extensible ...
C# 枚举
热门推荐
TheWindOfFate的博客
01-15 1万+
C# Enum（枚举）和一些简单用法，声明枚举、添加自定义属性、获取常量名、获取自定义属性
C#程序员面试题
wangnanofspirit的博客
05-13 1635
C#初级程序员面试题可以涵盖多个方面，包括语言基础、面向对象编程、异常处理、命名空间、Web服务等。C#高级程序员面试题通常会涉及到更深入的技术领域和更复杂的编程问题。
C#快速入门
wuhuanyicheng的博客
06-27 6303
通过使用LINQ查询，可以从Dictionary对象中筛选出符合某些特定条件的元素。下面以一个Dictionary为例，演示如何使用LINQ查询语法从Dictionary中筛选出所有值大于2的键值对。
C# 中常用控件的查询手册
08-21
本手册旨在提供C#中常用控件的功能与用法的详细指南，帮助开发者在编程过程中快速查找和理解相关知识。 1. **窗体（Form）** 窗体是所有用户界面的基础，它是所有控件的容器。在C#中，窗体通过`System.Windows....
AlphaGradientPanel.rar_C# 形状的Panel_panel_panel 扩展
09-24
在这个特定的案例中，我们关注的是一个名为"AlphaGradientPanel"的自定义控件，它是一个扩展了标准Windows Forms Panel控件的类。AlphaGradientPanel.rar文件包含了实现这个功能的源代码，可能包括一个或多个.cs文件...
CSharp-the-three-control.rar_C# 工业控件_Csharp 工业控件_c#与工控_csharp 工业
07-14
C#在工业控制领域的应用广泛，其强类型、面向对象的特性使得代码更易于维护和扩展。此外，C#支持多线程、网络通信和数据库操作，这些都是工控系统中的关键功能。通过C#，开发者可以构建分布式、实时的控制系统，...
C#基础知识
记忆中的星空的博客
02-15 6000
C#基础知识，跟随铁锰老师教学视频总结
C#匿名方法
nazabanne的博客
09-12 756
在C#中，匿名函数是一种没有名字的方法，可以在代码中定义和使用。我们已经提到过，委托是用于引用与其具有相同标签的方法。换句话说，可以使用委托对象调用可由委托引用的方法。匿名方法（Anonymous methods）提供了一种传递代码块作为委托参数的技术。在匿名方法中不需要指定返回类型，它是从方法主体内的return语句推断的。
使用c#制作一个小型桌面程序
qq_44691564的博客
09-14 843
创建.NET Framework新项目，将之前生成的dll放在Demo文件夹的bin ->debug或是 release中（看你自己用的什么模式），创建完成后 系统会自动生成一些文件，其中 pch.cpp 先不要修改，pch.h中先导入自己需要用到的库，下面是我的代码。布局完了之后会自动生成Form1.Designer.cs 的窗口设计代码，点击控件按F4 还可以修改他们的属性。完成之后点击生成 就可以在bin中出现的你的.exe文件咯，是不是很简单呀~[狗头]我们还需要一个入口主程序。
联合仿真（FMI,FMU）资料收集
听星的专栏
09-14 265
最近在研究使用Unity导入FMU模块进行仿真的功能。做功能前先尽可能收集下资料。
c#visionpro开发 方法统计
最新发布
视觉人机器视觉的博客
09-17 1257
C#visionpro开发 方法统计
002集—— CAD划线并模拟向命令窗口发送命令（CAD—C#二次开发入门）
yongshiqq的博客
09-14 426
模拟向命令窗口发送全图居中的命令： Application.DocumentManager.MdiActiveDocument.SendStringToExecute("z\ne\n",true,false,false);
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值