> For the complete documentation index, see [llms.txt](https://docs.skail.dev/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.skail.dev/construir/sdk-.net/configuracao-do-host.md).

# Configuração do host

O que precisa existir no `Program.cs` para o runtime descobrir e executar suas functions: o atributo de assembly e a registração no host. Mais como a injeção de dependência funciona nas classes skail.

## Atributo de assembly

```csharp
using Skail.Platform.Runtime.Standard;

[assembly: VisibleToSkailPlatform]
```

Em qualquer arquivo `.cs` do projeto que contém functions e commands (`Program.cs` ou `AssemblyInfo.cs`). Sem ele, o runtime não varre o assembly e nenhum método é descoberto: o sintoma é "StateMachine not registered." ou execuções que ficam em Na fila sem serem processadas. Um projeto com functions em mais de um assembly precisa do atributo em cada um.

## Registração no host

Host genérico (Worker Service), o modelo de todos os exemplos:

```csharp
using Microsoft.Extensions.Hosting;
using Skail.Platform.Runtime.Hosting;
using Skail.Platform.Runtime.Standard;

[assembly: VisibleToSkailPlatform]

var builder = Host.CreateApplicationBuilder(args);

builder.Services.AddHttpClient();
builder.Services.AddDbContext<ErpDbContext>(...);
builder.Services.AddTransient<IGatewayPagamento, GatewayPagamento>();   // seus serviços, como sempre

builder.UseSkail();

await builder.Build().RunAsync();
```

Startup tradicional (`IServiceCollection`):

```csharp
services.AddSkail();
```

| Extensão              | Onde                      | O que faz                                                                                                                                                                                  |
| --------------------- | ------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `builder.UseSkail()`  | `IHostApplicationBuilder` | Registra os serviços do runtime, descobre as classes com métodos decorados e as registra como transient, e adiciona o serviço hospedado que busca trabalho no skail e executa as functions |
| `services.AddSkail()` | `IServiceCollection`      | O mesmo, para o modelo de `Startup`                                                                                                                                                        |

Chame uma vez por processo. Uma segunda chamada (dois `ServiceProvider` no mesmo processo) lança "The Builder Factory can only be registered once!".

`UseSkail` lê a configuração de `SKAIL_*` e da seção `skail` do `appsettings`; ver [Como configurar o runtime](/construir/configurar-e-hospedar/como-configurar-o-runtime.md).

## ASP.NET Core

Os exemplos oficiais usam `Host.CreateApplicationBuilder`. Hospedar o runtime dentro de uma aplicação `WebApplication.CreateBuilder` não é o arranjo que recomendamos. Separe: a API web dispara pela API HTTP; um Worker Service ao lado hospeda o runtime e as functions. Ver [Como hospedar](/construir/configurar-e-hospedar/como-hospedar-worker-service-asp.net-core-container-kubernetes-azure.md).

## Injeção de dependência nas classes skail

Classes que contêm `[SkailFunction]` ou `[SkailCommand]` são registradas automaticamente como transient por `UseSkail()`; não as registre você mesmo. Injete o que precisar pelo construtor: `ILogger<T>`, `DbContext`, `IHttpClientFactory`, seus serviços. A instância é obtida do contêiner a cada execução.

```csharp
public class Faturamento
{
    private readonly IGatewayPagamento _gateway;
    private readonly ILogger<Faturamento> _log;

    public Faturamento(IGatewayPagamento gateway, ILogger<Faturamento> log)
    {
        _gateway = gateway;
        _log = log;
    }

    [SkailFunction]
    public async SkailTask EmitirFatura(Guid faturaId)
    {
        _log.LogInformation("Emitindo {FaturaId} na execução {TaskId}", faturaId, SkailContext.Current.TaskId);
        await CobrarCartao(faturaId);
    }

    [SkailCommand]
    public async SkailTask CobrarCartao(Guid faturaId) => await _gateway.CobrarAsync(faturaId);
}
```

Dois cuidados. Serviços com I/O (`DbContext`, `HttpClient`) devem ser usados dentro de commands, não na function: a function é reexecutada no replay e não deve tocar neles. E a instância da classe não guarda estado entre `await`s de forma confiável: a hibernação descarta a instância; tudo o que importa vive em argumentos e retornos.

## SkailContext

```csharp
var taskId = SkailContext.Current.TaskId;    // id da execução atual
```

Válido só dentro de um método decorado em execução; fora, lança. Use como chave de correlação em logs.

## Pacote de build

A reescrita de IL que injeta o method builder de `SkailTask` é feita pelo pacote `Skail.Platform.Runtime.Build` (target MSBuild `SkailBuild`), trazido como dependência do pacote do runtime. Se ela não rodar, o sintoma é "There is not Skail runtime available!" ao chamar um método decorado. Ver [Pacotes](/construir/sdk-.net/pacotes.md).

## Veja também

[Quickstart](/aprender/readme.md), [Como hospedar](/construir/configurar-e-hospedar/como-hospedar-worker-service-asp.net-core-container-kubernetes-azure.md), [Runtime](/aprender/arquitetura/runtime.md).