devbox
你好赵伟
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

C#个人珍藏基础类库分享 — 8、通用工具帮助类ToolHelper_c# 常用类库

作者：你好赵伟 | 2024-03-13 09:26:12

赞

踩

c# 常用类库

        做.NET开发的同学，一套简单易用的基础类库是必不可少的，这里把我混迹C#圈子十余载珍藏的类库分享出来，希望能够给刚踏入开发门槛的朋友一些帮助。

        后续会逐步分享基础库的其余部分，先列个大纲：

C#个人珍藏基础类库分享 — 1、通用缓存帮助类CacheHelper
C#个人珍藏基础类库分享 — 2、Memcached缓存帮助类MemcachedHelper
C#个人珍藏基础类库分享 — 3、目录、文件帮助类FileHelper
C#个人珍藏基础类库分享 — 4、字节数组帮助类BytesObjectHelper
C#个人珍藏基础类库分享 — 5、日志帮助类LogHelper
C#个人珍藏基础类库分享 — 6、数据库处理帮助类SqlHelper
C#个人珍藏基础类库分享 — 7、Xml处理帮助类XmlHelper
C#个人珍藏基础类库分享 — 8、通用工具帮助类ToolHelper

通用工具帮助类包括方法目录如下：     

1、类型验证相关

     1.1 判断字符串是否为数字 

     1.2 判断字符串是否为整型

     1.3 判断字符串是否为日期

2、类型转换相关

     2.1 获得字符串值

     2.2 获取8位整型值

     2.3 获得16位整型值

     2.4 获得整型值

     2.5 获得长整型值

     2.6 获得双精度值

     2.7 获得时间类型值

3、数组相关

     3.1 将以分隔符分隔的字符串转为int数组

     3.2 合并一组可枚举的对象为字符串

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Data;
  6. using System.Web;
  7. using System.Net;
  8. using System.IO;
  9. using System.Collections;
  10. using System.Configuration;
  11.  
  12. namespace BaseUtilities
  13. {
  14.     /// <summary>
  15.     /// 常用的工具类静态方法集合。
  16.     /// </summary>
  17.     public class Tools
  18.     {
  19.         #region 类型验证
  20.  
  21.         /// <summary>
  22.         /// 判断字符串是否为数字
  23.         /// </summary>
  24.         /// <param name="src"></param>
  25.         /// <returns></returns>
  26.         public static bool IsNumber(string src)
  27.         {
  28.             try
  29.             {
  30.                 decimal d = decimal.Parse(src);
  31.                 return true;
  32.             }
  33.             catch
  34.             {
  35.                 return false;
  36.             }
  37.         }
  38.  
  39.         /// <summary>
  40.         /// 判断字符串是否为整型
  41.         /// </summary>
  42.         /// <param name="src"></param>
  43.         /// <returns></returns>
  44.         public static bool IsInt(string src)
  45.         {
  46.             try
  47.             {
  48.                 int d = int.Parse(src);
  49.                 return true;
  50.             }
  51.             catch
  52.             {
  53.                 return false;
  54.             }
  55.         }
  56.         
  57.         /// <summary>
  58.         /// 判断字符串是否为日期
  59.         /// </summary>
  60.         /// <param name="src"></param>
  61.         /// <returns></returns>
  62.         public static bool IsDatetime(string src)
  63.         {
  64.             if (src.Trim() == "")
  65.                 return false;
  66.             try
  67.             {
  68.                 DateTime d = DateTime.Parse(src);
  69.                 d = Convert.ToDateTime(src);
  70.                 return true;
  71.             }
  72.             catch
  73.             {
  74.                 return false;
  75.             }
  76.         }
  77.  
  78.         #endregion
  79.  
  80.         #region 类型转换
  81.  
  82.         /// <summary>
  83.         /// 获得字符串值。
  84.         /// <para>该方法会将 string.Empty 转换为 defaultValue。</para>
  85.         /// <para>该方法用于依据一个对象，始终得到一个不为空的字符串（除非调用者将 defaultVal 设置为空）。</para>
  86.         /// <para>它等价于在程序中对象判空、ToString、IsNullOrEmpty等处理。</para>
  87.         /// </summary>
  88.         /// <param name="src">源对象</param>
  89.         /// <param name="defaultVal">转换失败时期望返回的字符串值</param>
  90.         /// <returns></returns>
  91.         public static string GetStr(object src, string defaultVal)
  92.         {
  93.             return GetStr(src, defaultVal, true);
  94.         }
  95.  
  96.         /// <summary>
  97.         /// 获得字符串值。
  98.         /// <para>该方法会将 string.Empty 转换为 defaultValue。</para>
  99.         /// <para>该方法用于依据一个对象，始终得到一个不为空的字符串（除非调用者将 defaultVal 设置为空）。</para>
  100.         /// <para>它等价于在程序中对象判空、ToString、IsNullOrEmpty等处理。</para>
  101.         /// </summary>
  102.         /// <param name="src">源对象</param>
  103.         /// <param name="defaultVal">转换失败时期望返回的字符串值</param>
  104.         /// <param name="disallowEmpty">是否不允许空值（将 string.Empty 转换为 defaultValue）</param>
  105.         /// <returns></returns>
  106.         public static string GetStr(object src, string defaultVal, bool disallowEmpty)
  107.         {
  108.             if (src == null)
  109.                 return defaultVal;
  110.             if (disallowEmpty && src.ToString().Length == 0)
  111.                 return defaultVal;
  112.             return src.ToString();
  113.         }
  114.  
  115.         /// <summary>
  116.         /// 获取8位整型值。
  117.         /// </summary>
  118.         /// <param name="src">长整型值</param>
  119.         /// <returns></returns>
  120.         public static byte GetByte(long src)
  121.         {
  122.             if (src > byte.MaxValue)
  123.                 return byte.MaxValue;
  124.             else if (src < byte.MinValue)
  125.                 return byte.MinValue;
  126.             return (byte)src;
  127.         }
  128.  
  129.         /// <summary>
  130.         /// 获得16位整型值。
  131.         /// </summary>
  132.         /// <param name="src">源对象</param>
  133.         /// <param name="defaultVal">转换失败时期望返回的整型值</param>
  134.         /// <param name="scale">源字符串的进位制，如16、10、8、2等</param>
  135.         /// <returns></returns>
  136.         public static short GetShort(object src, short defaultVal, int scale)
  137.         {
  138.             short rv;
  139.             try
  140.             {
  141.                 rv = Convert.ToInt16(src.ToString().Trim(), scale);
  142.             }
  143.             catch
  144.             {
  145.                 rv = defaultVal;
  146.             }
  147.             return rv;
  148.         }
  149.  
  150.         /// <summary>
  151.         /// 获得16位整型值。
  152.         /// </summary>
  153.         /// <param name="src">源对象</param>
  154.         /// <param name="defaultVal">转换失败时期望返回的整型值</param>
  155.         /// <returns></returns>
  156.         public static short GetShort(object src, short defaultVal)
  157.         {
  158.             short rv;
  159.             if (src != null && short.TryParse(src.ToString().Trim(), out rv))
  160.                 return rv;
  161.             return defaultVal;
  162.         }
  163.  
  164.         /// <summary>
  165.         /// 获取16位整型值。
  166.         /// </summary>
  167.         /// <param name="src">长整型值</param>
  168.         /// <returns></returns>
  169.         public static short GetShort(long src)
  170.         {
  171.             if (src > short.MaxValue)
  172.                 return short.MaxValue;
  173.             else if (src < short.MinValue)
  174.                 return short.MinValue;
  175.             return (short)src;
  176.         }
  177.  
  178.         /// <summary>
  179.         /// 获得整型值。
  180.         /// </summary>
  181.         /// <param name="src">源对象</param>
  182.         /// <param name="defaultVal">转换失败时期望返回的整型值</param>
  183.         /// <param name="scale">源字符串的进位制，如16、10、8、2等</param>
  184.         /// <returns></returns>
  185.         public static int GetInt(object src, int defaultVal, int scale)
  186.         {
  187.             int rv;
  188.             try
  189.             {
  190.                 rv = Convert.ToInt32(src.ToString().Trim(), scale);
  191.             }
  192.             catch
  193.             {
  194.                 rv = defaultVal;
  195.             }
  196.             return rv;
  197.         }
  198.  
  199.         /// <summary>
  200.         /// 获得整型值。
  201.         /// </summary>
  202.         /// <param name="src">源对象</param>
  203.         /// <param name="defaultVal">转换失败时期望返回的整型值</param>
  204.         /// <returns></returns>
  205.         public static int GetInt(object src, int defaultVal)
  206.         {
  207.             int rv;
  208.             if (src != null && int.TryParse(src.ToString().Trim(), out rv))
  209.                 return rv;
  210.             return defaultVal;
  211.         }
  212.  
  213.         /// <summary>
  214.         /// 获取整型值。
  215.         /// </summary>
  216.         /// <param name="src">长整型值</param>
  217.         /// <returns></returns>
  218.         public static int GetInt(long src)
  219.         {
  220.             if (src > int.MaxValue)
  221.                 return int.MaxValue;
  222.             else if (src < int.MinValue)
  223.                 return int.MinValue;
  224.             return (int)src;
  225.         }
  226.  
  227.         /// <summary>
  228.         /// 获得长整型值。
  229.         /// </summary>
  230.         /// <param name="src">源对象</param>
  231.         /// <param name="defaultVal">转换失败时期望返回的长整型值</param>
  232.         /// <param name="scale">源字符串的进位制，如16、10、8、2等</param>
  233.         /// <returns></returns>
  234.         public static long GetLong(object src, long defaultVal, int scale)
  235.         {
  236.             long rv;
  237.             try
  238.             {
  239.                 rv = Convert.ToInt64(src.ToString().Trim(), scale);
  240.             }
  241.             catch
  242.             {
  243.                 rv = defaultVal;
  244.             }
  245.             return rv;
  246.         }
  247.  
  248.         /// <summary>
  249.         /// 获得长整型值。
  250.         /// </summary>
  251.         /// <param name="src">源对象</param>
  252.         /// <param name="defaultVal">转换失败时期望返回的长整型值</param>
  253.         /// <returns></returns>
  254.         public static long GetLong(object src, long defaultVal)
  255.         {
  256.             long rv;
  257.             if (src != null && long.TryParse(src.ToString(), out rv))
  258.                 return rv;
  259.             return defaultVal;
  260.         }
  261.  
  262.         /// <summary>
  263.         /// 获得双精度值。
  264.         /// </summary>
  265.         /// <param name="src">源对象</param>
  266.         /// <param name="defaultVal">转换失败时期望返回的双精度值</param>
  267.         /// <returns></returns>
  268.         public static double GetDouble(object src, double defaultVal)
  269.         {
  270.             double rv;
  271.             if (src != null && double.TryParse(src.ToString(), out rv))
  272.                 return rv;
  273.             return defaultVal;
  274.         }
  275.  
  276.         /// <summary>
  277.         /// 获得时间类型值
  278.         /// </summary>
  279.         /// <param name="src">源对象</param>
  280.         /// <param name="defaultVal">转换失败时期望返回的时间类型值</param>
  281.         /// <returns></returns>
  282.         public static DateTime GetDatetime(object src, DateTime defaultVal)
  283.         {
  284.             DateTime dt;
  285.             if (src != null && DateTime.TryParse(src.ToString(), out dt))
  286.                 return dt;
  287.             return defaultVal;
  288.         }
  289.  
  290.         #endregion
  291.  
  292.         #region Byte相关
  293.  
  294.         /// <summary>
  295.         /// 返回由字节数组中指定位置的两个字节转换来的 16 位有符号整型 (NetworkToHostOrder)。
  296.         /// </summary>
  297.         /// <param name="src">字节数组</param>
  298.         /// <param name="startIndex">读数起始位置</param>
  299.         /// <returns></returns>
  300.         public static short ReadShort(byte[] src, int startIndex)
  301.         {
  302.             return IPAddress.NetworkToHostOrder(BitConverter.ToInt16(src, startIndex));
  303.         }
  304.  
  305.         /// <summary>
  306.         /// 返回由字节数组中指定位置的两个字节转换来的 32 位有符号整型 (NetworkToHostOrder)。
  307.         /// </summary>
  308.         /// <param name="src">字节数组</param>
  309.         /// <param name="startIndex">读数起始位置</param>
  310.         /// <returns></returns>
  311.         public static int ReadInt(byte[] src, int startIndex)
  312.         {
  313.             return IPAddress.NetworkToHostOrder(BitConverter.ToInt32(src, startIndex));
  314.         }
  315.  
  316.         /// <summary>
  317.         /// 返回由字节数组中指定位置的两个字节转换来的 32 位无符号整型 (NetworkToHostOrder)。
  318.         /// </summary>
  319.         /// <param name="src">字节数组</param>
  320.         /// <param name="startIndex">读数起始位置</param>
  321.         /// <returns></returns>
  322.         public static uint ReadUInt(byte[] src, int startIndex)
  323.         {
  324.             return (uint)IPAddress.NetworkToHostOrder((long)BitConverter.ToUInt32(src, startIndex));
  325.         }
  326.  
  327.         /// <summary>
  328.         /// 返回由字节数组中指定位置的两个字节转换来的 64 位有符号整型 (NetworkToHostOrder)。
  329.         /// </summary>
  330.         /// <param name="src">字节数组</param>
  331.         /// <param name="startIndex">读数起始位置</param>
  332.         /// <returns></returns>
  333.         public static long ReadLong(byte[] src, int startIndex)
  334.         {
  335.             return IPAddress.NetworkToHostOrder(BitConverter.ToInt64(src, startIndex));
  336.         }
  337.  
  338.         /// <summary>
  339.         /// 获得byte数组。
  340.         /// </summary>
  341.         /// <param name="src">整型值</param>
  342.         /// <returns></returns>
  343.         public static byte[] GetBytes(int src)
  344.         {
  345.             return BitConverter.GetBytes(IPAddress.HostToNetworkOrder(src));
  346.         }
  347.  
  348.         /// <summary>
  349.         /// 获得byte数组。
  350.         /// </summary>
  351.         /// <param name="src">短整型值</param>
  352.         /// <returns></returns>
  353.         public static byte[] GetBytes(short src)
  354.         {
  355.             return BitConverter.GetBytes(IPAddress.HostToNetworkOrder(src));
  356.         }
  357.  
  358.         /// <summary>
  359.         /// 获得byte数组。
  360.         /// </summary>
  361.         /// <param name="src">长整型值</param>
  362.         /// <returns></returns>
  363.         public static byte[] GetBytes(long src)
  364.         {
  365.             return BitConverter.GetBytes(IPAddress.HostToNetworkOrder(src));
  366.         }
  367.  
  368.         /// <summary>
  369.         /// 获得byte数组。
  370.         /// </summary>
  371.         /// <param name="src">整型值</param>
  372.         /// <param name="bytesRightLen">要靠右保留的byte个数</param>
  373.         /// <returns></returns>
  374.         public static byte[] RightBytes(byte[] src, int bytesRightLen)
  375.         {
  376.             byte[] retBytes = new byte[bytesRightLen];
  377.             Array.Copy(src, src.Length - bytesRightLen, retBytes, 0, bytesRightLen);
  378.             return retBytes;
  379.         }
  380.  
  381.         #endregion
  382.  
  383.         #region 数组相关
  384.  
  385.         /// <summary>
  386.         /// 将以分隔符分隔的字符串转为int数组
  387.         /// </summary>
  388.         /// <param name="str"></param>
  389.         /// <param name="seperator"></param>
  390.         /// <returns></returns>
  391.         public static int[] SplitToInt32Array(string str, string seperator)
  392.         {
  393.             string[] items = str.Split(new string[] { seperator }, StringSplitOptions.RemoveEmptyEntries);
  394.             int[] array = new int[items.Length];
  395.             for (int i = items.Length - 1; i >= 0; i--)
  396.             {
  397.                 int value;
  398.                 if (!int.TryParse(items[i], out value))
  399.                     return null;
  400.                 array[i] = value;
  401.             }
  402.             return array;
  403.         }
  404.  
  405.         /// <summary>
  406.         /// 将以分隔符分隔的字符串转为int数组
  407.         /// </summary>
  408.         /// <param name="str"></param>
  409.         /// <param name="seperators"></param>
  410.         /// <returns></returns>
  411.         public static int[] SplitToInt32Array(string str, string[] seperators)
  412.         {
  413.             string[] items = str.Split(seperators, StringSplitOptions.RemoveEmptyEntries);
  414.             int[] array = new int[items.Length];
  415.             for (int i = items.Length - 1; i >= 0; i--)
  416.             {
  417.                 int value;
  418.                 if (!int.TryParse(items[i], out value))
  419.                     return null;
  420.                 array[i] = value;
  421.             }
  422.             return array;
  423.         }
  424.  
  425.         /// <summary>
  426.         /// 合并一组可枚举的对象为字符串
  427.         /// </summary>
  428.         /// <param name="enumerable">被枚举对象</param>
  429.         /// <param name="seperator">分隔符</param>
  430.         /// <returns></returns>
  431.         public static string ConcatEnumerable(IEnumerable enumerable, string seperator)
  432.         {
  433.             IEnumerator enumerator = enumerable.GetEnumerator();
  434.             if (!enumerator.MoveNext())
  435.                 return string.Empty;
  436.             StringBuilder text = new StringBuilder(128);
  437.             text.Append(enumerator.Current.ToString());
  438.             while (enumerator.MoveNext())
  439.             {
  440.                 text.Append(seperator + enumerator.Current);
  441.             }
  442.             return text.ToString();
  443.         }
  444.  
  445.         #endregion
  446.  
  447.         #region 列表分页相关
  448.         /// <summary>
  449.         /// 获取分页起始索引（同时验证与修改参数）
  450.         /// </summary>
  451.         /// <param name="pageSize">每页显示记录数</param>
  452.         /// <param name="pageIndex">当前是第几页</param>
  453.         /// <returns></returns>
  454.         public static int GetStartRec(ref int pageSize, ref int pageIndex)
  455.         {
  456.             if (pageSize < 1) pageSize = 20;
  457.             if (pageIndex < 1) pageIndex = 1;
  458.             return pageSize * (pageIndex - 1) + 1;
  459.         }
  460.  
  461.         /// <summary>
  462.         /// 获取分页终止索引（不验证参数）
  463.         /// </summary>
  464.         /// <param name="pageSize">每页显示记录数</param>
  465.         /// <param name="pageIndex">当前是第几页</param>
  466.         /// <returns></returns>
  467.         public static int GetEndRec(int pageSize, int pageIndex)
  468.         {
  469.             return pageSize * pageIndex;
  470.         }
  471.  
  472.         /// <summary>
  473.         /// 获取分页起始索引（同时验证与修改参数）
  474.         /// </summary>
  475.         /// <param name="pageSize">每页显示记录数</param>
  476.         /// <param name="pageIndex">当前是第几页</param>
  477.         /// <returns></returns>
  478.         public static long GetStartRec(ref long pageSize, ref long pageIndex)
  479.         {
  480.             if (pageSize < 1) pageSize = 20;
  481.             if (pageIndex < 1) pageIndex = 1;
  482.             return pageSize * (pageIndex - 1) + 1;
  483.         }
  484.  
  485.         /// <summary>
  486.         /// 获取分页终止索引（不验证参数）
  487.         /// </summary>
  488.         /// <param name="pageSize">每页显示记录数</param>
  489.         /// <param name="pageIndex">当前是第几页</param>
  490.         /// <returns></returns>
  491.         public static long GetEndRec(long pageSize, long pageIndex)
  492.         {
  493.             return pageSize * pageIndex;
  494.         }
  495.  
  496.         /// <summary>
  497.         /// 根据记录总数与每页记录数，计算分页总数
  498.         /// </summary>
  499.         /// <param name="recordCount">记录总数</param>
  500.         /// <param name="pageSize">每页记录数</param>
  501.         /// <returns></returns>
  502.         public static int GetPageSize(int recordCount, int pageSize)
  503.         {
  504.             return (int)Math.Ceiling((double)recordCount / pageSize);
  505.         }
  506.         #endregion
  507.  
  508.         #region 其它
  509.  
  510.         /// <summary>
  511.         /// 得到Request中指定参数的值（返回String值）
  512.         /// </summary>
  513.         /// <param name="keyName">要获取的参数的名称</param>
  514.         /// <param name="defaultVal">当不存在该参数时返回的默认值</param>
  515.         /// <returns></returns>
  516.         public static string GetRequestVal(string keyName, string defaultVal)
  517.         {
  518.             string rv = System.Web.HttpContext.Current.Request[keyName];
  519.             return Tools.GetStr(rv, defaultVal);
  520.         }
  521.  
  522.         /// <summary>
  523.         /// 得到Request中指定参数的值（返回Int值）
  524.         /// </summary>
  525.         /// <param name="keyName">要获取的参数的名称</param>
  526.         /// <param name="defaultVal">当不存在该参数时返回的默认值</param>
  527.         /// <returns></returns>
  528.         public static int GetRequestVal(string keyName, int defaultVal)
  529.         {
  530.             string rv = System.Web.HttpContext.Current.Request[keyName];
  531.             return Tools.GetInt(rv, defaultVal);
  532.         }
  533.  
  534.         /// <summary>
  535.         /// 得到一个系统配置项的值
  536.         /// </summary>
  537.         /// <param name="keyName">配置项名称</param>
  538.         /// <param name="defaultVal">在不存在该配置项时返回的默认值</param>
  539.         /// <returns></returns>
  540.         public static string GetAppSetting(string keyName, string defaultVal)
  541.         {
  542.             string rv = System.Configuration.ConfigurationManager.AppSettings[keyName];
  543.             return Tools.GetStr(rv, defaultVal);
  544.         }
  545.  
  546.         /// <summary>
  547.         /// 得到一个系统配置项的值
  548.         /// </summary>
  549.         /// <param name="keyName">配置项名称</param>
  550.         /// <param name="defaultVal">在不存在该配置项时返回的默认值</param>
  551.         /// <returns></returns>
  552.         public static int GetAppSetting(string keyName, int defaultVal)
  553.         {
  554.             string rv = System.Configuration.ConfigurationManager.AppSettings[keyName];
  555.             return Tools.GetInt(rv, defaultVal);
  556.         }
  557.  
  558.         /// <summary>
  559.         /// 得到一个连接字符串配置项的值
  560.         /// <para>当配置不存在时，返回Null</para>
  561.         /// </summary>
  562.         /// <param name="keyName">配置项名称</param>
  563.         /// <returns></returns>
  564.         public static string GetConnStrConfig(string keyName)
  565.         {
  566.             if(ConfigurationManager.ConnectionStrings[keyName] != null)
  567.                 return System.Configuration.ConfigurationManager.ConnectionStrings[keyName].ConnectionString;
  568.             return null;
  569.         }
  570.  
  571.         /// <summary>
  572.         /// 获得字符串值的前N位字符
  573.         /// </summary>
  574.         /// <param name="src">指定的字符串</param>
  575.         /// <param name="len">指定的长度</param>
  576.         /// <returns></returns>
  577.         public static string GetLenthStr(string src, int len)
  578.         {
  579.             if (src.Length > len)
  580.                 return src.Substring(0, len);
  581.             return src;
  582.         }
  583.  
  584.         /// <summary>
  585.         /// 对字符串进行编码，以保证SQL参数的安全性
  586.         /// </summary>
  587.         /// <param name="src"></param>
  588.         /// <returns></returns>
  589.         public static string EncodeStr4Sql(string src)
  590.         {
  591.             return src.Replace("'", "''");
  592.         }
  593.  
  594.         #endregion
  595.     }
  596. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/你好赵伟/article/detail/228655?site
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号