Tôi có một giao diện hiển thị một số phương thức không đồng bộ. Cụ thể hơn, nó có các phương thức được định nghĩa trả về Task hoặc Task <T>. Tôi đang sử dụng từ khóa async / await.

Tôi đang trong quá trình thực hiện giao diện này. Tuy nhiên, trong một số phương pháp này, việc triển khai này không có gì để chờ đợi. Vì lý do đó, tôi nhận được cảnh báo trình biên dịch "Phương thức không đồng bộ này thiếu toán tử 'chờ đợi' và sẽ chạy đồng bộ ..."

Tôi hiểu lý do tại sao tôi nhận được lỗi nhưng đang tự hỏi liệu tôi có nên làm bất cứ điều gì với chúng trong bối cảnh này hay không. Thật sai lầm khi bỏ qua cảnh báo của trình biên dịch.

Tôi biết mình có thể sửa nó bằng cách đợi Task.Run nhưng điều đó cảm thấy không ổn đối với một phương pháp chỉ thực hiện một vài thao tác rẻ tiền. Nó cũng có vẻ như nó sẽ thêm chi phí không cần thiết vào quá trình thực thi nhưng sau đó tôi cũng không chắc liệu đã có chưa vì từ khóa async hiện diện.

Tôi có nên bỏ qua các cảnh báo hay có cách giải quyết vấn đề này mà tôi không thấy?

Các async từ khóa chỉ là một chi tiết thi hành một phương pháp; nó không phải là một phần của chữ ký phương thức. Nếu việc triển khai hoặc ghi đè một phương pháp cụ thể không có gì để chờ đợi, thì chỉ cần bỏ qua từ khóa async và trả về một tác vụ đã hoàn thành bằng Task.FromResult <TResult> :

public Task<string> Foo()               //    public async Task<string> Foo()
{                                       //    {
    Baz();                              //        Baz();
    return Task.FromResult("Hello");    //        return "Hello";
}                                       //    }

Nếu phương thức của bạn trả về Tác vụ thay vì Tác vụ <Kết quả> , thì bạn có thể trả về tác vụ đã hoàn thành thuộc bất kỳ loại và giá trị nào. Task.FromResult(0)dường như là một lựa chọn phổ biến:

public Task Bar()                       //    public async Task Bar()
{                                       //    {
    Baz();                              //        Baz();
    return Task.FromResult(0);          //
}                                       //    }

Hoặc, kể từ .NET Framework 4.6, bạn có thể trả về Task.CompletedTask :

public Task Bar()                       //    public async Task Bar()
{                                       //    {
    Baz();                              //        Baz();
    return Task.CompletedTask;          //
}                                       //    }

Hoàn toàn hợp lý khi một số hoạt động "không đồng bộ" hoàn thành đồng bộ, nhưng vẫn tuân theo mô hình gọi không đồng bộ vì lợi ích của tính đa hình.

Một ví dụ thực tế về điều này là với các API I / O của hệ điều hành. Các cuộc gọi không đồng bộ và chồng chéo trên một số thiết bị luôn hoàn thành nội tuyến (ví dụ: ghi vào đường ống được triển khai bằng bộ nhớ dùng chung). Nhưng chúng thực hiện cùng một giao diện như các hoạt động nhiều phần vẫn tiếp tục trong nền.

Michael Liu đã trả lời tốt câu hỏi của bạn về cách bạn có thể tránh cảnh báo: bằng cách trả lại Task.FromResult.

Tôi sẽ trả lời phần "Tôi có nên lo lắng về cảnh báo" trong câu hỏi của bạn.

Câu trả lời là Có!

Lý do cho điều này là cảnh báo thường xuất hiện khi bạn gọi một phương thức trả về Taskbên trong một phương thức không đồng bộ mà không có awaittoán tử. Tôi vừa sửa một lỗi đồng thời đã xảy ra vì tôi đã gọi một thao tác trong Entity Framework mà không đợi thao tác trước đó.

Nếu bạn có thể viết mã một cách tỉ mỉ để tránh các cảnh báo của trình biên dịch, thì khi có cảnh báo, nó sẽ nổi bật lên như một ngón tay cái đau. Tôi có thể tránh được vài giờ gỡ lỗi.

Có thể đã quá muộn nhưng nó có thể là một cuộc điều tra hữu ích:

Có về cấu trúc bên trong của mã đã biên dịch ( IL ):

 public static async Task<int> GetTestData()
    {
        return 12;
    }

nó trở thành trong IL:

.method private hidebysig static class [mscorlib]System.Threading.Tasks.Task`1<int32> 
        GetTestData() cil managed
{
  .custom instance void [mscorlib]System.Runtime.CompilerServices.AsyncStateMachineAttribute::.ctor(class [mscorlib]System.Type) = ( 01 00 28 55 73 61 67 65 4C 69 62 72 61 72 79 2E   // ..(UsageLibrary.
                                                                                                                                     53 74 61 72 74 54 79 70 65 2B 3C 47 65 74 54 65   // StartType+<GetTe
                                                                                                                                     73 74 44 61 74 61 3E 64 5F 5F 31 00 00 )          // stData>d__1..
  .custom instance void [mscorlib]System.Diagnostics.DebuggerStepThroughAttribute::.ctor() = ( 01 00 00 00 ) 
  // Code size       52 (0x34)
  .maxstack  2
  .locals init ([0] class UsageLibrary.StartType/'<GetTestData>d__1' V_0,
           [1] valuetype [mscorlib]System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1<int32> V_1)
  IL_0000:  newobj     instance void UsageLibrary.StartType/'<GetTestData>d__1'::.ctor()
  IL_0005:  stloc.0
  IL_0006:  ldloc.0
  IL_0007:  call       valuetype [mscorlib]System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1<!0> valuetype [mscorlib]System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1<int32>::Create()
  IL_000c:  stfld      valuetype [mscorlib]System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1<int32> UsageLibrary.StartType/'<GetTestData>d__1'::'<>t__builder'
  IL_0011:  ldloc.0
  IL_0012:  ldc.i4.m1
  IL_0013:  stfld      int32 UsageLibrary.StartType/'<GetTestData>d__1'::'<>1__state'
  IL_0018:  ldloc.0
  IL_0019:  ldfld      valuetype [mscorlib]System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1<int32> UsageLibrary.StartType/'<GetTestData>d__1'::'<>t__builder'
  IL_001e:  stloc.1
  IL_001f:  ldloca.s   V_1
  IL_0021:  ldloca.s   V_0
  IL_0023:  call       instance void valuetype [mscorlib]System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1<int32>::Start<class UsageLibrary.StartType/'<GetTestData>d__1'>(!!0&)
  IL_0028:  ldloc.0
  IL_0029:  ldflda     valuetype [mscorlib]System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1<int32> UsageLibrary.StartType/'<GetTestData>d__1'::'<>t__builder'
  IL_002e:  call       instance class [mscorlib]System.Threading.Tasks.Task`1<!0> valuetype [mscorlib]System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1<int32>::get_Task()
  IL_0033:  ret
} // end of method StartType::GetTestData

Và không có phương thức không đồng bộ và tác vụ:

 public static int GetTestData()
        {
            return 12;
        }

trở thành:

.method private hidebysig static int32  GetTestData() cil managed
{
  // Code size       8 (0x8)
  .maxstack  1
  .locals init ([0] int32 V_0)
  IL_0000:  nop
  IL_0001:  ldc.i4.s   12
  IL_0003:  stloc.0
  IL_0004:  br.s       IL_0006
  IL_0006:  ldloc.0
  IL_0007:  ret
} // end of method StartType::GetTestData

Như bạn có thể thấy sự khác biệt lớn giữa các phương pháp này. Nếu bạn không sử dụng phương thức await bên trong async và không quan tâm đến việc sử dụng phương thức async (ví dụ: lệnh gọi API hoặc trình xử lý sự kiện), thì ý kiến ​​hay là chuyển nó sang phương thức đồng bộ thông thường (nó tiết kiệm hiệu suất ứng dụng của bạn).

Đã cập nhật:

Ngoài ra còn có thông tin bổ sung từ tài liệu microsoft https://docs.microsoft.com/en-us/dotnet/standard/async-in-depth :

các phương thức async cần phải có một từ khóa đang chờ trong nội dung của chúng nếu không chúng sẽ không bao giờ mang lại kết quả! Đây là điều quan trọng cần ghi nhớ. Nếu await không được sử dụng trong phần thân của một phương thức không đồng bộ, trình biên dịch C # sẽ tạo ra một cảnh báo, nhưng mã sẽ biên dịch và chạy như thể nó là một phương thức bình thường. Lưu ý rằng điều này cũng sẽ cực kỳ kém hiệu quả, vì máy trạng thái được tạo bởi trình biên dịch C # cho phương thức không đồng bộ sẽ không hoàn thành bất cứ điều gì.

Lưu ý về hành vi ngoại lệ khi quay lại Task.FromResult

Đây là một bản demo nhỏ cho thấy sự khác biệt trong việc xử lý ngoại lệ giữa các phương pháp được đánh dấu và không được đánh dấu bằng async.

public Task<string> GetToken1WithoutAsync() => throw new Exception("Ex1!");

// Warning: This async method lacks 'await' operators and will run synchronously. Consider ...
public async Task<string> GetToken2WithAsync() => throw new Exception("Ex2!");  

public string GetToken3Throws() => throw new Exception("Ex3!");
public async Task<string> GetToken3WithAsync() => await Task.Run(GetToken3Throws);

public async Task<string> GetToken4WithAsync() { throw new Exception("Ex4!"); return await Task.FromResult("X");} 


public static async Task Main(string[] args)
{
    var p = new Program();

    try { var task1 = p.GetToken1WithoutAsync(); } 
    catch( Exception ) { Console.WriteLine("Throws before await.");};

    var task2 = p.GetToken2WithAsync(); // Does not throw;
    try { var token2 = await task2; } 
    catch( Exception ) { Console.WriteLine("Throws on await.");};

    var task3 = p.GetToken3WithAsync(); // Does not throw;
    try { var token3 = await task3; } 
    catch( Exception ) { Console.WriteLine("Throws on await.");};

    var task4 = p.GetToken4WithAsync(); // Does not throw;
    try { var token4 = await task4; } 
    catch( Exception ) { Console.WriteLine("Throws on await.");};
}

// .NETCoreApp,Version=v3.0
Throws before await.
Throws on await.
Throws on await.
Throws on await.

(Bài đăng chéo câu trả lời của tôi cho Khi không đồng bộ Tác vụ <T> theo yêu cầu của giao diện, cách lấy biến trả về mà không có cảnh báo trình biên dịch )