> ## Documentation Index
> Fetch the complete documentation index at: https://easyaf.nimbleapps.cloud/llms.txt
> Use this file to discover all available pages before exploring further.

# Getting Started with SimpleMessageBus

> Get up and running quickly is as easy as 1-2-3.

Get SimpleMessageBus working in your application with just a few simple steps.

## Step 1: Install the Package

Choose the provider that matches your infrastructure:

```bash Azure Storage Queue theme={"dark"}
dotnet add package SimpleMessageBus.Publish.Azure
dotnet add package SimpleMessageBus.Dispatch.Azure
```

```bash Amazon SQS theme={"dark"}
dotnet add package SimpleMessageBus.Publish.Amazon
dotnet add package SimpleMessageBus.Dispatch.Amazon
```

```bash File System theme={"dark"}
dotnet add package SimpleMessageBus.Publish
dotnet add package SimpleMessageBus.Dispatch.FileSystem
```

```bash Blazor WebAssembly theme={"dark"}
dotnet add package SimpleMessageBus.Publish.IndexedDb
dotnet add package SimpleMessageBus.Dispatch.IndexedDb
```

## Step 2: Define Your Message

Create a message class that implements `IMessage`:

```csharp theme={"dark"}
using SimpleMessageBus.Core;

public class UserCreatedMessage : IMessage
{
    public string UserId { get; set; }
    public string Email { get; set; }
    public DateTime CreatedAt { get; set; }
}
```

## Step 3: Create a Message Handler

Implement `IMessageHandler<T>` to process your messages:

```csharp theme={"dark"}
using SimpleMessageBus.Core;

public class UserCreatedHandler : IMessageHandler<UserCreatedMessage>
{
    private readonly ILogger<UserCreatedHandler> _logger;

    public UserCreatedHandler(ILogger<UserCreatedHandler> logger)
    {
        _logger = logger;
    }

    public async Task HandleAsync(UserCreatedMessage message)
    {
        _logger.LogInformation("User created: {UserId} - {Email}", 
            message.UserId, message.Email);
        
        // Process the message (send welcome email, update database, etc.)
        await ProcessUserCreation(message);
    }

    private async Task ProcessUserCreation(UserCreatedMessage message)
    {
        // Your business logic here
        await Task.Delay(100); // Simulate processing
    }
}
```

## Step 4: Configure Services

Add SimpleMessageBus to your dependency injection container:

```csharp Azure Storage Queue theme={"dark"}
using SimpleMessageBus.Publish.Azure.Extensions;
using SimpleMessageBus.Dispatch.Azure.Extensions;

var builder = WebApplication.CreateBuilder(args);

// Configure Azure Storage Queue
builder.Services.AddSimpleMessageBusAzureStoragePublisher(options =>
{
    options.ConnectionString = builder.Configuration.GetConnectionString("AzureStorage");
});

builder.Services.AddSimpleMessageBusAzureStorageDispatcher(options =>
{
    options.ConnectionString = builder.Configuration.GetConnectionString("AzureStorage");
});

// Register your message handler
builder.Services.AddScoped<IMessageHandler<UserCreatedMessage>, UserCreatedHandler>();

var app = builder.Build();
```

```csharp Amazon SQS theme={"dark"}
using SimpleMessageBus.Publish.Amazon.Extensions;
using SimpleMessageBus.Dispatch.Amazon.Extensions;

var builder = WebApplication.CreateBuilder(args);

// Configure Amazon SQS
builder.Services.AddSimpleMessageBusAmazonSQSPublisher(options =>
{
    options.AccessKey = builder.Configuration["AWS:AccessKey"];
    options.SecretKey = builder.Configuration["AWS:SecretKey"];
    options.Region = "us-east-1";
});

builder.Services.AddSimpleMessageBusAmazonSQSDispatcher(options =>
{
    options.AccessKey = builder.Configuration["AWS:AccessKey"];
    options.SecretKey = builder.Configuration["AWS:SecretKey"];
    options.Region = "us-east-1";
});

// Register your message handler
builder.Services.AddScoped<IMessageHandler<UserCreatedMessage>, UserCreatedHandler>();

var app = builder.Build();
```

```csharp File System theme={"dark"}
using SimpleMessageBus.Publish.Extensions;
using SimpleMessageBus.Dispatch.FileSystem.Extensions;

var builder = WebApplication.CreateBuilder(args);

// Configure File System
builder.Services.AddSimpleMessageBusFileSystemPublisher(options =>
{
    options.RootPath = Path.Combine(Directory.GetCurrentDirectory(), "messages");
});

builder.Services.AddSimpleMessageBusFileSystemDispatcher(options =>
{
    options.RootPath = Path.Combine(Directory.GetCurrentDirectory(), "messages");
});

// Register your message handler
builder.Services.AddScoped<IMessageHandler<UserCreatedMessage>, UserCreatedHandler>();

var app = builder.Build();
```

```csharp Blazor WebAssembly theme={"dark"}
using SimpleMessageBus.Publish.IndexedDb.Extensions;
using SimpleMessageBus.Dispatch.IndexedDb.Extensions;

var builder = WebAssemblyHostBuilder.CreateDefault(args);

// Configure IndexedDB
builder.Services.AddSimpleMessageBusIndexedDbPublisher();
builder.Services.AddSimpleMessageBusIndexedDbDispatcher();

// Register your message handler
builder.Services.AddScoped<IMessageHandler<UserCreatedMessage>, UserCreatedHandler>();

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

## Step 5: Publish Messages

Inject `IMessagePublisher` and publish messages:

```csharp theme={"dark"}
public class UserController : ControllerBase
{
    private readonly IMessagePublisher _messagePublisher;

    public UserController(IMessagePublisher messagePublisher)
    {
        _messagePublisher = messagePublisher;
    }

    [HttpPost]
    public async Task<IActionResult> CreateUser([FromBody] CreateUserRequest request)
    {
        // Create the user (your business logic)
        var userId = await CreateUserInDatabase(request);

        // Publish the message
        var message = new UserCreatedMessage
        {
            UserId = userId,
            Email = request.Email,
            CreatedAt = DateTime.UtcNow
        };

        await _messagePublisher.PublishAsync(message);

        return Ok(new { UserId = userId });
    }
}
```

## Step 6: Start Processing

The message dispatcher will automatically start processing messages when your application starts. For Azure Functions or console applications, you might need additional configuration.

> [!NOTE]
>
> For Azure Functions, see the [Azure Functions guide](https://easyaf.nimbleapps.cloud/simplemessagebus/guides/azure-functions) for trigger-based message processing.

## Next Steps

Congratulations! You now have SimpleMessageBus running in your application. Here are some next steps:

> [card] [Learn Core Concepts](https://easyaf.nimbleapps.cloud/simplemessagebus/concepts/overview)
>
> Understand messages, publishers, and handlers

> [card] [Provider Configuration](https://easyaf.nimbleapps.cloud/simplemessagebus/providers/overview.md)
>
> Deep dive into provider-specific configuration

> [card] [Testing Guide](https://easyaf.nimbleapps.cloud/simplemessagebus/guides/testing.md)
>
> Learn how to test your message handlers

> [card] [API Reference](https://easyaf.nimbleapps.cloud/simplemessagebus/api-reference/overview)
>
> Explore the complete API documentation

## Example Application

For a complete working example, check out our [sample applications](https://github.com/CloudNimble/SimpleMessageBus/tree/main/src/SimpleMessageBus.Samples) on GitHub.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.