Việc không gọi Dispose () trên một đối tượng TPL Task có được coi là chấp nhận được không?

Tôi muốn kích hoạt một tác vụ để chạy trên một chuỗi nền. Tôi không muốn chờ đợi khi hoàn thành nhiệm vụ.

Trong .net 3.5, tôi sẽ làm điều này:

ThreadPool.QueueUserWorkItem(d => { DoSomething(); });

Trong .net 4, TPL là cách được đề xuất. Mô hình phổ biến mà tôi đã thấy được đề xuất là:

Task.Factory.StartNew(() => { DoSomething(); });

Tuy nhiên, StartNew()phương thức trả về một Taskđối tượng thực hiện IDisposable. Điều này dường như bị bỏ qua bởi những người giới thiệu mẫu này. Tài liệu MSDN về Task.Dispose()phương pháp cho biết:

"Luôn gọi Vứt bỏ trước khi bạn phát hành tham chiếu cuối cùng của mình cho Tác vụ."

Bạn không thể gọi hủy bỏ một nhiệm vụ cho đến khi nó hoàn thành, vì vậy, việc để luồng chính chờ và xử lý lệnh gọi sẽ đánh bại quan điểm của việc thực hiện trên một luồng nền ngay từ đầu. Có vẻ như không có bất kỳ sự kiện đã hoàn thành / kết thúc nào có thể được sử dụng để dọn dẹp.

Trang MSDN trên lớp Tác vụ không bình luận về điều này và cuốn sách "Pro C # 2010 ..." đề xuất mẫu tương tự và không đưa ra bình luận về việc xử lý tác vụ.

Tôi biết nếu tôi cứ để nó thì cuối cùng thì trình hoàn thiện sẽ bắt được nó, nhưng liệu điều này có quay lại và cắn tôi khi tôi đang thực hiện rất nhiều nhiệm vụ và quên như thế này và chuỗi trình hoàn thiện bị quá tải không?

Vì vậy, câu hỏi của tôi là:

• Không gọi Dispose()vào Tasklớp trong trường hợp này có được chấp nhận không ? Và nếu có, tại sao và có rủi ro / hậu quả không?
• Có tài liệu nào thảo luận về điều này không?
• Hay có cách nào thích hợp để vứt bỏ Taskđối tượng mà tôi đã bỏ sót?
• Hay có một cách khác để thực hiện nhiệm vụ cứu hỏa và quên với TPL?

Có một cuộc thảo luận về điều này trong các diễn đàn MSDN .

Stephen Toub, một thành viên của nhóm pfx của Microsoft có điều này để nói:

Task.Dispose tồn tại do Tác vụ có khả năng bao bọc một xử lý sự kiện được sử dụng khi chờ tác vụ hoàn thành, trong trường hợp chuỗi chờ thực sự phải chặn (trái ngược với việc quay hoặc có khả năng thực thi tác vụ mà nó đang chờ). Nếu tất cả những gì bạn đang làm là sử dụng tính năng liên tục, thì xử lý sự kiện đó sẽ không bao giờ được phân bổ
...
tốt hơn là bạn nên dựa vào việc hoàn thiện để xử lý mọi thứ.

Cập nhật (tháng 10 năm 2012)
Stephen Toub đã đăng một blog có tiêu đề Tôi có cần phải hủy bỏ Công việc không? cung cấp một số chi tiết hơn và giải thích các cải tiến trong .Net 4.5.

Tóm lại: Bạn không cần phải vứt bỏ Taskđồ vật trong 99% thời gian.

Có hai lý do chính để xử lý một đối tượng: để giải phóng tài nguyên không được quản lý một cách kịp thời, xác định và để tránh chi phí chạy trình hoàn thiện của đối tượng. Cả hai điều này đều không áp dụng cho Taskhầu hết thời gian:

1. Tính đến Net 4.5, lần duy nhất một Taskgiao đất tay cầm chờ đợi nội bộ (tài nguyên duy nhất không được quản lý trong các Taskđối tượng) là khi bạn sử dụng một cách rõ ràng IAsyncResult.AsyncWaitHandletrong những Task, và
2. Bản Taskthân đối tượng không có trình hoàn thiện; tay cầm tự nó được bao bọc trong một đối tượng có trình hoàn thiện, vì vậy trừ khi nó được cấp phát, không có trình hoàn thiện nào để chạy.

Đây là loại vấn đề tương tự như với lớp Thread. Nó tiêu thụ 5 tay cầm hệ điều hành nhưng không triển khai IDisposable. Quyết định tốt của các nhà thiết kế ban đầu, tất nhiên có rất ít cách hợp lý để gọi phương thức Dispose (). Trước tiên, bạn phải gọi Join ().

Lớp Tác vụ thêm một tay cầm vào điều này, một sự kiện đặt lại thủ công nội bộ. Tài nguyên hệ điều hành rẻ nhất hiện có. Tất nhiên, phương thức Dispose () của nó chỉ có thể giải phóng một xử lý sự kiện đó, không phải 5 xử lý mà Thread sử dụng. Ừ, đừng bận tâm .

Hãy cẩn thận rằng bạn phải quan tâm đến thuộc tính IsFaulted của nhiệm vụ. Đó là một chủ đề khá xấu xí, bạn có thể đọc thêm về nó trong bài viết này của Thư viện MSDN . Một khi bạn giải quyết vấn đề này đúng cách, bạn cũng nên có một vị trí tốt trong mã của mình để xử lý các nhiệm vụ.

Tôi rất muốn thấy ai đó cân nhắc kỹ thuật được hiển thị trong bài đăng này: Lệnh gọi đại biểu không đồng bộ có thể cháy và quên an toàn trong C #

Có vẻ như một phương thức mở rộng đơn giản sẽ xử lý tất cả các trường hợp nhỏ khi tương tác với các tác vụ và có thể gọi vứt bỏ nó.

public static void FireAndForget<T>(this Action<T> act,T arg1)
{
    var tsk = Task.Factory.StartNew( ()=> act(arg1),
                                     TaskCreationOptions.LongRunning);
    tsk.ContinueWith(cnt => cnt.Dispose());
}