Suprima la advertencia CS1998: este método asincrónico carece de 'espera'

Tengo una interfaz con algunas funciones asincrónicas. Algunas de las clases que implementan la interfaz no tienen nada que esperar, y algunas pueden simplemente lanzar. Es un poco molesto con todas las advertencias.

Cuando no se usa await en una función asincrónica.

¿Es posible suprimir el mensaje?

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

advertencia CS1998: este método asincrónico carece de operadores 'en espera' y se ejecutará de forma sincrónica. Considere usar el operador 'await' para esperar las llamadas API sin bloqueo, o 'await Task.Run (...)' para hacer un trabajo vinculado a la CPU en un hilo en segundo plano.

Tengo una interfaz con algunas funciones asincrónicas.

Los métodos regresan Task, creo. asynces un detalle de implementación, por lo que no se puede aplicar a métodos de interfaz.

Algunas de las clases que implementan la interfaz no tienen nada que esperar, y algunas pueden simplemente lanzar.

En estos casos, puede aprovechar el hecho de que asynces un detalle de implementación.

Si no tiene nada que hacer await, puede simplemente regresar Task.FromResult:

public Task<int> Success() // note: no "async"
{
  ... // non-awaiting code
  int result = ...;
  return Task.FromResult(result);
}

En el caso de lanzar NotImplementedException, el procedimiento es un poco más prolijo:

public Task<int> Fail() // note: no "async"
{
  var tcs = new TaskCompletionSource<int>();
  tcs.SetException(new NotImplementedException());
  return tcs.Task;
}

Si tiene muchos métodos lanzando NotImplementedException(lo que en sí mismo puede indicar que una refactorización a nivel de diseño sería buena), entonces podría resumir la palabra en una clase auxiliar:

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

La clase auxiliar también reduce la basura que el GC tendría que recolectar, ya que cada método con el mismo tipo de retorno puede compartir sus objetos Tasky NotImplementedException.

Tengo varios otros ejemplos de tipo "constante de tarea" en mi biblioteca AsyncEx .

Otra opción, si desea mantener el cuerpo de la función simple y no escribir código para admitirlo, es simplemente suprimir la advertencia con #pragma:

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

Si esto es lo suficientemente común, puede colocar la declaración de desactivación en la parte superior del archivo y omitir la restauración.

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

Otra forma de preservar la palabra clave async (en caso de que quiera mantenerla) es usar:

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

Una vez que complete el método, simplemente puede eliminar la declaración. Lo uso mucho, especialmente cuando un método puede esperar algo, pero no todas las implementaciones lo hacen.

Hay una diferencia entre las soluciones y, estrictamente hablando, debe saber cómo la persona que llama va a llamar al método asíncrono, pero con el patrón de uso predeterminado que asume ".Wait ()" en el resultado del método - " return Task.CompletedTask " es la mejor solución.

    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 |

Nota: FromResultno se puede comparar directamente.

Código de prueba:

   [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);
        }
    }

}

Sé que este es un hilo antiguo, y tal vez esto no tenga el efecto correcto para todos los usos, pero lo siguiente es lo más cerca que puedo llegar a poder simplemente lanzar una NotImplementedException cuando aún no he implementado un método, sin alterar la firma del método. Si es problemático, estaría feliz de saberlo, pero apenas me importa: de todos modos, solo uso esto mientras estoy en desarrollo, por lo que su rendimiento no es tan importante. Aún así, estaría feliz de saber por qué es una mala idea, si lo es.

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

Aquí está el tipo que agregué para hacerlo posible.

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

Solo como una actualización de Stephen's Answer, ya no necesita escribir la TaskConstantsclase ya que hay un nuevo método de ayuda:

    public Task ThrowException()
    {
        try
        {
            throw new NotImplementedException();
        }
        catch (Exception e)
        {
            return Task.FromException(e);
        }
    }

En caso de que ya se vincule con Reactive Extension, también puede hacer:

public async Task<object> NotImplemented()
{
    await Observable.Throw(new NotImplementedException(), null as object).ToTask();
}

public async Task<object> SimpleResult()
{
    await Observable.Return(myvalue).ToTask();
}

Reactive y async / await son increíbles por sí mismos, pero también funcionan bien juntos.

Los incluidos necesarios son:

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

Podría ocurrir cs1998 a continuación.

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

Entonces puedes reformar a continuación.

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

Puede intentar esto:

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

Prueba esto:

[System.Diagnostics.CodeAnalysis.SuppressMessage("Await.Warning", "CS1998:Await.Warning")]

Ver: https://docs.microsoft.com/en-us/dotnet/api/system.diagnostics.codeanalysis.suppressmessageattribute?view=netframework-4.7.2

Si no tiene nada que esperar, devuelva Task.FromResult

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

Aquí hay algunas alternativas dependiendo de la firma de su método.

    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());
    }

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

Puede eliminar la palabra clave async del método y hacer que devuelva Task;

    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();
            }
        }));
    }