以下两段代码之间是否存在任何概念差异:
async Task TestAsync()
{
await Task.Run(() => DoSomeWork());
}
和
Task TestAsync()
{
return Task.Run(() => DoSomeWork());
}
生成的代码也不同吗？
编辑:为避免混淆Task.Run,类似的情况:
async Task TestAsync()
{
await Task.Delay(1000);
}
和
Task TestAsync()
{
return Task.Delay(1000);
}
最新更新:除了接受的答案之外,LocalCallContext处理方式也有所不同:即使没有异步,CallContext.LogicalGetData也会被恢复.为什么？
快问...
为了对异步编程有一些基础的了解,await我想知道这两个代码片段在多线程和执行顺序和时间方面有什么区别:
这个:
public Task CloseApp()
{
return Task.Run(
()=>{
// save database
// turn off some lights
// shutdown application
});
}
对此:
public async Task CloseApp()
{
await Task.Run(
()=>{
// save database
// turn off some lights
// shutdown application
});
}
如果我在这个例程中调用它:
private async void closeButtonTask()
{
// Some Task 1
// ..
await CloseApp();
// Some Task 2
// ..
}
我一直在研究如何使用异步等待，但是当我们有多个互相调用的方法时，我不太了解它。我们应该始终使用等待还是仅在实际准备好使用结果时才使用等待？
因此，例如，我们应该这样做吗：
async Task<string[]> FooAsync()
{
var info = await Func1();
return info.split('.');
}
async Task<string> Func1()
{
return await Func2();
}
async Task<string> Func2()
{
return await tcpClient.ReadStringAsync();
}
或像这样：
async Task<string[]> FooAsync()
{
var info = await Func1();
return info.split('.');
}
Task<string> Func1()
{
return Func2();
}
Task<string> Func2()
{
return tcpClient.ReadStringAsync();
}
根据示例1，我们应该在每种方法中始终使用await吗？
还是
按照示例2，当我们开始使用结果时，我们应该只在最上面的方法上使用await吗？
我有一个服务可以说,
public interface ISomeService
{
Task<bool> DoSomeExpensiveCheckAsync(string parameter);
}
我有这个课程来消费服务.它只需要做一些简单的空检查,然后返回服务响应.
public class SomeServiceConsumer
{
private readonly ISomeService _serviceClient;
public SomeServiceConsumer(ISomeService serviceClient)
{
_serviceClient = serviceClient;
}
public async Task<bool> DoSomething1Async(string someParameter)
{
if (string.IsNullOrWhiteSpace(someParameter))
{
return false;
}
return await _serviceClient.DoSomeExpensiveCheckAsync(someParameter);
}
//No async or await keywords
public Task<bool> DoSomething2Async(string someParameter)
{
if (string.IsNullOrWhiteSpace(someParameter))
{
return Task.FromResult(false);
}
return _serviceClient.DoSomeExpensiveCheckAsync(someParameter);
}
}
我应该做的DoSomething1Async还是DoSomething2Async？
根据这个答案,我不应该用不必要的东西包裹await但是我必须Task.FromResult(false)用于短路DoSomething2Async
但根据这个答案,有一些案例try/catch和 …
假设我有一个C#控制器调用一些返回Task的任意函数(例如,因为它执行数据库事务).我应该总是使用异步和等待,还是应该只返回任务？
示例控制器:
public async Task<string> DoSomething() {
return await SomeOtherFunctionThatReturnsATask();
}
我应该把它改成:
public Task<string> DoSomething() {
return SomeOtherFunctionThatReturnsATask();
}
还是真的没关系？
我对async关键字的行为有点困惑。
可以说我有两种方法，
public async Task DoSomething1()
{
await Task.Run(() =>
{
for(int i = 0; i<3; i++)
{
Console.WriteLine("I m doing something:" + i);
}
});
}
和
public Task DoSomething2()
{
return Task.Run(() =>
{
for(int i = 0; i<3; i++)
{
Console.WriteLine("I m doing something:" + i);
}
});
}
根据我的理解，这两种方法都值得期待。但是当我编写一个Task没有async关键字的返回类型的方法时，我需要返回 aTask否则编译器会产生错误。方法应该返回其类型是很常见的事情。但是当我将它与async关键字一起使用时，编译器会生成另一个错误，您无法返回Task. 那么它是什么意思呢？我完全糊涂了。请帮我。
简介:在库方法中,何时应该使用async和await关键字而不是Task直接返回？
我相信我的问题与此问题有关.但是,这个问题是关于.NET 4.0和TPL,而我正在使用.NET 4.6 async和await关键字.所以,我认为我的问题可能得到不同的答案,因为在回答链接问题时这些关键字不存在.
说明:我正在为外部WCF服务编写一个简单的包装器,并且包装器会进行多次SendAsync调用.现在我认为每个包装器方法都应该直接返回Task<>,而不必等待.我的理解是async/ await应该在应用层上使用,而不是在库中.
因此,例如,我认为我应该为每个包装器方法采用的方法:
private Task<SignResponse> GetSignDataAsync(SigningRequestType request)
{
return _service.SendAsync(request);
}
但是在互联网上,我找到了几个使用这种方法的帖子:
private async Task<SignResponse> GetSignDataAsync(SigningRequestType request)
{
return await _service.SendAsync(request).ConfigureAwait(false);
}
这是我在technet上找到的另一个例子:
async Task PutTaskDelay()
{
await Task.Delay(5000);
}
private async void btnTaskDelay_Click(object sender, EventArgs e)
{
await PutTaskDelay();
MessageBox.Show("I am back");
}
那么,我何时应该使用第二种方法(包含 …
我应该将async/await添加到单行函数,如:
public async Task<T> GetFoo()
{
return await HandleAsync<T>(....);
}
或者如果参数不需要异步调用,这是不必要的开销,我可以简单地写:
public Task<T> GetFoo()
{
return HandleAsync<T>(....);
}
假设我有一个方法可以立即或类似地调用另一个异步方法:
//Main method
public async Task<int> Foo1( int x )
{
var result = await DoingSomethingAsync(x );
return DoSomethingElse(result );
}
//other method
public async Task<int> Foo2( Double double )
{
return await Foo1( Convert.ToInt32(double ) );
}
是否存在Foo2需要/应该具有异步/等待的特定原因,而不是简单地调用:
//other method
public Task<int> Foo3( Double double )
{
return Foo1( Convert.ToInt32( double ) );
}
在消费者中,无论如何,这仍然是等待的,不管:
int x = await Foo1(1);
int x = await Foo2(1D);
int x = await Foo3(1D);
所有这些陈述都将汇编.编译器会为两种不同的方法生成不同的IL吗？