溫馨提示×
您好，登錄后才能下訂單哦！
點擊 登錄注冊 即表示同意《億速云用戶服務條款》
您好，登錄后才能下訂單哦！
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文件的鏈接參數
<appSettings>
<!--
connStr參數設置，事例說明：
（1）Sql server數據庫，例如“server=local;database=test;uid=sa;pwd=;”
（2）Access數據庫，例如“data\ex.mdb; user id='admin';Jet OLEDB:database password='admin';”
-->
<add key="connStr" value="server=127.0.0.1;database=DbName;uid=sa;pwd=;" />
</appSettings>
C#代碼
using System;
using System.Data;
using System.Data.SqlClient;
namespace Com.LXJ.Database
{
/// <summary>
/// ConnDB 的摘要說明。
/// </summary>
public class ConnDB
{
protected SqlConnection Connection;
private string connectionString;
/// <summary>
/// 默認構造函數
/// </summary>
public ConnDB()
{
string connStr;
connStr = System.Configuration.ConfigurationSettings.AppSettings["connStr"].ToString();
connectionString = connStr;
Connection = new SqlConnection(connectionString);
}
/// <summary>
/// 帶參數的構造函數
/// </summary>
/// <param name="newConnectionString">數據庫聯接字符串</param>
public ConnDB(string newConnectionString)
{
connectionString = newConnectionString;
Connection = new SqlConnection(connectionString);
}
/// <summary>
/// 完成SqlCommand對象的實例化
/// </summary>
/// <param name="storedProcName"></param>
/// <param name="parameters"></param>
/// <returns></returns>
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;
}
/// <summary>
/// 創建新的SQL命令對象(存儲過程)
/// </summary>
/// <param name="storedProcName"></param>
/// <param name="parameters"></param>
/// <returns></returns>
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;
}
/// <summary>
/// 執行存儲過程,無返回值
/// </summary>
/// <param name="storedProcName"></param>
/// <param name="parameters"></param>
public void ExecuteProcedure(string storedProcName,IDataParameter[] parameters)
{
Connection.Open();
SqlCommand command;
command=BuildQueryCommand(storedProcName,parameters);
command.ExecuteNonQuery();
Connection.Close();
}
/// <summary>
/// 執行存儲過程，返回執行操作影響的行數目
/// </summary>
/// <param name="storedProcName"></param>
/// <param name="parameters"></param>
/// <param name="rowsAffected"></param>
/// <returns></returns>
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
{
class DbConn
{
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 Size 最大連接數
//Min Pool Size 最小連接數
//Pooling 當設置為true時,SQL連接將從連接池獲得,如果沒有則新建并添加到連接池中,默認是true.false則不設連接池
//Connection Lifetime 在連接池中應用,指定一個連接處于close后的生存時間大于指定時間并屬于最小連接數以外的將自動消毀
//Application Name 應用程序名稱或者當沒有提供應用程序時為.Net SqlClient數據提供者
//Connection Reset true 當連接從連接池移走時決定是否重置數據庫連接.當設置為 false 時用于避免獲得連接時的額外服務器往復代價
//Enlist true 為真時，連接池自動列出創建線程的當前事務上下文中的連接
//Workstation ID 指定工作組的名稱
//Packet Size= 就是設置網絡數據包的大小值,默認為8192
//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 ID=myUsername;Password=myPassword;
//默認情況下， SQL服務器的微軟.NET框架數據提供者設置網絡包大小對8192個字節.
//然而這不一定是最好的,你可以根據你覺的合適的包大小設置包的大小
//Server=myServerAddress;Database=myDataBase;User ID=myUsername;Password=myPassword;Trusted_Connection=False;Packet Size=4096;
//-----------------------------------------------------------------------------------------------
//因為考慮到實現復雜業務邏輯時,需要同進使用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[i] = SqlDr[i];
// }
// 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[i].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 Id=52";
5. SqlCommand myCommand = new SqlCommand(strSql, myConnection);
6. myConnection.Open();
7. int rows = myCommand.ExecuteNonQuery();
8. myConnection.Close();
如果是很多個這樣的操作，那么我們就需要寫很多基本相似的代碼。根據面對對象的抽象原則，在這些操作里面有很多共性的東西，唯一的不同就是conString和strSql。那我是不是可以將共性的東西抽象出來將其封裝為所有操作所共用呢？
我們把共性的東西抽象出一個獨立方法：
1. //<summary>
2. //執行SQL語句，返回影響的記錄數
3. //</summary>
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 Id=52";
4. int rows =ExecuteSql(strSql, conString);
是不是簡單了很多？可以讓其他類共用這個方法，重復代碼少了，工作效率提高了。
如果所連數據庫都是固定不變的，也就是說連接字符串一般不變，那么我們可以將conString 提取出來放到一個變量里面，所有的方法都用這個變量。想改變數據庫時，直接修改變量的內容即可，在實際調用的時候不需要傳連接字符串，是不是又省了一步？為了更好地復用，我們還可以將該方法放到單獨的類DbHelperSQL里面去。
DbHelperSQL類中：
1. public class DbHelperSQL
2. {
3. public static string conString = "data source=127.0.0.1;
4. database=codematic;user id=sa;password=";
5. //<summary>
6. //執行SQL語句，返回影響的記錄數
7. //</summary>
8. //<param name="StrSql">SQL語句</param>
9. //<returns>影響的記錄數</returns>
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 Id=52";
2. int rows = DbHelperSQL.ExecuteSql(strSql);
為了以后的維護和擴展，數據庫連接字符串最好放在Web.config里面，這樣以后想改數據庫就直接改一下Web.config即可，而無須重新編譯代碼。
1. Web.config加入：
2. <appSettings>
3. <add key="ConnectionString" value="server=127.0.0.1;
database=codematic;
4. uid=sa;pwd="/>
5. </appSettings>
6. 變量獲取該字符串：
7. public static string conString = ConfigurationManager.AppSettings
8. ["ConnectionString "];
有時候為了安全，我們可能會對Web.config中的連接字符串進行加密。這樣就需要在獲取連接字符串的時候進行解密。這樣，單憑上面一句代碼可能就無法解決了，我們還需要單獨的處理方法來處理。為了更好地降低耦合性，減少對類的依賴，我們可以將獲取數據庫連接字符串的操作單獨放到一個類里面，如PubConstant。這樣以后修改相應的連接規則和加密處理時，直接調用各個模塊的這個類就可以了，而并不需要知道實際的各個模塊的數據庫訪問類是怎么獲取的。
例如Web.config的<appSettings>設置：
1. <add key="ConStringEncrypt" value="false"/>
2. <add key="ConnectionString" value="server=127.0.0.1;database=codematic;
3. uid=sa;pwd="/>
4. 公共常量類獲取并處理：
5. public class PubConstant
6. {
7. //<summary>
8. //獲取連接字符串，判斷是否加密處理
9. //</summary>
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
{
class BaseOperate
{
//連接數據庫
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
{
class OperateAndValidate
{
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- ./?%&=]*)?");
}
//自動編號
/// <summary>
/// 自動編號
/// </summary>
/// <param name="P_str_sqlstr">SQL語句</param>
/// <param name="P_str_table">數據表</param>
/// <param name="P_str_tbColumn">數據表字段</param>
/// <param name="P_str_codeIndex">編號前的字符串</param>
/// <param name="P_str_codeNum">編號后的數字</param>
/// <param name="txt">textBox控件名</param>
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了），這方法也就將就著能用吧。
免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
