步步为营 .NET三层架构解析 三、SQLHelper设计

最新推荐文章于 2024-09-15 12:22:38 发布
最新推荐文章于 2024-09-15 12:22:38 发布
阅读量259 收藏 1
点赞数
文章标签： 数据库

数据库设计好了,我们开始设计SQLHelper了,是一个SQL基类.

 连接数据源:

    private SqlConnection myConnection = null;
    private readonly string RETURNVALUE = "RETURNVALUE";

打开数据库连接.

 private void Open()
        {
            // 打开数据库连接
            if (myConnection == null)
            {
               //    myConnection = new SqlConnection(ConfigurationManager.ConnectionStrings["ConnectionString"].ConnectionString);
               myConnection = new SqlConnection(ConfigurationManager.AppSettings["ConnectionString"].ToString());
            
            }
            if (myConnection.State == ConnectionState.Closed)
            {
                try
                {
                    ///打开数据库连接
                    myConnection.Open();
                }
                catch (Exception ex)
                {
                    
                    SystemError.CreateErrorLog(ex.Message);
                }
                finally
                {
                    ///关闭已经打开的数据库连接				
                }
            }
        }

关闭数据库连接

 public void Close()
        {
            ///判断连接是否已经创建
            if (myConnection != null)
            {
                ///判断连接的状态是否打开
                if (myConnection.State == ConnectionState.Open)
                {
                    myConnection.Close();
                }
            }
        }

释放资源

        public void Dispose()
        {
            // 确认连接是否已经关闭
            if (myConnection != null)
            {
                myConnection.Dispose();
                myConnection = null;
            }
        }

执行无参数和返回int型的存储过程

public int RunProc(string procName)
        {
            SqlCommand cmd = CreateProcCommand(procName, null);
            try
            {
                ///执行存储过程
                cmd.ExecuteNonQuery();
            }
            catch (Exception ex)
            {
                ///记录错误日志
                SystemError.CreateErrorLog(ex.Message);
            }
            finally
            {
                ///关闭数据库的连接
                Close();
            }

            ///返回存储过程的参数值
            return (int)cmd.Parameters[RETURNVALUE].Value;
        }

执行传入参数和返回int型的存储过程

public int RunProc(string procName, SqlParameter[] prams)
        {
            SqlCommand cmd = CreateProcCommand(procName, prams);
            try
            {
                ///执行存储过程
                cmd.ExecuteNonQuery();
            }
            catch (Exception ex)
            {
                ///记录错误日志
                SystemError.CreateErrorLog(ex.Message);
            }
            finally
            {
                ///关闭数据库的连接
                Close();
            }

            ///返回存储过程的参数值
            return (int)cmd.Parameters[RETURNVALUE].Value;
        }

 执行存储过程和返回SqlDataReader

        public void RunProc(string procName, out SqlDataReader dataReader)
        {
            ///创建Command
            SqlCommand cmd = CreateProcCommand(procName, null);

            try
            {
                ///读取数据
                dataReader = cmd.ExecuteReader(CommandBehavior.CloseConnection);
            }
            catch (Exception ex)
            {
                dataReader = null;
                ///记录错误日志
                SystemError.CreateErrorLog(ex.Message);
            }
        }

 执行传入参数和返回SqlDataReader存储过程

public void RunProc(string procName, SqlParameter[] prams, out SqlDataReader dataReader)
        {
            ///创建Command
            SqlCommand cmd = CreateProcCommand(procName, prams);

            try
            {
                ///读取数据
                dataReader = cmd.ExecuteReader(CommandBehavior.CloseConnection);
            }
            catch (Exception ex)
            {
                dataReader = null;
                ///记录错误日志
                SystemError.CreateErrorLog(ex.Message);
            }
        }

执行无参数存储过程返回DataSet

        public void RunProc(string procName, ref DataSet dataSet)
        {
            if (dataSet == null)
            {
                dataSet = new DataSet();
            }
            ///创建SqlDataAdapter
            SqlDataAdapter da = CreateProcDataAdapter(procName, null);

            try
            {
                ///读取数据
                da.Fill(dataSet);
            }
            catch (Exception ex)
            {
                ///记录错误日志
                SystemError.CreateErrorLog(ex.Message);
            }
            finally
            {
                ///关闭数据库的连接
                Close();
            }
        }

执行传入参数的存储过程返回DataSet

 public void RunProc(string procName, SqlParameter[] prams, ref DataSet dataSet)
        {
            if (dataSet == null)
            {
                dataSet = new DataSet();
            }
            ///创建SqlDataAdapter
            SqlDataAdapter da = CreateProcDataAdapter(procName, prams);

            try
            {
                ///读取数据
                da.Fill(dataSet);
            }
            catch (Exception ex)
            {
                ///记录错误日志
                SystemError.CreateErrorLog(ex.Message);
            }
            finally
            {
                ///关闭数据库的连接
                Close();
            }
        }

执行传入参数和表名的存储过程返回DataSet

public void RunProc(string procName, SqlParameter[] prams, string TableName, ref DataSet dataSet)
        {
            if (dataSet == null)
            {
                dataSet = new DataSet();
            }
            ///创建SqlDataAdapter
            SqlDataAdapter da = CreateProcDataAdapter(procName, prams);

            try
            {
                ///读取数据
                da.Fill(dataSet, TableName);
            }
            catch (Exception ex)
            {
                ///记录错误日志
                SystemError.CreateErrorLog(ex.Message);
            }
            finally
            {
                ///关闭数据库的连接
                Close();
            }
        }

执行无参数SQL语句

        public int RunSQL(string cmdText)
        {
            SqlCommand cmd = CreateSQLCommand(cmdText, null);
            try
            {
                ///执行存储过程
                cmd.ExecuteNonQuery();
            }
            catch (Exception ex)
            {
                ///记录错误日志
                SystemError.CreateErrorLog(ex.Message);
            }
            finally
            {
                ///关闭数据库的连接
                Close();
            }

            ///返回存储过程的参数值
            return (int)cmd.Parameters[RETURNVALUE].Value;
        }

执行传入参数SQL语句

 public int RunSQL(string cmdText, SqlParameter[] prams)
        {
            SqlCommand cmd = CreateSQLCommand(cmdText, prams);
            try
            {
                ///执行存储过程
                cmd.ExecuteNonQuery();
            }
            catch (Exception ex)
            {
                ///记录错误日志
                SystemError.CreateErrorLog(ex.Message);
            }
            finally
            {
                ///关闭数据库的连接
                Close();
            }

            ///返回存储过程的参数值
            return (int)cmd.Parameters[RETURNVALUE].Value;
        }

 执行无参数SQL语句返回SqlDataReader

 public void RunSQL(string cmdText, out SqlDataReader dataReader)
        {
            ///创建Command
            SqlCommand cmd = CreateSQLCommand(cmdText, null);

            try
            {
                ///读取数据
                dataReader = cmd.ExecuteReader(CommandBehavior.CloseConnection);
            }
            catch (Exception ex)
            {
                dataReader = null;
                ///记录错误日志
                SystemError.CreateErrorLog(ex.Message);
            }
        }

执行传入参数SQL语句返回SqlDataReader

        public void RunSQL(string cmdText, SqlParameter[] prams, out SqlDataReader dataReader)
        {
            ///创建Command
            SqlCommand cmd = CreateSQLCommand(cmdText, prams);

            try
            {
                ///读取数据
                dataReader = cmd.ExecuteReader(CommandBehavior.CloseConnection);
            }
            catch (Exception ex)
            {
                dataReader = null;
                ///记录错误日志
                SystemError.CreateErrorLog(ex.Message);
            }
        }

 执行无参数SQL语句返回DataSet

 public void RunSQL(string cmdText, ref DataSet dataSet)
        {
            if (dataSet == null)
            {
                dataSet = new DataSet();
            }
            ///创建SqlDataAdapter
            SqlDataAdapter da = CreateSQLDataAdapter(cmdText, null);

            try
            {
                ///读取数据
                da.Fill(dataSet);
            }
            catch (Exception ex)
            {
                ///记录错误日志
                SystemError.CreateErrorLog(ex.Message);
            }
            finally
            {
                ///关闭数据库的连接
                Close();
            }
        }

执行传入参数SQL语句返回DataSet

 public void RunSQL(string cmdText, SqlParameter[] prams, ref DataSet dataSet)
        {
            if (dataSet == null)
            {
                dataSet = new DataSet();
            }
            ///创建SqlDataAdapter
            SqlDataAdapter da = CreateProcDataAdapter(cmdText, prams);

            try
            {
                ///读取数据
                da.Fill(dataSet);
            }
            catch (Exception ex)
            {
                ///记录错误日志
                SystemError.CreateErrorLog(ex.Message);
            }
            finally
            {
                ///关闭数据库的连接
                Close();
            }
        }

执行传入参数SQL语句和表名返回DataSet

 public void RunSQL(string cmdText, SqlParameter[] prams, string TableName, ref DataSet dataSet)
        {
            if (dataSet == null)
            {
                dataSet = new DataSet();
            }
            ///创建SqlDataAdapter
            SqlDataAdapter da = CreateProcDataAdapter(cmdText, prams);

            try
            {
                ///读取数据
                da.Fill(dataSet, TableName);
            }
            catch (Exception ex)
            {
                ///记录错误日志
                SystemError.CreateErrorLog(ex.Message);
            }
            finally
            {
                ///关闭数据库的连接
                Close();
            }
        }

创建一个SqlCommand对象以此来执行存储过程

 private SqlCommand CreateProcCommand(string procName, SqlParameter[] prams)
        {
            ///打开数据库连接
            Open();

            ///设置Command
            SqlCommand cmd = new SqlCommand(procName, myConnection);
            cmd.CommandType = CommandType.StoredProcedure;


            ///添加把存储过程的参数
            if (prams != null)
            {
                foreach (SqlParameter parameter in prams)
                {
                    cmd.Parameters.Add(parameter);
                }
            }

            ///添加返回参数ReturnValue
            cmd.Parameters.Add(
                new SqlParameter(RETURNVALUE, SqlDbType.Int, 4, ParameterDirection.ReturnValue,
                false, 0, 0, string.Empty, DataRowVersion.Default, null));

            ///返回创建的SqlCommand对象
            return cmd;
        }

创建一个SqlCommand对象以此来执行存储过程

 private SqlCommand CreateSQLCommand(string cmdText, SqlParameter[] prams)
        {
            ///打开数据库连接
            Open();

            ///设置Command
            SqlCommand cmd = new SqlCommand(cmdText, myConnection);

            ///添加把存储过程的参数
            if (prams != null)
            {
                foreach (SqlParameter parameter in prams)
                {
                    cmd.Parameters.Add(parameter);
                }
            }

            ///添加返回参数ReturnValue
            cmd.Parameters.Add(
                new SqlParameter(RETURNVALUE, SqlDbType.Int, 4, ParameterDirection.ReturnValue,
                false, 0, 0, string.Empty, DataRowVersion.Default, null));

            ///返回创建的SqlCommand对象
            return cmd;
        }

创建一个SqlDataAdapter对象，用此来执行存储过程

private SqlDataAdapter CreateProcDataAdapter(string procName, SqlParameter[] prams)
        {
            ///打开数据库连接
            Open();

            ///设置SqlDataAdapter对象
            SqlDataAdapter da = new SqlDataAdapter(procName, myConnection);
            da.SelectCommand.CommandType = CommandType.StoredProcedure;

            ///添加把存储过程的参数
            if (prams != null)
            {
                foreach (SqlParameter parameter in prams)
                {
                    da.SelectCommand.Parameters.Add(parameter);
                }
            }

            ///添加返回参数ReturnValue
            da.SelectCommand.Parameters.Add(
                new SqlParameter(RETURNVALUE, SqlDbType.Int, 4, ParameterDirection.ReturnValue,
                false, 0, 0, string.Empty, DataRowVersion.Default, null));

            ///返回创建的SqlDataAdapter对象
            return da;
        }

创建一个SqlDataAdapter对象，用此来执行SQL语句

private SqlDataAdapter CreateSQLDataAdapter(string cmdText, SqlParameter[] prams)
        {
            ///打开数据库连接
            Open();

            ///设置SqlDataAdapter对象
            SqlDataAdapter da = new SqlDataAdapter(cmdText, myConnection);

            ///添加把存储过程的参数
            if (prams != null)
            {
                foreach (SqlParameter parameter in prams)
                {
                    da.SelectCommand.Parameters.Add(parameter);
                }
            }

            ///添加返回参数ReturnValue
            da.SelectCommand.Parameters.Add(
                new SqlParameter(RETURNVALUE, SqlDbType.Int, 4, ParameterDirection.ReturnValue,
                false, 0, 0, string.Empty, DataRowVersion.Default, null));

            ///返回创建的SqlDataAdapter对象
            return da;
        }

生成存储过程参数

 public SqlParameter CreateParam(string ParamName, SqlDbType DbType, Int32 Size, ParameterDirection Direction, object Value)
        {
            SqlParameter param;

            ///当参数大小为0时，不使用该参数大小值
            if (Size > 0)
            {
                param = new SqlParameter(ParamName, DbType, Size);
            }
            else
            {
                ///当参数大小为0时，不使用该参数大小值
                param = new SqlParameter(ParamName, DbType);
            }

            ///创建输出类型的参数
            param.Direction = Direction;
            if (!(Direction == ParameterDirection.Output && Value == null))
            {
                param.Value = Value;
            }

            ///返回创建的参数
            return param;
        }

传入输入参数

        public SqlParameter CreateInParam(string ParamName, SqlDbType DbType, int Size, object Value)
        {
            return CreateParam(ParamName, DbType, Size, ParameterDirection.Input, Value);
        }

传入返回值参数

        public SqlParameter CreateOutParam(string ParamName, SqlDbType DbType, int Size)
        {
            return CreateParam(ParamName, DbType, Size, ParameterDirection.Output, null);
        }

传入返回值参数

        public SqlParameter CreateReturnParam(string ParamName, SqlDbType DbType, int Size)
        {
            return CreateParam(ParamName, DbType, Size, ParameterDirection.ReturnValue, null);
        }

把所有这些方法放在SQLHelper.cs类里.再建一个SQLTools.cs,里面的方法如下:

 public class SystemException : Exception
    {
        /// <summary>
        /// 包含系统Excepton
        /// </summary>
        public SystemException(string source, string message, Exception inner)
            : base(message, inner)
        {
            base.Source = source;
        }

        /// <summary>
        /// 不包含系统Excepton
        /// </summary>			
        public SystemException(string source, string message)
            : base(message)
        {
            base.Source = source;
        }
    }

    /// <summary>
    /// 处理网页中的HTML代码，并消除危险字符
    /// </summary>
    public class SystemHTML
    {
        private static string HTMLEncode(string fString)
        {
            if (fString != string.Empty)
            {
                ///替换尖括号
                fString.Replace("<", "<");
                fString.Replace(">", "&rt;");
                ///替换引号
                fString.Replace(((char)34).ToString(), """);
                fString.Replace(((char)39).ToString(), "'");
                ///替换空格
                fString.Replace(((char)13).ToString(), "");
                ///替换换行符
                fString.Replace(((char)10).ToString(), "<BR> ");
            }
            return (fString);
        }
    }


    /// <summary>
    /// SystemTools 的摘要说明。
    /// </summary>
    public class SystemTools
    {
        /// <summary>
        /// 将DataReader转为DataTable
        /// </summary>
        /// <param name="DataReader">DataReader</param>
        public static DataTable ConvertDataReaderToDataTable(SqlDataReader dataReader)
        {
            ///定义DataTable
            DataTable datatable = new DataTable();

            try
            {	///动态添加表的数据列
                for (int i = 0; i < dataReader.FieldCount; i++)
                {
                    DataColumn myDataColumn = new DataColumn();
                    myDataColumn.DataType = dataReader.GetFieldType(i);
                    myDataColumn.ColumnName = dataReader.GetName(i);
                    datatable.Columns.Add(myDataColumn);
                }

                ///添加表的数据
                while (dataReader.Read())
                {
                    DataRow myDataRow = datatable.NewRow();
                    for (int i = 0; i < dataReader.FieldCount; i++)
                    {
                        myDataRow[i] = dataReader[i].ToString();
                    }
                    datatable.Rows.Add(myDataRow);
                    myDataRow = null;
                }
                ///关闭数据读取器
                dataReader.Close();
                return datatable;
            }
            catch (Exception ex)
            {
                ///抛出类型转换错误
                SystemError.CreateErrorLog(ex.Message);
                throw new Exception(ex.Message, ex);
            }
        }
    }

主要是处理异常和一些特殊字符.

再建一个SystemError.cs,里面的方法如下:

    public class SystemError
    {
        private static string m_fileName = "c:\\Systemlog.txt";

        public static String FileName
        {
            get
            {
                return (m_fileName);
            }
            set
            {
                if (value != null || value != "")
                {
                    m_fileName = value;
                }
            }
        }
        public static void CreateErrorLog(string message)
        {
            if (File.Exists(m_fileName))
            {
                ///如果日志文件已经存在，则直接写入日志文件
                StreamWriter sr = File.AppendText(FileName);
                sr.WriteLine("\n");
                sr.WriteLine(DateTime.Now.ToString() + message);
                sr.Close();
            }
            else
            {
                ///创建日志文件
                StreamWriter sr = File.CreateText(FileName);
                sr.Close();
            }	
        }
    }

主要记录日志.

我们的SQLHelper类就建完了,接下来我们就开始建Model类了.欢迎拍砖.

weixin_33734785
关注
学习笔记（设计实现SqlHelper）
MonGo17的博客
03-23 792
一、思维导图 二、知识点 sqlhelper是一个类，在这个类当中可以声明定义许多方法，如获取SQL命名、查询标量、写入操作等，sqlhelper可以用于简化重复的去写那些数据库连接（DbConnection）,DbCommand,DbDataReader等等。SqlHelper 封装过后通常是只需要给方法传入一些参数如数据库连接字符串，SQL参数等，就可以访问数据库了，很方便。数据访问层...
ASP.NET三层架构DAL（数据访问层）——SqlHelper（公共类）创建
YHBoy11的博客
06-20 760
首先，我们先来介绍下公共类中常用的五大对象： Connection：连接对象 用于对数据库的连接操作，传入的参数为连接字符串。 Commamd：命令对象 用于执行对数据库的操作 ，传入的参数可以为连接字符串或存储过程，也必须传入连接对象的实例。 DataReader：数据读取对象 用于对数据的读取操作，实例.Read()方法可以返回一个True或者False来判断是否读取到了数据,我们可以直接使用 实例["字段名称"]来取出读取到的数据。 DataSet：数据集对象 该对象类似于在内存中的多张虚拟的
C#三层架构数据库连接类SQLHelper，包含标准SQL，参数化和存储过程
04-06
某个培训机构写的SQLHelper，现在分享出来，基于三层架构写的SQLHelper文件，包含标准SQL，参数化和存储过程
三层架构SqlHelper
YuYuLingYan的博客
07-16 287
三层架构DAL层SqlHelper 模板： windows->类库 引用： System.Configuration、System.Data、System.Data.SqlClient 分析： 增、删、改、查功能及对应的SQL语句 using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Configuration; using System.Data; usin
构建高效自定义SQLHelper数据库操作类
最新发布
weixin_31715353的博客
09-15 1320
本文还有配套的精品资源，点击获取 简介：本文深入探讨了一个自定义的SQLHelper类——"自己的SQLHelper"，它是一个封装了基础SQL查询和数据库交互的工具，旨在提升开发效率。这个工具在.NET开发环境中常见，基于***构建，具备连接管理、参数化查询、事务支持、数据转换、扩展性、错误处理和批量操作等特性。文章还提供了对SQLHelper代码结构的分析，以及如何利用...
SQLHelper设计
颖火虫的夜空
03-25 453
SQLHelper设计：访问数据库基类
三层架构 公共类 SqlHelper
qq_41255880的博客
12-25 440
ADO.NET五大对象 1.Connection 连接对象 用于对数据库的连接操作。传入的参数为连接字符串。 2.Commamd 命令对象 用于执行对数据库的操作 ，传入的参数可以为连接字符串或存储过程，也必须传入连接对象的实例。3.DataReader 数据读取对象 用于对数据的读取操作，实例.Read()方法可以返回一个True或者False来判断是否读取到了数据,我们可以直接使用 实...
ASp.net三层架构实战解析
"ASp.net 三层架构解析及项目构建步骤" 在软件开发中，三层架构是一种常见的设计模式，它将应用程序分为三个主要部分：表现层（UI）、业务逻辑层（BLL）和数据访问层（DAL）。这种架构有助于提高代码的可维护性、可...
ASP.NET三层架构添删改查实例_aspx开发教程.rar
09-09
ASP.NET三层架构是一种常见的软件设计模式，用于构建可维护性和扩展性良好的Web应用程序。这个"ASP.NET三层架构添删改查实例_aspx开发教程"旨在帮助开发者理解和掌握如何在ASP.NET环境中实现数据操作的基本功能，如...
基于ADO.NET的三层架构实现（修改SQL参数后可使用）
04-08
在IT领域，三层架构是一种常见的软件设计模式，它将应用程序分为三个主要部分：表现层（Presentation Layer）、业务逻辑层（Business Logic Layer）和数据访问层（Data Access Layer）。这种架构有助于提高代码的可...
三层架构之抽象父类SQLHelper
Bitou_Von的专栏
03-23 2147
刚用三层架构完成了一个‘酒店管理系统’，其实编程这么久以来，发现这样那样的程序，不过就是和数据库打交道，其核心就是数据库的增加、删除、修改、查询。因为如此，在三层架构中，Model是这个程序的纽带，是传输数据的载体，我们查询数据，返回的是一泛型集合。修改数据，修改的是对象的属性，删除数据也是通过对象的某一个属性来操作的。增加数据那就是往数据库中添加一个对象了。初次使用三层架构，发现有很多的代码都是
SqlHelper.NET
02-05
SqlHelper ExecuteNonQuery ExecuteScalar ExecuteDataTable
SQLHelper C# 开发 三层架构
05-17
SQLHelper 三层架构 C# 开发技术 详解 数据访问层
.net 实用的SQL Helper
05-14
.net 实用的SQL Helper,方便实际项目中使用
学习笔记（二）设计实现SqlHelper
Excellent_2333的博客
03-20 242
特性与实体设计 对于需求中的不要暴露DataTable或DataSet，设计中常用的对象：实体（Entity），通过实体将数据库中的字段封装成类，这样做不仅使代码更有可读性，维护起来也很方便。 递增键 namespace RA.DataAccess.Attributes { /// <summary> /// 递增键 /// </summary> [Attrib...
HIS-第四周学习笔记：设计实现SqlHelper
Aurora_南瓜酥
03-24 233
目录 一、思维导图​ 二、编写SqlHelper调用代码 三、成员 四、使用C#设计实现SqlHelper 一、思维导图 二、编写SqlHelper调用代码 SqlHelper支持多种数据库包括MySql、SqlServer、Oracle、Access数据库，如果数据库是SqlServer，那么你可以使用SqlServerHelper类，如果是MySql，可以使用MyS...
第四周学习笔记之设计实现SqlHelper
qq_42740799的博客
03-24 143
一、思维导图 二、知识点描述 SqlHelper是一个基于NET Framework的数据库操作组件。组件中包含数据库操作方法。SqlHelper用于简化重复的数据库连接（SqlConnection），SqlCommand，SqlDataReader等等。SqlHelper封装过后通常是只需要给方法传入一些参数如数据库连接字符串，SQL参数等，就可以访问数据库了。 三、示例代码 1 publ...
关于三层架构中SQLHelper类基础形式
染秋尘的博客
06-16 244
需要引用的命名空间 using System.Data; using System.Data.SqlClient; using System.Configuration; 链接字符串 private static string strConn = ConfigurationManager.ConnectionStrings["链接字符串名"].ConnectionString; 正文 /// <summary> /// 执行查询 .
.Net平台下的SqlHelper
weixin_30781775的博客
12-10 110
class SqlHelper { //通过ConfigurationManager可以读到App.config中的配置信息 private static string conStr = ConfigurationManager.ConnectionStrings["dbConStr"].ConnectionString; /...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值