Доступ до даних в .NETM SK1 Порівняння ORM та стратегий відображання (Українська (Ukrainian))

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

Wednesday, 03 December 2025

//

20 minute read

Вітаю у частині 2 нашого повного інструкції про доступ до даних в .NETM SK2 В Частина 1, ми дослідили ядро системи Entity Framework в глибині ,, включно з генерацією SQL МSK2 поширені недоліки M SK3 і це критичное попередження прокси та шифрування .

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

  • Даппер: МікроM SK1ORM
  • Raw ADO.NET/Npgsql: Максимальна ефективність та контроль
  • Бібліотеки картографії об 'єктів: Мапстер проти Автомапер
  • Гібридні підходи: Об 'єднання EF Core і Dapper
  • Дослідження ефективності: РеальнийM SK1порівняння з іншими країнами
  • Матрица прийняття рішень: Вибір правильного інструмента для вашого сценарію

Стосунок

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

Даппер є легким, високим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

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

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картографування - ефективного об' єднання і картографування багатьох пов 'язаних об 'єктів

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овані технології дронта

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

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:

// 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:

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а транзакцій:

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 безпосередньо без будь-якого ORM шару.

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

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

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

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

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Послідження продуктивності

Мапстер це швидкий матриці об 'єктів на основі стандарту ,, що використовує генерацію джерел для оптимальної продуктивності

// 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На основі

Автомапер є найпопулярнішою картографією, хоча повільніше, ніж Mapster.

// 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());
    }
}

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

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

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 і ресурсування подій з Мартен, погляньте на мою статтю Сучасний CQRS і пошук подій.

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

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

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

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

  • Різні моделі запису ( оптимізовані для транзакцій та консенсусу
  • Різні моделі для читання ( оптимізовані для запитів та продуктивностіM SK1
  • Використовуйте правильний інструмент для кожної роботи
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

// 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, але потребує інколишньої оптимізації ефективності:

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 для всесторонних базових інструкцій 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) відмінно від швидкого розвитку , моделювання доменів M SK2 і застосування, де продуктивність розробника переважає чисту ефективність
  • Даппер дає чудову середню основу з майже МСК0 , оптимальною продуктивністю та розумною абстракцією
  • Raw Npgsql дає максимальное ефективність та контроль для даних- інтенсивних операцій
  • Картування бібліотек на кшталт Mapster і AutoMapper зменшують клапан, працюючи з доступом до даних на нижньому рівні – -

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

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

Ключом є::

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

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

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

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

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

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


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

Finding related posts...
logo

© 2026 Scott Galloway — Unlicense — All content and source code on this site is free to use, copy, modify, and sell.