分类 Helper 下的文章

Package

Install-Package ChineseConverter
Install-Package Microsoft.International.Converters.PinYinConverter -Version 1.0.0

ChineseHelper

using Microsoft.International.Converters.PinYinConverter;
using Microsoft.International.Converters.TraditionalChineseToSimplifiedConverter;
using Microsoft.International.Formatters;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Helper
{
    public static class ChineseHelper
    {
        /// <summary>
        /// 获取拼音缩写
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public static string GetSpellingAbbreviations(string str)
        {
            List<string> list = new List<string>();
            list.Add("");
            string tempStr = "";
            foreach (char c in str)
            {
                if (!ChineseChar.IsValidChar(c))
                {
                    for (int i = 0; i < list.Count; i++)
                        list[i] += c.ToString().ToLower();
                    continue;
                }
                ChineseChar cc = new ChineseChar(c);
                List<string> listChar = new List<string>();
                if (cc.PinyinCount > 0)
                {
                    for (int i = 0; i < cc.PinyinCount; i++)
                    {
                        listChar.Add(cc.Pinyins[i].Substring(0, 1).ToLower());
                    }
                    var listNewChar = listChar.Distinct().ToList();
                    if (listNewChar.Count > 1)
                    {
                        for (int i = 1; i < listNewChar.Count; i++)
                        {
                            int count = list.Count;
                            for (int j = 0; j < count; j++)
                            {
                                list.Add(list[j]);
                            }

                        }
                    }
                    for (int i = 0; i < listNewChar.Count; i++)
                    {
                        int count = list.Count / listNewChar.Count;

                        for (int j = i * count; j < list.Count; j++)
                        {
                            if (j < (i + 1) * count)
                                list[j] += listNewChar[i];
                        }

                    }
                }
                else
                {
                    for (int i = 0; i < list.Count; i++)
                        list[i] += c.ToString().ToLower();
                }
            }
            foreach (var item in list)
            {
                tempStr += item + ";";
            }
            return tempStr;
        }
        /// <summary>
        /// 获取拼音缩写
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public static List<List<string>> PinYinAbbreviation(string str)
        {
            List<List<string>> list = new List<List<string>>();
            foreach (char c in str)
            {
                List<string> listChar = new List<string>();
                if (ChineseChar.IsValidChar(c))
                {
                    ChineseChar cc = new ChineseChar(c);
                    for (int i = 0; i < cc.PinyinCount; i++)
                    {
                        listChar.Add(cc.Pinyins[i].Substring(0,1));
                    }
                }
                else
                {
                    listChar.Add(c.ToString());
                }
                list.Add(listChar);
            }
            return list;
        }
        /// <summary>
        /// 获取拼音全拼
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public static List<List<string>> PinYinFull(string str)
        {
            List<List<string>> list = new List<List<string>>();
            foreach (char c in str)
            {
                List<string> listChar = new List<string>();
                if (ChineseChar.IsValidChar(c))
                {
                    ChineseChar cc = new ChineseChar(c);
                    for (int i = 0; i < cc.PinyinCount; i++)
                    {
                        listChar.Add(cc.Pinyins[i]);
                    }
                }
                else
                {
                    listChar.Add(c.ToString());
                }
                list.Add(listChar);
            }
            return list;
        }
        /// <summary>
        /// 获取汉字，简体转繁体
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public static string SimplifiedToTraditional(string str)
        {
            return ChineseConverter.Convert(str, ChineseConversionDirection.SimplifiedToTraditional);
        }
        /// <summary>
        /// 获取汉字，繁体转简体
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public static string TraditionalToSimplified(string str)
        {
            return ChineseConverter.Convert(str, ChineseConversionDirection.TraditionalToSimplified);
        }
        /// <summary>
        /// 将数字货币转换为大写
        /// </summary>
        /// <param name="number"></param>
        /// <returns></returns>
        public static string NumericToLC(decimal number)
        {
            return string.Format(new EastAsiaNumericFormatter(), "{0:Lc}", number);
        }
        /// <summary>
        /// 强数字货币转换为小写
        /// </summary>
        /// <param name="number"></param>
        /// <returns></returns>
        public static string NumericToLN(decimal number)
        {
            return string.Format(new EastAsiaNumericFormatter(), "{0:Ln}", number);
        }
    }
}

Config

<connectionStrings>
    <add name="DBHelper" connectionString="Data Source=.;Initial Catalog=DB_Helper;User ID=sa;password=123456;" providerName="System.Data.SqlClient" />
</connectionStrings>

DBHelper

using System;
using System.Configuration;
using System.Data;
using System.Data.Common;

namespace Helper
{
    /// <summary>
    /// 数据库访问帮助类
    /// 必备
    /// System.Data
    /// System.Configuration
    /// </summary>
    public class DBHelper
    {

        //托管对象
        private static string dbProviderName;
        //连接字符串
        private static string dbConnectionString;
        //数据库连接
        private DbConnection connection;
        /// <summary>
        /// 构造函数
        /// 初始化数据库连接
        /// </summary>
        public DBHelper()
        {
            string name = this.GetType().Name;
            dbProviderName = ConfigurationManager.ConnectionStrings[name].ProviderName;
            dbConnectionString = ConfigurationManager.ConnectionStrings[name].ConnectionString;
            this.connection = CreateConnection(DBHelper.dbConnectionString);
        }
        public DBHelper(string providerName)
        {
            dbProviderName = ConfigurationManager.ConnectionStrings[providerName].ProviderName;
            dbConnectionString = ConfigurationManager.ConnectionStrings[providerName].ConnectionString;
            this.connection = CreateConnection(DBHelper.dbConnectionString);
        }

        /// <summary>
        /// 构造函数
        /// 初始化数据库连接
        /// </summary>
        /// <param name="providerName"></param>
        /// <param name="connectionString"></param>
        public DBHelper(string providerName, string connectionString)
        {
            dbProviderName = providerName;
            dbConnectionString = connectionString;
            this.connection = CreateConnection(connectionString);
        }

        /// <summary>
        /// 创建数据库连接
        /// </summary>
        /// <returns></returns>
        public static DbConnection CreateConnection()
        {
            DbProviderFactory dbfactory = DbProviderFactories.GetFactory(DBHelper.dbProviderName);
            DbConnection dbconn = dbfactory.CreateConnection();
            dbconn.ConnectionString = DBHelper.dbConnectionString;
            return dbconn;
        }
        /// <summary>
        /// 创建数据库连接
        /// </summary>
        /// <param name="connectionString">连接字符串</param>
        /// <returns></returns>
        public static DbConnection CreateConnection(string connectionString)
        {
            DbProviderFactory dbfactory = DbProviderFactories.GetFactory(DBHelper.dbProviderName);
            DbConnection dbconn = dbfactory.CreateConnection();
            dbconn.ConnectionString = connectionString;
            return dbconn;
        }

        /// <summary>
        /// 执行的存储过程
        /// </summary>
        /// <param name="storedProcedure">设置针对数据源运行的文本命令</param>
        /// <returns></returns>
        public DbCommand GetStoredProcCommand(string storedProcedure)
        {
            DbCommand dbCommand = connection.CreateCommand();
            dbCommand.CommandText = storedProcedure;
            dbCommand.CommandType = CommandType.StoredProcedure;
            return dbCommand;
        }
        /// <summary>
        /// 执行的sql语句
        /// </summary>
        /// <param name="sqlQuery">sql语句</param>
        /// <returns></returns>
        public DbCommand GetSqlStringCommand(string sqlQuery)
        {
            DbCommand dbCommand = connection.CreateCommand();
            dbCommand.CommandText = sqlQuery;
            dbCommand.CommandType = CommandType.Text;
            return dbCommand;
        }

        #region 增加参数

        /// <summary>
        /// 增加参数
        /// </summary>
        /// <param name="cmd">cmd对象</param>
        /// <param name="dbParameterCollection">参数集合</param>
        public void AddParameterCollection(DbCommand cmd, DbParameterCollection dbParameterCollection)
        {
            foreach (DbParameter dbParameter in dbParameterCollection)
            {
                cmd.Parameters.Add(dbParameter);
            }
        }
        /// <summary>
        /// 增加输出参数 适用于存储过程
        /// </summary>
        /// <param name="cmd">cmd对象</param>
        /// <param name="parameterName">参数名</param>
        /// <param name="dbType">参数类型</param>
        /// <param name="size">参数大小</param>
        public void AddOutParameter(DbCommand cmd, string parameterName, DbType dbType, int size)
        {
            DbParameter dbParameter = cmd.CreateParameter();
            dbParameter.DbType = dbType;
            dbParameter.ParameterName = parameterName;
            dbParameter.Size = size;
            dbParameter.Direction = ParameterDirection.Output;
            cmd.Parameters.Add(dbParameter);
        }
        /// <summary>
        /// 增加参数列表
        /// </summary>
        /// <param name="cmd">cmd对象</param>
        /// <param name="parameterName">参数名</param>
        /// <param name="dbType">参数类型</param>
        /// <param name="value">参数值</param>
        public void AddInParameter(DbCommand cmd, string parameterName, DbType dbType, object value)
        {
            DbParameter dbParameter = cmd.CreateParameter();
            dbParameter.DbType = dbType;
            dbParameter.ParameterName = parameterName;
            dbParameter.Value = value;
            dbParameter.Direction = ParameterDirection.Input;
            cmd.Parameters.Add(dbParameter);
        }
        /// <summary>
        /// 增加返回参数 适用于存储过程
        /// </summary>
        /// <param name="cmd">cmd对象</param>
        /// <param name="parameterName">参数名</param>
        /// <param name="dbType">参数类型</param>
        public void AddReturnParameter(DbCommand cmd, string parameterName, DbType dbType)
        {
            DbParameter dbParameter = cmd.CreateParameter();
            dbParameter.DbType = dbType;
            dbParameter.ParameterName = parameterName;
            dbParameter.Direction = ParameterDirection.ReturnValue;
            cmd.Parameters.Add(dbParameter);
        }
        /// <summary>
        /// 获取参数
        /// </summary>
        /// <param name="cmd">cmd对象</param>
        /// <param name="parameterName">参数名</param>
        /// <returns></returns>
        public DbParameter GetParameter(DbCommand cmd, string parameterName)
        {
            return cmd.Parameters[parameterName];
        }

        #endregion

        #region 执行

        /// <summary>
        /// 执行sql或者存储过程返回一个DataSet对象
        /// </summary>
        /// <param name="cmd">cmd对象</param>
        /// <returns></returns>
        public DataSet ExecuteDataSet(DbCommand cmd)
        {
            DbProviderFactory dbfactory = DbProviderFactories.GetFactory(DBHelper.dbProviderName);
            DbDataAdapter dbDataAdapter = dbfactory.CreateDataAdapter();
            dbDataAdapter.SelectCommand = cmd;
            DataSet ds = new DataSet();
            dbDataAdapter.Fill(ds);
            return ds;
        }
        /// <summary>
        /// 执行sql或者存储过程返回一个DataTable对象
        /// </summary>
        /// <param name="cmd">cmd对象</param>
        /// <returns></returns>
        public DataTable ExecuteDataTable(DbCommand cmd)
        {
            DbProviderFactory dbfactory = DbProviderFactories.GetFactory(DBHelper.dbProviderName);
            DbDataAdapter dbDataAdapter = dbfactory.CreateDataAdapter();
            dbDataAdapter.SelectCommand = cmd;
            DataTable dataTable = new DataTable();
            dbDataAdapter.Fill(dataTable);
            return dataTable;
        }
        /// <summary>
        /// 执行sql语句或者存储过程返回一个DbDataReader对象
        /// </summary>
        /// <param name="cmd">cmd对象</param>
        /// <returns></returns>
        public DbDataReader ExecuteReader(DbCommand cmd)
        {
            cmd.Connection.Open();
            DbDataReader reader = cmd.ExecuteReader(CommandBehavior.CloseConnection);
            return reader;
        }
        /// <summary>
        /// 执行一条sql语句或者存储过程，返回受影响的行数
        /// </summary>
        /// <param name="cmd">cmd对象</param>
        /// <returns></returns>
        public int ExecuteNonQuery(DbCommand cmd)
        {
            cmd.Connection.Open();
            int ret = cmd.ExecuteNonQuery();
            cmd.Connection.Close();
            return ret;
        }
        /// <summary>
        /// 执行一条sql语句或者存储过程，返回object对象
        /// </summary>
        /// <param name="cmd">cmd对象</param>
        /// <returns></returns>
        public object ExecuteScalar(DbCommand cmd)
        {
            cmd.Connection.Open();
            object ret = cmd.ExecuteScalar();
            cmd.Connection.Close();
            return ret;
        }

        #endregion

        #region 执行事务

        /// <summary>
        /// 执行sql或者存储过程返回一个dataSet对象+事务
        /// </summary>
        /// <param name="cmd">cmd对象</param>
        /// <param name="t">事务执行操作</param>
        /// <returns></returns>
        public DataSet ExecuteDataSet(DbCommand cmd, Trans t)
        {
            cmd.Connection = t.DbConnection;
            cmd.Transaction = t.DbTrans;
            DbProviderFactory dbfactory = DbProviderFactories.GetFactory(DBHelper.dbProviderName);
            DbDataAdapter dbDataAdapter = dbfactory.CreateDataAdapter();
            dbDataAdapter.SelectCommand = cmd;
            DataSet ds = new DataSet();
            dbDataAdapter.Fill(ds);
            return ds;
        }
        /// <summary>
        /// 执行sql或者存储过程返回一个DataTable对象+事务
        /// </summary>
        /// <param name="cmd">cmd对象</param>
        /// <param name="t">事务执行操作</param>
        /// <returns></returns>
        public DataTable ExecuteDataTable(DbCommand cmd, Trans t)
        {
            cmd.Connection = t.DbConnection;
            cmd.Transaction = t.DbTrans;
            DbProviderFactory dbfactory = DbProviderFactories.GetFactory(DBHelper.dbProviderName);
            DbDataAdapter dbDataAdapter = dbfactory.CreateDataAdapter();
            dbDataAdapter.SelectCommand = cmd;
            DataTable dataTable = new DataTable();
            dbDataAdapter.Fill(dataTable);
            return dataTable;
        }
        /// <summary>
        /// 执行sql或者存储过程返回一个DbDataReader对象+事务
        /// </summary>
        /// <param name="cmd">cmd对象</param>
        /// <param name="t">事务执行操作</param>
        /// <returns></returns>
        public DbDataReader ExecuteReader(DbCommand cmd, Trans t)
        {
            cmd.Connection.Close();
            cmd.Connection = t.DbConnection;
            cmd.Transaction = t.DbTrans;
            DbDataReader reader = cmd.ExecuteReader();
            DataTable dt = new DataTable();
            return reader;
        }
        /// <summary>
        /// 执行一条sql语句或者存储过程，返回受影响的行数+事务
        /// </summary>
        /// <param name="cmd">cmd对象</param>
        /// <param name="t">事务执行操作</param>
        /// <returns></returns>
        public int ExecuteNonQuery(DbCommand cmd, Trans t)
        {
            cmd.Connection.Close();
            cmd.Connection = t.DbConnection;
            cmd.Transaction = t.DbTrans;
            int ret = cmd.ExecuteNonQuery();
            return ret;
        }
        /// <summary>
        /// 执行sql或者存储过程返回一个object对象+事务
        /// </summary>
        /// <param name="cmd">cmd对象</param>
        /// <param name="t">事务执行操作</param>
        /// <returns></returns>
        public object ExecuteScalar(DbCommand cmd, Trans t)
        {
            cmd.Connection.Close();
            cmd.Connection = t.DbConnection;
            cmd.Transaction = t.DbTrans;
            object ret = cmd.ExecuteScalar();
            return ret;
        }

        #endregion
    }


    public class Trans : IDisposable
    {
        //数据库连接
        private DbConnection conn;
        //事务
        private DbTransaction dbTrans;

        /// <summary>
        /// 数据库连接
        /// </summary>
        public DbConnection DbConnection
        {
            get { return this.conn; }
        }
        /// <summary>
        /// 事务
        /// </summary>
        public DbTransaction DbTrans
        {
            get { return this.dbTrans; }
        }

        /// <summary>
        /// 构造函数
        /// 打开数据库连接
        /// 开启事务
        /// </summary>
        public Trans()
        {
            conn = DBHelper.CreateConnection();
            conn.Open();
            dbTrans = conn.BeginTransaction();
        }
        /// <summary>
        /// 构造函数
        /// 打开数据库连接
        /// 开启事务
        /// </summary>
        /// <param name="connectionString">数据库连接</param>
        public Trans(string connectionString)
        {
            conn = DBHelper.CreateConnection(connectionString);
            conn.Open();
            dbTrans = conn.BeginTransaction();
        }
        /// <summary>
        /// 事务提交
        /// </summary>
        public void Commit()
        {
            dbTrans.Commit();
            this.Colse();
        }
        /// <summary>
        /// 事务回滚
        /// </summary>
        public void RollBack()
        {
            dbTrans.Rollback();
            this.Colse();
        }
        /// <summary>
        /// 释放资源
        /// </summary>
        public void Dispose()
        {
            this.Colse();
        }
        /// <summary>
        /// 关闭数据库连接
        /// </summary>
        public void Colse()
        {
            if (conn.State == System.Data.ConnectionState.Open)
            {
                conn.Close();
            }
        }
    }
}
  1. 1
  2. 2