ToB企服应用市场:ToB评测及商务社交产业平台

标题: Ado.Net 数据库访问技术(.Net 6版本) [打印本页]
作者: 飞不高    时间: 2023-5-31 15:43
标题: Ado.Net 数据库访问技术(.Net 6版本)
1. ADO.NET的前世今生

ADO.NET的名称起源于ADO（ActiveX Data Objects），是一个COM组件库，用于在以往的Microsoft技术中访问数据。之所以使用ADO.NET名称，是因为Microsoft希望表明，这是在NET编程环境中优先使用的数据访问接口。
ADO.NET可让开发人员以一致的方式存取资料来源（例如 SQL Server 与 XML），以及透过 OLE DB 和 ODBC 所公开的资料来源。资料共用的消费者应用程序可使用ADO.NET 来连接至这些资料来源，并且撷取、处理及更新其中所含的资料。
ADO.NETt可将资料管理的资料存取分成不连续的元件，这些元件可分开使用，也可串联使用ADO.NET也包含 .NET Framework 资料提供者，以用于连接资料库、执行命令和撷取结果。这些结果会直接处理、放入ADO.NET DataSet 物件中以便利用机器操作 （Ad Hoc）的方式公开给使用者、与多个来源的资料结合，或在各层之间进行传递。DataSet 物件也可以与.NET Framework 资料提供者分开使用，以便管理应用程序本机的资料或来自 XML 的资料。
ADO.NET类别 （Class） 位于 System.Data.dll 中，而且会与 System.Xml.dll 中的XML 类别整合。
ADO.NET可为撰写 Managed 程式码的开发人员提供类似于ActiveX Data Objects （ADO）提供给原生元件物件模型 （Component Object Model，COM）开发人员的功能。建议使用ADO.NET而非ADO来存取.NET 应用程序中的资料。
ADO .NET会提供最直接的方法，让开发人员在 .NET Framework 中进行资料存取。
 
现阶段我们以SqlServer 为案例进行讲解。
 
Ado.Net 优点

执行效率高。任何ORM框架（对象关系映射，理解为一种可提高访问数据库开发效率的一种框架），在Ado.net 面前都是弟弟， ado.net 作为原装的直接跟数据库打交道，直接操作数据库，没有进行额外的封装。比如我们可以直接执行sql语句，直接调用存储过程。直接操作DataSet数据集等等数据。
 
缺点：
 
2. Connection 连接对象

Connection 是数据库连接对象，用于与数据库建立连接。SqlServer 连接类是SqlConnection , MySql 的连接类是MySqlConnection, Oracle 数据库连接类是 OracleConnection ，这些类都实现了IDbConnection接口。
1. SqlConnection 类

通过Nuget 将 System.Data.SqlClient 程序集引用到项目中
 
构造方法:
SqlConnection()初始化 SqlConnection 类的新实例。SqlConnection(String)如果给定包含连接字符串的字符串，则初始化 SqlConnection 类的新实例。SqlConnection(String, SqlCredential)在给定连接字符串的情况下，初始化 SqlConnection 类的新实例，该连接字符串不使用 Integrated Security = true 和包含用户 ID 和密码的 SqlCredential 对象。 
属性：
属性名描述ConnectionString连接字符串State只读，连接状态Database只读，当前连接的数据库ServerVersion只读，当前客户端连接的SQLServer的版本ConnectionTimeout尝试建立连接时终止尝试并生成错误之前所等待的时间（以秒为单位）,默认15秒 
常用方法：
方法名描述Open()使用由 ConnectionString 指定的属性设置打开一个数据库连接。Close()关闭与数据库之间的连接。 此方法是关闭任何打开连接的首选方法。Dispose()执行与释放或重置非托管资源关联的应用程序定义的任务。BeginTransaction()开始数据库事务。BeginTransaction(IsolationLevel)以指定的隔离级别启动数据库事务。BeginTransaction(IsolationLevel,string)以指定的隔离级别和事务名称启动数据库事务。CreateCommand()创建并返回与 SqlConnection 关联的 SqlCommand 对象。 
2. 修改超时时间
  1. SqlConnection connection =
  2. new SqlConnection("server=.;uid=sa;pwd=123456;database=unit21;timeout=30;");
  3. connection.Open();
  4. Console.WriteLine($"ConnectionTimeout={connection.ConnectionTimeout}");
  5. connection.Close();
复制代码
 
输入结果：
  1. ConnectionTimeout=30
复制代码
 
3. SqlCredential 类

提供了更安全的方式来指定使用 SQL Server 身份验证尝试登录的密码。 由用户 ID 和将用于 SQL Server 身份验证的密码构成。 SqlCredential 对象中的密码是 SecureString 类型(一种加密文本)。
如果调用ChangePassword() 方法修改SqlCredential对象时将会影响连接池 ，因为不对的SqlCredential 实例 将使用不同的连接池，即使用户 ID 和密码相同，也是如此 。
如果SqlCredential 对象非空 并且连接字符串中出现如下关键字，将会引发 InvalidOperationException 异常：
 
winform 案例：
  1. System.Windows.Controls.TextBox txtUserId = new System.Windows.Controls.TextBox();  
  2. System.Windows.Controls.PasswordBox txtPwd = new System.Windows.Controls.PasswordBox();  
  3. ​
  4. ​
  5. SqlConnection conn = new SqlConnection("server=.;database=unit21;");
  6. SecureString pwd = txtPwd.SecurePassword;  
  7. pwd.MakeReadOnly();  
  8. SqlCredential cred = new SqlCredential(txtUserId.Text, pwd);  
  9. conn.Credential = cred;  
  10. conn.Open();  
  11. // ...
  12. conn.close();
复制代码
3. 自动释放（推荐）

using

实现了IDispose 接口的类，都可以使用using 来实现自动释放资源功能。
  1. /* *
  2. * using : 引用命名空间
  3. * using: 释放资源
  4. *
  5. * 1. 为什么以前我们定义的变量不需要释放资源呢？
  6. * GC: 垃圾回收器，这里面封装了一些算法规定了什么时候去回收资源。我们自己定义一些变量，不需要关心它有没有释放掉，因为GC会帮我们自动回收资源
  7. *
  8. * 2. 既然已经有了GC,为什么还需要手动的释放资源呢？
  9. * 答：GC 只能回收托管资源（由.Net CLR管理的资源），而SqlConnection是属于非托管资源
  10. *
  11. * 3. 我怎么知道它是非托管？
  12. * 答：如果它实现了IDisposable 接口，那么我们就可以使用using 来手动的释放资源了
  13. */
  14. ​
  15. using (SqlConnection connection = new SqlConnection("server=.;uid=sa;pwd=123456;database=unit21;timeout=30"))
  16. {
  17.     connection.Open();// 打开连接
  18.     Console.WriteLine($"State={connection.State}");
  19.     Console.WriteLine($"DataBase={connection.Database}");
  20.     Console.WriteLine($"ServerVersion={connection.ServerVersion}");
  21.     Console.WriteLine($"DataSource={connection.DataSource}");
  22.     Console.WriteLine($"ConnectionTimeout={connection.ConnectionTimeout}");
  23. } // 并未调用close()方法，但会自动关闭
复制代码
 
C# 7.0 以后的语法：
  1. using SqlConnection connection = new SqlConnection("server=.;uid=sa;pwd=123456;database=unit21;timeout=30");
  2. connection.Open();// 打开连接
  3. Console.WriteLine($"State={connection.State}");
  4. Console.WriteLine($"DataBase={connection.Database}");
  5. Console.WriteLine($"ServerVersion={connection.ServerVersion}");
  6. Console.WriteLine($"DataSource={connection.DataSource}");
  7. Console.WriteLine($"ConnectionTimeout={connection.ConnectionTimeout}");
复制代码
connection 会在它当前的代码块结束处（作用域的结尾）自动调用关闭连接代码。
 
4. Command 命令对象

Command 是数据库命令对象，它是数据库执行的一个 Transact-SQL 语句或存储过程 。SqlServer 连接类是SqlCommand , MySql 的连接类是MySqlCommand, Oracle 数据库连接类是 OracleCommand ，这些类都实现了IDbCommand接口。
 
1. SqlCommand 类

 
构造方法：
SqlCommand()初始化 SqlCommand 类的新实例。SqlCommand(String)使用查询的文本初始化 SqlCommand 类的新实例。SqlCommand(String, SqlConnection)使用查询的文本和 SqlConnection 初始化 SqlCommand 类的新实例。SqlCommand(String, SqlConnection, SqlTransaction)使用查询文本、SqlConnection 以及 SqlTransaction 初始化 SqlCommand 类的新实例。常用属性：
CommandText获取或设置要在数据源中执行的 Transact-SQL 语句、表名或存储过程。CommandTimeout获取或设置在终止尝试执行命令并生成错误之前的等待时间（以秒为单位）。CommandType获取或设置一个值，该值指示解释 CommandText 属性的方式。Connection获取或设置 SqlCommand 的此实例使用的 SqlConnection。Parameters获取 SqlParameterCollection。Transaction获取或设置要在其中执行 SqlTransaction 的 SqlCommand。常用方法：
方法名描述Cancel()尝试取消 SqlCommand 的执行。CreateParameter()创建 SqlParameter 对象的新实例。Dispose()执行与释放或重置非托管资源关联的应用程序定义的任务。(继承自 DbCommand)Dispose(Boolean)释放由 DbCommand 占用的非托管资源，还可以另外再释放托管资源。(继承自 DbCommand)ExecuteNonQuery()对连接执行 Transact-SQL 语句并返回受影响的行数。ExecuteScalar()执行查询，并返回查询所返回的结果集中第一行的第一列。 忽略其他列或行。ExecuteReader()将 CommandText 发送到 Connection，并生成 SqlDataReader。 
案例1：
  1. using SqlConnection connection = new SqlConnection("server=.;uid=sa;pwd=123456;database=unit21;timeout=30");
  2. connection.Open();
  3. using SqlCommand cmd = new SqlCommand();
  4. cmd.Connection = connection;
  5. cmd.CommandText = $"insert into product values('枸杞',18)";
  6. cmd.ExecuteNonQuery();// 执行
复制代码
案例2：
  1. using SqlConnection connection = new SqlConnection("server=.;uid=sa;pwd=123456;database=unit21;timeout=30");
  2. connection.Open();
  3. using SqlCommand cmd = new SqlCommand("select count(id) from product");
  4. cmd.Connection = connection;
  5. object count = cmd.ExecuteScalar();// 获取首行首列
复制代码
案例3：
  1. using SqlConnection connection = new SqlConnection("server=.;uid=sa;pwd=123456;database=unit21;timeout=30");
  2. connection.Open();
  3. using SqlCommand cmd = new SqlCommand("select * from product",connection);
  4. using SqlDataReader dataReader = cmd.ExecuteReader(); // 返回一个读取对象
复制代码
5. SqlDataReader 数据读取

提供一种从 SQL Server 数据库中读取只进的行流的方式 。 在读取数据的过程中需要一直与数据库保持连接，适合数据量小的情况，执行效率还是可以的。 我们将SqlDataReader 读取数据的方式称为连接模式。
属性

Connection获取与 SqlConnection 关联的 SqlDataReader。Depth获取一个值，用于指示当前行的嵌套深度。FieldCount获取当前行中的列数。HasRows获取一个值，该值指示 SqlDataReader 是否包含一行还是多行。IsClosed检索一个布尔值，该值指示是否已关闭指定的 SqlDataReader 实例。Item[Int32]在给定列序号的情况下，获取指定列的以本机格式表示的值。Item[String]在给定列名称的情况下，获取指定列的以本机格式表示的值。RecordsAffected获取执行 Transact-SQL 语句所更改、插入或删除的行数。VisibleFieldCount获取 SqlDataReader 中未隐藏的字段的数目。方法

Close()关闭 DbDataReader 对象。Dispose()释放 DbDataReader 类的当前实例所使用的所有资源。GetName(Int32)获取指定列的名称。GetOrdinal(String)在给定列名时获取相应的列序号。Read()让 SqlDataReader 前进到下一条记录,返回bool。还有很多方法，他们都是根据列序列号获取指定列的功能，如：GetInt(int index),GetFloat(int index),GetDateTime(int index),GetString(int index) .....
案例

案例1：
  1. using SqlConnection connection = new SqlConnection("server=.;uid=sa;pwd=123456;database=unit21;timeout=30");
  2. connection.Open();
  3. using SqlCommand cmd = new SqlCommand("select * from product",connection);
  4. using SqlDataReader dataReader = cmd.ExecuteReader();
  5. ​
  6. while (dataReader.Read())
  7. {
  8.     object id = dataReader.GetValue("id");
  9.     object pname = dataReader.GetValue("pname");
  10.     object price = dataReader.GetValue("price");
  11. ​
  12.     Console.WriteLine($"id: {id}\t pname: {pname}\t price: {price}\t \n");
  13. }
复制代码
案例2，通过dataReader 索引读取：
  1. using SqlConnection connection = new SqlConnection("server=.;uid=sa;pwd=123456;database=unit21;timeout=30");
  2. connection.Open();
  3. using SqlCommand cmd = new SqlCommand("select * from product",connection);
  4. using SqlDataReader dataReader = cmd.ExecuteReader();
  5. ​
  6. while (dataReader.Read())
  7. {
  8.     // 索引下标顺序必须与数据库列顺序一致
  9.     object id = dataReader[0];
  10.     object pname = dataReader[1];
  11.     object price = dataReader[2];
  12. ​
  13.     Console.WriteLine($"id: {id}\t pname: {pname}\t price: {price}\t \n");
  14. }
复制代码
 
案例3，封装成对象:
  1. using SqlConnection connection = new SqlConnection("server=.;uid=sa;pwd=123456;database=unit21;timeout=30");
  2. connection.Open();
  3. using SqlCommand cmd = new SqlCommand("select * from product",connection);
  4. using SqlDataReader dataReader = cmd.ExecuteReader();
  5. ​
  6. while (dataReader.Read())
  7. {
  8.     // 索引下标顺序必须与数据库列顺序一致
  9.     Product product = new Product(
  10.         dataReader.GetInt32(0),
  11.         dataReader.GetString(1),
  12.         dataReader.GetInt32(2)
  13.     );
  14. ​
  15.     Console.WriteLine($"id: {product.Id}\t pname: {product.Name}\t price: {product.Price}\t \n");
  16. }
  17. ​
  18. record Product(int Id,string Name,int Price);
复制代码
6. SqlDataAdapter 适配器

适配器详细介绍

表示用于填充 DataSet （表示数据的内存中的数据库，它可以由多个table组成）和更新 SQL Server 数据库的一组数据命令和一个数据库连接。 适配器模式也被称为断开模式。
 
一次连接取得数据之后，即可断开，在用户非常多的情况下，不会占用太多的连接池资源。 还有一点，就是一次性的从数据库中取得了数据之后，这些数据是存在内存中的，而不会再去操作数据库，所以你对这些数据做任何的操作，都只是修改内存，不会改变数据库中的内容。
 
构造方法：
SqlDataAdapter()初始化 SqlDataAdapter 类的新实例。SqlDataAdapter(SqlCommand)初始化 SqlDataAdapter 类的新实例，用指定的 SqlCommand 作为 SelectCommand 的属性。SqlDataAdapter(String, SqlConnection)使用 SqlDataAdapter 和 SelectCommand 对象初始化 SqlConnection 类的一个新实例(用得最多)。SqlDataAdapter(String, String)用 SqlDataAdapter 和一个连接字符串初始化 SelectCommand 类的一个新实例。属性：
DeleteCommand获取或设置一个 Transact-SQL 语句或存储过程，以从数据集删除记录。InsertCommand获取或设置一个 Transact-SQL 语句或存储过程，以在数据源中插入新记录。SelectCommand获取或设置一个 Transact-SQL 语句或存储过程，用于在数据源中选择记录。UpdateBatchSize获取或设置每次到服务器的往返过程中处理的行数。UpdateCommand获取或设置一个 Transact-SQL 语句或存储过程，用于更新数据源中的记录。 
案例1：
  1. using SqlConnection connection =
  2.     new SqlConnection("server=.;uid=sa;pwd=123456;database=unit21");
  3. ​
  4. using SqlDataAdapter adapter = new SqlDataAdapter();
  5. using SqlCommand cmd = new SqlCommand("select * from product");
  6. cmd.Connection = connection;
  7. adapter.SelectCommand = cmd;
  8. DataSet ds = new DataSet();
  9. adapter.Fill(ds); // 填充数据
  10. Console.WriteLine(ds.Tables[0].Rows.Count);
复制代码
 
案例2：
  1. using SqlConnection connection =
  2.     new SqlConnection("server=.;uid=sa;pwd=123456;database=unit21");
  3. using SqlCommand cmd = new SqlCommand("select * from product",connection);
  4. using SqlDataAdapter adapter = new SqlDataAdapter(cmd);
  5. DataSet ds = new DataSet();
  6. adapter.Fill(ds);
  7. Console.WriteLine(ds.Tables[0].Rows.Count);
复制代码
 
案例3：
  1. using SqlConnection connection =
  2.     new SqlConnection("server=.;uid=sa;pwd=123456;database=unit21");
  3. using SqlDataAdapter adapter = new SqlDataAdapter("select * from product",connection);
  4. DataSet ds = new DataSet();
  5. adapter.Fill(ds);
  6. Console.WriteLine(ds.Tables[0].Rows.Count);
复制代码
 
案例4：
  1. using SqlDataAdapter adapter2 = new SqlDataAdapter("select * from product",
  2.     "server=.;uid=sa;pwd=123456;database=unit21");
  3. DataSet ds = new DataSet();
  4. adapter2.Fill(ds);
  5. Console.WriteLine(ds.Tables[0].Rows.Count);
复制代码
将DataTable封装成List 集合

通常我们对List操作比较多。
DataTable ：内存中的数据表。
  1. /**
  2. * 为什么要使用List
  3. * 1. List 更符合面向对象编程思想
  4. * 2. row 在操作列名的时候，有可能会将列名写错
  5. * 3. List集合操作速度要比DataTable要快，并且属于类型安全（C#高级中会有专门一个单元，给大家讲解泛型）
  6. */
  7. using SqlDataAdapter adapter2 = new SqlDataAdapter("select * from product",
  8.     "server=.;uid=sa;pwd=123456;database=unit21");
  9. DataTable dataTable = new DataTable();
  10. adapter2.Fill(dataTable);
  11. ​
  12. List<Product> list = new ();
  13. foreach (DataRow row in dataTable.Rows)
  14. {
  15.     Product product = new();
  16.     product.Id = Convert.ToInt32(row["id"]);
  17.     if (row["pname"] is not DBNull) // 判断非空
  18.     {
  19.         product.ProductName = row["pname"].ToString();
  20.     }
  21.      // 数字类型的一定要记得做判断
  22.     if (row["price"] is not DBNull)
  23.     {
  24.         product.Price = Convert.ToDecimal(row["price"]);
  25.     }
  26.     list.Add(product);
  27. }
  28. Console.WriteLine(list.Count);
  29. ​
  30. ​
  31. public class Product
  32. {
  33.     public int Id { get; set; }
  34.     public string? ProductName { get; set; }
  35.     public decimal Price { get; set; }
  36. }
复制代码
构建DataTable
  1. DataTable dataTable = new DataTable("商品表");
  2. ​
  3. // 创建表头
  4. dataTable.Columns.Add("id");
  5. dataTable.Columns.Add("productname");
  6. DataColumn column = new DataColumn("price");
  7. dataTable.Columns.Add(column);
  8. ​
  9. //创建行
  10. var dataRow = dataTable.NewRow();
  11. dataRow["id"] = 1;
  12. dataRow["productname"]="口红";
  13. dataRow["price"] = 269;
  14. ​
  15. // 添加到DataTable中
  16. dataTable.Rows.Add(dataRow);
复制代码
7. 配置文件

随着服务器的变更、密码的修改等不确定因素，导致连接字符串很有可能会发生变化，如果将连接字符串产用硬编码的形式写入代码中，会导致项目频繁的部署，影响用户的体验。我们更推荐使用配置文件的形式进行存储连接字符串。
添加引用：
  1. System.Configuration.ConfigurationManager
复制代码
 
添加配置文件

在控制台项目中，配置文件名称必须叫 App.config。
 
读取连接字符串

 
读取AppSettings 内容

有时候配置文件中不仅需要配置连接字符串，还有可能需要配置其他一些可变的内容，此时我们可以使用AppSettings 节点来进行配置。
  1. <?xml version="1.0" encoding="utf-8" ?>
  2. <configuration>
  3.    <connectionStrings>
  4.       <add name="connString" connectionString="server=.;uid=sa;pwd=123456;database=unit21" providerName="System.Data.SqlClient"></add>
  5.    </connectionStrings>
  6. </configuration>   
复制代码
读取app.config 文件中的appsetting 节点：
  1. var siteName = ConfigurationManager.AppSettings["siteName"].ToString();
  2. Console.WriteLine(siteName);
复制代码
 
8. 数据连接池

知道现在编程什么是最宝贵的？数据库连接，它其实是很耗费资源的。这里我们就连接池这个问题我们来一起讨论讨论吧。数据库连接池是为了更有效地利用数据库连接的最重要措施。它对于一个大型的应用系统的性能至关重要，特别是Web应用。ADO.NETData Provider（以下简称Data Provider）会帮我们管理连接池，所以有人说使用连接池就像游儿童池一样轻松。但并不是说有了Data Provider程序员就万事无忧的，不正确地使用连接池可能导致你的应用在池里淹死。
 
什么是ADO.net连接池？

ADO.Net连接池是Data Provider提供的一个机制，使得应用程序使用的连接保存在连接池里而避免每次都要完成建立/关闭连接的完整过程。要理解连接池，先要理解程序里SqlConnection.Open()、SqlConnection.Close()和打开/关闭一个“物理连接”的关系。
Data Provider在收到连接请求时建立连接的完整过程是：先连接池里建立新的连接（即“逻辑连接”），然后建立该“逻辑连接”对应的“物理连接”。建立“逻辑连接”一定伴随着建立“物理连接”。Data Provider关闭一个连接的完整过程是先关闭“逻辑连接”对应的“物理连接”然后销毁“逻辑连接”。销毁“逻辑连接”一定伴随着关闭“物理连接”。SqlConnection.Open()是向Data Provider请求一个连接，Data Provider不一定需要完成建立连接的完整过程，可能只需要从连接池里取出一个可用的连接就可以；SqlConnection.Close()是请求关闭一个连接，Data Provider不一定需要完成关闭连接的完整过程，可能只需要把连接释放回连接池就可以。
 
性能对比

非连接池下取数据
在连接字符串中加入配置,关闭数据连接池：pooling=false
  1. <?xml version="1.0" encoding="utf-8" ?>
  2. <configuration>
  3.    <connectionStrings>
  4.       <add name="connString" connectionString="server=.;uid=sa;pwd=123456;database=unit21" providerName="System.Data.SqlClient"></add>
  5.    </connectionStrings>
  6. </configuration>
复制代码
 
  1. using System.Configuration;
  2. using System.Data;
  3. using System.Data.SqlClient;
  4. using System.Diagnostics;
  5. ​
  6. Stopwatch stopwatch = new Stopwatch();
  7. stopwatch.Start();
  8. // 读取配置文件
  9. var connectionString = ConfigurationManager.ConnectionStrings["connString"].ConnectionString;
  10. for (int i = 0; i < 10000; i++)
  11. {
  12.      using SqlConnection connection = new SqlConnection(connectionString);
  13.      connection.Open();
  14. }
  15. ​
  16. stopwatch.Stop();
  17. Console.WriteLine("总耗时(s):"+stopwatch.ElapsedMilliseconds/1000.0);
  18. ​
  19. ​
  20. // 输出结果：
  21. 总耗时(s):11.897
复制代码
 
数据连接池取数据

在连接字符串中加入配置,打开数据连接池：pooling=true。默认情况下，数据连接池是打开的。
  1. <?xml version="1.0" encoding="utf-8" ?>
  2. <configuration>
  3.    <connectionStrings>
  4.       <add name="connString" connectionString="server=.;uid=sa;pwd=123456;database=unit21" providerName="System.Data.SqlClient"></add>
  5.    </connectionStrings>
  6. </configuration>
复制代码
  1. using System.Configuration;
  2. using System.Data;
  3. using System.Data.SqlClient;
  4. using System.Diagnostics;
  5. ​
  6. Stopwatch stopwatch = new Stopwatch();
  7. stopwatch.Start();
  8. // 读取配置文件
  9. var connectionString = ConfigurationManager.ConnectionStrings["connString"].ConnectionString;
  10. for (int i = 0; i < 10000; i++)
  11. {
  12.      using SqlConnection connection = new SqlConnection(connectionString);
  13.      connection.Open();
  14. }
  15. ​
  16. stopwatch.Stop();
  17. Console.WriteLine("总耗时(s):"+stopwatch.ElapsedMilliseconds/1000.0);
  18. ​
  19. ​
  20. // 输出结果：
  21. 总耗时(s):0.28
复制代码
 
9. 参数化查询
  1. create table Users
  2. (
  3.     Id int primary key identity,
  4.     NickName varchar(20),
  5.     Account varchar(20),
  6.     Pwd varchar(20)
  7. );
  8. ​
  9. insert into Users values('张三','zhangsan','123');
  10. insert into Users values('李四','lisi','123');
  11. insert into Users values('王五','wangwu','123');
  12. insert into Users values('任我行','renwoxing','123');
  13. insert into Users values('关莹莹','guanyingying','123');
复制代码
 
正常的你正在登录一个网站：
  1. select * from Users where Account='admin' and Pwd = '123'
复制代码
程序员的你：
  1. select * from Users where Account='admin' and Pwd = '' or 1='1'
复制代码
SQL注入攻击是互联网常用的一种攻击手段，如何防止？
 
解决手段：
所谓的参数化，即：将要传递的sql参数不通过拼接的形式进行组装sql语句，而是通过sql变量的形式进行传递。
  1. select count(*) from Users where Account=@account and Pwd = @pwd
复制代码
SqlParameter 对象

表示 SqlCommand 的参数 ， 参数名称不区分大小写。
 
构造函数

SqlParameter()初始化 SqlParameter 类的新实例。SqlParameter(String, Object)初始化 SqlParameter 类的新实例，该类使用参数名称和新 SqlParameter 的值。SqlParameter(String, SqlDbType)使用提供的参数名称和数据类型初始化 SqlParameter 类的新实例。SqlParameter(String, SqlDbType, Int32)使用参数名称、SqlDbType 和大小初始化 SqlParameter 类的新实例。SqlParameter(String, SqlDbType, Int32, ParameterDirection, Boolean, Byte, Byte, String, DataRowVersion, Object)使用提供的参数名称、参数类型、参数大小、ParameterDirection、参数精度、参数小数位数、源列、要使用的 DataRowVersion 以及参数值初始化 SqlParameter 类的新实例。SqlParameter(String, SqlDbType, Int32, ParameterDirection, Byte, Byte, String, DataRowVersion, Boolean, Object, String, String, String)使用以下信息初始化 SqlParameter 类的新实例：参数名、参数类型、参数长度、参数传递方向、参数精度、参数的范围、源列名、DataRowVersion 的一个值、源列映射的布尔值、SqlParameter 的值、此 XML 实例的架构集所在的数据库名称、此 XML 实例的架构集所在的关系型架构，以及此参数的架构集的名称。SqlParameter(String, SqlDbType, Int32, String)使用提供的参数名称、SqlDbType、大小和源列名初始化 SqlParameter 类的新实例。属性

CompareInfo获取或设置 CompareInfo 对象，它定义应如何对此参数执行字符串比较。DbType获取或设置参数的 SqlDbType。Direction获取或设置一个值，该值指示参数是只可输入的参数、只可输出的参数、双向参数还是存储过程返回值参数。IsNullable获取或设置一个值，该值指示参数是否接受 null 值。 IsNullable 不用于验证参数的值，并且在执行命令时不会阻止发送或接收 null 值。LocaleId获取或设置确定某一特定区域的约定和语言设置的区域设置标识符。Offset获取或设置 Value 属性的偏移量。ParameterName获取或设置 SqlParameter 的名称。Precision获取或设置用于表示 Value 属性的最大位数。Scale获取或设置所解析的 Value 的小数位数。Size获取或设置列中数据的最大大小（字节）。SourceColumn获取或设置源列的名称，该源列映射到 DataSet 并用于加载或返回 Value。SourceColumnNullMapping获取或设置一个值，该值指示源列是否可以为 null。 通过此操作，SqlCommandBuilder 能够为可以为 null 的列正确地生成 Update 语句。SourceVersion获取或设置在加载 DataRowVersion 时使用的 Value。SqlDbType获取或设置参数的 SqlDbType。SqlValue获取或设置作为 SQL 类型的参数的值。TypeName获取或设置表值参数的类型名称。UdtTypeName获取或设置作为参数的表示用户定义类型的 string。Value获取或设置参数的值。 
详细案例

案例1--登录
  1. // 读取配置文件
  2. var connectionString = ConfigurationManager.ConnectionStrings["localString"].ConnectionString;
  3. ​
  4. using SqlConnection conn = new(connectionString);
  5. conn.Open();
  6. // 一定要记得加@符号
  7. using SqlCommand cmd = new SqlCommand("select count(*) from Users where Account=@account and Pwd = @pwd",conn);
  8. ​
  9. SqlParameter parameter1 = new SqlParameter();
  10. parameter1.ParameterName = "account"; // 参数名,要与 上面的sql语句中的参数名要对应上，@符号可省略
  11. parameter1.Size = 20; // 参数大小
  12. parameter1.SqlDbType = SqlDbType.VarChar; // 类型
  13. parameter1.Value = "zhangsan"; // 参数值
  14. ​
  15. SqlParameter parameter2 = new SqlParameter();
  16. parameter2.ParameterName = "pwd"; // 参数名,要与 上面的sql语句中的参数名要对应上，@符号可省略
  17. parameter2.Size = 20; // 参数大小
  18. parameter2.SqlDbType = SqlDbType.VarChar; // 类型
  19. parameter2.Value = "123"; // 参数值
  20. ​
  21. ​
  22. // 将参数添加至命令对象中
  23. cmd.Parameters.Add(parameter1);
  24. cmd.Parameters.Add(parameter2);
  25. ​
  26. // 执行sql命令
  27. var count = Convert.ToInt32(cmd.ExecuteScalar());
  28. if (count > 0)
  29. {
  30.     Console.WriteLine("登录成功");
  31. }
  32. else
  33. {
  34.     Console.WriteLine("登录失败，用户名或者密码输入不正确");
  35. }
复制代码
案例2--添加
  1. var connectionString = ConfigurationManager.ConnectionStrings["connString"].ConnectionString;
  2. ​
  3. using SqlConnection conn = new SqlConnection(connectionString);
  4. conn.Open();
  5. using SqlCommand cmd = new SqlCommand("insert into Users values(@nickName,@account,@pwd);",conn);
  6. ​
  7. // 创建参数数组对象
  8. SqlParameter[] parameters =
  9. {
  10.     new SqlParameter("nickName","李重文"),
  11.     new SqlParameter("account","lichongwen"),
  12.     new SqlParameter("pwd","123")
  13. };
  14. // 批量添加 参数对象数组 至 命令对象中
  15. cmd.Parameters.AddRange(parameters);
  16. cmd.ExecuteNonQuery();
复制代码
 
数据类型如果 合适，Precision则从参数的值dbType推断出大小。
在参数中value指定时Object，SqlDbType将从 Microsoft .NET Framework 类型的Object推断。
使用此构造函数重 SqlParameter 载指定整数参数值时，请谨慎使用。 因为此重载接受 Object 类型的 value，所以当此值为零时，必须将整数值转换为 Object 类型，如下面的 C# 示例所示。
  1. Parameter = new SqlParameter("@pname", (object)0);
复制代码
如果不执行此转换，编译器假定你正在尝试调用 SqlParameter(String, SqlDbType) 构造函数重载。
 
案例3--修改
  1. var connectionString = ConfigurationManager.ConnectionStrings["connString"].ConnectionString;
  2. using SqlConnection conn = new SqlConnection(connectionString);
  3. conn.Open();
  4. using SqlCommand cmd = new SqlCommand("update Users set Account=@account,NickName=@nickName,Pwd=@pwd where Id=@id",conn);
  5. ​
  6. // 创建参数数组对象
  7. SqlParameter[] parameters =
  8. {
  9.     new SqlParameter("nickName",SqlDbType.VarChar,20),
  10.     new SqlParameter("account",SqlDbType.VarChar,20),
  11.     new SqlParameter("pwd",SqlDbType.VarChar,20),
  12.     new SqlParameter("id",SqlDbType.Int,4)
  13. };
  14. parameters[0].Value = "张三丰";
  15. parameters[1].Value = "zhangsanfeng";
  16. parameters[2].Value = "123456";
  17. parameters[3].Value = 1;
  18. ​
  19. // 批量添加 参数对象数组 至 命令对象中
  20. cmd.Parameters.AddRange(parameters);
  21. cmd.ExecuteNonQuery();
复制代码
 
如果未在参数中size显式设置，则从参数的值dbType推断 大小。
参数
 
案例4--查询
  1. var connectionString = ConfigurationManager.ConnectionStrings["connString"].ConnectionString;
  2. // 创建参数数组对象
  3. SqlParameter[] parameters =
  4. {
  5.     new SqlParameter("nickName",SqlDbType.VarChar),
  6.     new SqlParameter("pwd",SqlDbType.VarChar)
  7. };
  8. Console.WriteLine("请输入需要查询的姓名：");
  9. string? nickName = Console.ReadLine();
  10. parameters[0].Value = $"%{nickName}%"; // 模糊查询要加%
  11. parameters[1].Value = "123456";
  12. ​
  13. SqlDataAdapter adapter = new("select * from Users where NickName like @nickName and Pwd=@pwd",connectionString);
  14. // 批量添加参数对象
  15. adapter.SelectCommand.Parameters.AddRange(parameters);
  16. DataTable dataTable = new DataTable();
  17. adapter.Fill(dataTable);
  18. ​
  19. Console.WriteLine("\nId\t姓名\t账号 \t \t密码");
  20. Console.WriteLine("------------------------------------------------------");
  21. foreach (DataRow row in dataTable.Rows)
  22. {
  23.     Console.WriteLine($"{row["id"]}\t{row["nickname"]}\t{row["account"]}\t{row["pwd"]}");
  24. }
复制代码
 
输入结果：
  1. 请输入需要查询的姓名：张​Id      姓名    账号<?xml version="1.0" encoding="utf-8" ?>
  2. <configuration>
  3.    <connectionStrings>
  4.       <add name="connString" connectionString="server=.;uid=sa;pwd=123456;database=unit21" providerName="System.Data.SqlClient"></add>
  5.    </connectionStrings>
  6. </configuration>密码------------------------------------------------------1       张三丰  zhangsanfeng    123456
复制代码
如果未在参数中size显式设置，则从参数的值dbType推断 大小。
 
案例5--删除
  1. var connectionString = ConfigurationManager.ConnectionStrings["connString"].ConnectionString;
  2. ​
  3. using SqlConnection conn = new SqlConnection(connectionString);
  4. conn.Open();
  5. using SqlCommand cmd = new SqlCommand("delete from Users where id=@id;",conn);
  6. ​
  7. // 指添加 参数对象 命令对象中
  8. cmd.Parameters.Add(new SqlParameter("id",1));
  9. cmd.ExecuteNonQuery();
复制代码
 
案例6--批量删除

批量删除的sql：
  1. delete from Users where id in(1,2)
复制代码
但如果使用参数化来实现批量功能，只能通过循环单删操作实现。
  1. var connectionString = ConfigurationManager.ConnectionStrings["connString"].ConnectionString;
  2. ​
  3. using SqlConnection conn = new SqlConnection(connectionString);
  4. conn.Open();
  5. using SqlCommand cmd = new SqlCommand("delete from Users where id=@id;",conn);
  6. ​
  7. // 需要删除的数据
  8. int[] idList = {1, 2, 3};
  9. foreach (var id in idList)
  10. {
  11.     // 指添加 参数对象数组 至 命令对象中
  12.     cmd.Parameters.Add(new SqlParameter("id",id));
  13.     cmd.ExecuteNonQuery();
  14.     cmd.Parameters.Clear(); // 必须清除掉之前的参数
  15. }
复制代码
 
案例6--事务
  1. var connectionString = ConfigurationManager.ConnectionStrings["connString"].ConnectionString;
  2. ​
  3. using SqlConnection conn = new SqlConnection(connectionString);
  4. conn.Open();
  5. using SqlTransaction tran = conn.BeginTransaction(); // 开启事务
  6. // 命令对象指定事务对象
  7. using SqlCommand cmd = new SqlCommand("delete from Users where id=@id;",conn,tran);
  8. ​
  9. try
  10. {
  11.     // 需要删除的数据
  12.     int[] idList = {4, 5, 6};
  13.     foreach (var id in idList)
  14.     {
  15.         // 指添加 参数对象数组 至 命令对象中
  16.         cmd.Parameters.Add(new SqlParameter("id",id));
  17.         cmd.ExecuteNonQuery();
  18.         cmd.Parameters.Clear(); // 必须清除掉之前的参数
  19.     }
  20.     tran.Commit();// 提交事务
  21. }
  22. catch (Exception e)
  23. {
  24.     Console.WriteLine(e.Message);
  25.     tran.Rollback(); // 数据回滚
  26. }
复制代码
案例7--存储过程

存储过程：
  1. create proc p_users_insert
  2. (
  3.     @nickName varchar(20),
  4.     @account varchar(20),
  5.     @pwd varchar(20)
  6. ) as
  7. begin
  8.     insert into Users values(@nickName,@account,@pwd)
  9. end
复制代码
Ado.net 调用存储过程
  1. var connectionString = ConfigurationManager.ConnectionStrings["connString"].ConnectionString;
  2. ​
  3. using SqlConnection conn = new SqlConnection(connectionString);
  4. conn.Open();
  5. // 这里要写存储过程的名称
  6. using SqlCommand cmd = new SqlCommand("p_users_insert", conn);
  7. cmd.CommandType = CommandType.StoredProcedure;// 指定为存储过程类型
  8. SqlParameter[] parameters =
  9. {
  10.     new SqlParameter("nickName","李重文"),
  11.     new SqlParameter("account","lichongwen"),
  12.     new SqlParameter("pwd","123")
  13. };
  14. // 批量添加 参数对象数组 至 命令对象中
  15. cmd.Parameters.AddRange(parameters);
  16. cmd.ExecuteNonQuery();
复制代码
案例8--输出参数

修改存储过程，添加输出参数
  1. alter proc p_users_insert
  2. (
  3.     @nickName varchar(20),
  4.     @account varchar(20),
  5.     @pwd varchar(20),
  6.     @code int output,
  7.     @msg varchar(20) output -- 输出参数
  8. ) as
  9. begin
  10.     insert into Users values(@nickName,@account,@pwd);
  11.     set @msg = '添加成功';
  12.     set @code=1;
  13. end
复制代码
 
调用带有输出参数的存储过程
  1. var connectionString = ConfigurationManager.ConnectionStrings["connString"].ConnectionString;
  2. ​
  3. using SqlConnection conn = new SqlConnection(connectionString);
  4. conn.Open();
  5. // 这里要写存储过程的名称
  6. using SqlCommand cmd = new SqlCommand("p_users_insert", conn);
  7. cmd.CommandType = CommandType.StoredProcedure;// 指定为存储过程类型
  8. SqlParameter[] parameters =
  9. {
  10.     new SqlParameter("nickName","孙婷婷"),
  11.     new SqlParameter("account","suntingting"),
  12.     new SqlParameter("pwd","123"),
  13.     new SqlParameter("code",SqlDbType.Int,4), // 不给输出参数设置值
  14.     new SqlParameter("msg",SqlDbType.VarChar,20)
  15. };
  16. parameters[3].Direction = ParameterDirection.Output; // 第4个参数设置为输出参数
  17. parameters[4].Direction = ParameterDirection.Output; // 第5个参数设置为输出参数
  18. ​
  19. // 批量添加 参数对象数组 至 命令对象中
  20. cmd.Parameters.AddRange(parameters);
  21. cmd.ExecuteNonQuery();
  22. Console.WriteLine("code的值为："+ parameters[3].Value); // 获取输出参数返回的值
  23. Console.WriteLine("msg的值为："+ parameters[4].Value);
复制代码
 
输出结果是：
  1. code的值为：1
  2. msg的值为：添加成功
复制代码
　　
10. Web项目操作Ado

Web 项目是目前的开发主流，Ado.net 凭借的高效的运行效率，也占得了一席之地。
 
appsetting.json 配置文件：
  1. {
  2.   "Logging": {
  3.     "LogLevel": {
  4.       "Default": "Information",
  5.       "Microsoft.AspNetCore": "Warning"
  6.     }
  7.   },
  8.   "AllowedHosts": "*",
  9.   "ConnectionStrings": {
  10.     // 连接字符串
  11.     "SqlServer": "server=.;uid=sa;pwd=123456;database=unit21;pooling=true;"
  12.   }
  13. }
复制代码
  1.  
复制代码
IConfiguration 接口

在 .net web 项目中，IConfiguration 接口在项目启动中已经被注册到IOC容器中（Asp.net Mvc 高级阶段会进行讲解），所以我们只需要在需要用到的地方注入，即可拿到对象。
 
读取连接字符串
 
  1. public class HomeController : Controller
  2. {
  3.     // 注入配置对象（系统在启动时，已经在IOC容器中注册好了）
  4.     private readonly IConfiguration _configuration;
  5. ​
  6.     public HomeController(IConfiguration configuration)
  7.     {
  8.         _configuration = configuration;
  9.     }
  10. ​
  11.     public IActionResult Index()
  12.     {
  13.         // 读取连接字符串
  14.         string connString = _configuration.GetConnectionString("SqlServer");
  15.         return View();
  16.     }   
  17. }
复制代码
 
操作Ado.net

 
读取数据
  1. public class HomeController : Controller{    // 注入配置对象（系统在启动时，已经在IOC容器中注册好了）    private readonly IConfiguration _configuration;​    public HomeController(IConfiguration configuration)    {        _configuration = configuration;    }​    public IActionResult Index()    {        // 读取连接字符串        string connString = _configuration.GetConnectionString("SqlServer");        // 创建参数数组对象        SqlParameter[] parameters =        {<?xml version="1.0" encoding="utf-8" ?>
  2. <configuration>
  3.    <connectionStrings>
  4.       <add name="connString" connectionString="server=.;uid=sa;pwd=123456;database=unit21" providerName="System.Data.SqlClient"></add>
  5.    </connectionStrings>
  6. </configuration>new SqlParameter("nickName",SqlDbType.VarChar),<?xml version="1.0" encoding="utf-8" ?>
  7. <configuration>
  8.    <connectionStrings>
  9.       <add name="connString" connectionString="server=.;uid=sa;pwd=123456;database=unit21" providerName="System.Data.SqlClient"></add>
  10.    </connectionStrings>
  11. </configuration>new SqlParameter("pwd",SqlDbType.VarChar)        };        Console.WriteLine("请输入需要查询的姓名：");        string? nickName = Console.ReadLine();        parameters[0].Value = $"%{nickName}%"; // 模糊查询要加%        parameters[1].Value = "123456";​        SqlDataAdapter adapter = new("select * from Users where NickName like @nickName and Pwd=@pwd",connString);// 批量添加参数对象        adapter.SelectCommand.Parameters.AddRange(parameters);        DataTable dataTable = new DataTable();        adapter.Fill(dataTable);​        Console.WriteLine("\nId\t姓名\t账号 \t \t密码");        Console.WriteLine("------------------------------------------------------");        foreach (DataRow row in dataTable.Rows)        {<?xml version="1.0" encoding="utf-8" ?>
  12. <configuration>
  13.    <connectionStrings>
  14.       <add name="connString" connectionString="server=.;uid=sa;pwd=123456;database=unit21" providerName="System.Data.SqlClient"></add>
  15.    </connectionStrings>
  16. </configuration>Console.WriteLine($"{row["id"]}\t{row["nickname"]}\t{row["account"]}\t{row["pwd"]}");        }        return View();    }​   }
复制代码
11 .封装DbHelper

在上述案例中，存在太多的重复代码了，开发过程是绝不能容忍如此多的重复代码。上述代码中，除了sql 与 字段参数有可能不一样以外，其他创建连接等代码都是重复的，我们可以将上述操作分为3类。
如此，我们可以将上述3类封装为三个方法，将sql语句与字段参数 当作方法参数传入，达到重用作用。
需要安装的包：
  1. Microsoft.Extensions.Configuration 6.0
  2. Microsoft.Extensions.Configuration.Json 6.0
复制代码
  1. using System.Data;
  2. using System.Data.SqlClient;
  3. using System.Reflection;
  5. namespace WebApplication1;
  7. public class DbHelper
  8. {
  9.     private static string? _connString;
  11.     // 静态构造方法,
  12.     // 第一次访问 这个的类的时候，会执行一次静态构造
复制代码
  1.     static DbHelper()    {        ConfigurationBuilder configuration = new ConfigurationBuilder(); //读取配置文件        var config = configuration.SetBasePath(Directory.GetCurrentDirectory())<?xml version="1.0" encoding="utf-8" ?>
  2. <configuration>
  3.    <connectionStrings>
  4.       <add name="connString" connectionString="server=.;uid=sa;pwd=123456;database=unit21" providerName="System.Data.SqlClient"></add>
  5.    </connectionStrings>
  6. </configuration>.AddJsonFile(file =>        {<?xml version="1.0" encoding="utf-8" ?>
  7. <configuration>
  8.    <connectionStrings>
  9.       <add name="connString" connectionString="server=.;uid=sa;pwd=123456;database=unit21" providerName="System.Data.SqlClient"></add>
  10.    </connectionStrings>
  11. </configuration>file.Path = "/appsettings.json";<?xml version="1.0" encoding="utf-8" ?>
  12. <configuration>
  13.    <connectionStrings>
  14.       <add name="connString" connectionString="server=.;uid=sa;pwd=123456;database=unit21" providerName="System.Data.SqlClient"></add>
  15.    </connectionStrings>
  16. </configuration>file.Optional = false;<?xml version="1.0" encoding="utf-8" ?>
  17. <configuration>
  18.    <connectionStrings>
  19.       <add name="connString" connectionString="server=.;uid=sa;pwd=123456;database=unit21" providerName="System.Data.SqlClient"></add>
  20.    </connectionStrings>
  21. </configuration>file.ReloadOnChange = true;        }).Build();        _connString = config.GetConnectionString("SqlServer");    }    private static SqlCommand PrepareCommand(SqlConnection conn, string sql, CommandType cmdType,        params SqlParameter[]? parameters)    {        using SqlCommand cmd = new SqlCommand(sql, conn);        cmd.CommandType = cmdType;        if (parameters != null && parameters.Length > 0)        {<?xml version="1.0" encoding="utf-8" ?>
  22. <configuration>
  23.    <connectionStrings>
  24.       <add name="connString" connectionString="server=.;uid=sa;pwd=123456;database=unit21" providerName="System.Data.SqlClient"></add>
  25.    </connectionStrings>
  26. </configuration>cmd.Parameters.AddRange(parameters);        }        return cmd;    }    /**     * 执行增删改的操作     */        public static int ExecuteNonQuery(string sql,params SqlParameter[]? parameters)    {        using SqlConnection conn = new(_connString);        conn.Open();        return PrepareCommand(conn, sql, CommandType.Text, parameters).ExecuteNonQuery();    }        public static int ExecuteNonQuery(string sql, CommandType cmdType = CommandType.Text,        params SqlParameter[]? parameters)    {        using SqlConnection conn = new(_connString);        conn.Open();        return PrepareCommand(conn, sql, cmdType, parameters).ExecuteNonQuery();    }    public static int ExecuteScalar(string sql,params SqlParameter[]? parameters)    {        using SqlConnection conn = new(_connString);        conn.Open();        return Convert.ToInt32(PrepareCommand(conn, sql, CommandType.Text, parameters).ExecuteScalar());    }        public static int ExecuteScalar(string sql, CommandType cmdType = CommandType.Text,        params SqlParameter[]? parameters)    {        using SqlConnection conn = new(_connString);        conn.Open();        return Convert.ToInt32(PrepareCommand(conn, sql, cmdType, parameters).ExecuteScalar());    }    public static List GetList(string sql, CommandType cmdType = CommandType.Text,        params SqlParameter[]? parameters)  where T : class, new()    {        using SqlDataAdapter adapter = new(PrepareCommand(<?xml version="1.0" encoding="utf-8" ?>
  27. <configuration>
  28.    <connectionStrings>
  29.       <add name="connString" connectionString="server=.;uid=sa;pwd=123456;database=unit21" providerName="System.Data.SqlClient"></add>
  30.    </connectionStrings>
  31. </configuration>new (_connString),sql, cmdType, parameters));        DataTable dataTable = new DataTable();        adapter.Fill(dataTable);        return ToList(dataTable);    }        public static List GetList(string sql, params SqlParameter[]? parameters)  where T : class, new()    {        using SqlDataAdapter adapter = new(PrepareCommand(<?xml version="1.0" encoding="utf-8" ?>
  32. <configuration>
  33.    <connectionStrings>
  34.       <add name="connString" connectionString="server=.;uid=sa;pwd=123456;database=unit21" providerName="System.Data.SqlClient"></add>
  35.    </connectionStrings>
  36. </configuration>new (_connString),sql, CommandType.Text, parameters));        DataTable dataTable = new DataTable();        adapter.Fill(dataTable);        return ToList(dataTable);    }    private static List ToList(DataTable dt) where T : class, new()    {        Type t = typeof(T);        PropertyInfo[] propertys = t.GetProperties();        List lst = new List();        string typeName = string.Empty;        foreach (DataRow dr in dt.Rows)        {<?xml version="1.0" encoding="utf-8" ?>
  37. <configuration>
  38.    <connectionStrings>
  39.       <add name="connString" connectionString="server=.;uid=sa;pwd=123456;database=unit21" providerName="System.Data.SqlClient"></add>
  40.    </connectionStrings>
  41. </configuration>T entity = new T();<?xml version="1.0" encoding="utf-8" ?>
  42. <configuration>
  43.    <connectionStrings>
  44.       <add name="connString" connectionString="server=.;uid=sa;pwd=123456;database=unit21" providerName="System.Data.SqlClient"></add>
  45.    </connectionStrings>
  46. </configuration>foreach (PropertyInfo pi in propertys)<?xml version="1.0" encoding="utf-8" ?>
  47. <configuration>
  48.    <connectionStrings>
  49.       <add name="connString" connectionString="server=.;uid=sa;pwd=123456;database=unit21" providerName="System.Data.SqlClient"></add>
  50.    </connectionStrings>
  51. </configuration>{<?xml version="1.0" encoding="utf-8" ?>
  52. <configuration>
  53.    <connectionStrings>
  54.       <add name="connString" connectionString="server=.;uid=sa;pwd=123456;database=unit21" providerName="System.Data.SqlClient"></add>
  55.    </connectionStrings>
  56. </configuration>    typeName = pi.Name;<?xml version="1.0" encoding="utf-8" ?>
  57. <configuration>
  58.    <connectionStrings>
  59.       <add name="connString" connectionString="server=.;uid=sa;pwd=123456;database=unit21" providerName="System.Data.SqlClient"></add>
  60.    </connectionStrings>
  61. </configuration>    if (dt.Columns.Contains(typeName))<?xml version="1.0" encoding="utf-8" ?>
  62. <configuration>
  63.    <connectionStrings>
  64.       <add name="connString" connectionString="server=.;uid=sa;pwd=123456;database=unit21" providerName="System.Data.SqlClient"></add>
  65.    </connectionStrings>
  66. </configuration>    {<?xml version="1.0" encoding="utf-8" ?>
  67. <configuration>
  68.    <connectionStrings>
  69.       <add name="connString" connectionString="server=.;uid=sa;pwd=123456;database=unit21" providerName="System.Data.SqlClient"></add>
  70.    </connectionStrings>
  71. </configuration>        if (!pi.CanWrite) continue;<?xml version="1.0" encoding="utf-8" ?>
  72. <configuration>
  73.    <connectionStrings>
  74.       <add name="connString" connectionString="server=.;uid=sa;pwd=123456;database=unit21" providerName="System.Data.SqlClient"></add>
  75.    </connectionStrings>
  76. </configuration>        object value = dr[typeName];<?xml version="1.0" encoding="utf-8" ?>
  77. <configuration>
  78.    <connectionStrings>
  79.       <add name="connString" connectionString="server=.;uid=sa;pwd=123456;database=unit21" providerName="System.Data.SqlClient"></add>
  80.    </connectionStrings>
  81. </configuration>        if (value == DBNull.Value) continue;<?xml version="1.0" encoding="utf-8" ?>
  82. <configuration>
  83.    <connectionStrings>
  84.       <add name="connString" connectionString="server=.;uid=sa;pwd=123456;database=unit21" providerName="System.Data.SqlClient"></add>
  85.    </connectionStrings>
  86. </configuration>        if (pi.PropertyType == typeof(string))<?xml version="1.0" encoding="utf-8" ?>
  87. <configuration>
  88.    <connectionStrings>
  89.       <add name="connString" connectionString="server=.;uid=sa;pwd=123456;database=unit21" providerName="System.Data.SqlClient"></add>
  90.    </connectionStrings>
  91. </configuration>        {<?xml version="1.0" encoding="utf-8" ?>
  92. <configuration>
  93.    <connectionStrings>
  94.       <add name="connString" connectionString="server=.;uid=sa;pwd=123456;database=unit21" providerName="System.Data.SqlClient"></add>
  95.    </connectionStrings>
  96. </configuration><?xml version="1.0" encoding="utf-8" ?>
  97. <configuration>
  98.    <connectionStrings>
  99.       <add name="connString" connectionString="server=.;uid=sa;pwd=123456;database=unit21" providerName="System.Data.SqlClient"></add>
  100.    </connectionStrings>
  101. </configuration>pi.SetValue(entity, value.ToString(), null);<?xml version="1.0" encoding="utf-8" ?>
  102. <configuration>
  103.    <connectionStrings>
  104.       <add name="connString" connectionString="server=.;uid=sa;pwd=123456;database=unit21" providerName="System.Data.SqlClient"></add>
  105.    </connectionStrings>
  106. </configuration>        }<?xml version="1.0" encoding="utf-8" ?>
  107. <configuration>
  108.    <connectionStrings>
  109.       <add name="connString" connectionString="server=.;uid=sa;pwd=123456;database=unit21" providerName="System.Data.SqlClient"></add>
  110.    </connectionStrings>
  111. </configuration>        else if (pi.PropertyType == typeof(int) || pi.PropertyType == typeof(int?))<?xml version="1.0" encoding="utf-8" ?>
  112. <configuration>
  113.    <connectionStrings>
  114.       <add name="connString" connectionString="server=.;uid=sa;pwd=123456;database=unit21" providerName="System.Data.SqlClient"></add>
  115.    </connectionStrings>
  116. </configuration>        {<?xml version="1.0" encoding="utf-8" ?>
  117. <configuration>
  118.    <connectionStrings>
  119.       <add name="connString" connectionString="server=.;uid=sa;pwd=123456;database=unit21" providerName="System.Data.SqlClient"></add>
  120.    </connectionStrings>
  121. </configuration><?xml version="1.0" encoding="utf-8" ?>
  122. <configuration>
  123.    <connectionStrings>
  124.       <add name="connString" connectionString="server=.;uid=sa;pwd=123456;database=unit21" providerName="System.Data.SqlClient"></add>
  125.    </connectionStrings>
  126. </configuration>pi.SetValue(entity, int.Parse(value.ToString()), null);<?xml version="1.0" encoding="utf-8" ?>
  127. <configuration>
  128.    <connectionStrings>
  129.       <add name="connString" connectionString="server=.;uid=sa;pwd=123456;database=unit21" providerName="System.Data.SqlClient"></add>
  130.    </connectionStrings>
  131. </configuration>        }<?xml version="1.0" encoding="utf-8" ?>
  132. <configuration>
  133.    <connectionStrings>
  134.       <add name="connString" connectionString="server=.;uid=sa;pwd=123456;database=unit21" providerName="System.Data.SqlClient"></add>
  135.    </connectionStrings>
  136. </configuration>        else if (pi.PropertyType == typeof(DateTime?) || pi.PropertyType == typeof(DateTime))<?xml version="1.0" encoding="utf-8" ?>
  137. <configuration>
  138.    <connectionStrings>
  139.       <add name="connString" connectionString="server=.;uid=sa;pwd=123456;database=unit21" providerName="System.Data.SqlClient"></add>
  140.    </connectionStrings>
  141. </configuration>        {<?xml version="1.0" encoding="utf-8" ?>
  142. <configuration>
  143.    <connectionStrings>
  144.       <add name="connString" connectionString="server=.;uid=sa;pwd=123456;database=unit21" providerName="System.Data.SqlClient"></add>
  145.    </connectionStrings>
  146. </configuration><?xml version="1.0" encoding="utf-8" ?>
  147. <configuration>
  148.    <connectionStrings>
  149.       <add name="connString" connectionString="server=.;uid=sa;pwd=123456;database=unit21" providerName="System.Data.SqlClient"></add>
  150.    </connectionStrings>
  151. </configuration>pi.SetValue(entity, DateTime.Parse(value.ToString()), null);<?xml version="1.0" encoding="utf-8" ?>
  152. <configuration>
  153.    <connectionStrings>
  154.       <add name="connString" connectionString="server=.;uid=sa;pwd=123456;database=unit21" providerName="System.Data.SqlClient"></add>
  155.    </connectionStrings>
  156. </configuration>        }<?xml version="1.0" encoding="utf-8" ?>
  157. <configuration>
  158.    <connectionStrings>
  159.       <add name="connString" connectionString="server=.;uid=sa;pwd=123456;database=unit21" providerName="System.Data.SqlClient"></add>
  160.    </connectionStrings>
  161. </configuration>        else if (pi.PropertyType == typeof(float))<?xml version="1.0" encoding="utf-8" ?>
  162. <configuration>
  163.    <connectionStrings>
  164.       <add name="connString" connectionString="server=.;uid=sa;pwd=123456;database=unit21" providerName="System.Data.SqlClient"></add>
  165.    </connectionStrings>
  166. </configuration>        {<?xml version="1.0" encoding="utf-8" ?>
  167. <configuration>
  168.    <connectionStrings>
  169.       <add name="connString" connectionString="server=.;uid=sa;pwd=123456;database=unit21" providerName="System.Data.SqlClient"></add>
  170.    </connectionStrings>
  171. </configuration><?xml version="1.0" encoding="utf-8" ?>
  172. <configuration>
  173.    <connectionStrings>
  174.       <add name="connString" connectionString="server=.;uid=sa;pwd=123456;database=unit21" providerName="System.Data.SqlClient"></add>
  175.    </connectionStrings>
  176. </configuration>pi.SetValue(entity, float.Parse(value.ToString()), null);<?xml version="1.0" encoding="utf-8" ?>
  177. <configuration>
  178.    <connectionStrings>
  179.       <add name="connString" connectionString="server=.;uid=sa;pwd=123456;database=unit21" providerName="System.Data.SqlClient"></add>
  180.    </connectionStrings>
  181. </configuration>        }<?xml version="1.0" encoding="utf-8" ?>
  182. <configuration>
  183.    <connectionStrings>
  184.       <add name="connString" connectionString="server=.;uid=sa;pwd=123456;database=unit21" providerName="System.Data.SqlClient"></add>
  185.    </connectionStrings>
  186. </configuration>        else if (pi.PropertyType == typeof(double))<?xml version="1.0" encoding="utf-8" ?>
  187. <configuration>
  188.    <connectionStrings>
  189.       <add name="connString" connectionString="server=.;uid=sa;pwd=123456;database=unit21" providerName="System.Data.SqlClient"></add>
  190.    </connectionStrings>
  191. </configuration>        {<?xml version="1.0" encoding="utf-8" ?>
  192. <configuration>
  193.    <connectionStrings>
  194.       <add name="connString" connectionString="server=.;uid=sa;pwd=123456;database=unit21" providerName="System.Data.SqlClient"></add>
  195.    </connectionStrings>
  196. </configuration><?xml version="1.0" encoding="utf-8" ?>
  197. <configuration>
  198.    <connectionStrings>
  199.       <add name="connString" connectionString="server=.;uid=sa;pwd=123456;database=unit21" providerName="System.Data.SqlClient"></add>
  200.    </connectionStrings>
  201. </configuration>pi.SetValue(entity, double.Parse(value.ToString()), null);<?xml version="1.0" encoding="utf-8" ?>
  202. <configuration>
  203.    <connectionStrings>
  204.       <add name="connString" connectionString="server=.;uid=sa;pwd=123456;database=unit21" providerName="System.Data.SqlClient"></add>
  205.    </connectionStrings>
  206. </configuration>        }<?xml version="1.0" encoding="utf-8" ?>
  207. <configuration>
  208.    <connectionStrings>
  209.       <add name="connString" connectionString="server=.;uid=sa;pwd=123456;database=unit21" providerName="System.Data.SqlClient"></add>
  210.    </connectionStrings>
  211. </configuration>        else<?xml version="1.0" encoding="utf-8" ?>
  212. <configuration>
  213.    <connectionStrings>
  214.       <add name="connString" connectionString="server=.;uid=sa;pwd=123456;database=unit21" providerName="System.Data.SqlClient"></add>
  215.    </connectionStrings>
  216. </configuration>        {<?xml version="1.0" encoding="utf-8" ?>
  217. <configuration>
  218.    <connectionStrings>
  219.       <add name="connString" connectionString="server=.;uid=sa;pwd=123456;database=unit21" providerName="System.Data.SqlClient"></add>
  220.    </connectionStrings>
  221. </configuration><?xml version="1.0" encoding="utf-8" ?>
  222. <configuration>
  223.    <connectionStrings>
  224.       <add name="connString" connectionString="server=.;uid=sa;pwd=123456;database=unit21" providerName="System.Data.SqlClient"></add>
  225.    </connectionStrings>
  226. </configuration>pi.SetValue(entity, value, null);<?xml version="1.0" encoding="utf-8" ?>
  227. <configuration>
  228.    <connectionStrings>
  229.       <add name="connString" connectionString="server=.;uid=sa;pwd=123456;database=unit21" providerName="System.Data.SqlClient"></add>
  230.    </connectionStrings>
  231. </configuration>        }<?xml version="1.0" encoding="utf-8" ?>
  232. <configuration>
  233.    <connectionStrings>
  234.       <add name="connString" connectionString="server=.;uid=sa;pwd=123456;database=unit21" providerName="System.Data.SqlClient"></add>
  235.    </connectionStrings>
  236. </configuration>    }<?xml version="1.0" encoding="utf-8" ?>
  237. <configuration>
  238.    <connectionStrings>
  239.       <add name="connString" connectionString="server=.;uid=sa;pwd=123456;database=unit21" providerName="System.Data.SqlClient"></add>
  240.    </connectionStrings>
  241. </configuration>}<?xml version="1.0" encoding="utf-8" ?>
  242. <configuration>
  243.    <connectionStrings>
  244.       <add name="connString" connectionString="server=.;uid=sa;pwd=123456;database=unit21" providerName="System.Data.SqlClient"></add>
  245.    </connectionStrings>
  246. </configuration>lst.Add(entity);        }        return lst;    }}
复制代码
 
 
配套视频：
【ado.net访问 数据库技术】 Net 6 开发系列(已完结)_哔哩哔哩_bilibili
 

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！



欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/) Powered by Discuz! X3.4