c#.net 是如何访问 SQL Server 数据库

jdxyzlh

　　c#.net 是如何访问 SQL Server 数据库
　　1、导入命名空间
　　using System.Data.SqlClient; //连接SQLServer 数据库专用
　　2、创建连接
　　SqlConnection lo_conn = New SqlConnection("Server=服务器名字或IP;Database=数据库名字;uid=用户名;pwd=密码");
　　3、打开连接，第2步并没有真正连接数据库
　　lo_conn.Open(); //真正与数据库连接
　　4、向数据库发送SQL命令要使用SqlCommand:
　　SqlCommand lo_cmd = new SqlCommand(); //创建命令对象
　　lo_cmd.CommandText = "这里是SQL语句"; //写SQL语句
　　lo_cmd.Connection = lo_con; //指定连接对象，即上面创建的
　　5、处理SQL命令或返回结果集
　　lo_cmd.ExecuteNonQuery(); //这个仅仅执行SQL命令，不返回结果集，实用于建表、批量更新等不需要返回结果的操作。
　　SqlDataReader lo_reader = lo_cmd.ExecuteReader();//返回结果集
　　6、以数据集的方式反回结果集
　　SqlDataAdapter dbAdapter = new SqlDataAdapter(lo_cmd); //注意与上面的区分开
　　DataSet ds = new DataSet(); //创建数据集对象
　　dbAdapter.Fill(ds); //用返回的结果集填充数据集，这个数据集可以被能操作数据的控件DataBind
　　7、关闭连接
　　lo_conn.Close();
　　C#.NET操作数据库通用类（MS SQL Server篇）
　　下面给出了一个C#操作MS SQL Server 数据库的通用类，通过该类可以对数据库进行任何操作，包括执行SQL语句、执行存储过程。以下是其详细实现过程，希望大家共同修改优化之。稍后将介绍如何使用它实现N层的程序设计。
　　配置web.config文件的链接参数
　　
　　
　　
　　
　　C#代码
　　using System;
　　using System.Data;
　　using System.Data.SqlClient;
　　namespace Com.LXJ.Database
　　{
　　///
　　/// ConnDB 的摘要说明。
　　///

　　public>　　{
　　protected SqlConnection Connection;
　　private string connectionString;
　　///
　　/// 默认构造函数
　　///
　　public ConnDB()
　　{
　　string connStr;
　　connStr = System.Configuration.ConfigurationSettings.AppSettings["connStr"].ToString();
　　connectionString = connStr;
　　Connection = new SqlConnection(connectionString);
　　}
　　///
　　/// 带参数的构造函数
　　///
　　/// 数据库联接字符串
　　public ConnDB(string newConnectionString)
　　{
　　connectionString = newConnectionString;
　　Connection = new SqlConnection(connectionString);
　　}
　　///
　　/// 完成SqlCommand对象的实例化
　　///
　　///
　　///
　　///
　　private SqlCommand BuildCommand(string storedProcName,IDataParameter[] parameters)
　　{
　　SqlCommand command = BuildQueryCommand(storedProcName,parameters);
　　command.Parameters.Add(new SqlParameter("ReturnValue",SqlDbType.Int,4,ParameterDirection.ReturnValue,false,0,0,string.Empty,DataRowVersion.Default,null));
　　return command;
　　}
　　///
　　/// 创建新的SQL命令对象(存储过程)
　　///
　　///
　　///
　　///
　　private SqlCommand BuildQueryCommand(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;
　　}
　　///
　　/// 执行存储过程,无返回值
　　///
　　///
　　///
　　public void ExecuteProcedure(string storedProcName,IDataParameter[] parameters)
　　{
　　Connection.Open();
　　SqlCommand command;
　　command=BuildQueryCommand(storedProcName,parameters);
　　command.ExecuteNonQuery();
　　Connection.Close();
　　}
　　///
　　/// 执行存储过程，返回执行操作影响的行数目
　　///
　　///
　　///
　　///
　　///
　　public int RunProcedure(string storedProcName,IDataParameter[] parameters,out int rowsAffected)
　　{
　　int result;
　　Connection.Open();
　　SqlCommand command = BuildCommand(storedProcName,parameters);
　　rowsAffected = command.ExecuteNonQuery();
　　result = (int)command.Parameters["ReturnValue"].Value;
　　Connection.Close();
　　C# 连接SQL数据库、常用的连接字符串讲解、常用的数据库操作方法
　　2009-06-15 12:45:47
　　标签：数据库 休闲 职场
　　using System;
　　using System.Collections.Generic;
　　using System.Text;
　　using System.Data.SqlClient;
　　using System.Data;
　　namespace My_Connection
　　{

　　>　　{
　　private const string ConnString = "server=localhost;integrated security=sspi;database=pubs;";
　　//---------------------常用的连接字符串参数-------------------------------------------------
　　//server=locahost或 . 登录服务器地址这里是本地
　　//Data Source
　　//Address
　　//Addr
　　//Network Address
　　//integrated security=sspi或true 以Windows当前身份登录
　　//uid=sa; 登录用户名:sa
　　//pwd=sa;    登录密码:sa
　　//Connect Timeout=15 //设置连接等待时间,以秒为单位
　　//Trusted_Connection=True 设置信任连接
　　//Asynchronous Processing=true 设置异步访问数据库,默认关闭
　　//MultipleActiveResultSets=True 在单个连接上得到和管理多个、仅向前引用和只读的结果集(ADO.NET2.0,SQL 2005)
　　//database=pubs 或 Initial Catalog=pubs 指定数据库:pubs

　　//Max Pool>
　　//Min Pool>　　//Pooling 当设置为true时,SQL连接将从连接池获得,如果没有则新建并添加到连接池中,默认是true.false则不设连接池
　　//Connection Lifetime 在连接池中应用,指定一个连接处于close后的生存时间大于指定时间并属于最小连接数以外的将自动消毁
　　//Application Name 应用程序名称或者当没有提供应用程序时为.Net SqlClient数据提供者
　　//Connection Reset true 当连接从连接池移走时决定是否重置数据库连接.当设置为 false 时用于避免获得连接时的额外服务器往复代价
　　//Enlist true 为真时，连接池自动列出创建线程的当前事务上下文中的连接

　　//Workstation>
　　//Packet>　　//Network Library 设置网络连接协议
　　//当通过SQLOLEDB提供者进行连接时使用以下语法：
　　//Network Library=dbmssocn
　　//但通过MSDASQL提供者进行连接时使用以下语法：
　　//Network=dbmssocn
　　//名称            网络协议库
　　//dbnmpntw Win32 Named Pipes
　　//dbmssocn Win32 Winsock TCP/IP
　　//dbmsspxn Win32 SPX/IPX
　　//dbmsvinn Win32 Banyan Vines
　　//dbmsrpcn Win32 Multi-Protocol (Windows RPC)
　　//------------------------连接字符串示例   -----------------------------------------------------------------------------
　　//通过IP地址连接,必需确保SQL服务器开启1433端口和检查SQL网络连接启用TCP/IP协议

　　//Data Source=190.190.200.100,1433;Network Library=DBMSSOCN;Initial Catalog=myDataBase;User>　　//默认情况下， SQL服务器的微软.NET框架数据提供者设置网络包大小对8192个字节.
　　//然而这不一定是最好的,你可以根据你觉的合适的包大小设置包的大小

　　//Server=myServerAddress;Database=myDataBase;User>　　//-----------------------------------------------------------------------------------------------
　　//因为考虑到实现复杂业务逻辑时,需要同进使用GetDataReader、GetDataAdapter、GetTransaction等
　　//连接那里会变得麻烦，所以区分定义三种方式的连接对象
　　private SqlConnection SqlDrConn = new SqlConnection(ConnString);
　　private SqlConnection SqlDaConn = new SqlConnection(ConnString);
　　private SqlConnection SqlTrConn = new SqlConnection(ConnString);
　　public DataTable GetDataReader(string StrSql)//数据查询
　　{
　　//当连接处于打开状态时关闭,然后再打开,避免有时候数据不能及时更新
　　if (SqlDrConn.State == ConnectionState.Open)
　　{
　　SqlDrConn.Close();
　　}
　　try
　　{
　　SqlDrConn.Open();
　　SqlCommand SqlCmd = new SqlCommand(StrSql, SqlDrConn);
　　SqlDataReader SqlDr = SqlCmd.ExecuteReader();
　　if (SqlDr.HasRows)
　　{
　　DataTable dt = new DataTable();
　　//---------------Method 1-------------------
　　//for (int i = 0; i < SqlDr.FieldCount; i++)
　　//{
　　//     dt.Columns.Add(SqlDr.GetName(i), SqlDr.GetFieldType(i));
　　//}
　　//while (SqlDr.Read())
　　//{
　　//     DataRow dr= dt.NewRow();
　　//     for (int i = 0; i < SqlDr.FieldCount; i++)
　　//     {
　　//         dr = SqlDr;
　　//     }
　　//     dt.Rows.Add(dr);
　　//}
　　//---------------Method 2-------------------
　　//更为简单
　　dt.Load(SqlDr);
　　//关闭对象和连接
　　SqlDr.Close();
　　SqlDrConn.Close();
　　return dt;
　　}
　　return null;
　　}
　　catch (Exception ex)
　　{
　　System.Windows.Forms.MessageBox.Show(ex.Message);
　　return null;
　　}
　　finally
　　{
　　SqlDrConn.Close();
　　}
　　}
　　public SqlDataAdapter GetDataAdapter(string StrSql)//数据增删修查
　　{
　　if (SqlDaConn.State == ConnectionState.Open)
　　{
　　SqlDaConn.Close();
　　}
　　try
　　{
　　SqlDaConn.Open();
　　SqlDataAdapter SqlDa = new SqlDataAdapter(StrSql, SqlDaConn);
　　//提供自动生成单表命令的一种方式
　　SqlCommandBuilder SqlCb = new SqlCommandBuilder(SqlDa);
　　return SqlDa;
　　}
　　catch (Exception ex)
　　{
　　System.Windows.Forms.MessageBox.Show(ex.Message);
　　return null;
　　}
　　finally
　　{
　　SqlDaConn.Close();
　　}
　　}
　　//这里使用了ArrayList数组来存放SQL语句集
　　public bool GetTransaction(System.Collections.ArrayList StrSqlList)//实现事务
　　{
　　if (SqlTrConn.State == ConnectionState.Open)
　　{
　　SqlTrConn.Close();
　　}
　　SqlTransaction SqlTr = null;
　　try
　　{
　　SqlTrConn.Open();
　　SqlTr = SqlTrConn.BeginTransaction();
　　SqlCommand SqlCmd = new SqlCommand();
　　SqlCmd.Connection = SqlTrConn;
　　SqlCmd.Transaction = SqlTr;
　　//加载数组里的SQL语句
　　for (int i = 0; i < StrSqlList.Count; i++)
　　{
　　SqlCmd.CommandText = StrSqlList.ToString();
　　SqlCmd.ExecuteNonQuery();
　　}
　　//提交所有事务
　　SqlTr.Commit();
　　return true;
　　}
　　catch (Exception ex)
　　{
　　//一但出错,回滚所有事务,还原状态
　　if(SqlTr!=null) SqlTr.Rollback();
　　System.Windows.Forms.MessageBox.Show(ex.Message);
　　return false;
　　}
　　finally
　　{
　　SqlTrConn.Close();
　　}
　　}
　　}
　　}
　　C#.NET常用数据库操作(连接、增、删、改)封装
　　如果你经常从事基于.NET的应用程序的数据库开发，你会有这种感觉--总是觉得自己在反复编写相同的数据访问代码。很多相似的代码每天在复制来，粘贴去。你是否想过将数据访问代码包装在一个Helper函数里，以便能够在不同的类中共用？如果你还没有这样做，那么我这里就告诉你如何从复用的角度来设计和包装一个我们自己的数据访问类，从而减少冗余代码，提高开发效率。（本节代码位置：光盘\code\ch05\02）
　　当我们执行增加、更新、删除命令的时候，一般会这样来写：
　　1.  string conString = "data source=127.0.0.1;database=codematic;user
　　id=sa;
　　2.  password=";
　　3.  SqlConnection myConnection = new SqlConnection(conString );

　　4.  string strSql = "update P_Product set Name='电脑3' where>　　5.  SqlCommand myCommand = new SqlCommand(strSql, myConnection);
　　6.  myConnection.Open();
　　7.  int rows = myCommand.ExecuteNonQuery();
　　8.  myConnection.Close();
　　如果是很多个这样的操作，那么我们就需要写很多基本相似的代码。根据面对对象的抽象原则，在这些操作里面有很多共性的东西，唯一的不同就是conString和strSql。那我是不是可以将共性的东西抽象出来将其封装为所有操作所共用呢？
　　我们把共性的东西抽象出一个独立方法：
　　1.  //
　　2.  //执行SQL语句，返回影响的记录数
　　3.  //
　　4.  public int ExecuteSql(string StrSql, string conString)
　　5.  {
　　6.      using (SqlConnection connection = new SqlConnection(conString))
　　7.      {
　　8.          using (SqlCommand cmd = new SqlCommand(StrSql, connection))
　　9.          {
　　10.             connection.Open();
　　11.             int rows = cmd.ExecuteNonQuery();
　　12.             return rows;
　　13.        }
　　14.    }
　　15.}
　　这样，实际调用的代码就可以变成：
　　1.  string conString="data source=127.0.0.1;database=codematic;user
　　id=sa;
　　2.  password=";

　　3.  string strSql = "update P_Product set Name='电脑3' where>　　4.  int rows =ExecuteSql(strSql, conString);
　　是不是简单了很多？可以让其他类共用这个方法，重复代码少了，工作效率提高了。
　　如果所连数据库都是固定不变的，也就是说连接字符串一般不变，那么我们可以将conString 提取出来放到一个变量里面，所有的方法都用这个变量。想改变数据库时，直接修改变量的内容即可，在实际调用的时候不需要传连接字符串，是不是又省了一步？为了更好地复用，我们还可以将该方法放到单独的类DbHelperSQL里面去。
　　DbHelperSQL类中：

　　1.  public>　　2.  {
　　3.      public static string conString = "data source=127.0.0.1;

　　4.          database=codematic;user>　　5.      //
　　6.      //执行SQL语句，返回影响的记录数
　　7.      //
　　8.      //SQL语句
　　9.      //影响的记录数
　　10.    public static int ExecuteSql(string StrSql)
　　11.    {
　　12.        using (SqlConnection connection = new SqlConnection(conString))
　　13.        {
　　14.            using (SqlCommand cmd = new SqlCommand(StrSql, connection))
　　15.            {
　　16.                connection.Open();
　　17.                int rows = cmd.ExecuteNonQuery();
　　18.                return rows;
　　19.            }
　　20.        }
　　21.    }
　　22.}
　　为了使用方便和节省资源，我们将变量和方法设计成静态的。此时的调用就变成了：

　　1.  string strSql = "update P_Product set Name='电脑3' where>　　2.  int rows = DbHelperSQL.ExecuteSql(strSql);
　　为了以后的维护和扩展，数据库连接字符串最好放在Web.config里面，这样以后想改数据库就直接改一下Web.config即可，而无须重新编译代码。
　　1.  Web.config加入：
　　2.  
　　3.      
　　5.  
　　6.  变量获取该字符串：
　　7.  public static string conString = ConfigurationManager.AppSettings
　　8.      ["ConnectionString "];
　　有时候为了安全，我们可能会对Web.config中的连接字符串进行加密。这样就需要在获取连接字符串的时候进行解密。这样，单凭上面一句代码可能就无法解决了，我们还需要单独的处理方法来处理。为了更好地降低耦合性，减少对类的依赖，我们可以将获取数据库连接字符串的操作单独放到一个类里面，如PubConstant。这样以后修改相应的连接规则和加密处理时，直接调用各个模块的这个类就可以了，而并不需要知道实际的各个模块的数据库访问类是怎么获取的。
　　例如Web.config的设置：
　　1.  
　　2.  
　　4.  公共常量类获取并处理：

　　5.  public>　　6.  {
　　7.      //
　　8.      //获取连接字符串，判断是否加密处理
　　9.      //
　　10.    public static string ConString
　　11.    {
　　12.        get
　　13.        {
　　14.            string _conString = ConfigurationManager.AppSettings
　　["ConString"];
　　15.            string ConStringEncrypt = ConfigurationManager.AppSettings
　　16.            ["ConStringEncrypt"];
　　17.            if (ConStringEncrypt == "true")//是加密的
　　18.            {
　　19.                _conString = DESEncrypt.Decrypt(_conString);//解密
　　20.            }
　　21.            return _conString;
　　22.        }
　　23.}
　　24.}
　　25.使用连接字符串：
　　26.public static string conString = PubConstant.ConString;
　　C#操作数据库的常用公共方法！
　　分类： Winform项目心得体会 2012-09-03 18:46 285人阅读 评论(0) 收藏 举报
　　即便是一个小型的C#+数据库的项目(本文以SQL SERVER为例，其他数据库类似)，也需要多种对数据库的操作。有时候编代码的时候，想到哪写到哪确实可以实现具体的功能，但从整个框架体系上来看，代码的冗余以及不规范，很有可能导致代码运行的效率，对后期扩展项目的规模也是有弊而无利。以前我犯了很都这种错误，以后坚决不犯了。
　　好了，言归正传了。经常操作数据库的步骤无非就是连接数据库，执行SQL语句，显示结果三个大步骤。而一般这三个步骤可以由两个方面进行（个人感觉是这样）：一个方法就是建立SqlDataAdapter用以填充数据集DataSet；另一个方法就是利用Commd对象执行SQL语句，然后建立SqlDataReader。前者主要用于绑定显示控件，后者则倾向于判断某种条件。总之，大体的操作流程就是这样，当我们进行多次操作数据库的时候，必然会有重复的代码，那么建立公共方法就是很必要的了。
　　建立一个公共类，如下
　　[csharp] view plaincopyprint?
　　using System;
　　using System.Collections.Generic;
　　using System.Linq;
　　using System.Text;
　　using System.Data.SqlClient;
　　using System.Data;
　　namespace BaseClass
　　{

　　>　　{
　　//连接数据库
　　public SqlConnection getcon()
　　{
　　string M_str_sqlcon = "Server=.;DataBase=db_CRM;Trusted_Connection=SSPI";
　　SqlConnection myCon = new SqlConnection(M_str_sqlcon);
　　return myCon;
　　}
　　//连接SqlConnection,执行SQL
　　public void getcom(string M_str_sqlstr)
　　{
　　SqlConnection sqlcon = this.getcon();
　　sqlcon.Open();
　　SqlCommand sqlcom = new SqlCommand(M_str_sqlstr, sqlcon);
　　sqlcom.ExecuteNonQuery();
　　sqlcom.Dispose();
　　sqlcon.Close();
　　sqlcon.Dispose();
　　}
　　//创建DataSet对象
　　public DataSet getds(string M_str_sqlstr, string M_str_table)
　　{
　　SqlConnection sqlcon = this.getcon();
　　SqlDataAdapter sqlda = new SqlDataAdapter(M_str_sqlstr, sqlcon);
　　DataSet myds = new DataSet();
　　sqlda.Fill(myds, M_str_table);
　　return myds;
　　}
　　//创建SqlDataReader对象
　　public SqlDataReader getread(string M_str_sqlstr)
　　{
　　SqlConnection sqlcon = this.getcon();
　　SqlCommand sqlcom = new SqlCommand(M_str_sqlstr, sqlcon);
　　sqlcon.Open();
　　SqlDataReader sqlread = sqlcom.ExecuteReader(CommandBehavior.CloseConnection);
　　return sqlread;
　　}
　　}
　　}
　　将每一个步骤像如上一样写成公共方法，则就能随意的在各个模块进行调用，这不仅使得代码简洁明了，也有助于旁人阅读。另外，对变量的命名也需要有自己的命名规则，不然当变量很都得时候就会搞混。
　　有了上面的铺垫，可以按照上面的思路继续考虑可能用到的公共方法，其中，控件（比如下拉框）的数据绑定，正则表达式的判定算是最常用的，乘胜追击，立刻再写一个公共类，添加如下公共方法：
　　[csharp] view plaincopyprint?
　　using System;
　　using System.Collections.Generic;
　　using System.Linq;
　　using System.Text;
　　using System.Data.SqlClient;
　　using System.Data;
　　using System.Windows.Forms;
　　using System.Text.RegularExpressions;
　　namespace BaseClass
　　{

　　>　　{
　　BaseOperate boperate = new BaseOperate();// 声明BaseOperate类的一个对象，以调用其方法
　　//绑定COMBOBOX控件
　　public void cboxBind(string P_str_sqlstr, string P_str_table, string P_str_tbMember, ComboBox cbox)
　　{
　　DataSet myds = boperate.getds(P_str_sqlstr, P_str_table);
　　cbox.DataSource = myds.Tables[P_str_table];//将数据集中的表绑定到下拉框上
　　cbox.DisplayMember = P_str_tbMember;//将表中的具体的列所对应的值显示在下拉框中
　　}
　　//验证输入的字符串为数字
　　public bool validateNum(string P_str_num)
　　{
　　return Regex.IsMatch(P_str_num, "^[0-9]*$");
　　}
　　//验证输入的字符串为电话号码
　　public bool validatePhone(string P_str_phone)
　　{
　　return Regex.IsMatch(P_str_phone, @"\d{3,4}-\d{7,8}");
　　}
　　//验证输入的字符串为传真号码
　　public bool validateFax(string P_str_fax)
　　{
　　return Regex.IsMatch(P_str_fax, @"86-\d{2,3}-\d{7,8}");
　　}
　　//验证输入的字符串为邮编号码
　　public bool validatePostCode(string P_str_postcode)
　　{
　　return Regex.IsMatch(P_str_postcode, @"\d{6}");
　　}
　　#endregion
　　//验证输入的字符串为E-MAIL地址
　　public bool validateEmail(string P_str_email)
　　{
　　return Regex.IsMatch(P_str_email, @"\w+([-+.']\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*");
　　}
　　//验证输入的字符串为网络地址
　　public bool validateNAddress(string P_str_naddress)
　　{
　　return Regex.IsMatch(P_str_naddress, @"http(s)?://([\w-]+\.)+[\w-]+(/[\w- ./?%&=]*)?");
　　}
　　//自动编号
　　///
　　/// 自动编号
　　///
　　/// SQL语句
　　/// 数据表
　　/// 数据表字段
　　/// 编号前的字符串
　　/// 编号后的数字
　　/// textBox控件名
　　public void autoNum(string P_str_sqlstr, string P_str_table, string P_str_tbColumn, string P_str_codeIndex, string P_str_codeNum, TextBox txt)
　　{
　　string P_str_Code = "";
　　int P_int_Code = 0;
　　DataSet myds = boperate.getds(P_str_sqlstr, P_str_table);
　　if (myds.Tables[0].Rows.Count == 0)
　　{
　　txt.Text = P_str_codeIndex + P_str_codeNum;
　　}
　　else
　　{
　　P_str_Code = Convert.ToString(myds.Tables[0].Rows[myds.Tables[0].Rows.Count - 1][P_str_tbColumn]);//获取最后一行数据里的编号字段
　　P_int_Code = Convert.ToInt32(P_str_Code.Substring(1, 3)) + 1;//我的字段为"C101,C102....."
　　P_str_Code = P_str_codeIndex + P_int_Code.ToString();
　　txt.Text = P_str_Code;
　　}
　　}
　　}
　　}
　　在自动编号的公共方法里，提取字符串的格式各有不同，由于不知道有什么方法可以实现自增，只能用C101来进行自增（要是设置为C001要的话，按照上述方法，第二个就是C2了），这方法也就将就着能用吧。