# Доступ до даних в .NETM SK1 Порівняння ORM та стратегий відображання

<!-- category -- .NET, Dapper, PostgreSQL, Performance, Database -->
<datetime class="hidden">2025-12-03T15:00</datetime>

Вітаю у частині 2 нашого повного інструкції про доступ до даних в .NETM SK2 В [Частина 1](/blog/orm-mapping-comparison-part1), ми дослідили ядро системи Entity Framework в глибині ,, включно з генерацією SQL МSK2 поширені недоліки M SK3 і це критичное попередження прокси та шифрування .

В цій статті ми дослідимо легкі альтернативи вагою МСК2 і як об 'єднати кілька підходів для оптимальної продуктивності МСК3

- **[Даппер](https://github.com/DapperLib/Dapper)**: МікроM SK1ORM
- **Raw ADO.NET/[Npgsql](https://www.npgsql.org/)**: Максимальна ефективність та контроль
- **Бібліотеки картографії об 'єктів**: [Мапстер](https://github.com/MapsterMapper/Mapster) проти [Автомапер](https://automapper.org/)
- **Гібридні підходи**: Об 'єднання EF Core і Dapper
- **Дослідження ефективності**: РеальнийM SK1порівняння з іншими країнами
- **Матрица прийняття рішень**: Вибір правильного інструмента для вашого сценарію

## Стосунок

## Даппер: МікроМSK1ORM

[Даппер](https://github.com/DapperLib/Dapper) є легким, високимM SK1 мікроефективним -ORM створеним Stack Overflow. це надає тонкий шар над ADOMSC4NETMスク5 обробляючи нудну роботу з відображанням результатів запитів на об 'єктах, водночас даючи вам повний контроль над SQLМSK6

### Чому існує дротик?

Даппер народився з Stack Overflow . МSK0 потребує високого рівня даних. МSK1 має доступ до даних з високим рівнем продуктивності. . Команда з 'ясувала, що повні ORM, такі як Entity Framework (Entity Framework), ((pre) ,-(Core) ٬) (Core), накладають надто багато витрат на високу пропускну спроможність.

### Найголовніше

- **Хворий SQL**: Ви самі пишете всі SQL - повний контроль
- **Високоефективність**: Minimalne надрахунки над ADO
- **Мульти-МSK0**: Карта складних запитів для багатьох пов 'язаних типів
- **Обробка параметрів**: Автоматична параметризація запобігає введення SQL
- **Поддержка транзакцій**: Полна контроль над транзакціями
- **Простість**: Без конфігурації
- **Асинк/Очекайте**: Полна асинхальна поддержка для сучасного .NET

### Найпростіший приклад дронта

```csharp
using Npgsql;
using Dapper;

public class DapperBlogRepository
{
    private readonly string _connectionString;

    public DapperBlogRepository(string connectionString)
    {
        _connectionString = connectionString;

        // Configure Dapper to work with PostgreSQL naming conventions
        DefaultTypeMap.MatchNamesWithUnderscores = true;
    }

    // Simple query
    public async Task<IEnumerable<BlogPost>> GetRecentPostsAsync(int count)
    {
        using var connection = new NpgsqlConnection(_connectionString);

        const string sql = @"
            SELECT id, title, content, tags, published_date, category_id
            FROM blog_posts
            ORDER BY published_date DESC
            LIMIT @Count";

        return await connection.QueryAsync<BlogPost>(sql, new { Count = count });
    }

    // Query with WHERE clause
    public async Task<BlogPost> GetPostByIdAsync(int id)
    {
        using var connection = new NpgsqlConnection(_connectionString);

        const string sql = @"
            SELECT id, title, content, published_date
            FROM blog_posts
            WHERE id = @Id";

        return await connection.QueryFirstOrDefaultAsync<BlogPost>(sql, new { Id = id });
    }

    // Insert with returning ID
    public async Task<int> CreatePostAsync(BlogPost post)
    {
        using var connection = new NpgsqlConnection(_connectionString);

        const string sql = @"
            INSERT INTO blog_posts (title, content, published_date, category_id)
            VALUES (@Title, @Content, @PublishedDate, @CategoryId)
            RETURNING id";

        return await connection.ExecuteScalarAsync<int>(sql, post);
    }

    // Update
    public async Task UpdatePostAsync(BlogPost post)
    {
        using var connection = new NpgsqlConnection(_connectionString);

        const string sql = @"
            UPDATE blog_posts
            SET title = @Title,
                content = @Content,
                published_date = @PublishedDate
            WHERE id = @Id";

        await connection.ExecuteAsync(sql, post);
    }

    // Delete
    public async Task DeletePostAsync(int id)
    {
        using var connection = new NpgsqlConnection(_connectionString);

        const string sql = "DELETE FROM blog_posts WHERE id = @Id";

        await connection.ExecuteAsync(sql, new { Id = id });
    }
}
```

### Multi-MappingM SK1 Рухові з 'єднувачі

Однією з найпотужніших характеристик Dapper' є багатоп 'ятовеM SK1картографування - ефективного об' єднання і картографування багатьох пов 'язаних об 'єктів

```csharp
public async Task<IEnumerable<BlogPost>> GetPostsWithCategoryAsync()
{
    using var connection = new NpgsqlConnection(_connectionString);

    const string sql = @"
        SELECT
            p.id, p.title, p.content, p.published_date,
            c.id, c.name, c.description
        FROM blog_posts p
        INNER JOIN categories c ON p.category_id = c.id
        ORDER BY p.published_date DESC";

    return await connection.QueryAsync<BlogPost, Category, BlogPost>(
        sql,
        (post, category) =>
        {
            post.Category = category;
            return post;
        },
        splitOn: "id"  // Split at the second "id" column
    );
}

// More complex: Posts with comments
public async Task<IEnumerable<BlogPost>> GetPostsWithCommentsAsync()
{
    using var connection = new NpgsqlConnection(_connectionString);

    const string sql = @"
        SELECT
            p.id, p.title, p.content,
            c.id, c.author, c.content, c.created_at
        FROM blog_posts p
        LEFT JOIN comments c ON p.id = c.blog_post_id
        ORDER BY p.published_date DESC, c.created_at";

    var postDict = new Dictionary<int, BlogPost>();

    await connection.QueryAsync<BlogPost, Comment, BlogPost>(
        sql,
        (post, comment) =>
        {
            if (!postDict.TryGetValue(post.Id, out var existingPost))
            {
                existingPost = post;
                existingPost.Comments = new List<Comment>();
                postDict.Add(post.Id, existingPost);
            }

            if (comment != null)
            {
                existingPost.Comments.Add(comment);
            }

            return existingPost;
        },
        splitOn: "id"
    );

    return postDict.Values;
}
```

### Заawansовані технології дронта

**Динамічні параметри для складних запитів:**

```csharp
public async Task<IEnumerable<BlogPost>> SearchWithDynamicFiltersAsync(SearchCriteria criteria)
{
    using var connection = new NpgsqlConnection(_connectionString);

    var parameters = new DynamicParameters();
    var conditions = new List<string>();

    var sql = new StringBuilder("SELECT * FROM blog_posts");

    if (!string.IsNullOrEmpty(criteria.SearchTerm))
    {
        conditions.Add("search_vector @@ to_tsquery('english', @SearchTerm)");
        parameters.Add("SearchTerm", criteria.SearchTerm);
    }

    if (criteria.CategoryIds?.Any() == true)
    {
        conditions.Add("category_id = ANY(@CategoryIds)");
        parameters.Add("CategoryIds", criteria.CategoryIds);
    }

    if (criteria.FromDate.HasValue)
    {
        conditions.Add("published_date >= @FromDate");
        parameters.Add("FromDate", criteria.FromDate.Value);
    }

    if (criteria.Tags?.Any() == true)
    {
        conditions.Add("tags && @Tags");  // PostgreSQL array overlap
        parameters.Add("Tags", criteria.Tags);
    }

    if (conditions.Any())
    {
        sql.Append(" WHERE ");
        sql.Append(string.Join(" AND ", conditions));
    }

    sql.Append(" ORDER BY published_date DESC LIMIT @Limit");
    parameters.Add("Limit", criteria.Limit);

    return await connection.QueryAsync<BlogPost>(sql.ToString(), parameters);
}
```

**Руководителі на замовлення для типів PostgreSQL:**

```csharp
// Handle PostgreSQL arrays
public class PostgresArrayTypeHandler : SqlMapper.TypeHandler<string[]>
{
    public override void SetValue(IDbDataParameter parameter, string[] value)
    {
        parameter.Value = value;
        ((NpgsqlParameter)parameter).NpgsqlDbType = NpgsqlDbType.Array | NpgsqlDbType.Text;
    }

    public override string[] Parse(object value)
    {
        return (string[])value;
    }
}

// Handle PostgreSQL JSONB
public class JsonTypeHandler<T> : SqlMapper.TypeHandler<T>
{
    public override void SetValue(IDbDataParameter parameter, T value)
    {
        parameter.Value = JsonSerializer.Serialize(value);
        ((NpgsqlParameter)parameter).NpgsqlDbType = NpgsqlDbType.Jsonb;
    }

    public override T Parse(object value)
    {
        return JsonSerializer.Deserialize<T>(value.ToString());
    }
}

// Register handlers (in startup)
SqlMapper.AddTypeHandler(new PostgresArrayTypeHandler());
SqlMapper.AddTypeHandler(new JsonTypeHandler<Dictionary<string, object>>());
```

**Об 'ємні операції з PostgreSQL COPY:**

```csharp
public async Task BulkInsertPostsAsync(IEnumerable<BlogPost> posts)
{
    using var connection = new NpgsqlConnection(_connectionString);
    await connection.OpenAsync();

    using var writer = await connection.BeginBinaryImportAsync(
        "COPY blog_posts (title, content, tags, published_date) FROM STDIN (FORMAT BINARY)"
    );

    foreach (var post in posts)
    {
        await writer.StartRowAsync();
        await writer.WriteAsync(post.Title);
        await writer.WriteAsync(post.Content);
        await writer.WriteAsync(post.Tags, NpgsqlDbType.Array | NpgsqlDbType.Text);
        await writer.WriteAsync(post.PublishedDate);
    }

    await writer.CompleteAsync();
}
```

**Obsługа транзакцій:**

```csharp
public async Task TransferPostToCategoryAsync(int postId, int newCategoryId)
{
    using var connection = new NpgsqlConnection(_connectionString);
    await connection.OpenAsync();

    using var transaction = await connection.BeginTransactionAsync();

    try
    {
        // Update the post
        await connection.ExecuteAsync(
            "UPDATE blog_posts SET category_id = @CategoryId WHERE id = @PostId",
            new { CategoryId = newCategoryId, PostId = postId },
            transaction
        );

        // Log the change
        await connection.ExecuteAsync(
            @"INSERT INTO category_history (post_id, category_id, changed_at)
              VALUES (@PostId, @CategoryId, @ChangedAt)",
            new { PostId = postId, CategoryId = newCategoryId, ChangedAt = DateTime.UtcNow },
            transaction
        );

        await transaction.CommitAsync();
    }
    catch
    {
        await transaction.RollbackAsync();
        throw;
    }
}
```

### Коли використовувати Dapper

**✅ Використовуйте Dapper, коли**

- Мощність критична, але ви не потребуєте абсолютної максимальної швидкості
- Ви - МСК0 - звикли писати SQL
- У вас є складні питання, які не map well to LINQ
- Потрібно добре контролювати генерацію SQL
- Ви' працюєте з існуючою схемою бази даних
- Ви хочете мінімальних надрахунків та залежності
- Спостереження щодо використання пам 'яті
- Потрібно широко використати специфічні характеристики бази даних-

**❌ уникати дроту, колиM SK1**

- Ваша команда не в захваті з SQL
- Вам потрібно автоматично відстежувати зміни
- Ви хочете схему мігрувати як код
- У вас є схема, що швидко розвивається
- Вам потрібна портативність бази даних cross-
- Ви віддають перевагу LINQ, ніж синтаксису SQL

### Характеристики ефективності

- **Результати тесту**: 5-15% накладні витрати на сирові ADOM SK2NET
- **Використовування пам 'яті**: Minimal - без відстеження змін або прокси
- **Об 'ємні операції**: Чудово з PostgreSQL COPY
- **Перше запитання**: Швидкий - без кроку компіляції
- **Продуктивність розробника**: Requires SQL knowledge but very predictable

## Raw ADO.NET з Npgsql

Для абсолютної максимальної продуктивності та контролю, ви можете використовувати [Npgsql](https://www.npgsql.org/) безпосередньо без будь-якого ORM шару.

### Коли RAW ADO.NET має сенс

Raw ADO.NET підходить, коли

- Потрібно кожну мілісекундну
- Ви будуєте високопропускні процесори даних
- Ви' працюєте з PostgreSQL- конкретні funkcje не підтримують ORMs
- Потрібно точно контролювати розподіл пам 'яті
- Ви займаєтесь об 'ємними операціями або потоком великих наборів даних

### Наприклад: Pure Npgsql

```csharp
public class NpgsqlBlogRepository
{
    private readonly string _connectionString;

    public async Task<List<BlogPost>> GetRecentPostsAsync(int count)
    {
        var posts = new List<BlogPost>();

        using var connection = new NpgsqlConnection(_connectionString);
        await connection.OpenAsync();

        using var command = new NpgsqlCommand(
            "SELECT id, title, content, tags, published_date FROM blog_posts ORDER BY published_date DESC LIMIT @count",
            connection
        );

        command.Parameters.AddWithValue("count", count);

        using var reader = await command.ExecuteReaderAsync();

        while (await reader.ReadAsync())
        {
            posts.Add(new BlogPost
            {
                Id = reader.GetInt32(0),
                Title = reader.GetString(1),
                Content = reader.GetString(2),
                Tags = reader.GetFieldValue<string[]>(3),
                PublishedDate = reader.GetDateTime(4)
            });
        }

        return posts;
    }

    // Using prepared statements for repeated queries
    public async Task<BlogPost> GetPostByIdAsync(int id)
    {
        using var connection = new NpgsqlConnection(_connectionString);
        await connection.OpenAsync();

        using var command = new NpgsqlCommand(
            "SELECT id, title, content FROM blog_posts WHERE id = $1",
            connection
        );

        command.Parameters.AddWithValue(id);
        await command.PrepareAsync(); // Prepared statement for performance

        using var reader = await command.ExecuteReaderAsync();

        if (await reader.ReadAsync())
        {
            return new BlogPost
            {
                Id = reader.GetInt32(0),
                Title = reader.GetString(1),
                Content = reader.GetString(2)
            };
        }

        return null;
    }

    // Working with PostgreSQL JSONB
    public async Task<Dictionary<string, object>> GetPostMetadataAsync(int id)
    {
        using var connection = new NpgsqlConnection(_connectionString);
        await connection.OpenAsync();

        using var command = new NpgsqlCommand(
            "SELECT metadata FROM blog_posts WHERE id = $1",
            connection
        );

        command.Parameters.AddWithValue(id);

        var json = await command.ExecuteScalarAsync() as string;
        return JsonSerializer.Deserialize<Dictionary<string, object>>(json);
    }

    // Streaming large result sets
    public async IAsyncEnumerable<BlogPost> StreamAllPostsAsync()
    {
        using var connection = new NpgsqlConnection(_connectionString);
        await connection.OpenAsync();

        using var command = new NpgsqlCommand(
            "SELECT id, title, content FROM blog_posts ORDER BY id",
            connection
        );

        using var reader = await command.ExecuteReaderAsync();

        while (await reader.ReadAsync())
        {
            yield return new BlogPost
            {
                Id = reader.GetInt32(0),
                Title = reader.GetString(1),
                Content = reader.GetString(2)
            };
        }
    }
}
```

### Характеристики ефективності

- **Результати тесту**: Базовая лінія - найшвидше, що можливо
- **Використовування пам 'яті**: Найнижчий МSK1 повний контроль над розподілом
- **Об 'ємні операції**: Чудово з протоколом COPY
- **Продуктивність розробника**: вимагає більшої кількості ручної роботи

## Бібліотеки картографії об 'єктів

Коли ви працюєте з Dapper або сировим ADO, вам часто потрібно відображати між різними представленнями об 'єктів.

### Mapster: WysokaM SK1Послідження продуктивності

[Мапстер](https://github.com/MapsterMapper/Mapster) це швидкий матриці об 'єктів на основі стандарту ,, що використовує генерацію джерел для оптимальної продуктивності

```csharp
// Install: Mapster and Mapster.Tool
using Mapster;

public class BlogPostDto
{
    public int Id { get; set; }
    public string Title { get; set; }
    public string Summary { get; set; }
    public List<string> CategoryNames { get; set; }
}

public class BlogPost
{
    public int Id { get; set; }
    public string Title { get; set; }
    public string Content { get; set; }
    public List<Category> Categories { get; set; }
}

// Configuration
public class MappingConfig : IRegister
{
    public void Register(TypeAdapterConfig config)
    {
        config.NewConfig<BlogPost, BlogPostDto>()
            .Map(dest => dest.Summary, src => src.Content.Substring(0, Math.Min(200, src.Content.Length)))
            .Map(dest => dest.CategoryNames, src => src.Categories.Select(c => c.Name).ToList());

        // Reverse map with ignore
        config.NewConfig<BlogPostDto, BlogPost>()
            .Ignore(dest => dest.Content);
    }
}

// Registration in Program.cs
TypeAdapterConfig.GlobalSettings.Scan(Assembly.GetExecutingAssembly());

// Usage with Dapper
public class BlogService
{
    private readonly string _connectionString;

    public async Task<List<BlogPostDto>> GetPostsAsync()
    {
        using var connection = new NpgsqlConnection(_connectionString);

        var posts = await connection.QueryAsync<BlogPost>(@"
            SELECT p.id, p.title, p.content
            FROM blog_posts p
        ");

        // Map to DTOs - very fast with Mapster
        return posts.Adapt<List<BlogPostDto>>();
    }

    // Projection mapping (compile-time)
    public async Task<List<BlogPostDto>> GetPostsDtosDirectlyAsync()
    {
        using var connection = new NpgsqlConnection(_connectionString);

        // Query directly to DTO shape
        return (await connection.QueryAsync<BlogPostDto>(@"
            SELECT
                id,
                title,
                SUBSTRING(content, 1, 200) as summary
            FROM blog_posts
        ")).ToList();
    }
}
```

### AutoMapper: Доросліша КонвенціяM SK1На основі

[Автомапер](https://automapper.org/) є найпопулярнішою картографією, хоча повільніше, ніж Mapster.

```csharp
// Install: AutoMapper and AutoMapper.Extensions.Microsoft.DependencyInjection
using AutoMapper;

public class MappingProfile : Profile
{
    public MappingProfile()
    {
        CreateMap<BlogPost, BlogPostDto>()
            .ForMember(d => d.Summary, opt => opt.MapFrom(s =>
                s.Content.Length > 200 ? s.Content.Substring(0, 200) : s.Content))
            .ForMember(d => d.CategoryNames, opt => opt.MapFrom(s =>
                s.Categories.Select(c => c.Name)));

        // Reverse map
        CreateMap<BlogPostDto, BlogPost>()
            .ForMember(d => d.Content, opt => opt.Ignore());
    }
}

// Registration in Program.cs
services.AddAutoMapper(typeof(MappingProfile));

// Usage
public class BlogService
{
    private readonly IMapper _mapper;
    private readonly string _connectionString;

    public BlogService(IMapper mapper, IConfiguration configuration)
    {
        _mapper = mapper;
        _connectionString = configuration.GetConnectionString("DefaultConnection");
    }

    public async Task<List<BlogPostDto>> GetPostsAsync()
    {
        using var connection = new NpgsqlConnection(_connectionString);

        var posts = await connection.QueryAsync<BlogPost>(@"
            SELECT id, title, content FROM blog_posts
        ");

        return _mapper.Map<List<BlogPostDto>>(posts.ToList());
    }
}
```

### Ручне картування: Полне управління

Іноді найкращий спосіб - це експлицитно мапуванняруч:

```csharp
public static class BlogPostMapper
{
    public static BlogPostDto ToDto(this BlogPost post)
    {
        return new BlogPostDto
        {
            Id = post.Id,
            Title = post.Title,
            Summary = post.Content.Length > 200
                ? post.Content.Substring(0, 200) + "..."
                : post.Content,
            CategoryNames = post.Categories?.Select(c => c.Name).ToList() ?? new List<string>()
        };
    }

    public static List<BlogPostDto> ToDtoList(this IEnumerable<BlogPost> posts)
    {
        return posts.Select(p => p.ToDto()).ToList();
    }

    // Inline mapping for simple cases
    public static BlogPostDto MapToDto(BlogPost post) => new()
    {
        Id = post.Id,
        Title = post.Title,
        Summary = post.Content[..Math.Min(200, post.Content.Length)]
    };
}

// Usage
var posts = await _repository.GetAllPostsAsync();
var dtos = posts.ToDtoList();
```

### Порівняння ефективності картування

```
BenchmarkDotNet Results (mapping 1000 objects):

Method              | Mean      | Allocated
--------------------|-----------|----------
Manual Mapping      | 45.2 μs   | 78 KB
Mapster             | 52.1 μs   | 79 KB
AutoMapper          | 184.3 μs  | 156 KB
```

**Key Takeaways:**

- Ручне картування найшвидше, але потребує більшого коду
- Мапстер майже такий же швидкий з меншим кодом
- AutoMapper зручно, але має більший об 'єм

## Гібридні підходи: Найкраще з обох світів

У реальних програмах, ви часто хочете використовувати різні підходи для різних сценаріїв в одній і тій самій програміM SK1 Це **запропонований підхід** для більшості систем виробництва.

### Модель CQRS: Розмежування odczytів та записів

Модель CQRS (Command Query Responsibility SegregationM SK1 є природною підходящою для гібридного підходу до доступу до даних. Для глибшого поглинання в CQ RS і ресурсування подій з [Мартен](https://martendb.io/), погляньте на мою статтю [Сучасний CQRS і пошук подій](/blog/moderncqrsandeventsourcing).

**Як Мартен ставиться до цієї дискусії:**

Мартен - це документова база даних і магазин подій, збудована на PostgreSQL, яка бере доступ до гібридних даних на іншому рівні.

- **Використовування подій** для записів (невідмінні потоки подійM SK1
- **Проекції** для чтень (матеріалізовані погляди оптимізовані для запитів
- **PostgreSQL's JSONB** для зберігання документів
- Вбудовані шаблони CQRS

Ця стаття фокусується на традиційному доступі до реляційних даних. (EF Core, DapperM SK2 Мартен показує, як можна використати передові функції PostgreSQL ' для реалізування складних архітектур.

- Різні моделі запису ( оптимізовані для транзакцій та консенсусу
- Різні моделі для читання ( оптимізовані для запитів та продуктивностіM SK1
- Використовуйте правильний інструмент для кожної роботи

```mermaid
graph TB
    Client[Client Application]

    subgraph "Write Side - Commands"
        WriteAPI[Write API / Commands]
        EFCore[EF Core Context]
        WriteDB[(PostgreSQL<br/>Write Operations)]
    end

    subgraph "Read Side - Queries"
        ReadAPI[Read API / Queries]
        Dapper[Dapper Repository]
        ReadDB[(PostgreSQL<br/>Read Operations)]
    end

    Client -->|Create/Update/Delete| WriteAPI
    WriteAPI --> EFCore
    EFCore -->|Change Tracking<br/>Validation<br/>Business Logic| WriteDB

    Client -->|Query/Search| ReadAPI
    ReadAPI --> Dapper
    Dapper -->|Optimized SQL<br/>DTOs<br/>No Tracking| ReadDB

    WriteDB -.->|Same Database| ReadDB

    style Client stroke:#6366f1,stroke-width:2px
    style WriteAPI stroke:#2563eb,stroke-width:2px
    style EFCore stroke:#2563eb,stroke-width:2px
    style WriteDB stroke:#2563eb,stroke-width:2px
    style ReadAPI stroke:#059669,stroke-width:2px
    style Dapper stroke:#059669,stroke-width:2px
    style ReadDB stroke:#059669,stroke-width:2px
```

Ця модель дає перевагу

- **Корінь EF** для записів: Зміна відстеженняМSK1 перевіркиM SK2 правила бізнесу
- **Даппер** для чтень: Максимальна ефективність та гнучкість запросів
- Те ж саме бази даних , різні моделі доступу оптимізовані для кожного випадку використання

### Implementation: CQRS with EF Core and Dapper

```csharp
// Commands: Use EF Core for change tracking and validation
public class BlogCommandService
{
    private readonly BlogDbContext _context;
    private readonly ILogger<BlogCommandService> _logger;

    public BlogCommandService(BlogDbContext context, ILogger<BlogCommandService> logger)
    {
        _context = context;
        _logger = logger;
    }

    public async Task<int> CreatePostAsync(CreatePostCommand command)
    {
        // Business logic and validation
        var post = new BlogPost
        {
            Title = command.Title,
            Content = command.Content,
            CategoryId = command.CategoryId,
            PublishedDate = DateTime.UtcNow
        };

        _context.BlogPosts.Add(post);
        await _context.SaveChangesAsync();

        _logger.LogInformation("Created blog post {PostId}", post.Id);

        return post.Id;
    }

    public async Task UpdatePostAsync(UpdatePostCommand command)
    {
        var post = await _context.BlogPosts.FindAsync(command.Id);

        if (post == null)
            throw new InvalidOperationException($"Post {command.Id} not found");

        post.Title = command.Title;
        post.Content = command.Content;
        post.UpdatedAt = DateTime.UtcNow;

        await _context.SaveChangesAsync();

        _logger.LogInformation("Updated blog post {PostId}", post.Id);
    }

    public async Task DeletePostAsync(int id)
    {
        var post = await _context.BlogPosts.FindAsync(id);

        if (post != null)
        {
            _context.BlogPosts.Remove(post);
            await _context.SaveChangesAsync();

            _logger.LogInformation("Deleted blog post {PostId}", id);
        }
    }
}

// Queries: Use Dapper for read performance
public class BlogQueryService
{
    private readonly string _connectionString;
    private readonly ILogger<BlogQueryService> _logger;

    public BlogQueryService(IConfiguration configuration, ILogger<BlogQueryService> logger)
    {
        _connectionString = configuration.GetConnectionString("DefaultConnection");
        _logger = logger;
    }

    public async Task<BlogPostDto> GetPostBySlugAsync(string slug)
    {
        using var connection = new NpgsqlConnection(_connectionString);

        const string sql = @"
            SELECT
                p.id,
                p.title,
                p.slug,
                p.content,
                p.published_date,
                c.id as category_id,
                c.name as category_name,
                (SELECT COUNT(*) FROM comments WHERE blog_post_id = p.id) as comment_count
            FROM blog_posts p
            INNER JOIN categories c ON p.category_id = c.id
            WHERE p.slug = @Slug";

        var post = await connection.QueryFirstOrDefaultAsync<BlogPostDto>(sql, new { Slug = slug });

        if (post != null)
        {
            _logger.LogInformation("Retrieved blog post by slug {Slug}", slug);
        }

        return post;
    }

    public async Task<PagedResult<BlogPostSummaryDto>> GetRecentPostsAsync(int page, int pageSize)
    {
        using var connection = new NpgsqlConnection(_connectionString);

        const string sql = @"
            SELECT
                p.id,
                p.title,
                p.slug,
                LEFT(p.content, 200) as summary,
                p.published_date,
                c.name as category_name
            FROM blog_posts p
            INNER JOIN categories c ON p.category_id = c.id
            ORDER BY p.published_date DESC
            LIMIT @PageSize OFFSET @Offset";

        const string countSql = "SELECT COUNT(*) FROM blog_posts";

        var posts = await connection.QueryAsync<BlogPostSummaryDto>(
            sql,
            new { PageSize = pageSize, Offset = (page - 1) * pageSize }
        );

        var totalCount = await connection.ExecuteScalarAsync<int>(countSql);

        return new PagedResult<BlogPostSummaryDto>
        {
            Items = posts.ToList(),
            TotalCount = totalCount,
            Page = page,
            PageSize = pageSize
        };
    }

    public async Task<List<BlogPostDto>> SearchPostsAsync(string searchTerm)
    {
        using var connection = new NpgsqlConnection(_connectionString);

        const string sql = @"
            SELECT
                p.id,
                p.title,
                p.slug,
                p.content,
                p.published_date,
                c.name as category_name,
                ts_rank(p.search_vector, query) as relevance_score
            FROM blog_posts p
            INNER JOIN categories c ON p.category_id = c.id,
                 to_tsquery('english', @SearchTerm) query
            WHERE p.search_vector @@ query
            ORDER BY relevance_score DESC
            LIMIT 50";

        var posts = await connection.QueryAsync<BlogPostDto>(sql, new { SearchTerm = searchTerm });

        _logger.LogInformation(
            "Searched posts with term {SearchTerm}, found {Count} results",
            searchTerm,
            posts.Count()
        );

        return posts.ToList();
    }
}

// Service layer orchestrating commands and queries
public class BlogService
{
    private readonly BlogCommandService _commands;
    private readonly BlogQueryService _queries;

    public BlogService(BlogCommandService commands, BlogQueryService queries)
    {
        _commands = commands;
        _queries = queries;
    }

    // Write operations delegate to command service
    public Task<int> CreatePostAsync(CreatePostCommand command) => _commands.CreatePostAsync(command);
    public Task UpdatePostAsync(UpdatePostCommand command) => _commands.UpdatePostAsync(command);
    public Task DeletePostAsync(int id) => _commands.DeletePostAsync(id);

    // Read operations delegate to query service
    public Task<BlogPostDto> GetPostBySlugAsync(string slug) => _queries.GetPostBySlugAsync(slug);
    public Task<PagedResult<BlogPostSummaryDto>> GetRecentPostsAsync(int page, int pageSize)
        => _queries.GetRecentPostsAsync(page, pageSize);
    public Task<List<BlogPostDto>> SearchPostsAsync(string searchTerm)
        => _queries.SearchPostsAsync(searchTerm);
}
```

### EF Core з Occasional Raw SQL

Для застосування, яке є основним ядром EF, але потребує інколишньої оптимізації ефективності:

```csharp
public class BlogService
{
    private readonly BlogDbContext _context;

    // 95% of queries: Use EF Core LINQ
    public async Task<List<BlogPost>> GetPostsByCategoryAsync(int categoryId)
    {
        return await _context.BlogPosts
            .Where(p => p.CategoryId == categoryId)
            .Include(p => p.Comments)
            .ToListAsync();
    }

    // 5% of queries: Use raw SQL for complex analytics
    public async Task<List<PostAnalytics>> GetPostAnalyticsAsync()
    {
        using var connection = _context.Database.GetDbConnection();
        await _context.Database.OpenConnectionAsync();

        using var command = connection.CreateCommand();
        command.CommandText = @"
            WITH post_metrics AS (
                SELECT
                    p.id,
                    p.title,
                    COUNT(DISTINCT c.id) as comment_count,
                    COUNT(DISTINCT v.id) as view_count,
                    AVG(c.sentiment_score) as avg_sentiment
                FROM blog_posts p
                LEFT JOIN comments c ON p.id = c.post_id
                LEFT JOIN post_views v ON p.id = v.post_id
                WHERE p.published_date >= NOW() - INTERVAL '30 days'
                GROUP BY p.id, p.title
            )
            SELECT * FROM post_metrics
            ORDER BY view_count DESC";

        var analytics = new List<PostAnalytics>();
        using var reader = await command.ExecuteReaderAsync();

        while (await reader.ReadAsync())
        {
            analytics.Add(new PostAnalytics
            {
                PostId = reader.GetInt32(0),
                Title = reader.GetString(1),
                CommentCount = reader.GetInt64(2),
                ViewCount = reader.GetInt64(3),
                AverageSentiment = reader.IsDBNull(4) ? 0 : reader.GetDouble(4)
            });
        }

        return analytics;
    }
}
```

## Порівняння ефективності

Давайте поглянемо на реальні показники світового рівня ефективності для об 'єднаних операцій з PostgreSQL

### Значення Benchmark: Reading M SK1 Rekordи

```
BenchmarkDotNet Results (Lower is Better):

Method                    | Mean       | Allocated
------------------------- |----------- |-----------
EF Core (No Tracking)    | 12.34 ms   | 2.4 MB
EF Core (With Tracking)  | 15.67 ms   | 4.8 MB
Dapper                   | 8.21 ms    | 1.8 MB
Raw Npgsql               | 7.45 ms    | 1.2 MB
```

### Посадковий знак: Введення записів M SK1

```
Method                    | Mean       | Allocated
------------------------- |----------- |-----------
EF Core (SaveChanges)    | 245.3 ms   | 15.2 MB
EF Core (BulkInsert)     | 42.1 ms    | 8.4 MB
Dapper (Loop)            | 189.7 ms   | 2.1 MB
Npgsql COPY              | 18.3 ms    | 0.8 MB
```

### Benchmark: Complex Join Query

```
Method                    | Mean       | Allocated
------------------------- |----------- |-----------
EF Core (Include)        | 28.5 ms    | 5.2 MB
EF Core (Split Query)    | 24.1 ms    | 4.8 MB
Dapper (Multi-Map)       | 16.8 ms    | 3.1 MB
Raw Npgsql               | 15.2 ms    | 2.4 MB
```

### Key Takeaways

1. **Raw Npgsql найшвидший** але потребує найбільшого коду
2. **Dapper дає чудову ефективність** з мінімальними затратами на абстракцію (60-70% швидше, ніж EF CoreM SK1
3. **EF Core no-запитки про відстеження** є прийнятними для більшості сценаріїв
4. **Об 'ємні операції** показувати найбільші розбіжності між показниками (10-13x різницяM SK1
5. **Приділ пам 'яті** слідуйте за схожим шаблоном на час виконання

## Матрица прийняття рішень: Який підхід використовувати

### Використовуйте ядро EF, коли:

- ✅ Збудувати нову програму з еволюціонуючими потребами
- ✅ Домен МSK1направлений дизайн з багатими моделями об 'єктів
- ✅ Вам потрібні міграції та управління схемою
- ✅ Команда почувається краще з C#, ніж з SQL
- ✅ ПрочитатиM SK1 співвідношение запису збалансоване
- ✅ Показові результати в межах 20-50% оптимальних є прийнятними
- ✅ Ви хочете змінити відслідковування і одиниця роботи

Подивіться [Частина 1](/blog/orm-mapping-comparison-part1) для всесторонних базових інструкцій EF.

### Використовуйте Dapper, коли:

- ✅ Функція є важливою, але не критичною
- ✅ У вас є складні питання, які не map LINQ
- ✅ Ви' зручно пишете SQL
- ✅ Потрібно добре контролювати генерацію SQL
- ✅ Працювати з існуючими схемами бази даних
- ✅ ПрочитайтеM SK1важкі навантаження з простими записами
- ✅ Ви хочете мінімальну абстракцію надрахунку

### Використовуйте Raw Npgsql, коли:

- ✅ Максимальна ефективність критична
- ✅ Збудувати високопропускні процесори даних
- ✅ Поглинає роботу з PostgreSQL
- ✅ Пракції на біржових партіях та доведення в vrac
- ✅ Кожна милісекундка і мегабайт мають значення
- ✅ Потрібна абсолютна контроль

### Гібридний підхід коли:

- ✅ Різні частини застосування мають різні потреби
- ✅ Модель CQRS
- ✅ Більшість запитів використовують EF Core,, але деякі потребують сирого SQL
- ✅ Ви хочете поступову міграцію між підходами
- ✅ DużeM SK1 складні застосунки з різними потребами

## Підсумок найкращих практик

### Ogólnі правила

1. **Почнемо з EF Core** для нових проектів, якщо ви не маєте конкретних вимог
2. **Профиль перед оптимізацією** - не ' не припустимо, що вам потрібен Dapper/raw SQL
3. **Використовувати гібридні підходи** - об 'єднує переваги різних інструментів
4. **Залишити логіку доступу до даних ізольованим** - модель репозитори допомагає переключити застосування
5. **Використовувати об 'єднання підключень** - правильно налаштувати для вашого навантаження
6. **Допоможіть використати PostgreSQL** - don ' не абстракціонує потужних можливостей бази даних

### Специальне для дроту

1. **Використовувати параметризовані питання** щоб запобігти введенням SQL
2. **Погляньмо на Caching результатів запиту** для повторних запитів
3. **Використовуйте мульти--картографію** для з 'єднання замість кількох об' єднаних маршрутів
4. **Знову використати підключення** з підключеного басейну
5. **Розгляньмо Dapper.Contrib** для простих операцій CRUD

### Наполегшення розвитку

1. **Індекс ваших запитів** - аналізує повільні питання за допомогою аналізу EXPLAIN
2. **Використовувати підготовані заяви** для повторних запитів
3. **Операції на батареї** коли це можливо
4. **Використовуйте COPY** для bulk inserts в PostgreSQL
5. **Спостерігати за пульсом підключення** - налагодити макс. розмір басейну
6. **Розглянемо, як читати реплікації** для читання-важкі робочі навантаження

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

Вибирати правильний підхід до доступу до даних для вашої .NET aplikacji з PostgreSQL - це не пошук найкращогоM SK2не найкраще" інструмента, а вибір правильного інструменту для ваших конкретних потреб.

- **Корінь EF** (гляньте [Частина 1](/blog/orm-mapping-comparison-part1)) відмінно від швидкого розвитку , моделювання доменів M SK2 і застосування, де продуктивність розробника переважає чисту ефективність
- **Даппер** дає чудову середню основу з майже МСК0 , оптимальною продуктивністю та розумною абстракцією
- **Raw Npgsql** дає максимальное ефективність та контроль для даних- інтенсивних операцій
- **Картування бібліотек** на кшталт Mapster і AutoMapper зменшують клапан, працюючи з доступом до даних на нижньому рівні – -

У практиці, найуспішніші програми часто використовують **гібридний підхід**,, використовуючи переваги кожного інструмента, якщо це потрібно

- Використовувати **Корінь EF** для вашої доменної логіки і записів
- Використовувати **Даппер** для складних розпитів і звітів
- Використовувати **сирого Npgsql** для операцій та аналітики

Ключом є::

1. **Розумійте ваші потреби** - продуктивність МSK1 швидкість розвитку , командні вміння
2. **Профиль вашої програми** - ідентифікувати справжні бар 'єри за bottlenecks , не припущені
3. **Вибирайте прагматично** - використовуйте найпростіший інструмент, який відповідає вашим потребам
4. **Залиштеся гнучкими** - ви можете змішувати підходи в рамках однієї програми

Пам 'ятайте, що передчасна оптимізація - це корень всього зла. МСК1, але так само і створення системи, яка зможе, МСК2, не змінювати масштабу, коли це потрібно. МSK3. Почнемо з простого. ,, вимірюємо ефективність, МSK5, оптимізуємо там, де це важливо.

## Відповіді та подальше читання

**Частина МСК0 цієї серії:**

- [Доступ до даних в .NET-частині 1:](/blog/orm-mapping-comparison-part1)

**офіційна документація:**

- [Dapper GitHub](https://github.com/DapperLib/Dapper)
- [Даппер](https://dapper-tutorial.net/)
- [Документація Npgsql](https://www.npgsql.org/doc/)
- [Допомічник Npgsql ADO.NET](https://www.npgsql.org/doc/basic-usage.html)
- [Сайт Mapster GitHub](https://github.com/MapsterMapper/Mapster)
- [Автоматична документація](https://docs.automapper.org/)
- [Документація PostgreSQL](https://www.postgresql.org/docs/)

**Подібні Articles on This Blog:**

- [Додання кар 'єриエンіті для блогів](/blog/addingentityframeworkforblogpostspt1)
- [Миграції EF - це правильний шлях](/blog/efmigrationstherightway)
- [Полне пошук із ядром EF](/blog/textsearchingpt1)
- [Сучасний CQRS і пошук подій](/blog/moderncqrsandeventsourcing)

---


*Це завершує нашу серію частин про доступ до даних в . NET ! Ми МSK3 обробили все, починаючи з EF Core М SK4 потужних абстракцій і закінчуючи raw SQL M SK5 максимальної продуктивності , практичною інструкцією про поєднання підходів для отримання оптимальних результатів*