数据访问公共类（BaseProvider）

最新推荐文章于 2022-03-29 10:12:41 发布
最新推荐文章于 2022-03-29 10:12:41 发布
阅读量235 收藏
点赞数
原文链接：http://www.cnblogs.com/ahlx/p/5226840.html
版权 
using System;
using System.Data;
using System.Data.Common;
using System.Configuration;
using System.Text;
using System.Collections.Generic;
using System.Data.SqlClient;

namespace MDCRM.DAL
{
    /// <summary>
    /// 数据访问基类
    /// </summary>
    public abstract class BaseProvider
    {


        protected string ConnectionString { get; set; }
            
        protected BaseProvider()
        {
            this.ConnectionString = ConfigurationManager.ConnectionStrings["ConnectionString"].ConnectionString;
        }

        /// <summary>
        /// 构造
        /// </summary>
        /// <param name="connectionStringSectionName">链接字符串节点对应名称</param>
        protected BaseProvider(string connectionStringSectionName)
        {
            this.ConnectionString = ConfigurationManager.ConnectionStrings[connectionStringSectionName].ConnectionString;
        }

        /// <summary>
        /// 执行 ExecuteNonQuery
        /// </summary>
        protected int ExecuteNonQuery(DbCommand cmd)
        {
            foreach (DbParameter param in cmd.Parameters)
            {
                if (param.Direction == ParameterDirection.Output || param.Direction == ParameterDirection.ReturnValue)
                {
                    switch (param.DbType)
                    {
                        case DbType.AnsiString:
                        case DbType.AnsiStringFixedLength:
                        case DbType.String:
                        case DbType.StringFixedLength:
                        case DbType.Xml:
                            param.Value = string.Empty;
                            break;
                        case DbType.Boolean:
                            param.Value = false;
                            break;
                        case DbType.Byte:
                            param.Value = byte.MinValue;
                            break;
                        case DbType.Date:
                        case DbType.DateTime:
                            param.Value = DateTime.MinValue;
                            break;
                        case DbType.Currency:
                        case DbType.Decimal:
                            param.Value = decimal.MinValue;
                            break;
                        case DbType.Guid:
                            param.Value = Guid.Empty;
                            break;
                        case DbType.Double:
                        case DbType.Int16:
                        case DbType.Int32:
                        case DbType.Int64:
                            param.Value = 0;
                            break;
                        default:
                            param.Value = null;
                            break;
                    }
                }
            }

            FilterSqlParameter(cmd);

            return cmd.ExecuteNonQuery();
        }

        /// <summary>
        /// 执行 ExecuteReader
        /// </summary>
        protected IDataReader ExecuteReader(DbCommand cmd)
        {
            FilterSqlParameter(cmd);

            return ExecuteReader(cmd, CommandBehavior.Default);
        }

        /// <summary>
        /// 执行 ExecuteReader
        /// </summary>
        protected IDataReader ExecuteReader(DbCommand cmd, CommandBehavior behavior)
        {
            FilterSqlParameter(cmd);

            return cmd.ExecuteReader(behavior);
        }

        /// <summary>
        /// 执行查询，并返回查询所返回的结果集中第一行的第一列。所有其他的列和行将被忽略。
        /// </summary>
        protected object ExecuteScalar(DbCommand cmd)
        {
            FilterSqlParameter(cmd);

            return cmd.ExecuteScalar();
        }

        /// <summary>
        /// 执行查询，返回数据结果集
        /// </summary>
        protected void FillDataSet(System.Data.DataSet dataSet, DbCommand cmd, string tableNames)
        {
            FillDataSet(dataSet, cmd, tableNames.Split('|'));
        }

        /// <summary>
        /// 执行查询，返回数据结果集
        /// </summary>
        protected void FillDataSet(System.Data.DataSet dataSet, DbCommand cmd, string[] tableNames)
        {
            System.Data.SqlClient.SqlDataAdapter dataAdapter = new System.Data.SqlClient.SqlDataAdapter((System.Data.SqlClient.SqlCommand)cmd);
            cmd.CommandTimeout = 10000;

            string mapTableName = "Table";
            for (int index = 0; index < tableNames.Length; index++)
            {
                if (tableNames[index] != null && tableNames[index].Length >= 0)
                {
                    dataAdapter.TableMappings.Add(mapTableName, tableNames[index]);
                    mapTableName = "Table" + (index + 1).ToString();
                }
            }

            FilterSqlParameter(cmd);

           dataAdapter.Fill(dataSet);
        }


        /// <summary>
        /// 集合转成搜索条件
        /// </summary>
        protected string ListToString<T>(List<T> list, char departChar)
        {
            string listStr = string.Empty;
            if (list != null && list.Count > 0)
            {
                foreach (T tType in list)
                {
                    if (!string.IsNullOrEmpty(tType.ToString().Trim()))
                        listStr += tType.ToString().Trim() + departChar.ToString();
                }
            }
            return listStr.Trim(departChar);
        }

        /// <summary>
        /// 集合转成搜索条件
        /// </summary>
        protected string ListToString<T>(List<T> list, string departStr)
        {
            string listStr = string.Empty;
            if (list != null && list.Count > 0)
            {
                foreach (T tType in list)
                {
                    if (!string.IsNullOrEmpty(tType.ToString().Trim()))
                        listStr += tType.ToString().Trim() + departStr.ToString();
                }
            }

            if (!string.IsNullOrEmpty(listStr))
                listStr = listStr.Remove(listStr.Length - departStr.Length);

            return listStr;
        }

        /// <summary>
        /// 数组转成搜索条件
        /// </summary>
        protected string ArrayToString<T>(T[] arr, char departChar)
        {
            string listStr = string.Empty;
            if (arr != null && arr.Length > 0)
            {
                foreach (T tType in arr)
                {
                    if (!string.IsNullOrEmpty(tType.ToString().Trim()))
                        listStr += tType.ToString().Trim() + departChar.ToString();
                }
            }
            return listStr.Trim(departChar);
        }

        /// <summary>
        /// 过滤注入式特殊符号
        /// </summary>
        protected SqlParameter[] FilterSqlParameterArray(params SqlParameter[] parameterValues)
        {
            int paraCount = 0;
            paraCount = parameterValues.Length;
            SqlParameter[] paraArray = new SqlParameter[paraCount];
            for (int i = 0; i < paraCount; i++)
            {
                SqlParameter parameterValue = parameterValues[i];
                if (parameterValue.DbType == DbType.AnsiString || parameterValue.DbType == DbType.String || parameterValue.SqlDbType == SqlDbType.VarChar || parameterValue.SqlDbType == SqlDbType.NVarChar || parameterValue.SqlDbType == SqlDbType.Text)
                {
                    if (parameterValue.Value != null && parameterValue.Value.ToString() != "")
                        parameterValue.Value = parameterValue.Value.ToString().Replace("'", "''").Replace("--", "");
                }
                paraArray[i] = parameterValue;
            }
            return paraArray;
        }

        /// <summary>
        /// 过滤注入式特殊符号
        /// </summary>
        protected void FilterSqlParameter(DbCommand cmd)
        {
            int paraCount = 0;
            paraCount = cmd.Parameters.Count;
            SqlParameter[] paraArray = new SqlParameter[paraCount];
            for (int i = 0; i < paraCount; i++)
            {
                SqlParameter parameterValue = (SqlParameter)cmd.Parameters[i];
                if (parameterValue.DbType == DbType.AnsiString || parameterValue.DbType == DbType.String || parameterValue.SqlDbType == SqlDbType.VarChar || parameterValue.SqlDbType == SqlDbType.NVarChar || parameterValue.SqlDbType == SqlDbType.Text)
                {
                    if (parameterValue.Value != null && parameterValue.Value.ToString() != "")
                        parameterValue.Value = parameterValue.Value.ToString().Replace("'", "''").Replace("--", "");
                }
                paraArray[i] = parameterValue;
            }

            cmd.Parameters.Clear();
            cmd.Parameters.AddRange(paraArray);
        }
        /// <summary>
        /// 将传入的参数生成为相应的sql语句
        /// </summary>
        /// <param name="param">SqlParameter[]</param>
        /// <param name="split">split</param>
        /// <returns>string</returns>
        protected string SqlParameterToSql(SqlParameter[] param, string split)
        {
            string sql = string.Empty;
            if (param == null) return sql;
            for (int i = 0; i < param.Length; i++)
            {
                SqlParameter key = param[i];
                if (i > 0)
                {
                    sql += " " + split;
                }
                sql += string.Format(" {0}=@{1}", key.ParameterName, key.ParameterName);
            }
            return sql;
        }
        /// <summary>
        /// 执行查询
        /// </summary>
        /// <param name="ConnectionString">ConnectionString</param>
        /// <param name="data">DataSet</param>
        /// <param name="tableName">string</param>
        /// <param name="param">SqlSelectEntity</param>
        protected void Select(string ConnectionString, DataSet data, string tableName, SqlSelectEntity param)
        {
            string select = string.Join(",", param.Select.ToArray());
            string where = " 1=1 ";
            if (param.Where != null)
            {
                where += "and " + SqlParameterToSql(param.Where, "and");
            }
            string sql = string.Format("select {0} from {1} where {2}", select, param.TableName, where);
            if (!string.IsNullOrEmpty(param.Sort)) {
                sql += string.Format(" order by {0}", param.Sort);
            }
            using (SqlConnection conn = new SqlConnection(ConnectionString))
            {
                SqlCommand cmd = new SqlCommand(sql, conn);
                if (param.Where != null)
                    cmd.Parameters.AddRange(param.Where);
                conn.Open();

                FillDataSet(data, cmd, tableName);
            }
        }
        /// <summary>
        /// 执行更新
        /// </summary>
        /// <param name="ConnectionString">ConnectionString</param>
        /// <param name="param">SqlUpdateEntity</param>
        /// <returns>int(受影响的行数)</returns>
        protected int Update(string ConnectionString, SqlUpdateEntity param)
        {
            string where = " 1=1 ";
            string update = SqlParameterToSql(param.Update,",");
            if (param.Where!=null)
            {
                where += "and " + SqlParameterToSql(param.Where, "and");
            }
            string sql = string.Format("update {0} set {1} where {2}", param.TableName, update, where);

            using (SqlConnection conn = new SqlConnection(ConnectionString))
            {
                SqlCommand cmd = new SqlCommand(sql, conn);
                cmd.Parameters.AddRange(param.Update);
                if (param.Where != null)
                    cmd.Parameters.AddRange(param.Where);
                conn.Open();

                return ExecuteNonQuery(cmd);
            }
        }
        /// <summary>
        /// 执行删除
        /// </summary>
        /// <param name="ConnectionString">ConnectionString</param>
        /// <param name="param">SqlDeleteEntity</param>
        /// <returns>int(受影响的行数)</returns>
        protected int Delete(string ConnectionString, SqlDeleteEntity param)
        {
            string where = " 1=1 ";
            if (param.Where!=null)
            {
                where += "and " + SqlParameterToSql(param.Where, "and");
            }
            string sql = string.Format("delete from {0} where {1}", param.TableName, where);

            using (SqlConnection conn = new SqlConnection(ConnectionString))
            {
                SqlCommand cmd = new SqlCommand(sql, conn);
                if (param.Where != null)
                    cmd.Parameters.AddRange(param.Where);
                conn.Open();

                return ExecuteNonQuery(cmd);
            }
        }
        /// <summary>
        /// 执行插入
        /// </summary>
        /// <param name="ConnectionString">ConnectionString</param>
        /// <param name="param">SqlInsertEntity</param>
        /// <returns>int(受影响的行数)</returns>
        protected int Insert(string ConnectionString, SqlInsertEntity param)
        {

            List<string> fileds = new List<string>();
            List<string> values = new List<string>();
            foreach (SqlParameter parameter in param.Insert)
            {
                fileds.Add(parameter.ParameterName);
                values.Add("@" + parameter.ParameterName);
            }
            string sql = string.Format("insert into {0}({1}) values({2})", param.TableName, string.Join(",", fileds), string.Join(",", values));

            using (SqlConnection conn = new SqlConnection(ConnectionString))
            {
                SqlCommand cmd = new SqlCommand(sql, conn);
                cmd.Parameters.AddRange(param.Insert);
                conn.Open();

                return ExecuteNonQuery(cmd);
            }
        }
    }
    /// <summary>
    /// 查询的基类
    /// </summary>
    public class SqlEntity
    {
        /// <summary>
        /// 数据表名称
        /// </summary>
        public string TableName { get; set; }
    }
    /// <summary>
    /// Select Class
    /// </summary>
    public class SqlSelectEntity : SqlEntity
    {
        /// <summary>
        /// 需要查询的字段，查询所有字段传new List<string>(){"*"}
        /// </summary>
        public List<string> Select { get; set; }
        /// <summary>
        /// 查询条件new SqlParameter[]{ new SqlParameter("Filed",FiledValue) };
        /// 不需要@
        /// </summary>
        public SqlParameter[] Where { get; set; }
        /// <summary>
        /// 排序字符串 CreateTime Desc
        /// </summary>
        public string Sort { get; set; }

    }
    /// <summary>
    /// Insert Class
    /// </summary>
    public class SqlInsertEntity : SqlEntity
    {
        /// <summary>
        /// 插入的字段和值 new SqlParameter[]{ new SqlParameter("Filed",FiledValue) };
        /// 不需要@
        /// </summary>
        public SqlParameter[] Insert { get; set; }

    }
    /// <summary>
    /// Update Class
    /// </summary>
    public class SqlUpdateEntity : SqlEntity
    {
        /// <summary>
        /// 更新的字段和值 new SqlParameter[]{ new SqlParameter("Filed",FiledValue) };
        /// 不需要@
        /// </summary>
        public SqlParameter[] Update { get; set; }
        /// <summary>
        /// 查询条件new SqlParameter[]{ new SqlParameter("Filed",FiledValue) };
        /// 不需要@
        /// </summary>
        public SqlParameter[] Where { get; set; }
    }
    /// <summary>
    /// Delete Class
    /// </summary>
    public class SqlDeleteEntity : SqlEntity
    { 
        /// <summary>
        /// 查询条件new SqlParameter[]{ new SqlParameter("Filed",FiledValue) };
        /// 不需要@
        /// </summary>
        public SqlParameter[] Where { get; set; }
    }
}

　　

using System;
using System.Data;
using System.Data.Common;
using System.Configuration;
using System.Text;
using System.Collections.Generic;
using System.Data.SqlClient;

namespace MDCRM.DAL
{
/// <summary>
/// 数据访问基类
/// </summary>
public abstract class BaseProvider
{


protected string ConnectionString { get; set; }

protected BaseProvider()
{
this.ConnectionString = ConfigurationManager.ConnectionStrings["ConnectionString"].ConnectionString;
}

/// <summary>
/// 构造
/// </summary>
/// <param name="connectionStringSectionName">链接字符串节点对应名称</param>
protected BaseProvider(string connectionStringSectionName)
{
this.ConnectionString = ConfigurationManager.ConnectionStrings[connectionStringSectionName].ConnectionString;
}

/// <summary>
/// 执行 ExecuteNonQuery
/// </summary>
protected int ExecuteNonQuery(DbCommand cmd)
{
foreach (DbParameter param in cmd.Parameters)
{
if (param.Direction == ParameterDirection.Output || param.Direction == ParameterDirection.ReturnValue)
{
switch (param.DbType)
{
case DbType.AnsiString:
case DbType.AnsiStringFixedLength:
case DbType.String:
case DbType.StringFixedLength:
case DbType.Xml:
param.Value = string.Empty;
break;
case DbType.Boolean:
param.Value = false;
break;
case DbType.Byte:
param.Value = byte.MinValue;
break;
case DbType.Date:
case DbType.DateTime:
param.Value = DateTime.MinValue;
break;
case DbType.Currency:
case DbType.Decimal:
param.Value = decimal.MinValue;
break;
case DbType.Guid:
param.Value = Guid.Empty;
break;
case DbType.Double:
case DbType.Int16:
case DbType.Int32:
case DbType.Int64:
param.Value = 0;
break;
default:
param.Value = null;
break;
}
}
}

FilterSqlParameter(cmd);

return cmd.ExecuteNonQuery();
}

/// <summary>
/// 执行 ExecuteReader
/// </summary>
protected IDataReader ExecuteReader(DbCommand cmd)
{
FilterSqlParameter(cmd);

return ExecuteReader(cmd, CommandBehavior.Default);
}

/// <summary>
/// 执行 ExecuteReader
/// </summary>
protected IDataReader ExecuteReader(DbCommand cmd, CommandBehavior behavior)
{
FilterSqlParameter(cmd);

return cmd.ExecuteReader(behavior);
}

/// <summary>
/// 执行查询，并返回查询所返回的结果集中第一行的第一列。所有其他的列和行将被忽略。
/// </summary>
protected object ExecuteScalar(DbCommand cmd)
{
FilterSqlParameter(cmd);

return cmd.ExecuteScalar();
}

/// <summary>
/// 执行查询，返回数据结果集
/// </summary>
protected void FillDataSet(System.Data.DataSet dataSet, DbCommand cmd, string tableNames)
{
FillDataSet(dataSet, cmd, tableNames.Split('|'));
}

/// <summary>
/// 执行查询，返回数据结果集
/// </summary>
protected void FillDataSet(System.Data.DataSet dataSet, DbCommand cmd, string[] tableNames)
{
System.Data.SqlClient.SqlDataAdapter dataAdapter = new System.Data.SqlClient.SqlDataAdapter((System.Data.SqlClient.SqlCommand)cmd);
cmd.CommandTimeout = 10000;

string mapTableName = "Table";
for (int index = 0; index < tableNames.Length; index++)
{
if (tableNames[index] != null && tableNames[index].Length >= 0)
{
dataAdapter.TableMappings.Add(mapTableName, tableNames[index]);
mapTableName = "Table" + (index + 1).ToString();
}
}

FilterSqlParameter(cmd);

dataAdapter.Fill(dataSet);
}


/// <summary>
/// 集合转成搜索条件
/// </summary>
protected string ListToString<T>(List<T> list, char departChar)
{
string listStr = string.Empty;
if (list != null && list.Count > 0)
{
foreach (T tType in list)
{
if (!string.IsNullOrEmpty(tType.ToString().Trim()))
listStr += tType.ToString().Trim() + departChar.ToString();
}
}
return listStr.Trim(departChar);
}

/// <summary>
/// 集合转成搜索条件
/// </summary>
protected string ListToString<T>(List<T> list, string departStr)
{
string listStr = string.Empty;
if (list != null && list.Count > 0)
{
foreach (T tType in list)
{
if (!string.IsNullOrEmpty(tType.ToString().Trim()))
listStr += tType.ToString().Trim() + departStr.ToString();
}
}

if (!string.IsNullOrEmpty(listStr))
listStr = listStr.Remove(listStr.Length - departStr.Length);

return listStr;
}

/// <summary>
/// 数组转成搜索条件
/// </summary>
protected string ArrayToString<T>(T[] arr, char departChar)
{
string listStr = string.Empty;
if (arr != null && arr.Length > 0)
{
foreach (T tType in arr)
{
if (!string.IsNullOrEmpty(tType.ToString().Trim()))
listStr += tType.ToString().Trim() + departChar.ToString();
}
}
return listStr.Trim(departChar);
}

/// <summary>
/// 过滤注入式特殊符号
/// </summary>
protected SqlParameter[] FilterSqlParameterArray(params SqlParameter[] parameterValues)
{
int paraCount = 0;
paraCount = parameterValues.Length;
SqlParameter[] paraArray = new SqlParameter[paraCount];
for (int i = 0; i < paraCount; i++)
{
SqlParameter parameterValue = parameterValues[i];
if (parameterValue.DbType == DbType.AnsiString || parameterValue.DbType == DbType.String || parameterValue.SqlDbType == SqlDbType.VarChar || parameterValue.SqlDbType == SqlDbType.NVarChar || parameterValue.SqlDbType == SqlDbType.Text)
{
if (parameterValue.Value != null && parameterValue.Value.ToString() != "")
parameterValue.Value = parameterValue.Value.ToString().Replace("'", "''").Replace("--", "");
}
paraArray[i] = parameterValue;
}
return paraArray;
}

/// <summary>
/// 过滤注入式特殊符号
/// </summary>
protected void FilterSqlParameter(DbCommand cmd)
{
int paraCount = 0;
paraCount = cmd.Parameters.Count;
SqlParameter[] paraArray = new SqlParameter[paraCount];
for (int i = 0; i < paraCount; i++)
{
SqlParameter parameterValue = (SqlParameter)cmd.Parameters[i];
if (parameterValue.DbType == DbType.AnsiString || parameterValue.DbType == DbType.String || parameterValue.SqlDbType == SqlDbType.VarChar || parameterValue.SqlDbType == SqlDbType.NVarChar || parameterValue.SqlDbType == SqlDbType.Text)
{
if (parameterValue.Value != null && parameterValue.Value.ToString() != "")
parameterValue.Value = parameterValue.Value.ToString().Replace("'", "''").Replace("--", "");
}
paraArray[i] = parameterValue;
}

cmd.Parameters.Clear();
cmd.Parameters.AddRange(paraArray);
}
/// <summary>
/// 将传入的参数生成为相应的sql语句
/// </summary>
/// <param name="param">SqlParameter[]</param>
/// <param name="split">split</param>
/// <returns>string</returns>
protected string SqlParameterToSql(SqlParameter[] param, string split)
{
string sql = string.Empty;
if (param == null) return sql;
for (int i = 0; i < param.Length; i++)
{
SqlParameter key = param[i];
if (i > 0)
{
sql += " " + split;
}
sql += string.Format(" {0}=@{1}", key.ParameterName, key.ParameterName);
}
return sql;
}
/// <summary>
/// 执行查询
/// </summary>
/// <param name="ConnectionString">ConnectionString</param>
/// <param name="data">DataSet</param>
/// <param name="tableName">string</param>
/// <param name="param">SqlSelectEntity</param>
protected void Select(string ConnectionString, DataSet data, string tableName, SqlSelectEntity param)
{
string select = string.Join(",", param.Select.ToArray());
string where = " 1=1 ";
if (param.Where != null)
{
where += "and " + SqlParameterToSql(param.Where, "and");
}
string sql = string.Format("select {0} from {1} where {2}", select, param.TableName, where);
if (!string.IsNullOrEmpty(param.Sort)) {
sql += string.Format(" order by {0}", param.Sort);
}
using (SqlConnection conn = new SqlConnection(ConnectionString))
{
SqlCommand cmd = new SqlCommand(sql, conn);
if (param.Where != null)
cmd.Parameters.AddRange(param.Where);
conn.Open();

FillDataSet(data, cmd, tableName);
}
}
/// <summary>
/// 执行更新
/// </summary>
/// <param name="ConnectionString">ConnectionString</param>
/// <param name="param">SqlUpdateEntity</param>
/// <returns>int(受影响的行数)</returns>
protected int Update(string ConnectionString, SqlUpdateEntity param)
{
string where = " 1=1 ";
string update = SqlParameterToSql(param.Update,",");
if (param.Where!=null)
{
where += "and " + SqlParameterToSql(param.Where, "and");
}
string sql = string.Format("update {0} set {1} where {2}", param.TableName, update, where);

using (SqlConnection conn = new SqlConnection(ConnectionString))
{
SqlCommand cmd = new SqlCommand(sql, conn);
cmd.Parameters.AddRange(param.Update);
if (param.Where != null)
cmd.Parameters.AddRange(param.Where);
conn.Open();

return ExecuteNonQuery(cmd);
}
}
/// <summary>
/// 执行删除
/// </summary>
/// <param name="ConnectionString">ConnectionString</param>
/// <param name="param">SqlDeleteEntity</param>
/// <returns>int(受影响的行数)</returns>
protected int Delete(string ConnectionString, SqlDeleteEntity param)
{
string where = " 1=1 ";
if (param.Where!=null)
{
where += "and " + SqlParameterToSql(param.Where, "and");
}
string sql = string.Format("delete from {0} where {1}", param.TableName, where);

using (SqlConnection conn = new SqlConnection(ConnectionString))
{
SqlCommand cmd = new SqlCommand(sql, conn);
if (param.Where != null)
cmd.Parameters.AddRange(param.Where);
conn.Open();

return ExecuteNonQuery(cmd);
}
}
/// <summary>
/// 执行插入
/// </summary>
/// <param name="ConnectionString">ConnectionString</param>
/// <param name="param">SqlInsertEntity</param>
/// <returns>int(受影响的行数)</returns>
protected int Insert(string ConnectionString, SqlInsertEntity param)
{

List<string> fileds = new List<string>();
List<string> values = new List<string>();
foreach (SqlParameter parameter in param.Insert)
{
fileds.Add(parameter.ParameterName);
values.Add("@" + parameter.ParameterName);
}
string sql = string.Format("insert into {0}({1}) values({2})", param.TableName, string.Join(",", fileds), string.Join(",", values));

using (SqlConnection conn = new SqlConnection(ConnectionString))
{
SqlCommand cmd = new SqlCommand(sql, conn);
cmd.Parameters.AddRange(param.Insert);
conn.Open();

return ExecuteNonQuery(cmd);
}
}
}
/// <summary>
/// 查询的基类
/// </summary>
public class SqlEntity
{
/// <summary>
/// 数据表名称
/// </summary>
public string TableName { get; set; }
}
/// <summary>
/// Select Class
/// </summary>
public class SqlSelectEntity : SqlEntity
{
/// <summary>
/// 需要查询的字段，查询所有字段传new List<string>(){"*"}
/// </summary>
public List<string> Select { get; set; }
/// <summary>
/// 查询条件new SqlParameter[]{ new SqlParameter("Filed",FiledValue) };
/// 不需要@
/// </summary>
public SqlParameter[] Where { get; set; }
/// <summary>
/// 排序字符串 CreateTime Desc
/// </summary>
public string Sort { get; set; }

}
/// <summary>
/// Insert Class
/// </summary>
public class SqlInsertEntity : SqlEntity
{
/// <summary>
/// 插入的字段和值 new SqlParameter[]{ new SqlParameter("Filed",FiledValue) };
/// 不需要@
/// </summary>
public SqlParameter[] Insert { get; set; }

}
/// <summary>
/// Update Class
/// </summary>
public class SqlUpdateEntity : SqlEntity
{
/// <summary>
/// 更新的字段和值 new SqlParameter[]{ new SqlParameter("Filed",FiledValue) };
/// 不需要@
/// </summary>
public SqlParameter[] Update { get; set; }
/// <summary>
/// 查询条件new SqlParameter[]{ new SqlParameter("Filed",FiledValue) };
/// 不需要@
/// </summary>
public SqlParameter[] Where { get; set; }
}
/// <summary>
/// Delete Class
/// </summary>
public class SqlDeleteEntity : SqlEntity
{
/// <summary>
/// 查询条件new SqlParameter[]{ new SqlParameter("Filed",FiledValue) };
/// 不需要@
/// </summary>
public SqlParameter[] Where { get; set; }
}
}

转载于:https://www.cnblogs.com/ahlx/p/5226840.html

diadangai6018
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
yii2 / 在这里有个叫BaseDataProvider的老爹
weixin_34244102的博客
03-16 115
我们昨天说到了ActiveDataProvider、SqlDataProvider和ArrayDataProvider，从描述中不难发现这几个货的行为都差不多，因此yii2的开发者们为它们设置了一个BaseDataProvider的父类，而BaseDataProvider又实现了一个叫做DataProviderInterface的接口。 ...
ProviderBase类
weixin_30906185的博客
05-15 137
所有的提供程序都以某种方式派生于System.Configuration.Provider命名空间中的ProviderBase类。ProviderBase是一个抽象类，用于为继承它的提供程序定义基本模板。注意ProviderBase类包含的内容很少，如图15-3所示。 图 15-3 如前所述，这个类的内容不多。它只是提供程序的一个根类，可以让提供程序初始化它本身。 Name属性用于提供...
MyBatis之databaseIdProvider多数据库支持
热门推荐
火柴盒
05-13 2万+
一、databaseIdProvider官方描述MyBatis 可以根据不同的数据库厂商执行不同的语句，这种多厂商的支持是基于映射语句中的 databaseId 属性。 MyBatis 会加载不带 databaseId 属性和带有匹配当前数据库 databaseId 属性的所有语句。 如果同时找到带有 databaseId 和不带 databaseId 的相同语句，则后者会被舍弃。 这里什么
BaseQuickAdapter万能适配器实现分类型
heishuai123的博客
07-07 3786
多布局 对于多布局，提供了： BaseMultiItemQuickAdapter、BaseDelegateMultiAdapter、BaseProviderMultiAdapter 三种基础类型。 1、BaseMultiItemQuickAdapter 说明：适用于类型较少，业务不复杂的场景，便于快速使用。 所有的数据类型，都必须实现MultiItemEntity接口（注意，这里不是继承抽象类，而是实现接口，避免对业务的实体类带来影响） public class MultipleItemQuickAdapt
SAS数据分析_sasbase_数据分析_
10-02
本资料包"**SAS数据分析_sasbase_数据分析**_"显然专注于使用SAS Base进行数据探索、清洗、建模和解释。 首先，SAS Base中的数据管理功能包括数据导入导出、数据转换和数据整合。它可以处理多种数据格式，如CSV、...
asp.net C#数据库访问公共类
09-20
本文将深入探讨如何使用C#编写一个数据库访问公共类，以实现对SQL Server、Access和Oracle等不同数据库的通用操作。 首先，我们要创建一个数据库访问的基类，这个类通常包含连接数据库的基本方法，如打开、关闭连接...
php解析base64数据生成图片的方法
10-20
Base64编码是一种用于将二进制数据转换为ASCII字符串的编码方式，使得数据可以在纯文本环境中传输。下面将详细解释如何使用PHP解析Base64数据生成图片。 1. **Base64解码函数：`base64_decode()`** PHP提供了一个...
Base64加解密工具类
01-14
Base64工具类 功能：对字符串进行加解密，可携带混淆字符串、迭代次数 注： Base64字符串特点： 字符串只可能包含A-Z，a-z，0-9，+，/，=字符 字符串长度是4的倍数 =只会出现在字符串最后，可能没有...
图片与Base64互相转换的工具类
10-31
将图片转换成Base64编码 对字节数组字符串进行Base64解码并生成图片 Base64字符串转byte[] 判断图片base64字符串的文件格式 字符串转base64
Flutter中Sqlite数据库封装和使用
qq_19979101的博客
06-20 1万+
1、添加依赖，打开flutter项目根目录下的pubspec.yaml文件，添加依赖。 2、开始sqlite的数据操作基本封装，我一般是在lib目录下建一个db的包，把数据库相关操作的类都放在这个包下面，方面管理和维护，下面是的项目目录。 3、DBManger类，将数据库的创建，关闭等基础操作同一封装在一个类中统一管理。 DBManager这个类主要做了以下几件事情： ...
.Net5 框架搭建（七）：FreeSql配置多个数据库
shaojiayong的博客
11-12 3488
前言 因为项目关系，需要连接到多个数据库，之前我框架选择的ORM是FreeSql，所以这次我们对他进行一次简单的升级改造 方案 方式一：定义多个IFreeSql 像这样子要几个连接实例，就写几个类 优点：简单粗暴 缺点：100个连接实例，就得写100个。。 方式二：引用IdleBus重写IFreeSql IdleBus 空闲对象管理容器，有效组织对象重复利用，自动创建、销毁，解决【实例】过多且长时间占用的问题。有时候想做一个单例对象重复使用提升性能，但是定义多了，有的又可能一直空闲着占用资源。专门解决：又
ASP.NET三层架构DAL（数据访问层）——SqlHelper（公共类）创建
YHBoy11的博客
06-20 732
首先，我们先来介绍下公共类中常用的五大对象： Connection：连接对象 用于对数据库的连接操作，传入的参数为连接字符串。 Commamd：命令对象 用于执行对数据库的操作 ，传入的参数可以为连接字符串或存储过程，也必须传入连接对象的实例。 DataReader：数据读取对象 用于对数据的读取操作，实例.Read()方法可以返回一个True或者False来判断是否读取到了数据,我们可以直接使用 实例["字段名称"]来取出读取到的数据。 DataSet：数据集对象 该对象类似于在内存中的多张虚拟的
Cause: java.lang.InstantiationException: tk.mybatis.mapper.provider.base.BaseInsertProvider"
yflu0914的博客
01-28 1614
springboot项目 执行插入操作时，出现如下错误 {“status”:555,“msg”:“nested exception is org.apache.ibatis.builder.BuilderException: Error invoking SqlProvider method (tk.mybatis.mapper.provider.base.BaseInsertProvider.d...
怎么解决Cannot resolve method ‘getContextPath()‘这类问题
qq_48650296的博客
03-29 3328
当出现这类问题时，你就要想到是否是自己的jar包没有导入全，所以只需要添加相应的jar包即可 打开项目文件file 选择Project Structure 选择Libraries,点击+号，选择Java 导入自己本地Tomcat下的lib文件夹就可以,最后申请apply就可以解决问题！ ...
关于Mybatis3.5.1的ProviderMethodResolver
Ahageete的博客
06-17 1025
首先,我们在写@SelectProvider(本文以这个为例子)或者其他Provider是按照@SelectProvider(type=XXX.class,method="XXXXX")的方式写的,在3.5.1中,更新了所有provider的规范,现在只要在provider类上实现ProviderMethodResolver的接口,然后保证SQL编写@XXXXProvider注解的方法名一致,就可...
Provider中查询的一个Cursor对象问题
Robin Hu的专栏
12-04 2249
文章转自：http://archive.cnblogs.com/a/1984501/ 昨天写一个provider的时候出现了如下问题： 　　写完之后在同一个进程内使用provider完全没有问题，但是一旦到其他进程（另一个apk）里使用的时候就会报错 E/DatabaseUtils( 339): Writing exception to parcelE/DatabaseUti
使用ADO.NET轻松操纵数据库(二）
≡≡奋斗中的猫≡≡
08-06 2018
     首先，ADO.NET中使用了DataAdapter 来处理与数据库的联机与脱机。当时开发人员设计了DataAdapter是为了能够处理脱机数据，方便操作，关于这一点，只要调用其Fill()方法即可,这时会在DataSet中创建一个新的名为“Table“的DataTable.要重新指定名可用DataAdapter.Fill(DataSet,“Tabelname“)。此时connection
Time Base Provider
最新发布
07-25
"Time Base Provider" 可以理解为提供时间基准的实体或服务。它通常是一个硬件或软件组件，用于向系统或应用程序提供准确且稳定的时间参考。 在计算机系统中，时间基准非常重要，因为许多应用和操作需要依赖准确的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值