Предупреждение о подавлении CS1998: в этом асинхронном методе отсутствует "ожидание",

У меня есть интерфейс с некоторыми асинхронными функциями. Некоторым классам, которые реализуют интерфейс, нечего ждать, а некоторые могут просто бросить. Это немного раздражает всеми предупреждениями.

Если не использовать ожидание в асинхронной функции.

Можно ли подавить сообщение?

public async Task<object> test()
{
    throw new NotImplementedException();
}

warning CS1998: в этом асинхронном методе отсутствуют операторы "ждут" и будут выполняться синхронно. Рассмотрите возможность использования оператора ожидания неблокирующие вызовы API или "ждут Task.Run(...)" для работы с ЦП на фоновом потоке.

ОТВЕТЫ

Ответ 1

У меня есть интерфейс с некоторыми асинхронными функциями.

Способы возвращения 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;
}

Вспомогательный класс также уменьшает мусор, который GC должен был бы собрать, поскольку каждый метод с одним и тем же типом возвращаемого типа может делиться своими объектами Task и NotImplementedException.

У меня есть несколько других "констант задачи" в моей библиотеке AsyncEx.

Ответ 2

Другой вариант, если вы хотите, чтобы тело функции было простым и не записывало код для его поддержки, просто нужно подавить предупреждение с помощью #pragma:

#pragma warning disable 1998
public async Task<object> Test()
{
    throw new NotImplementedException();
}
#pragma warning restore 1998

Если это достаточно распространено, вы можете поместить оператор disable в верхнюю часть файла и опустить восстановление.

http://msdn.microsoft.com/en-us/library/441722ys(v=vs.110).aspx

Ответ 3

Другой способ сохранить ключевое слово async (в случае, если вы хотите его сохранить) - использовать:

public async Task StartAsync()
{
    await Task.Yield();
}

После заполнения метода вы можете просто удалить инструкцию. Я использую это особенно особенно, когда метод может что-то ждать, но не всякая реализация на самом деле делает.

Ответ 4

Так же, как обновление для Stephen Answer, вам больше не нужно писать класс TaskConstants, так как есть новый вспомогательный метод:

return Task.FromException(new NotImplementedException());

Ответ 5

Между решениями есть разница, и, строго говоря, вы должны знать, как вызывающая сторона будет вызывать асинхронный метод, но с шаблоном использования по умолчанию, который предполагает ".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);
        }
    }

}

Ответ 6

Я знаю, что это старый поток, и, возможно, это не будет иметь правильного эффекта для всех обычаев, но следующее настолько близко, насколько я могу получить возможность просто выбросить исключение NotImplementedException, когда я еще не реализовал метод, не изменяя подписи метода. Если это проблематично, я был бы рад узнать об этом, но это едва ли имеет значение для меня: я использую это только при разработке, так что, как это работает, это не так важно. Тем не менее, я был бы рад услышать, почему это плохая идея, если она есть.

public 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;
    }
}

Ответ 7

Если вы уже ссылаетесь на 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();
}

Реактивный и асинхронный/ожидающий оба удивительны и сами по себе, но они также хорошо сочетаются.

Включаются следующие требования:

using System.Reactive.Linq;
using System.Reactive.Threading.Tasks;

Ответ 8

Это может произойти cs1998 ниже.

public async Task<object> Foo()
{
    return object;
}

Затем вы можете провести реформу ниже.

public async Task<object> Foo()
{
    var result = await Task.Run(() =>
    {
        return object;
    });
    return result;
}

Ответ 9

Если вам нечего ждать, верните Task.FromResult

public Task<int> Success() // note: no "async"
{
  ... // Do not have await code
  var result = ...;
  return Task.FromResult(result);
}

Ответ 10

Вот несколько альтернатив в зависимости от вашей сигнатуры метода.

    public async Task Test1()
    {
        await Task.CompletedTask;
    }

    public async Task<object> Test2()
    {
        return await Task.FromResult<object>(null);
    }

    public async Task<object> Test3()
    {
        return await Task.FromException<object>(new NotImplementedException());
    }

Ответ 12

Сначала я нашел способ обойти это предупреждение:

public async Task<object> test()
{
    //a pseudo code just to disable the warning about lack of await in async code!
    var xyz = true ? 0 : await Task.FromResult(0); //use a var name that not used later

    //... your code statements as normal, eg:
    //throw new NotImplementedException();
}

Это псевдокод для отключения предупреждения об отсутствии await в методе asycn! существование этого ключевого слова await обманет компилятор и не выдаст предупреждение, даже если мы знаем, что оно никогда не будет вызвано! поскольку условие true оно всегда возвращает первую часть троичного условного выражения (? :), а также, поскольку эта переменная не используется, она будет опущена в сборках Release. Я не уверен, есть ли какие-либо побочные эффекты с этим подходом.

Кроме того, я обнаружил, что этот простой метод используется в исходном коде ядра asp.net(TagHelper.cs), но для этого необходимо удалить ключевое слово async из строки сигнатуры метода:

return Task.CompletedTask;

Вот более полный код:

public abstract class TagHelper : ITagHelper, ITagHelperComponent
{

    public virtual void Process(TagHelperContext context, TagHelperOutput output)
    {
    }

    public virtual Task ProcessAsync(TagHelperContext context, TagHelperOutput output)
    {
        Process(context, output);
        return Task.CompletedTask; // *** this will avoid the lacks await warning!
    }
}

Ответ 13

Вы можете попробовать это:

public async Task<object> test()
{
await Task.CompletedTask; 
}

Ответ 14

// This is to get rid of warning CS1998, please remove when implementing this method.
await new Task(() => { }).ConfigureAwait(false);
throw new NotImplementedException();

Ответ 15

Вы можете удалить ключевое слово async из метода и просто вернуть ему задачу;

    public async Task DoTask()
    {
        State = TaskStates.InProgress;
        await RunTimer();
    }

    public Task RunTimer()
    {
        return new Task(new Action(() =>
        {
            using (var t = new time.Timer(RequiredTime.Milliseconds))
            {
                t.Elapsed += ((x, y) => State = TaskStates.Completed);
                t.Start();
            }
        }));
    }