数据访问公共类（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解决 ...

随机推荐

Linux Oracle DB log 清理
sid_list=`/bin/ps -ef |/bin/grep smon |/bin/grep -v grep | /bin/cut -f3 -d_` host_name=`hostname` cd ...
Switch能否用string做参数
在Java5以前,switch(expr)中,exper只能是byte,short,char,int类型(或其包装类)的常量表达式. 从Java5开始,java中引入了枚举类型,即enum类型. 从J ...
AC日记——Mice and Holes codeforces 797f
797F - Mice and Holes 思路: XXYXX: 代码: #include <cmath> #include <cstdio> #include <cst ...
DP【p2051(bzoj 1801)】 [AHOI2009]中国象棋.
题目描述这次小可可想解决的难题和中国象棋有关,在一个N行M列的棋盘上,让你放若干个炮(可以是0个),使得没有一个炮可以攻击到另一个炮,请问有多少种放置方法.大家肯定很清楚,在中国象棋中炮的行走方式是 ...
【字符串】Your Ride Is Here
题目描述 It is a well-known fact that behind every good comet is a UFO. These UFOs often come to collect ...
java有自动垃圾回收机制
当垃圾收集器判断已经没有任何引用指向对象的时候,会调用对象的finalize方法来释放对象占据的内存空间~ java中垃圾回收以前听老师讲好像是内存满了他才去做一次整体垃圾回收,在回收垃圾的同时会调用 ...
[BZOJ5289][HNOI2018]排列(拓扑排序+pb_ds)
首先确定将所有a[i]向i连边之后会形成一张图,图上每条有向边i->j表示i要在j之前选. 图上的每个拓扑序都对应一种方案(如果有环显然无解),经过一系列推导可以发现贪心策略与合并的块的大小和w ...
2.2多线程（java学习笔记）线程状态及线程操作的相关方法
一.线程的状态线程一般具有五种状态,即创建.就绪.运行.阻塞.终止. 它们之间的关系: 二.线程操作相关方法 1.设置和取得线程名称. 如果不设置线程名称,系统会自动分配线程名,一般格式为Threa ...
spring-----mvc的反射调用
这几天在看spring mvc 源码,一直很好奇它究竟在哪进行的反射调用,通过源码,仔细阅读,最后发现了调用位置在类 InvocableHandlerMethod 的doInvoke 方法 /** * ...
使用gtest自动化测试并给出性能测试结果（windows 版本，版本平台也可以使用，但并没有做完整的测试）
/************************************************************* *使用gtest自动化测试 * ********************* ...

数据访问公共类（BaseProvider）

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

随机推荐

热门专题