# .NETM SK1 Роблячи це правильно

<!--category-- ASP.NET, Architecture, CQRS, Event Sourcing, Marten, Performance -->
<datetime class="hidden">2025-11-13T12:00</datetime>

> **Зверніть увагу**: Це стара стаття, яку я забув опублікувати

CQRS і пошуки подій - дві моделі, які часто згадуються разом, але часто неправильно розуміються . В цій статті МSK2 Я \ ' покажу вам, як їх правильно реалізувати, використовуючи сучасні \ МSK4 \ NET інструменти | : \ Marten для пошуків подій | МSK6 \ Dapper для оптимізованих запитів |, \ та MediatR для того, щоб все було організовано \. \

Я також покажу вам альтернативу за допомогою "half-assedM SK3キャッシュа - і поясню, чому спроба поєднати Miксування подій з ручним невизначенням вキャッシュі - жахлива ідея.

## Введение

CQRS ( Розмежування відповідальності за завдання командного запиту ) і пошук подій - це дві різні схеми, які працюють надзвичайно добре разом

- **CQRS** - Відокремлення ваших читаних моделей від ваших записових
- **Прослідження подій** - Сохранени кожної зміни стану як незмінної послідовності подій

Якщо зробити це правильно з такими інструментами, як Мартен, то отримаєте:

- Полне стеження за кожним зміною
- Здатність перебудувати стан в будь-який момент часу
- Автоматичне читання моделей прогнозів
- Природний підбір з дизайном доmeny-

Ця стаття фокусується на тому, щоб зробити це **правильно**. Якщо ви хочете мати швидкий - і МSK2 забруднений кэш - підход, заснований на , Я M SK5 коротко розповім про це наприкінці. МSK6 але це МСК7 насправді не CQRS М СК8 і це не дасть вам benefits of Event Sourcing M СК10

[TOC]

## Що таке CQRS?

Це означає використання різних моделей для читання та запису даних

```csharp
// Write Model - Commands that change state
public record CreateBlogPostCommand(string Title, string Content, string AuthorId);

// Read Model - DTOs optimised for display
public class BlogPostListItemDto
{
    public Guid Id { get; set; }
    public string Title { get; set; }
    public string AuthorName { get; set; }
    public DateTime PublishedDate { get; set; }
    public int CommentCount { get; set; }
}
```

Літечна сторона зосереджена на логіці і перевірки. Читальна сторона денормалізована та оптимізована для дисплеївM SK1 Простота доволі велика , але справжня CQRS означає, що вони МSK3 є повністю відокремленими шляхами через вашу програму.

## Що таке пошук подій?

Замість того, щоб зберігати теперішній стан, ви зберігаєте події, які призвели до цього стану.

```csharp
// Traditional: Store current state
public class BlogPost
{
    public Guid Id { get; set; }
    public string Title { get; set; }  // Current title
    public bool IsPublished { get; set; }  // Current status
}

// Event Sourcing: Store the events
public record BlogPostCreated(Guid Id, string Title, string Content, DateTime CreatedAt);
public record BlogPostTitleChanged(Guid Id, string OldTitle, string NewTitle, DateTime ChangedAt);
public record BlogPostPublished(Guid Id, DateTime PublishedAt);
```

Текущий стан відтворюється від повторення подій. Це дає повну історію всього, що траплялося в вашій системі

## Чому використовувати пошук подій за допомогою CQRS?

**Повний шлях аудиту**МСК0 Кожна зміна записуєтьсяМSK1 Чудово для фінансових систем, охорони здоров 'яM SK3 або будь-де, де вам потрібно довести, що сталося і коли

**Тиморальні питання**МSK0 " Як виглядав мій блог минулого вівторка? МSK2 стає банальним. - просто повторює події до того моменту

**Розладнання**: Репродуцювати баги, повторюючи правильну послідовність подій, які їх викликали

**Бізнес-інтелект**: Збудувати нові звіти з історичних даних без запуску міграціїM SK1 події вже там

**Природний CQRS Fit**: Втіхи, які відокремлені природно, пишуть ( додати події M SK2 від прочитань МSK3 просити проекції

### Коли вам варто

**Простій CRUD**: Якщо ви ' просто зберігаєте та відбираєте дані МSK2 пошук подій - безглуздо

**Невелика команда без досвіду**: Кривая навчання крутаM SK1

**Ніяких вимог до аудиту**: Якщо ви маєте справу лише з теперішнім станом

**Великі бінарні дані**: Мероприяти погано працюють з зображеннямиMSC1 відеоM SK2 файли.

## Современная пошукова система подій в Мартіні

Найкращим інструментом для пошуку подій в .NET в \2025 є [Мартен](https://martendb.io/). Це ' це магазин подій, збудований на PostgreSQL МSK2 активно підтримований Джеремі Міллером МSK3 і він просто працює

Чому Мартен?

- Побудована на PostgreSQL ( ви вже знаєте це)
- Автоматічні проекції від подій для читання моделей
- Асинк-デーмон для обробки проекції
- Здатність задавати складні питання
- Produkція- готовий і боєздатнийM SK1 перевірений

### Установлення мартена

Установити пакети:

```bash
dotnet add package Marten
dotnet add package Marten.AspNetCore
```

Konfigurувати в `Program.cs`:

```csharp
var builder = WebApplication.CreateBuilder(args);

builder.Services.AddMarten(options =>
{
    options.Connection(builder.Configuration.GetConnectionString("Marten")!);

    // Register event types
    options.Events.AddEventType<BlogPostCreated>();
    options.Events.AddEventType<BlogPostPublished>();
    options.Events.AddEventType<BlogPostTitleChanged>();
    options.Events.AddEventType<CommentAdded>();

    // Configure async projections
    options.Projections.Add<BlogPostProjection>(ProjectionLifecycle.Async);
});

builder.Services.AddMediatR(cfg =>
    cfg.RegisterServicesFromAssembly(typeof(Program).Assembly));

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

### Архітектура

Ось як все працює.

```mermaid
flowchart TB
    subgraph Client["Client Application"]
        UI[User Interface]
    end

    subgraph Commands["Command Side (Writes)"]
        CMD[Commands] --> CMDH[Command Handlers]
        CMDH --> MARTEN[Marten Session]
        MARTEN --> EVENTS[(Event Store)]
    end

    subgraph Background["Async Processing"]
        EVENTS -.->|Event Stream| DAEMON[Marten Async Daemon]
        DAEMON --> PROJ[Projections]
        PROJ --> READDB[(Read Models)]
    end

    subgraph Queries["Query Side (Reads)"]
        QRY[Queries] --> QRYH[Query Handlers with Dapper]
        QRYH --> READDB
    end

    UI -->|Commands| CMD
    UI -->|Queries| QRY

    classDef commandStyle fill:none,stroke:#e63946,stroke-width:3px
    classDef queryStyle fill:none,stroke:#457b9d,stroke-width:3px
    classDef dataStyle fill:none,stroke:#2a9d8f,stroke-width:3px

    class CMD,CMDH,MARTEN commandStyle
    class QRY,QRYH queryStyle
    class EVENTS,READDB dataStyle
```

Ключевые моменти:

- **Команди** додавати події в магазин подій
- **Асинк-デーмон** обробляє події та aktualizuje моделі читання
- **Запитки** читати з денормальних моделей читання
- Ніхто не потребує ручного валида Cache!

## Визначати події

події - це незмінні записи, які описують події, що відбувалися

```csharp
// Always past tense - these things have happened
public record BlogPostCreated(
    Guid BlogPostId,
    string Title,
    string Content,
    string AuthorId,
    DateTime CreatedAt
);

public record BlogPostPublished(
    Guid BlogPostId,
    DateTime PublishedAt
);

public record BlogPostTitleChanged(
    Guid BlogPostId,
    string OldTitle,
    string NewTitle,
    DateTime ChangedAt
);

public record CommentAdded(
    Guid BlogPostId,
    Guid CommentId,
    string Author,
    string Content,
    DateTime CreatedAt
);
```

Мероприяти мають бути::

- **Невідмінний** - коли-небудь було написаноM SK1 ніколи не змінювалось
- **Тензия минулого** МСК0 вони описують, що сталося
- **Багатство у значенні бізнесу** - МSK1BlogPostTitleChangedM SK2 not "PropertyUpdated"

## Створювання agregaтів

Aggregати - це модель запису. Вони підтверджують правила бізнесу і створюють подіїM SK1

```csharp
public class BlogPost
{
    // Marten requires an Id property
    public Guid Id { get; set; }

    // Current state (private setters)
    public string Title { get; private set; } = string.Empty;
    public string Content { get; private set; } = string.Empty;
    public string AuthorId { get; private set; } = string.Empty;
    public bool IsPublished { get; private set; }
    public DateTime? PublishedDate { get; private set; }
    private readonly List<Comment> _comments = new();
    public IReadOnlyList<Comment> Comments => _comments.AsReadOnly();

    // Apply methods - called by Marten when replaying events
    public void Apply(BlogPostCreated e)
    {
        Id = e.BlogPostId;
        Title = e.Title;
        Content = e.Content;
        AuthorId = e.AuthorId;
    }

    public void Apply(BlogPostPublished e)
    {
        IsPublished = true;
        PublishedDate = e.PublishedAt;
    }

    public void Apply(BlogPostTitleChanged e)
    {
        Title = e.NewTitle;
    }

    public void Apply(CommentAdded e)
    {
        _comments.Add(new Comment
        {
            Id = e.CommentId,
            Author = e.Author,
            Content = e.Content,
            CreatedAt = e.CreatedAt
        });
    }

    // Business logic methods that produce events
    public static BlogPostCreated Create(string title, string content, string authorId)
    {
        if (string.IsNullOrWhiteSpace(title))
            throw new ArgumentException("Title is required");

        return new BlogPostCreated(
            Guid.NewGuid(),
            title,
            content,
            authorId,
            DateTime.UtcNow
        );
    }

    public BlogPostPublished Publish()
    {
        if (IsPublished)
            throw new InvalidOperationException("Post is already published");

        return new BlogPostPublished(Id, DateTime.UtcNow);
    }

    public BlogPostTitleChanged ChangeTitle(string newTitle)
    {
        if (string.IsNullOrWhiteSpace(newTitle))
            throw new ArgumentException("Title cannot be empty");

        if (newTitle == Title)
            throw new InvalidOperationException("New title is the same as current title");

        return new BlogPostTitleChanged(Id, Title, newTitle, DateTime.UtcNow);
    }
}

public class Comment
{
    public Guid Id { get; set; }
    public string Author { get; set; } = string.Empty;
    public string Content { get; set; } = string.Empty;
    public DateTime CreatedAt { get; set; }
}
```

Модель:

1. Бізнесові методи підтверджують та повертають події
2. Використовувати методи, щоб оновити внутрішній стан
3. Мартен управляє тривалістю подій та повторюваністю

## Руководителі команд (ПисьморучM SK1

Команди обробляються шляхом додавання подій до потоків:

```csharp
// Define commands
public record CreateBlogPostCommand(
    string Title,
    string Content,
    string AuthorId
) : IRequest<Guid>;

public record PublishBlogPostCommand(Guid BlogPostId) : IRequest;

public record ChangeBlogPostTitleCommand(
    Guid BlogPostId,
    string NewTitle
) : IRequest;

// Handler for creating a blog post
public class CreateBlogPostHandler : IRequestHandler<CreateBlogPostCommand, Guid>
{
    private readonly IDocumentSession _session;

    public CreateBlogPostHandler(IDocumentSession session)
    {
        _session = session;
    }

    public async Task<Guid> Handle(CreateBlogPostCommand request, CancellationToken cancellationToken)
    {
        // Create the event
        var created = BlogPost.Create(
            request.Title,
            request.Content,
            request.AuthorId
        );

        // Start a new event stream
        _session.Events.StartStream<BlogPost>(created.BlogPostId, created);

        await _session.SaveChangesAsync(cancellationToken);

        return created.BlogPostId;
    }
}

// Handler for publishing
public class PublishBlogPostHandler : IRequestHandler<PublishBlogPostCommand>
{
    private readonly IDocumentSession _session;

    public PublishBlogPostHandler(IDocumentSession session)
    {
        _session = session;
    }

    public async Task Handle(PublishBlogPostCommand request, CancellationToken cancellationToken)
    {
        // Load the aggregate by replaying its events
        var blogPost = await _session.Events.AggregateStreamAsync<BlogPost>(
            request.BlogPostId,
            token: cancellationToken
        );

        if (blogPost == null)
            throw new InvalidOperationException($"Blog post {request.BlogPostId} not found");

        // Business logic produces new event
        var published = blogPost.Publish();

        // Append event to the stream
        _session.Events.Append(request.BlogPostId, published);

        await _session.SaveChangesAsync(cancellationToken);
    }
}

// Handler for changing title
public class ChangeBlogPostTitleHandler : IRequestHandler<ChangeBlogPostTitleCommand>
{
    private readonly IDocumentSession _session;

    public ChangeBlogPostTitleHandler(IDocumentSession session)
    {
        _session = session;
    }

    public async Task Handle(ChangeBlogPostTitleCommand request, CancellationToken cancellationToken)
    {
        var blogPost = await _session.Events.AggregateStreamAsync<BlogPost>(
            request.BlogPostId,
            token: cancellationToken
        );

        if (blogPost == null)
            throw new InvalidOperationException($"Blog post {request.BlogPostId} not found");

        var titleChanged = blogPost.ChangeTitle(request.NewTitle);

        _session.Events.Append(request.BlogPostId, titleChanged);

        await _session.SaveChangesAsync(cancellationToken);
    }
}
```

Потік:

1. Загрузити агрегат, відтворивши події ( або створити новийM SK1
2. Позвонити бізнес-metodою (validates and returns eventM SK1
3. Додайте подію до потоку
4. Врятувати зміни

Мартен відповідає за решту: - зберігає події , запускає проекції МSK2 і т.д.

## Прочитайте моделі та прогнози

Проекції перетворюють події на денормальні читані моделі:

```csharp
// Read model - optimised for queries
public class BlogPostReadModel
{
    public Guid Id { get; set; }
    public string Title { get; set; } = string.Empty;
    public string Content { get; set; } = string.Empty;
    public string AuthorId { get; set; } = string.Empty;
    public DateTime CreatedAt { get; set; }
    public DateTime? PublishedAt { get; set; }
    public bool IsPublished { get; set; }
    public int CommentCount { get; set; }
}

// Projection - tells Marten how to build read models from events
public class BlogPostProjection : MultiStreamProjection<BlogPostReadModel, Guid>
{
    public BlogPostProjection()
    {
        // Identity tells Marten which stream each event belongs to
        Identity<BlogPostCreated>(x => x.BlogPostId);
        Identity<BlogPostPublished>(x => x.BlogPostId);
        Identity<BlogPostTitleChanged>(x => x.BlogPostId);
        Identity<CommentAdded>(x => x.BlogPostId);
    }

    // Apply methods - Marten calls these to update read models
    public void Apply(BlogPostReadModel view, BlogPostCreated e)
    {
        view.Id = e.BlogPostId;
        view.Title = e.Title;
        view.Content = e.Content;
        view.AuthorId = e.AuthorId;
        view.CreatedAt = e.CreatedAt;
        view.IsPublished = false;
    }

    public void Apply(BlogPostReadModel view, BlogPostPublished e)
    {
        view.IsPublished = true;
        view.PublishedAt = e.PublishedAt;
    }

    public void Apply(BlogPostReadModel view, BlogPostTitleChanged e)
    {
        view.Title = e.NewTitle;
    }

    public void Apply(BlogPostReadModel view, CommentAdded e)
    {
        view.CommentCount++;
    }
}
```

Мартен's асинк-デーмон обробляє події в фоні і keeps reading models up to date

## Query Side with Dapper

Тепер ми запитуємо читані моделі, використовуючи Dapper для максимальної продуктивності:

```csharp
// Define queries
public record GetRecentBlogPostsQuery(
    int Count,
    bool PublishedOnly
) : IRequest<List<BlogPostListItemDto>>;

public record GetBlogPostByIdQuery(Guid Id) : IRequest<BlogPostDetailDto?>;

// DTOs for display
public class BlogPostListItemDto
{
    public Guid Id { get; set; }
    public string Title { get; set; } = string.Empty;
    public string AuthorName { get; set; } = string.Empty;
    public DateTime CreatedAt { get; set; }
    public DateTime? PublishedAt { get; set; }
    public int CommentCount { get; set; }
    public bool IsPublished { get; set; }
}

public class BlogPostDetailDto
{
    public Guid Id { get; set; }
    public string Title { get; set; } = string.Empty;
    public string Content { get; set; } = string.Empty;
    public string AuthorId { get; set; } = string.Empty;
    public string AuthorName { get; set; } = string.Empty;
    public DateTime CreatedAt { get; set; }
    public DateTime? PublishedAt { get; set; }
    public bool IsPublished { get; set; }
    public List<CommentDto> Comments { get; set; } = new();
}

public class CommentDto
{
    public Guid Id { get; set; }
    public string Author { get; set; } = string.Empty;
    public string Content { get; set; } = string.Empty;
    public DateTime CreatedAt { get; set; }
}

// Query handlers
public class GetRecentBlogPostsHandler : IRequestHandler<GetRecentBlogPostsQuery, List<BlogPostListItemDto>>
{
    private readonly string _connectionString;

    public GetRecentBlogPostsHandler(IConfiguration config)
    {
        _connectionString = config.GetConnectionString("Marten")!;
    }

    public async Task<List<BlogPostListItemDto>> Handle(
        GetRecentBlogPostsQuery request,
        CancellationToken cancellationToken)
    {
        await using var connection = new NpgsqlConnection(_connectionString);

        // Query the Marten-generated read model table
        const string sql = @"
            SELECT
                bp.id AS Id,
                bp.title AS Title,
                u.name AS AuthorName,
                bp.created_at AS CreatedAt,
                bp.published_at AS PublishedAt,
                bp.comment_count AS CommentCount,
                bp.is_published AS IsPublished
            FROM blog_post_read_models bp
            LEFT JOIN users u ON bp.author_id = u.id
            WHERE (@PublishedOnly = false OR bp.is_published = true)
            ORDER BY
                CASE WHEN bp.is_published THEN bp.published_at
                     ELSE bp.created_at
                END DESC
            LIMIT @Count";

        var results = await connection.QueryAsync<BlogPostListItemDto>(
            sql,
            new
            {
                PublishedOnly = request.PublishedOnly,
                Count = request.Count
            });

        return results.ToList();
    }
}

public class GetBlogPostByIdHandler : IRequestHandler<GetBlogPostByIdQuery, BlogPostDetailDto?>
{
    private readonly string _connectionString;

    public GetBlogPostByIdHandler(IConfiguration config)
    {
        _connectionString = config.GetConnectionString("Marten")!;
    }

    public async Task<BlogPostDetailDto?> Handle(
        GetBlogPostByIdQuery request,
        CancellationToken cancellationToken)
    {
        await using var connection = new NpgsqlConnection(_connectionString);

        const string sql = @"
            SELECT
                bp.id AS Id,
                bp.title AS Title,
                bp.content AS Content,
                bp.author_id AS AuthorId,
                u.name AS AuthorName,
                bp.created_at AS CreatedAt,
                bp.published_at AS PublishedAt,
                bp.is_published AS IsPublished
            FROM blog_post_read_models bp
            LEFT JOIN users u ON bp.author_id = u.id
            WHERE bp.id = @Id";

        var post = await connection.QuerySingleOrDefaultAsync<BlogPostDetailDto>(
            sql,
            new { request.Id });

        if (post == null)
            return null;

        // Get comments from event stream if needed
        // Or maintain a separate comment read model

        return post;
    }
}
```

Жодного коду кэшування. Жодної логіки знижуванняМSK1 Мартен зберігає читані моделі в синхронному стані автоматичноM SK2

## Контролери

За допомогою MediatR, контролери дуже прості

```csharp
[ApiController]
[Route("api/[controller]")]
public class BlogPostsController : ControllerBase
{
    private readonly IMediator _mediator;

    public BlogPostsController(IMediator mediator)
    {
        _mediator = mediator;
    }

    [HttpGet]
    public async Task<ActionResult<List<BlogPostListItemDto>>> GetRecent(
        [FromQuery] int count = 10,
        [FromQuery] bool publishedOnly = true)
    {
        var query = new GetRecentBlogPostsQuery(count, publishedOnly);
        var results = await _mediator.Send(query);
        return Ok(results);
    }

    [HttpGet("{id}")]
    public async Task<ActionResult<BlogPostDetailDto>> GetById(Guid id)
    {
        var query = new GetBlogPostByIdQuery(id);
        var result = await _mediator.Send(query);

        if (result == null)
            return NotFound();

        return Ok(result);
    }

    [HttpPost]
    public async Task<ActionResult<Guid>> Create([FromBody] CreateBlogPostCommand command)
    {
        var postId = await _mediator.Send(command);
        return CreatedAtAction(nameof(GetById), new { id = postId }, postId);
    }

    [HttpPost("{id}/publish")]
    public async Task<ActionResult> Publish(Guid id)
    {
        await _mediator.Send(new PublishBlogPostCommand(id));
        return NoContent();
    }

    [HttpPut("{id}/title")]
    public async Task<ActionResult> ChangeTitle(
        Guid id,
        [FromBody] ChangeBlogPostTitleCommand command)
    {
        if (id != command.BlogPostId)
            return BadRequest();

        await _mediator.Send(command);
        return NoContent();
    }
}
```

## Повний потік

Ось як це працює:

```mermaid
sequenceDiagram
    participant Client
    participant Controller
    participant MediatR
    participant CommandHandler
    participant Marten
    participant EventStore
    participant AsyncDaemon
    participant ReadDB
    participant QueryHandler

    Note over Client,ReadDB: Write Operation
    Client->>Controller: POST /api/blogposts
    Controller->>MediatR: Send CreateBlogPostCommand
    MediatR->>CommandHandler: Handle command
    CommandHandler->>CommandHandler: Validate & create event
    CommandHandler->>Marten: StartStream(event)
    Marten->>EventStore: Append event
    EventStore-->>Marten: Success
    Marten-->>CommandHandler: Success
    CommandHandler-->>Controller: Return ID
    Controller-->>Client: 201 Created

    Note over AsyncDaemon,ReadDB: Background Processing
    EventStore->>AsyncDaemon: New event available
    AsyncDaemon->>AsyncDaemon: Apply projection
    AsyncDaemon->>ReadDB: Update read model
    ReadDB-->>AsyncDaemon: Updated

    Note over Client,ReadDB: Read Operation
    Client->>Controller: GET /api/blogposts
    Controller->>MediatR: Send Query
    MediatR->>QueryHandler: Handle query
    QueryHandler->>ReadDB: SELECT with Dapper
    ReadDB-->>QueryHandler: Return data
    QueryHandler-->>Controller: Return DTOs
    Controller-->>Client: 200 OK
```

## Врешті-решт, послідовність

Одне, що треба зрозуміти: МСК0 з асинковими проекціями; МСК1 - там; МSK2 - невелика затримка між написанням подій і оновленням читальної моделі. МСК3 - зазвичай мілісекунд; МКС4 - але це

Якщо вам потрібна безпосередня послідовність для певної операції,

```csharp
builder.Services.AddMarten(options =>
{
    // This projection runs synchronously
    options.Projections.Add<CriticalDataProjection>(ProjectionLifecycle.Inline);

    // This projection runs async
    options.Projections.Add<BlogPostProjection>(ProjectionLifecycle.Async);
});
```

Або запитувати поток подій безпосередньо для читання

```csharp
var blogPost = await _session.Events.AggregateStreamAsync<BlogPost>(id);
```

## Частина 2: Половина МSK1Асоціальний підхід МSK2Невиліковування кэша )

Правильно. МСК0, так що ви МСК1, ви прочитали про правильне підбірку подій і ви МSK2 думаєте, МСК3, що МСК4 - це багато роботи. МSK5 - досить справедливо. . - ось тут МСК7 - неформальний CQRS МСК9 - підхід, який більшість команд насправді використовують

### Установлення

- Команди пишуть до бази даних (за допомогою EF або Dapper)
- Запитки читаються від IMemoryCache або IDistributedCache
- Команди зазнають непотрібності відповідних записів в кэші після написання
- Жодного ресурсу подій, ніяких передбачень , ніякого асинкового демона

Це неправда CQRS. Ви не отримуєте audit trail ' Не отримуєте временних запитів МSK4 або автоматичних прогнозів M SK5 Але ви отримуєте результат з меншою складністю

### Найкращий приклад

```csharp
// Command handler
public class CreateBlogPostHandler : IRequestHandler<CreateBlogPostCommand, int>
{
    private readonly ApplicationDbContext _context;
    private readonly IMemoryCache _cache;

    public async Task<int> Handle(CreateBlogPostCommand request, CancellationToken cancellationToken)
    {
        var blogPost = new BlogPost
        {
            Title = request.Title,
            Content = request.Content,
            AuthorId = request.AuthorId,
            PublishedDate = DateTime.UtcNow
        };

        _context.BlogPosts.Add(blogPost);
        await _context.SaveChangesAsync(cancellationToken);

        // Manual cache invalidation - this is the tedious bit
        _cache.Remove("recent-posts");
        _cache.Remove($"author-posts-{request.AuthorId}");
        _cache.Remove($"post-{blogPost.Id}");

        return blogPost.Id;
    }
}

// Query handler
public class GetRecentPostsHandler : IRequestHandler<GetRecentPostsQuery, List<BlogPostDto>>
{
    private readonly string _connectionString;
    private readonly IMemoryCache _cache;

    public async Task<List<BlogPostDto>> Handle(GetRecentPostsQuery request, CancellationToken cancellationToken)
    {
        var cacheKey = "recent-posts";

        if (_cache.TryGetValue<List<BlogPostDto>>(cacheKey, out var cached))
            return cached!;

        // Cache miss - query with Dapper
        using var connection = new NpgsqlConnection(_connectionString);
        var posts = (await connection.QueryAsync<BlogPostDto>(
            "SELECT id, title, author_name, published_date FROM blog_posts ORDER BY published_date DESC LIMIT 10"
        )).ToList();

        _cache.Set(cacheKey, posts, TimeSpan.FromMinutes(5));
        return posts;
    }
}
```

### Коли це працює

- Прості застосування без складних вимог до аудиту
- Ви потребуєте ефективності, але не можете виправдовувати складність пошуку подій
- Невелика команда, яка не хоче вивчити Event Sourcing
- Нестабільність кількох секунд є прийнятною

### Проблеми

**Невправність таємниці в кэші важка**: Ви втрачаєте один ключ кэшу і отримуєте застарілі даніM SK1 Кожна команда мусить знати, які кэши неważні

**Ніяких слідів аудиту**: Ви маєте лише те саме, що й заразM SK1 Ви не можете стверджувати, що сталося чи коли

**Ніяких тимчасових запитів**МSK0 Не можу ' не запитати " як виглядала система вчора

**Скалування**: З IMemoryCache , кожен сервер має свій власний кэш МSK2 Обновлення на сервері А МСК3 сервер Б досі має старі дані М СК4 IDistributedCache вирішує це, але додає Redis M СК5

**Пов 'язане поєднання**: Команди під 'єднані до ключів кэшу . Зміняємо запити МSK2 може зламати команду

Це працює. МСК0, але ви - МСК1 - це простота торгівлі втратою можливостей. МSK2. Інколи - МSK3 - це правильний курс.

## Частина 3: Найгірша ідея - Обстеження подій МSK2 Ручна неvaliда Cache

А тепер на справді жахливу ідею – using Event Sourcing but also trying to manually invalidate caches.

### Чому люди це роблять?

Вони хочуть відстеження подій, перевірку слідів та часових запитів, але вони хвилюються про остаточну послідовність. Тож вони думають: "" МСК4 I ' "". Вони просто додають неważність кэша, щоб читати швидше і більш послідовно.

Не робіть цього

### Чому це жахливо

**Ви МСК0 перемогли ціль**: Обстеження подій вже створює читані моделі за допомогою проекцій . Добавляючи manuellу неważність кэша означає, що ви' перехиляєте цю системуM SK3

**Двойна складність**: Зараз у вас є дві системи, які підтримують синхронність читаних моделей. - Мартен

**Недосконалість**: Marten ' асинк-デーмон оновлює базу даних МSK2 Ваша неważність кэшу одразу ж запускається M SK3 Вони ' закінчуються синхронизацією

**Утрачені переваги**: Обстеження подійM SK1 головною метою є те, що прогнози походять з подій

**Розладнання ночного кошмару**: Це застарілі дані тому, що проекції не працювали ' не працювала МSK2 Або через те, що ви забули в nullі внести ключ кэшу

### Правильний підхід

Якщо вам потрібно пошук подій:

- Використовуйте проекції Marten' M SK1асинк або в лінію )
- Змовірити прочитані моделі напряму
- Прийміть остаточну послідовність (itM SK1s зазвичай непогано)
- Використовуйте проекції в лінії, якщо вам дійсно потрібна безпосередня послідовність

Якщо ви можете' не приймати остаточної послідовностіM SK1

- Don' не використовувати пошук подій
- Використовуйте підхід cache- з частини 2
- Або просто використати традиційний CRUD з EF Core

Не намагайтеся зробити обидві речі.

### Приклад того, що не треба робити

```csharp
// Don't do this!
public class PublishBlogPostHandler : IRequestHandler<PublishBlogPostCommand>
{
    private readonly IDocumentSession _session;
    private readonly IMemoryCache _cache;  // ← BAD

    public async Task Handle(PublishBlogPostCommand request, CancellationToken cancellationToken)
    {
        var blogPost = await _session.Events.AggregateStreamAsync<BlogPost>(request.BlogPostId);
        var published = blogPost.Publish();

        _session.Events.Append(request.BlogPostId, published);
        await _session.SaveChangesAsync(cancellationToken);

        // Manually invalidating cache while using Event Sourcing ← TERRIBLE IDEA
        _cache.Remove($"post-{request.BlogPostId}");
        _cache.Remove("recent-posts");

        // Now you have:
        // 1. Event in event store
        // 2. Cache invalidated
        // 3. But projection hasn't run yet!
        // Queries will hit database before projection completes = stale data
    }
}
```

Просто використовуйте проекції Мартена.

## Завершення

Три підходи , три способи використання:

### Правильний CQRS з пошуком подій (MartenM SK1

**Використовуйте коли:**

- Потрібно провести повний аудит
- Temporal queries are valuable
- Комплексна домена з розвиненою логікою бізнесу
- фінансовий, охорона здоров 'яM SK1 або системи, regulовані

**Не користуйтеся коли**

- Проста програма CRUD
- Команді бракує досвіду
- Ніяких вимог до аудиту

### Неформальний CQRS з Caching

**Використовуйте коли:**

- Потрібно підвищити продуктивність при читанні
- Прослідка аудиту не обов 'язково
- Простіше, ніж пошук подій
- Врешті-решт, прийнятна послідовність

**Не користуйтеся коли**

- Потрібно провести аудит
- Потрібні тимчасові пошуки
- Складність неприйнятності キャッシュа переважає переваги

### Вишукання подій + Ручна неvaliда Cache

**Використовуйте коли:**

- Ніколи

Виберіть правильне інструментарій для вашого випадку використання. Обстеження подій з Мартеном є потужним, коли вам це потрібно . Cache-Based CQRS is simpler when you donMSC3tM SK4 Mixing them is a mistakeMRK5

Для більшості застосувань, розпочинаємо з традиційного CRUD M SK1гляньте на мою серію EF Core [тут](/blog/addingentityframeworkforblogpostspt1)). Коли ви стикаєтеся з проблемами з продуктивністю , додайте кэшування

## Дальне читання

- [Документація Мартена](https://martendb.io/) - Отож, чудові книги
- [EventStoreDB](https://www.eventstore.com/) - Альтернативний магазин подій, якщо Postgres - не ваш
- [Документація Dapper](https://github.com/DapperLib/Dapper) - швидкі SQL запроси
- [MediatR](https://github.com/jbogard/MediatR) - Команда
- [Microsoft на CQRS](https://learn.microsoft.com/en-us/azure/architecture/patterns/cqrs) - офіційні інструкції
- Розпочинається серія рамок моєї сутності [тут](/blog/addingentityframeworkforblogpostspt1) - Традиційний підхід