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

随机推荐

安装戴尔OMSA
设置变量versionum=`cat /etc/redhat-release | awk '{print $3}' | awk -F '.' '{print $1}'`versionname=`cat ...
sysbench（mysql测试工具）
目录一.基准测试简介 1.什么是基准测试 2.基准测试的作用 3.基准测试的指标 4.基准测试的分类二.sysbench 1.sysbench简介 2.sysbench安装 3.sysbench语 ...
jquery导出Excel表格
1.引用js插件 <script src="tableExport.js"></script> <script src="jquery.ba ...
ACM阶段总结（2016.10.07-2016.11.09)
来这里也有一段时间了…… 总感觉自己练得不是很有效. 最近的一些行动就是不断做比赛,然后不停地补,但是感觉这样像只无头苍蝇,没有效果,学不到什么真正的东西. 最近开始打算补专题,做做codeforce ...
js加强
js加强 js深度解析闭包讲解 1.闭包是和gc(垃圾回收机制)相关的 2.闭包实际上是涉及一个对象属性何时被gc回收的问题 3怎样产生闭包? <script type="tex ...
luogu 2509. 森林大礼包
2509. 森林大礼包 ★ 输入文件:three_squirrels.in 输出文件:three_squirrels.out 简单对比时间限制:1 s 内存限制:256 MB [题目描 ...
[Bzoj5285][洛谷P4424][HNOI/AHOI2018]寻宝游戏（bitset）
P4424 [HNOI/AHOI2018]寻宝游戏某大学每年都会有一次Mystery Hunt的活动,玩家需要根据设置的线索解谜,找到宝藏的位置,前一年获胜的队伍可以获得这一年出题的机会. 作为新生 ...
Struts2笔记--文件下载
Struts2提供了stream结果类型,该结果类型是专门用于支持文件下载功能的.配置stream类型的结果需要指定以下4个属性. contentType:指定被下载文件的文件类型 inputName ...
学习Flash 3D图形图像知识的网络资源集合
1. 华中科技大学计算机学院开放式课程--计算机图形学 http://cs.hust.edu.cn/webroot/courses/csgraphics/index.php 2.深入Stage3D_7 ...
十. 图形界面(GUI)设计1.图形界面设计基础
早先程序使用最简单的输入输出方式,用户在键盘输入数据,程序将信息输出在屏幕上.现代程序要求使用图形用户界面(Graphical User Interface,GUI),界面中有菜单.按钮等,用户通过鼠 ...

数据访问公共类（BaseProvider）

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

随机推荐

热门专题