异步 SqlClient 方法的好处
Benefits of async SqlClient methods
System.Data.SqlClient 命名空间中可用的本机 *Async 方法有哪些好处？与主体仅由同步方法调用组成的手动 Task.Run 相比，它们有什么优势？
这是我的 'starting point' 示例（控制台应用程序）：
using System;
using System.Data.SqlClient;
using System.Threading.Tasks;
class Program
{
const string CommandTest = @"
SET NOCOUNT ON;
WITH
L0 AS (SELECT c FROM (SELECT 1 UNION ALL SELECT 1) AS D(c)), -- 2^1
L1 AS (SELECT 1 AS c FROM L0 AS A CROSS JOIN L0 AS B), -- 2^2
L2 AS (SELECT 1 AS c FROM L1 AS A CROSS JOIN L1 AS B), -- 2^4
L3 AS (SELECT 1 AS c FROM L2 AS A CROSS JOIN L2 AS B), -- 2^8
L4 AS (SELECT 1 AS c FROM L3 AS A CROSS JOIN L3 AS B), -- 2^16
L5 AS (SELECT 1 AS c FROM L4 AS A CROSS JOIN L4 AS B), -- 2^32
Nums AS (SELECT ROW_NUMBER() OVER(ORDER BY (SELECT NULL)) AS k FROM L5)
SELECT
k
FROM
Nums
WHERE
k <= 1000000";
const string ConnectionString = "Server=.;Database=master;Integrated Security=SSPI;";
// This requires c# 7.1 or later. Check project settings
public static async Task Main(string[] args)
{
var aSW = new System.Diagnostics.Stopwatch();
aSW.Restart();
{
var aRes = ExecuteSync();
Console.WriteLine($"ExecuteSync returned {aRes} in {aSW.Elapsed}.");
}
aSW.Restart();
{
var aRes = await ExecuteWrapperAsync();
Console.WriteLine($"ExecuteWrapperAsync returned {aRes} in {aSW.Elapsed}.");
}
aSW.Restart();
{
var aRes = await ExecuteNativeAsync();
Console.WriteLine($"ExecuteNativeAsync returned {aRes} in {aSW.Elapsed}.");
}
}
private static Task<long> ExecuteWrapperAsync()
{
return Task.Run(() => ExecuteSync());
}
private static long ExecuteSync()
{
using (var aConn = new SqlConnection(ConnectionString))
using (var aCmd = new SqlCommand(CommandTest, aConn))
{
aConn.Open();
using (var aR = aCmd.ExecuteReader())
{
long aRetVal = 0;
while (aR.Read())
aRetVal += aR.GetInt64(0);
return aRetVal;
}
}
}
private static async Task<long> ExecuteNativeAsync()
{
using (var aConn = new SqlConnection(ConnectionString))
using (var aCmd = new SqlCommand(CommandTest, aConn))
{
await aConn.OpenAsync();
using (var aR = await aCmd.ExecuteReaderAsync())
{
long aRetVal = 0;
while (await aR.ReadAsync())
aRetVal += aR.GetInt64(0);
return aRetVal;
}
}
}
}
谈到我的开发机器的性能，*Async 方法的使用实际上导致 运行 时间变慢。通常，我的输出如下：
ExecuteSync returned 500000500000 in 00:00:00.4514950.
ExecuteWrapperAsync returned 500000500000 in 00:00:00.2525898.
ExecuteNativeAsync returned 500000500000 in 00:00:00.3662496.
换句话说，方法 ExecuteNativeAsync 是使用 System.Data.SqlClient 的 *Async 方法的方法，并且通常比 Task.Run 包装的同步方法慢打电话。
我做错了什么吗？也许我误读了文档？
在几乎所有情况下，无论您使用 Sync 还是 Async SqlClient APIs 都会对您的查询运行时间、聚合资源利用率、应用程序吞吐量绝对没有有意义的影响, 或可扩展性。
一个简单的事实是，您的应用程序可能不会进行数千个并发 SQL 服务器调用，因此为每个 SQL 查询阻塞一个线程池线程并不是什么大问题。它甚至可以通过消除请求量的峰值而变得有益。
如果您想从单个线程编排多个 SQL 服务器调用，API 很有用。例如，您可以轻松地启动对 N SQL 服务器中每一个的查询，然后 Wait() 获取结果。
在现代 ASP.NET 中，您的控制器和几乎所有 API 调用都是异步的，而在 UI 应用程序中，使用异步方法避免阻塞 UI线程。
我已经修改了上面的示例并且能够从使用 *Async 方法中实际受益：
using System;
using System.Data.SqlClient;
using System.Linq;
using System.Threading.Tasks;
class Program
{
const string CommandTest = @"
SET NOCOUNT ON;
WAITFOR DELAY '00:00:01';
WITH
L0 AS (SELECT c FROM (SELECT 1 UNION ALL SELECT 1) AS D(c)), -- 2^1
L1 AS (SELECT 1 AS c FROM L0 AS A CROSS JOIN L0 AS B), -- 2^2
L2 AS (SELECT 1 AS c FROM L1 AS A CROSS JOIN L1 AS B), -- 2^4
L3 AS (SELECT 1 AS c FROM L2 AS A CROSS JOIN L2 AS B), -- 2^8
L4 AS (SELECT 1 AS c FROM L3 AS A CROSS JOIN L3 AS B), -- 2^16
L5 AS (SELECT 1 AS c FROM L4 AS A CROSS JOIN L4 AS B), -- 2^32
Nums AS (SELECT ROW_NUMBER() OVER(ORDER BY (SELECT NULL)) AS k FROM L5)
SELECT
k
FROM
Nums
WHERE
k <= 100000";
const string ConnectionString = "Server=tcp:.;Database=master;Integrated Security=SSPI;";
const int VirtualClientCount = 100;
// This requires c# 7.1 or later. Check project settings
public static async Task Main(string[] args)
{
var aSW = new System.Diagnostics.Stopwatch();
aSW.Restart();
{
var aTasks = Enumerable.Range(0, VirtualClientCount).Select(_ => ExecuteWrapperAsync());
await Task.WhenAll(aTasks);
Console.WriteLine($"ExecuteWrapperAsync completed in {aSW.Elapsed}.");
}
aSW.Restart();
{
var aTasks = Enumerable.Range(0, VirtualClientCount).Select(_ => ExecuteNativeAsync());
await Task.WhenAll(aTasks);
Console.WriteLine($"ExecuteNativeAsync completed in {aSW.Elapsed}.");
}
}
private static Task<long> ExecuteWrapperAsync()
{
return Task.Run(() => ExecuteSync());
}
private static long ExecuteSync()
{
using (var aConn = new SqlConnection(ConnectionString))
using (var aCmd = new SqlCommand(CommandTest, aConn))
{
aConn.Open();
using (var aR = aCmd.ExecuteReader())
{
long aRetVal = 0;
while (aR.Read())
aRetVal += aR.GetInt64(0);
return aRetVal;
}
}
}
private static async Task<long> ExecuteNativeAsync()
{
using (var aConn = new SqlConnection(ConnectionString))
using (var aCmd = new SqlCommand(CommandTest, aConn))
{
await aConn.OpenAsync();
using (var aR = await aCmd.ExecuteReaderAsync())
{
long aRetVal = 0;
while (await aR.ReadAsync())
aRetVal += aR.GetInt64(0);
return aRetVal;
}
}
}
}
现在我得到以下输出：
ExecuteWrapperAsync completed in 00:00:09.6214859.
ExecuteNativeAsync completed in 00:00:02.2103956.
感谢 David Browne 的提示！
要了解异步的好处，您需要模拟服务器在高负载下执行需要一些时间才能完成的异步操作。在不编写两个版本的情况下，几乎不可能衡量 运行 在生产环境中的应用程序的好处。
您可以模拟预期的查询延迟，而不是再次调用没有负载且可能是应用程序本地的数据库。
随着客户端数量或操作长度的增加，ExecuteAsync 将显着优于 ExecuteSync。在没有负载的情况下，没有观察到使用异步的好处，大多数服务器上的大多数应用程序 运行 通常都是这种情况。
此处Async的好处是它在异步操作完成之前将线程释放回池中，从而释放系统资源。
测试程序：
static void Main(string[] args)
{
RunTest(clients: 10, databaseCallTime: 10);
RunTest(clients: 1000, databaseCallTime: 10);
RunTest(clients: 10, databaseCallTime: 1000);
RunTest(clients: 1000, databaseCallTime: 1000);
}
public static void RunTest(int clients, int databaseCallTime)
{
var aSW = new Stopwatch();
Console.WriteLine($"Testing {clients} clients with a {databaseCallTime}ms database response time.");
aSW.Restart();
{
Task.WaitAll(
Enumerable.Range(0, clients)
.AsParallel()
.Select(_ => ExecuteAsync(databaseCallTime))
.ToArray());
Console.WriteLine($"-> ExecuteAsync returned in {aSW.Elapsed}.");
}
aSW.Restart();
{
Task.WaitAll(
Enumerable.Range(0, clients)
.AsParallel()
.Select(_ => Task.Run(() => ExecuteSync(databaseCallTime)))
.ToArray());
Console.WriteLine($"-> ExecuteSync returned in {aSW.Elapsed}.");
}
Console.WriteLine();
Console.WriteLine();
}
private static void ExecuteSync(int databaseCallTime)
{
Thread.Sleep(databaseCallTime);
}
private static async Task ExecuteAsync(int databaseCallTime)
{
await Task.Delay(databaseCallTime);
}
我的结果：
Testing 10 clients with a 10ms database response time.
-> ExecuteAsync returned in 00:00:00.1119717.
-> ExecuteSync returned in 00:00:00.0268717.
Testing 1000 clients with a 10ms database response time.
-> ExecuteAsync returned in 00:00:00.0593431.
-> ExecuteSync returned in 00:00:01.3065965.
Testing 10 clients with a 1000ms database response time.
-> ExecuteAsync returned in 00:00:01.0126014.
-> ExecuteSync returned in 00:00:01.0099419.
Testing 1000 clients with a 1000ms database response time.
-> ExecuteAsync returned in 00:00:01.1711554.
-> ExecuteSync returned in 00:00:25.0433635.
System.Data.SqlClient 命名空间中可用的本机 *Async 方法有哪些好处？与主体仅由同步方法调用组成的手动 Task.Run 相比，它们有什么优势？
这是我的 'starting point' 示例（控制台应用程序）：
using System;
using System.Data.SqlClient;
using System.Threading.Tasks;
class Program
{
const string CommandTest = @"
SET NOCOUNT ON;
WITH
L0 AS (SELECT c FROM (SELECT 1 UNION ALL SELECT 1) AS D(c)), -- 2^1
L1 AS (SELECT 1 AS c FROM L0 AS A CROSS JOIN L0 AS B), -- 2^2
L2 AS (SELECT 1 AS c FROM L1 AS A CROSS JOIN L1 AS B), -- 2^4
L3 AS (SELECT 1 AS c FROM L2 AS A CROSS JOIN L2 AS B), -- 2^8
L4 AS (SELECT 1 AS c FROM L3 AS A CROSS JOIN L3 AS B), -- 2^16
L5 AS (SELECT 1 AS c FROM L4 AS A CROSS JOIN L4 AS B), -- 2^32
Nums AS (SELECT ROW_NUMBER() OVER(ORDER BY (SELECT NULL)) AS k FROM L5)
SELECT
k
FROM
Nums
WHERE
k <= 1000000";
const string ConnectionString = "Server=.;Database=master;Integrated Security=SSPI;";
// This requires c# 7.1 or later. Check project settings
public static async Task Main(string[] args)
{
var aSW = new System.Diagnostics.Stopwatch();
aSW.Restart();
{
var aRes = ExecuteSync();
Console.WriteLine($"ExecuteSync returned {aRes} in {aSW.Elapsed}.");
}
aSW.Restart();
{
var aRes = await ExecuteWrapperAsync();
Console.WriteLine($"ExecuteWrapperAsync returned {aRes} in {aSW.Elapsed}.");
}
aSW.Restart();
{
var aRes = await ExecuteNativeAsync();
Console.WriteLine($"ExecuteNativeAsync returned {aRes} in {aSW.Elapsed}.");
}
}
private static Task<long> ExecuteWrapperAsync()
{
return Task.Run(() => ExecuteSync());
}
private static long ExecuteSync()
{
using (var aConn = new SqlConnection(ConnectionString))
using (var aCmd = new SqlCommand(CommandTest, aConn))
{
aConn.Open();
using (var aR = aCmd.ExecuteReader())
{
long aRetVal = 0;
while (aR.Read())
aRetVal += aR.GetInt64(0);
return aRetVal;
}
}
}
private static async Task<long> ExecuteNativeAsync()
{
using (var aConn = new SqlConnection(ConnectionString))
using (var aCmd = new SqlCommand(CommandTest, aConn))
{
await aConn.OpenAsync();
using (var aR = await aCmd.ExecuteReaderAsync())
{
long aRetVal = 0;
while (await aR.ReadAsync())
aRetVal += aR.GetInt64(0);
return aRetVal;
}
}
}
}
谈到我的开发机器的性能，*Async 方法的使用实际上导致 运行 时间变慢。通常，我的输出如下：
ExecuteSync returned 500000500000 in 00:00:00.4514950.
ExecuteWrapperAsync returned 500000500000 in 00:00:00.2525898.
ExecuteNativeAsync returned 500000500000 in 00:00:00.3662496.
换句话说，方法 ExecuteNativeAsync 是使用 System.Data.SqlClient 的 *Async 方法的方法，并且通常比 Task.Run 包装的同步方法慢打电话。
我做错了什么吗？也许我误读了文档？
在几乎所有情况下，无论您使用 Sync 还是 Async SqlClient APIs 都会对您的查询运行时间、聚合资源利用率、应用程序吞吐量绝对没有有意义的影响, 或可扩展性。
一个简单的事实是，您的应用程序可能不会进行数千个并发 SQL 服务器调用，因此为每个 SQL 查询阻塞一个线程池线程并不是什么大问题。它甚至可以通过消除请求量的峰值而变得有益。
如果您想从单个线程编排多个 SQL 服务器调用，API 很有用。例如，您可以轻松地启动对 N SQL 服务器中每一个的查询，然后 Wait() 获取结果。
在现代 ASP.NET 中，您的控制器和几乎所有 API 调用都是异步的，而在 UI 应用程序中，使用异步方法避免阻塞 UI线程。
我已经修改了上面的示例并且能够从使用 *Async 方法中实际受益：
using System;
using System.Data.SqlClient;
using System.Linq;
using System.Threading.Tasks;
class Program
{
const string CommandTest = @"
SET NOCOUNT ON;
WAITFOR DELAY '00:00:01';
WITH
L0 AS (SELECT c FROM (SELECT 1 UNION ALL SELECT 1) AS D(c)), -- 2^1
L1 AS (SELECT 1 AS c FROM L0 AS A CROSS JOIN L0 AS B), -- 2^2
L2 AS (SELECT 1 AS c FROM L1 AS A CROSS JOIN L1 AS B), -- 2^4
L3 AS (SELECT 1 AS c FROM L2 AS A CROSS JOIN L2 AS B), -- 2^8
L4 AS (SELECT 1 AS c FROM L3 AS A CROSS JOIN L3 AS B), -- 2^16
L5 AS (SELECT 1 AS c FROM L4 AS A CROSS JOIN L4 AS B), -- 2^32
Nums AS (SELECT ROW_NUMBER() OVER(ORDER BY (SELECT NULL)) AS k FROM L5)
SELECT
k
FROM
Nums
WHERE
k <= 100000";
const string ConnectionString = "Server=tcp:.;Database=master;Integrated Security=SSPI;";
const int VirtualClientCount = 100;
// This requires c# 7.1 or later. Check project settings
public static async Task Main(string[] args)
{
var aSW = new System.Diagnostics.Stopwatch();
aSW.Restart();
{
var aTasks = Enumerable.Range(0, VirtualClientCount).Select(_ => ExecuteWrapperAsync());
await Task.WhenAll(aTasks);
Console.WriteLine($"ExecuteWrapperAsync completed in {aSW.Elapsed}.");
}
aSW.Restart();
{
var aTasks = Enumerable.Range(0, VirtualClientCount).Select(_ => ExecuteNativeAsync());
await Task.WhenAll(aTasks);
Console.WriteLine($"ExecuteNativeAsync completed in {aSW.Elapsed}.");
}
}
private static Task<long> ExecuteWrapperAsync()
{
return Task.Run(() => ExecuteSync());
}
private static long ExecuteSync()
{
using (var aConn = new SqlConnection(ConnectionString))
using (var aCmd = new SqlCommand(CommandTest, aConn))
{
aConn.Open();
using (var aR = aCmd.ExecuteReader())
{
long aRetVal = 0;
while (aR.Read())
aRetVal += aR.GetInt64(0);
return aRetVal;
}
}
}
private static async Task<long> ExecuteNativeAsync()
{
using (var aConn = new SqlConnection(ConnectionString))
using (var aCmd = new SqlCommand(CommandTest, aConn))
{
await aConn.OpenAsync();
using (var aR = await aCmd.ExecuteReaderAsync())
{
long aRetVal = 0;
while (await aR.ReadAsync())
aRetVal += aR.GetInt64(0);
return aRetVal;
}
}
}
}
现在我得到以下输出：
ExecuteWrapperAsync completed in 00:00:09.6214859.
ExecuteNativeAsync completed in 00:00:02.2103956.
感谢 David Browne 的提示！
要了解异步的好处，您需要模拟服务器在高负载下执行需要一些时间才能完成的异步操作。在不编写两个版本的情况下，几乎不可能衡量 运行 在生产环境中的应用程序的好处。
您可以模拟预期的查询延迟，而不是再次调用没有负载且可能是应用程序本地的数据库。
随着客户端数量或操作长度的增加，ExecuteAsync 将显着优于 ExecuteSync。在没有负载的情况下，没有观察到使用异步的好处，大多数服务器上的大多数应用程序 运行 通常都是这种情况。
此处Async的好处是它在异步操作完成之前将线程释放回池中，从而释放系统资源。
测试程序：
static void Main(string[] args)
{
RunTest(clients: 10, databaseCallTime: 10);
RunTest(clients: 1000, databaseCallTime: 10);
RunTest(clients: 10, databaseCallTime: 1000);
RunTest(clients: 1000, databaseCallTime: 1000);
}
public static void RunTest(int clients, int databaseCallTime)
{
var aSW = new Stopwatch();
Console.WriteLine($"Testing {clients} clients with a {databaseCallTime}ms database response time.");
aSW.Restart();
{
Task.WaitAll(
Enumerable.Range(0, clients)
.AsParallel()
.Select(_ => ExecuteAsync(databaseCallTime))
.ToArray());
Console.WriteLine($"-> ExecuteAsync returned in {aSW.Elapsed}.");
}
aSW.Restart();
{
Task.WaitAll(
Enumerable.Range(0, clients)
.AsParallel()
.Select(_ => Task.Run(() => ExecuteSync(databaseCallTime)))
.ToArray());
Console.WriteLine($"-> ExecuteSync returned in {aSW.Elapsed}.");
}
Console.WriteLine();
Console.WriteLine();
}
private static void ExecuteSync(int databaseCallTime)
{
Thread.Sleep(databaseCallTime);
}
private static async Task ExecuteAsync(int databaseCallTime)
{
await Task.Delay(databaseCallTime);
}
我的结果：
Testing 10 clients with a 10ms database response time.
-> ExecuteAsync returned in 00:00:00.1119717.
-> ExecuteSync returned in 00:00:00.0268717.
Testing 1000 clients with a 10ms database response time.
-> ExecuteAsync returned in 00:00:00.0593431.
-> ExecuteSync returned in 00:00:01.3065965.
Testing 10 clients with a 1000ms database response time.
-> ExecuteAsync returned in 00:00:01.0126014.
-> ExecuteSync returned in 00:00:01.0099419.
Testing 1000 clients with a 1000ms database response time.
-> ExecuteAsync returned in 00:00:01.1711554.
-> ExecuteSync returned in 00:00:25.0433635.