Introdução:

A programação assíncrona se tornou uma tendência popular no desenvolvimento de software moderno. Duas técnicas comumente usadas para programação assíncrona em C# são Tarefas e Tópicos . No entanto, muitos desenvolvedores estão confusos sobre as diferenças entre Tarefas e Tópicos e quando usar cada um deles. Neste artigo, veremos as diferenças presentes entre Tarefas e Tópicos em C# e forneça diretrizes sobre quando usar cada um deles.

O que são tarefas?

Em C#, uma tarefa é uma abstração de nível superior para executar código de forma assíncrona. Uma Tarefa denota uma unidade de trabalho que precisa ser executada de forma assíncrona e pode ou não retornar um valor. Uma tarefa geralmente é criada com a ajuda do Classe de fábrica de tarefas , que fornece vários métodos para criar e executar tarefas.

As tarefas usam um Grupo de discussão para executar seu trabalho, o que significa que as tarefas são executadas em um dos threads no Grupo de discussão. Quando uma tarefa é criada, ela é adicionada ao Fila do pool de threads , e um dos Threads no pool é usado para executar a tarefa. Assim que a Tarefa for concluída, o Thread retorna ao pool, pronto para ser usado em outra Tarefa.

As tarefas têm várias vantagens sobre os Threads:

• As tarefas são mais leves que os Threads. As tarefas usam menos recursos do sistema, como memória e tempo de CPU, em comparação com Threads.
• As tarefas são mais fáceis de gerenciar do que Threads. As tarefas fornecem uma abstração de nível superior para programação assíncrona, o que facilita a escrita e a manutenção do código.
• As tarefas também podem fornecer melhor desempenho do que Threads em determinadas situações. Isso ocorre porque as tarefas usam um Grupo de discussão , que pode gerenciar Threads com mais eficiência do que criar e destruir Threads para cada unidade de trabalho.

O que são tópicos?

Em C#, um Thread é uma abstração de nível inferior para executar código de forma assíncrona. Um Thread representa uma construção no nível do sistema operacional usada para executar código de forma assíncrona. Um Thread pode ou não retornar um valor, e geralmente é criado com a ajuda do Classe de thread .

Threads usam seus próprios recursos, como memória e tempo de CPU, e geralmente são criados e destruídos explicitamente pelo desenvolvedor. Quando um Thread é criado, ele começa a ser executado imediatamente e continua a ser executado até ser explicitamente interrompido ou concluir seu trabalho.

Threads têm várias desvantagens em comparação com tarefas:

• Threads são mais pesados ​​que tarefas. Threads usam mais recursos do sistema, como memória e tempo de CPU, em comparação com tarefas.
• Threads são mais difíceis de gerenciar do que tarefas. Threads exigem mais programação e sincronização de baixo nível, o que torna mais difícil escrever e manter código.
• Threads também podem fornecer desempenho pior do que tarefas em determinadas situações. Isso ocorre porque criar e destruir Threads para cada unidade de trabalho pode ser ineficiente, especialmente quando há muitas unidades de trabalho para executar.

Quando usar tarefas:

As tarefas são recomendadas quando você deseja executar uma unidade de trabalho de forma assíncrona e não precisa de controle refinado sobre a execução. As tarefas são perfeitas para executar unidades de trabalho pequenas e de curta duração, como operações de E/S ou cálculos simples.

As tarefas também são recomendadas quando você deseja aproveitar os benefícios de um Grupo de discussão . A Grupo de discussão pode gerenciar Threads com mais eficiência do que criar e destruir Threads para cada unidade de trabalho. Isso pode resultar em melhor desempenho, especialmente quando há muitas unidades de trabalho a serem executadas.

As tarefas também são úteis quando você deseja encadear operações assíncronas. As tarefas podem ser combinadas usando o operador await para criar uma cadeia de operações assíncronas que são executadas uma após a outra. Isto pode ser importante quando você deseja executar uma série de operações assíncronas dependentes.

Quando usar tópicos:

Threads em C# devem ser usados ​​quando você precisar de controle refinado sobre a execução e quando tiver requisitos específicos que não podem ser atendidos com as abstrações de nível superior fornecidas pelas Tarefas. Aqui estão algumas situações em que Threads pode ser a melhor escolha:

Unidades de trabalho de longa duração:

Threads são mais adequados para unidades de trabalho de longa duração, como serviços em segundo plano ou cálculos complexos que exigem mais controle sobre a execução. Nesses casos, muitas vezes é necessário controlar a execução do código de uma maneira mais refinada do que a fornecida pelas Tarefas.

Controle refinado sobre a execução de threads:

Threads permitem que você defina Prioridades de thread, sincronização de thread , e Tópico abortado . Se você precisar personalizar a forma como seu código é executado, Threads fornece uma interface de baixo nível que permite fazer isso.

Programação de baixo nível:

comentário javascript

Os threads exigem mais programação e sincronização de baixo nível, o que pode ser útil se você tiver requisitos especializados que não podem ser atendidos com as abstrações de nível superior fornecidas pelas Tarefas.

Interoperabilidade com código não gerenciado:

Se você precisar interoperar com código não gerenciado, Threads poderá ser a única opção. Nesses casos, pode ser necessário criar e controlar Threads manualmente para garantir que seu código funcione corretamente com código não gerenciado.

Considerações de desempenho:

Em algumas situações, criar e destruir Threads para cada unidade de trabalho pode ser ineficiente, especialmente quando há muitas unidades de trabalho para executar. Nesses casos, usar Threads pode ser uma opção melhor, pois podem ser reutilizados para múltiplas unidades de trabalho.