C#帮助工具类整理--FileHelper、XmlHelper、ToolHelper

C#工具帮助类整理

1 目录、文件帮助类FileHelper

1-1 文件处理类主要包括以下方法：

1、获得指定（文件或目录）相对路径的物理路径
2、确保目录存在，如果目录不存在，则创建目录（包括上级目录）
3、确保文件存在，如果文件目录不存在，则创建目录（包括上级目录）
4、将默认编码类型（Unicode）的字符串，追加至指定文件
5、将指定编码类型的字符串，追加至指定文件
6、将默认编码类型（Unicode）的字符串，写入指定文件
7、将指定编码类型的字符串，写入指定文件
8、依据默认编码类型（Unicode），获取指定文件、指定范围的字符
9、依据指定的编码类型，获取指定文件、指定范围的字符
10、基于默认编码类型（Unicode），将字节数组追加至指定的二进制文件
11、基于所提供编码类型，将字节数组追加至指定的二进制文件
12、基于默认编码类型（Unicode），将字节数组写入指定的二进制文件
13、基于所提供编码类型，将字节数组写入指定的二进制文件
14、依据默认编码类型（Unicode），获取指定文件、指定范围的二进制数据
15、依据指定的编码类型，获取指定文件、指定范围的二进制数据

1-2 代码如下：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Web;
using System.IO;
using Microsoft.Win32.SafeHandles;
 
namespace BaseUtilities
{
    /// <summary>
    /// 目录、文件与文件内容相关，常用的处理方法集合。
    /// </summary>
    public class FileHelper
    {
        #region Path & Directory & File
 
        /// <summary>
        /// 获得指定（文件或目录）相对路径的物理路径。
        /// <para>支持 Web 程序、Windows 服务程序、控制台等程序。</para>
        /// </summary>
        /// <param name="path">相对路径</param>
        /// <returns>返回指定相对路径的物理路径（异常时返回值为 Null）。</returns>
        public static string GetMapPath(string path)
        {
            try
            {
                if (HttpContext.Current != null)
                    return HttpContext.Current.Server.MapPath(path);
                else
                    return Path.Combine(AppDomain.CurrentDomain.BaseDirectory, path);
            }
            catch (Exception ex)
            {
                LogHelper.Error("Sxmobi.FileHelper", null, ex);
                return null;
            }
        }
 
        /// <summary>
        /// 确保目录存在。
        /// <para>如果目录不存在，则创建目录（包括上级目录）。</para>
        /// </summary>
        /// <param name="path">目录路径（不含文件名）</param>
        /// <returns>返回一个 Boolean 值，如果目录不存在且创建目录出现异常时，返回值为 False。</returns>
        public static bool EnsureDir(string path)
        {
            try
            {
                if (Directory.Exists(path))
                    return true;
                if (EnsureDir(Directory.GetParent(path).ToString()))
                {
                    Directory.CreateDirectory(path);
                    return true;
                }
                return false;
            }
            catch (Exception ex)
            {
                LogHelper.Error("Sxmobi.FileHelper", null, ex);
                return false;
            }
        }
 
        /// <summary>
        /// 确保文件存在。
        /// <para>如果文件目录不存在，则创建目录（包括上级目录）。</para>
        /// </summary>
        /// <param name="path">文件路径</param>
        /// <returns>返回一个 Boolean 值，如果目录或文件不存在且创建它们出现异常时，返回值为 False。</returns>
        public static bool EnsureFile(string path)
        {
            try
            {
                if (File.Exists(path))
                    return true;
                if (EnsureDir(Directory.GetParent(path).ToString()))
                {
                    File.Create(path).Close();
                    return true;
                }
                return false;
            }
            catch (Exception ex)
            {
                LogHelper.Error("Sxmobi.FileHelper", null, ex);
                return false;
            }
        }
 
        #endregion
 
        #region Text 相关
 
        /// <summary>
        /// 将默认编码类型（Unicode）的字符串，追加至指定文件。
        /// <para>系统推荐使用默认的 Unicode 编码类型格式来进行文字的读取与写入。</para>
        /// <para>方法将确保目录与文件存在</para>
        /// </summary>
        /// <param name="path">文件路径</param>
        /// <param name="text">需要写入的字符</param>
        /// <param name="isNewLine">指定是否将字符串写入新行</param>
        /// <returns>返回一个 Boolean 值，如果指定的目录、文件不存在且创建它们（或写入字符时）出现异常，返回值为 False。</returns>
        public static bool AddFileText(string path, string text, bool isNewLine)
        {
            return AddFileText(path, Encoding.Unicode, text, isNewLine);
        }
 
        /// <summary>
        /// 将指定编码类型的字符串，追加至指定文件。
        /// <para>方法将确保目录与文件存在。</para>
        /// <para>系统推荐使用默认的 Unicode 编码类型格式来进行文字的读取与写入。</para>
        /// </summary>
        /// <param name="path">文件路径</param>
        /// <param name="encodingType">编码类型</param>
        /// <param name="text">需要写入的字符</param>
        /// <param name="isNewLine">指定是否将字符串写入新行</param>
        /// <returns>返回一个 Boolean 值，如果指定的目录、文件不存在且创建它们（或写入字符时）出现异常，返回值为 False。</returns>
        public static bool AddFileText(string path, Encoding encodingType, string text, bool isNewLine)
        {
            if (!EnsureFile(path))
                return false;
 
            try
            {
                using (FileStream fs = new FileStream(path, FileMode.Append, FileAccess.Write, FileShare.ReadWrite))
                {
                    using (StreamWriter sw = new StreamWriter(fs, encodingType))
                    {
                        if (isNewLine)
                            sw.WriteLine(text);
                        else
                            sw.Write(text);
                    }
                }
                return true;
            }
            catch (Exception ex)
            {
                LogHelper.Error("Sxmobi.FileHelper", null, ex);
                return false;
            }
        }
 
        /// <summary>
        /// 将默认编码类型（Unicode）的字符串，写入指定文件。
        /// <para>方法将确保目录与文件存在。</para>
        /// <para>系统推荐使用默认的 Unicode 编码类型格式来进行文字的读取与写入。</para>
        /// </summary>
        /// <param name="path">文件路径</param>
        /// <param name="text">需要写入的字符</param>
        /// <returns>返回一个 Boolean 值，如果指定的目录、文件不存在且创建它们（或写入字符时）出现异常，返回值为 False。</returns>
        public static bool SetFileText(string path, string text)
        {
            return SetFileText(path, Encoding.Unicode, text);
        }
 
        /// <summary>
        /// 将指定编码类型的字符串，写入指定文件。
        /// <para>方法将确保目录与文件存在。</para>
        /// <para>系统推荐使用默认的 Unicode 编码类型格式来进行文字的读取与写入。</para>
        /// </summary>
        /// <param name="path">文件路径</param>
        /// <param name="encodingType">编码类型</param>
        /// <param name="text">需要写入的字符</param>
        /// <returns>返回一个 Boolean 值，如果指定的目录、文件不存在且创建它们（或写入字符时）出现异常，返回值为 False。</returns>
        public static bool SetFileText(string path, Encoding encodingType, string text)
        {
            if (!EnsureDir(Directory.GetParent(path).ToString()))
                return false;
 
            try
            {
                using (FileStream fs = new FileStream(path, FileMode.Create, FileAccess.Write, FileShare.ReadWrite))
                {
                    using (StreamWriter sw = new StreamWriter(fs, encodingType))
                    {
                        sw.Write(text);
                    }
                }
                return true;
            }
            catch (Exception ex)
            {
                LogHelper.Error("Sxmobi.FileHelper", null, ex);
                return false;
            }
        }
 
        /// <summary>
        /// 依据默认编码类型（Unicode），获取指定文件、指定范围的字符。
        /// <para>系统推荐使用默认的 Unicode 编码类型格式来进行文字的读取与写入。</para>
        /// </summary>
        /// <param name="path">文件路径</param>
        /// <param name="index">指定要获取内容的起始索引位置（例如文件内容：“类型 FileHelper 是...”，如果 index 设置为 3，则取得字符串“FileHelper 是...”）</param>
        /// <param name="count">指定要获取内容的长度，内容读取长度设置不宜过大，以避免内存溢出</param>
        /// <returns>返回 String 类型值，当文件不存在或其它异常时，返回值为 Null。</returns>
        public static string GetFileText(string path, int index, int count)
        {
            return GetFileText(path, Encoding.Unicode, index, count);
        }
 
        /// <summary>
        /// 依据指定的编码类型，获取指定文件、指定范围的字符。
        /// <para>系统推荐使用默认的 Unicode 编码类型格式来进行文字的读取与写入。</para>
        /// </summary>
        /// <param name="path">文件路径</param>
        /// <param name="encodingType">编码类型</param>
        /// <param name="index">指定要获取内容的起始索引位置（例如文件内容：“类型 FileHelper 是...”，如果 index 设置为 3，则取得字符串“FileHelper 是...”）</param>
        /// <param name="count">指定要获取内容的长度，内容读取长度设置不宜过大，以避免内存溢出</param>
        /// <returns>返回 String 类型值，当文件不存在或其它异常时，返回值为 Null。</returns>
        public static string GetFileText(string path, Encoding encodingType, int index, int count)
        {
            try
            {
                if (!File.Exists(path))
                    return null;
 
                int maxReads = 10000;
                char[] tempChars = new char[maxReads];
                char[] chars = new char[count];
                int loopCount = index / maxReads;
                int tempIndex = index % maxReads;
                using (FileStream fs = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
                {
                    using (StreamReader sr = new StreamReader(fs, encodingType))
                    {
                        // 如果起始索引超过 1W 个字符，则以 1W 个字符为单位，循环丢弃起始索引之前的所有字符，以避免内存开销过大。
                        while (loopCount-- > 0)
                            sr.ReadBlock(tempChars, 0, maxReads);
                        sr.ReadBlock(tempChars, 0, tempIndex);
 
                        sr.ReadBlock(chars, 0, count);
                    }
                }
                return new string(chars);
            }
            catch (Exception ex)
            {
                LogHelper.Error("Sxmobi.FileHelper", null, ex);
                return null;
            }
        }
 
        #endregion
 
        #region Binary 相关
 
        /// <summary>
        /// 基于默认编码类型（Unicode），将字节数组追加至指定的二进制文件
        /// </summary>
        /// <param name="path">二进制文件</param>
        /// <param name="bytes">字节数组</param>
        /// <returns>返回一个 Boolean 值，如果指定的目录、文件不存在且创建它们（或写入二进制数据时）出现异常，返回值为 False。</returns>
        public static bool AddFileBinary(string path, byte[] bytes)
        {
            return AddFileBinary(path, Encoding.Unicode, bytes);
        }
 
        /// <summary>
        /// 基于所提供编码类型，将字节数组追加至指定的二进制文件
        /// </summary>
        /// <param name="path">二进制文件</param>
        /// <param name="encodingType">编码类型</param>
        /// <param name="bytes">字节数组</param>
        /// <returns>返回一个 Boolean 值，如果指定的目录、文件不存在且创建它们（或写入二进制数据时）出现异常，返回值为 False。</returns>
        public static bool AddFileBinary(string path, Encoding encodingType, byte[] bytes)
        {
            if (!EnsureDir(Directory.GetParent(path).ToString()))
                return false;
 
            try
            {
                using (FileStream fs = new FileStream(path, FileMode.Append, FileAccess.Write, FileShare.ReadWrite))
                {
                    using (BinaryWriter bw = new BinaryWriter(fs, encodingType))
                    {
                        bw.Write(bytes);
                    }
                }
                return true;
            }
            catch (Exception ex)
            {
                LogHelper.Error("Sxmobi.FileHelper", null, ex);
                return false;
            }
        }
 
        /// <summary>
        /// 基于默认编码类型（Unicode），将字节数组写入指定的二进制文件
        /// </summary>
        /// <param name="path">二进制文件</param>
        /// <param name="bytes">字节数组</param>
        /// <returns>返回一个 Boolean 值，如果指定的目录、文件不存在且创建它们（或写入二进制数据时）出现异常，返回值为 False。</returns>
        public static bool SetFileBinary(string path, byte[] bytes)
        {
            return SetFileBinary(path, Encoding.Unicode, bytes);
        }
 
        /// <summary>
        /// 基于所提供编码类型，将字节数组写入指定的二进制文件
        /// </summary>
        /// <param name="path">二进制文件</param>
        /// <param name="encodingType">编码类型</param>
        /// <param name="bytes">字节数组</param>
        /// <returns>返回一个 Boolean 值，如果指定的目录、文件不存在且创建它们（或写入二进制数据时）出现异常，返回值为 False。</returns>
        public static bool SetFileBinary(string path, Encoding encodingType, byte[] bytes)
        {
            if (!EnsureDir(Directory.GetParent(path).ToString()))
                return false;
 
            try
            {
                using (FileStream fs = new FileStream(path, FileMode.Create, FileAccess.Write, FileShare.ReadWrite))
                {
                    using (BinaryWriter bw = new BinaryWriter(fs, encodingType))
                    {
                        bw.Write(bytes);
                    }
                }
                return true;
            }
            catch (Exception ex)
            {
                LogHelper.Error("Sxmobi.FileHelper", null, ex);
                return false;
            }
        }
 
        /// <summary>
        /// 依据默认编码类型（Unicode），获取指定文件、指定范围的二进制数据。
        /// </summary>
        /// <param name="path">文件路径</param>
        /// <param name="index">指定要获取数据的起始索引位置</param>
        /// <param name="count">指定要获取数据的长度，内容读取长度设置不宜过大，以避免内存溢出</param>
        /// <returns>返回 byte[] 类型值，当文件不存在或其它异常时，返回值为 Null。</returns>
        public static byte[] GetFileBinary(string path, int index, int count)
        {
            return GetFileBinary(path, Encoding.Unicode, index, count);
        }
 
        /// <summary>
        /// 依据指定的编码类型，获取指定文件、指定范围的二进制数据。
        /// </summary>
        /// <param name="path">文件路径</param>
        /// <param name="encodingType">编码类型</param>
        /// <param name="index">指定要获取数据的起始索引位置</param>
        /// <param name="count">指定要获取数据的长度，内容读取长度设置不宜过大，以避免内存溢出</param>
        /// <returns>返回 byte[] 类型值，当文件不存在或其它异常时，返回值为 Null。</returns>
        public static byte[] GetFileBinary(string path, Encoding encodingType, int index, int count)
        {
            try
            {
                if (!File.Exists(path))
                    return null;
 
                int maxReads = 1024000;
                byte[] bytes = new byte[count];
                int loopCount = index / maxReads;
                int tempIndex = index % maxReads;
                using (FileStream fs = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
                {
                    using (BinaryReader br = new BinaryReader(fs, encodingType))
                    {
                        // 如果起始索引超过1M（1000K），则以1M为单位，循环丢弃起始索引之前的所有字节，以避免内存开销过大。
                        while (loopCount-- > 0)
                            br.ReadBytes(maxReads);
                        br.ReadBytes(tempIndex);
 
                        bytes = br.ReadBytes(count);
                    }
                }
                return bytes;
            }
            catch (Exception ex)
            {
                LogHelper.Error("Sxmobi.FileHelper", null, ex);
                return null;
            }
        }
 
        #endregion
    }
}

2 Xml处理帮助类XmlHelper

2-1 Xml处理帮助类包括方法目录如下：

1、依据XML文件或XML格式字符串，获得XmlDocument对象。
2、将XmlDocument对象保存为指定路径的XML文件。
3、获取XPATH指定节点的值。
4、设置XPATH指定节点的值。
5、获取XPATH指定节点下，指定属性的值。
6、设置XPATH指定节点下，指定属性的值。
7、更新XML文件的节点的值。
8、更新XML文件的节点下指定属性的值。

2-2 代码如下：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Xml;
using System.IO;
 
namespace BaseUtilities
{
    /// <summary>
    /// Xml常用处理方法集合.
    /// </summary>
    public class XmlHelper
    {
        /// <summary>
        /// 依据XML文件或XML格式字符串，获得XmlDocument对象。
        /// </summary>
        /// <param name="filePathOrXmlStr">XML文件路径（或XML格式字符串）</param>
        /// <returns>返回XmlDocument对象，出现异常时返回值为空</returns>
        public static XmlDocument GetXmlDoc(string filePathOrXmlStr)
        {
            try
            {
                XmlDocument xmlDoc = new XmlDocument();
                if (File.Exists(filePathOrXmlStr))
                {
                    xmlDoc.Load(filePathOrXmlStr);
                }
                else
                {
                    xmlDoc.LoadXml(filePathOrXmlStr);
                }
                return xmlDoc;
            }
            catch (Exception ex)
            {
                return null;
            }
        }
 
        /// <summary>
        /// 将XmlDocument对象保存为指定路径的XML文件。
        /// </summary>
        /// <param name="filePath">XML文件路径</param>
        /// <param name="xmlDoc">XmlDocument对象</param>
        /// <returns>出现异常时返回值为False</returns>
        public static bool SaveXmlDoc(string filePath, XmlDocument xmlDoc)
        {
            try
            {
                xmlDoc.Save(filePath);
                return true;
            }
            catch (Exception ex)
            {
                return false;
            }
        }
 
        /// <summary>
        /// 获取XPATH指定节点的值。
        /// </summary>
        /// <param name="xmlDoc">XmlDocument对象</param>
        /// <param name="xpath">XPATH字符串参数，如：//CacheTime、//settings/CacheTime、...</param>
        /// <returns>出现异常时，返回值为空</returns>
        public static string GetNodeValue(XmlDocument xmlDoc, string xpath)
        {
            try
            {
                return xmlDoc.DocumentElement.SelectSingleNode(xpath).InnerText;
            }
            catch (Exception ex)
            {
                return null;
            }
        }
 
        /// <summary>
        /// 设置XPATH指定节点的值。
        /// </summary>
        /// <param name="xmlDoc">XmlDocument对象</param>
        /// <param name="xpath">XPATH值，如：//CacheTime、//appSettings/CacheTime、...</param>
        /// <param name="nodeVal">要设置的节点的值</param>
        /// <returns>出现异常时，返回值为False</returns>
        public static bool SetNodeValue(ref XmlDocument xmlDoc, string xpath, string nodeVal)
        {
            try
            {
                xmlDoc.DocumentElement.SelectSingleNode(xpath).InnerText = nodeVal;
                return true;
            }
            catch (Exception ex)
            {
                return false;
            }
        }
 
        /// <summary>
        /// 获取XPATH指定节点下，指定属性的值。
        /// </summary>
        /// <param name="xmlDoc">XmlDocument对象</param>
        /// <param name="nodePath">XPATH值，如：//CacheTime、//appSettings/CacheTime、...</param>
        /// <param name="attrName">要设置的节点属性名称</param>
        /// <returns></returns>
        public static string GetNodeAttr(XmlDocument xmlDoc, string nodePath, string attrName)
        {
            try
            {
                XmlNode node = xmlDoc.DocumentElement.SelectSingleNode(nodePath);
                return node.Attributes[attrName].Value;
            }
            catch (Exception ex)
            {
                return null;
            }
        }
 
        /// <summary>
        /// 设置XPATH指定节点下，指定属性的值。
        /// </summary>
        /// <param name="xmlDoc">XmlDocument对象</param>
        /// <param name="nodePath">XPATH值，如：//CacheTime、//appSettings/CacheTime、...</param>
        /// <param name="attrName">要设置的节点属性名称</param>
        /// <param name="attrVal">要设置的节点属性的值</param>
        /// <returns></returns>
        public static bool SetNodeAttr(ref XmlDocument xmlDoc, string nodePath, string attrName, string attrVal)
        {
            try
            {
                XmlNode node = xmlDoc.DocumentElement.SelectSingleNode(nodePath);
                ((XmlElement)node).SetAttribute(attrName, attrVal);
                return true;
            }
            catch (Exception ex)
            {
                return false;
            }
        }
 
        /// <summary>
        /// 更新XML文件的节点的值。
        /// <para>操作步骤：打开XML->更新节点->写入XML文件，因此，本方法不适用于频繁调用。</para>
        /// </summary>
        /// <param name="filePath">XML文件路径</param>
        /// <param name="xpath">XPATH值，如：//CacheTime、//appSettings/CacheTime、...</param>
        /// <param name="nodeVal">要设置的节点的值</param>
        /// <returns></returns>
        public static bool UpdateXmlFileNodeValue(string filePath, string xpath, string nodeVal)
        {
            XmlDocument xmlDoc = GetXmlDoc(filePath);
            if (SetNodeValue(ref xmlDoc, xpath, nodeVal))
                return SaveXmlDoc(filePath, xmlDoc);
            return false;
        }
 
        /// <summary>
        /// 更新XML文件的节点下指定属性的值。
        /// <para>操作步骤：打开XML->更新节点->写入XML文件，因此，本方法不适用于频繁调用。</para>
        /// </summary>
        /// <param name="filePath">XML文件路径</param>
        /// <param name="nodePath">xpath值，如：//CacheTime、//appSettings/CacheTime、...</param>
        /// <param name="attrName">要设置的节点属性名称</param>
        /// <param name="attrVal">要设置的节点属性的值</param>
        /// <returns></returns>
        public static bool UpdateXmlFileNodeAttr(string filePath, string nodePath, string attrName, string attrVal)
        {
            XmlDocument xmlDoc = GetXmlDoc(filePath);
            if (SetNodeAttr(ref xmlDoc, nodePath, attrName, attrVal))
                return SaveXmlDoc(filePath, xmlDoc);
            return false;
        }
    }
}

3 通用工具帮助类ToolHelper

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

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 合并一组可枚举的对象为字符串

3-2 代码如下：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data;
using System.Web;
using System.Net;
using System.IO;
using System.Collections;
using System.Configuration;
 
namespace BaseUtilities
{
    /// <summary>
    /// 常用的工具类静态方法集合。
    /// </summary>
    public class Tools
    {
        #region 类型验证
 
        /// <summary>
        /// 判断字符串是否为数字
        /// </summary>
        /// <param name="src"></param>
        /// <returns></returns>
        public static bool IsNumber(string src)
        {
            try
            {
                decimal d = decimal.Parse(src);
                return true;
            }
            catch
            {
                return false;
            }
        }
 
        /// <summary>
        /// 判断字符串是否为整型
        /// </summary>
        /// <param name="src"></param>
        /// <returns></returns>
        public static bool IsInt(string src)
        {
            try
            {
                int d = int.Parse(src);
                return true;
            }
            catch
            {
                return false;
            }
        }
        
        /// <summary>
        /// 判断字符串是否为日期
        /// </summary>
        /// <param name="src"></param>
        /// <returns></returns>
        public static bool IsDatetime(string src)
        {
            if (src.Trim() == "")
                return false;
            try
            {
                DateTime d = DateTime.Parse(src);
                d = Convert.ToDateTime(src);
                return true;
            }
            catch
            {
                return false;
            }
        }
 
        #endregion
 
        #region 类型转换
 
        /// <summary>
        /// 获得字符串值。
        /// <para>该方法会将 string.Empty 转换为 defaultValue。</para>
        /// <para>该方法用于依据一个对象，始终得到一个不为空的字符串（除非调用者将 defaultVal 设置为空）。</para>
        /// <para>它等价于在程序中对象判空、ToString、IsNullOrEmpty等处理。</para>
        /// </summary>
        /// <param name="src">源对象</param>
        /// <param name="defaultVal">转换失败时期望返回的字符串值</param>
        /// <returns></returns>
        public static string GetStr(object src, string defaultVal)
        {
            return GetStr(src, defaultVal, true);
        }
 
        /// <summary>
        /// 获得字符串值。
        /// <para>该方法会将 string.Empty 转换为 defaultValue。</para>
        /// <para>该方法用于依据一个对象，始终得到一个不为空的字符串（除非调用者将 defaultVal 设置为空）。</para>
        /// <para>它等价于在程序中对象判空、ToString、IsNullOrEmpty等处理。</para>
        /// </summary>
        /// <param name="src">源对象</param>
        /// <param name="defaultVal">转换失败时期望返回的字符串值</param>
        /// <param name="disallowEmpty">是否不允许空值（将 string.Empty 转换为 defaultValue）</param>
        /// <returns></returns>
        public static string GetStr(object src, string defaultVal, bool disallowEmpty)
        {
            if (src == null)
                return defaultVal;
            if (disallowEmpty && src.ToString().Length == 0)
                return defaultVal;
            return src.ToString();
        }
 
        /// <summary>
        /// 获取8位整型值。
        /// </summary>
        /// <param name="src">长整型值</param>
        /// <returns></returns>
        public static byte GetByte(long src)
        {
            if (src > byte.MaxValue)
                return byte.MaxValue;
            else if (src < byte.MinValue)
                return byte.MinValue;
            return (byte)src;
        }
 
        /// <summary>
        /// 获得16位整型值。
        /// </summary>
        /// <param name="src">源对象</param>
        /// <param name="defaultVal">转换失败时期望返回的整型值</param>
        /// <param name="scale">源字符串的进位制，如16、10、8、2等</param>
        /// <returns></returns>
        public static short GetShort(object src, short defaultVal, int scale)
        {
            short rv;
            try
            {
                rv = Convert.ToInt16(src.ToString().Trim(), scale);
            }
            catch
            {
                rv = defaultVal;
            }
            return rv;
        }
 
        /// <summary>
        /// 获得16位整型值。
        /// </summary>
        /// <param name="src">源对象</param>
        /// <param name="defaultVal">转换失败时期望返回的整型值</param>
        /// <returns></returns>
        public static short GetShort(object src, short defaultVal)
        {
            short rv;
            if (src != null && short.TryParse(src.ToString().Trim(), out rv))
                return rv;
            return defaultVal;
        }
 
        /// <summary>
        /// 获取16位整型值。
        /// </summary>
        /// <param name="src">长整型值</param>
        /// <returns></returns>
        public static short GetShort(long src)
        {
            if (src > short.MaxValue)
                return short.MaxValue;
            else if (src < short.MinValue)
                return short.MinValue;
            return (short)src;
        }
 
        /// <summary>
        /// 获得整型值。
        /// </summary>
        /// <param name="src">源对象</param>
        /// <param name="defaultVal">转换失败时期望返回的整型值</param>
        /// <param name="scale">源字符串的进位制，如16、10、8、2等</param>
        /// <returns></returns>
        public static int GetInt(object src, int defaultVal, int scale)
        {
            int rv;
            try
            {
                rv = Convert.ToInt32(src.ToString().Trim(), scale);
            }
            catch
            {
                rv = defaultVal;
            }
            return rv;
        }
 
        /// <summary>
        /// 获得整型值。
        /// </summary>
        /// <param name="src">源对象</param>
        /// <param name="defaultVal">转换失败时期望返回的整型值</param>
        /// <returns></returns>
        public static int GetInt(object src, int defaultVal)
        {
            int rv;
            if (src != null && int.TryParse(src.ToString().Trim(), out rv))
                return rv;
            return defaultVal;
        }
 
        /// <summary>
        /// 获取整型值。
        /// </summary>
        /// <param name="src">长整型值</param>
        /// <returns></returns>
        public static int GetInt(long src)
        {
            if (src > int.MaxValue)
                return int.MaxValue;
            else if (src < int.MinValue)
                return int.MinValue;
            return (int)src;
        }
 
        /// <summary>
        /// 获得长整型值。
        /// </summary>
        /// <param name="src">源对象</param>
        /// <param name="defaultVal">转换失败时期望返回的长整型值</param>
        /// <param name="scale">源字符串的进位制，如16、10、8、2等</param>
        /// <returns></returns>
        public static long GetLong(object src, long defaultVal, int scale)
        {
            long rv;
            try
            {
                rv = Convert.ToInt64(src.ToString().Trim(), scale);
            }
            catch
            {
                rv = defaultVal;
            }
            return rv;
        }
 
        /// <summary>
        /// 获得长整型值。
        /// </summary>
        /// <param name="src">源对象</param>
        /// <param name="defaultVal">转换失败时期望返回的长整型值</param>
        /// <returns></returns>
        public static long GetLong(object src, long defaultVal)
        {
            long rv;
            if (src != null && long.TryParse(src.ToString(), out rv))
                return rv;
            return defaultVal;
        }
 
        /// <summary>
        /// 获得双精度值。
        /// </summary>
        /// <param name="src">源对象</param>
        /// <param name="defaultVal">转换失败时期望返回的双精度值</param>
        /// <returns></returns>
        public static double GetDouble(object src, double defaultVal)
        {
            double rv;
            if (src != null && double.TryParse(src.ToString(), out rv))
                return rv;
            return defaultVal;
        }
 
        /// <summary>
        /// 获得时间类型值
        /// </summary>
        /// <param name="src">源对象</param>
        /// <param name="defaultVal">转换失败时期望返回的时间类型值</param>
        /// <returns></returns>
        public static DateTime GetDatetime(object src, DateTime defaultVal)
        {
            DateTime dt;
            if (src != null && DateTime.TryParse(src.ToString(), out dt))
                return dt;
            return defaultVal;
        }
 
        #endregion
 
        #region Byte相关
 
        /// <summary>
        /// 返回由字节数组中指定位置的两个字节转换来的 16 位有符号整型 (NetworkToHostOrder)。
        /// </summary>
        /// <param name="src">字节数组</param>
        /// <param name="startIndex">读数起始位置</param>
        /// <returns></returns>
        public static short ReadShort(byte[] src, int startIndex)
        {
            return IPAddress.NetworkToHostOrder(BitConverter.ToInt16(src, startIndex));
        }
 
        /// <summary>
        /// 返回由字节数组中指定位置的两个字节转换来的 32 位有符号整型 (NetworkToHostOrder)。
        /// </summary>
        /// <param name="src">字节数组</param>
        /// <param name="startIndex">读数起始位置</param>
        /// <returns></returns>
        public static int ReadInt(byte[] src, int startIndex)
        {
            return IPAddress.NetworkToHostOrder(BitConverter.ToInt32(src, startIndex));
        }
 
        /// <summary>
        /// 返回由字节数组中指定位置的两个字节转换来的 32 位无符号整型 (NetworkToHostOrder)。
        /// </summary>
        /// <param name="src">字节数组</param>
        /// <param name="startIndex">读数起始位置</param>
        /// <returns></returns>
        public static uint ReadUInt(byte[] src, int startIndex)
        {
            return (uint)IPAddress.NetworkToHostOrder((long)BitConverter.ToUInt32(src, startIndex));
        }
 
        /// <summary>
        /// 返回由字节数组中指定位置的两个字节转换来的 64 位有符号整型 (NetworkToHostOrder)。
        /// </summary>
        /// <param name="src">字节数组</param>
        /// <param name="startIndex">读数起始位置</param>
        /// <returns></returns>
        public static long ReadLong(byte[] src, int startIndex)
        {
            return IPAddress.NetworkToHostOrder(BitConverter.ToInt64(src, startIndex));
        }
 
        /// <summary>
        /// 获得byte数组。
        /// </summary>
        /// <param name="src">整型值</param>
        /// <returns></returns>
        public static byte[] GetBytes(int src)
        {
            return BitConverter.GetBytes(IPAddress.HostToNetworkOrder(src));
        }
 
        /// <summary>
        /// 获得byte数组。
        /// </summary>
        /// <param name="src">短整型值</param>
        /// <returns></returns>
        public static byte[] GetBytes(short src)
        {
            return BitConverter.GetBytes(IPAddress.HostToNetworkOrder(src));
        }
 
        /// <summary>
        /// 获得byte数组。
        /// </summary>
        /// <param name="src">长整型值</param>
        /// <returns></returns>
        public static byte[] GetBytes(long src)
        {
            return BitConverter.GetBytes(IPAddress.HostToNetworkOrder(src));
        }
 
        /// <summary>
        /// 获得byte数组。
        /// </summary>
        /// <param name="src">整型值</param>
        /// <param name="bytesRightLen">要靠右保留的byte个数</param>
        /// <returns></returns>
        public static byte[] RightBytes(byte[] src, int bytesRightLen)
        {
            byte[] retBytes = new byte[bytesRightLen];
            Array.Copy(src, src.Length - bytesRightLen, retBytes, 0, bytesRightLen);
            return retBytes;
        }
 
        #endregion
 
        #region 数组相关
 
        /// <summary>
        /// 将以分隔符分隔的字符串转为int数组
        /// </summary>
        /// <param name="str"></param>
        /// <param name="seperator"></param>
        /// <returns></returns>
        public static int[] SplitToInt32Array(string str, string seperator)
        {
            string[] items = str.Split(new string[] { seperator }, StringSplitOptions.RemoveEmptyEntries);
            int[] array = new int[items.Length];
            for (int i = items.Length - 1; i >= 0; i--)
            {
                int value;
                if (!int.TryParse(items[i], out value))
                    return null;
                array[i] = value;
            }
            return array;
        }
 
        /// <summary>
        /// 将以分隔符分隔的字符串转为int数组
        /// </summary>
        /// <param name="str"></param>
        /// <param name="seperators"></param>
        /// <returns></returns>
        public static int[] SplitToInt32Array(string str, string[] seperators)
        {
            string[] items = str.Split(seperators, StringSplitOptions.RemoveEmptyEntries);
            int[] array = new int[items.Length];
            for (int i = items.Length - 1; i >= 0; i--)
            {
                int value;
                if (!int.TryParse(items[i], out value))
                    return null;
                array[i] = value;
            }
            return array;
        }
 
        /// <summary>
        /// 合并一组可枚举的对象为字符串
        /// </summary>
        /// <param name="enumerable">被枚举对象</param>
        /// <param name="seperator">分隔符</param>
        /// <returns></returns>
        public static string ConcatEnumerable(IEnumerable enumerable, string seperator)
        {
            IEnumerator enumerator = enumerable.GetEnumerator();
            if (!enumerator.MoveNext())
                return string.Empty;
            StringBuilder text = new StringBuilder(128);
            text.Append(enumerator.Current.ToString());
            while (enumerator.MoveNext())
            {
                text.Append(seperator + enumerator.Current);
            }
            return text.ToString();
        }
 
        #endregion
 
        #region 列表分页相关
        /// <summary>
        /// 获取分页起始索引（同时验证与修改参数）
        /// </summary>
        /// <param name="pageSize">每页显示记录数</param>
        /// <param name="pageIndex">当前是第几页</param>
        /// <returns></returns>
        public static int GetStartRec(ref int pageSize, ref int pageIndex)
        {
            if (pageSize < 1) pageSize = 20;
            if (pageIndex < 1) pageIndex = 1;
            return pageSize * (pageIndex - 1) + 1;
        }
 
        /// <summary>
        /// 获取分页终止索引（不验证参数）
        /// </summary>
        /// <param name="pageSize">每页显示记录数</param>
        /// <param name="pageIndex">当前是第几页</param>
        /// <returns></returns>
        public static int GetEndRec(int pageSize, int pageIndex)
        {
            return pageSize * pageIndex;
        }
 
        /// <summary>
        /// 获取分页起始索引（同时验证与修改参数）
        /// </summary>
        /// <param name="pageSize">每页显示记录数</param>
        /// <param name="pageIndex">当前是第几页</param>
        /// <returns></returns>
        public static long GetStartRec(ref long pageSize, ref long pageIndex)
        {
            if (pageSize < 1) pageSize = 20;
            if (pageIndex < 1) pageIndex = 1;
            return pageSize * (pageIndex - 1) + 1;
        }
 
        /// <summary>
        /// 获取分页终止索引（不验证参数）
        /// </summary>
        /// <param name="pageSize">每页显示记录数</param>
        /// <param name="pageIndex">当前是第几页</param>
        /// <returns></returns>
        public static long GetEndRec(long pageSize, long pageIndex)
        {
            return pageSize * pageIndex;
        }
 
        /// <summary>
        /// 根据记录总数与每页记录数，计算分页总数
        /// </summary>
        /// <param name="recordCount">记录总数</param>
        /// <param name="pageSize">每页记录数</param>
        /// <returns></returns>
        public static int GetPageSize(int recordCount, int pageSize)
        {
            return (int)Math.Ceiling((double)recordCount / pageSize);
        }
        #endregion
 
        #region 其它
 
        /// <summary>
        /// 得到Request中指定参数的值（返回String值）
        /// </summary>
        /// <param name="keyName">要获取的参数的名称</param>
        /// <param name="defaultVal">当不存在该参数时返回的默认值</param>
        /// <returns></returns>
        public static string GetRequestVal(string keyName, string defaultVal)
        {
            string rv = System.Web.HttpContext.Current.Request[keyName];
            return Tools.GetStr(rv, defaultVal);
        }
 
        /// <summary>
        /// 得到Request中指定参数的值（返回Int值）
        /// </summary>
        /// <param name="keyName">要获取的参数的名称</param>
        /// <param name="defaultVal">当不存在该参数时返回的默认值</param>
        /// <returns></returns>
        public static int GetRequestVal(string keyName, int defaultVal)
        {
            string rv = System.Web.HttpContext.Current.Request[keyName];
            return Tools.GetInt(rv, defaultVal);
        }
 
        /// <summary>
        /// 得到一个系统配置项的值
        /// </summary>
        /// <param name="keyName">配置项名称</param>
        /// <param name="defaultVal">在不存在该配置项时返回的默认值</param>
        /// <returns></returns>
        public static string GetAppSetting(string keyName, string defaultVal)
        {
            string rv = System.Configuration.ConfigurationManager.AppSettings[keyName];
            return Tools.GetStr(rv, defaultVal);
        }
 
        /// <summary>
        /// 得到一个系统配置项的值
        /// </summary>
        /// <param name="keyName">配置项名称</param>
        /// <param name="defaultVal">在不存在该配置项时返回的默认值</param>
        /// <returns></returns>
        public static int GetAppSetting(string keyName, int defaultVal)
        {
            string rv = System.Configuration.ConfigurationManager.AppSettings[keyName];
            return Tools.GetInt(rv, defaultVal);
        }
 
        /// <summary>
        /// 得到一个连接字符串配置项的值
        /// <para>当配置不存在时，返回Null</para>
        /// </summary>
        /// <param name="keyName">配置项名称</param>
        /// <returns></returns>
        public static string GetConnStrConfig(string keyName)
        {
            if(ConfigurationManager.ConnectionStrings[keyName] != null)
                return System.Configuration.ConfigurationManager.ConnectionStrings[keyName].ConnectionString;
            return null;
        }
 
        /// <summary>
        /// 获得字符串值的前N位字符
        /// </summary>
        /// <param name="src">指定的字符串</param>
        /// <param name="len">指定的长度</param>
        /// <returns></returns>
        public static string GetLenthStr(string src, int len)
        {
            if (src.Length > len)
                return src.Substring(0, len);
            return src;
        }
 
        /// <summary>
        /// 对字符串进行编码，以保证SQL参数的安全性
        /// </summary>
        /// <param name="src"></param>
        /// <returns></returns>
        public static string EncodeStr4Sql(string src)
        {
            return src.Replace("'", "''");
        }
 
        #endregion
    }
}