कार्य और पूर्ववत .Net में - युक्तियाँ और चालें

.NET फ्रेमवर्क 4.0 की रिलीज़ के साथ टास्क पैरेलल लाइब्रेरी (TPL), जो कार्य-आधारित समानता को लागू करता है, BCL में जोड़ा गया था। पुस्तकालय Task प्रकारों पर आधारित है और Task प्रकार इसे विरासत में मिला है । ये प्रकार अतुल्यकालिक संचालन के लिए आवरण हैं; वे आपको ऐसे तकनीकी विवरणों से सार करने की अनुमति देते हैं, उदाहरण के लिए, धागे और एक दूसरे के साथ अतुल्यकालिक संचालन को सिंक्रनाइज़ करते हैं।

.NET फ्रेमवर्क के एक ही संस्करण में, एसिंक्रोनस संचालन के सहकारी रद्द करने के लिए एक मिनी-फ्रेमवर्क दिखाई दिया। इसमें केवल तीन प्रकार होते हैं:

• CancellationTokenSource CancelAfter - रद्दीकरण टोकन ( Token संपत्ति) बनाता है और ऑपरेशन को रद्द करने के अनुरोधों को संसाधित करता है (ओवरलोड Cancel / Cancel CancelAfter )।
• CancellationToken टोकन - रद्द करने का टोकन; आपको कई तरीकों से ऑपरेशन को रद्द करने के अनुरोधों को ट्रैक करने की अनुमति देता है: IsCancellationRequested संपत्ति का सर्वेक्षण करके, कॉलबैक फ़ंक्शन (अतिभारित Register विधि के माध्यम से) को Register करके, सिंक्रनाइज़ेशन ऑब्जेक्ट ( WaitHandle संपत्ति) पर प्रतीक्षा कर रहा है।
• OperationCanceledException - एक अपवाद जिसका अनुबंध से फेंकने का अर्थ है कि ऑपरेशन को रद्द करने का अनुरोध संसाधित किया गया है और ऑपरेशन को रद्द माना जाना चाहिए। अपवाद को फेंकने का पसंदीदा तरीका CancellationToken. ThrowIfCancellationRequested विधि को कॉल करके है CancellationToken. ThrowIfCancellationRequested CancellationToken. ThrowIfCancellationRequested ।

रद्दीकरण के माध्यम से रद्दीकरण तंत्र TPL के लिए मानक है - CancellationToken स्वीकार करने के लिए कई तरीके हैं, जो CancellationToken स्वीकार करते हैं, OperationCanceledException अपवादों को एक विशेष तरीके से नियंत्रित किया जाता है, आदि। हालांकि, किसी भी अन्य एपीआई की तरह, सूक्ष्मता, चाल और सर्वोत्तम अभ्यास हैं।

सह-ऑप रद्दीकरण क्यों है?

अतुल्यकालिक ऑपरेशन करने वाले कोड को तीन भागों (परतों) में विभाजित किया जा सकता है:

• कोड "आस-पास" अतुल्यकालिक ऑपरेशन, बाहरी परत। यह कोड ऑपरेशन शुरू करता है, इसके परिणाम और संचालन के दौरान होने वाले अपवादों को संसाधित करता है।
• कोड अतुल्यकालिक ऑपरेशन, आंतरिक परत "अंदर" है। यह कोड ऑपरेशन को स्वयं लागू करता है, एक पेलोड करता है - गणना, इनपुट / आउटपुट, डेटा प्रोसेसिंग आदि।
• बाहरी (1) और आंतरिक (2) कोड, बुनियादी ढांचे की परत के बीच मध्यस्थ कोड। वह निम्न-स्तरीय विवरणों के लिए जिम्मेदार है - वह वांछित थ्रेड में निष्पादित करने के लिए ऑपरेशन शुरू करता है, ऑपरेशन के परिणाम को प्रकाशित करता है ताकि यह बाहरी कोड, आदि के लिए सुलभ हो। टीपीएल का उपयोग करने के मामले में, यह कोड टीपीएल के अंदर ही है।

रद्दीकरण तंत्र के माध्यम से रद्दीकरण तंत्र सहकारी है, क्योंकि इसे तीन परतों से रद्दीकरण की कार्यक्षमता के लिए समन्वित समर्थन की आवश्यकता है। विशिष्ट कोड जो रद्दीकरण समर्थन के साथ एक अतुल्यकालिक ऑपरेशन करता है वह इस तरह दिखता है:

 CancellationTokenSource cts; void Start() { cts = new CancellationTokenSource(); //    var task = Task.Run(() => SomeWork(cts.Token), cts.Token); //     // // ... } int SomeWork(CancellationToken cancellationToken) { int result; while (true) { // -  ... // ...   ,      cancellationToken.ThrowIfCancellationRequested(); } //   return result; } void Cancel() { //    cts.Cancel(); } 

इस उदाहरण में, Start और Cancel फ़ंक्शन में कोड बाहरी परत है। यह Task.Run पद्धति को कॉल करके एक एसिंक्रोनस ऑपरेशन शुरू करता है। एक ही समय में, यह एक बार में दो स्थानों पर SomeWork पास करता है: आंतरिक परत सीधे ऑपरेशन ( SomeWork पद्धति) और बुनियादी ढांचे की परत (कार्य के लिए दूसरा तर्क Task.Run फ़ंक्शन) पर। Cancel फ़ंक्शन ऑपरेशन को रद्द करने के लिए कहता है।

पेलोड का प्रदर्शन करने के अलावा, आंतरिक परत ( SomeWork फ़ंक्शन) समय-समय पर यह देखने के लिए जांचता है कि क्या रद्द करने का अनुरोध किया गया है और यदि आवश्यक हो, तो कैंसिल करने के लिए एक OperationCanceledException को फेंकता है कि रद्द करने का अनुरोध संसाधित किया गया है।

रद्दीकरण का समर्थन करने के लिए बुनियादी ढांचे की परत (टीपीएल के अंदर) दो काम करती है। सबसे पहले, कार्य शुरू करने से पहले Task.Run पास किया गया। यह देखने के लिए कि क्या रद्द करने का अनुरोध किया गया है। यदि हां, तो फ़ंक्शन निष्पादित करना भी शुरू नहीं करता है। दूसरे, यह OperationCanceledException विशेष तरीके से एक OperationCanceledException संभालता है, जो रिपोर्ट करता है कि ऑपरेशन रद्द कर दिया गया था।

रद्द करने का अनुरोध प्रसंस्करण

CancellationTokenSource.Cancel पद्धति को कॉल करने के बाद (या CancellationTokenSource.Cancel जाने के बाद निर्दिष्ट किए गए समय को CancellationTokenSource कंस्ट्रक्टर / CancellationTokenSource.CancelAfter विधि) के रूप में CancellationTokenSource करने के बाद रद्द करने की स्थिति में रद्द कर दिया जाता है। रद्द किए गए राज्य में संक्रमण ठीक एक बार हो सकता है। मन को बदलना और CancellationTokenSource कर दिया गया CancellationTokenSource करने के लिए रद्द CancellationTokenSource संभव नहीं है, और बार-बार कॉल की अनदेखी नहीं की जाती है।

रद्द की गई स्थिति में संक्रमण होने पर, कॉलबैक फ़ंक्शंस को CancellationToken.Register विधि के माध्यम से कॉल किया जाता है, CancellationToken.ThrowIfCancellationRequested किया गया।

आंतरिक परत कोड को समय-समय पर रद्द करने के अनुरोध की जांच करनी चाहिए। आमतौर पर, सत्यापन कोड ThrowIfCancellationRequested विधि को कॉल करने के लिए नीचे आता है, अगर ऑपरेशन तुरंत बाधित हो सकता है। यदि आपको IsCancellationRequested से पहले अतिरिक्त कार्य करने की आवश्यकता है (उदाहरण के लिए, मुक्त संसाधनों का उपयोग), सत्यापन कोड IsCancellationRequested संपत्ति को संदर्भित करता है। यदि यह true , तो संसाधन साफ ​​हो जाता है और एक ThrowIfCancellationRequested OperationCanceledException फेंक दिया जाता है (फिर से, ThrowIfCancellationRequested विधि या मैन्युअल रूप से कॉल करके)।

निम्नलिखित पर ध्यान देना महत्वपूर्ण है। सबसे पहले, यदि रद्द करने का अनुरोध ऑपरेशन कोड द्वारा संसाधित नहीं किया गया है, तो ऑपरेशन जारी रहेगा। अंत में, जब ऑपरेशन पूरा हो जाता है (सामान्य रूप से या अपवाद के साथ), कार्य पूरा हो जाएगा ( Task.IsCompleted == true ), लेकिन इसे रद्द नहीं माना जाएगा ( Task.IsCanceled == false )।

दूसरे, आपको चेक के बीच अंतराल का इष्टतम आकार चुनने की आवश्यकता है। यदि अंतराल बहुत लंबा है, तो रद्द होने पर ऑपरेशन अतिरिक्त काम करेगा। यदि अंतराल बहुत छोटा है, तो सत्यापन का ओवरहेड ऑपरेशन के समय को बढ़ा देगा। किसी भी विशिष्ट मूल्यों की सिफारिश करना मुश्किल है, बहुत कुछ विशिष्ट परिदृश्य पर निर्भर करता है। सामान्य सिफारिशें इस प्रकार हैं: यदि रद्द करने की संभावना बहुत अधिक नहीं है, तो चेक कम बार किए जा सकते हैं। यदि ऑपरेशन को रद्द करना उपयोगकर्ता द्वारा शुरू किया गया है, तो यूआई की जवाबदेही सुनिश्चित करने के लिए, यह प्रत्येक 200-2000 एमएस की जांच करने के लिए पर्याप्त है। यदि ऑपरेशन सर्वर एप्लिकेशन में किया जाता है, तो चेक को अधिक बार किया जाना चाहिए, ताकि रद्दीकरण के मामले में, आपको सर्वर संसाधन नहीं होना चाहिए। निरीक्षण को कुल संचालन समय के कुछ प्रतिशत से अधिक नहीं लेना चाहिए। फिर से, मैं दोहराता हूं कि ये केवल सामान्य सिफारिशें हैं और प्रत्येक विशेष मामले में, डेवलपर को सभी निर्णय लेने वाले कारकों को ध्यान में रखते हुए अपना निर्णय करना चाहिए। शायद प्रोफाइलर की मदद सतही नहीं होगी।

तीसरा, CancellationToken पास CanBeCanceled संपत्ति है। यदि यह false , तो रद्द करने के अनुरोध की कोई गारंटी नहीं है और सत्यापन को छोड़ा जा सकता है। CanBeCanceled false यदि CancellationToken संपत्ति को स्थैतिक संपत्ति का उपयोग करके प्राप्त किया CancellationToken , तो CancellationToken ।

और अंत में, चौथा, एक कार्य के लिए, जिसे "मैन्युअल रूप से" (async विधि द्वारा नहीं) बनाया गया था, उसे सही ढंग से रद्द किया जाए (ताकि Task.IsCanceled संपत्ति true ), निम्नलिखित की आवश्यकता है:

• एसिंक्रोनस ऑपरेशन कोड को एक OperationCanceledException अपवाद को फेंकना चाहिए, जिसके निर्माता को एक CancellationToken जाना चाहिए।
• कार्य CancellationToken करने और कार्य को चलाने के लिए उसी CancellationToken को पास CancellationToken चाहिए।
• CancellationToken का IsCancellationRequested संपत्ति CancellationToken जाना चाहिए।

निम्नलिखित उदाहरणों पर विचार करें:

 var cts = new CancellationTokenSource(); var cancellationToken = cts.Token; //... Task.Run(() => { //... if (cancellationToken.IsCancellationRequested) throw new OperationCanceledException(); //   CancellationToken //... }, cancellationToken); 

यहां, CancellationToken OperationCanceledException कैन्सेलडेड OperationCanceledException निर्माणकर्ता को पारित नहीं किया गया है। यही कारण है कि मैन्युअल रूप से OperationCanceledException फेंकने के बजाय CancellationToken.ThrowIfCancelationRequested विधि का उपयोग CancellationToken.ThrowIfCancelationRequested बेहतर है।

 var cts = new CancellationTokenSource(); var cancellationToken = cts.Token; //... Task.Run(() => { //... cancellationToken.ThrowIfCancellationRequested(); //... }/*   CancellationToken */); 

इस उदाहरण में, कार्य बनाते समय, Task.Run लिए पारित नहीं किया Task.Run । विधि।

 var cts = new CancellationTokenSource(); var cancellationToken = cts.Token; var cts2 = new CancellationTokenSource(); var cancellationToken2 = cts2.Token; //... var task = Task.Run(() => { //... cancellationToken2.ThrowIfCancellationRequested(); // «» CancellationToken //... }, cancellationToken); 

यहाँ, एक कार्य बनाने के लिए और रद्द करने के लिए, CancellationToken करने के लिए, CancellationToken किया गया, अलग-अलग CancellationTokenSource प्राप्त किया गया।

 var cts = new CancellationTokenSource(); var cancellationToken = cts.Token; //... var task = Task.Run(() => { //... if (!cancellationToken.IsCancellationRequested) //    throw new OperationCanceledException(cancellationToken); //... }, cancellationToken); 

एक OperationCanceledException , हालाँकि रद्द करने का अनुरोध नहीं किया गया था।

सभी उदाहरणों में, OperationCanceledException को TPL के अंदर रद्द करने के संकेत के रूप में संसाधित नहीं किया जाएगा, लेकिन एक नियमित अपवाद के रूप में। नतीजतन, कार्य रद्द करने के साथ नहीं, बल्कि एक त्रुटि के साथ समाप्त होगा ( Task.IsCancelled == false , Task.IsFaulted == true )।

रद्द करें और निरंतर कार्य करें

TPL आपको ओवरलोड टास्क का उपयोग करके चेन कार्यों को करने की अनुमति देता है। Task.ContinueWith विधि के साथ। टास्क द्वारा बनाया गया कार्य। Task.ContinueWith विधि को निरंतरता कार्य कहा जाता है, और जिस कार्य को विधि कहा जाता है वह पूर्ववर्ती कार्य है। निरंतरता कार्य पूर्ववर्ती कार्य के पूरा होने की प्रतीक्षा करता है, जिसके बाद वह निष्पादित होता है:

 var antecedentTask = Task.Run(() => Console.Write("Hello, ")); var continuationTask = antecedentTask.ContinueWith(_ => Console.Write("world!")); //    `Hello, world!` 

निरंतरता के कार्य पूरी तरह से रद्द करने का समर्थन करते हैं, और जो कुछ भी ऊपर लिखा गया था वह उन पर लागू होता है। Task.ContinueWith विधि में अधिभार हैं जो आपको बनाए गए कार्य के साथ CancellationToken करने की अनुमति देते हैं।

यदि निरस्तीकरण अनुरोध तब आता है जब निरंतरता कार्य अभी तक शुरू नहीं हुआ है, तो इसे निष्पादित नहीं किया जाएगा। इस स्थिति में, डिफ़ॉल्ट रूप से, जारी रखने का कार्य तुरंत रद्द कर दिया जाएगा और पूर्ववर्ती कार्य की तुलना में पहले पूरा हो सकता है:

 var cts = new CancellationTokenSource(); var cancellationToken = cts.Token; var antecedentTask = Task.Run(() => Thread.Sleep(5000)); var continuationTask = antecedentTask.ContinueWith( _ => {}, cancellationToken); Thread.Sleep(1000); cts.Cancel(); Console.WriteLine(antecedentTask.IsCompleted); // False Console.WriteLine(continuationTask.IsCompleted); // True 

लेकिन इस व्यवहार को तब बदला जा सकता है, जब TaskContinuationOptions.LazyCancellation का उपयोग करके एक निरंतरता कार्य बना रहा हो। इस मामले में, पूर्ववर्ती कार्य पूरा होने तक जारी रखने का कार्य रद्द नहीं किया जाएगा (और पूरा नहीं होगा):

 var cts = new CancellationTokenSource(); var cancellationToken = cts.Token; var antecedentTask = Task.Run(() => Thread.Sleep(5000)); var continuationTask = antecedentTask.ContinueWith( _ => {}, cancellationToken, TaskContinuationOptions.LazyCancellation, TaskScheduler.Default); Thread.Sleep(1000); cts.Cancel(); Console.WriteLine(antecedentTask.IsCompleted); // False Console.WriteLine(continuationTask.IsCompleted); // False 

विशेष रुचि का मामला है, जहां CancellationToken का उपयोग किए बिना निरंतरता कार्य रद्द हो सकता है। TaskContinuationOptions में झंडे की एक श्रृंखला है जो आपको निर्दिष्ट करती है कि किन मामलों में एक निरंतरता कार्य लॉन्च किया जाना चाहिए। उदाहरण के लिए, पूर्ववर्ती कार्य के लिए, आप दो निरंतरता कार्य बना सकते हैं - एक उस मामले के लिए जब पूर्ववर्ती कार्य सामान्य रूप से चलता है, और दूसरा जब पूर्ववर्ती कार्य में कोई त्रुटि / निरस्तीकरण होता है। पूर्ववर्ती कार्य के पूरा होने के बाद, केवल एक निरंतर कार्य शुरू होगा, और दूसरा रद्द कर दिया जाएगा:

 var antecedentTask = Task.Run(() => {}); var continuationTask1 = antecedentTask.ContinueWith( _ => {}, TaskContinuationOptions.OnlyOnRanToCompletion); var continuationTask2 = antecedentTask.ContinueWith( _ => {}, TaskContinuationOptions.NotOnRanToCompletion); try { Task.WaitAll(continuationTask1, continuationTask2); } catch{} Console.WriteLine(continuationTask1.IsCanceled); // False Console.WriteLine(continuationTask2.IsCanceled); // True 

रद्द करें और async विधियाँ

C # 5.0 ने async विधियों की शुरुआत की। रद्द करने के दृष्टिकोण से, async विधियाँ दिलचस्प हैं कि केवल void और Task / Task. , async- (Task / Task), , . ,
Task<int> task = Task .Delay(TimeSpan.FromSeconds(5)) .ContinueWith(_ => { while (true) { // - } return 42; });
async- :
Task<int> task = SomeWork(); async Task<int> SomeWork() { await Task.Delay(TimeSpan.FromSeconds(5)); while (true) { // - } return 42; }
, Task.Run , Task.Factory.StartNew , . SomeWork int . , SomeWork Task.

, async-, , , . , :
var cts = new CancellationTokenSource(); var cancellationToken = cts.Token; Task<int> task = Task .Delay(TimeSpan.FromSeconds(5), cancellationToken) .ContinueWith(_ => { while (true) { // - cancellationToken.ThrowIfCancellationRequested(); } return 42; }, cancellationToken);

var cts = new CancellationTokenSource(); var cancellationToken = cts.Token; Task<int> task = SomeWork(cancellationToken); async Task<int> SomeWork(CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); /* 1 */ await Task.Delay(TimeSpan.FromSeconds(5), cancellationToken); cancellationToken.ThrowIfCancellationRequested(); /* 2 */ while (true) { // - cancellationToken.ThrowIfCancellationRequested(); } return 42; }
, async-, , CancellationToken ( CancellationToken async- CancellationToken ). :
async-, async- . (, Task.Run Task.ContinueWith ) . 1 2. , async-, . OperationCanceledException . CancellationToken , , .. . , , CancellationToken . , Task.Run , :
static async Task<int> SomeWork(CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); throw new OperationCanceledException(cancellationToken); throw new OperationCanceledException(); throw new OperationCanceledException(CancellationToken.None); throw new OperationCanceledException(new CancellationToken(true)); throw new OperationCanceledException(new CancellationToken(false)); }

Task.IsCompleted true . ( Task.Status == TaskStatus.RanToCompletion ), ( Task.Status == TaskStatus.Faulted ; Task.IsFaulted == true ) ( Task.Status == TaskStatus.Canceled ; Task.IsCanceled == true ). .

-. TaskContinuationOptions - -:
var task = Task.Run(() => 42); task.ContinueWith( t => Console.WriteLine("Result: {0}", t.Result), TaskContinuationOptions.OnlyOnRanToCompletion); task.ContinueWith( _ => Console.WriteLine("Canceled"), TaskContinuationOptions.OnlyOnCanceled); task.ContinueWith( t => Console.WriteLine("Error: {0}", t.Exception), TaskContinuationOptions.OnlyOnFaulted);
Task.Wait Task.Result. c , . . -, — AggregateException . AggregateException , ( AggregateException ). -, , , AggregateException TaskCanceledException , OperationCanceledException , :
var task = Task.Run(() => { /* - */ }); try { task.Wait(); Console.WriteLine("Success"); } catch (AggregateException ae) { try { ae.Flatten().Handle(e => e is TaskCanceledException); Console.WriteLine("Cancelled"); } catch (AggregateException e) { Console.WriteLine("Error: {0}", e); } }
async- await . AggregateException , OperationCanceledException ; :
var task = Task.Run(() => { /* - */ }); try { await task; Console.WriteLine("Success"); } catch (OperationCanceledException) { Console.WriteLine("Cancelled"); } catch (Exception e) { Console.WriteLine("Error: {0}", e); } प्रकारों का उपयोग रिटर्न मान के रूप में किया जा सकता है Task. , async- (Task / Task), , . ,
Task<int> task = Task .Delay(TimeSpan.FromSeconds(5)) .ContinueWith(_ => { while (true) { // - } return 42; });
async- :
Task<int> task = SomeWork(); async Task<int> SomeWork() { await Task.Delay(TimeSpan.FromSeconds(5)); while (true) { // - } return 42; }
, Task.Run , Task.Factory.StartNew , . SomeWork int . , SomeWork Task.

, async-, , , . , :
var cts = new CancellationTokenSource(); var cancellationToken = cts.Token; Task<int> task = Task .Delay(TimeSpan.FromSeconds(5), cancellationToken) .ContinueWith(_ => { while (true) { // - cancellationToken.ThrowIfCancellationRequested(); } return 42; }, cancellationToken);

var cts = new CancellationTokenSource(); var cancellationToken = cts.Token; Task<int> task = SomeWork(cancellationToken); async Task<int> SomeWork(CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); /* 1 */ await Task.Delay(TimeSpan.FromSeconds(5), cancellationToken); cancellationToken.ThrowIfCancellationRequested(); /* 2 */ while (true) { // - cancellationToken.ThrowIfCancellationRequested(); } return 42; }
, async-, , CancellationToken ( CancellationToken async- CancellationToken ). :
async-, async- . (, Task.Run Task.ContinueWith ) . 1 2. , async-, . OperationCanceledException . CancellationToken , , .. . , , CancellationToken . , Task.Run , :
static async Task<int> SomeWork(CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); throw new OperationCanceledException(cancellationToken); throw new OperationCanceledException(); throw new OperationCanceledException(CancellationToken.None); throw new OperationCanceledException(new CancellationToken(true)); throw new OperationCanceledException(new CancellationToken(false)); }

Task.IsCompleted true . ( Task.Status == TaskStatus.RanToCompletion ), ( Task.Status == TaskStatus.Faulted ; Task.IsFaulted == true ) ( Task.Status == TaskStatus.Canceled ; Task.IsCanceled == true ). .

-. TaskContinuationOptions - -:
var task = Task.Run(() => 42); task.ContinueWith( t => Console.WriteLine("Result: {0}", t.Result), TaskContinuationOptions.OnlyOnRanToCompletion); task.ContinueWith( _ => Console.WriteLine("Canceled"), TaskContinuationOptions.OnlyOnCanceled); task.ContinueWith( t => Console.WriteLine("Error: {0}", t.Exception), TaskContinuationOptions.OnlyOnFaulted);
Task.Wait Task.Result. c , . . -, — AggregateException . AggregateException , ( AggregateException ). -, , , AggregateException TaskCanceledException , OperationCanceledException , :
var task = Task.Run(() => { /* - */ }); try { task.Wait(); Console.WriteLine("Success"); } catch (AggregateException ae) { try { ae.Flatten().Handle(e => e is TaskCanceledException); Console.WriteLine("Cancelled"); } catch (AggregateException e) { Console.WriteLine("Error: {0}", e); } }
async- await . AggregateException , OperationCanceledException ; :
var task = Task.Run(() => { /* - */ }); try { await task; Console.WriteLine("Success"); } catch (OperationCanceledException) { Console.WriteLine("Cancelled"); } catch (Exception e) { Console.WriteLine("Error: {0}", e); } Task. , async- (Task / Task), , . ,
Task<int> task = Task .Delay(TimeSpan.FromSeconds(5)) .ContinueWith(_ => { while (true) { // - } return 42; });
async- :
Task<int> task = SomeWork(); async Task<int> SomeWork() { await Task.Delay(TimeSpan.FromSeconds(5)); while (true) { // - } return 42; }
, Task.Run , Task.Factory.StartNew , . SomeWork int . , SomeWork Task.

, async-, , , . , :
var cts = new CancellationTokenSource(); var cancellationToken = cts.Token; Task<int> task = Task .Delay(TimeSpan.FromSeconds(5), cancellationToken) .ContinueWith(_ => { while (true) { // - cancellationToken.ThrowIfCancellationRequested(); } return 42; }, cancellationToken);

var cts = new CancellationTokenSource(); var cancellationToken = cts.Token; Task<int> task = SomeWork(cancellationToken); async Task<int> SomeWork(CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); /* 1 */ await Task.Delay(TimeSpan.FromSeconds(5), cancellationToken); cancellationToken.ThrowIfCancellationRequested(); /* 2 */ while (true) { // - cancellationToken.ThrowIfCancellationRequested(); } return 42; }
, async-, , CancellationToken ( CancellationToken async- CancellationToken ). :
async-, async- . (, Task.Run Task.ContinueWith ) . 1 2. , async-, . OperationCanceledException . CancellationToken , , .. . , , CancellationToken . , Task.Run , :
static async Task<int> SomeWork(CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); throw new OperationCanceledException(cancellationToken); throw new OperationCanceledException(); throw new OperationCanceledException(CancellationToken.None); throw new OperationCanceledException(new CancellationToken(true)); throw new OperationCanceledException(new CancellationToken(false)); }

Task.IsCompleted true . ( Task.Status == TaskStatus.RanToCompletion ), ( Task.Status == TaskStatus.Faulted ; Task.IsFaulted == true ) ( Task.Status == TaskStatus.Canceled ; Task.IsCanceled == true ). .

-. TaskContinuationOptions - -:
var task = Task.Run(() => 42); task.ContinueWith( t => Console.WriteLine("Result: {0}", t.Result), TaskContinuationOptions.OnlyOnRanToCompletion); task.ContinueWith( _ => Console.WriteLine("Canceled"), TaskContinuationOptions.OnlyOnCanceled); task.ContinueWith( t => Console.WriteLine("Error: {0}", t.Exception), TaskContinuationOptions.OnlyOnFaulted);
Task.Wait Task.Result. c , . . -, — AggregateException . AggregateException , ( AggregateException ). -, , , AggregateException TaskCanceledException , OperationCanceledException , :
var task = Task.Run(() => { /* - */ }); try { task.Wait(); Console.WriteLine("Success"); } catch (AggregateException ae) { try { ae.Flatten().Handle(e => e is TaskCanceledException); Console.WriteLine("Cancelled"); } catch (AggregateException e) { Console.WriteLine("Error: {0}", e); } }
async- await . AggregateException , OperationCanceledException ; :
var task = Task.Run(() => { /* - */ }); try { await task; Console.WriteLine("Success"); } catch (OperationCanceledException) { Console.WriteLine("Cancelled"); } catch (Exception e) { Console.WriteLine("Error: {0}", e); }

 Task.   ,  async-   (Task / Task),    ,   . ,   
 Task<int> task = Task .Delay(TimeSpan.FromSeconds(5)) .ContinueWith(_ => { while (true) { // -  } return 42; }); 
      async-  : 
 Task<int> task = SomeWork(); async Task<int> SomeWork() { await Task.Delay(TimeSpan.FromSeconds(5)); while (true) { // -  } return 42; } 
  ,     Task.Run ,  Task.Factory.StartNew ,  .  SomeWork    int .    ,    SomeWork  Task. 
 
 ,  async-,   ,  ,   .       ,    : 
 var cts = new CancellationTokenSource(); var cancellationToken = cts.Token; Task<int> task = Task .Delay(TimeSpan.FromSeconds(5), cancellationToken) .ContinueWith(_ => { while (true) { // -  cancellationToken.ThrowIfCancellationRequested(); } return 42; }, cancellationToken); 
  
 var cts = new CancellationTokenSource(); var cancellationToken = cts.Token; Task<int> task = SomeWork(cancellationToken); async Task<int> SomeWork(CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); /* 1 */ await Task.Delay(TimeSpan.FromSeconds(5), cancellationToken); cancellationToken.ThrowIfCancellationRequested(); /* 2 */ while (true) { // -  cancellationToken.ThrowIfCancellationRequested(); } return 42; } 
 ,   async-,  ,       CancellationToken ( CancellationToken  async-      CancellationToken   ).      : 
        async-,  async-    .       (,  Task.Run  Task.ContinueWith )   .       1  2. ,   async-,    . OperationCanceledException   .   CancellationToken ,         , ..     .  ,        ,   CancellationToken      . ,      Task.Run ,       : 
 static async Task<int> SomeWork(CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); throw new OperationCanceledException(cancellationToken); throw new OperationCanceledException(); throw new OperationCanceledException(CancellationToken.None); throw new OperationCanceledException(new CancellationToken(true)); throw new OperationCanceledException(new CancellationToken(false)); } 
    
     Task.IsCompleted    true .     ( Task.Status == TaskStatus.RanToCompletion ),   ( Task.Status == TaskStatus.Faulted ; Task.IsFaulted == true )    ( Task.Status == TaskStatus.Canceled ; Task.IsCanceled == true ).             . 
 
       -.      TaskContinuationOptions   -     -: 
 var task = Task.Run(() => 42); task.ContinueWith( t => Console.WriteLine("Result: {0}", t.Result), TaskContinuationOptions.OnlyOnRanToCompletion); task.ContinueWith( _ => Console.WriteLine("Canceled"), TaskContinuationOptions.OnlyOnCanceled); task.ContinueWith( t => Console.WriteLine("Error: {0}", t.Exception), TaskContinuationOptions.OnlyOnFaulted); 
            Task.Wait     Task.Result.      c   ,   .    . -,          — AggregateException . AggregateException       ,     (  AggregateException    ). -,  ,   , AggregateException      TaskCanceledException ,   OperationCanceledException ,   : 
 var task = Task.Run(() => { /* -  */ }); try { task.Wait(); Console.WriteLine("Success"); } catch (AggregateException ae) { try { ae.Flatten().Handle(e => e is TaskCanceledException); Console.WriteLine("Cancelled"); } catch (AggregateException e) { Console.WriteLine("Error: {0}", e); } } 
   async-           await .       AggregateException ,       OperationCanceledException ;     : 
 var task = Task.Run(() => { /* -  */ }); try { await task; Console.WriteLine("Success"); } catch (OperationCanceledException) { Console.WriteLine("Cancelled"); } catch (Exception e) { Console.WriteLine("Error: {0}", e); } 

Task. , async- (Task / Task), , . ,
Task<int> task = Task .Delay(TimeSpan.FromSeconds(5)) .ContinueWith(_ => { while (true) { // - } return 42; });
async- :
Task<int> task = SomeWork(); async Task<int> SomeWork() { await Task.Delay(TimeSpan.FromSeconds(5)); while (true) { // - } return 42; }
, Task.Run , Task.Factory.StartNew , . SomeWork int . , SomeWork Task.

, async-, , , . , :
var cts = new CancellationTokenSource(); var cancellationToken = cts.Token; Task<int> task = Task .Delay(TimeSpan.FromSeconds(5), cancellationToken) .ContinueWith(_ => { while (true) { // - cancellationToken.ThrowIfCancellationRequested(); } return 42; }, cancellationToken);

var cts = new CancellationTokenSource(); var cancellationToken = cts.Token; Task<int> task = SomeWork(cancellationToken); async Task<int> SomeWork(CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); /* 1 */ await Task.Delay(TimeSpan.FromSeconds(5), cancellationToken); cancellationToken.ThrowIfCancellationRequested(); /* 2 */ while (true) { // - cancellationToken.ThrowIfCancellationRequested(); } return 42; }
, async-, , CancellationToken ( CancellationToken async- CancellationToken ). :
async-, async- . (, Task.Run Task.ContinueWith ) . 1 2. , async-, . OperationCanceledException . CancellationToken , , .. . , , CancellationToken . , Task.Run , :
static async Task<int> SomeWork(CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); throw new OperationCanceledException(cancellationToken); throw new OperationCanceledException(); throw new OperationCanceledException(CancellationToken.None); throw new OperationCanceledException(new CancellationToken(true)); throw new OperationCanceledException(new CancellationToken(false)); }

Task.IsCompleted true . ( Task.Status == TaskStatus.RanToCompletion ), ( Task.Status == TaskStatus.Faulted ; Task.IsFaulted == true ) ( Task.Status == TaskStatus.Canceled ; Task.IsCanceled == true ). .

-. TaskContinuationOptions - -:
var task = Task.Run(() => 42); task.ContinueWith( t => Console.WriteLine("Result: {0}", t.Result), TaskContinuationOptions.OnlyOnRanToCompletion); task.ContinueWith( _ => Console.WriteLine("Canceled"), TaskContinuationOptions.OnlyOnCanceled); task.ContinueWith( t => Console.WriteLine("Error: {0}", t.Exception), TaskContinuationOptions.OnlyOnFaulted);
Task.Wait Task.Result. c , . . -, — AggregateException . AggregateException , ( AggregateException ). -, , , AggregateException TaskCanceledException , OperationCanceledException , :
var task = Task.Run(() => { /* - */ }); try { task.Wait(); Console.WriteLine("Success"); } catch (AggregateException ae) { try { ae.Flatten().Handle(e => e is TaskCanceledException); Console.WriteLine("Cancelled"); } catch (AggregateException e) { Console.WriteLine("Error: {0}", e); } }
async- await . AggregateException , OperationCanceledException ; :
var task = Task.Run(() => { /* - */ }); try { await task; Console.WriteLine("Success"); } catch (OperationCanceledException) { Console.WriteLine("Cancelled"); } catch (Exception e) { Console.WriteLine("Error: {0}", e); }

 Task.   ,  async-   (Task / Task),    ,   . ,   
 Task<int> task = Task .Delay(TimeSpan.FromSeconds(5)) .ContinueWith(_ => { while (true) { // -  } return 42; }); 
      async-  : 
 Task<int> task = SomeWork(); async Task<int> SomeWork() { await Task.Delay(TimeSpan.FromSeconds(5)); while (true) { // -  } return 42; } 
  ,     Task.Run ,  Task.Factory.StartNew ,  .  SomeWork    int .    ,    SomeWork  Task. 
 
 ,  async-,   ,  ,   .       ,    : 
 var cts = new CancellationTokenSource(); var cancellationToken = cts.Token; Task<int> task = Task .Delay(TimeSpan.FromSeconds(5), cancellationToken) .ContinueWith(_ => { while (true) { // -  cancellationToken.ThrowIfCancellationRequested(); } return 42; }, cancellationToken); 
  
 var cts = new CancellationTokenSource(); var cancellationToken = cts.Token; Task<int> task = SomeWork(cancellationToken); async Task<int> SomeWork(CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); /* 1 */ await Task.Delay(TimeSpan.FromSeconds(5), cancellationToken); cancellationToken.ThrowIfCancellationRequested(); /* 2 */ while (true) { // -  cancellationToken.ThrowIfCancellationRequested(); } return 42; } 
 ,   async-,  ,       CancellationToken ( CancellationToken  async-      CancellationToken   ).      : 
        async-,  async-    .       (,  Task.Run  Task.ContinueWith )   .       1  2. ,   async-,    . OperationCanceledException   .   CancellationToken ,         , ..     .  ,        ,   CancellationToken      . ,      Task.Run ,       : 
 static async Task<int> SomeWork(CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); throw new OperationCanceledException(cancellationToken); throw new OperationCanceledException(); throw new OperationCanceledException(CancellationToken.None); throw new OperationCanceledException(new CancellationToken(true)); throw new OperationCanceledException(new CancellationToken(false)); } 
    
     Task.IsCompleted    true .     ( Task.Status == TaskStatus.RanToCompletion ),   ( Task.Status == TaskStatus.Faulted ; Task.IsFaulted == true )    ( Task.Status == TaskStatus.Canceled ; Task.IsCanceled == true ).             . 
 
       -.      TaskContinuationOptions   -     -: 
 var task = Task.Run(() => 42); task.ContinueWith( t => Console.WriteLine("Result: {0}", t.Result), TaskContinuationOptions.OnlyOnRanToCompletion); task.ContinueWith( _ => Console.WriteLine("Canceled"), TaskContinuationOptions.OnlyOnCanceled); task.ContinueWith( t => Console.WriteLine("Error: {0}", t.Exception), TaskContinuationOptions.OnlyOnFaulted); 
            Task.Wait     Task.Result.      c   ,   .    . -,          — AggregateException . AggregateException       ,     (  AggregateException    ). -,  ,   , AggregateException      TaskCanceledException ,   OperationCanceledException ,   : 
 var task = Task.Run(() => { /* -  */ }); try { task.Wait(); Console.WriteLine("Success"); } catch (AggregateException ae) { try { ae.Flatten().Handle(e => e is TaskCanceledException); Console.WriteLine("Cancelled"); } catch (AggregateException e) { Console.WriteLine("Error: {0}", e); } } 
   async-           await .       AggregateException ,       OperationCanceledException ;     : 
 var task = Task.Run(() => { /* -  */ }); try { await task; Console.WriteLine("Success"); } catch (OperationCanceledException) { Console.WriteLine("Cancelled"); } catch (Exception e) { Console.WriteLine("Error: {0}", e); } 

Task. , async- (Task / Task), , . ,
Task<int> task = Task .Delay(TimeSpan.FromSeconds(5)) .ContinueWith(_ => { while (true) { // - } return 42; });
async- :
Task<int> task = SomeWork(); async Task<int> SomeWork() { await Task.Delay(TimeSpan.FromSeconds(5)); while (true) { // - } return 42; }
, Task.Run , Task.Factory.StartNew , . SomeWork int . , SomeWork Task.

, async-, , , . , :
var cts = new CancellationTokenSource(); var cancellationToken = cts.Token; Task<int> task = Task .Delay(TimeSpan.FromSeconds(5), cancellationToken) .ContinueWith(_ => { while (true) { // - cancellationToken.ThrowIfCancellationRequested(); } return 42; }, cancellationToken);

var cts = new CancellationTokenSource(); var cancellationToken = cts.Token; Task<int> task = SomeWork(cancellationToken); async Task<int> SomeWork(CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); /* 1 */ await Task.Delay(TimeSpan.FromSeconds(5), cancellationToken); cancellationToken.ThrowIfCancellationRequested(); /* 2 */ while (true) { // - cancellationToken.ThrowIfCancellationRequested(); } return 42; }
, async-, , CancellationToken ( CancellationToken async- CancellationToken ). :
async-, async- . (, Task.Run Task.ContinueWith ) . 1 2. , async-, . OperationCanceledException . CancellationToken , , .. . , , CancellationToken . , Task.Run , :
static async Task<int> SomeWork(CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); throw new OperationCanceledException(cancellationToken); throw new OperationCanceledException(); throw new OperationCanceledException(CancellationToken.None); throw new OperationCanceledException(new CancellationToken(true)); throw new OperationCanceledException(new CancellationToken(false)); }

Task.IsCompleted true . ( Task.Status == TaskStatus.RanToCompletion ), ( Task.Status == TaskStatus.Faulted ; Task.IsFaulted == true ) ( Task.Status == TaskStatus.Canceled ; Task.IsCanceled == true ). .

-. TaskContinuationOptions - -:
var task = Task.Run(() => 42); task.ContinueWith( t => Console.WriteLine("Result: {0}", t.Result), TaskContinuationOptions.OnlyOnRanToCompletion); task.ContinueWith( _ => Console.WriteLine("Canceled"), TaskContinuationOptions.OnlyOnCanceled); task.ContinueWith( t => Console.WriteLine("Error: {0}", t.Exception), TaskContinuationOptions.OnlyOnFaulted);
Task.Wait Task.Result. c , . . -, — AggregateException . AggregateException , ( AggregateException ). -, , , AggregateException TaskCanceledException , OperationCanceledException , :
var task = Task.Run(() => { /* - */ }); try { task.Wait(); Console.WriteLine("Success"); } catch (AggregateException ae) { try { ae.Flatten().Handle(e => e is TaskCanceledException); Console.WriteLine("Cancelled"); } catch (AggregateException e) { Console.WriteLine("Error: {0}", e); } }
async- await . AggregateException , OperationCanceledException ; :
var task = Task.Run(() => { /* - */ }); try { await task; Console.WriteLine("Success"); } catch (OperationCanceledException) { Console.WriteLine("Cancelled"); } catch (Exception e) { Console.WriteLine("Error: {0}", e); }

 Task.   ,  async-   (Task / Task),    ,   . ,   
 Task<int> task = Task .Delay(TimeSpan.FromSeconds(5)) .ContinueWith(_ => { while (true) { // -  } return 42; }); 
      async-  : 
 Task<int> task = SomeWork(); async Task<int> SomeWork() { await Task.Delay(TimeSpan.FromSeconds(5)); while (true) { // -  } return 42; } 
  ,     Task.Run ,  Task.Factory.StartNew ,  .  SomeWork    int .    ,    SomeWork  Task. 
 
 ,  async-,   ,  ,   .       ,    : 
 var cts = new CancellationTokenSource(); var cancellationToken = cts.Token; Task<int> task = Task .Delay(TimeSpan.FromSeconds(5), cancellationToken) .ContinueWith(_ => { while (true) { // -  cancellationToken.ThrowIfCancellationRequested(); } return 42; }, cancellationToken); 
  
 var cts = new CancellationTokenSource(); var cancellationToken = cts.Token; Task<int> task = SomeWork(cancellationToken); async Task<int> SomeWork(CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); /* 1 */ await Task.Delay(TimeSpan.FromSeconds(5), cancellationToken); cancellationToken.ThrowIfCancellationRequested(); /* 2 */ while (true) { // -  cancellationToken.ThrowIfCancellationRequested(); } return 42; } 
 ,   async-,  ,       CancellationToken ( CancellationToken  async-      CancellationToken   ).      : 
        async-,  async-    .       (,  Task.Run  Task.ContinueWith )   .       1  2. ,   async-,    . OperationCanceledException   .   CancellationToken ,         , ..     .  ,        ,   CancellationToken      . ,      Task.Run ,       : 
 static async Task<int> SomeWork(CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); throw new OperationCanceledException(cancellationToken); throw new OperationCanceledException(); throw new OperationCanceledException(CancellationToken.None); throw new OperationCanceledException(new CancellationToken(true)); throw new OperationCanceledException(new CancellationToken(false)); } 
    
     Task.IsCompleted    true .     ( Task.Status == TaskStatus.RanToCompletion ),   ( Task.Status == TaskStatus.Faulted ; Task.IsFaulted == true )    ( Task.Status == TaskStatus.Canceled ; Task.IsCanceled == true ).             . 
 
       -.      TaskContinuationOptions   -     -: 
 var task = Task.Run(() => 42); task.ContinueWith( t => Console.WriteLine("Result: {0}", t.Result), TaskContinuationOptions.OnlyOnRanToCompletion); task.ContinueWith( _ => Console.WriteLine("Canceled"), TaskContinuationOptions.OnlyOnCanceled); task.ContinueWith( t => Console.WriteLine("Error: {0}", t.Exception), TaskContinuationOptions.OnlyOnFaulted); 
            Task.Wait     Task.Result.      c   ,   .    . -,          — AggregateException . AggregateException       ,     (  AggregateException    ). -,  ,   , AggregateException      TaskCanceledException ,   OperationCanceledException ,   : 
 var task = Task.Run(() => { /* -  */ }); try { task.Wait(); Console.WriteLine("Success"); } catch (AggregateException ae) { try { ae.Flatten().Handle(e => e is TaskCanceledException); Console.WriteLine("Cancelled"); } catch (AggregateException e) { Console.WriteLine("Error: {0}", e); } } 
   async-           await .       AggregateException ,       OperationCanceledException ;     : 
 var task = Task.Run(() => { /* -  */ }); try { await task; Console.WriteLine("Success"); } catch (OperationCanceledException) { Console.WriteLine("Cancelled"); } catch (Exception e) { Console.WriteLine("Error: {0}", e); } 

Task. , async- (Task / Task), , . ,
Task<int> task = Task .Delay(TimeSpan.FromSeconds(5)) .ContinueWith(_ => { while (true) { // - } return 42; });
async- :
Task<int> task = SomeWork(); async Task<int> SomeWork() { await Task.Delay(TimeSpan.FromSeconds(5)); while (true) { // - } return 42; }
, Task.Run , Task.Factory.StartNew , . SomeWork int . , SomeWork Task.

, async-, , , . , :
var cts = new CancellationTokenSource(); var cancellationToken = cts.Token; Task<int> task = Task .Delay(TimeSpan.FromSeconds(5), cancellationToken) .ContinueWith(_ => { while (true) { // - cancellationToken.ThrowIfCancellationRequested(); } return 42; }, cancellationToken);

var cts = new CancellationTokenSource(); var cancellationToken = cts.Token; Task<int> task = SomeWork(cancellationToken); async Task<int> SomeWork(CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); /* 1 */ await Task.Delay(TimeSpan.FromSeconds(5), cancellationToken); cancellationToken.ThrowIfCancellationRequested(); /* 2 */ while (true) { // - cancellationToken.ThrowIfCancellationRequested(); } return 42; }
, async-, , CancellationToken ( CancellationToken async- CancellationToken ). :
async-, async- . (, Task.Run Task.ContinueWith ) . 1 2. , async-, . OperationCanceledException . CancellationToken , , .. . , , CancellationToken . , Task.Run , :
static async Task<int> SomeWork(CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); throw new OperationCanceledException(cancellationToken); throw new OperationCanceledException(); throw new OperationCanceledException(CancellationToken.None); throw new OperationCanceledException(new CancellationToken(true)); throw new OperationCanceledException(new CancellationToken(false)); }

Task.IsCompleted true . ( Task.Status == TaskStatus.RanToCompletion ), ( Task.Status == TaskStatus.Faulted ; Task.IsFaulted == true ) ( Task.Status == TaskStatus.Canceled ; Task.IsCanceled == true ). .

-. TaskContinuationOptions - -:
var task = Task.Run(() => 42); task.ContinueWith( t => Console.WriteLine("Result: {0}", t.Result), TaskContinuationOptions.OnlyOnRanToCompletion); task.ContinueWith( _ => Console.WriteLine("Canceled"), TaskContinuationOptions.OnlyOnCanceled); task.ContinueWith( t => Console.WriteLine("Error: {0}", t.Exception), TaskContinuationOptions.OnlyOnFaulted);
Task.Wait Task.Result. c , . . -, — AggregateException . AggregateException , ( AggregateException ). -, , , AggregateException TaskCanceledException , OperationCanceledException , :
var task = Task.Run(() => { /* - */ }); try { task.Wait(); Console.WriteLine("Success"); } catch (AggregateException ae) { try { ae.Flatten().Handle(e => e is TaskCanceledException); Console.WriteLine("Cancelled"); } catch (AggregateException e) { Console.WriteLine("Error: {0}", e); } }
async- await . AggregateException , OperationCanceledException ; :
var task = Task.Run(() => { /* - */ }); try { await task; Console.WriteLine("Success"); } catch (OperationCanceledException) { Console.WriteLine("Cancelled"); } catch (Exception e) { Console.WriteLine("Error: {0}", e); }

 Task.   ,  async-   (Task / Task),    ,   . ,   
 Task<int> task = Task .Delay(TimeSpan.FromSeconds(5)) .ContinueWith(_ => { while (true) { // -  } return 42; }); 
      async-  : 
 Task<int> task = SomeWork(); async Task<int> SomeWork() { await Task.Delay(TimeSpan.FromSeconds(5)); while (true) { // -  } return 42; } 
  ,     Task.Run ,  Task.Factory.StartNew ,  .  SomeWork    int .    ,    SomeWork  Task. 
 
 ,  async-,   ,  ,   .       ,    : 
 var cts = new CancellationTokenSource(); var cancellationToken = cts.Token; Task<int> task = Task .Delay(TimeSpan.FromSeconds(5), cancellationToken) .ContinueWith(_ => { while (true) { // -  cancellationToken.ThrowIfCancellationRequested(); } return 42; }, cancellationToken); 
  
 var cts = new CancellationTokenSource(); var cancellationToken = cts.Token; Task<int> task = SomeWork(cancellationToken); async Task<int> SomeWork(CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); /* 1 */ await Task.Delay(TimeSpan.FromSeconds(5), cancellationToken); cancellationToken.ThrowIfCancellationRequested(); /* 2 */ while (true) { // -  cancellationToken.ThrowIfCancellationRequested(); } return 42; } 
 ,   async-,  ,       CancellationToken ( CancellationToken  async-      CancellationToken   ).      : 
        async-,  async-    .       (,  Task.Run  Task.ContinueWith )   .       1  2. ,   async-,    . OperationCanceledException   .   CancellationToken ,         , ..     .  ,        ,   CancellationToken      . ,      Task.Run ,       : 
 static async Task<int> SomeWork(CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); throw new OperationCanceledException(cancellationToken); throw new OperationCanceledException(); throw new OperationCanceledException(CancellationToken.None); throw new OperationCanceledException(new CancellationToken(true)); throw new OperationCanceledException(new CancellationToken(false)); } 
    
     Task.IsCompleted    true .     ( Task.Status == TaskStatus.RanToCompletion ),   ( Task.Status == TaskStatus.Faulted ; Task.IsFaulted == true )    ( Task.Status == TaskStatus.Canceled ; Task.IsCanceled == true ).             . 
 
       -.      TaskContinuationOptions   -     -: 
 var task = Task.Run(() => 42); task.ContinueWith( t => Console.WriteLine("Result: {0}", t.Result), TaskContinuationOptions.OnlyOnRanToCompletion); task.ContinueWith( _ => Console.WriteLine("Canceled"), TaskContinuationOptions.OnlyOnCanceled); task.ContinueWith( t => Console.WriteLine("Error: {0}", t.Exception), TaskContinuationOptions.OnlyOnFaulted); 
            Task.Wait     Task.Result.      c   ,   .    . -,          — AggregateException . AggregateException       ,     (  AggregateException    ). -,  ,   , AggregateException      TaskCanceledException ,   OperationCanceledException ,   : 
 var task = Task.Run(() => { /* -  */ }); try { task.Wait(); Console.WriteLine("Success"); } catch (AggregateException ae) { try { ae.Flatten().Handle(e => e is TaskCanceledException); Console.WriteLine("Cancelled"); } catch (AggregateException e) { Console.WriteLine("Error: {0}", e); } } 
   async-           await .       AggregateException ,       OperationCanceledException ;     : 
 var task = Task.Run(() => { /* -  */ }); try { await task; Console.WriteLine("Success"); } catch (OperationCanceledException) { Console.WriteLine("Cancelled"); } catch (Exception e) { Console.WriteLine("Error: {0}", e); } 

Task. , async- (Task / Task), , . ,
Task<int> task = Task .Delay(TimeSpan.FromSeconds(5)) .ContinueWith(_ => { while (true) { // - } return 42; });
async- :
Task<int> task = SomeWork(); async Task<int> SomeWork() { await Task.Delay(TimeSpan.FromSeconds(5)); while (true) { // - } return 42; }
, Task.Run , Task.Factory.StartNew , . SomeWork int . , SomeWork Task.

, async-, , , . , :
var cts = new CancellationTokenSource(); var cancellationToken = cts.Token; Task<int> task = Task .Delay(TimeSpan.FromSeconds(5), cancellationToken) .ContinueWith(_ => { while (true) { // - cancellationToken.ThrowIfCancellationRequested(); } return 42; }, cancellationToken);

var cts = new CancellationTokenSource(); var cancellationToken = cts.Token; Task<int> task = SomeWork(cancellationToken); async Task<int> SomeWork(CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); /* 1 */ await Task.Delay(TimeSpan.FromSeconds(5), cancellationToken); cancellationToken.ThrowIfCancellationRequested(); /* 2 */ while (true) { // - cancellationToken.ThrowIfCancellationRequested(); } return 42; }
, async-, , CancellationToken ( CancellationToken async- CancellationToken ). :
async-, async- . (, Task.Run Task.ContinueWith ) . 1 2. , async-, . OperationCanceledException . CancellationToken , , .. . , , CancellationToken . , Task.Run , :
static async Task<int> SomeWork(CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); throw new OperationCanceledException(cancellationToken); throw new OperationCanceledException(); throw new OperationCanceledException(CancellationToken.None); throw new OperationCanceledException(new CancellationToken(true)); throw new OperationCanceledException(new CancellationToken(false)); }

Task.IsCompleted true . ( Task.Status == TaskStatus.RanToCompletion ), ( Task.Status == TaskStatus.Faulted ; Task.IsFaulted == true ) ( Task.Status == TaskStatus.Canceled ; Task.IsCanceled == true ). .

-. TaskContinuationOptions - -:
var task = Task.Run(() => 42); task.ContinueWith( t => Console.WriteLine("Result: {0}", t.Result), TaskContinuationOptions.OnlyOnRanToCompletion); task.ContinueWith( _ => Console.WriteLine("Canceled"), TaskContinuationOptions.OnlyOnCanceled); task.ContinueWith( t => Console.WriteLine("Error: {0}", t.Exception), TaskContinuationOptions.OnlyOnFaulted);
Task.Wait Task.Result. c , . . -, — AggregateException . AggregateException , ( AggregateException ). -, , , AggregateException TaskCanceledException , OperationCanceledException , :
var task = Task.Run(() => { /* - */ }); try { task.Wait(); Console.WriteLine("Success"); } catch (AggregateException ae) { try { ae.Flatten().Handle(e => e is TaskCanceledException); Console.WriteLine("Cancelled"); } catch (AggregateException e) { Console.WriteLine("Error: {0}", e); } }
async- await . AggregateException , OperationCanceledException ; :
var task = Task.Run(() => { /* - */ }); try { await task; Console.WriteLine("Success"); } catch (OperationCanceledException) { Console.WriteLine("Cancelled"); } catch (Exception e) { Console.WriteLine("Error: {0}", e); }

• Task. , async- (Task / Task), , . ,
Task<int> task = Task .Delay(TimeSpan.FromSeconds(5)) .ContinueWith(_ => { while (true) { // - } return 42; });
async- :
Task<int> task = SomeWork(); async Task<int> SomeWork() { await Task.Delay(TimeSpan.FromSeconds(5)); while (true) { // - } return 42; }
, Task.Run , Task.Factory.StartNew , . SomeWork int . , SomeWork Task.

, async-, , , . , :
var cts = new CancellationTokenSource(); var cancellationToken = cts.Token; Task<int> task = Task .Delay(TimeSpan.FromSeconds(5), cancellationToken) .ContinueWith(_ => { while (true) { // - cancellationToken.ThrowIfCancellationRequested(); } return 42; }, cancellationToken);

var cts = new CancellationTokenSource(); var cancellationToken = cts.Token; Task<int> task = SomeWork(cancellationToken); async Task<int> SomeWork(CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); /* 1 */ await Task.Delay(TimeSpan.FromSeconds(5), cancellationToken); cancellationToken.ThrowIfCancellationRequested(); /* 2 */ while (true) { // - cancellationToken.ThrowIfCancellationRequested(); } return 42; }
, async-, , CancellationToken ( CancellationToken async- CancellationToken ). :
async-, async- . (, Task.Run Task.ContinueWith ) . 1 2. , async-, . OperationCanceledException . CancellationToken , , .. . , , CancellationToken . , Task.Run , :
static async Task<int> SomeWork(CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); throw new OperationCanceledException(cancellationToken); throw new OperationCanceledException(); throw new OperationCanceledException(CancellationToken.None); throw new OperationCanceledException(new CancellationToken(true)); throw new OperationCanceledException(new CancellationToken(false)); }

Task.IsCompleted true . ( Task.Status == TaskStatus.RanToCompletion ), ( Task.Status == TaskStatus.Faulted ; Task.IsFaulted == true ) ( Task.Status == TaskStatus.Canceled ; Task.IsCanceled == true ). .

-. TaskContinuationOptions - -:
var task = Task.Run(() => 42); task.ContinueWith( t => Console.WriteLine("Result: {0}", t.Result), TaskContinuationOptions.OnlyOnRanToCompletion); task.ContinueWith( _ => Console.WriteLine("Canceled"), TaskContinuationOptions.OnlyOnCanceled); task.ContinueWith( t => Console.WriteLine("Error: {0}", t.Exception), TaskContinuationOptions.OnlyOnFaulted);
Task.Wait Task.Result. c , . . -, — AggregateException . AggregateException , ( AggregateException ). -, , , AggregateException TaskCanceledException , OperationCanceledException , :
var task = Task.Run(() => { /* - */ }); try { task.Wait(); Console.WriteLine("Success"); } catch (AggregateException ae) { try { ae.Flatten().Handle(e => e is TaskCanceledException); Console.WriteLine("Cancelled"); } catch (AggregateException e) { Console.WriteLine("Error: {0}", e); } }
async- await . AggregateException , OperationCanceledException ; :
var task = Task.Run(() => { /* - */ }); try { await task; Console.WriteLine("Success"); } catch (OperationCanceledException) { Console.WriteLine("Cancelled"); } catch (Exception e) { Console.WriteLine("Error: {0}", e); }
• Task. , async- (Task / Task), , . ,
Task<int> task = Task .Delay(TimeSpan.FromSeconds(5)) .ContinueWith(_ => { while (true) { // - } return 42; });
async- :
Task<int> task = SomeWork(); async Task<int> SomeWork() { await Task.Delay(TimeSpan.FromSeconds(5)); while (true) { // - } return 42; }
, Task.Run , Task.Factory.StartNew , . SomeWork int . , SomeWork Task.

, async-, , , . , :
var cts = new CancellationTokenSource(); var cancellationToken = cts.Token; Task<int> task = Task .Delay(TimeSpan.FromSeconds(5), cancellationToken) .ContinueWith(_ => { while (true) { // - cancellationToken.ThrowIfCancellationRequested(); } return 42; }, cancellationToken);

var cts = new CancellationTokenSource(); var cancellationToken = cts.Token; Task<int> task = SomeWork(cancellationToken); async Task<int> SomeWork(CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); /* 1 */ await Task.Delay(TimeSpan.FromSeconds(5), cancellationToken); cancellationToken.ThrowIfCancellationRequested(); /* 2 */ while (true) { // - cancellationToken.ThrowIfCancellationRequested(); } return 42; }
, async-, , CancellationToken ( CancellationToken async- CancellationToken ). :
async-, async- . (, Task.Run Task.ContinueWith ) . 1 2. , async-, . OperationCanceledException . CancellationToken , , .. . , , CancellationToken . , Task.Run , :
static async Task<int> SomeWork(CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); throw new OperationCanceledException(cancellationToken); throw new OperationCanceledException(); throw new OperationCanceledException(CancellationToken.None); throw new OperationCanceledException(new CancellationToken(true)); throw new OperationCanceledException(new CancellationToken(false)); }

Task.IsCompleted true . ( Task.Status == TaskStatus.RanToCompletion ), ( Task.Status == TaskStatus.Faulted ; Task.IsFaulted == true ) ( Task.Status == TaskStatus.Canceled ; Task.IsCanceled == true ). .

-. TaskContinuationOptions - -:
var task = Task.Run(() => 42); task.ContinueWith( t => Console.WriteLine("Result: {0}", t.Result), TaskContinuationOptions.OnlyOnRanToCompletion); task.ContinueWith( _ => Console.WriteLine("Canceled"), TaskContinuationOptions.OnlyOnCanceled); task.ContinueWith( t => Console.WriteLine("Error: {0}", t.Exception), TaskContinuationOptions.OnlyOnFaulted);
Task.Wait Task.Result. c , . . -, — AggregateException . AggregateException , ( AggregateException ). -, , , AggregateException TaskCanceledException , OperationCanceledException , :
var task = Task.Run(() => { /* - */ }); try { task.Wait(); Console.WriteLine("Success"); } catch (AggregateException ae) { try { ae.Flatten().Handle(e => e is TaskCanceledException); Console.WriteLine("Cancelled"); } catch (AggregateException e) { Console.WriteLine("Error: {0}", e); } }
async- await . AggregateException , OperationCanceledException ; :
var task = Task.Run(() => { /* - */ }); try { await task; Console.WriteLine("Success"); } catch (OperationCanceledException) { Console.WriteLine("Cancelled"); } catch (Exception e) { Console.WriteLine("Error: {0}", e); }

Task. , async- (Task / Task), , . ,
Task<int> task = Task .Delay(TimeSpan.FromSeconds(5)) .ContinueWith(_ => { while (true) { // - } return 42; });
async- :
Task<int> task = SomeWork(); async Task<int> SomeWork() { await Task.Delay(TimeSpan.FromSeconds(5)); while (true) { // - } return 42; }
, Task.Run , Task.Factory.StartNew , . SomeWork int . , SomeWork Task.

, async-, , , . , :
var cts = new CancellationTokenSource(); var cancellationToken = cts.Token; Task<int> task = Task .Delay(TimeSpan.FromSeconds(5), cancellationToken) .ContinueWith(_ => { while (true) { // - cancellationToken.ThrowIfCancellationRequested(); } return 42; }, cancellationToken);

var cts = new CancellationTokenSource(); var cancellationToken = cts.Token; Task<int> task = SomeWork(cancellationToken); async Task<int> SomeWork(CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); /* 1 */ await Task.Delay(TimeSpan.FromSeconds(5), cancellationToken); cancellationToken.ThrowIfCancellationRequested(); /* 2 */ while (true) { // - cancellationToken.ThrowIfCancellationRequested(); } return 42; }
, async-, , CancellationToken ( CancellationToken async- CancellationToken ). :
async-, async- . (, Task.Run Task.ContinueWith ) . 1 2. , async-, . OperationCanceledException . CancellationToken , , .. . , , CancellationToken . , Task.Run , :
static async Task<int> SomeWork(CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); throw new OperationCanceledException(cancellationToken); throw new OperationCanceledException(); throw new OperationCanceledException(CancellationToken.None); throw new OperationCanceledException(new CancellationToken(true)); throw new OperationCanceledException(new CancellationToken(false)); }

Task.IsCompleted true . ( Task.Status == TaskStatus.RanToCompletion ), ( Task.Status == TaskStatus.Faulted ; Task.IsFaulted == true ) ( Task.Status == TaskStatus.Canceled ; Task.IsCanceled == true ). .

-. TaskContinuationOptions - -:
var task = Task.Run(() => 42); task.ContinueWith( t => Console.WriteLine("Result: {0}", t.Result), TaskContinuationOptions.OnlyOnRanToCompletion); task.ContinueWith( _ => Console.WriteLine("Canceled"), TaskContinuationOptions.OnlyOnCanceled); task.ContinueWith( t => Console.WriteLine("Error: {0}", t.Exception), TaskContinuationOptions.OnlyOnFaulted);
Task.Wait Task.Result. c , . . -, — AggregateException . AggregateException , ( AggregateException ). -, , , AggregateException TaskCanceledException , OperationCanceledException , :
var task = Task.Run(() => { /* - */ }); try { task.Wait(); Console.WriteLine("Success"); } catch (AggregateException ae) { try { ae.Flatten().Handle(e => e is TaskCanceledException); Console.WriteLine("Cancelled"); } catch (AggregateException e) { Console.WriteLine("Error: {0}", e); } }
async- await . AggregateException , OperationCanceledException ; :
var task = Task.Run(() => { /* - */ }); try { await task; Console.WriteLine("Success"); } catch (OperationCanceledException) { Console.WriteLine("Cancelled"); } catch (Exception e) { Console.WriteLine("Error: {0}", e); }

 Task.   ,  async-   (Task / Task),    ,   . ,   
 Task<int> task = Task .Delay(TimeSpan.FromSeconds(5)) .ContinueWith(_ => { while (true) { // -  } return 42; }); 
      async-  : 
 Task<int> task = SomeWork(); async Task<int> SomeWork() { await Task.Delay(TimeSpan.FromSeconds(5)); while (true) { // -  } return 42; } 
  ,     Task.Run ,  Task.Factory.StartNew ,  .  SomeWork    int .    ,    SomeWork  Task. 
 
 ,  async-,   ,  ,   .       ,    : 
 var cts = new CancellationTokenSource(); var cancellationToken = cts.Token; Task<int> task = Task .Delay(TimeSpan.FromSeconds(5), cancellationToken) .ContinueWith(_ => { while (true) { // -  cancellationToken.ThrowIfCancellationRequested(); } return 42; }, cancellationToken); 
  
 var cts = new CancellationTokenSource(); var cancellationToken = cts.Token; Task<int> task = SomeWork(cancellationToken); async Task<int> SomeWork(CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); /* 1 */ await Task.Delay(TimeSpan.FromSeconds(5), cancellationToken); cancellationToken.ThrowIfCancellationRequested(); /* 2 */ while (true) { // -  cancellationToken.ThrowIfCancellationRequested(); } return 42; } 
 ,   async-,  ,       CancellationToken ( CancellationToken  async-      CancellationToken   ).      : 
        async-,  async-    .       (,  Task.Run  Task.ContinueWith )   .       1  2. ,   async-,    . OperationCanceledException   .   CancellationToken ,         , ..     .  ,        ,   CancellationToken      . ,      Task.Run ,       : 
 static async Task<int> SomeWork(CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); throw new OperationCanceledException(cancellationToken); throw new OperationCanceledException(); throw new OperationCanceledException(CancellationToken.None); throw new OperationCanceledException(new CancellationToken(true)); throw new OperationCanceledException(new CancellationToken(false)); } 
    
     Task.IsCompleted    true .     ( Task.Status == TaskStatus.RanToCompletion ),   ( Task.Status == TaskStatus.Faulted ; Task.IsFaulted == true )    ( Task.Status == TaskStatus.Canceled ; Task.IsCanceled == true ).             . 
 
       -.      TaskContinuationOptions   -     -: 
 var task = Task.Run(() => 42); task.ContinueWith( t => Console.WriteLine("Result: {0}", t.Result), TaskContinuationOptions.OnlyOnRanToCompletion); task.ContinueWith( _ => Console.WriteLine("Canceled"), TaskContinuationOptions.OnlyOnCanceled); task.ContinueWith( t => Console.WriteLine("Error: {0}", t.Exception), TaskContinuationOptions.OnlyOnFaulted); 
            Task.Wait     Task.Result.      c   ,   .    . -,          — AggregateException . AggregateException       ,     (  AggregateException    ). -,  ,   , AggregateException      TaskCanceledException ,   OperationCanceledException ,   : 
 var task = Task.Run(() => { /* -  */ }); try { task.Wait(); Console.WriteLine("Success"); } catch (AggregateException ae) { try { ae.Flatten().Handle(e => e is TaskCanceledException); Console.WriteLine("Cancelled"); } catch (AggregateException e) { Console.WriteLine("Error: {0}", e); } } 
   async-           await .       AggregateException ,       OperationCanceledException ;     : 
 var task = Task.Run(() => { /* -  */ }); try { await task; Console.WriteLine("Success"); } catch (OperationCanceledException) { Console.WriteLine("Cancelled"); } catch (Exception e) { Console.WriteLine("Error: {0}", e); } 

Task. , async- (Task / Task), , . ,
Task<int> task = Task .Delay(TimeSpan.FromSeconds(5)) .ContinueWith(_ => { while (true) { // - } return 42; });
async- :
Task<int> task = SomeWork(); async Task<int> SomeWork() { await Task.Delay(TimeSpan.FromSeconds(5)); while (true) { // - } return 42; }
, Task.Run , Task.Factory.StartNew , . SomeWork int . , SomeWork Task.

, async-, , , . , :
var cts = new CancellationTokenSource(); var cancellationToken = cts.Token; Task<int> task = Task .Delay(TimeSpan.FromSeconds(5), cancellationToken) .ContinueWith(_ => { while (true) { // - cancellationToken.ThrowIfCancellationRequested(); } return 42; }, cancellationToken);

var cts = new CancellationTokenSource(); var cancellationToken = cts.Token; Task<int> task = SomeWork(cancellationToken); async Task<int> SomeWork(CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); /* 1 */ await Task.Delay(TimeSpan.FromSeconds(5), cancellationToken); cancellationToken.ThrowIfCancellationRequested(); /* 2 */ while (true) { // - cancellationToken.ThrowIfCancellationRequested(); } return 42; }
, async-, , CancellationToken ( CancellationToken async- CancellationToken ). :
async-, async- . (, Task.Run Task.ContinueWith ) . 1 2. , async-, . OperationCanceledException . CancellationToken , , .. . , , CancellationToken . , Task.Run , :
static async Task<int> SomeWork(CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); throw new OperationCanceledException(cancellationToken); throw new OperationCanceledException(); throw new OperationCanceledException(CancellationToken.None); throw new OperationCanceledException(new CancellationToken(true)); throw new OperationCanceledException(new CancellationToken(false)); }

Task.IsCompleted true . ( Task.Status == TaskStatus.RanToCompletion ), ( Task.Status == TaskStatus.Faulted ; Task.IsFaulted == true ) ( Task.Status == TaskStatus.Canceled ; Task.IsCanceled == true ). .

-. TaskContinuationOptions - -:
var task = Task.Run(() => 42); task.ContinueWith( t => Console.WriteLine("Result: {0}", t.Result), TaskContinuationOptions.OnlyOnRanToCompletion); task.ContinueWith( _ => Console.WriteLine("Canceled"), TaskContinuationOptions.OnlyOnCanceled); task.ContinueWith( t => Console.WriteLine("Error: {0}", t.Exception), TaskContinuationOptions.OnlyOnFaulted);
Task.Wait Task.Result. c , . . -, — AggregateException . AggregateException , ( AggregateException ). -, , , AggregateException TaskCanceledException , OperationCanceledException , :
var task = Task.Run(() => { /* - */ }); try { task.Wait(); Console.WriteLine("Success"); } catch (AggregateException ae) { try { ae.Flatten().Handle(e => e is TaskCanceledException); Console.WriteLine("Cancelled"); } catch (AggregateException e) { Console.WriteLine("Error: {0}", e); } }
async- await . AggregateException , OperationCanceledException ; :
var task = Task.Run(() => { /* - */ }); try { await task; Console.WriteLine("Success"); } catch (OperationCanceledException) { Console.WriteLine("Cancelled"); } catch (Exception e) { Console.WriteLine("Error: {0}", e); }

Task. , async- (Task / Task), , . ,
Task<int> task = Task .Delay(TimeSpan.FromSeconds(5)) .ContinueWith(_ => { while (true) { // - } return 42; });
async- :
Task<int> task = SomeWork(); async Task<int> SomeWork() { await Task.Delay(TimeSpan.FromSeconds(5)); while (true) { // - } return 42; }
, Task.Run , Task.Factory.StartNew , . SomeWork int . , SomeWork Task.

, async-, , , . , :
var cts = new CancellationTokenSource(); var cancellationToken = cts.Token; Task<int> task = Task .Delay(TimeSpan.FromSeconds(5), cancellationToken) .ContinueWith(_ => { while (true) { // - cancellationToken.ThrowIfCancellationRequested(); } return 42; }, cancellationToken);

var cts = new CancellationTokenSource(); var cancellationToken = cts.Token; Task<int> task = SomeWork(cancellationToken); async Task<int> SomeWork(CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); /* 1 */ await Task.Delay(TimeSpan.FromSeconds(5), cancellationToken); cancellationToken.ThrowIfCancellationRequested(); /* 2 */ while (true) { // - cancellationToken.ThrowIfCancellationRequested(); } return 42; }
, async-, , CancellationToken ( CancellationToken async- CancellationToken ). :
async-, async- . (, Task.Run Task.ContinueWith ) . 1 2. , async-, . OperationCanceledException . CancellationToken , , .. . , , CancellationToken . , Task.Run , :
static async Task<int> SomeWork(CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); throw new OperationCanceledException(cancellationToken); throw new OperationCanceledException(); throw new OperationCanceledException(CancellationToken.None); throw new OperationCanceledException(new CancellationToken(true)); throw new OperationCanceledException(new CancellationToken(false)); }

Task.IsCompleted true . ( Task.Status == TaskStatus.RanToCompletion ), ( Task.Status == TaskStatus.Faulted ; Task.IsFaulted == true ) ( Task.Status == TaskStatus.Canceled ; Task.IsCanceled == true ). .

-. TaskContinuationOptions - -:
var task = Task.Run(() => 42); task.ContinueWith( t => Console.WriteLine("Result: {0}", t.Result), TaskContinuationOptions.OnlyOnRanToCompletion); task.ContinueWith( _ => Console.WriteLine("Canceled"), TaskContinuationOptions.OnlyOnCanceled); task.ContinueWith( t => Console.WriteLine("Error: {0}", t.Exception), TaskContinuationOptions.OnlyOnFaulted);
Task.Wait Task.Result. c , . . -, — AggregateException . AggregateException , ( AggregateException ). -, , , AggregateException TaskCanceledException , OperationCanceledException , :
var task = Task.Run(() => { /* - */ }); try { task.Wait(); Console.WriteLine("Success"); } catch (AggregateException ae) { try { ae.Flatten().Handle(e => e is TaskCanceledException); Console.WriteLine("Cancelled"); } catch (AggregateException e) { Console.WriteLine("Error: {0}", e); } }
async- await . AggregateException , OperationCanceledException ; :
var task = Task.Run(() => { /* - */ }); try { await task; Console.WriteLine("Success"); } catch (OperationCanceledException) { Console.WriteLine("Cancelled"); } catch (Exception e) { Console.WriteLine("Error: {0}", e); }

Task. , async- (Task / Task), , . ,
Task<int> task = Task .Delay(TimeSpan.FromSeconds(5)) .ContinueWith(_ => { while (true) { // - } return 42; });
async- :
Task<int> task = SomeWork(); async Task<int> SomeWork() { await Task.Delay(TimeSpan.FromSeconds(5)); while (true) { // - } return 42; }
, Task.Run , Task.Factory.StartNew , . SomeWork int . , SomeWork Task.

, async-, , , . , :
var cts = new CancellationTokenSource(); var cancellationToken = cts.Token; Task<int> task = Task .Delay(TimeSpan.FromSeconds(5), cancellationToken) .ContinueWith(_ => { while (true) { // - cancellationToken.ThrowIfCancellationRequested(); } return 42; }, cancellationToken);

var cts = new CancellationTokenSource(); var cancellationToken = cts.Token; Task<int> task = SomeWork(cancellationToken); async Task<int> SomeWork(CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); /* 1 */ await Task.Delay(TimeSpan.FromSeconds(5), cancellationToken); cancellationToken.ThrowIfCancellationRequested(); /* 2 */ while (true) { // - cancellationToken.ThrowIfCancellationRequested(); } return 42; }
, async-, , CancellationToken ( CancellationToken async- CancellationToken ). :
async-, async- . (, Task.Run Task.ContinueWith ) . 1 2. , async-, . OperationCanceledException . CancellationToken , , .. . , , CancellationToken . , Task.Run , :
static async Task<int> SomeWork(CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); throw new OperationCanceledException(cancellationToken); throw new OperationCanceledException(); throw new OperationCanceledException(CancellationToken.None); throw new OperationCanceledException(new CancellationToken(true)); throw new OperationCanceledException(new CancellationToken(false)); }

Task.IsCompleted true . ( Task.Status == TaskStatus.RanToCompletion ), ( Task.Status == TaskStatus.Faulted ; Task.IsFaulted == true ) ( Task.Status == TaskStatus.Canceled ; Task.IsCanceled == true ). .

-. TaskContinuationOptions - -:
var task = Task.Run(() => 42); task.ContinueWith( t => Console.WriteLine("Result: {0}", t.Result), TaskContinuationOptions.OnlyOnRanToCompletion); task.ContinueWith( _ => Console.WriteLine("Canceled"), TaskContinuationOptions.OnlyOnCanceled); task.ContinueWith( t => Console.WriteLine("Error: {0}", t.Exception), TaskContinuationOptions.OnlyOnFaulted);
Task.Wait Task.Result. c , . . -, — AggregateException . AggregateException , ( AggregateException ). -, , , AggregateException TaskCanceledException , OperationCanceledException , :
var task = Task.Run(() => { /* - */ }); try { task.Wait(); Console.WriteLine("Success"); } catch (AggregateException ae) { try { ae.Flatten().Handle(e => e is TaskCanceledException); Console.WriteLine("Cancelled"); } catch (AggregateException e) { Console.WriteLine("Error: {0}", e); } }
async- await . AggregateException , OperationCanceledException ; :
var task = Task.Run(() => { /* - */ }); try { await task; Console.WriteLine("Success"); } catch (OperationCanceledException) { Console.WriteLine("Cancelled"); } catch (Exception e) { Console.WriteLine("Error: {0}", e); }

 Task.   ,  async-   (Task / Task),    ,   . ,   
 Task<int> task = Task .Delay(TimeSpan.FromSeconds(5)) .ContinueWith(_ => { while (true) { // -  } return 42; }); 
      async-  : 
 Task<int> task = SomeWork(); async Task<int> SomeWork() { await Task.Delay(TimeSpan.FromSeconds(5)); while (true) { // -  } return 42; } 
  ,     Task.Run ,  Task.Factory.StartNew ,  .  SomeWork    int .    ,    SomeWork  Task. 
 
 ,  async-,   ,  ,   .       ,    : 
 var cts = new CancellationTokenSource(); var cancellationToken = cts.Token; Task<int> task = Task .Delay(TimeSpan.FromSeconds(5), cancellationToken) .ContinueWith(_ => { while (true) { // -  cancellationToken.ThrowIfCancellationRequested(); } return 42; }, cancellationToken); 
  
 var cts = new CancellationTokenSource(); var cancellationToken = cts.Token; Task<int> task = SomeWork(cancellationToken); async Task<int> SomeWork(CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); /* 1 */ await Task.Delay(TimeSpan.FromSeconds(5), cancellationToken); cancellationToken.ThrowIfCancellationRequested(); /* 2 */ while (true) { // -  cancellationToken.ThrowIfCancellationRequested(); } return 42; } 
 ,   async-,  ,       CancellationToken ( CancellationToken  async-      CancellationToken   ).      : 
        async-,  async-    .       (,  Task.Run  Task.ContinueWith )   .       1  2. ,   async-,    . OperationCanceledException   .   CancellationToken ,         , ..     .  ,        ,   CancellationToken      . ,      Task.Run ,       : 
 static async Task<int> SomeWork(CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); throw new OperationCanceledException(cancellationToken); throw new OperationCanceledException(); throw new OperationCanceledException(CancellationToken.None); throw new OperationCanceledException(new CancellationToken(true)); throw new OperationCanceledException(new CancellationToken(false)); } 
    
     Task.IsCompleted    true .     ( Task.Status == TaskStatus.RanToCompletion ),   ( Task.Status == TaskStatus.Faulted ; Task.IsFaulted == true )    ( Task.Status == TaskStatus.Canceled ; Task.IsCanceled == true ).             . 
 
       -.      TaskContinuationOptions   -     -: 
 var task = Task.Run(() => 42); task.ContinueWith( t => Console.WriteLine("Result: {0}", t.Result), TaskContinuationOptions.OnlyOnRanToCompletion); task.ContinueWith( _ => Console.WriteLine("Canceled"), TaskContinuationOptions.OnlyOnCanceled); task.ContinueWith( t => Console.WriteLine("Error: {0}", t.Exception), TaskContinuationOptions.OnlyOnFaulted); 
            Task.Wait     Task.Result.      c   ,   .    . -,          — AggregateException . AggregateException       ,     (  AggregateException    ). -,  ,   , AggregateException      TaskCanceledException ,   OperationCanceledException ,   : 
 var task = Task.Run(() => { /* -  */ }); try { task.Wait(); Console.WriteLine("Success"); } catch (AggregateException ae) { try { ae.Flatten().Handle(e => e is TaskCanceledException); Console.WriteLine("Cancelled"); } catch (AggregateException e) { Console.WriteLine("Error: {0}", e); } } 
   async-           await .       AggregateException ,       OperationCanceledException ;     : 
 var task = Task.Run(() => { /* -  */ }); try { await task; Console.WriteLine("Success"); } catch (OperationCanceledException) { Console.WriteLine("Cancelled"); } catch (Exception e) { Console.WriteLine("Error: {0}", e); } 

Task. , async- (Task / Task), , . ,
Task<int> task = Task .Delay(TimeSpan.FromSeconds(5)) .ContinueWith(_ => { while (true) { // - } return 42; });
async- :
Task<int> task = SomeWork(); async Task<int> SomeWork() { await Task.Delay(TimeSpan.FromSeconds(5)); while (true) { // - } return 42; }
, Task.Run , Task.Factory.StartNew , . SomeWork int . , SomeWork Task.

, async-, , , . , :
var cts = new CancellationTokenSource(); var cancellationToken = cts.Token; Task<int> task = Task .Delay(TimeSpan.FromSeconds(5), cancellationToken) .ContinueWith(_ => { while (true) { // - cancellationToken.ThrowIfCancellationRequested(); } return 42; }, cancellationToken);

var cts = new CancellationTokenSource(); var cancellationToken = cts.Token; Task<int> task = SomeWork(cancellationToken); async Task<int> SomeWork(CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); /* 1 */ await Task.Delay(TimeSpan.FromSeconds(5), cancellationToken); cancellationToken.ThrowIfCancellationRequested(); /* 2 */ while (true) { // - cancellationToken.ThrowIfCancellationRequested(); } return 42; }
, async-, , CancellationToken ( CancellationToken async- CancellationToken ). :
async-, async- . (, Task.Run Task.ContinueWith ) . 1 2. , async-, . OperationCanceledException . CancellationToken , , .. . , , CancellationToken . , Task.Run , :
static async Task<int> SomeWork(CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); throw new OperationCanceledException(cancellationToken); throw new OperationCanceledException(); throw new OperationCanceledException(CancellationToken.None); throw new OperationCanceledException(new CancellationToken(true)); throw new OperationCanceledException(new CancellationToken(false)); }

Task.IsCompleted true . ( Task.Status == TaskStatus.RanToCompletion ), ( Task.Status == TaskStatus.Faulted ; Task.IsFaulted == true ) ( Task.Status == TaskStatus.Canceled ; Task.IsCanceled == true ). .

-. TaskContinuationOptions - -:
var task = Task.Run(() => 42); task.ContinueWith( t => Console.WriteLine("Result: {0}", t.Result), TaskContinuationOptions.OnlyOnRanToCompletion); task.ContinueWith( _ => Console.WriteLine("Canceled"), TaskContinuationOptions.OnlyOnCanceled); task.ContinueWith( t => Console.WriteLine("Error: {0}", t.Exception), TaskContinuationOptions.OnlyOnFaulted);
Task.Wait Task.Result. c , . . -, — AggregateException . AggregateException , ( AggregateException ). -, , , AggregateException TaskCanceledException , OperationCanceledException , :
var task = Task.Run(() => { /* - */ }); try { task.Wait(); Console.WriteLine("Success"); } catch (AggregateException ae) { try { ae.Flatten().Handle(e => e is TaskCanceledException); Console.WriteLine("Cancelled"); } catch (AggregateException e) { Console.WriteLine("Error: {0}", e); } }
async- await . AggregateException , OperationCanceledException ; :
var task = Task.Run(() => { /* - */ }); try { await task; Console.WriteLine("Success"); } catch (OperationCanceledException) { Console.WriteLine("Cancelled"); } catch (Exception e) { Console.WriteLine("Error: {0}", e); }

 Task.   ,  async-   (Task / Task),    ,   . ,   
 Task<int> task = Task .Delay(TimeSpan.FromSeconds(5)) .ContinueWith(_ => { while (true) { // -  } return 42; }); 
      async-  : 
 Task<int> task = SomeWork(); async Task<int> SomeWork() { await Task.Delay(TimeSpan.FromSeconds(5)); while (true) { // -  } return 42; } 
  ,     Task.Run ,  Task.Factory.StartNew ,  .  SomeWork    int .    ,    SomeWork  Task. 
 
 ,  async-,   ,  ,   .       ,    : 
 var cts = new CancellationTokenSource(); var cancellationToken = cts.Token; Task<int> task = Task .Delay(TimeSpan.FromSeconds(5), cancellationToken) .ContinueWith(_ => { while (true) { // -  cancellationToken.ThrowIfCancellationRequested(); } return 42; }, cancellationToken); 
  
 var cts = new CancellationTokenSource(); var cancellationToken = cts.Token; Task<int> task = SomeWork(cancellationToken); async Task<int> SomeWork(CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); /* 1 */ await Task.Delay(TimeSpan.FromSeconds(5), cancellationToken); cancellationToken.ThrowIfCancellationRequested(); /* 2 */ while (true) { // -  cancellationToken.ThrowIfCancellationRequested(); } return 42; } 
 ,   async-,  ,       CancellationToken ( CancellationToken  async-      CancellationToken   ).      : 
        async-,  async-    .       (,  Task.Run  Task.ContinueWith )   .       1  2. ,   async-,    . OperationCanceledException   .   CancellationToken ,         , ..     .  ,        ,   CancellationToken      . ,      Task.Run ,       : 
 static async Task<int> SomeWork(CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); throw new OperationCanceledException(cancellationToken); throw new OperationCanceledException(); throw new OperationCanceledException(CancellationToken.None); throw new OperationCanceledException(new CancellationToken(true)); throw new OperationCanceledException(new CancellationToken(false)); } 
    
     Task.IsCompleted    true .     ( Task.Status == TaskStatus.RanToCompletion ),   ( Task.Status == TaskStatus.Faulted ; Task.IsFaulted == true )    ( Task.Status == TaskStatus.Canceled ; Task.IsCanceled == true ).             . 
 
       -.      TaskContinuationOptions   -     -: 
 var task = Task.Run(() => 42); task.ContinueWith( t => Console.WriteLine("Result: {0}", t.Result), TaskContinuationOptions.OnlyOnRanToCompletion); task.ContinueWith( _ => Console.WriteLine("Canceled"), TaskContinuationOptions.OnlyOnCanceled); task.ContinueWith( t => Console.WriteLine("Error: {0}", t.Exception), TaskContinuationOptions.OnlyOnFaulted); 
            Task.Wait     Task.Result.      c   ,   .    . -,          — AggregateException . AggregateException       ,     (  AggregateException    ). -,  ,   , AggregateException      TaskCanceledException ,   OperationCanceledException ,   : 
 var task = Task.Run(() => { /* -  */ }); try { task.Wait(); Console.WriteLine("Success"); } catch (AggregateException ae) { try { ae.Flatten().Handle(e => e is TaskCanceledException); Console.WriteLine("Cancelled"); } catch (AggregateException e) { Console.WriteLine("Error: {0}", e); } } 
   async-           await .       AggregateException ,       OperationCanceledException ;     : 
 var task = Task.Run(() => { /* -  */ }); try { await task; Console.WriteLine("Success"); } catch (OperationCanceledException) { Console.WriteLine("Cancelled"); } catch (Exception e) { Console.WriteLine("Error: {0}", e); } 

Task. , async- (Task / Task), , . ,
Task<int> task = Task .Delay(TimeSpan.FromSeconds(5)) .ContinueWith(_ => { while (true) { // - } return 42; });
async- :
Task<int> task = SomeWork(); async Task<int> SomeWork() { await Task.Delay(TimeSpan.FromSeconds(5)); while (true) { // - } return 42; }
, Task.Run , Task.Factory.StartNew , . SomeWork int . , SomeWork Task.

, async-, , , . , :
var cts = new CancellationTokenSource(); var cancellationToken = cts.Token; Task<int> task = Task .Delay(TimeSpan.FromSeconds(5), cancellationToken) .ContinueWith(_ => { while (true) { // - cancellationToken.ThrowIfCancellationRequested(); } return 42; }, cancellationToken);

var cts = new CancellationTokenSource(); var cancellationToken = cts.Token; Task<int> task = SomeWork(cancellationToken); async Task<int> SomeWork(CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); /* 1 */ await Task.Delay(TimeSpan.FromSeconds(5), cancellationToken); cancellationToken.ThrowIfCancellationRequested(); /* 2 */ while (true) { // - cancellationToken.ThrowIfCancellationRequested(); } return 42; }
, async-, , CancellationToken ( CancellationToken async- CancellationToken ). :
async-, async- . (, Task.Run Task.ContinueWith ) . 1 2. , async-, . OperationCanceledException . CancellationToken , , .. . , , CancellationToken . , Task.Run , :
static async Task<int> SomeWork(CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); throw new OperationCanceledException(cancellationToken); throw new OperationCanceledException(); throw new OperationCanceledException(CancellationToken.None); throw new OperationCanceledException(new CancellationToken(true)); throw new OperationCanceledException(new CancellationToken(false)); }

Task.IsCompleted true . ( Task.Status == TaskStatus.RanToCompletion ), ( Task.Status == TaskStatus.Faulted ; Task.IsFaulted == true ) ( Task.Status == TaskStatus.Canceled ; Task.IsCanceled == true ). .

-. TaskContinuationOptions - -:
var task = Task.Run(() => 42); task.ContinueWith( t => Console.WriteLine("Result: {0}", t.Result), TaskContinuationOptions.OnlyOnRanToCompletion); task.ContinueWith( _ => Console.WriteLine("Canceled"), TaskContinuationOptions.OnlyOnCanceled); task.ContinueWith( t => Console.WriteLine("Error: {0}", t.Exception), TaskContinuationOptions.OnlyOnFaulted);
Task.Wait Task.Result. c , . . -, — AggregateException . AggregateException , ( AggregateException ). -, , , AggregateException TaskCanceledException , OperationCanceledException , :
var task = Task.Run(() => { /* - */ }); try { task.Wait(); Console.WriteLine("Success"); } catch (AggregateException ae) { try { ae.Flatten().Handle(e => e is TaskCanceledException); Console.WriteLine("Cancelled"); } catch (AggregateException e) { Console.WriteLine("Error: {0}", e); } }
async- await . AggregateException , OperationCanceledException ; :
var task = Task.Run(() => { /* - */ }); try { await task; Console.WriteLine("Success"); } catch (OperationCanceledException) { Console.WriteLine("Cancelled"); } catch (Exception e) { Console.WriteLine("Error: {0}", e); }

 Task.   ,  async-   (Task / Task),    ,   . ,   
 Task<int> task = Task .Delay(TimeSpan.FromSeconds(5)) .ContinueWith(_ => { while (true) { // -  } return 42; }); 
      async-  : 
 Task<int> task = SomeWork(); async Task<int> SomeWork() { await Task.Delay(TimeSpan.FromSeconds(5)); while (true) { // -  } return 42; } 
  ,     Task.Run ,  Task.Factory.StartNew ,  .  SomeWork    int .    ,    SomeWork  Task. 
 
 ,  async-,   ,  ,   .       ,    : 
 var cts = new CancellationTokenSource(); var cancellationToken = cts.Token; Task<int> task = Task .Delay(TimeSpan.FromSeconds(5), cancellationToken) .ContinueWith(_ => { while (true) { // -  cancellationToken.ThrowIfCancellationRequested(); } return 42; }, cancellationToken); 
  
 var cts = new CancellationTokenSource(); var cancellationToken = cts.Token; Task<int> task = SomeWork(cancellationToken); async Task<int> SomeWork(CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); /* 1 */ await Task.Delay(TimeSpan.FromSeconds(5), cancellationToken); cancellationToken.ThrowIfCancellationRequested(); /* 2 */ while (true) { // -  cancellationToken.ThrowIfCancellationRequested(); } return 42; } 
 ,   async-,  ,       CancellationToken ( CancellationToken  async-      CancellationToken   ).      : 
        async-,  async-    .       (,  Task.Run  Task.ContinueWith )   .       1  2. ,   async-,    . OperationCanceledException   .   CancellationToken ,         , ..     .  ,        ,   CancellationToken      . ,      Task.Run ,       : 
 static async Task<int> SomeWork(CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); throw new OperationCanceledException(cancellationToken); throw new OperationCanceledException(); throw new OperationCanceledException(CancellationToken.None); throw new OperationCanceledException(new CancellationToken(true)); throw new OperationCanceledException(new CancellationToken(false)); } 
    
     Task.IsCompleted    true .     ( Task.Status == TaskStatus.RanToCompletion ),   ( Task.Status == TaskStatus.Faulted ; Task.IsFaulted == true )    ( Task.Status == TaskStatus.Canceled ; Task.IsCanceled == true ).             . 
 
       -.      TaskContinuationOptions   -     -: 
 var task = Task.Run(() => 42); task.ContinueWith( t => Console.WriteLine("Result: {0}", t.Result), TaskContinuationOptions.OnlyOnRanToCompletion); task.ContinueWith( _ => Console.WriteLine("Canceled"), TaskContinuationOptions.OnlyOnCanceled); task.ContinueWith( t => Console.WriteLine("Error: {0}", t.Exception), TaskContinuationOptions.OnlyOnFaulted); 
            Task.Wait     Task.Result.      c   ,   .    . -,          — AggregateException . AggregateException       ,     (  AggregateException    ). -,  ,   , AggregateException      TaskCanceledException ,   OperationCanceledException ,   : 
 var task = Task.Run(() => { /* -  */ }); try { task.Wait(); Console.WriteLine("Success"); } catch (AggregateException ae) { try { ae.Flatten().Handle(e => e is TaskCanceledException); Console.WriteLine("Cancelled"); } catch (AggregateException e) { Console.WriteLine("Error: {0}", e); } } 
   async-           await .       AggregateException ,       OperationCanceledException ;     : 
 var task = Task.Run(() => { /* -  */ }); try { await task; Console.WriteLine("Success"); } catch (OperationCanceledException) { Console.WriteLine("Cancelled"); } catch (Exception e) { Console.WriteLine("Error: {0}", e); }