C# Academy · Aula

Sagas e fluxos de trabalho

Coordene processos de longa duração.

Sagas e fluxos de trabalho é uma aula grátis de C# Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de C# Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de C# Academy inclui 4 aulas no total.

Coordenando fluxos de trabalho longos

Alguns processos de negócio abrangem várias mensagens e etapas ao longo do tempo: fazer um pedido, cobrar o pagamento, reservar o estoque e enviar o pedido. Uma saga coordena esse fluxo de trabalho de longa duração e acompanha seu estado entre as mensagens.

O que é uma saga

Uma saga é um consumidor com estado. Ela correlaciona mensagens relacionadas, mantém o estado atual do fluxo de trabalho e reage aos eventos transitando entre estados até que o processo seja concluído.

Sagas como máquinas de estados

O MassTransit modela sagas como máquinas de estados usando MassTransitStateMachine. Você define estados, eventos e transições de forma declarativa.

dotnet add package MassTransit
// state machine sagas are built in

O estado da saga

O estado é uma classe que implementa SagaStateMachineInstance. Ele contém um CorrelationId e todos os dados que você precisa lembrar entre as etapas.

public class OrderState : SagaStateMachineInstance
{
    public Guid CorrelationId { get; set; }
    public string CurrentState { get; set; }
    public decimal Amount { get; set; }
}

Declarando estados e eventos

Dentro da máquina de estados, você declara propriedades State e propriedades Event que fazem a correspondência com os tipos de mensagem.

public class OrderSaga : MassTransitStateMachine<OrderState>
{
    public State AwaitingPayment { get; private set; }
    public State Completed { get; private set; }
    public Event<OrderPlaced> OrderPlaced { get; private set; }
    public Event<PaymentReceived> PaymentReceived { get; private set; }
}

Correlação

Cada evento deve ser correlacionado à instância correta da saga, geralmente por meio de um identificador compartilhado, como OrderId. Isso encaminha as mensagens recebidas para o fluxo de trabalho correto que está em andamento.

Event(() => PaymentReceived, e =>
    e.CorrelateById(m => m.Message.OrderId));

Definindo transições

O construtor conecta os comportamentos: o evento inicial cria a instância, armazena os dados e faz a transição para o próximo estado.

Initially(
    When(OrderPlaced)
        .Then(ctx => ctx.Saga.Amount = ctx.Message.Amount)
        .TransitionTo(AwaitingPayment));

Reagindo em um estado

Use During para tratar eventos válidos apenas em um determinado estado; depois, publique mensagens de acompanhamento e avance para o próximo estado.

During(AwaitingPayment,
    When(PaymentReceived)
        .Publish(ctx => new OrderConfirmed(ctx.Saga.CorrelationId))
        .TransitionTo(Completed)
        .Finalize());

Persistindo o estado da saga

O estado da saga precisa sobreviver às reinicializações, por isso é armazenado em um repositório: Entity Framework, MongoDB, Redis ou outros. O MassTransit carrega e salva a instância em torno de cada mensagem.

x.AddSagaStateMachine<OrderSaga, OrderState>()
    .EntityFrameworkRepository(r =>
    {
        r.ExistingDbContext<OrderDbContext>();
    });

Tempos limite com agendamentos

As sagas podem agendar um tempo limite (por exemplo, cancelar se o pagamento não for recebido em 30 minutos) usando um Schedule e, depois, tratar o evento de tempo limite para realizar uma compensação.

Compensação

Se uma etapa posterior falhar, uma saga pode executar ações de compensação para desfazer as anteriores (estornar uma cobrança ou liberar o estoque), mantendo a consistência do processo geral sem transações distribuídas.

Verificação rápida

Teste sagas e fluxos de trabalho.

Recapitulação

Uma saga coordena fluxos de trabalho longos como um consumidor com estado e correlação. O MassTransit usa MassTransitStateMachine com um estado SagaStateMachineInstance, membros State/Event declarados, correlação por identificador e transições por meio de Initially/During. O estado é persistido em um repositório, os tempos limite usam agendamentos e a compensação desfaz etapas anteriores em caso de falha.

Perguntas Frequentes

A aula “Sagas e fluxos de trabalho” é grátis?

Sim — o texto completo de “Sagas e fluxos de trabalho” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de C# Academy, atualize para CoddyKit PRO. O curso de C# Academy inclui 4 aulas no total.

O que vou aprender em “Sagas e fluxos de trabalho”?

Coordene processos de longa duração. Você pratica C# Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar C# Academy?

Nenhuma experiência prévia é necessária. C# Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Sagas e fluxos de trabalho”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de C# Academy?

Sim. Cada aula de C# Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para C# Academy