Eu tenho um aplicativo multi-threaded onde eu preciso cancelar cada tarefa depois de um certo tempo, mesmo se no momento do cancelamento, eles usam recursos não gerenciados. Agora eu uso o seguinte código (por exemplo, um aplicativo de console). Em um aplicativo real, o atraso pode ocorrer no recurso não gerenciado.

static void Main()
    {
        for (int i = 0; i < 10; i++)
        {
            Task.Factory.StartNew(Do, TaskCreationOptions.LongRunning);
        }

        Console.ReadLine();
    }

    private static void Do()
    {
        new Timer(Thread.CurrentThread.Abort, null, 1000, -1);

        try
        {
            Console.WriteLine("Start " + Task.CurrentId);
            Thread.Sleep(2000);
            Console.WriteLine("End " + Task.CurrentId);
        }
        catch (Exception)
        {
            Console.WriteLine("Thread Aborted " + Task.CurrentId);
        }
    }

Obtenha o resultado:

Mas não tenho certeza se é certo para uma aplicação real do ponto de vista da segurança. Eu também usei CancellationToken em diferentes variantes, mas isso não me deu resultado correto, porque onde eu uso CancellAfter () ou .Delay () com o intervalo de tempo e cancelar a tarefa após a confirmação do tempo, obtive os seguintes resultados:

static void Main()
    {
        for (int i = 0; i < 10; i++)
        {
            var clt = new CancellationTokenSource();

            Task task = new Task(() =>
            {
                Task.Delay(2000).ContinueWith(_ =>
                {
                    clt.Cancel();

                }, clt.Token);

                Do(clt.Token);

            }, clt.Token);

            task.Start();
        }

        Console.ReadLine();
    }

    private static void Do(CancellationToken cltToken)
    {
        Console.WriteLine("Start " + Task.CurrentId);

        Thread.Sleep(2500);

        if (!cltToken.IsCancellationRequested)
        {
            Console.WriteLine("End " + Task.CurrentId);
        }
        else
        {
            Console.WriteLine("Cancelled "+ Task.CurrentId);
        }
    }

Nessa situação, todas as tarefas devem ser canceladas, porque Thread.Sleep ()> de tempo alocado para executar cada tarefa. Mas podemos ver que parte do tempo para executar.

Eu também uso a seguinte construção e dou o mesmo resultado:

        static void Main()
    {
        for (int i = 0; i < 10; i++)
        {
            var clt = new CancellationTokenSource();
            clt.CancelAfter(2000);

            Task.Factory.StartNew(Do, clt.Token);

        }

        Console.ReadLine();
    }

    private static void Do(object obj)
    {
        var cltToken = (CancellationToken) obj;

        Console.WriteLine("Start " + Task.CurrentId);

        Thread.Sleep(2500);

        if (!cltToken.IsCancellationRequested)
        {
            Console.WriteLine("End " + Task.CurrentId);
        }
        else
        {
            Console.WriteLine("Cancelled "+ Task.CurrentId);
        }
    }

Eu também uso o Parallel e inicializo o método Token Interno de Cancelamento Do (), e uso o Timer para cancelar o token após o tempo limite, mas todos dão o mesmo resultado.

Então, por que isso está acontecendo e qual é a maneira correta de cancelar a tarefa depois de um certo tempo ???