.NET教程-ADO.NET

更新记录
转载请注明出处：
2022年10月7日发布。
2022年10月7日从笔记迁移到博客。

基础知识

ADO.NET介绍

ADO.NET全称：ActiveX Data Objects.NET（活动数据对象.NET版本）

是.NET平台上一个数据访问技术，提供统一、标准、结构化的方式与数据交互

ADO.NET依赖于.NET FrameWork类库

ADO.NET既可以管理内部数据(内存中的数据)，也可以管理外部数据库

ADO.NET可以使用断开式模式、连接式模式

ADO. NET作用

数据量不断的增加，需要使用数据库管理数据

数据库管理系统类型非常多(SqlServer、Oracle等)

ADO.NET使用一个统一的、标准的方法来管理数据库

所有说ADO.NET服务于程序员，可以让其专注于数据本身

注意：ADO.NET除了支持对SQL Server支持，还可以对XML等数据源进行访问

ADO.NET官方文档

https://docs.microsoft.com/zh-cn/dotnet/framework/data/adonet/index

程序常用连接数据库的三种方式

ADO.NET

ODBC(Open Database Connectivity)

OLE DB

Active Data Object(ADO)

ADO.NET的工作模式

说明

主要工作模式有：

连接模式

非连接模式

Entity Framework(基于ADO.NET)

图示结构：

连接式模式说明

连接式模式需要显式的连接和断开数据库

连接式模式需要使用连接对象和命令对象和数据读取器来实现

应用程序		.NET处理		数据库
Winfroms		Connection		SqlServer
Asp.NET	←	Command	←	Oracle
Console	→	DataReader	→	Mysql
WPF		Parameter		Access

非连接式模式说明

创建Connection对象、DataAdapter对象。通过DataAdapter从数据库中选取用户需要的数据，将这些数据写入到DataSet对象中。在这个过程中，DataAdapter将会自动使用Connection对象连接到数据库，从服务器取回用户所需数据，将取回的数据写入到DataSet，断开与数据库的连接。用户修改完数据后，通过DataAdapter再次使用Connection对象连接到数据库，完成对数据库中数据的更新、删除、增加等操作

应用程序		.NET本地缓存		数据库
Winfroms		DataSet		SqlServer
Asp.NET	←	DataAdapter	←	Oracle
Console	→	DataTable	→	Mysql
WPF		DataRow		Access
Other APP		DataColumn

ADO.NET类比解释

（1）数据库好比水源，存储了大量的数据

（2）Connection对象好比伸入水中的进水龙头，保持与水的接触，只有它与水进行了“连接”，其他对象才可以抽到水

（3）Command对象则像抽水机，为抽水提供动力和执行方法，通过“水龙头”，然后把水返给上面的“水管”

（4）DataAdapter、DataReader对象就像输水管，担任着水的传输任务，并起着桥梁的作用。DataAdapter对象像一根输水管，通过发动机，把水从水源输送到水库里进行保存。而DataReader对象也是一种水管，和DataAdapter对象不同的是，它不把水输送到水库里面，而是单向地直接把水送到需要水的用户那里或田地里，所以要比在水库中转一下速度更快

（5）DataSet对象则是一个大水库，把抽上来的水按一定关系的池子进行存放。即使撤掉“抽水装置”（断开连接，离线状态），也可以保持“水”的存在。这也正是ADO.NET的核心

（6）DataTable对象则像水库中的每个独立的水池子，分别存放不同种类的水。一个大水库由一个或多个这样的水池子组成

各类型代表内容

Connection 连接、断开数据源对象

Command 命令对象

DataReader 只读/向前的读取对象

Parameter 参数对象

DataAdapter 适配同步对象

DataSet 本地数据集，独立于任何数据源的数据访问

DataTable 表

DataRow 行

DataColumn 列

DataView 视图

DataRelation 关系

Entity Framework模式说明

一组抽象化的API，封装了底层的细节，EF还可以用LINQ

ADO.NET的组成

所在程序集文件

System.Data.dll

命名空间

System.Data ADO.NET全部

System.Data.Common 供Data下其他命名空间共享类集合

System.Data.Design 生成自定义类型的技术集的类

System.Data.Sql SQL支持

System.Data.SqlTypes Sql Server映射.NET类型

System.Data.SqlServerCe Sql Server Moblie支持

Microsoft.SqlServer.Server Sql Server和CLR组件支持

System.Data.Odbc 数据提供程序，Odbc支持

System.Data.OleDb 数据提供程序，OLEDB支持

System.Data.SqlClient 数据提供程序，Sql Server支持

System.Data.OracleClient 数据提供程序，Oracle支持

主要包含类

主要包含两组主要的类：

管理内部实际数据的类

与外部数据系统进行通信的类

ADO.NET与外部通信结构图

ADO.NET内部类图

DataTable 用于表示内存中数据表

DataColumn 用于表示内存中数据表中的域(列)

DataRow 用于表示内存中某个数据表中的某一行记录

DataRelation 用于表示内存中表间的关系

DataView 用于表示内存中的视图

ADO.NET内部类工作原理图

ADO.NET数据提供程序

说明

数据提供程序：定义在命名空间中用于和特定数据库进行通信的一组类型

ADO.NET数据提供程序的基类和接口

注意：实际上并没有Connection对象，只是一种泛指，其他对象也是泛指，使用的时候使用具体数据集专属的对象，比如SqlConnection

SqlServer常用类

SqlConnection 连接，执行与数据源进行连接

SqlCommand 命令，执行数据库的命令

SqlParameter 参数，表示命令的参数

SqlDataReader 读取，数据读取器

SqlDataAdapter 适配器，用于数据源与DataSet的桥梁

SqlError 错误

SqlException 异常

SqlTransaction 事务

OleDb常用类

OleDbConnection 连接

OleDbCommand 命令

OleDbParameter 参数

OleDbDataReader 读取

OleDbDataAdapter 适配器

OleDbError 错误

OleDbException 异常

OleDbTransaction 事务

Odbc常用类

OdbcConnection 连接

OdbcCommand 命令

OdbcParameter 参数

OdbcDataReader 读取

OdbcDataAdapter 适配器

OdbcError 错误

OdbcException 异常

OdbcTransaction 事务

使用ADO.NET提供的工厂模式创建连接

说明

使用System.Data中的基类进行数据读取

需要使用System.Data.Common命名空间下的类型：

DbConnection 连接抽象基类

DbCommand 命令抽象基类

DbDataReader 读取抽象基类

DbParameter 参数抽象基类

DbTransaction 事务抽象基类

DbDataAdapter 数据适配抽象基类

DbProviderFactory 数据提供抽象基类

DbProviderFactories 创建数据提供

工厂模式适合场景

需要灵活操作数据库、需要使用不同的数据库，程序需要高度灵活

如果只需要使用SQL Server，不建议使用工厂模式

最灵活的读取方式

使用某种数据库特有的功能比较麻烦

维护不方便

工厂模式存在问题

使用的都是泛化的基类，而非某一种特定的数据库，所以不能直接访问特定数据库的功能，必须使用转换，导致程序很灵活，不便于维护

工厂模式实例

配置文件处理

配置文件中添加

<!-- 定义连接字符串-->
  <appSettings>
    <add key="provider" value="System.Data.SqlClient"/>
    <add key="conStr" value="Server=(local);User Id = sa;Pwd = 12678q;Database=test"/>
 </appSettings>

注意：在C#中需要添加System.Configuration引用来使用该配置文件信息

注意：在C#中需要使用System.Configuration命名空间来使用该配置文件信息

如图所示：

Program.cs

using System;
using System.Data;
using System.Data.Common;
using System.Data.Sql;
using System.Configuration;

namespace PandaNamespace
{
    class PandaClass
    {
        static void Main(string[] args)
        {
            //读取config中的配置信息
            string provider = ConfigurationManager.AppSettings["provider"];
            string cnStr = ConfigurationManager.AppSettings["conStr"];
            //初始化一个工厂对象
            DbProviderFactory sqlProvider = DbProviderFactories.GetFactory(provider);
            //初始化一个连接对象
            using (DbConnection conn = sqlProvider.CreateConnection())
            {
                try
                {
                    //打开连接
                    conn.ConnectionString = cnStr;
                    conn.Open();

                    //创建一个命令
                    DbCommand comm = sqlProvider.CreateCommand();
                    comm.Connection = conn;
                    comm.CommandText = "SELECT * From panda_table";

                    //创建一个读取
                    DbDataReader reader = comm.ExecuteReader();
                    while (reader.Read())
                    {
                        Console.WriteLine($"Id = {reader["Id"]} Name = {reader["Name"]}");
                    }
                }
                catch (Exception e)
                {

                    Console.WriteLine(e.Message);
                }
            }

            Console.ReadKey();
        }
    }
}

使用ADO.NET连接层进行创建连接

连接式工作结构图

如图所示，连接式使用：连接对象、命令对象、数据读取对象进行对数据的操作

使用连接层创建连接的步骤

1、创建、配置、打开连接对象

2、创建、配置一个命令对象

3、执行命令对象的执行方法ExecuteReader()获得DataReader读取对象，或直接执行ExecuteNoQuery()等

4、使用DataReader对象的Read和索引读取数据

使用连接层相关的类型

使用SqlServer示例，其他数据库都是相似的

命名空间：System.Data; System.Data.SqlClient;

SqlConnection 连接

SqlCommand 命令

SqlDataReader 读取

SqlParameter 参数

连接层实例(面向SqlServer实现)

配置文件中添加

<appSettings>
  <add key="conStr" value="Server=(local);User Id=sa;Pwd=password;Database=test"/>
</appSettings>

注意：在C#中需要添加System.Configuration引用来使用该配置文件信息

注意：在C#中需要使用System.Configuration命名空间来使用该配置文件信息

Program.cs

using System;
using System.Data.SqlClient;
using System.Configuration;
namespace Test
{
    class Panda
    {
        static void Main()
        {
            //建立连接
            string conStr = ConfigurationManager.AppSettings["conStr"];
            using (SqlConnection conn = new SqlConnection())
            {
                //打开连接
                conn.ConnectionString = conStr;
                conn.Open();
                //建立命令
                using(SqlCommand comm = new SqlCommand())
                {
                    comm.Connection = conn;
                    comm.CommandText = "SELECT Id,Name FROM panda_table";
                    //建立读取
                    SqlDataReader dr = comm.ExecuteReader();
                    //开始读取
                    while (dr.Read())
                    {
                        Console.WriteLine($"Id = {dr["Id"]},Name = {dr["Name"]}");
                    }
                }
            }
            Console.ReadKey();
        }
    }
}

使用连接字符串对象

使用DbConnectionStringBuilder进行对连接字符串的规范化

每个具体的数据库有具体的ConnectionStringBuilder

比如SqlSever有：SqlConnectionStringBuilder

DataReader和DataSet的区别

DataReader适合：只读向前的数据流，一次只返回一条记录，当查询大量数据的时候，比DataSet节省内存

使用参数化对象

作用

可以像对象一样处理参数，而不是使用文本拼接

减少SQL注入问题

实例

配置文件中添加

<appSettings>
  <add key="conStr" value="Server=(local);User Id=sa;Pwd=password;Database=test"/>
</appSettings>

注意：在C#中需要添加System.Configuration引用来使用该配置文件信息

注意：在C#中需要使用System.Configuration命名空间来使用该配置文件信息

program.cs

using System;
using System.Data.SqlClient;
using System.Data;
using System.Configuration;
namespace Test
{
    class Panda
    {
        static void Main()
        {
            using (SqlConnection conn = new SqlConnection())
            {
                //建立连接
                string conStr = ConfigurationManager.AppSettings["conStr"];
                //打开连接
                conn.ConnectionString = conStr;
                conn.Open();
                //建立命令
                using(SqlCommand comm = new SqlCommand())
                {
                    comm.Connection = conn;
                    //使用占位符@
                    comm.CommandText = "SELECT Id,Name FROM panda_table WHERE Id = @Id";
                    //添加参数方法一
                    //comm.Parameters.Add("@Id", SqlDbType.Int, 50).Value = 2;

                    //添加参数方法二
                    SqlParameter para = new SqlParameter();
                    para.ParameterName = "@Id";
                    para.Value = 2;
                    para.SqlDbType = SqlDbType.Int;
                    para.Size = 10;
                    comm.Parameters.Add(para);

                    //建立读取
                    SqlDataReader dr = comm.ExecuteReader();
                    //开始读取
                    while (dr.Read())
                    {
                        Console.WriteLine($"Id = {dr["Id"]},Name={dr["Name"]}");
                    }
                }
            }

            Console.ReadKey();
        }
    }
}

调用SQL Server存储过程

存储过程说明

使用Command对象和查询命令类型，只是命令类型和参数不同

存储过程实例

在SQL Server中定义存储过程：

CREATE PROCEDURE panda_procedure2 @id INT, @name NVARCHAR(32) OUT
AS
BEGIN
    IF(@id = 1)
        BEGIN
            SET @name = N'Panda';
        END
    ELSE
        BEGIN
            SET @name = N'Dog';
        END
END;

Program.cs

using System;
using System.Data.SqlClient;
using System.Data;
using System.Configuration;
namespace Test
{
    class Panda
    {
        static void Main()
        {
            using (SqlConnection conn = new SqlConnection())
            {
                //建立连接
                string conStr = ConfigurationManager.AppSettings["conStr"];
                //打开连接
                conn.ConnectionString = conStr;
                conn.Open();
                //建立命令
                using (SqlCommand comm = new SqlCommand())
                {
                    //定义连接对象
                    comm.Connection = conn;
                    //定义存储过程名
                    comm.CommandText = "panda_procedure2";
                    //定义命令类型为存储过程
                    comm.CommandType = CommandType.StoredProcedure;
                    //定义输入参数
                    SqlParameter inPara = new SqlParameter();
                    inPara.ParameterName = "@id";
                    inPara.Value = 1;
                    inPara.SqlDbType = SqlDbType.Int;
                    inPara.Size = 10;
                    //定义方向：输入
                    inPara.Direction = ParameterDirection.Input;
                    comm.Parameters.Add(inPara);
                    //定义输出参数
                    SqlParameter outPara = new SqlParameter();
                    outPara.ParameterName = "@name";
                    outPara.SqlDbType = SqlDbType.NVarChar;
                    outPara.Size = 50;
                    //定义方向：输出
                    outPara.Direction = ParameterDirection.Output;
                    comm.Parameters.Add(outPara);

                    //执行存储过程
                    comm.ExecuteNonQuery();
                    //获取输出的参数值
                    Console.WriteLine((string)comm.Parameters["@name"].Value);
                }
            }

            Console.ReadKey();
        }
    }
}

实现SQL Server事务

实现SQL Server事务的方式

1、使用ADO.NET提供的事务对象Transaction

2、使用System.EnterpriseServices命名空间提供的类型

3、使用System.Transactions命名空间中的类型

4、使用WCF

5、使用WF

Transaction主要成员

Public interface IDbTransaction: IDisposable
{
    IDbConnection Connection{ get;}     //指定连接对象
    IsoLationLevel IsoLationLevel { get; }  
    void Commit();                  //提交
    void Rollback();                //回滚
}

事务实例

配置文件中添加

<appSettings>
  <add key="conStr" value="Server=(local);User Id=sa;Pwd=password;Database=test"/>
</appSettings>

注意：在C#中需要添加System.Configuration引用来使用该配置文件信息

注意：在C#中需要使用System.Configuration命名空间来使用该配置文件信息

program.cs

using System;
using System.Data;
using System.Data.SqlClient;
using System.Configuration;

namespace Test
{
    class Test
    {
        static void Main()
        {

            //新建连接
            using (SqlConnection conn = new SqlConnection())
            {
                //建立连接
                string conStr = ConfigurationManager.AppSettings["conStr"];
                //打开连接
                conn.ConnectionString = conStr;
                conn.Open();

                //联合操作1
                string sql1 = "INSERT INTO panda_table VALUES(4,'Monkey')";
                SqlCommand comm1 = new SqlCommand(sql1,conn);
                //联合操作2
                string sql2 = "INSERT INTO panda_table VALUES(5,'Cat')";
                SqlCommand comm2 = new SqlCommand(sql2,conn);
                //定义一个事务变量
                SqlTransaction tra = null;
                try
                {
                    //实例化事务
                    tra = conn.BeginTransaction();
                    //添加事务到命令中
                    comm1.Transaction = tra;
                    comm2.Transaction = tra;
                    //执行命令
                    comm1.ExecuteNonQuery();
                    comm2.ExecuteNonQuery();
                    //无误执行两条命令，进行提交
                    tra.Commit();
                }
                catch (Exception e)
                {
                    //出现错误，进行回滚
                    tra.Rollback();
                    Console.WriteLine(e.Message);
                }
            }

            Console.ReadKey();
        }
    }
}

ADO.NET断开式工作模式

断开式工作模式说明

使用内存中的对象模型来表示数据库，使我们误以为数据库是一直连接的

使用断开式方式访问时，不需要连接数据库也可以进行数据的访问和修改

如果需要返回到数据库，最终将所有修改提交的数据库进行修改

断开式访问和连接式区别

连接方式不同：断开式不用随时访问数据库，节省了宽带，但会占用一定的内存

数据访问方式不同：连接式用数据读取器读取，断开式用适配器进行访问数据

数据存储位置不同：连接式数据来自数据库，断开式数据来自存储在内存中对象模型

DataTable类型

说明

表示一个表

DataTable表示表，使用System.Data.DataTable类表示

构造函数

new DataTable()
new DataTable(string tableName)
new DataTable(string tableName,string tableNamespace)
//tableNamespace 转为XML时命名空间

主要成员

Rows 行集合

Columns 列域集合

TableName 表的名字

DataSet 所属DataSet

CaseSensitive 表中字符串比较是否区分大小写

ChildRelations 表子关系集合

ParentRelations 表父关系集合

PrimaryKey 表的主键数组

Constraints 表的约束集合

DefaultViews 表视图

CreateDataReader() 创建读取器

RemotingFormat 设置序列化格式(默认XML)

ReadXML() 从XML中读入DataTable

WriteXML() 从DataTable写入XML

DataTable主要成员

CaseSensitive 指示表中比较字符串是否区分大小写，默认为false

ChildRelations 获取DataTable的字关系集合

Constraints 表中约束的集合

Copy() 复制表

DataSet 表所属的DataSet

DefaultView 自定义视图

ParentRelations 父关系集合

PrimaryKey 主键数组

TableName 表名

DataTable的逻辑结构和物理结构

DataTable逻辑结构：类似Excel表格，具有行列

DataTable物理结构：类中使用集合表示行列，具有一个列定义集合，每一行数据使用一个DataRow类型表示

DataTable内部组成

主要由三个类组成：

DataColumn 表示表中的列

DataRow 表示表中的一条记录

实例

实例化DataTable

//直接实例化
DataTable dataTable1 = new DataTable();
//带表名实例化
DataTable dataTable2 = new DataTable("dataTable2");
//带命名空间实例化
DataTable dataTable3 = new DataTable("dataTable3","Panda");

设置表主键

//表
DataTable tb = new DataTable();
//列
DataColumn col1 = new DataColumn("Col1");
tb.Columns.Add(col1);
//设置主键
tb.PrimaryKey = new DataColumn[] { col1 };

将表插入到DataSet中

//表
DataTable tb = new DataTable("tb");
//DataSet
DataSet set = new DataSet("set");
set.Tables.Add(tb);

输出表中的列域

//表
DataTable tb = new DataTable("tb");

//添加列
DataColumn col1 = new DataColumn("col1");
DataColumn col2 = new DataColumn("col2");
DataColumn col3 = new DataColumn("col3");
tb.Columns.AddRange(new DataColumn[] { col1, col2, col3 });
//输出列
foreach (DataColumn col in tb.Columns)
{
    Console.Write(col.ColumnName + " ");
}

输出表中数据(行使用列名)

//表
DataTable tb = new DataTable("tb");
        
//添加列
DataColumn id = new DataColumn("Id",typeof(int));
DataColumn name = new DataColumn("Name",typeof(string));
tb.Columns.AddRange(new DataColumn[] { id, name });

//添加行
DataRow row = tb.NewRow();
row["Id"] = 1;
row["Name"] = "Panda";
tb.Rows.Add(row);
row = tb.NewRow();
row["Id"] = 2;
row["Name"] = "Dog";
tb.Rows.Add(row);

//输出列
foreach (DataColumn col in tb.Columns)
{
    Console.Write(col.ColumnName + " ");
}

Console.WriteLine();

//输出行(使用列名)
foreach (DataRow r in tb.Rows)
{
    Console.WriteLine(r["Id"] + " " + r["Name"]);
}

输出表中数据(行使用索引)

//表
DataTable tb = new DataTable("tb");
        
//添加列
DataColumn id = new DataColumn("Id",typeof(int));
DataColumn name = new DataColumn("Name",typeof(string));
tb.Columns.AddRange(new DataColumn[] { id, name });

//添加行
DataRow row = tb.NewRow();
row["Id"] = 1;
row["Name"] = "Panda";
tb.Rows.Add(row);
row = tb.NewRow();
row["Id"] = 2;
row["Name"] = "Dog";
tb.Rows.Add(row);

//输出列
foreach (DataColumn col in tb.Columns)
{
    Console.Write(col.ColumnName + " ");
}

Console.WriteLine();

 //输出行(使用索引)
foreach (DataRow r in tb.Rows)
{
    Console.WriteLine(r[0] + " " + r[1]);
}

输出表中数据(使用列索引号遍历)

//表
DataTable tb = new DataTable("tb");
        
//添加列
DataColumn id = new DataColumn("Id",typeof(int));
DataColumn name = new DataColumn("Name",typeof(string));
tb.Columns.AddRange(new DataColumn[] { id, name });

//添加行
DataRow row = tb.NewRow();
row["Id"] = 1;
row["Name"] = "Panda";
tb.Rows.Add(row);
row = tb.NewRow();
row["Id"] = 2;
row["Name"] = "Dog";
tb.Rows.Add(row);

//输出列
foreach (DataColumn col in tb.Columns)
{
    Console.Write(col.ColumnName + " ");
}

Console.WriteLine();

//输出行号
for (int i = 0; i < tb.Rows.Count; i++)
{
    for (int j = 0; j < tb.Columns.Count; j++)
    {
        Console.Write(tb.Rows[i][j] + " ");
    }
    Console.WriteLine();
}

输出表中数据(使用读取器)

//表
DataTable tb = new DataTable("tb");
        
//添加列
DataColumn id = new DataColumn("Id",typeof(int));
DataColumn name = new DataColumn("Name",typeof(string));
tb.Columns.AddRange(new DataColumn[] { id, name });

//添加行
DataRow row = tb.NewRow();
row["Id"] = 1;
row["Name"] = "Panda";
tb.Rows.Add(row);
row = tb.NewRow();
row["Id"] = 2;
row["Name"] = "Dog";
tb.Rows.Add(row);

//输出列
foreach (DataColumn col in tb.Columns)
{
    Console.Write(col.ColumnName + " ");
}

Console.WriteLine();

//使用读取器
DataTableReader reader =  tb.CreateDataReader();
while(reader.Read())
{
    Console.WriteLine(reader.GetInt32(0) + " " + reader.GetString(1));
}

DataTable序列化为XML文件

//表
DataTable tb = new DataTable("tb");

//添加列
DataColumn id = new DataColumn("Id",typeof(int));
DataColumn name = new DataColumn("Name",typeof(string));
tb.Columns.AddRange(new DataColumn[] { id, name });

//添加行
DataRow row = tb.NewRow();
row["Id"] = 1;
row["Name"] = "Panda";
tb.Rows.Add(row);
row = tb.NewRow();
row["Id"] = 2;
row["Name"] = "Dog";
tb.Rows.Add(row);

//写入XML
tb.WriteXml("D:/test.xml");
从XML文件中读入DataTable
//表
DataTable tb = new DataTable("tb");
//读取XML
tb.ReadXml("D:/test.xml");
DataTable序列化为二进制文件
//表
DataTable tb = new DataTable("tb");
//将序列化格式改为二进制
tb.RemotingFormat = SerializationFormat.Binary;
//新建文件流
FileStream fs1 = new FileStream("D:/test.bin", FileMode.Create);
//新建二进制序列化器
BinaryFormatter bformatter = new BinaryFormatter();
//序列化
bformatter.Serialize(fs1, tb);
fs1.Close();

从二进制文件读取DataTable

//表
DataTable tb = new DataTable("tb");
//新建二进制序列化器
BinaryFormatter bformatter = new BinaryFormatter();
//从二进制文件加载DataTable
FileStream fs2 = new FileStream("D:/test.bin", FileMode.Open);
tb = (DataTable)bformatter.Deserialize(fs2);
//清空表
tb.Clear();

选择表中的行

//表
DataTable tb = new DataTable("tb");
        
//添加列
DataColumn id = new DataColumn("Id", typeof(int));
DataColumn name = new DataColumn("Name", typeof(string));
tb.Columns.AddRange(new DataColumn[] { id, name });
        
//添加行
DataRow row = tb.NewRow();
row["Id"] = 1;
row["Name"] = "Panda";
tb.Rows.Add(row);
row = tb.NewRow();
row["Id"] = 2;
row["Name"] = "Dog";
tb.Rows.Add(row);
        
//使用Select
//注意字符串使用单引号
DataRow[] rowSelect = tb.Select("Name = 'Panda'");
//输出选择的行
foreach (DataRow rows in rowSelect)
{
    Console.WriteLine(rows[0] + " " + rows[1]);
}

修改表中的行

//表
DataTable tb = new DataTable("tb");
        
//添加列
DataColumn id = new DataColumn("Id", typeof(int));
DataColumn name = new DataColumn("Name", typeof(string));
tb.Columns.AddRange(new DataColumn[] { id, name });
        
//添加行
DataRow row = tb.NewRow();
row["Id"] = 1;
row["Name"] = "Panda";
tb.Rows.Add(row);
row = tb.NewRow();
row["Id"] = 2;
row["Name"] = "Dog";
tb.Rows.Add(row);
        
//使用Select
//注意字符串使用单引号
DataRow[] rowSelect = tb.Select("Name = 'Panda'");
//修改数据
rowSelect[0]["Id"] = 123;
tb.AcceptChanges();

//输出选择的行
foreach (DataRow rows in rowSelect)
{
    Console.WriteLine(rows[0] + " " + rows[1]);
}

删除表中的行

//表
DataTable tb = new DataTable("tb");
        
//添加列
DataColumn id = new DataColumn("Id", typeof(int));
DataColumn name = new DataColumn("Name", typeof(string));
tb.Columns.AddRange(new DataColumn[] { id, name });
        
//添加行
DataRow row = tb.NewRow();
row["Id"] = 1;
row["Name"] = "Panda";
tb.Rows.Add(row);
row = tb.NewRow();
row["Id"] = 2;
row["Name"] = "Dog";
tb.Rows.Add(row);
        
//使用Select
//注意字符串使用单引号
DataRow[] rowSelect = tb.Select("Name = 'Panda'");
//删除数据
rowSelect[0].Delete();
tb.AcceptChanges();

Console.WriteLine(tb.Rows.Count);

增加表中的行

提交表修改

回滚表修改

检测表修改

使用DataTableReader读取DataTable中的数据

//实例DataSet
DataSet myDs = new DataSet();
//设置DataSet名字
myDs.DataSetName = "test";
//循环读取数据
foreach (DataTable tableTemp in myDs.Tables)
{
    //输出列名
    for (int colCount = 0; colCount < tableTemp.Columns.Count; colCount++)
    {
        Console.WriteLine(tableTemp.Columns[colCount]);
    }
    //获取读取对象
    DataTableReader myDr = tableTemp.CreateDataReader();
    //输出数据
    while (myDr.Read())
    {
        for (int colCount = 0; colCount < myDr.FieldCount; colCount++)
        {
            Console.WriteLine(myDr[colCount]);
        }
    }
    myDr.Close();
}

DataTableCollection类型

DataColumn类型

DataColumn作用

表示一个单列

一个DataColumn绑定到一个特定的DataTable，然后组成一个完整的DataTable

注意：DataColumn表示DataTable的字段，而非数据

构造函数

DataColumn()
DataColumn(string ColumnName)
DataColumn(string ColumnName,Type DataType)
DataColumn(string ColumnName,Type DataType,string expression)
DataColumn(string ColumnName,Type DataType, string expression,MappingType type)

DataColumn的主要属性

AllowDBNull 是否允许该列为Null，默认为true

DataType 该列的数据类型

Unique 约束，是否是唯一的，如果是主键则要设置

DefaultValue 约束，默认值

AutoIncrement 约束，自增

AutoIncrementStep 约束，自增的步进值

AutoIncrementSeed 约束，自增的基础值

Caption 要对外显示的标题，友好名字(对外)

ColumnName 设置集合中的列名(对内)(默认:Column0123...)

ColumnMapping 转为XML的方式

Expression 设置列表达式

Ordinal 获取DataColumn在DataColumnCollection中的位置，返回数值

ReadOnly 添加了数据后是否还可以改变列名，默认false

Table 指向所属的表

DataColumn实例

基本使用

//初始化一个列
DataColumn myCol = new DataColumn();
//设置列名
myCol.ColumnName = "UserName";
//设置对外显示的列名
myCol.Caption = "用户名";
//设置为只读
myCol.ReadOnly = true;
//设置为不能为null
myCol.AllowDBNull = false;
//设置为唯一
myCol.Unique = true;
//设置列类型
myCol.DataType = typeof(int);
//设置自增
myCol.AutoIncrement = true;
myCol.AutoIncrementStep = 1;
myCol.AutoIncrementSeed = 0;
//DataColumn还有很多构造函数
DataColumn myCol2 = new DataColumn("UserSex", typeof(int));
DataColumn myCol3 = new DataColumn("UserAge", typeof(int), "", MappingType.Attribute);
//实例化一个表
DataTable myTable = new DataTable();
//设置表名
myTable.TableName = "test";
//单个添加到DataTable中
myTable.Columns.Add(myCol);
//多个添加到DataTable中
myTable.Columns.AddRange(new DataColumn[] { myCol2, myCol3 });

构造列对象

实例化DataColumn

//直接实例化
DataColumn dataColumn1 = new DataColumn();
//实例化带列名
DataColumn dataColumn2 = new DataColumn("Name");
//实例化带数据类型
DataColumn dataCoulmun3 = new DataColumn("Name", typeof(int));

更多构造函数请查文档

实例化一个列并设置为主键

DataColumn col = new DataColumn("Col Id");
col.Caption = "编号";
col.DataType = typeof(int);
col.AutoIncrement = true;
col.AutoIncrementSeed = 1;
col.AutoIncrementStep = 1;
col.Unique = true;
col.AllowDBNull = false;
col.ReadOnly = true;

把DataColumn添加到DataTable

DataColumn col1 = new DataColumn("Col Id1");
DataColumn col2 = new DataColumn("Col Id2");
DataColumn col3 = new DataColumn("Col Id3");

//添加一个列
DataTable table = new DataTable();
table.Columns.Add(col1);

//添加多个列
DataTable table2 = new DataTable();
table2.Columns.AddRange(new DataColumn[] {col2, col3 });

添加列到表中

//实例化表
DataTable dataTable1 = new DataTable("Panda");
//实例化2个列
DataColumn dataColumn1 = new DataColumn("Id",typeof(int));
DataColumn dataColumn2 = new DataColumn("Name",typeof(string));
//添加列实例
dataTable1.Columns.Add(dataColumn1);
dataTable1.Columns.Add(dataColumn2);
//或直接添加
dataTable1.Columns.Add("Age", typeof(int));
dataTable1.Columns.Add("Note", typeof(string));

列添加到表

DataTable table = new DataTable();
DataColumn col1 = new DataColumn("Id", typeof(int));
DataColumn col2 = new DataColumn("Name", typeof(string));
table.Columns.AddRange(new DataColumn[] { col1,col2});

DataColumnColletion类型

DataRow类型

作用

表示DataTable中的一行数据
一行数据使用一个DataRow对象表示
注意：该类没有构造函数,只可以通过Table.NewRow()来获得对象

主要成员

Table 获取所属表，指向包含该DataRow的DataTable
BeginEdit() 开始修改
EndEdit 结束修改
CancelEdit() 取消修改
AcceptChanges() 提交修改
RejectChanges() 取消修改
Delete() 标记该行为待删除，调用AcceptChanges()后移除
IsNull() 行是否包含Null
RowSate 行状态
可取值是DataRowState枚举
Added 行添加到表中了,但未使用AcceptChanges()
Deleted 行从表删除了,但未使用AcceptChanges()
Modified 行修改了,但未使用AcceptChanges()
Detached 未被添加到表或已被表删除
Unchanged 上次AcceptChanges()以来没有被改变
DataRowVersion 行版本(非公开属性)
可取值是DataRowVersion枚举
Current 当前版本
Default 默认版本(RowState为:Added/Modified/Deleted 值为Current,Detached值为Proposed)
Original 首次插入或调用AcceptChanges()后版本
Proposed 调用BeginEdit()后版本
可以是DataRowVerson
ItemArray 获得行的所有列值,是一个对象数组
HasError 返回布尔值，指示该行是否有错误
GetColumnsInError() 包含错误的成员
GetColumnError() 获得错误说明
ClearErrors() 清除该行的所有错误
RowError 设置自定义错误说明

行对象的状态RowState属性

RowState取值为DataRowState的枚举值

DataRowState.Added 该行已添加到DataRowCollection,但AcceptChanges()还没调用

DataRowState.Deleted 已经被.Delete()方法删除,但AcceptChanges()还没调用

DataRowState.Modifed 该行已经被修改，但AcceptChanges()未调用

DataRowState.Unchanged 该行自从上次调用AccpetChanges()后未修改过

DataRowState.Detached 该行已经创建，但未加入到任何DataRowCollection

行对象的版本DataRowVersion属性

当新建DataRow对象时，只有一份数据，表示当前版本，当改变该行数据的时候，就会出现其他版本的数据

DataRowVersion属性可以取值为DataRowVersion枚举的值

DataRowVersion.Current 当前值，当RowState为Added/Modified/Deleted时

DataRowVersion.Default 默认值

DataRowVersion.Proposed 正在编辑的行，比如调用BeginEdit()、或者DataRowSate为Detached时

DataRowVersion.Original 首次插入值的时候，或AcceptChanges()调用后，

DataRow实例

添加行到表

//DataRow没有直接公共的构造函数
//需要使用DataTable的方法进行分配实例
DataTable myTable = new DataTable();
//分配实例
DataRow myRow1 = myTable.NewRow();
//使用列名插入数据
myRow1["UserName"] = "panda";
myRow1["UserPwd"] = "123";
//添加到表中
myTable.Rows.Add(myRow1);
//分配新的行
myRow1 = myTable.NewRow();
//使用索引插入数据
myRow1[0] = "Panda";
myRow1[1] = "123";
myTable.Rows.Add(myRow1);

DataRowCollection类型

Constraint类型

ConstraintCollection类型

DataSet类型

说明

DataSet对象就像存放于内存中的一个小型数据库

DataSet对象可以包含数据表、数据列、数据行、视图、约束以及关系

通常，DataSet的数据来源于数据库或者XML

为了从数据库中获取数据，需要使用数据适配器（DataAdapter）从数据库中查询数据

内存中对象模型结构图：

使用DataSet的方式

手动创建DataSet、DataTable、DataRelation和Contraint实例，使用数据填充

使用DataAdapter从指定数据库抓取数据填充到DataSet中

使用XML加载和保持DataSet内容

构造函数

DataSet dataSet1 = new DataSet();
DataSet dataSet2 = new DataSet(DataSetName);

DataSet主要属性

Tables 指向DataTableCollection类型，该对象是包含Datatable对象的集合

Relations 指向DataRelationCollection类型，该对象是包含DataRelation对象的集合

ExtendedProperties 指向PropertyCollection对象，是一个Key/Value集合

CaseSensitive DataSet中的字符串比较是否区分大小写，默认false，不区分

DataSetName 用于设定DataSet的名字

HasErrors 获取一个值，查看DataSet中的数据是否有误

主要成员

Tables 表集合

Relations 关系集合

ExtendedProperties 附加属性

CaseSensitive 字符串比较是否区分大小写

DataSetName DataSet名

EnforceConstraint 操作是否遵守约束

HasErrors 是否有错误

RemotingFotmat 远程传输时格式.(二进制和XML(默认))

AcceptChanges() 提交更新改动

GetChanges() 获取上一次更新改动

HasChanges() 是否有更新改动

RejectChanges() 回滚更新改动

Merge() 合并多个DataSet

Clear() 清空DataSet

Clone() 复制DataSet的结构

Copy() 复制DataSet的结构和数据

RemotingFormat 设置序列化格式(默认XML)

ReadXML() 从XML中读入DataSet

WriteXML() 从DataSet写入XML

DataSet实例

DataSet属性操作

//新建DataSet对象
DataSet myDataSet = new DataSet();
//添加Data的说明到ExtendedProperties集合中
myDataSet.ExtendedProperties.Add("WhoCreate","Panda");
myDataSet.ExtendedProperties.Add("CreateDate","2017-7");

获取DataSet中的数据

//实例化一个DataSet
DataSet myDs = new DataSet();
//设置DataSet的名字
myDs.DataSetName = "MyDss";
//循环输出数据
foreach(DataTable tableTemp in myDs.Tables)
{
    //输出表列名
    for (int colCuunt = 0; colCuunt < tableTemp.Columns.Count; colCuunt++)
    {
        Console.WriteLine(tableTemp.Columns[colCuunt]);
    }
    //输出表中数据
    for (int rowCount = 0; rowCount < tableTemp.Rows.Count; rowCount++)
    {
        for (int colCount = 0; colCount < tableTemp.Columns.Count; colCount++)
        {
            Console.WriteLine(tableTemp.Rows[rowCount][colCount]);
        }
    }
}

DataSet序列化为XML文件

//表
DataTable tb = new DataTable("tb");

//添加列
DataColumn id = new DataColumn("Id", typeof(int));
DataColumn name = new DataColumn("Name", typeof(string));
tb.Columns.AddRange(new DataColumn[] { id, name });

//添加行
DataRow row = tb.NewRow();
row["Id"] = 1;
row["Name"] = "Panda";
tb.Rows.Add(row);
row = tb.NewRow();
row["Id"] = 2;
row["Name"] = "Dog";
tb.Rows.Add(row);
DataSet set = new DataSet("set");
set.Tables.Add(tb);

//写入XML
set.WriteXml("D:/test.xml");

从XML文件读入DataSet

DataSet set = new DataSet("set");
//读取XML
set.ReadXml("D:/test.xml");

清空DataSet

DataSet set = new DataSet("set");
//清空
set.Clear();

DataSet序列化为二进制文件

DataSet set = new DataSet("set");
//将序列化格式改为二进制
set.RemotingFormat = SerializationFormat.Binary;
//新建文件流
FileStream fs1 = new FileStream("D:/test.bin", FileMode.Create);
//新建二进制序列化器
BinaryFormatter bformatter = new BinaryFormatter();
//序列化
bformatter.Serialize(fs1, set);
fs1.Close();

从二进制文件读取DataSet

DataSet set = new DataSet("set");
//新建二进制序列化器
BinaryFormatter bformatter = new BinaryFormatter();
//从二进制文件加载DataSet
FileStream fs2 = new FileStream("D:/test.bin", FileMode.Open);
set = (DataSet)bformatter.Deserialize(fs2);

合并多个DataSet对象

使用.Merge()方法

提交DataSet修改

回滚DataSet修改

检测DataSet修改

DataView类型

DataView类型说明

表示一个视图

构造函数

new DataView();
new DataView(DataTable table);
new DataView(DataTable table,string RowFilter,string sort,DataViewRowState RowState);

主要成员

Table 所属的表

RowFilter 对行过滤

实例

新建view并筛选行

//新建view
DataView dv = new DataView(tb);
//筛选行
dv.RowFilter = "Name = 'Panda'";

DataRelation类型

说明

表示表的关系

实例

实现表的关系

//集合
DataSet set = new DataSet();
//表
DataTable tb1 = new DataTable("tb1");
DataTable tb2 = new DataTable("tb2");
//列
DataColumn col1 = new DataColumn("col1");
DataColumn col2 = new DataColumn("col2");
//添加表添加列
tb1.Columns.Add(col1);
tb2.Columns.Add(col2);
set.Tables.Add(tb1);
set.Tables.Add(tb2);
//建立关系
//注意列顺序：父表列在前，子表列在后
DataRelation rs = new DataRelation("关系名",set.Tables["tb1"].Columns["col1"], set.Tables["tb2"].Columns["col2"]);
//添加关系
set.Relations.Add(rs);

DataRelationCollection类型

DataAdapter类型

DataAdapter类型说明

数据适配器，专为断开层数据处理设计

用于从数据源获得数据然后填充到DataSet中

用于将DataSet中的更改修改到原数据源

DataAdapter需要使用Connection对象连接到数据库

DataAdapter需要使用Command对象来对数据进行查询和修改

DataAdapter作用

数据适配器

向DataSet对象填充数据和把DataSet修改后的数据返回到数据库

使用数据适配器只用传入连接参数，而不用手动管理连接

DataAdapter主要成员

Fill() 执行(Select语句)填充DataSet

Update() 执行(Insert/Update/Delete语句)把修改后的DataSet修改到数据库中

SelectCommand 选择命令

InsertCommand 插入命令

UpdateCommand 更新命令

DeleteCommand 删除命令

DataAdapter实例

DataAdapter填充DataSet

//定义连接字符串
string conStr = "Server= ;User Id= ;Password= ;DataBase= ;";
//新建适配器
//设置选择数据的命令
SqlDataAdapter myAr = new SqlDataAdapter("选择数据命令",conStr);
//新建一个DataSet存放数据
DataSet myDs = new DataSet();
//填充数据到DataSet中
myAr.Fill(myDs, "test");
//现在DataSet可以使用了
//使用DataSet的代码 
//code

//更新DataSet到数据库中
myAr.Update(myDs);

SqlConnection类型

Connection类型说明

Connection类型只是一个基类

使用时需要使用具体数据库的Connection类型

SQL Server数据提供程序，位于System.Data.SqlClient命名空间

ODBC数据提供程序，位于System.Data.Odbc命名空间

OLEDB数据提供程序，位于System.Data.OleDb命名空间

Oracle数据提供程序，位于System.Data.OracleClient命名空间

构造函数

SqlConnection conn = new SqlConnection();
SqlConnection conn = new SqlConnection(connString);

Connection常用连接参数

注意：

连接字符串忽略空格

关键字不区分大小写

值区分大小写，如果值包含分号、单引号或双引号，则必须加双引号

Application Name 应用程序名称

Server | Data Source 服务器地址

Database | Initial Catalog 数据库名

User ID | UID 用户名

Password | PWD 密码

Connect Timeout 超时时间

Encrypt 是否使用SSL

WorkStation ID 工作站ID

Integrated Security 是否启用Windows身份验证模式，true表示启用

Packet Size 网络包大小(512倍数)

Provider 设置或返回连接程序的名称

常用方法和属性

.ConnectionString 连接字符串

.Open() 打开连接

.Close() 关闭连接

.Database 连接的数据库

.ChangeDatabase() 更换数据库

.State 连接对象的状态(ConnectionState枚举)

.WorkstationId 工作站Id(默认本机名)

.ServerVersion sqlserver版本

.DataSource 服务器名称

.ClientConnectionId 连接Id

.ConnectionString 连接字符串

.ConnectionTimeout 超时时间

.BeginTransaction 开启数据库事务

判断连接状态

使用State属性

State属性的值为ConnectionState枚举值

ConnectionState可取值：

断开连接

使用.Close()方法或者.Dispose()方法

当对数据库操作完毕后，要关闭与数据库的连接，释放占用的资源

通过调用 SqlConnection对象的Close方法或Dispose方法关闭与数据库的连接

这两种方法的主要区别是：

Close方法用于关闭一个连接

Dispose方法不仅关闭一个连接，而且还清理连接所占用的资源

使用Close方法关闭连接后，可以再调用Open方法打开连接

使用Dispose方法关闭连接，就不可以再次直接用Open方法打开连接

必须再次重新初始化连接再打开

注意

连接对象打开后应尽快关闭,减少资源占用

Close表示关闭连接,可以使用Open再次打开.Dispose表示释放,不可以再次打开

Connection具体类型

微软提供了4种连接数据库的Connection对象，分别是：

SqlConnection 用于SQL Server

OracleConnection 用于Oracle

OdbcConnection 用于ODBC

OleDbConnection 用于Ole DB 多见于ACCESS

实例

开启连接

//定义一个连接
using (SqlConnection conn = new SqlConnection())
{
    //建立连接凭证
    string sqlConnectionMessage = "Server = m1.dogdog.com; DataBase = dogDb; User Id = sa; password = 100dasd";
    conn.ConnectionString = sqlConnectionMessage;

    //打开连接
    conn.Open();

    //检测是否连接完成
    if(conn.State == System.Data.ConnectionState.Open)
    {
        //进行操作

    }
}

关闭连接

使用using语句可以自动关闭

也可以使用.Close()来进行关闭

释放连接

使用using语句可以自动释放

也可以使用.Dispose()来进行释放

使用SqlConnection连接Sql Server的实例

//定义一个连接
using (SqlConnection conn = new SqlConnection())
{
    //建立连接凭证
    string sqlConnectionMessage = "Server = m1.dogdog.com; DataBase = dogDb; User Id = sa; password = aaa";
    conn.ConnectionString = sqlConnectionMessage;

    //打开连接
    conn.Open();

    //检测是否连接完成
    if(conn.State == System.Data.ConnectionState.Open)
    {
        //进行操作
        //获得当前使用的数据库名称
        Console.WriteLine(conn.Database);
        //获得当前连接的状态
        Console.WriteLine(conn.State);

        //关闭连接
        conn.Close();
    }
}

获得连接的信息

//定义一个连接
using (SqlConnection conn = new SqlConnection())
{
    //建立连接凭证
    string sqlConnectionMessage = "Server = m1.dogdog.com; DataBase = dogDb; User Id = sa; password = sdadas";
    conn.ConnectionString = sqlConnectionMessage;

    //打开连接
    conn.Open();

    //检测是否连接完成
    if(conn.State == System.Data.ConnectionState.Open)
    {
        //获得当前使用的数据库名称
        Console.WriteLine(conn.Database);
        //获得当前连接的状态
        Console.WriteLine(conn.State);
        //获得连接的超时时间
        Console.WriteLine(conn.ConnectionTimeout);
        //获得数据源名称
        Console.WriteLine(conn.DataSource);
//SQL Server版本信息
Console.WriteLine(conn.ServerVersion);
    }
}

修改当前的数据库

//定义一个连接
using (SqlConnection conn = new SqlConnection())
{
    //建立连接凭证
    string sqlConnectionMessage = "Server = m1.dogdog.com; DataBase = dogDb; User Id = sa; password = asdasd";
    conn.ConnectionString = sqlConnectionMessage;

    //打开连接
    conn.Open();

    //检测是否连接完成
    if(conn.State == System.Data.ConnectionState.Open)
    {
        //获得当前使用的数据库名称
        Console.WriteLine(conn.Database);
        //修改数据库
        conn.ChangeDatabase("master");
        //获得当前使用的数据库名称
        Console.WriteLine(conn.Database);
    }
}

ConnectionStringBuilder类型

ConnectionStringBuilder类型说明

连接字符串对象

实例

配置连接对象

//创建连接对象
SqlConnectionStringBuilder dbconnStr = new SqlConnectionStringBuilder();

配置连接对象的选项

//创建连接对象
SqlConnectionStringBuilder dbconnStr = new SqlConnectionStringBuilder();
//设置服务器
dbconnStr.DataSource = "m1.dogdog.com";
//设置数据库
dbconnStr.InitialCatalog = "dogDb";
//设置超时时间
dbconnStr.ConnectTimeout = 30;
//设置用户名
dbconnStr.UserID = "sa";
//设置密码
dbconnStr.Password = "10asd8sadQ";
//设置是否启用连接池
dbconnStr.Pooling = true;
dbconnStr.MaxPoolSize = 100;
dbconnStr.MinPoolSize = 1;

与连接对象配合使用

//定义一个连接
using (SqlConnection conn = new SqlConnection())
{
    //建立连接凭证
    //创建连接对象
    SqlConnectionStringBuilder dbconnStr = new SqlConnectionStringBuilder();
    //设置服务器
    dbconnStr.DataSource = "m1.dogdog.com";
    //设置数据库
    dbconnStr.InitialCatalog = "dogDb";
    //设置超时时间
    dbconnStr.ConnectTimeout = 30;
    //设置用户名
    dbconnStr.UserID = "sa";
    //设置密码
    dbconnStr.Password = "dsds";
    //设置是否启用连接池
    dbconnStr.Pooling = true;
    dbconnStr.MaxPoolSize = 100;
    dbconnStr.MinPoolSize = 1;

    //赋值给连接对象
    conn.ConnectionString = dbconnStr.ToString();

    //打开连接
    conn.Open();

    //检测是否连接完成
    if(conn.State == System.Data.ConnectionState.Open)
    {
        //进行操作

    }
}

SqlCommand类型

SqlCommand类型说明

SqlCommand对象标识数据库命令对象

用于处理SQL语句或存储过程

构造函数

SqlCommand sql = new SqlCommand();
SqlCommand sql = new SqlCommand(CommandText);
SqlCommand sql = new SqlCommand(CommandText,Connection);
SqlCommand sql = new SqlCommand(CommandText,Connection,SqlTransaction);

注意

可以多个命令对象共用一个连接对象

主要成员

.Connection 连接对象

.CommandText SQL文本或存储过程名称

.CommandType 命令的类型；

CommandType.Text表示SQL语句；

CommandType.StoredProcedure表示存储过程

.Parameters 命令的参数集合

.Transaction 获得或设置执行命令的事务

.CommandTimeout 超时时间

.ExecuteNonQuery() 执行命令,返回受影响的行数量(用于INSERT/DELETE/UPDATE/SET)

.ExecuteReader() 执行命令,返回0或多行数据(用于SELECT)

.ExecuteXmlReader() 执行命令.返回一个XmlReader对象(用于处理XML数据)

.ExecuteScalar() 执行命令,返回第一行第一列的数据

.BeginExecuteNonQuery() 启用异步执行查询

.BeginExecuteReader() 启用异步执行查询

.BeginExecuteXmlReader() 启用异步执行查询

Command具体类型

SqlCommand：用于向SQL Server数据库发送SQL语句，位于System.Data.SqlClient命名空间

OleDbCommand：OLEDB公开的数据库发送SQL语句，位于System.Data.OleDb命名空间。例如，Access数据库和MySQL数据库都是OLE DB公开的数据库

OdbcCommand：ODBC公开的数据库发送SQL语句，位于System.Data.Odbc命名空间有些数据库没有提供相应的连接程序，则可以配置好ODBC连接后，使用OdbcCommand

OracleCommand：用于向Oracle数据库发送SQL语句，位于System.D ata.OracleClient命名空间

Command对象常用属性和方法

常用属性

CommandText 获取或设置SQL语句或者存储过程或者表名

CommandType 获取或设置命令类型

CommandTimeOut 获取或设置超时时间

Connection 获取或设置连接对象

Parameters 参数条件集合

常用方法

ExecuteNonQuery() 执行SQL命令，返回影响的条数

ExecuteReader() 执行SQL命令，返回查询的数据

ExecuteScalar() 执行SQL命令，返回查询的第一行第一列数据

实例

创建命令对象-直接创建1

using(SqlConnection conn = new SqlConnection())
{
    //连接参数
    string connectionString = ConfigurationManager.ConnectionStrings["PandaConn"].ToString();
    conn.ConnectionString = connectionString;

    //开启连接
    conn.Open();

    //检测连接信息
    if(conn.State == System.Data.ConnectionState.Open)
    {
        //创建命令
        SqlCommand sqlCommand = new SqlCommand();
        sqlCommand.Connection = conn;
        string sql = "";
        sqlCommand.CommandText = sql;
//如果是存储过程
//sqlCommand.CommandType = System.Data.CommandType.StoredProcedure;
    }

}

创建命令对象-直接创建2

using(SqlConnection conn = new SqlConnection())
{
    //连接参数
    string connectionString = ConfigurationManager.ConnectionStrings["PandaConn"].ToString();
    conn.ConnectionString = connectionString;

    //开启连接
    conn.Open();

    //检测连接信息
    if(conn.State == System.Data.ConnectionState.Open)
    {
        //创建命令
        string sql = "";
        SqlCommand sqlCommand = new SqlCommand(sql);
        sqlCommand.Connection = conn;
        
        //如果是存储过程
        //sqlCommand.CommandType = System.Data.CommandType.StoredProcedure;
    }
}

创建命令对象-直接创建3

using(SqlConnection conn = new SqlConnection())
{
    //连接参数
    string connectionString = ConfigurationManager.ConnectionStrings["PandaConn"].ToString();
    conn.ConnectionString = connectionString;

    //开启连接
    conn.Open();

    //检测连接信息
    if(conn.State == System.Data.ConnectionState.Open)
    {
        //创建命令
        string sql = "";
        SqlCommand sqlCommand = new SqlCommand(sql, conn);
        
        //如果是存储过程
        //sqlCommand.CommandType = System.Data.CommandType.StoredProcedure;
    }
}

创建命令对象-从连接对象创建

using(SqlConnection conn = new SqlConnection())
{
    //连接参数
    string connectionString = ConfigurationManager.ConnectionStrings["PandaConn"].ToString();
    conn.ConnectionString = connectionString;

    //开启连接
    conn.Open();

    //检测连接信息
    if(conn.State == System.Data.ConnectionState.Open)
    {
        //创建命令
        string sql = "";
        SqlCommand sqlCommand = conn.CreateCommand();
        sqlCommand.CommandText = sql;
        
        //如果是存储过程
        //sqlCommand.CommandType = System.Data.CommandType.StoredProcedure;
    }

}

设置连接

使用Connection属性

设置命令内容

使用CommandText属性
CommandText属性用于设置要对数据源执行的SQL语句或存储过程

设置命令的类型

使用CommandType属性
CommandType属性用于设置指定CommandText的类型
CommandType 属性的值是CommandType枚举值
StoredProcedure：存储过程的名称
TableDirect：表的名称
Text：SQL文本命令

绑定参数-新建参数对象1

//新建参数绑定
SqlParameter sqlParameter = new SqlParameter();
sqlParameter.ParameterName = "@ProductName";
sqlParameter.SqlDbType = SqlDbType.NVarChar;
sqlParameter.Size = 50;
sqlParameter.Value = "防护套2";
//添加参数绑定
sqlCommand.Parameters.Add(sqlParameter);

绑定参数-新建参数对象2

//新建参数绑定
SqlParameter sqlParameter = new SqlParameter("@ProductName", SqlDbType.NVarChar,50);
sqlParameter.Value = "防护套3";
//添加参数绑定
sqlCommand.Parameters.Add(sqlParameter);

绑定参数-快捷绑定参数

SqlCommand sqlCommand = new SqlCommand(sqlStr, conn);
//添加参数绑定
sqlCommand.Parameters.Add("@ProductName", SqlDbType.VarChar, 50).Value = "防护套";

绑定多个参数

//新建参数绑定
SqlParameter[] sqlParameters = new SqlParameter[]
{
    new SqlParameter("@ProductName",SqlDbType.NVarChar,50){Value = "保护套4"},
    new SqlParameter("@ProductName2",SqlDbType.NVarChar,500){Value = "保护套5"}
};
//添加参数绑定
sqlCommand.Parameters.AddRange(sqlParameters);

执行SQL语句（删除、插入、修改）

使用.ExecuteNonQuery()方法
返回受影响的行数
执行SQL语句，并返回受影响的行数，在使用SqlCommand向数据库发送增、删、改命令时，通常使用ExecuteNonQuery方法执行发送的SQL语句

执行SQL语句（查询）

使用.ExecuteReader()方法
执行SQL语句，并生成一个包含数据的SqlDataReader对象的实例
执行SQL语句（查询）（返回第一行第一列）
使用.ExecuteScalar()方法
通常与聚合函数一起使用

执行存储过程-输入参数

将CommandType属性设置为StoredProcedure
将CommandText属性设置为存储过程的名称

using System;
using System.Data;
using System.Data.SqlClient;
using System.Configuration;

namespace ConsoleApp2
{
    class Program
    {
        static void Main(string[] args)
        {
            using(SqlConnection conn = new SqlConnection())
            {
                //连接参数
                string connectionString = ConfigurationManager.ConnectionStrings["PandaConn"].ToString();
                conn.ConnectionString = connectionString;

                //开启连接
                conn.Open();

                //检测连接信息
                if(conn.State == System.Data.ConnectionState.Open)
                {
                    //创建命令
                    SqlCommand sqlCommand = new SqlCommand() {
                        Connection = conn,
                        CommandType = CommandType.StoredProcedure,
                        CommandText = "ProcedureName1"
                    };

                    //创建参数
                    SqlParameter sqlParameter = new SqlParameter()
                    {
                        ParameterName = "@arg1",
                        Value = "防护套2",
                        SqlDbType = SqlDbType.NVarChar,
                        Direction = ParameterDirection.Input
                    };

                    //添加参数绑定
                    sqlCommand.Parameters.Add(sqlParameter);
                    //不返回内容用这个
                    //int affectRows = sqlCommand.ExecuteNonQuery();
                    //返回一个标量用这个
                    //object someValue = sqlCommand.ExecuteScalar();
                    //返回集合用这个
                    SqlDataReader sqlDataReader = sqlCommand.ExecuteReader();

                    while(sqlDataReader.Read())
                    {
                        Console.WriteLine((int?)sqlDataReader["ProductId"] ?? -1);
                        Console.WriteLine((string)sqlDataReader["ProductName"] ?? "没有数据");
                    }
                }
            }

            //wait
            Console.ReadKey();
        }
    }
}

执行存储过程-输出参数

using System;
using System.Data;
using System.Data.SqlClient;
using System.Configuration;

namespace ConsoleApp2
{
    class Program
    {
        static void Main(string[] args)
        {
            using(SqlConnection conn = new SqlConnection())
            {
                //连接参数
                string connectionString = ConfigurationManager.ConnectionStrings["PandaConn"].ToString();
                conn.ConnectionString = connectionString;

                //开启连接
                conn.Open();

                //检测连接信息
                if(conn.State == System.Data.ConnectionState.Open)
                {
                    //创建命令
                    SqlCommand sqlCommand = new SqlCommand() {
                        Connection = conn,
                        CommandType = CommandType.StoredProcedure,
                        CommandText = "ProcedureName2"
                    };

                    //创建参数
                    SqlParameter sqlParameter = new SqlParameter()
                    {
                        ParameterName = "@arg1",
                        Value = 666,
                        SqlDbType = SqlDbType.Int,
                        Direction = ParameterDirection.InputOutput
                    };

                    //添加参数绑定
                    sqlCommand.Parameters.Add(sqlParameter);
                    //不返回内容用这个
                    int affectRows = sqlCommand.ExecuteNonQuery();
                    //获得输出参数的内容
                    Console.WriteLine(sqlParameter.Value);
                    //返回一个标量用这个
                    //object someValue = sqlCommand.ExecuteScalar();
                    //返回集合用这个
                    //SqlDataReader sqlDataReader = sqlCommand.ExecuteReader();
                }
            }
            //wait
            Console.ReadKey();
        }
    }
}

执行存储过程-返回值

using System;
using System.Data;
using System.Data.SqlClient;
using System.Configuration;

namespace ConsoleApp2
{
    class Program
    {
        static void Main(string[] args)
        {
            using(SqlConnection conn = new SqlConnection())
            {
                //连接参数
                string connectionString = ConfigurationManager.ConnectionStrings["PandaConn"].ToString();
                conn.ConnectionString = connectionString;

                //开启连接
                conn.Open();

                //检测连接信息
                if(conn.State == System.Data.ConnectionState.Open)
                {
                    //创建命令
                    SqlCommand sqlCommand = new SqlCommand() {
                        Connection = conn,
                        CommandType = CommandType.StoredProcedure,
                        CommandText = "ProcedureName3"
                    };

                    //创建参数
                    SqlParameter sqlParameter = new SqlParameter()
                    {
                        ParameterName = "@ReturnValue",
                        SqlDbType = SqlDbType.Int, //可以设置为存储过程返回的类型
                        Direction = ParameterDirection.ReturnValue
                    };

                    //添加参数绑定
                    sqlCommand.Parameters.Add(sqlParameter);
                    //不返回内容用这个
                    //int affectRows = sqlCommand.ExecuteNonQuery();
                    //返回一个标量用这个
                    object someValue = sqlCommand.ExecuteScalar();
                    Console.WriteLine((int?)sqlParameter.Value ?? -1);
                    //返回集合用这个
                    //SqlDataReader sqlDataReader = sqlCommand.ExecuteReader();
                }
            }

            //wait
            Console.ReadKey();
        }
    }
}

使用Command对象查询数据

using System;
using System.Data;
using System.Data.SqlClient;
using System.Configuration;

namespace ConsoleApp2
{
    class Program
    {
        static void Main(string[] args)
        {
            using(SqlConnection conn = new SqlConnection())
            {
                //连接参数
                string connectionString = ConfigurationManager.ConnectionStrings["PandaConn"].ToString();
                conn.ConnectionString = connectionString;

                //开启连接
                conn.Open();

                //检测连接信息
                if (conn.State == System.Data.ConnectionState.Open)
                {
                    //创建命令
                    SqlCommand sqlCommand = new SqlCommand() {
                        Connection = conn,
                        CommandText = "SELECT * FROM Product WHERE ProductId > @ProductId"
                    };

                    //创建参数
                    SqlParameter sqlParameter = new SqlParameter()
                    {
                        ParameterName = "@ProductId",
                        SqlDbType = SqlDbType.Int,
                        Value = 0
                    };

                    //添加参数绑定
                    sqlCommand.Parameters.Add(sqlParameter);

                    //返回集合
                    SqlDataReader sqlDataReader = sqlCommand.ExecuteReader();

                    while (sqlDataReader.Read())
                    {
                        Console.WriteLine((int?)sqlDataReader["ProductId"] ?? -1);
                        Console.WriteLine((string)sqlDataReader["ProductName"] ?? "没有数据");
                    }
                }
            }

            //wait
            Console.ReadKey();
        }
    }
}

使用Command对象插入数据

using System;
using System.Data;
using System.Data.SqlClient;
using System.Configuration;

namespace ConsoleApp2
{
    class Program
    {
        static void Main(string[] args)
        {
            using(SqlConnection conn = new SqlConnection())
            {
                //连接参数
                string connectionString = ConfigurationManager.ConnectionStrings["PandaConn"].ToString();
                conn.ConnectionString = connectionString;

                //开启连接
                conn.Open();

                //检测连接信息
                if (conn.State == System.Data.ConnectionState.Open)
                {
                    //创建命令
                    SqlCommand sqlCommand = new SqlCommand() {
                        Connection = conn,
                        CommandText = "INSERT INTO Product VALUES(@ProductName)"
                    };

                    //创建参数
                    SqlParameter sqlParameter = new SqlParameter()
                    {
                        ParameterName = "@ProductName",
                        SqlDbType = SqlDbType.NVarChar,
                        Value = "有意思的宝贝"
                    };

                    //添加参数绑定
                    sqlCommand.Parameters.Add(sqlParameter);
                    int affectRows = sqlCommand.ExecuteNonQuery();
                    Console.WriteLine(affectRows);
                }
            }

            //wait
            Console.ReadKey();
        }
    }
}

使用Command对象修改数据

using System;
using System.Data;
using System.Data.SqlClient;
using System.Configuration;

namespace ConsoleApp2
{
    class Program
    {
        static void Main(string[] args)
        {
            using(SqlConnection conn = new SqlConnection())
            {
                //连接参数
                string connectionString = ConfigurationManager.ConnectionStrings["PandaConn"].ToString();
                conn.ConnectionString = connectionString;

                //开启连接
                conn.Open();

                //检测连接信息
                if (conn.State == System.Data.ConnectionState.Open)
                {
                    //创建命令
                    SqlCommand sqlCommand = new SqlCommand() {
                        Connection = conn,
                        CommandText = "UPDATE Product SET ProductName = @ProductName WHERE ProductId = @ProductId"
                    };

                    //创建参数
                    SqlParameter[] sqlParameters = new SqlParameter[]
                    {
                        new SqlParameter(){
                            ParameterName = "@ProductName",
                            SqlDbType = SqlDbType.NVarChar,
                            Value = "有意思的宝贝2"
                        },
                        new SqlParameter(){
                            ParameterName = "@ProductId",
                            SqlDbType = SqlDbType.Int,
                            Value = 6
                        },
                    };

                    //添加参数绑定
                    sqlCommand.Parameters.AddRange(sqlParameters);
                    int affectRows = sqlCommand.ExecuteNonQuery();
                    Console.WriteLine(affectRows);
                }
            }

            //wait
            Console.ReadKey();
        }
    }
}

使用Command对象删除数据

using System;
using System.Data;
using System.Data.SqlClient;
using System.Configuration;

namespace ConsoleApp2
{
    class Program
    {
        static void Main(string[] args)
        {
            using(SqlConnection conn = new SqlConnection())
            {
                //连接参数
                string connectionString = ConfigurationManager.ConnectionStrings["PandaConn"].ToString();
                conn.ConnectionString = connectionString;

                //开启连接
                conn.Open();

                //检测连接信息
                if (conn.State == System.Data.ConnectionState.Open)
                {
                    //创建命令
                    SqlCommand sqlCommand = new SqlCommand() {
                        Connection = conn,
                        CommandText = "DELETE FROM Product WHERE ProductId = @ProductId"
                    };

                    //创建参数
                    SqlParameter sqlParameter = new SqlParameter()
                    {
                        ParameterName = "@ProductId",
                        SqlDbType = SqlDbType.Int,
                        Value = 6
                    };

                    //添加参数绑定
                    sqlCommand.Parameters.Add(sqlParameter);
                    int affectRows = sqlCommand.ExecuteNonQuery();
                    Console.WriteLine(affectRows);
                }
            }

            //wait
            Console.ReadKey();
        }
    }
}

SqlParameter类型

SqlParameter类型说明

主要成员

ParameterName 参数名
Value 参数值
Size 参数大小(只对文本类型有效)
Direction 参数的方向(输入、输出、双向、返回值)
DbType 参数类型
IsNullable 参数可否为Null

实例

//建立连接
SqlConnection conn = new SqlConnection();
conn.ConnectionString = @"Server=localhost;Database=Panda;Uid=sa;Password=password";
//打开连接
conn.Open();
//建立命令
SqlCommand comm = conn.CreateCommand();
string sql = @"SELECT * FROM PandaTest2 WHERE Name = @name";
comm.CommandText = sql;
//配置参数
SqlParameter param = new SqlParameter();
param.ParameterName = "@name";
param.Value = "panda";
param.Direction = ParameterDirection.Input;
param.DbType = DbType.String;
//添加参数
comm.Parameters.Add(param);
//执行命令
SqlDataReader reader = comm.ExecuteReader();
//读取数据
while (reader.Read())
{
    Console.WriteLine("{0} => {1}", reader["Id"], reader["Name"]);
}
//释放
reader.Close();
conn.Close();

DataAdaper类型

DataAdapter说明

数据适配器

从数据库填充DataSet

提交DataSet到数据库

构造函数

new SqlDataAdapter();
new SqlDataAdapter(SqlCommand selectCommand);
new SqlDataAdapter(string selectCommandString,string connectionString);
new SqlDataAdapter(string selectCommandString,SqlConnection connection);

主要成员

.SelectCommand 向数据库发送查询的SQL语句

.InsertCommand 向数据库发送插入的SQL语句

.UpdateCommand 向数据库发送更新的SQL语句

.DeleteCommand 向数据库发送删除的SQL语句

.Fill() 执行SQL Select命令,填充数据到DataSet

.Update() 执行SQL Insert、Update、Delete命令,将DataSet的修改保存到数据库

实例

填充数据到DataSet

//连接字符串
string cnStr = @"Server=localhost;Database=Panda;UId=sa;Password=password";
//建立适配器
SqlDataAdapter adp = new SqlDataAdapter("select * from PandaTable2",cnStr);
//DataSet
DataSet set = new DataSet("set");
//填充
adp.Fill(set, "PandaTable");

自动生成更新Sql语句

//连接字符串
string cnStr = @"Server=localhost;Database=Panda;UId=sa;Password=password";
//建立适配器
SqlDataAdapter adp = new SqlDataAdapter("select * from PandaTable2",cnStr);
//自动生成更新Sql语句
SqlCommandBuilder builder = new SqlCommandBuilder(adp);
//DataSet
DataSet set = new DataSet("set");
//填充
adp.Fill(set, "PandaTable");

更新DataSet到数据库

//连接字符串
string cnStr = @"Server=localhost;Database=Panda;UId=sa;Password=password";
//建立适配器
SqlDataAdapter adp = new SqlDataAdapter("select * from PandaTable2",cnStr);
//自动生成更新Sql语句
SqlCommandBuilder builder = new SqlCommandBuilder(adp);
//DataSet
DataSet set = new DataSet("set");
//填充DataSet
adp.Fill(set, "PandaTable");
//更新DataSet
adp.Update(set);

使用DataTableMapping映射友好名字

//连接字符串
string cnStr = @"Server=localhost;Database=Panda;UId=sa;Password=password";
//建立适配器
SqlDataAdapter adp = new SqlDataAdapter("select * from PandaTable2",cnStr);
//DataSet
DataSet set = new DataSet("set");
//为表建立映射
DataTableMapping mapping = adp.TableMappings.Add("PandaTable", "Panda Table");
mapping.ColumnMappings.Add("Id", "编号");
mapping.ColumnMappings.Add("Name","姓名");
//填充
adp.Fill(set, "PandaTable");

DataReader类型

DataReader类型说明

数据读取器对象，提供只读向前的游标

该对象不可以直接实例化

只能通过ExecuteReader返回获得

如果应用程序需要每次从数据库中取出最新的数据，或者只是需要快速读取数据，并不需要修改数据，那么就可以使用DataReader对象进行读取

对于不同的数据库连接，有不同的DataReader类型

在System.Data.SqlClient命名空间下时，可以调用SqlDataReader类

在System.Data.OleDb命名空间下时，可以调用OleDbDataReader类

在System.Data.Odbc命名空间下时，可以调用OdbcDataReader类

在System.Data.Oracle命名空间下时，可以调用OracleDataReader类

主要成员

Read() 返回bool指示是否还有数据

Close() 关闭读取器

[] 索引获得每行的列值(可以是数值索引或者列名索引)

GetBytes() 索引访问,binary,varbinary,long varbinary,Image,timestamp

GetByte() 索引访问,tinyint

GetInt16() 索引访问,smallint

GetInt32() 索引访问,int

GetInt64() 索引访问,bigint

GetDecimal() 索引访问,decimal,money,numeric,smallmoney

GetFloat() 索引访问,real

GetDouble() 索引访问,float

GetChars() 索引访问,char,varchar,nchar,long varchar,nvarchar,ntext

GetString() 索引访问,char,varchar,nchar,long varchar,nvarchar,ntext

GetBoolean() 索引访问,bit

GetDateTime() 索引访问,datetime,smalldatetime

GetValue() 索引访问,sql_variant

GetGuid() 索引访问,uniqueidentifier

.Depth 获得行深度

.FieldCount 获得列数量

.GetDataTypeName(index) 获得指定index列的SqlServer数据类型

.GetFieldType(index) 获得指定index列的.net数据类型

.GetName(index) 获得指定index列的列名

.GetOrdinal(String) 获得指定列名的index

.GetSchemaTable() 获得DataTable对象(获得结果集合的表结构信息)

.HasRows 是否有行

.RecordsAffected 检测是否有行变化

.NextResult() 切换到下一个结果集合(用于多SELECT语句)

检测结果集中是否有数据

使用.HasRows属性即可

使用ExecuteReader()方法读取数据库

此方法返回一个DataReader对象

using System;
using System.Data;
using System.Data.SqlClient;

namespace Test
{
    class TestClass
    {
        public static void Main()
        {
            try
            {
                //连接字符串
                string conStr = @"Server='(local)';database='mydb';uid='sa';pwd='pwd'";
                //连接对象
                SqlConnection sqlConnection = new SqlConnection(conStr);
                //开启连接
                sqlConnection.Open();

                //sql命令
                string sqlStr = @"select * from someTable";
                //命令对象
                SqlCommand sqlCommand = new SqlCommand(sqlStr, sqlConnection);
                //读取数据,获得读取对象
                SqlDataReader dataReader = sqlCommand.ExecuteReader();

                //遍历数据
                while (dataReader.Read())
                {
                    //通过索引式访问
                    Console.WriteLine(dataReader[0].ToString());
                    //通过列名访问
                    Console.WriteLine(dataReader["Name"].ToString());
                }

                //关闭连接
                sqlConnection.Close();
                //释放命令对象
                sqlCommand.Dispose();
                //关闭读取对象
                dataReader.Close();
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
            }
            
            Console.ReadKey();
        }
    }
}

使用ExecuteNonQuery()操作操作数据库

该方法返回一个整数数值，表示操作影响的条数

using System;
using System.Data;
using System.Data.SqlClient;

namespace Test
{
    class TestClass
    {
        public static void Main()
        {
            try
            {
                //连接字符串
                string conStr = @"Server='(local)';database='mydb';uid='sa';pwd='pwd'";
                //连接对象
                SqlConnection sqlConnection = new SqlConnection(conStr);
                //开启连接
                sqlConnection.Open();

                //sql命令
                string sqlStr = @"INSERT INTO tableName VALUES(*,*)";
                //命令对象
                SqlCommand sqlCommand = new SqlCommand(sqlStr, sqlConnection);
                //操作数据
                int affectRows = sqlCommand.ExecuteNonQuery();

                Console.WriteLine(affectRows);

                //关闭连接
                sqlConnection.Close();
                //释放命令对象
                sqlCommand.Dispose();
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
            }
            
            Console.ReadKey();
        }
    }
}

使用ExecuteScalar()方法读取数据库第一行第一列

该方法返回一个object类型

获得列的序号

使用dataReader.GetOrdinal()方法

using System;
using System.Data;
using System.Data.SqlClient;

namespace Test
{
    class TestClass
    {
        public static void Main()
        {
            try
            {
                //连接字符串
                string conStr = @"Server='(local)';database='mydb';uid='sa';pwd='pwd'";
                //连接对象
                SqlConnection sqlConnection = new SqlConnection(conStr);
                //开启连接
                sqlConnection.Open();

                //sql命令
                string sqlStr = @"select * from someTable";
                //命令对象
                SqlCommand sqlCommand = new SqlCommand(sqlStr, sqlConnection);
                //读取数据,获得读取对象
                SqlDataReader dataReader = sqlCommand.ExecuteReader();

                //获得列序号
                int columnId = dataReader.GetOrdinal("CloumnName");

                Console.WriteLine(columnId);

                //关闭连接
                sqlConnection.Close();
                //释放命令对象
                sqlCommand.Dispose();
                //关闭读取对象
                dataReader.Close();
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
            }
            
            Console.ReadKey();
        }
    }
}

关闭读取器

使用.Close()方法

DataException类型

.NET Framework可配置式连接字符串

配置说明

打开App.config文件添加内容

可以在节点或者节点配置

在节点配置

配置文件

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
    <startup> 
        <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.7.2" />
    </startup>
    <appSettings>
        <add key="PandaConn" value="Server=m1.dogdog.com;Database=dogDb;Uid=sa;Pwd=101asd8asd1qas"/>
    </appSettings>
</configuration>

代码文件

注意：需要引入System.Configuration命名空间

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Data.SqlClient;
using System.Configuration;

namespace ConsoleApp2
{
    class Program
    {
        static void Main(string[] args)
        {

            //定义一个连接
            using (SqlConnection conn = new SqlConnection())
            {
                //获得连接配置字符串
                string connStr = ConfigurationManager.AppSettings["PandaConn"];
                //赋值给连接对象
                conn.ConnectionString = connStr;

                //打开连接
                conn.Open();

                //检测是否连接完成
                if(conn.State == System.Data.ConnectionState.Open)
                {
                    //进行操作
                    Console.WriteLine(conn.State);
                    Console.WriteLine(conn.ConnectionString);
                    Console.WriteLine(conn.Database);
                }
            }

            //wait
            Console.ReadKey();
        }
    }
}

在< connectionStrings >节点配置

配置文件

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
    <startup> 
        <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.7.2" />
    </startup>
    <connectionStrings>
        <add name="PandaConn" connectionString="Server=m1.dogdog.com;Database=dogDb;Uid=sa;Pwd=password" providerName="System.Data.SqlClient"/>
    </connectionStrings>
</configuration>

代码文件

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Data.SqlClient;
using System.Configuration;

namespace ConsoleApp2
{
    class Program
    {
        static void Main(string[] args)
        {

            //定义一个连接
            using (SqlConnection conn = new SqlConnection())
            {
                //获得连接配置字符串
                string connStr = ConfigurationManager.ConnectionStrings["PandaConn"].ToString();
                //赋值给连接对象
                conn.ConnectionString = connStr;
    
                //打开连接
                conn.Open();
    
                //检测是否连接完成
                if(conn.State == System.Data.ConnectionState.Open)
                {
                    //进行操作
                    Console.WriteLine(conn.State);
                    Console.WriteLine(conn.ConnectionString);
                    Console.WriteLine(conn.Database);
                }
            }
    
            //wait
            Console.ReadKey();
        }
    }
}

连接池

说明

默认情况下，连接池是启用的

使用连接字符串可以配置连接池的一些参数

Pooling = true | false; #关闭或开启连接池
Max Pool Size = 5；  #最大连接数
Min Pool Size = 0；  #最小连接数

注意：连接池最大连接数默认是100

注意：连接字符串只要是有一点点差异都是不同的连接字符串，包括一个空格！

配置参数实例：

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
    <startup>
        <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.7.2" />
    </startup>
    <connectionStrings>
        <add name="PandaConn" connectionString="Server=m1.dogdog.com;Database=dogDb;Uid=sa;Pwd=1sd1123asd;Max Pool Size = 205;Min Pool Size = 0;" providerName="System.Data.SqlClient"/>
    </connectionStrings>
</configuration>

使用连接池的作用（为什么使用连接池）

可以有效的减少因为连接的开启和释放引起的性能损耗和时间消耗

实例：对比没有连接池和有连接池的性能差异

using System;
using System.Data.SqlClient;
using System.Diagnostics;

namespace ConsoleApp2
{
    class Program
    {
        static void Main(string[] args)
        {
            //开启连接池的连接（默认）
            string connStr1 = "Server=m1.dogdog.com;Database=dogDb;Uid=sa;Pwd=abc;Max Pool Size = 205;Min Pool Size = 0;";
            //关闭连接池的连接
            string connStr2 = "Server=m1.dogdog.com;Database=dogDb;Uid=sa;Pwd=abc;Pooling=false;";

            //设置时间检测
            Stopwatch stopwatch = new Stopwatch();
            stopwatch.Start();
            for (int i = 0; i < 100; i++)
            {
                //定义一个连接
                SqlConnection conn = new SqlConnection(connStr1);
                //打开连接
                conn.Open();
                //检测是否连接完成
                if (conn.State == System.Data.ConnectionState.Open)
                {
                }
            }
            stopwatch.Stop();
            Console.WriteLine("运行的时间消耗 {0} 秒", stopwatch.ElapsedMilliseconds / 1000);

            //设置时间检测
            Stopwatch stopwatch2 = new Stopwatch();
            stopwatch2.Start();
            for (int i = 0; i < 100; i++)
            {
                //定义一个连接
                SqlConnection conn = new SqlConnection(connStr2);
                //打开连接
                conn.Open();
                //检测是否连接完成
                if (conn.State == System.Data.ConnectionState.Open)
                {
                }
            }
            stopwatch2.Stop();
            Console.WriteLine("运行的时间消耗 {0} 秒", stopwatch2.ElapsedMilliseconds / 1000);

            //wait
            Console.ReadKey();
        }
    }
}

posted @ 2022-10-08 07:35 重庆熊猫阅读(542) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

重庆熊猫 Loading

重庆熊猫

wx：wdfysoft

.NET教程-ADO.NET

基础知识

ADO.NET介绍

ADO. NET作用

ADO.NET官方文档

程序常用连接数据库的三种方式

ADO.NET的工作模式

说明

连接式模式说明

非连接式模式说明

ADO.NET类比解释

各类型代表内容

Entity Framework模式说明

ADO.NET的组成

所在程序集文件

命名空间

主要包含类

ADO.NET与外部通信结构图

ADO.NET内部类图

ADO.NET内部类工作原理图

ADO.NET数据提供程序

说明

ADO.NET数据提供程序的基类和接口

SqlServer常用类

OleDb常用类

Odbc常用类

使用ADO.NET提供的工厂模式创建连接

说明

工厂模式适合场景

工厂模式存在问题

工厂模式实例

配置文件处理

Program.cs

使用ADO.NET连接层进行创建连接

连接式工作结构图

使用连接层创建连接的步骤

使用连接层相关的类型

连接层实例(面向SqlServer实现)

配置文件中添加

Program.cs

使用连接字符串对象

DataReader和DataSet的区别

使用参数化对象

作用

实例

配置文件中添加

program.cs

调用SQL Server存储过程

存储过程说明

存储过程实例

实现SQL Server事务

实现SQL Server事务的方式

Transaction主要成员

事务实例

配置文件中添加

program.cs

ADO.NET断开式工作模式

断开式工作模式说明

断开式访问和连接式区别

DataTable类型

说明

构造函数

主要成员

DataTable主要成员

DataTable的逻辑结构和物理结构

DataTable内部组成

实例

实例化DataTable

设置表主键

将表插入到DataSet中

输出表中的列域

输出表中数据(行使用列名)

输出表中数据(行使用索引)

输出表中数据(使用列索引号遍历)

输出表中数据(使用读取器)

DataTable序列化为XML文件

从二进制文件读取DataTable