Cách triển khai phương thức giao diện trả về tác vụ <T>?

Question

Tôi có một giao diện

interface IFoo 
{ 
    Task<Bar> CreateBarAsync(); 
} 

Có hai phương pháp để tạo ra Bar, một không đồng bộ và một đồng bộ. Tôi muốn cung cấp một giao diện thực hiện cho mỗi một trong hai phương pháp này.

Đối với phương pháp không đồng bộ, việc thực hiện có thể nhìn như thế này:

class Foo1 : IFoo 
{ 
    async Task<Bar> CreateBarAsync() 
    { 
    return await AsynchronousBarCreatorAsync(); 
    } 
} 

Nhưng CÁCH tôi nên thực hiện các lớp Foo2 mà sử dụng đồng bộ phương pháp để tạo Bar?

tôi thể thực hiện các phương pháp để chạy đồng bộ:

async Task<Bar> CreateBarAsync() 
    { 
    return SynchronousBarCreator(); 
    } 

thì Trình biên dịch sẽ cảnh báo chống lại bằng async trong phương pháp chữ ký:

phương pháp

async này thiếu 'await' khai thác và sẽ chạy đồng bộ. Xem xét sử dụng toán tử 'await' để đợi các cuộc gọi API không chặn hoặc 'đang chờ Task.Run (...)' để thực hiện công việc liên kết CPU trên một chuỗi nền.

Hoặc, tôi có thể thực hiện phương thức để trả lại rõ ràng Task<Bar>. Theo ý kiến ​​của tôi, mã sẽ trông ít có thể đọc được:

Task<Bar> CreateBarAsync() 
    { 
    return Task.Run(() => SynchronousBarCreator()); 
    } 

Từ quan điểm hiệu năng, tôi cho rằng cả hai phương pháp đều có cùng chi phí, hoặc?

Tôi nên chọn phương pháp nào; thực hiện phương thức async đồng bộ hoặc kết nối rõ ràng cuộc gọi phương thức đồng bộ trong Task?

EDIT

Dự án tôi đang làm việc trên thực sự là một dự án 4 NET với async/chờ phần mở rộng từ gói Microsoft Async NuGet. Trên .NET 4, Task.Run sau đó có thể được thay thế bằng TaskEx.Run. Tôi đã sử dụng phương thức .NET 4.5 một cách có ý thức trong ví dụ trên với hy vọng làm cho câu hỏi chính rõ ràng hơn.

Answer 1

Khi bạn phải thực hiện một phương pháp async từ một giao diện và thực hiện của bạn là đồng bộ, bạn có thể sử dụng Ned của giải pháp:

public Task<Bar> CreateBarAsync() 
{ 
    return Task.FromResult<Bar>(SynchronousBarCreator()); 
} 

Với giải pháp này, phương pháp này trông async nhưng là đồng bộ.

Hoặc giải pháp bạn đề xuất:

Task<Bar> CreateBarAsync() 
    { 
    return Task.Run(() => SynchronousBarCreator()); 
    } 

Bằng cách này phương pháp này là thực sự async.

Bạn không có giải pháp chung chung phù hợp với tất cả các trường hợp "Cách triển khai phương thức giao diện trả về tác vụ". Nó phụ thuộc vào ngữ cảnh: việc triển khai của bạn có đủ nhanh để gọi nó trên một luồng khác là vô ích không? Giao diện này được sử dụng như thế nào khi phương thức này được gọi (nó sẽ đóng băng ứng dụng)? Thậm chí có thể gọi triển khai của bạn trong một chuỗi khác không?

Answer 2

Hãy thử điều này:

class Foo2 : IFoo 
{ 
    public Task<Bar> CreateBarAsync() 
    { 
     return Task.FromResult<Bar>(SynchronousBarCreator()); 
    } 
} 

Task.FromResult tạo ra một nhiệm vụ đã hoàn thành của các loại quy định sử dụng các giá trị cung cấp.

Answer 3

Nếu bạn đang sử dụng .NET 4.0, bạn có thể sử dụng TaskCompletionSource<T>:

Task<Bar> CreateBarAsync() 
{ 
    var tcs = new TaskCompletionSource<Bar>(); 
    tcs.SetResult(SynchronousBarCreator()); 
    return tcs.Task 
} 

Cuối cùng, nếu theres không có gì không đồng bộ về phương pháp của bạn, bạn nên cân nhắc để lộ một thiết bị đầu cuối đồng bộ (CreateBar) mà tạo ra một mới Bar.Bằng cách đó không có bất ngờ và không cần phải bọc với một dư thừa Task.

Answer 4

Để bổ sung cho những người khác câu trả lời, có một lựa chọn hơn, mà tôi tin rằng công trình với .NET 4.0 quá:

class Foo2 : IFoo 
{ 
    public Task<Bar> CreateBarAsync() 
    { 
     var task = new Task<Bar>(() => SynchronousBarCreator()); 
     task.RunSynchronously(); 
     return task; 
    } 
} 

Note task.RunSynchronously(). Nó có thể là tùy chọn chậm nhất, so với Task<>.FromResult và TaskCompletionSource<>.SetResult, nhưng có sự khác biệt quan trọng nhưng quan trọng: hành vi truyền bá lỗi.

Cách tiếp cận trên sẽ bắt chước hành vi của phương pháp async, trong đó ngoại lệ không bao giờ được ném trên cùng một khung ngăn xếp (tháo ra), nhưng được lưu trữ không hoạt động bên trong đối tượng Task. Người gọi thực sự phải quan sát nó qua await task hoặc task.Result, tại thời điểm đó người gọi sẽ được quay lại.

Đây không phải là trường hợp với Task<>.FromResult và TaskCompletionSource<>.SetResult, trong đó bất kỳ ngoại lệ nào được ném bởi SynchronousBarCreator sẽ được truyền trực tiếp đến người gọi, thư giãn ngăn xếp cuộc gọi.

Tôi có giải thích chi tiết hơn một chút về điều này ở đây:

Any difference between "await Task.Run(); return;" and "return Task.Run()"?

Trên một mặt lưu ý, tôi đề nghị bổ sung một điều khoản cho hủy khi thiết kế giao diện (ngay cả khi hủy hiện không sử dụng/triển khai):

interface IFoo 
{ 
    Task<Bar> CreateBarAsync(CancellationToken token); 
} 

class Foo2 : IFoo 
{ 
    public Task<Bar> CreateBarAsync(CancellationToken token) 
    { 
     var task = new Task<Bar>(() => SynchronousBarCreator(), token); 
     task.RunSynchronously(); 
     return task; 
    } 
}