根据我的理解，async和await所做的主要事情之一是使代码易于编写和阅读-但使用它们是否等于生成后台线程来执行长时间的逻辑?
我目前正在尝试最基本的例子。我内联添加了一些注释。你能给我解释一下吗?
// I don't understand why this method must be marked as `async`.
private async void button1_Click(object sender, EventArgs e)
{
Task<int> access = DoSomethingAsync();
// task independent stuff here
// this line is reached after the 5 seconds sleep from
// DoSomethingAsync() method. Shouldn't it be reached immediately?
int a = 1;
// from my understanding the waiting should be done here.
int x = await access;
}
async Task<int> DoSomethingAsync()
{
// is this executed on a background thread?
System.Threading.Thread.Sleep(5000);
return 1;
}
下面是通过打开对话框读取excel文件的代码，然后使用async和等待运行异步代码，从excel逐行读取并绑定到网格
namespace EmailBillingRates
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
lblProcessing.Text = "";
}
private async void btnReadExcel_Click(object sender, EventArgs e)
{
string filename = OpenFileDialog();
Microsoft.Office.Interop.Excel.Application xlApp = new Microsoft.Office.Interop.Excel.Application();
Microsoft.Office.Interop.Excel.Workbook xlWorkbook = xlApp.Workbooks.Open(filename);
Microsoft.Office.Interop.Excel._Worksheet xlWorksheet = xlWorkbook.Sheets[1];
Microsoft.Office.Interop.Excel.Range xlRange = xlWorksheet.UsedRange;
try
{
Task<int> longRunningTask = BindGrid(xlRange);
int result = await longRunningTask;
}
catch (Exception ex)
{
MessageBox.Show(ex.Message.ToString());
}
finally
{
//cleanup
// GC.Collect();
//GC.WaitForPendingFinalizers();
//rule of thumb for releasing com objects:
// never use two dots, all COM objects must be referenced and released individually
// ex: [somthing].[something].[something] is bad
//release com objects to fully kill excel process from running in the background
Marshal.ReleaseComObject(xlRange);
Marshal.ReleaseComObject(xlWorksheet);
//close and release
xlWorkbook.Close();
Marshal.ReleaseComObject(xlWorkbook);
//quit and release
xlApp.Quit();
Marshal.ReleaseComObject(xlApp);
}
}
private void btnSendEmail_Click(object sender, EventArgs e)
{
}
private string OpenFileDialog()
{
string filename = "";
OpenFileDialog fdlg = new OpenFileDialog();
fdlg.Title = "Excel File Dialog";
fdlg.InitialDirectory = @"c:\";
fdlg.Filter = "All files (*.*)|*.*|All files (*.*)|*.*";
fdlg.FilterIndex = 2;
fdlg.RestoreDirectory = true;
if (fdlg.ShowDialog() == DialogResult.OK)
{
filename = fdlg.FileName;
}
return filename;
}
private async Task<int> BindGrid(Microsoft.Office.Interop.Excel.Range xlRange)
{
lblProcessing.Text = "Processing File.. Please wait";
int rowCount = xlRange.Rows.Count;
int colCount = xlRange.Columns.Count;
// dt.Column = colCount;
dataGridView1.ColumnCount = colCount;
dataGridView1.RowCount = rowCount;
for (int i = 1; i <= rowCount; i++)
{
for (int j = 1; j <= colCount; j++)
{
//write the value to the Grid
if (xlRange.Cells[i, j] != null && xlRange.Cells[i, j].Value2 != null)
{
await Task.Delay(1);
dataGridView1.Rows[i - 1].Cells[j - 1].Value = xlRange.Cells[i, j].Value2.ToString();
}
}
}
lblProcessing.Text = "";
return 0;
}
}
internal class async
{
}
}
我想对此发表我的意见，如果任何其他答案包含我将解释的内容，我很抱歉，我读了大部分，但没有找到它，但我可能错过了一些东西。
我看到了很多错误的概念和很多好的解释，只是想解释一下异步与并行编程的区别，我相信这会让事情更容易理解。
当你需要做长时间的计算，处理器密集的工作，你应该选择使用并行编程，如果可能的话，以优化核心的使用。这将打开一些线程并同时处理一些事情。
假设你有一个数字数组，想要对每一个数字进行一些昂贵的长计算。平行是你的朋友。
异步编程在不同的用例中使用。
当你在等待一些不依赖于你的处理器的事情时，它用来释放你的线程，例如IO(写入和读取磁盘)，当你执行IO时，你的线程什么都不做，当你等待一个昂贵的查询结果从DB返回时也是一样。
异步方法在线程等待很长时间返回结果时释放线程。这个线程可以被应用程序的其他部分使用(例如，在web应用程序中，它可以处理其他请求)，也可以返回操作系统用于其他用途。
当您的结果完成时，相同的线程(或另一个线程)将返回给您的应用程序以继续处理。
在像。net这样的多线程环境中，异步编程不是强制性的(但是个很好的实践)，在web应用程序中，其他线程将响应新请求，但如果你是在像nodejs这样的单线程框架中，这是强制性的，因为你不能阻塞你唯一的线程，否则你将无法回答任何其他请求。
总而言之，长处理器密集型计算将从并行编程中受益更多，而不依赖于处理器的长等待时间，如IO或DB查询或对某些API的调用将从异步编程中受益更多。
这就是为什么Entity Framework有一个async api来保存、列表、查找等等…
记住async/await与wait或waitAll不同，上下文不同。Async/await释放线程，是异步编程。wait / waitAll阻塞所有线程(它们没有被释放)来强制并行上下文中的同步…不同的东西…
希望这对某些人有用…
除了其他答案，还有await (c#参考)
更具体地说，在包含的例子中，它解释了您的情况
下面的Windows窗体示例说明了await在
异步方法，WaitAsynchronouslyAsync。对比一下它的行为
方法使用waitsynchrontically的行为。没有等待
应用到任务的操作符，waitsynchronize同步运行
尽管在定义中使用了async修饰符，并且调用了
线程。睡在它的身体里。
private async void button1_Click(object sender, EventArgs e)
{
// Call the method that runs asynchronously.
string result = await WaitAsynchronouslyAsync();
// Call the method that runs synchronously.
//string result = await WaitSynchronously ();
// Display the result.
textBox1.Text += result;
}
// The following method runs asynchronously. The UI thread is not
// blocked during the delay. You can move or resize the Form1 window
// while Task.Delay is running.
public async Task<string> WaitAsynchronouslyAsync()
{
await Task.Delay(10000);
return "Finished";
}
// The following method runs synchronously, despite the use of async.
// You cannot move or resize the Form1 window while Thread.Sleep
// is running because the UI thread is blocked.
public async Task<string> WaitSynchronously()
{
// Add a using directive for System.Threading.
Thread.Sleep(10000);
return "Finished";
}
