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

随机推荐

I2C总线介绍
1. 简介 I2C, Inter-Integrated Circuit, 是一种串行通信总线,用于连接微控制器及其外围设备它是一种两线式串行总线(串行数据:SDA; 串行时钟频率:SCL), 利用电阻 ...
Altium Designer 总线式布线
1.常规布线:不详细说了,是个人就知道怎么弄.需要说明的是在布线过程中,可按小键盘的*键或大键盘的数字2键添加一个过孔:按L键可以切换布线层:按数字3可设定最小线宽.典型线宽.最大线宽的值进行切换. ...
【计算机网络】HTTP协议详解
详见:http://blog.csdn.net/gueter/article/details/1524447 不让转载,但写得很好
【linux高级程序设计】（第十章）Linux异步信号处理机制 3
信号屏蔽信号忽略:系统仍然传递该信号,只是相应的进程不做任何处理信号屏蔽:进程不捕获信号,信号处于未决状态,当不再屏蔽信号时可以捕获之前被屏蔽的信号. 信号集数据结构定义: typedef __s ...
vue.js 2的表单控件
静下心,抄一段sample,以后可以快点到这里来抄...: <!DOCTYPE html> <html> <head> <meta charset=" ...
Javascript短路表达式
短路表达式:作为"&&"和"||"操作符的操作数表达式,这些表达式在进行求值时,只要最终的结果已经可以确定是真或假,求值过程便告终止,这称之为短 ...
树莓派3b入门教程
原文地址:传送门这篇教程将带您一起玩转树莓派3(Raspberry Pi 3).和普通PC一样,拿到新设备第一件事就是要给它安装一个操作系统,并做一些初始化的操作.比PC简单的是,树莓派是一个固定配 ...
使用net包发送http请求
[java] view plain copy import java.io.BufferedReader; import java.io.InputStream; import java.io.Inp ...
Linux CURL的安装
Linux CURL的安装 Linux CURL的安装 --获得安装包,从网上直接下载或者其他途径,这里直接wget# wget http://curl.haxx.se/download/cur ...
Android的数据存储方式概述
数据存储在开发中是使用最频繁的,在这里主要介绍Android平台中实现数据存储的5种方式,分别是: 1 使用SharedPreferences存储数据 2 文件存储数据 3 SQLite数据库存储数据 ...

数据访问公共类（BaseProvider）

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

随机推荐

热门专题