我有一个接口，其中一些函数返回Task。实现该接口的某些类没有任何需要等待的内容，而其他类可能会抛出异常-因此警告是虚假和烦人的。
有没有可能抑制这些警告？例如：
public async Task<object> test()
{
throw new NotImplementedException();
}
产生：
警告 CS1998：此异步方法缺少“await”运算符，将同步运行。 请考虑使用“await”运算符等待非阻塞API调用， 或使用“await Task.Run（...）”在后台线程上执行CPU绑定的工作。
我有一个带有一些异步函数的接口。
我相信这些方法返回Task。由于async是一种实现细节，因此不能应用于接口方法。
一些实现该接口的类没有任何东西需要等待，有些可能会抛出异常。
在这些情况下，可以利用async是一种实现细节的特点。
如果你没有要await的内容，那么可以直接返回Task.FromResult：
public Task<int> Success() // note: no "async"
{
... // non-awaiting code
int result = ...;
return Task.FromResult(result);
}
如果抛出NotImplementedException，则流程会更加冗长：
public Task<int> Fail() // note: no "async"
{
var tcs = new TaskCompletionSource<int>();
tcs.SetException(new NotImplementedException());
return tcs.Task;
}
如果你有很多方法会抛出NotImplementedException（这本身可能表明需要进行某些设计层面的重构），那么你可以将冗长的代码封装到一个帮助类中：
public static class TaskConstants<TResult>
{
static TaskConstants()
{
var tcs = new TaskCompletionSource<TResult>();
tcs.SetException(new NotImplementedException());
NotImplemented = tcs.Task;
}
public static Task<TResult> NotImplemented { get; private set; }
}
public Task<int> Fail() // note: no "async"
{
return TaskConstants<int>.NotImplemented;
}
这个辅助类还有一个好处是减少了垃圾回收器要收集的无用对象，因为每个返回类型相同的方法都可以共用 Task 和 NotImplementedException 对象。
我的AsyncEx库中有几个其他的"任务常量"类型示例。
Task中被抛出。相反，您的方法将在它甚至有机会创建一个Task之前就抛出异常。我认为最好的模式是定义一个没有await操作符的异步方法。这样可以确保方法内部的所有代码都被视为Task的一部分。 - Bob Meyersawait Task.FromResult(0);。这样做不会对性能产生显着影响（不像 Task.Yield()）。 - Bob Meyersreturn Task.CompletedTask; 来完成最简单的任务。 - Stephen Cleary如果您想保持函数体简单，而不编写支持代码，则另一种选择是使用#pragma来简单地禁止警告：
#pragma warning disable 1998
public async Task<object> Test()
{
throw new NotImplementedException();
}
#pragma warning restore 1998
如果这种情况很常见，你可以把禁用语句放在文件顶部并省略恢复。
http://msdn.microsoft.com/zh-cn/library/441722ys(v=vs.110).aspx
如果您想保留async关键字，另一种方法是使用：
public async Task StartAsync()
{
await Task.Yield();
}
一旦你填充了该方法，你可以简单地删除该语句。 我经常使用它，特别是当一个方法可能等待某些东西，但并不是每个实现都需要。
Task.CompletedTask 看起来不再存在了。 - Sebastián VansteenkisteTask.FromResult 是更好的答案。就此而言，如果您确实要抛出异常，似乎已经有另一个回答涉及到 Task.FromException，这使得这永远不是理想的解决方案。您同意吗？ - BlueMonkMN解决方案和严格意义上的说法是有区别的，你应该知道调用异步方法的调用者会如何调用，但是使用默认的使用模式假设在方法结果上使用 ".Wait()" - "return Task.CompletedTask" 是最好的解决方案。
BenchmarkDotNet=v0.10.11, OS=Windows 10 Redstone 3 [1709, Fall Creators Update] (10.0.16299.192)
Processor=Intel Core i5-2500K CPU 3.30GHz (Sandy Bridge), ProcessorCount=4
Frequency=3233537 Hz, Resolution=309.2589 ns, Timer=TSC
.NET Core SDK=2.1.2
[Host] : .NET Core 2.0.3 (Framework 4.6.25815.02), 64bit RyuJIT
Clr : .NET Framework 4.7 (CLR 4.0.30319.42000), 64bit RyuJIT-v4.7.2600.0
Core : .NET Core 2.0.3 (Framework 4.6.25815.02), 64bit RyuJIT
Method | Job | Runtime | Mean | Error | StdDev | Median | Min | Max | Rank | Gen 0 | Gen 1 | Gen 2 | Allocated |
--------------- |----- |-------- |-------------:|------------:|------------:|-------------:|-------------:|-------------:|-----:|-------:|-------:|-------:|----------:|
CompletedAwait | Clr | Clr | 95.253 ns | 0.7491 ns | 0.6641 ns | 95.100 ns | 94.461 ns | 96.557 ns | 7 | 0.0075 | - | - | 24 B |
Completed | Clr | Clr | 12.036 ns | 0.0659 ns | 0.0617 ns | 12.026 ns | 11.931 ns | 12.154 ns | 2 | 0.0076 | - | - | 24 B |
Pragma | Clr | Clr | 87.868 ns | 0.3923 ns | 0.3670 ns | 87.789 ns | 87.336 ns | 88.683 ns | 6 | 0.0075 | - | - | 24 B |
FromResult | Clr | Clr | 107.009 ns | 0.6671 ns | 0.6240 ns | 107.009 ns | 106.204 ns | 108.247 ns | 8 | 0.0584 | - | - | 184 B |
Yield | Clr | Clr | 1,766.843 ns | 26.5216 ns | 24.8083 ns | 1,770.383 ns | 1,705.386 ns | 1,800.653 ns | 9 | 0.0877 | 0.0038 | 0.0019 | 320 B |
CompletedAwait | Core | Core | 37.201 ns | 0.1961 ns | 0.1739 ns | 37.227 ns | 36.970 ns | 37.559 ns | 4 | 0.0076 | - | - | 24 B |
Completed | Core | Core | 9.017 ns | 0.0690 ns | 0.0577 ns | 9.010 ns | 8.925 ns | 9.128 ns | 1 | 0.0076 | - | - | 24 B |
Pragma | Core | Core | 34.118 ns | 0.4576 ns | 0.4281 ns | 34.259 ns | 33.437 ns | 34.792 ns | 3 | 0.0076 | - | - | 24 B |
FromResult | Core | Core | 46.953 ns | 1.2728 ns | 1.1905 ns | 46.467 ns | 45.674 ns | 49.868 ns | 5 | 0.0533 | - | - | 168 B |
Yield | Core | Core | 2,480.980 ns | 199.4416 ns | 575.4347 ns | 2,291.978 ns | 1,810.644 ns | 4,085.196 ns | 10 | 0.0916 | - | - | 296 B |
FromResult 不能直接比较。 [RankColumn, MinColumn, MaxColumn, StdDevColumn, MedianColumn]
[ClrJob, CoreJob]
[HtmlExporter, MarkdownExporter]
[MemoryDiagnoser]
public class BenchmarkAsyncNotAwaitInterface
{
string context = "text context";
[Benchmark]
public int CompletedAwait()
{
var t = new CompletedAwaitTest();
var a = t.DoAsync(context);
a.Wait();
return t.Length;
}
[Benchmark]
public int Completed()
{
var t = new CompletedTest();
var a = t.DoAsync(context);
a.Wait();
return t.Length;
}
[Benchmark]
public int Pragma()
{
var t = new PragmaTest();
var a = t.DoAsync(context);
a.Wait();
return t.Length;
}
[Benchmark]
public int Yield()
{
var t = new YieldTest();
var a = t.DoAsync(context);
a.Wait();
return t.Length;
}
[Benchmark]
public int FromResult()
{
var t = new FromResultTest();
var t2 = t.DoAsync(context);
return t2.Result;
}
public interface ITestInterface
{
int Length { get; }
Task DoAsync(string context);
}
class CompletedAwaitTest : ITestInterface
{
public int Length { get; private set; }
public async Task DoAsync(string context)
{
Length = context.Length;
await Task.CompletedTask;
}
}
class CompletedTest : ITestInterface
{
public int Length { get; private set; }
public Task DoAsync(string context)
{
Length = context.Length;
return Task.CompletedTask;
}
}
class PragmaTest : ITestInterface
{
public int Length { get; private set; }
#pragma warning disable 1998
public async Task DoAsync(string context)
{
Length = context.Length;
return;
}
#pragma warning restore 1998
}
class YieldTest : ITestInterface
{
public int Length { get; private set; }
public async Task DoAsync(string context)
{
Length = context.Length;
await Task.Yield();
}
}
public interface ITestInterface2
{
Task<int> DoAsync(string context);
}
class FromResultTest : ITestInterface2
{
public async Task<int> DoAsync(string context)
{
var i = context.Length;
return await Task.FromResult(i);
}
}
}
#pragma 看起来会产生开销。可能与返回 CompletedTask 相比，创建并完成 AsyncOperation 会有同样的开销。如果能够告诉编译器在方法同步运行时可以跳过它，那就太好了。 - binkiTask.CompletedTask 和 Task.FromResult 有多相似？很有趣，我认为 FromResult 是最类似的，如果你需要返回一个值，它仍然是最佳选择。 - BlueMonkMNpublic async Task<object> test()
{
throw await new AwaitableNotImplementedException<object>();
}
这是我添加的类型，使这成为可能。
public class AwaitableNotImplementedException<TResult> : NotImplementedException
{
public AwaitableNotImplementedException() { }
public AwaitableNotImplementedException(string message) : base(message) { }
// This method makes the constructor awaitable.
public TaskAwaiter<AwaitableNotImplementedException<TResult>> GetAwaiter()
{
throw this;
}
}
给大家更新一下Stephen的答案，现在不需要再编写TaskConstants类了，因为有一个新的助手方法：
public Task ThrowException()
{
try
{
throw new NotImplementedException();
}
catch (Exception e)
{
return Task.FromException(e);
}
}
您可以尝试以下方法：
public async Task<object> test()
{
await Task.CompletedTask;
}
全局配置/禁用：
在 .editorconfig 文件中
# CS1998: Async method lacks 'await' operators and will run synchronously
dotnet_diagnostic.CS1998.severity = suggestion
如果您已经链接了Reactive Extension，您还可以执行以下操作：
public async Task<object> NotImplemented()
{
await Observable.Throw(new NotImplementedException(), null as object).ToTask();
}
public async Task<object> SimpleResult()
{
await Observable.Return(myvalue).ToTask();
}
响应式编程和async/await本身都非常出色，但它们也可以很好地结合在一起。
需要包括：
using System.Reactive.Linq;
using System.Reactive.Threading.Tasks;
[System.Diagnostics.CodeAnalysis.SuppressMessage("Await.Warning", "CS1998:Await.Warning")]
详见：
https://learn.microsoft.com/en-us/dotnet/api/system.diagnostics.codeanalysis.suppressmessageattribute?view=netframework-4.7.2
#pragma warning disable 1998可以特别回答实际提出的问题...即“是否可能抑制这些警告？” - Simon Sanderson