Cancel Task C#

Cancel Task C#: .NET 4.0 में किसी Task को Cancel करने के लिए एक Flexible System Define किया गया है। ये Mechanism एक Cancellation Token पर आधारित है, जिसे Task Class व StartNew() Factory Method द्वारा Support किया जाता है। इस Cancellation Subsystem का प्रयोग Threads को भी Chance करने के लिए किया जा सकता है, जिसके बारे में हमने इसी Chapter की शुरूआत में जाना था।

Cancellation कुछ इस तरह से काम करता है कि सबसे पहले Cancellation Token को एक Cancellation Token Source से Obtain किया जाता है और फिर इस Token को Task में Pass किया जाता है। फिर Task उस Token को Task Cancellation Request के लिए Monitor करता है। यदि Cancellation Request Receive होता है, तो Task End हो जाता है।

अक्सर किसी Task को Stop करने के लिए इतना करना ही काफी होता है। लेकिन कई बार Task को Cancellation Token के लिए ThrowIfCancellationRequested() Method को Invoke करना पडता है। ये Method उस Cancel करने वाले को एक Notification जारी करता है, कि जिस Task को वह Cancel करना चाहता था, वह Cancel हो चुका है।

Cancellation Token वास्तव में CancellationToken Type का एक Instance होता है, जो System.Threading Namespace में Define किया गया एक Structure है। इस Structure में कई Properties व Methods को Define किया गया है, जिनमें से हम दो को यहां Use करेंगे। पहला IsCancellationRequested नाम की एक Read-Only Property है, जिसे निम्नानुसार Define किया गया है:

public bool IsCancellationRequested { get; }

ये Property उस स्थिति में true Return करता है जब Cancellation के लिए Invoking Token को Use किया जाता है, अन्‍यथा ये false Return करता है। जबकि दूसरा Member ThrowIfCancellationRequested() Method है, जिसे निम्नानुसार Define किया गया है:

public void ThrowIfCancellationRequested( )

यदि जिस Cancellation Token के माध्‍यम से Cancellation Request Receive होती है, तो ये Method OperationCanceledException Throw करता है अन्‍यथा ये कोई Action Perform नहीं करता। Canceling Code इस Exception को Monitor कर सकता है और यदि ये Exception Trigger होता है, तो Monitoring Code में इस Exception को AggregateException के रूप में Catch किया जा सकता है और अन्‍य Inner Exceptions के लिए InnerException या InnerExceptions Properties को Monitor किया जा सकता है।

Cancellation Token को एक Cancellation Source द्वारा Obtain किया जाता है। ये Source CancellationTokenSource Type का एक Object होता है, जिसे System.Threading Namespace में Define किया गया है।

इस Token को Obtain करने के लिए सबसे पहले हमें CancellationTokenSource Type का एक Instance Create करना होता है, जिसके लिए हम इसके Default Constructor को Use कर सकते हैं। इस Source के साथ Associated Cancellation Token को Read-Only Token Property द्वारा प्राप्त किया जा सकता है, जिसे निम्नानुसार Define किया गया है

public CancellationToken Token { get; }

ये Token उस Task में Pass करना होता है, जिसे Cancel करना है।

Cancellation को Use करने के लिए Task को Cancellation Token की एक Copy Receive करना होता है और फिर उस Token को Incoming Cancellation Request के लिए Monitor करना होता है। Cancellation को Monitor करने के कुल तीन तरीके होते हैं:

• Polling
• Using Callback Method
• Wait Handle

Polling सबसे सरल तरीका होता है और हम इसी Approach को अपने उदाहरण में Use करेंगे। Polling Use करने के लिए Task Cancellation Token के IsCancellationRequested Property को Check करता है। जैसाकि पहले Describe किया गया है कि यदि इस Property में true होता है तो इसका मतलब है कि Task Cancellation की Request की गई है और Task को Terminate कर दिया जाता है।

जब हम Calling Code को Cancellation का Notification भी देना चाहते हैं, तब हमें ThrowIfCancellationRequested() Method को Cancellation के दौरान Invoke करना होता है और इसके द्वारा Generate होने वाले Exception को Calling Code में Catch करना होता है। इस Method को Invoke करने से पहले हमें उस Token को Task व Task Constructor दोनों में Directly या Indirectly StartNew() Method के माध्‍यम से Pass करना होता है। Cancellation Token को Task में Pass करके हम Outside Code के माध्‍यम से Task के Termination के लिए Request Send करने की सुविधा प्राप्त करते हैं। इस जरूरत को पूरा करने के लिए हमें StartNew() Method को निम्न Format में Use करना होता है:

public Task StartNew(Action<Object> action, Object state, CancellationToken cancellationToken)

जब हम इस तरह से StartNew() Method को Use करते हैं तो हम वास्तव में Task Instance व उस Delegate Method दोनों को Cancellation Token Pass कर रहे होते हैं, जो Task को Implement करता है। यहां Use होने वाले Action का Form कुछ निम्नानुसार होता है:

public delegate void Action<in T>(T obj)

जहां T एक Object है और Task के अन्दर obj को CancellationToken Type में Cast करना जरूरी होता है। साथ ही जब हम कोई Token Create करते हैं, तो Task Finish होने के बाद हमें Resources को Free करने के लिए Dispose() Method को भी Invoke करना जरूरी होता है।

कोई Task Cancelled हुआ है या नहीं इस बात को Check करने के भी कई तरीके हैं। हम यहां जो Approach Use कर रहे है, वह Task Instance के IsCanceled Property को Check करते हुए कर रहे हैं। इस पूरे Theoretical Concept को हम निम्नानुसार एक Program के रूप में Implement कर सकते हैं:

File Name: TaskCancellation.cs
using System;
using System.Threading;
using System.Threading.Tasks;

namespace CSharpMultiThreading
{
    class DemoCancelTask
    {
        // A method to be run as a task.
        static void MyTask(Object ct)
        {
            CancellationToken cancelTok = (CancellationToken)ct;

            // Check if cancelled prior to starting.
            cancelTok.ThrowIfCancellationRequested();
            Console.WriteLine("MyTask() starting");
            for (int count = 0; count < 10; count++)
            {
                // This example uses polling to watch for cancellation.
                if (cancelTok.IsCancellationRequested)
                {
                    Console.WriteLine("Cancellation request received.");
                    cancelTok.ThrowIfCancellationRequested();
                }
                Thread.Sleep(500);
                Console.WriteLine("In MyTask(), count is " + count);
            }
            Console.WriteLine("MyTask terminating");
        }

        static void Main()
        {
            Console.WriteLine("Main thread starting.");

            // Create a cancellation token source.
            CancellationTokenSource cancelTokSrc = new CancellationTokenSource();

            // Start a task, passing the cancellation token to both the delegate and the task.
            Task tsk = Task.Factory.StartNew(MyTask, cancelTokSrc.Token, cancelTokSrc.Token);

            // Let tsk run until cancelled.
            Thread.Sleep(2000);
            try
            {
                // Cancel the task.
                cancelTokSrc.Cancel();

                // Suspend Main() until tsk terminates.
                tsk.Wait();
            }
            catch (AggregateException exc)
            {
                if (tsk.IsCanceled)
                    Console.WriteLine("\ntsk Cancelled\n");
                // To see the exception, un-comment this line: 
                // Console.WriteLine(exc);
            }
            finally
            {
                tsk.Dispose();
                cancelTokSrc.Dispose();
            }
            Console.WriteLine("Main thread ending.");
        }
    }
}

Output:
Main thread starting.
MyTask() starting
In MyTask(), count is 0
In MyTask(), count is 1
In MyTask(), count is 2
In MyTask(), count is 3
Cancellation request received.

tsk Cancelled

Main thread ending.

जैसाकि हम इस Program के Output में देख सकते हैं कि MyTask() को Main() Method द्वारा 2 Seconds के Delay के बाद Cancel किया गया है। अत: MyTask() Loop केवल चार बार ही चलता है।