C# chủ đề nền đơn giản

Question

Tôi đang tìm một cách đơn giản để thực hiện tác vụ ở chế độ nền, sau đó cập nhật nội dung nào đó (trên chuỗi chính) khi hoàn thành. Nó thuộc tầng lớp 'mô hình' mức thấp nên tôi không thể gọi InvokeOnMainThread vì tôi không có NSObject xung quanh. Tôi có phương pháp này:

public void GetItemsAsync(Action<Item[]> handleResult) 
{ 
    Item[] items=null; 
    Task task=Task.Factory.StartNew(() => 
    { 
    items=this.CreateItems(); // May take a second or two 
    }); 
    task.ContinueWith(delegate 
    { 
    handleResult(items); 
    }, TaskScheduler.FromCurrentSynchronizationContext()); 
} 

Điều này dường như làm việc OK, nhưng

1) Đây có phải là tốt nhất (đơn giản nhất) cách?

2) Tôi đang lo lắng về biến cục bộ:

Item{} items=null 

ngừng mà biến mất khi trở về phương pháp trước khi thread nền hoàn gì?

Cảm ơn.

Answer 1

Tôi nghĩ rằng phương pháp của bạn hơi vi phạm một Single Responsibility Principle, bởi vì nó làm quá nhiều.

Trước hết tôi đề nghị thay đổi CreateItems trở Task thay vì gói nó trong GetItemsAsync:

public Task<Item[]> CreateItems(CancellationToken token) 
{ 
    return Task.Factory.StartNew(() => 
    // obtaining the data... 
    {}); 
} 

CancellationToken là không bắt buộc nhưng có thể giúp bạn nếu bạn có thể hủy bỏ này hoạt động dài chạy.

Với phương pháp này, bạn có thể loại bỏ hoàn toàn GetItemsAsync vì nó đơn giản như vậy để xử lý kết quả theo khách hàng của bạn mà không đi đại biểu này:

// Somewhere in the client of your class 
var task = yourClass.CreateItems(token); 
task.ContinueWith(t => 
// Code of the delegate that previously 
// passed to GetItemsAsync method 
{}, TaskScheduler.FromCurrentSynchronizationContext()); 

Sử dụng phương pháp này, bạn sẽ nhận được mã rõ ràng hơn chỉ với một trách nhiệm. Task chính lớp là công cụ hoàn hảo để biểu diễn hoạt động không đồng bộ dưới dạng first class object. Sử dụng kỹ thuật được đề xuất, bạn có thể dễ dàng giả lập bạn thực hiện hiện tại bằng hành vi giả mạo để kiểm tra đơn vị mà không thay đổi mã máy khách của bạn.

Answer 2

Mã của bạn có vẻ ổn.

Đây là ví dụ hoàn hảo về thời điểm sử dụng async/await nếu bạn có thể sử dụng C# 5, nhưng nếu không, bạn phải viết nó như bạn đã làm với phần tiếp theo.

Biến số items được ghi lại trong lambdas của bạn, vì vậy cũng tốt.

Khi bạn viết một lambda sử dụng một biến bên ngoài, trình biên dịch C# tạo ra một lớp có chứa biến. Điều này được gọi là đóng cửa và có nghĩa là bạn có thể truy cập biến bên trong lambda của bạn.

Answer 3

Đây là một soultion đẹp hơn:

public void GetItemsAsync(Action<Item[]> handleResult) 
    { 
     var task = Task.Factory.StartNew<Item[]>(() => 
     { 
      return this.CreateItems(); // May take a second or two 
     }); 

     task.ContinueWith(delegate 
     { 
      handleResult(task.Result); 
     }, TaskScheduler.FromCurrentSynchronizationContext()); 
    } 

Answer 4

Something như thế này:

public void GetItemsAsync(Action<Item[]> handleResult) 
    { 
     int Id = 11; 
     Task<Item[]> task = Task.Factory.StartNew(() => CreateItems(Id)); // May take a second or two 
     task.ContinueWith(t => handleResult(t.Result), TaskScheduler.FromCurrentSynchronizationContext()); 
    }