This is a viewer only at the moment see the article on how this works.
To update the preview hit Ctrl-Alt-R (or ⌘-Alt-R on Mac) or Enter to refresh. The Save icon lets you save the markdown file to disk
This is a preview from the server running through my markdig pipeline
Доступ до даних в .NETM SK1 Порівняння ORM та стратегий відображання
Wednesday, 03 December 2025
Вітаю у частині 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
- Raw Npgsql найшвидший але потребує найбільшого коду
- Dapper дає чудову ефективність з мінімальними затратами на абстракцію (60-70% швидше, ніж EF CoreM SK1
- EF Core no-запитки про відстеження є прийнятними для більшості сценаріїв
- Об 'ємні операції показувати найбільші розбіжності між показниками (10-13x різницяM SK1
- Приділ пам 'яті слідуйте за схожим шаблоном на час виконання
Матрица прийняття рішень: Який підхід використовувати
Використовуйте ядро 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і правила
- Почнемо з EF Core для нових проектів, якщо ви не маєте конкретних вимог
- Профиль перед оптимізацією - не ' не припустимо, що вам потрібен Dapper/raw SQL
- Використовувати гібридні підходи - об 'єднує переваги різних інструментів
- Залишити логіку доступу до даних ізольованим - модель репозитори допомагає переключити застосування
- Використовувати об 'єднання підключень - правильно налаштувати для вашого навантаження
- Допоможіть використати PostgreSQL - don ' не абстракціонує потужних можливостей бази даних
Специальне для дроту
- Використовувати параметризовані питання щоб запобігти введенням SQL
- Погляньмо на Caching результатів запиту для повторних запитів
- Використовуйте мульти--картографію для з 'єднання замість кількох об' єднаних маршрутів
- Знову використати підключення з підключеного басейну
- Розгляньмо Dapper.Contrib для простих операцій CRUD
Наполегшення розвитку
- Індекс ваших запитів - аналізує повільні питання за допомогою аналізу EXPLAIN
- Використовувати підготовані заяви для повторних запитів
- Операції на батареї коли це можливо
- Використовуйте COPY для bulk inserts в PostgreSQL
- Спостерігати за пульсом підключення - налагодити макс. розмір басейну
- Розглянемо, як читати реплікації для читання-важкі робочі навантаження
Завершення
Вибирати правильний підхід до доступу до даних для вашої .NET aplikacji з PostgreSQL - це не пошук найкращогоM SK2не найкраще" інструмента, а вибір правильного інструменту для ваших конкретних потреб.
- Корінь EF (гляньте Частина 1) відмінно від швидкого розвитку , моделювання доменів M SK2 і застосування, де продуктивність розробника переважає чисту ефективність
- Даппер дає чудову середню основу з майже МСК0 , оптимальною продуктивністю та розумною абстракцією
- Raw Npgsql дає максимальное ефективність та контроль для даних- інтенсивних операцій
- Картування бібліотек на кшталт Mapster і AutoMapper зменшують клапан, працюючи з доступом до даних на нижньому рівні – -
У практиці, найуспішніші програми часто використовують гібридний підхід,, використовуючи переваги кожного інструмента, якщо це потрібно
- Використовувати Корінь EF для вашої доменної логіки і записів
- Використовувати Даппер для складних розпитів і звітів
- Використовувати сирого Npgsql для операцій та аналітики
Ключом є::
- Розумійте ваші потреби - продуктивність МSK1 швидкість розвитку , командні вміння
- Профиль вашої програми - ідентифікувати справжні бар 'єри за bottlenecks , не припущені
- Вибирайте прагматично - використовуйте найпростіший інструмент, який відповідає вашим потребам
- Залиштеся гнучкими - ви можете змішувати підходи в рамках однієї програми
Пам 'ятайте, що передчасна оптимізація - це корень всього зла. МСК1, але так само і створення системи, яка зможе, МСК2, не змінювати масштабу, коли це потрібно. МSK3. Почнемо з простого. ,, вимірюємо ефективність, МSK5, оптимізуємо там, де це важливо.
Відповіді та подальше читання
Частина МСК0 цієї серії:
офіційна документація:
- Dapper GitHub
- Даппер
- Документація Npgsql
- Допомічник Npgsql ADO.NET
- Сайт Mapster GitHub
- Автоматична документація
- Документація PostgreSQL
Подібні Articles on This Blog:
- Додання кар 'єриエンіті для блогів
- Миграції EF - це правильний шлях
- Полне пошук із ядром EF
- Сучасний CQRS і пошук подій
Це завершує нашу серію частин про доступ до даних в . NET ! Ми МSK3 обробили все, починаючи з EF Core М SK4 потужних абстракцій і закінчуючи raw SQL M SK5 максимальної продуктивності , практичною інструкцією про поєднання підходів для отримання оптимальних результатів