IHostedService Vs BackgroudService
Published: 2023-12-13 14:46:36



### IHostedService e BackgroundService no .NET

O .NET fornece duas interfaces para implementar tarefas em segundo plano: IHostedService e BackgroundService.

IHostedService é uma interface abstrata que fornece métodos para iniciar, parar e reiniciar uma tarefa em segundo plano.

BackgroundService é uma classe base que implementa a interface IHostedService. Ela fornece métodos e propriedades adicionais para facilitar a implementação de tarefas em segundo plano.

### Comparação entre IHostedService e BackgroundService

A principal diferença entre IHostedService e BackgroundService é que BackgroundService fornece uma implementação padrão para os métodos StartAsync(), StopAsync() e DisposeAsync(). Isso pode facilitar a implementação de tarefas em segundo plano, mas também pode limitar a flexibilidade.

Se você precisa de controle total sobre a implementação de uma tarefa em segundo plano, deve usar IHostedService.

### Quando usar um ou outro?

Em geral, BackgroundService é recomendado para tarefas que podem ser executadas por um longo período de tempo, sem a necessidade de interação com a interface do usuário. Isso inclui tarefas como:

- Envio de e-mail
- Download de arquivos
- Processamento de dados
- Monitoramento de sistemas

IHostedService é recomendado para tarefas que precisam ser executadas de forma mais rápida, ou que precisam interagir com a interface do usuário. Isso inclui tarefas como:

- Envio de push notifications
- Requisição de dados da API
- Atualização de dados na tela

No entanto, a escolha do tipo de implementação a ser usada depende de uma série de fatores, como o tempo de execução da tarefa, a necessidade de interação com a interface do usuário e as preferências do desenvolvedor.

Aqui estão alguns critérios que podem ser usados para ajudar a tomar a decisão:

- Tempo de execução da tarefa: Se a tarefa for executada por um longo período de tempo, BackgroundService é a melhor opção. Isso ocorre porque BackgroundService usa um thread separado para executar a tarefa, o que evita que ela bloqueie a interface do usuário.

- Necessidade de interação com a interface do usuário: Se a tarefa precisar interagir com a interface do usuário, IHostedService é a melhor opção. Isso ocorre porque IHostedService permite que a tarefa seja executada no mesmo thread que a interface do usuário, o que facilita a interação entre as duas.

- Preferências do desenvolvedor: Em última análise, a escolha do tipo de interface a ser usada depende das preferências do desenvolvedor. Alguns desenvolvedores preferem a flexibilidade que IHostedService oferece, enquanto outros preferem a simplicidade de BackgroundService.

### Implementando uma tarefa em segundo plano com IHostedService

Para implementar uma tarefa em segundo plano com IHostedService, você deve criar uma classe que implemente a interface. A classe deve implementar os seguintes métodos:

StartAsync(): Task - Este método é chamado quando a tarefa em segundo plano é iniciada.

StopAsync(): Task - Este método é chamado quando a tarefa em segundo plano é interrompida.

DisposeAsync(): Task - Este método é chamado quando a tarefa em segundo plano é descartada.

De forma bastante simplificada podemos implementa-lá da seguinte forma:

```csharp
public class MyHostedService : IHostedService
{
    public Task StartAsync(CancellationToken cancellationToken)
    {
        // Execute the background task
        return Task.Run(() =>
        {
            // Do something in the background
        });
    }

    public Task StopAsync(CancellationToken cancellationToken)
    {
        // Cleanup any resources used by the background task
        return Task.CompletedTask;
    }

    public Task DisposeAsync()
    {
        // Dispose of any resources used by the background task
        return Task.CompletedTask;
    }
}
```

Para registrar uma tarefa em segundo plano implementada por IHostedService, você pode usar o método AddHostedService() da classe Host da seguinte forma:


```csharp
using Microsoft.Extensions.Hosting;

namespace MyApp
{
    public class Program
    {
        public static void Main(string[] args)
        {
            // Create the host
            var host = new HostBuilder()
                .ConfigureServices((services) =>
                {
                    // Register the background service
                    services.AddHostedService(new MyHostedService());
                })
                .Build();

            // Start the host
            host.Run();
        }
    }
}
```

### Implementando uma tarefa em segundo plano com BackgroundService

A classe BackgroundService fornece uma implementação padrão para os métodos StartAsync(), StopAsync() e DisposeAsync(). Isso facilita a implementação de tarefas em segundo plano.

Para implementar uma tarefa em segundo plano com BackgroundService, você deve criar uma classe que herde da classe BackgroundService. A classe herdada pode substituir os métodos StartAsync() e StopAsync() para fornecer a funcionalidade desejada, mas pode ser usada apenas o método Execute e deixar abstraído pela classe mãe as implementações de start e stop.

```csharp
public class MyBackgroundService : BackgroundService
{
    protected override async Task StartAsync(CancellationToken cancellationToken)
    {
        // Execute the background task
        await Task.Run(() =>
        {
            // Do something in the background
        });
    }
}
```
Para registrar uma tarefa em segundo plano implementada por BackgroundService, você pode usar o método AddHostedService() da classe Host.

```csharp
using Microsoft.Extensions.Hosting;

namespace MyApp
{
    public class Program
    {
        public static void Main(string[] args)
        {
            // Create the host
            var host = new HostBuilder()
                .ConfigureServices((services) =>
                {
                    // Register the background service
                    services.AddHostedService(new MyBackgroundService());
                })
                .Build();

            // Start the host
            host.Run();
        }
    }
}
```

Entenda bem cada implementação e assim poderá fazer a melhor escolha. E as functions?!?! Aí é outra história.