数据访问公共类（BaseProvider）

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; }
}
}

数据访问公共类（BaseProvider）的更多相关文章

【ASP.NET-中级】SQLHelper数据访问公共类
ASP.NET开发中的三层开发思想指的是UI层(界面显示层),BLL层(业务逻辑层),DAL层(数据访问层)三层,三层之间通过函数的调用来达到降低耦合,易于系统维护的目的,SQLHelper助手类的主 ...
基于SqlSugar的开发框架循序渐进介绍（4）-- 在数据访问基类中对GUID主键进行自动赋值处理
我们在设计数据库表的时候,往往为了方便,主键ID一般采用字符串类型或者GUID类型,这样对于数据库表记录的迁移非常方便,而且有时候可以在处理关联记录的时候,提前对应的ID值.但有时候进行数据记录插入的 ...
数据访问层的超级基类AbstractBaseDAL
using System; using System.Collections; using System.Data; using System.Data.Common; using System.Co ...
Spring.NET 中的 ADO.NET 数据访问的示例
Spring.NET 1.3.1 中提供了一个使用 AdoTemplate 的完整示例,包括使用泛型和使用非泛型技术进行数据访问,这个示例位于下载的压缩包中\Spring.NET-1.3.1\Spri ...
JS设计模式（三）数据访问对象模式
引言 HTML5 提供了两种在客户端存储数据的新方法:localStorage.sessionStorage,他们是Web Storage API 提供的两种存储机制,区别在于前者属于永久性存储,而后 ...
[转]DbHelper通用数据库访问帮助类
之前我一直都是在博客园中查看各位高手的博文,确实学到了不少知识,不过比较少写博客,现在就把我自己在项目实施过程中使用到比较好的技术框架写出来,希望能让更多的人了解和学习. 通常我们在开发使用数据库访问 ...
Util应用程序框架公共操作类（一）:数据类型转换公共操作类（介绍篇）
本系列文章将介绍一些对初学者有帮助的辅助类,这些辅助类本身并没有什么稀奇之处,如何能发现需要封装它们可能更加重要,所谓授之以鱼不如授之以渔,掌握封装公共操作类的技巧才是关键,我会详细说明创建这些类的动 ...
Util应用程序框架公共操作类(三):数据类型转换公共操作类（扩展篇）
上一篇以TDD方式介绍了数据类型转换公共操作类的开发,并提供了单元测试和实现代码,本文将演示通过扩展方法来增强公共操作类,以便调用时更加简化. 下面以字符串转换为List<Guid>为例进 ...
Util应用程序框架公共操作类(二):数据类型转换公共操作类（源码篇）
上一篇介绍了数据类型转换的一些情况,可以看出,如果不进行封装,有可能导致比较混乱的代码.本文通过TDD方式把数据类型转换公共操作类开发出来,并提供源码下载. 我们在应用程序框架实战十一:创建VS解决 ...

随机推荐

glOrthof 与glFrustumf
http://www.java123.net/v/533543.html glViewport()函数和glOrtho()函数的理解(转) 在OpenGL中有两个比较重要的投影变换函数,glViewp ...
SVN如何进行版本的还原
http://jingyan.baidu.com/article/d621e8da0d07022865913fa5.html 工具/原料 SVN乌龟软件和相关的文件百度经验:jingyan.baid ...
Windows8 上用Ubuntu-Ubuntu启动SSH
公司刚给配了一个电脑,华硕的超级本8个G的内存,很强大的了,但是系统是64位的windows 8,我用wubi.exe直接安装到系统上,但是开机启动的时候总是下面这个错误,去Ubuntu社区请教,结论 ...
centos7 挂载exfat格式的u盘
下载两个包 rpm -ivh http://download1.rpmfusion.org/free/el/updates/7/x86_64/f/fuse-exfat-1.2.8-1.el7.x86 ...
计蒜客 28201.Choosing Ice Cream-gcd (BAPC 2014 Preliminary ACM-ICPC Asia Training League 暑假第一阶段第一场 A)
开始水一波博客题目链接: A. Choosing Ice Cream 传送门题意就是n个冰淇淋,骰子有k个面,问你是否能在公平的概率下转几次骰子能确定买哪个冰淇淋. 举个例子,假设我只有一个冰淇淋 ...
树上各种DFS姿势算法笔记
树是指由n个点,n-1条边构成的联通无向图.如果有一棵树,它的每一条边(u,v)都有一个权值l(u,v),我们把这样的树称作带权树. 我们知道对于树上的任意两个点,他们之间的路径是唯一的.对于两个点u ...
APIO2018练习赛伪题解
传送门:https://pcms.university.innopolis.ru/statements/org/apio/2018/practice/statements.pdf 主要就在于后面三道构 ...
2.5多线程（Java学习笔记）生产者消费者模式
一.什么是生产者消费者模式生产者生产数据存放在缓冲区,消费者从缓冲区拿出数据处理. 可能大家会问这样有何好处? 1.解耦由于有了缓冲区,生产者和消费者之间不直接依赖,耦合度降低,便于程序拓展和维护 ...
SQL 统计某一列出现的总和
现有数据如上图所示,要求统计出日期相同的Count总数,并且加一列统计前面日期Count的总和 SELECT SUM([Count]) AS DayTotal, SUM(SUM([Count])) o ...
windows如何安装python zmq
百度windows python zmq 安装,真的是佩服百度还能活到今天,搜到的结果是各种yum 安装,各种jmq怎么安装,更有甚者直接整源代码编译,忍无可忍,所以自己写下这一篇自己探索出来的安装方 ...

数据访问公共类（BaseProvider）

数据访问公共类（BaseProvider）的更多相关文章

随机推荐

热门专题