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

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

Коли ви будуєте .NET-приложенияM SK1 одне з найважливіших рішень в галузі архітектури, яке ви зробите, – це як керувати доступом до даних та картографією об 'єктів . Екосистема МSK4NET пропонує безліч способів підходу МSK5 від повного МСК6 ORM з функціями до босого М СК7 металеві SQL-виконки М ็ СК8 Кожен підхід має свою власну концепцію M СК9 переваги з точки зору продуктивності М S К 10 продуктивності розробників М Ш К 11 безпека типу M S K 12 і стійкість до підтримки.

В цьому цілковитому інструкції з двох частин, МСК0 і МСК1, ми вивчимо найпопулярніші моделі доступу до даних в МСК3, NET та МСК4. Коли ми використовуємо PostgreSQL з Npgsql у наших прикладах, МSK5, тому що МСК6 - це те, що керує цим блогом. МSK7 - це концепції. МСК8 - це шаблони. , - це торгівля.

**Частина 1 МSK1 цей artykułM SK2** зосереджується на Корі Entity Framework Core, генерації SQL, та поширених помилкахM SK2
**Частина 2** застосуватиме Dapper, сирові ADO.NETM SK2 об 'єктиві картографічні бібліотеки , та гібридні підходи МSK4

## Подібні статті

Якщо ви' зацікавлені в практичних implementaціях стандарту EF Core,(МSK1), погляньте на мої інші статті(M SK2).

- [Доdanie об 'ємної системи для блогових постів (Part МSK1](/blog/addingentityframeworkforblogpostspt1) - Налагодження EF Кора з нуля
- [Миграції EF - це правильний шлях](/blog/efmigrationstherightway) - Як правильно справлятися з міграціями в процесі виробництва
- [Поиск повного тексту (Pt 1)](/blog/textsearchingpt1) - Implementing PostgreSQL full-text search with EF Core
- [Сучасний CQRS і пошук подій](/blog/moderncqrsandeventsourcing) - Заawansовані архітектурні візерунки з EF Core

## Стосунок

## Спектр підходів до доступу до даних

Краєвид доступу до даних .NET можна візуалізувати як спектр

```
Full Abstraction                                      Full Control
     ↓                                                      ↓
[EF Core] → [EF Core Raw SQL] → [Dapper] → [Npgsql ADO.NET]
```

Коли ви рухаєтесь зліва направо, ви отримуєте ефективність та контроль, але втрачаєте зручності і автоматичну функцію . ДозвольтеM SK2 розглянути кожен підхід детальніше

### Порівняння потоку доступу до даних

Це візуальний порівняння того, як кожен підхід працює з типовим запитом.

```mermaid
graph TB
    subgraph "EF Core Flow"
        A1[LINQ Query] -->|Compile| B1[Expression Tree]
        B1 -->|Translate| C1[SQL Query]
        C1 -->|Execute| D1[PostgreSQL]
        D1 -->|Results| E1[DbDataReader]
        E1 -->|Materialize| F1[Tracked Entities]
        F1 -->|Return| G1[Application]
    end

    subgraph "Dapper Flow"
        A2[SQL String] -->|Parameterize| B2[DbCommand]
        B2 -->|Execute| C2[PostgreSQL]
        C2 -->|Results| D2[DbDataReader]
        D2 -->|Map| E2[POCOs]
        E2 -->|Return| F2[Application]
    end

    subgraph "Raw Npgsql Flow"
        A3[SQL + Parameters] -->|Build Command| B3[NpgsqlCommand]
        B3 -->|Execute| C3[PostgreSQL]
        C3 -->|Results| D3[NpgsqlDataReader]
        D3 -->|Manual Mapping| E3[Objects]
        E3 -->|Return| F3[Application]
    end

    style A1 stroke:#2563eb,stroke-width:2px
    style B1 stroke:#2563eb,stroke-width:2px
    style C1 stroke:#2563eb,stroke-width:2px
    style D1 stroke:#2563eb,stroke-width:2px
    style E1 stroke:#2563eb,stroke-width:2px
    style F1 stroke:#2563eb,stroke-width:2px
    style G1 stroke:#2563eb,stroke-width:2px

    style A2 stroke:#059669,stroke-width:2px
    style B2 stroke:#059669,stroke-width:2px
    style C2 stroke:#059669,stroke-width:2px
    style D2 stroke:#059669,stroke-width:2px
    style E2 stroke:#059669,stroke-width:2px
    style F2 stroke:#059669,stroke-width:2px

    style A3 stroke:#dc2626,stroke-width:2px
    style B3 stroke:#dc2626,stroke-width:2px
    style C3 stroke:#dc2626,stroke-width:2px
    style D3 stroke:#dc2626,stroke-width:2px
    style E3 stroke:#dc2626,stroke-width:2px
    style F3 stroke:#dc2626,stroke-width:2px
```

### Досконалість у порівнянні з торгівлею продуктивністю програмістів

```mermaid
graph LR
    A[High Productivity<br/>Low Performance] --> B[EF Core<br/>Full Tracking]
    B --> C[EF Core<br/>No Tracking]
    C --> D[EF Core<br/>Raw SQL]
    D --> E[Dapper]
    E --> F[Raw Npgsql]
    F --> G[Low Productivity<br/>High Performance]

    style A stroke:#2563eb,stroke-width:2px
    style B stroke:#2563eb,stroke-width:2px
    style C stroke:#3b82f6,stroke-width:2px
    style D stroke:#059669,stroke-width:2px
    style E stroke:#059669,stroke-width:2px
    style F stroke:#dc2626,stroke-width:2px
    style G stroke:#dc2626,stroke-width:2px
```

## Кора сутності: Полне-Фетеровані ОРМ

[Кора сутності](https://learn.microsoft.com/en-us/ef/core/) Microsoft ' флагман ORM , що надає повну абстракцію над вашою базою даних МSK2 Він підтримує PostgreSQL через [Npgsql.EntityFrameworkCore.PostgreSQL](https://www.npgsql.org/efcore/) постачальник.

Для практичних вказівок на створення EF Core у вашому проекті, читайте мою статтю [Додання кар 'єриエンіті для блогів](/blog/addingentityframeworkforblogpostspt1).

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

- **Зміна стеження**: Автоматично відстежує зміни об 'єкту і генерує відповідний SQL
- **Миграції**: КодM SK1перше управління схемою та контроль версії МSK2patrz [Миграції EF - це правильний шлях](/blog/efmigrationstherightway))
- **Допомічник LINQ**: Тип-безпекні запити, використовуючи конструкції мови CM SK2
- **Лайзий/Хочний завантаження**: Гибкі стратегії завантаження для пов 'язаних podmiotів
- **Розвинені Funkції PostgreSQL**: ПолнеM SK1 пошук тексту ([погляньте на мою статтю](/blog/textsearchingpt1)), columns JSON , arraysM SK2 range types
- **Перехопці та події**: Помітки розширюваності для перетинання

### Наприклад: Базовий CRUD з ядром EF

```csharp
public class BlogDbContext : DbContext
{
    public DbSet<BlogPost> BlogPosts { get; set; }
    public DbSet<Comment> Comments { get; set; }

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        optionsBuilder.UseNpgsql("Host=localhost;Database=blog;Username=postgres;Password=secret");
    }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        // PostgreSQL-specific: Full-text search
        modelBuilder.Entity<BlogPost>()
            .HasGeneratedTsVectorColumn(
                p => p.SearchVector,
                "english",
                p => new { p.Title, p.Content })
            .HasIndex(p => p.SearchVector)
            .HasMethod("GIN");

        // PostgreSQL array type
        modelBuilder.Entity<BlogPost>()
            .Property(p => p.Tags)
            .HasPostgresArrayConversion(
                tag => tag.ToLowerInvariant(),
                tag => tag);
    }
}

public class BlogPost
{
    public int Id { get; set; }
    public string Title { get; set; }
    public string Content { get; set; }
    public string[] Tags { get; set; }
    public NpgsqlTsVector SearchVector { get; set; }
    public List<Comment> Comments { get; set; }
    public DateTime PublishedDate { get; set; }
}

// Usage
public class BlogService
{
    private readonly BlogDbContext _context;

    public async Task<List<BlogPost>> GetRecentPostsAsync(int count)
    {
        return await _context.BlogPosts
            .Include(p => p.Comments)
            .OrderByDescending(p => p.PublishedDate)
            .Take(count)
            .ToListAsync();
    }

    public async Task<List<BlogPost>> SearchPostsAsync(string searchTerm)
    {
        return await _context.BlogPosts
            .Where(p => p.SearchVector.Matches(EF.Functions.ToTsQuery("english", searchTerm)))
            .ToListAsync();
    }

    public async Task AddPostAsync(BlogPost post)
    {
        _context.BlogPosts.Add(post);
        await _context.SaveChangesAsync();
    }
}
```

### EF Core з RAW SQL

EF Core також підтримує сирові SQL запроси, коли вам потрібно більше контролю:

```csharp
public async Task<List<BlogPost>> GetPostsByComplexCriteriaAsync()
{
    var searchTerm = "postgresql";

    return await _context.BlogPosts
        .FromSqlInterpolated($@"
            SELECT * FROM ""BlogPosts""
            WHERE ""SearchVector"" @@ to_tsquery('english', {searchTerm})
            AND array_length(""Tags"", 1) > 3
            ORDER BY ts_rank(""SearchVector"", to_tsquery('english', {searchTerm})) DESC
        ")
        .ToListAsync();
}

// Or with DbDataReader for maximum control
public async Task<List<PostStatistics>> GetPostStatisticsAsync()
{
    using var command = _context.Database.GetDbConnection().CreateCommand();
    command.CommandText = @"
        SELECT
            DATE_TRUNC('month', ""PublishedDate"") as Month,
            COUNT(*) as PostCount,
            AVG(ARRAY_LENGTH(""Tags"", 1)) as AvgTags
        FROM ""BlogPosts""
        GROUP BY DATE_TRUNC('month', ""PublishedDate"")
        ORDER BY Month DESC";

    await _context.Database.OpenConnectionAsync();

    var results = new List<PostStatistics>();
    using var reader = await command.ExecuteReaderAsync();

    while (await reader.ReadAsync())
    {
        results.Add(new PostStatistics
        {
            Month = reader.GetDateTime(0),
            PostCount = reader.GetInt32(1),
            AverageTags = reader.GetDouble(2)
        });
    }

    return results;
}
```

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

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

- Збудувати нову програму з еволюціонуючими потребами схеми
- Потрібно міцне введення і компіляція-веріалізація запиту на час
- Миграції та версії схем є важливими. (гляньте [мій інструктор по міграції](/blog/efmigrationstherightway))
- Ваша команда надає перевагу роботі з об 'єктами, ніж з SQL
- Ви - МСК0 - використовуєте складні доменні моделі з зв 'язками
- Скорость розвитку більш вирішальна, ніж просто продуктивність
- Вам потрібна перехрестяність-переносимость бази даних M SK1 хоча PostgreSQL-спеціальні характеристики заблоковують вас вМSK3

**❌ Уникати EF-коріння, коли МSK1**

- Максимальна ефективність є вирішальним (wysokaM SK1пропускні інтерфейси API , переробка пакетів )
- У вас є складні, рукиM SK1 впорядковані SQL запроси
- Ваші питання не map well to object graphs
- Потрібно добре контролювати кожен SQL твердження.
- Використовування пам 'яті є критичним обмеженням (вимінювання зворотнього зв' язку
- Ви працюєте з архагічними схемами, які не map to conventions

## Зрозуміння того, що відбувається

Одним з найважливіших аспектів ефективного використання SQL Core є розуміння того, що він генерує.

### Погляньмо на генерований SQL

```csharp
// Enable sensitive data logging and detailed errors (development only!)
optionsBuilder
    .UseNpgsql(connectionString)
    .EnableSensitiveDataLogging()
    .EnableDetailedErrors()
    .LogTo(Console.WriteLine, LogLevel.Information);

// Or use logging to see SQL
public class BlogService
{
    private readonly BlogDbContext _context;
    private readonly ILogger<BlogService> _logger;

    public async Task<List<BlogPost>> GetPostsAsync()
    {
        var query = _context.BlogPosts
            .Where(p => p.PublishedDate > DateTime.UtcNow.AddDays(-30))
            .OrderByDescending(p => p.PublishedDate);

        // View the SQL before execution
        var sql = query.ToQueryString();
        _logger.LogInformation("Executing query: {Sql}", sql);

        return await query.ToListAsync();
    }
}
```

### Наприклад: Просте запитання

**C# LINQM SK1**

```csharp
var recentPosts = await _context.BlogPosts
    .Where(p => p.CategoryId == 5)
    .OrderByDescending(p => p.PublishedDate)
    .Take(10)
    .ToListAsync();
```

**Згенерований SQL ([Кора EF 8+](https://learn.microsoft.com/en-us/ef/core/what-is-new/ef-core-8.0/whatsnew)):**

```sql
SELECT b."Id", b."Title", b."Content", b."CategoryId", b."PublishedDate"
FROM "BlogPosts" AS b
WHERE b."CategoryId" = @__categoryId_0
ORDER BY b."PublishedDate" DESC
LIMIT @__p_1
```

Зверніть увагу на те, як EF Core 8+ генерує чисту , ефективну SQL з правильною параметризацією [Кора EF 10](https://learn.microsoft.com/en-us/ef/core/what-is-new/ef-core-10.0/whatsnew) продовжує цю тенденцію з ще більшими покращеннями.

### До прикладу: З 'єднуйтесь з включним M SK1Before EF Core 5)

**ЦМСК0 КодМSK1**

```csharp
var posts = await _context.BlogPosts
    .Include(p => p.Category)
    .Include(p => p.Comments)
    .ToListAsync();
```

**Старий SQL (EF Кора МSK1 - Cartesian Explosion):**

```sql
SELECT b."Id", b."Title", c."Id", c."Name", cm."Id", cm."Content"
FROM "BlogPosts" AS b
LEFT JOIN "Categories" AS c ON b."CategoryId" = c."Id"
LEFT JOIN "Comments" AS cm ON b."Id" = cm."BlogPostId"
ORDER BY b."Id", c."Id"
```

Це створює **Картеський продукт** - якщо пост має МSK1 коментаріM SK2 ця строка повторюється

### До прикладу: Спілкування запитів (EF Кора 5+)

**C# Код з розділеним питаннямM SK1**

```csharp
var posts = await _context.BlogPosts
    .Include(p => p.Category)
    .Include(p => p.Comments)
    .AsSplitQuery()  // ← This is the key!
    .ToListAsync();
```

**Згенерований SQL (Мільйозові запити):**

```sql
-- Query 1: Get posts and categories
SELECT b."Id", b."Title", b."Content", c."Id", c."Name"
FROM "BlogPosts" AS b
LEFT JOIN "Categories" AS c ON b."CategoryId" = c."Id"

-- Query 2: Get comments for those posts
SELECT cm."Id", cm."Content", cm."BlogPostId"
FROM "Comments" AS cm
INNER JOIN (
    SELECT b."Id"
    FROM "BlogPosts" AS b
) AS t ON cm."BlogPostId" = t."Id"
ORDER BY t."Id"
```

Це виключає картесовий продукт і часто **набагато швидше** для колекцій!

### До прикладу: Filtrовані включають (EF Core 5+)

**ЦМСК0 КодМSK1**

```csharp
var posts = await _context.BlogPosts
    .Include(p => p.Comments.Where(c => c.IsApproved))
    .ToListAsync();
```

**Згенерований SQL:**

```sql
SELECT b."Id", b."Title", b."Content", t."Id", t."Content", t."IsApproved"
FROM "BlogPosts" AS b
LEFT JOIN (
    SELECT c."Id", c."Content", c."IsApproved", c."BlogPostId"
    FROM "Comments" AS c
    WHERE c."IsApproved" = TRUE
) AS t ON b."Id" = t."BlogPostId"
ORDER BY b."Id"
```

### Наприклад: Попит на колону JSON M SK1EF Core 7+)

**ЦМСК0 КодМSK1**

```csharp
public class BlogPost
{
    public int Id { get; set; }
    public string Title { get; set; }
    public PostMetadata Metadata { get; set; }  // Stored as JSONB
}

public class PostMetadata
{
    public bool IsFeatured { get; set; }
    public int ViewCount { get; set; }
    public List<string> RelatedTags { get; set; }
}

// Query JSON properties
var featuredPosts = await _context.BlogPosts
    .Where(p => p.Metadata.IsFeatured)
    .ToListAsync();
```

**Згенерований SQL:**

```sql
SELECT b."Id", b."Title", b."Metadata"
FROM "BlogPosts" AS b
WHERE b."Metadata" ->> 'IsFeatured' = 'true'
```

EF Core 7+ може перетворити доступ до властивостей JSON на оператори PostgreSQL JSON

### До прикладу: Bulk Update (EF Core 7+ ExecuteUpdateM SK3

**Старий шлях (НеефективнийM SK1**

```csharp
var posts = await _context.BlogPosts
    .Where(p => p.CategoryId == 5)
    .ToListAsync();

foreach (var post in posts)
{
    post.IsArchived = true;
}

await _context.SaveChangesAsync();  // Generates N UPDATE statements!
```

**Нова методика (EF Кора МSK1**

```csharp
await _context.BlogPosts
    .Where(p => p.CategoryId == 5)
    .ExecuteUpdateAsync(setters => setters
        .SetProperty(p => p.IsArchived, true));
```

**Згенерований SQL (Single Query!):**

```sql
UPDATE "BlogPosts" AS b
SET "IsArchived" = TRUE
WHERE b."CategoryId" = 5
```

Це **масивна** покращення - один SQL замість NM SK1

### До прикладу: Упаковка видалення (EF Кора 7+)

**Старий шлях:**

```csharp
var oldPosts = await _context.BlogPosts
    .Where(p => p.PublishedDate < DateTime.UtcNow.AddYears(-5))
    .ToListAsync();

_context.BlogPosts.RemoveRange(oldPosts);
await _context.SaveChangesAsync();  // N DELETE statements
```

**Нова дорога:**

```csharp
await _context.BlogPosts
    .Where(p => p.PublishedDate < DateTime.UtcNow.AddYears(-5))
    .ExecuteDeleteAsync();
```

**Згенерований SQL:**

```sql
DELETE FROM "BlogPosts" AS b
WHERE b."PublishedDate" < @__p_0
```

### До прикладу: Комплексна агрегація

**ЦМСК0 КодМSK1**

```csharp
var categoryStats = await _context.Categories
    .Select(c => new CategoryStats
    {
        CategoryName = c.Name,
        PostCount = c.BlogPosts.Count(),
        LatestPostDate = c.BlogPosts.Max(p => p.PublishedDate),
        AverageComments = c.BlogPosts.Average(p => p.Comments.Count)
    })
    .ToListAsync();
```

**Згенерований SQL (EF Core 8+/10):**

```sql
SELECT c."Name" AS "CategoryName",
       COUNT(*)::int AS "PostCount",
       MAX(b."PublishedDate") AS "LatestPostDate",
       COALESCE(AVG((
           SELECT COUNT(*)::int
           FROM "Comments" AS c0
           WHERE b."Id" = c0."BlogPostId"
       ))::double precision, 0.0) AS "AverageComments"
FROM "Categories" AS c
LEFT JOIN "BlogPosts" AS b ON c."Id" = b."CategoryId"
GROUP BY c."Id", c."Name"
```

### Полне пошук PostgreSQL-Text Search

Для глибшого підходу до повного-текстового пошукуM SK1 погляньте на мою статтю [Implementing full-text search with EF Core](/blog/textsearchingpt1).

**ЦМСК0 КодМSK1**

```csharp
var searchResults = await _context.BlogPosts
    .Where(p => p.SearchVector.Matches(EF.Functions.ToTsQuery("english", "postgresql & performance")))
    .OrderByDescending(p => p.SearchVector.Rank(EF.Functions.ToTsQuery("english", "postgresql & performance")))
    .Take(20)
    .ToListAsync();
```

**Згенерований SQL:**

```sql
SELECT b."Id", b."Title", b."Content", b."SearchVector"
FROM "BlogPosts" AS b
WHERE b."SearchVector" @@ to_tsquery('english', @__searchTerm_0)
ORDER BY ts_rank(b."SearchVector", to_tsquery('english', @__searchTerm_0)) DESC
LIMIT 20
```

## ⚠️ Радикальні застереження і падіння

### 1. Зміна витіку пам 'яті від стеження

**Проблема:**

```csharp
// ❌ DANGER: This can cause memory leaks!
public class PostCache
{
    private readonly BlogDbContext _context;
    private List<BlogPost> _cachedPosts;

    public PostCache(BlogDbContext context)
    {
        _context = context;
    }

    public async Task LoadCacheAsync()
    {
        // These entities are now tracked by the context
        _cachedPosts = await _context.BlogPosts.ToListAsync();

        // The DbContext holds references to these entities FOREVER
        // They can never be garbage collected while the context lives!
    }
}
```

**Чому це проблема?**

- Прослідковані об 'єкти залишаються в пам' яті на все життя `DbContext`
- Переслідувач змін зберігає посилання, запобігає збирання сміття
- Довгий-живі контексти (e.gM SK3シングルтониMST4 M ST5 витік пам 'яті
- В ASP контекст .NET Core, за замовчанням об 'єднується (goodM SK3
- Але якщо ви зберігаєте в кэші відслідковані об 'єкти, ви' в небезпеці

**Рішення:**

```csharp
public async Task LoadCacheAsync()
{
    // ✅ Use AsNoTracking() for read-only queries
    _cachedPosts = await _context.BlogPosts
        .AsNoTracking()
        .ToListAsync();

    // Or detach entities after loading
    var posts = await _context.BlogPosts.ToListAsync();
    foreach (var post in posts)
    {
        _context.Entry(post).State = EntityState.Detached;
    }
    _cachedPosts = posts;
}
```

### 2. генерування прокси та небезпеки завантаження

> **🚨 Крітичні попередження: Не використовувати стандартні засоби, якщо ви зберігаєте дані**
> 
> + Caching МSK1 **Гарантований запас пам 'яті**
> 
> Якщо ви зберігаєте уривки DbContext чи об 'єкти, завантажені проксими, включені, ви **УILL** втрача пам 'яті. Механізм прокси підтримує посилання на контекст Db, запобігає збирання сміттяM SK2 Це одна з найпоширеніших і найнебезпечніших помилок у програмі EF CoreMSC3
> 
> **Правило палець**: Включити завжди експлицитно колекції з `.Include()`. Використовуйте прокси тільки тоді, коли ви повністю розумієте компроміси і ніколи не зберігаєте прокси-інтети

**Проблема 1: Клятва номара NM SK1**

```csharp
// ❌ Enable lazy loading
optionsBuilder
    .UseNpgsql(connectionString)
    .UseLazyLoadingProxies();  // Convenient but dangerous!

public class BlogPost
{
    public int Id { get; set; }
    public string Title { get; set; }
    public virtual Category Category { get; set; }  // Virtual = proxy
    public virtual List<Comment> Comments { get; set; }
}

// Somewhere in your code
var posts = await _context.BlogPosts.ToListAsync();

foreach (var post in posts)
{
    Console.WriteLine(post.Category.Name);  // N+1 query here!
    Console.WriteLine(post.Comments.Count);  // Another N+1 query!
}
```

**Що відбувається?**

1. Перше запитання завантаження всіх постів
2. Для **кожен пост**, доступ `Category` запускає пошук в базі даних
3. Для **кожен пост**, доступ `Comments` запускає інший запит
4. Якщо у вас є записи 100 **201 - питання**!

**Проблема 2: Прокси + Caching МSK2 Похибка пам 'яті**

```csharp
// ❌ CATASTROPHIC: Lazy loading proxies + caching
public class BlogPostCache
{
    private static List<BlogPost> _cachedPosts;
    private readonly BlogDbContext _context;

    public BlogPostCache()
    {
        var optionsBuilder = new DbContextOptionsBuilder<BlogDbContext>();
        optionsBuilder
            .UseNpgsql(connectionString)
            .UseLazyLoadingProxies();  // ⚠️ DANGER!

        _context = new BlogDbContext(optionsBuilder.Options);
    }

    public async Task<List<BlogPost>> GetCachedPostsAsync()
    {
        if (_cachedPosts == null)
        {
            // ❌ These proxy entities hold references to _context
            _cachedPosts = await _context.BlogPosts.ToListAsync();
        }
        return _cachedPosts;
    }
}
```

**Чому це катастрофічні?**

- Прокси-елементи зберігають інформацію про `DbContext`
- І `DbContext` зберігає інформацію про всі об 'єкти стеження
- Ваш кэш тепер запобігає тому, щоб цілий граф об 'єктів не збирався як сміття
- Кожного разу, коли ви звертаєтеся до навігаційної властивості,, вона може викликати запитання за допомогою **старі, в кэші**
- Пам 'ять росте безмежно, коли ви завантажуєте більше даних
- Врешті-решт, у вас закінчується пам 'ять або з' ємне підключення

**Рішення: має бути зрозумілим**

```csharp
// ✅ NEVER use lazy loading proxies - always be explicit
optionsBuilder
    .UseNpgsql(connectionString);
    // NO .UseLazyLoadingProxies()!

public class BlogPost
{
    public int Id { get; set; }
    public string Title { get; set; }
    public Category Category { get; set; }  // NOT virtual
    public List<Comment> Comments { get; set; }  // NOT virtual
}

// ✅ Explicit eager loading - you control what's loaded
var posts = await _context.BlogPosts
    .Include(p => p.Category)
    .Include(p => p.Comments)
    .ToListAsync();

// ✅ Or use split queries for better performance
var posts = await _context.BlogPosts
    .Include(p => p.Category)
    .Include(p => p.Comments)
    .AsSplitQuery()
    .ToListAsync();

// ✅ Or use projection to DTOs (best for caching)
var posts = await _context.BlogPosts
    .Select(p => new PostDto
    {
        Title = p.Title,
        CategoryName = p.Category.Name,
        CommentCount = p.Comments.Count
    })
    .ToListAsync();

// ✅ If you MUST cache, use AsNoTracking and no proxies
public class SafeBlogPostCache
{
    private static List<BlogPost> _cachedPosts;
    private readonly IDbContextFactory<BlogDbContext> _contextFactory;

    public async Task<List<BlogPost>> GetCachedPostsAsync()
    {
        if (_cachedPosts == null)
        {
            using var context = await _contextFactory.CreateDbContextAsync();

            _cachedPosts = await context.BlogPosts
                .Include(p => p.Category)
                .Include(p => p.Comments)
                .AsNoTracking()  // Critical for caching!
                .ToListAsync();
        }
        return _cachedPosts;
    }
}
```

**Коли прокси можуть бути прийнятними (Усвідомлюйте компромісні варіанти ):**

Нездібні прокси для завантаження можуть бути прийнятними лише тоді, коли:

1. ✅ Ви маєте **короткий-живий** масштабовані контексти (e.g., за HTTP-запрос
2. ✅ Ви **ніколи** об 'єкти в буфері
3. ✅ ВиM SK1приємно з N+1 результати тесту
4. ✅ ВиM SK1 будуєте прототип і оптимізуєте його пізніше
5. ✅ Ваша команда повністю розуміє наслідки

Але навіть тоді `Include()` це майже завжди кращий вибір, тому що

- Він робить завантаження даних **чітко і очевидно**
- МSK0 **легше оптимізувати** ( ви бачите, що завантаження
- Це **запобігає випадковим N+1 запитам**
- Він працює правильно з Caching і довгими-живими контекстами
- Це - МСК. **запропонований підхід** команда EF Core

### 3. DbContext Проблеми протягом життя

Для більшої інформації про управління DbContext lifetime в produkcji, читайте мою статтю на [Миграції EF - це правильний шлях](/blog/efmigrationstherightway).

**Проблема:**

```csharp
// ❌ NEVER do this - singleton DbContext
public void ConfigureServices(IServiceCollection services)
{
    services.AddSingleton<BlogDbContext>();  // WRONG!
}

// ❌ Also wrong - storing context in static field
public static class DataAccess
{
    private static BlogDbContext _context = new BlogDbContext();

    public static async Task<BlogPost> GetPostAsync(int id)
    {
        return await _context.BlogPosts.FindAsync(id);
    }
}
```

**Чому це не так?**

- `DbContext` є **без потоку-безпечно**
- Конкурентні вимоги спричинять пошкодження даних
- Зміна трекера росте невичерпно
- Вичерпання резервуару підключення
- Залишити дані з кэшу

**Рішення:**

```csharp
// ✅ Use scoped lifetime (default in ASP.NET Core)
public void ConfigureServices(IServiceCollection services)
{
    services.AddDbContext<BlogDbContext>(options =>
        options.UseNpgsql(connectionString));
}

// ✅ Or use DbContext factory for background services
public void ConfigureServices(IServiceCollection services)
{
    services.AddDbContextFactory<BlogDbContext>(options =>
        options.UseNpgsql(connectionString));
}

public class BlogBackgroundService
{
    private readonly IDbContextFactory<BlogDbContext> _contextFactory;

    public async Task ProcessPostsAsync()
    {
        // Create a new context for this operation
        using var context = await _contextFactory.CreateDbContextAsync();

        var posts = await context.BlogPosts.ToListAsync();
        // Process posts...
    }
}
```

### 4. Непередбачуваний включає в себе властивості навігації

**Проблема:**

```csharp
public class BlogPost
{
    public int Id { get; set; }
    public string Title { get; set; }
    public List<Comment> Comments { get; set; }
}

// You query one post...
var post = await _context.BlogPosts.FirstAsync();

// Add a new comment
var newComment = new Comment { Content = "Great post!" };
post.Comments.Add(newComment);

await _context.SaveChangesAsync();

// ❌ EF Core saves the comment, BUT...
// If Comments wasn't loaded, you just lost all existing comments!
// The collection is empty, so EF thinks there are no other comments
```

**Рішення:**

```csharp
// ✅ Always load navigation properties before modifying
var post = await _context.BlogPosts
    .Include(p => p.Comments)
    .FirstAsync(p => p.Id == postId);

post.Comments.Add(newComment);
await _context.SaveChangesAsync();

// Or add directly to the DbSet
_context.Comments.Add(new Comment
{
    BlogPostId = postId,
    Content = "Great post!"
});
await _context.SaveChangesAsync();
```

### 5. Асинк проти синхронізації

**Проблема:**

```csharp
// ❌ Mixing sync and async - deadlock risk!
public async Task<BlogPost> GetPostAsync(int id)
{
    var post = _context.BlogPosts
        .Where(p => p.Id == id)
        .FirstOrDefault();  // Sync method in async context!

    return post;
}

// ❌ Even worse - blocking async code
public BlogPost GetPost(int id)
{
    return _context.BlogPosts
        .FirstOrDefaultAsync(p => p.Id == id)
        .Result;  // DEADLOCK RISK!
}
```

**Рішення:**

```csharp
// ✅ Use async all the way
public async Task<BlogPost> GetPostAsync(int id)
{
    return await _context.BlogPosts
        .FirstOrDefaultAsync(p => p.Id == id);
}

// ✅ Or use sync all the way (not recommended for ASP.NET Core)
public BlogPost GetPost(int id)
{
    return _context.BlogPosts
        .FirstOrDefault(p => p.Id == id);
}
```

## Корінь EF 10: Що МSK1 - це нові та переломні зміни

З [Кора EF 10](https://learn.microsoft.com/en-us/ef/core/what-is-new/ef-core-10.0/whatsnew) випущені разом з .NET 10, є кілька важливих змін, які слід усвідомлювати при модернізації МSK2 Полний список [Переломні зміни в основі EF 10](https://learn.microsoft.com/en-us/ef/core/what-is-new/ef-core-10.0/breaking-changes).

### Побажання часу запуску

**Кора EF 10 вимагає .NET МSK2**. Він не працюватиме на ♫ . ♫ NET ♫ МSK2 ♫ `net10.0` перед оновленням.

### Query-Related Breaking Changes

#### 1. Перевод із параметризованої колекції

Кора EF 10 змінює те, як `Contains()` з в-kolekціями пам 'яті перекладається на SQL. РанішеM SK2 використовували EF Core `OpenJson()` (SQL ServerM SK1 або щось подібне . Тепер він по замовчуванню **tablicи параметрів** які забезпечують кращий Caching плану запитів.

**Вплив**: Ви можете побачити різні SQL генеровані для запитів, як :

```csharp
var ids = new List<int> { 1, 2, 3, 4, 5 };
var posts = await _context.BlogPosts
    .Where(p => ids.Contains(p.Id))
    .ToListAsync();
```

**Кора EF 8/9 (OpenJsonM SK2**

```sql
SELECT b."Id", b."Title"
FROM "BlogPosts" AS b
WHERE b."Id" IN (SELECT value FROM OPENJSON(@__ids_0))
```

**Кора EF 10 МSK1Parameter ArraysM SK2**

```sql
SELECT b."Id", b."Title"
FROM "BlogPosts" AS b
WHERE b."Id" = ANY(@__ids_0)  -- PostgreSQL
-- Or: WHERE b."Id" IN (@__ids_0_0, @__ids_0_1, @__ids_0_2, ...) -- SQL Server
```

**Якщо ви відчуваєте регресії**, повернутися до старої поведінкиM SK1

```csharp
// SQL Server
optionsBuilder.UseSqlServer(connectionString,
    o => o.UseParameterizedCollectionMode(ParameterTranslationMode.Constant));

// PostgreSQL - generally parameter arrays work well, but you can opt out if needed
```

#### 2. СтворитиAktualізовану Асинку Зміну Signature

І `ExecuteUpdateAsync` Signature has changed to support non-expression lambdas . This is more flexible but **розрив коду, який запрограмував дерева вираження**:

**Старий спосіб (EF Кора МSK1**

```csharp
// This still works
await _context.BlogPosts
    .Where(p => p.CategoryId == 5)
    .ExecuteUpdateAsync(setters => setters
        .SetProperty(p => p.IsArchived, true));
```

**Нова технологія в основі EF 10 - Не МSK2 вираження Lambdas МSK3**

```csharp
// Now you can include custom logic!
await _context.BlogPosts
    .Where(p => p.CategoryId == 5)
    .ExecuteUpdateAsync(setters =>
    {
        setters.SetProperty(p => p.IsArchived, true);
        setters.SetProperty(p => p.UpdatedAt, DateTime.UtcNow);
        // Can now include conditional logic, loops, etc.
    });
```

#### 3. Назви колони складного типу

EF Core 10 змінює назву вбудованих колон складного типу, щоб запобігти зруйнуванню даних

**Кора EF 9:**

```
NestedComplex_Property
```

**Кора EF 10:**

```
OuterComplex_NestedComplex_Property
```

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

```csharp
modelBuilder.Entity<Order>()
    .ComplexProperty(o => o.ShippingAddress)
    .Property(a => a.Street)
    .HasColumnName("ShippingAddress_Street"); // Explicit name
```

### SQL Server / А Azure SQL Specific Changes

#### Початковий тип даних JSON

Для Azure SQL Database або SQL Server 2025 (рівномір коміpatibility МSK2 EF Core МSK3 domyślnie для нового нативного `JSON` тип даних замість `NVARCHAR(MAX)`.

**Виключитися** (if you need backwards compatibility ):

```csharp
optionsBuilder.UseAzureSql(connectionString,
    o => o.UseCompatibilityLevel(160)); // Use old NVARCHAR behavior
```

### Обновлення списку перевірок

Підключення з модуля EF Core 8/9 до модуля ES Core ≥10:

1. ✅ Обновляти цільову структуру до `net10.0`
2. ✅ Обновлюйте все `Microsoft.EntityFrameworkCore.*` пакети на 10.x
3. ✅ Обновлення `Npgsql.EntityFrameworkCore.PostgreSQL` до 10.x
4. ✅ Проаналізувати питання за допомогою `Contains()` з колекціями для змін в показниках
5. ✅ Тестувати будь-який код, який програмовано будується `ExecuteUpdateAsync` вирази
6. ✅ Проверяйте назви столбів складного типу, якщо використовує вбудовані складні типи
7. ✅ Проаналізувати використання столбца SQL Server JSON, якщо ви використовуєте Azure SQL

### Що нового? '

- **Удосконалений переклад LINQ**: Краще генерувати SQL для складних запитів
- **Неможливі- lambdas вираження в ExecuteUpdateAsync**: Більша гнучкість у великих обсягах оновлень
- **Краще використання параметрів**: Удосконалена кэшування плану запитів
- **Удосконалена підтримка JSON**: Тип нативного JSON на сервері SQL 2025
- **покращення ефективності**: Швидша матеріалізація і змінна стеження

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

- **Результати тесту**: 20-50% накладні витрати порівняно з Dapper для простих запитів
- **Використовування пам 'яті**: Вищий через зміну відстеження та генерування прокси
- **Перше запитання**: Повільно МSK1Compilation and Caching queryM SK2
- **Наступні пошуки**: Краще через компілірований кэш запитів
- **Вставляє/Aktualізації**: Автоматичне стеження за змінами доповнює накладні витрати
- **Об 'ємні операції**: Поганий результат з початковими методами [EFCore.BulkExtensions](https://github.com/borisdj/EFCore.BulkExtensions) або ExecuteUpdate/ExecuteDelete в EF Core 7+)

## Найкращі практики для центру EF

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

1. **Використовуйте AsNoTracking()** для чтення- тільки запитів, щоб зменшити зайву пам 'ять
2. **Уникніть N+1 запитів** - використання `Include()` або розділити питання відповідно
3. **Використовувати складання запитів** для повторюваних шаблонів
4. **Розгляньмо AsSplitQuery()** для комплексу включно, щоб уникнути картеських продуктів
5. **Використовувати байтинг** для декількох вставок/updates
6. **Проект для конструкторів** рано зменшити використання даних та пам 'яті
7. **Вказівник ExecuteUpdate/ExecuteDelete** (EF Кора 7+) для переробки
8. **Повсякчас записувати і перевіряти генеровані SQL** в розробці

### Працюючи з PostgreSQL

1. **Використовуйте повний-текстовий пошук** характеристики ([мій інструктор](/blog/textsearchingpt1)) замість `LIKE` запитів
2. **Лівержування столбців JSONB** для elasтичного schema-без даних
3. **Використовувати типи массивів** для збирання всередині інституцій
4. **Настройка об 'єднання зв' язків** відповідно до вашого навантаження
5. **Індекс вашого `tsvector` столбці** з індексами GIN
6. **Використовувати типи діапазону** для часових поясів data/

## З 'являється частина 2

У наступному artykule ми дослідимо

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

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

- [Корінна документація](https://learn.microsoft.com/en-us/ef/core/)
- [Допомічник сутності Framework Npgsql](https://www.npgsql.org/efcore/)
- [Корінна ефективність EF](https://learn.microsoft.com/en-us/ef/core/performance/)
- [Що нового в основі EF 10](https://learn.microsoft.com/en-us/ef/core/what-is-new/ef-core-10.0/whatsnew)
- [Переломні зміни в основі EF 10](https://learn.microsoft.com/en-us/ef/core/what-is-new/ef-core-10.0/breaking-changes)
- [Що нового в основі EF 8](https://learn.microsoft.com/en-us/ef/core/what-is-new/ef-core-8.0/whatsnew)
- [Документація PostgreSQL](https://www.postgresql.org/docs/)

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

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

---


*У частині "2," ми МSK1 зануримося в Dapper , ,", raw Npgsql і ",", щоб дослідити, як об 'єднати кілька підходів для оптимальної продуктивності та підтримливості .*