asp.net 数据层类 存储过程访问方式

最新推荐文章于 2023-12-11 10:32:19 发布
最新推荐文章于 2023-12-11 10:32:19 发布
阅读量556 收藏
点赞数
分类专栏： asp.net日记 文章标签： 存储 asp.net parameters dataset exception string
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fangxianghua9801/article/details/2853634
版权

 using System;
 using System.Data;
 using System.Text;
 using System.Data.SqlClient;
namespace RBSolution.SQLServerDAL
{
 /// <summary>
 /// 数据访问类Ph_AdInfo 。
 /// </summary>
 public class Ph_AdInfo
 {
  public Ph_AdInfo()
  {}
  #region  成员方法
  /// <summary>
  /// 得到最大ID
  /// </summary>
  public int GetMaxId()
  {

   int rowsAffected;
   SqlParameter[] parameters = {};
   return DbHelperSQL.RunProcedure("UP_Ph_AdInfo_GetMaxId",parameters,out rowsAffected);
  }

  /// <summary>
  /// 是否存在该记录
  /// </summary>
  public bool Exists(int id)
  {
   int rowsAffected;
   SqlParameter[] parameters = {
     new SqlParameter("@id", SqlDbType.Int,4)
    };
   parameters[0].Value = id;
   int result= DbHelperSQL.RunProcedure("UP_Ph_AdInfo_Exists",parameters,out rowsAffected);
   if(result==1)
   {
    return true;
   }
   else
   {
    return false;
   }
   }

  /// <summary>
  ///  增加一条数据
  /// </summary>
  public int Add(RBSolution.Model.Ph_AdInfo model)
  {
   model.id=GetMaxId();
   int rowsAffected;
   SqlParameter[] parameters = {
     new SqlParameter("@id", SqlDbType.Int,4),
     new SqlParameter("@PalecType", SqlDbType.Int,4),
     new SqlParameter("@AdContent", SqlDbType.Text),
     new SqlParameter("@AdType", SqlDbType.Int,4),
     new SqlParameter("@Url", SqlDbType.VarChar,200),
     new SqlParameter("@Title", SqlDbType.VarChar,100),
     new SqlParameter("@CreateTime", SqlDbType.DateTime)};
   parameters[0].Value = model.id;
   parameters[1].Value = model.PalecType;
   parameters[2].Value = model.AdContent;
   parameters[3].Value = model.AdType;
   parameters[4].Value = model.Url;
   parameters[5].Value = model.Title;
   parameters[6].Value = model.CreateTime;

   DbHelperSQL.RunProcedure("UP_Ph_AdInfo_ADD",parameters,out rowsAffected);
   return model.id;
  }

  /// <summary>
  ///  更新一条数据
  /// </summary>
  public void Update(RBSolution.Model.Ph_AdInfo model)
  {
   int rowsAffected;
   SqlParameter[] parameters = {
     new SqlParameter("@id", SqlDbType.Int,4),
     new SqlParameter("@PalecType", SqlDbType.Int,4),
     new SqlParameter("@AdContent", SqlDbType.Text),
     new SqlParameter("@AdType", SqlDbType.Int,4),
     new SqlParameter("@Url", SqlDbType.VarChar,200),
     new SqlParameter("@Title", SqlDbType.VarChar,100),
     new SqlParameter("@CreateTime", SqlDbType.DateTime)};
   parameters[0].Value = model.id;
   parameters[1].Value = model.PalecType;
   parameters[2].Value = model.AdContent;
   parameters[3].Value = model.AdType;
   parameters[4].Value = model.Url;
   parameters[5].Value = model.Title;
   parameters[6].Value = model.CreateTime;

   DbHelperSQL.RunProcedure("UP_Ph_AdInfo_Update",parameters,out rowsAffected);
  }

  /// <summary>
  /// 删除一条数据
  /// </summary>
  public void Delete(int id)
  {

   int rowsAffected;
   SqlParameter[] parameters = {
     new SqlParameter("@id", SqlDbType.Int,4)
    };
   parameters[0].Value = id;
   DbHelperSQL.RunProcedure("UP_Ph_AdInfo_Delete",parameters,out rowsAffected);
  }

  /// <summary>
  /// 得到一个对象实体
  /// </summary>
  public RBSolution.Model.Ph_AdInfo GetModel(int id)
  {
   SqlParameter[] parameters = {
     new SqlParameter("@id", SqlDbType.Int,4)
    };
   parameters[0].Value = id;
   RBSolution.Model.Ph_AdInfo model=new RBSolution.Model.Ph_AdInfo();

   DataSet ds= DbHelperSQL.RunProcedure("UP_Ph_AdInfo_GetModel",parameters,"ds");
   model.id=id;
   if(ds.Tables[0].Rows.Count>0)
   {
    if(ds.Tables[0].Rows[0]["PalecType"].ToString()!="")
    {
     model.PalecType=int.Parse(ds.Tables[0].Rows[0]["PalecType"].ToString());
    }
    model.AdContent=ds.Tables[0].Rows[0]["AdContent"].ToString();
    if(ds.Tables[0].Rows[0]["AdType"].ToString()!="")
    {
     model.AdType=int.Parse(ds.Tables[0].Rows[0]["AdType"].ToString());
    }
    model.Url=ds.Tables[0].Rows[0]["Url"].ToString();
    model.Title=ds.Tables[0].Rows[0]["Title"].ToString();
    if(ds.Tables[0].Rows[0]["CreateTime"].ToString()!="")
    {

     model.CreateTime=DateTime.Parse(ds.Tables[0].Rows[0]["CreateTime"].ToString());
    }
    return model;
   }
   else
   {
    return null;
   }
  }

  /// <summary>
  /// 获取数据列表
  /// </summary>
  public DataSet GetList()
  {
   SqlParameter[] parameters = {};
   return DbHelperSQL.RunProcedure("UP_Ph_AdInfo_GetList",parameters,"ds");
  }

  /// <summary>
  /// 分页获取数据列表
  /// </summary>
  public DataSet GetList(int PageSize,int PageIndex,string strWhere)
  {
   SqlParameter[] parameters = {
     new SqlParameter("@tblName", SqlDbType.VarChar, 255),
     new SqlParameter("@fldName", SqlDbType.VarChar, 255),
     new SqlParameter("@PageSize", SqlDbType.Int),
     new SqlParameter("@PageIndex", SqlDbType.Int),
     new SqlParameter("@IsReCount", SqlDbType.Bit),
     new SqlParameter("@OrderType", SqlDbType.Bit),
     new SqlParameter("@strWhere", SqlDbType.VarChar,1000),
     };
   parameters[0].Value = "Ph_AdInfo";
   parameters[1].Value = "id";
   parameters[2].Value = PageSize;
   parameters[3].Value = PageIndex;
   parameters[4].Value = 0;
   parameters[5].Value = 0;
   parameters[6].Value = strWhere; 
   return DbHelperSQL.RunProcedure("UP_GetRecordByPage",parameters,"ds");
  }

  #endregion  成员方法
 }
}

//---------DbHelperSQL.cs--------------------------//

using System;
using System.Collections;
using System.Collections.Specialized;
using System.Data;
using System.Data.SqlClient;
using System.Configuration;

namespace RBSolution.SQLServerDAL //可以修改成实际项目的命名空间名称
{
 /// <summary>
 /// 数据访问基础类(基于SQLServer)
 /// 用户可以修改满足自己项目的需要。
 /// </summary>
 public abstract class DbHelperSQL
 {
  //数据库连接字符串(web.config来配置)
  //<add key="ConnectionString" value="server=127.0.0.1;database=DATABASE;uid=sa;pwd=" />  
  protected static string connectionString = ConfigurationSettings.AppSettings["ConnectionString"];
  public DbHelperSQL()
  {   
  }

  #region 公用方法

  public static int GetMaxID(string FieldName,string TableName)
  {
   string strsql = "select max(" + FieldName + ")+1 from " + TableName;
   object obj = GetSingle(strsql);
   if (obj == null)
   {
    return 1;
   }
   else
   {
    return int.Parse(obj.ToString());
   }
  }
  public static bool Exists(string strSql, params SqlParameter[] cmdParms)
  {
   object obj = GetSingle(strSql, cmdParms);
   int cmdresult;
   if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
   {
    cmdresult = 0;
   }
   else
   {
    cmdresult = int.Parse(obj.ToString());
   }
   if (cmdresult == 0)
   {
    return false;
   }
   else
   {
    return true;
   }
  }
  #endregion

  #region  执行简单SQL语句

  /// <summary>
  /// 执行SQL语句，返回影响的记录数
  /// </summary>
  /// <param name="SQLString">SQL语句</param>
  /// <returns>影响的记录数</returns>
  public static int ExecuteSql(string SQLString)
  {
   using (SqlConnection connection = new SqlConnection(connectionString))
   {    
    using (SqlCommand cmd = new SqlCommand(SQLString,connection))
    {
     try
     {  
      connection.Open();
      int rows=cmd.ExecuteNonQuery();
      return rows;
     }
     catch(System.Data.SqlClient.SqlException E)
     {     
      connection.Close();
      throw new Exception(E.Message);
     }
    }    
   }
  }
  
  /// <summary>
  /// 执行多条SQL语句，实现数据库事务。
  /// </summary>
  /// <param name="SQLStringList">多条SQL语句</param>  
  public static void ExecuteSqlTran(ArrayList SQLStringList)
  {
   using (SqlConnection conn = new SqlConnection(connectionString))
   {
    conn.Open();
    SqlCommand cmd = new SqlCommand();
    cmd.Connection=conn;    
    SqlTransaction tx=conn.BeginTransaction();   
    cmd.Transaction=tx;    
    try
    {     
     for(int n=0;n<SQLStringList.Count;n++)
     {
      string strsql=SQLStringList[n].ToString();
      if (strsql.Trim().Length>1)
      {
       cmd.CommandText=strsql;
       cmd.ExecuteNonQuery();
      }
     }          
     tx.Commit();     
    }
    catch(System.Data.SqlClient.SqlException E)
    {  
     tx.Rollback();
     throw new Exception(E.Message);
    }
   }
  }
  /// <summary>
  /// 执行带一个存储过程参数的的SQL语句。
  /// </summary>
  /// <param name="SQLString">SQL语句</param>
  /// <param name="content">参数内容,比如一个字段是格式复杂的文章，有特殊符号，可以通过这个方式添加</param>
  /// <returns>影响的记录数</returns>
  public static int ExecuteSql(string SQLString,string content)
  {    
   using (SqlConnection connection = new SqlConnection(connectionString))
   {
    SqlCommand cmd = new SqlCommand(SQLString,connection);  
    System.Data.SqlClient.SqlParameter  myParameter = new System.Data.SqlClient.SqlParameter ( "@content", SqlDbType.NText);
    myParameter.Value = content ;
    cmd.Parameters.Add(myParameter);
    try
    {
     connection.Open();
     int rows=cmd.ExecuteNonQuery();
     return rows;
    }
    catch(System.Data.SqlClient.SqlException E)
    {    
     throw new Exception(E.Message);
    }
    finally
    {
     cmd.Dispose();
     connection.Close();
    } 
   }
  }  
  /// <summary>
  /// 向数据库里插入图像格式的字段(和上面情况类似的另一种实例)
  /// </summary>
  /// <param name="strSQL">SQL语句</param>
  /// <param name="fs">图像字节,数据库的字段类型为image的情况</param>
  /// <returns>影响的记录数</returns>
  public static int ExecuteSqlInsertImg(string strSQL,byte[] fs)
  {  
   using (SqlConnection connection = new SqlConnection(connectionString))
   {
    SqlCommand cmd = new SqlCommand(strSQL,connection); 
    System.Data.SqlClient.SqlParameter  myParameter = new System.Data.SqlClient.SqlParameter ( "@fs", SqlDbType.Image);
    myParameter.Value = fs ;
    cmd.Parameters.Add(myParameter);
    try
    {
     connection.Open();
     int rows=cmd.ExecuteNonQuery();
     return rows;
    }
    catch(System.Data.SqlClient.SqlException E)
    {    
     throw new Exception(E.Message);
    }
    finally
    {
     cmd.Dispose();
     connection.Close();
    }    
   }
  }
  
  /// <summary>
  /// 执行一条计算查询结果语句，返回查询结果（object）。
  /// </summary>
  /// <param name="SQLString">计算查询结果语句</param>
  /// <returns>查询结果（object）</returns>
  public static object GetSingle(string SQLString)
  {
   using (SqlConnection connection = new SqlConnection(connectionString))
   {
    using(SqlCommand cmd = new SqlCommand(SQLString,connection))
    {
     try
     {
      connection.Open();
      object obj = cmd.ExecuteScalar();
      if((Object.Equals(obj,null))||(Object.Equals(obj,System.DBNull.Value)))
      {     
       return null;
      }
      else
      {
       return obj;
      }    
     }
     catch(System.Data.SqlClient.SqlException e)
     {      
      connection.Close();
      throw new Exception(e.Message);
     } 
    }
   }
  }
  /// <summary>
  /// 执行查询语句，返回SqlDataReader
  /// </summary>
  /// <param name="strSQL">查询语句</param>
  /// <returns>SqlDataReader</returns>
  public static SqlDataReader ExecuteReader(string strSQL)
  {
   SqlConnection connection = new SqlConnection(connectionString);   
   SqlCommand cmd = new SqlCommand(strSQL,connection);    
   try
   {
    connection.Open(); 
    SqlDataReader myReader = cmd.ExecuteReader();
    return myReader;
   }
   catch(System.Data.SqlClient.SqlException e)
   {        
    throw new Exception(e.Message);
   }   
   
  }  
  /// <summary>
  /// 执行查询语句，返回DataSet
  /// </summary>
  /// <param name="SQLString">查询语句</param>
  /// <returns>DataSet</returns>
  public static DataSet Query(string SQLString)
  {
   using (SqlConnection connection = new SqlConnection(connectionString))
   {
    DataSet ds = new DataSet();
    try
    {
     connection.Open();
     SqlDataAdapter command = new SqlDataAdapter(SQLString,connection);    
     command.Fill(ds,"ds");
    }
    catch(System.Data.SqlClient.SqlException ex)
    {    
     throw new Exception(ex.Message);
    }   
    return ds;
   }   
  }


  #endregion

  #region 执行带参数的SQL语句

  /// <summary>
  /// 执行SQL语句，返回影响的记录数
  /// </summary>
  /// <param name="SQLString">SQL语句</param>
  /// <returns>影响的记录数</returns>
  public static int ExecuteSql(string SQLString,params SqlParameter[] cmdParms)
  {
   using (SqlConnection connection = new SqlConnection(connectionString))
   {    
    using (SqlCommand cmd = new SqlCommand())
    {
     try
     {  
      PrepareCommand(cmd, connection, null,SQLString, cmdParms);
      int rows=cmd.ExecuteNonQuery();
      cmd.Parameters.Clear();
      return rows;
     }
     catch(System.Data.SqlClient.SqlException E)
     {    
      throw new Exception(E.Message);
     }
    }    
   }
  }
  
   
  /// <summary>
  /// 执行多条SQL语句，实现数据库事务。
  /// </summary>
  /// <param name="SQLStringList">SQL语句的哈希表（key为sql语句，value是该语句的SqlParameter[]）</param>
  public static void ExecuteSqlTran(Hashtable SQLStringList)
  {   
   using (SqlConnection conn = new SqlConnection(connectionString))
   {
    conn.Open();
    using (SqlTransaction trans = conn.BeginTransaction())
    {
     SqlCommand cmd = new SqlCommand();
     try
     {
      //循环
      foreach (DictionaryEntry myDE in SQLStringList)
      { 
       string  cmdText=myDE.Key.ToString();
       SqlParameter[] cmdParms=(SqlParameter[])myDE.Value;
       PrepareCommand(cmd,conn,trans,cmdText, cmdParms);
       int val = cmd.ExecuteNonQuery();
       cmd.Parameters.Clear();

       trans.Commit();
      }     
     }
     catch
     {
      trans.Rollback();
      throw;
     }
    }    
   }
  }
 
    
  /// <summary>
  /// 执行一条计算查询结果语句，返回查询结果（object）。
  /// </summary>
  /// <param name="SQLString">计算查询结果语句</param>
  /// <returns>查询结果（object）</returns>
  public static object GetSingle(string SQLString,params SqlParameter[] cmdParms)
  {
   using (SqlConnection connection = new SqlConnection(connectionString))
   {
    using (SqlCommand cmd = new SqlCommand())
    {
     try
     {
      PrepareCommand(cmd, connection, null,SQLString, cmdParms);
      object obj = cmd.ExecuteScalar();
      cmd.Parameters.Clear();
      if((Object.Equals(obj,null))||(Object.Equals(obj,System.DBNull.Value)))
      {     
       return null;
      }
      else
      {
       return obj;
      }    
     }
     catch(System.Data.SqlClient.SqlException e)
     {    
      throw new Exception(e.Message);
     }     
    }
   }
  }
  
  /// <summary>
  /// 执行查询语句，返回SqlDataReader
  /// </summary>
  /// <param name="strSQL">查询语句</param>
  /// <returns>SqlDataReader</returns>
  public static SqlDataReader ExecuteReader(string SQLString,params SqlParameter[] cmdParms)
  {  
   SqlConnection connection = new SqlConnection(connectionString);
   SqlCommand cmd = new SqlCommand();    
   try
   {
    PrepareCommand(cmd, connection, null,SQLString, cmdParms);
    SqlDataReader myReader = cmd.ExecuteReader();
    cmd.Parameters.Clear();
    return myReader;
   }
   catch(System.Data.SqlClient.SqlException e)
   {        
    throw new Exception(e.Message);
   }     
   
  }  
  
  /// <summary>
  /// 执行查询语句，返回DataSet
  /// </summary>
  /// <param name="SQLString">查询语句</param>
  /// <returns>DataSet</returns>
  public static DataSet Query(string SQLString,params SqlParameter[] cmdParms)
  {
   using (SqlConnection connection = new SqlConnection(connectionString))
   {
    SqlCommand cmd = new SqlCommand();
    PrepareCommand(cmd, connection, null,SQLString, cmdParms);
    using( SqlDataAdapter da = new SqlDataAdapter(cmd) )
    {
     DataSet ds = new DataSet(); 
     try
     {            
      da.Fill(ds,"ds");
      cmd.Parameters.Clear();
     }
     catch(System.Data.SqlClient.SqlException ex)
     {    
      throw new Exception(ex.Message);
     }   
     return ds;
    }    
   }   
  }


  private static void PrepareCommand(SqlCommand cmd,SqlConnection conn,SqlTransaction trans, string cmdText, SqlParameter[] cmdParms)
  {
   if (conn.State != ConnectionState.Open)
    conn.Open();
   cmd.Connection = conn;
   cmd.CommandText = cmdText;
   if (trans != null)
    cmd.Transaction = trans;
   cmd.CommandType = CommandType.Text;//cmdType;
   if (cmdParms != null)
   {
    foreach (SqlParameter parm in cmdParms)
     cmd.Parameters.Add(parm);
   }
  }

  #endregion

  #region 存储过程操作

  /// <summary>
  /// 执行存储过程
  /// </summary>
  /// <param name="storedProcName">存储过程名</param>
  /// <param name="parameters">存储过程参数</param>
  /// <returns>SqlDataReader</returns>
  public static SqlDataReader RunProcedure(string storedProcName, IDataParameter[] parameters )
  {
   SqlConnection connection = new SqlConnection(connectionString);
   SqlDataReader returnReader;
   connection.Open();
   SqlCommand command = BuildQueryCommand( connection,storedProcName, parameters );
   command.CommandType = CommandType.StoredProcedure;
   returnReader = command.ExecuteReader();    
   return returnReader;   
  }
  
  
  /// <summary>
  /// 执行存储过程
  /// </summary>
  /// <param name="storedProcName">存储过程名</param>
  /// <param name="parameters">存储过程参数</param>
  /// <param name="tableName">DataSet结果中的表名</param>
  /// <returns>DataSet</returns>
  public static DataSet RunProcedure(string storedProcName, IDataParameter[] parameters, string tableName )
  {
   using (SqlConnection connection = new SqlConnection(connectionString))
   {
    DataSet dataSet = new DataSet();
    connection.Open();
    SqlDataAdapter sqlDA = new SqlDataAdapter();
    sqlDA.SelectCommand = BuildQueryCommand(connection, storedProcName, parameters );
    sqlDA.Fill( dataSet, tableName );
    connection.Close();
    return dataSet;
   }
  }

  
  /// <summary>
  /// 构建 SqlCommand 对象(用来返回一个结果集，而不是一个整数值)
  /// </summary>
  /// <param name="connection">数据库连接</param>
  /// <param name="storedProcName">存储过程名</param>
  /// <param name="parameters">存储过程参数</param>
  /// <returns>SqlCommand</returns>
  private static SqlCommand BuildQueryCommand(SqlConnection connection,string storedProcName, IDataParameter[] parameters)
  {   
   SqlCommand command = new SqlCommand( storedProcName, connection );
   command.CommandType = CommandType.StoredProcedure;
   foreach (SqlParameter parameter in parameters)
   {
    command.Parameters.Add( parameter );
   }
   return command;   
  }
  
  /// <summary>
  /// 执行存储过程，返回影响的行数  
  /// </summary>
  /// <param name="storedProcName">存储过程名</param>
  /// <param name="parameters">存储过程参数</param>
  /// <param name="rowsAffected">影响的行数</param>
  /// <returns></returns>
  public static int RunProcedure(string storedProcName, IDataParameter[] parameters, out int rowsAffected )
  {
   using (SqlConnection connection = new SqlConnection(connectionString))
   {
    int result;
    connection.Open();
    SqlCommand command = BuildIntCommand(connection,storedProcName, parameters );
    rowsAffected = command.ExecuteNonQuery();
    result = (int)command.Parameters["ReturnValue"].Value;
    //Connection.Close();
    return result;
   }
  }
  
  /// <summary>
  /// 创建 SqlCommand 对象实例(用来返回一个整数值) 
  /// </summary>
  /// <param name="storedProcName">存储过程名</param>
  /// <param name="parameters">存储过程参数</param>
  /// <returns>SqlCommand 对象实例</returns>
  private static SqlCommand BuildIntCommand(SqlConnection connection,string storedProcName, IDataParameter[] parameters)
  {
   SqlCommand command = BuildQueryCommand(connection,storedProcName, parameters );
   command.Parameters.Add( new SqlParameter ( "ReturnValue",
    SqlDbType.Int,4,ParameterDirection.ReturnValue,
    false,0,0,string.Empty,DataRowVersion.Default,null ));
   return command;
  }
  #endregion 

 }
}

fangxianghua9801
关注
专栏目录
JDBC：java数据库连接对象
Problem_Girl的博客
03-19 5090
一、JDBC：即Java DataBase Connectivity的缩写。全称为Java数据库连接对象，是java程序和数据库的连接桥梁。 作用：可以为多种关系型数据库DBMS提供统一的访问方式，用Java来操作数据库。 1. JDBC API主要功能：主要干三件事，具体通过以下类/接口实现： DriverManager：管理jdbc驱动 Connection：连接 Sta...
asp.net 数据访问层 存储过程分页语句
01-20
以下是一个基于ASP.NET数据访问层，使用存储过程进行分页的示例： 首先，创建一个名为`getdata`的存储过程，该过程接受三个参数：`@pageindex`表示当前页的索引，`@dataperpage`表示每页显示的记录数，`@...
创建数据库连接对象
weixin_30760895的博客
07-12 364
using System;using System.Collections;using System.Collections.Specialized;using System.Data;using System.Data.SqlClient;using System.Configuration;using System.Text.RegularExpressions; /// <summ...
【数据库学习笔记】——创建数据库连接对象connection
python_AI_fans的博客
11-02 2290
目录 connect函数的参数 创建连接对象连接MySQL代码 连接对象常见属性与方法 事务名词解释 课程视频链接： 第14节 Python操作数据库_哔哩哔哩_bilibili666https://www.bilibili.com/video/BV1q54y147KX?from=search&seid=968950907021994347&spm_id_from=333.337.0.0 模块：pymysql 函数：connect（） connect函数的参数 ...
数据库连接对象
baoluoaoxiang的专栏
03-31 685
Connection 物件   Connection 对象主要是开启程序和数据库之间的连结。没有利用连结对象将数据库打开，是无法从数据库中取得数据的。这个物件在ADO.NET 的最底层，我们可以自己产生这个对象，或是由其它的对象自动产生。Command 物件   Command 对象主要可以用来对数据库发出一些指令，例如可以对数据库下达查询、新增、修改、删除数据等指令，以及呼叫存在数据库中
003、Connection：数据库连接对象
l0510402015的博客
03-07 565
一、简介 Connection：数据库连接对象，具体的实现类由数据库的厂商实现，代表一个连接对象。 Connection对象的方法createStatement()会返回一个Statement 对象，Statement 对象用于存放准备执行的SQL语句 二.功能详介绍： 1.获取执行sql 的对象 * Statement createStatemen...
ASP.NET通过视图、存储过程访问数据表（非三层架构，含样例数据库、增删改查）
03-02
该例是asp.net教学中常见案例，主要通过视图、存储过程的方式访问数据库（非三层架构），操作包含逻辑完成的增删改查，主要供初学者学习使用。 特别提醒：代码环境MS.net2012，数据库环境SQL Server2012。Webconfig...
asp.net三层架构实现注册登录,三层架构练习-C#文档类资源
02-27
3. **数据访问层（Data Access Layer, DAL）**：DAL是应用程序与数据库交互的接口，它封装了所有与数据库相关的操作，如SQL查询、存储过程调用等。在ASP.NET中，可以使用ADO.NET、Entity Framework或其他ORM框架来...
asp.net Oracle数据库访问操作类
01-01
代码如下:using System;using System.Collections;using System.Collections.Specialized;using System.Data;using System.Data.Oracle... ///  /// 数据访问抽象基础类 /// /// </summary>public class DBBase{
数据库--获取数据库的连接对象
weixin_45063957的博客
05-21 720
//方式1 @Test public void testConnection1() throws SQLException { /* 导入驱动，需要新建一个驱动文件夹Direction，名为lib，然后驱动复制进这个文件夹 之后通过右键add as library 才能正常使用 */ Driver driver = new com.mysql.jdbc.Driver(); /* .
.NET数据库连接中的对象
littlecolor
05-16 2590
在学习VB.NET视频时，其中有几个单元讲到了.NET的数据库设计与连接。对于数据库的连接，其实我们并不陌生，原来在做红皮书和机房收费系统的时候，我们都有接触过，可是，在我的印象中，这些关于数据库连接的知识很是模糊。对于数据库连接对象更是一知半解。  回过头来，翻了一遍红皮书中的几个实例，里面讲到了利用ADO控件来连接数据库,它涉及到的数据库连接对象有7个（connection,com
数据连接对象简介
GEEK-BANANA
08-29 3380
Connection Connection对象，也成为连接对象，他的功能就是负责对数据源的连接，Connection的基类都是DbConnection类 Connection的两个重要的属性： ConnectionString：表示用于打开SQL Server的数据库的字符串 State：表示Connection的状态，有Close和Open两种状态   Command Co...
数据库标准项目创建连接数据库的对象的写法
holoblog
03-31 151
所需文档 db.config.properties 内容如下： driver=oracle.jdbc.driver.OracleDriverurl=jdbc:oracle:thin:@loaclhost:1521:XEuser=systempassword=admin Java代码数据库创建连接工厂类写法： ConnectionFactor...
【JDBC】Connection数据库连接对象
Need not to know
11-30 655
Connection数据库连接对象   功能：   1.获取执行sql的对象 Statement st = con.createStatement(String sql); PreparedStatement pst = con.prepareStatement(String sql);   2.管理事务 con.setAutoCommit(false); / 开启事务（设置参数为false） con.commit(); / 提交事务 c
PDO对象数据库连接
u011234448的博客
08-26 291
<?php header('Content-type:text/html;charset=utf-8'); $dbms = 'mysql'; $host = '127.0.0.1'; $dbname = 'php9'; $charset = 'utf8'; $dsn = "$dbms:host=$host;dbname=$dbname;charset=$charset"; $user_...
进行数据库的连接-ADO.NET四大内置对象
最新发布
12-11 130
当Command对象如果查询的结果将是一个或多个集合(一张表或多张表)，有很多未知因素(查询的结果的表的数量，每张表中的数据量)，因此使用的接收容器(DataSet)的容量(存储的表的数量，每张表的行和列)都无法确定，所以要将查询结果集能够准确无漏的使用容器接收，则需要根据查询结果集进行适配。Read()：在DataReader对象是Command对象返回的DataReader时，则证明可以对Command执行命令的结果集进行阅读，进行阅读就需要依靠Read方法进行逐行阅读(这个方法执行一次阅读一行)。
C#的一些基本操作
大牛笔记
09-25 847
在C#中我们经常会操作，数组、list集合、文本文档、File文件、Directory目录、Stream流、Json解析等。而有些语法又经常会被忘掉。         下面列出了我们常用的一些类和一些语法等。   数组：     List集合：     文本文档：     File文件：     Directory目录：     Stream流：   Jso
数据库驱动连接流程和对象实例化方式
低调的嚣张
03-18 678
ASP.NET 数据访问基础类详解
ASP.NET 数据访问类是一个...总结来说，ASP.NET 数据访问类是一个强大的工具，它简化了在ASP.NET项目中进行数据操作的过程，允许开发人员以一种标准化的方式执行SQL查询，同时确保了数据库连接的正确管理和资源的释放。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值