// 블로그 포스트와 작성자 정보를 가져오는 코드
var posts = await context.Posts.ToListAsync();

foreach (var post in posts)
{
    // 각 포스트마다 작성자 정보를 개별적으로 조회!
    Console.WriteLine($"{post.Title} - {post.Author.Name}");
}

// 실행되는 쿼리:
// 1. SELECT * FROM Posts (1개의 쿼리)
// 2. SELECT * FROM Authors WHERE Id = 1 (N개의 쿼리)
// 3. SELECT * FROM Authors WHERE Id = 2
// ... 총 N+1개의 쿼리 실행!

// Include를 사용한 Eager Loading
var posts = await context.Posts
    .Include(p => p.Author)  // 작성자 정보를 함께 로드
    .ToListAsync();

foreach (var post in posts)
{
    Console.WriteLine($"{post.Title} - {post.Author.Name}");
}

// 실행되는 쿼리:
// SELECT p.*, a.* FROM Posts p 
// LEFT JOIN Authors a ON p.AuthorId = a.Id
// 단 1개의 쿼리로 모든 데이터를 가져옴!

var posts = await context.Posts
    .Include(p => p.Author)           // 작성자
    .Include(p => p.Comments)         // 댓글들
        .ThenInclude(c => c.Author)   // 각 댓글의 작성자
    .Include(p => p.Tags)             // 태그들
    .ToListAsync();

// ThenInclude는 Include한 엔티티의 하위 관계를 로드할 때 사용해

var posts = await context.Posts
    .Include(p => p.Comments)
    .Include(p => p.Tags)
    .AsSplitQuery()  // 각 Include를 별도의 쿼리로 분리
    .ToListAsync();

// 카티션 곱 문제를 피하면서 효율적으로 데이터를 가져와

// 기본적으로 변경 추적이 활성화됨
var products = await context.Products
    .Where(p => p.Price > 1000)
    .ToListAsync();

// EF Core는 각 Product 엔티티의 원본 값을 메모리에 저장
// 메모리 사용량 증가 + 처리 시간 증가

// 읽기 전용 쿼리에는 AsNoTracking 사용
var products = await context.Products
    .AsNoTracking()  // 변경 추적 비활성화
    .Where(p => p.Price > 1000)
    .ToListAsync();

// 메모리 사용량 감소 + 처리 속도 향상 (약 30-50% 빨라짐!)

// DbContext 설정에서 전역으로 NoTracking 설정
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
    optionsBuilder
        .UseSqlServer(connectionString)
        .UseQueryTrackingBehavior(QueryTrackingBehavior.NoTracking);
}

// 이제 모든 쿼리가 기본적으로 NoTracking
// 필요한 경우에만 .AsTracking()을 사용하면 돼

// 전체 엔티티를 가져온 후 필요한 필드만 사용
var users = await context.Users
    .Include(u => u.Profile)
    .Include(u => u.Orders)
    .ToListAsync();

var userNames = users.Select(u => u.Name).ToList();

// 문제점:
// 1. 불필요한 모든 컬럼을 DB에서 가져옴
// 2. 관련 엔티티까지 모두 로드
// 3. 메모리에 전체 객체를 생성
// 4. 결국 Name만 사용하는데 엄청난 낭비!

// 필요한 컬럼만 선택해서 가져오기
var userNames = await context.Users
    .Select(u => u.Name)
    .ToListAsync();

// 또는 여러 필드가 필요하다면 익명 타입 사용
var userInfo = await context.Users
    .Select(u => new 
    {
        u.Id,
        u.Name,
        u.Email,
        OrderCount = u.Orders.Count()
    })
    .ToListAsync();

// 실행되는 SQL:
// SELECT Id, Name, Email, COUNT(Orders.Id) FROM Users
// 딱 필요한 것만 가져와!

// DTO 클래스 정의
public class UserSummaryDto
{
    public int Id { get; set; }
    public string Name { get; set; }
    public string Email { get; set; }
    public int OrderCount { get; set; }
    public DateTime LastLoginDate { get; set; }
}

// DTO로 프로젝션
var userSummaries = await context.Users
    .Select(u => new UserSummaryDto
    {
        Id = u.Id,
        Name = u.Name,
        Email = u.Email,
        OrderCount = u.Orders.Count(),
        LastLoginDate = u.LastLogin
    })
    .ToListAsync();

// 장점:
// 1. 타입 안정성 확보
// 2. IntelliSense 지원
// 3. 재사용 가능
// 4. API 응답 모델로 바로 사용 가능

var orderDetails = await context.Orders
    .Where(o => o.OrderDate >= DateTime.Now.AddMonths(-1))
    .Select(o => new OrderDetailDto
    {
        OrderId = o.Id,
        OrderDate = o.OrderDate,
        CustomerName = o.Customer.Name,
        CustomerEmail = o.Customer.Email,
        TotalAmount = o.OrderItems.Sum(oi => oi.Quantity * oi.UnitPrice),
        ItemCount = o.OrderItems.Count(),
        Products = o.OrderItems.Select(oi => new ProductSummaryDto
        {
            ProductName = oi.Product.Name,
            Quantity = oi.Quantity,
            Price = oi.UnitPrice
        }).ToList(),
        Status = o.Status
    })
    .ToListAsync();

// 이렇게 하면 복잡한 데이터도 한 번의 쿼리로 효율적으로 가져올 수 있어!

// 전체 데이터를 한 번에 가져오기 (위험!)
var allProducts = await context.Products
    .OrderBy(p => p.Name)
    .ToListAsync();

// 10만 개의 상품이 있다면?
// - 메모리 폭발 💥
// - 응답 시간 폭발 💥
// - 데이터베이스 부하 폭발 💥

// 페이지 번호와 페이지 크기 정의
int pageNumber = 1;  // 첫 번째 페이지
int pageSize = 20;   // 페이지당 20개

var products = await context.Products
    .OrderBy(p => p.Name)  // 정렬은 필수!
    .Skip((pageNumber - 1) * pageSize)  // 건너뛸 개수
    .Take(pageSize)  // 가져올 개수
    .ToListAsync();

// SQL로 변환되면:
// SELECT * FROM Products 
// ORDER BY Name 
// OFFSET 0 ROWS FETCH NEXT 20 ROWS ONLY

// 페이징 확장 메서드
public static class QueryableExtensions
{
    public static IQueryable<t> Paginate<t>(
        this IQueryable<t> query, 
        int pageNumber, 
        int pageSize)
    {
        return query
            .Skip((pageNumber - 1) * pageSize)
            .Take(pageSize);
    }
}

// 사용 예시
var products = await context.Products
    .OrderBy(p => p.Name)
    .Paginate(pageNumber: 2, pageSize: 20)
    .ToListAsync();

// 훨씬 깔끔하지? 😊</t></t></t>

// 페이징 결과를 담을 클래스
public class PagedResult<t>
{
    public List<t> Items { get; set; }
    public int TotalCount { get; set; }
    public int PageNumber { get; set; }
    public int PageSize { get; set; }
    public int TotalPages => (int)Math.Ceiling(TotalCount / (double)PageSize);
    public bool HasPreviousPage => PageNumber > 1;
    public bool HasNextPage => PageNumber < TotalPages;
}

// 페이징 헬퍼 메서드
public static async Task<pagedresult<t>> ToPagedResultAsync<t>(
    this IQueryable<t> query,
    int pageNumber,
    int pageSize)
{
    var totalCount = await query.CountAsync();  // 전체 개수 조회
    
    var items = await query
        .Skip((pageNumber - 1) * pageSize)
        .Take(pageSize)
        .ToListAsync();
    
    return new PagedResult<t>
    {
        Items = items,
        TotalCount = totalCount,
        PageNumber = pageNumber,
        PageSize = pageSize
    };
}

// 사용 예시
var result = await context.Products
    .Where(p => p.IsActive)
    .OrderBy(p => p.Name)
    .ToPagedResultAsync(pageNumber: 1, pageSize: 20);

Console.WriteLine($"총 {result.TotalCount}개 중 {result.Items.Count}개 표시");
Console.WriteLine($"전체 {result.TotalPages}페이지 중 {result.PageNumber}페이지");</t></t></t></pagedresult<t></t></t>

// 커서 기반 페이징 (마지막으로 본 ID 기준)
public async Task<list<product>> GetProductsAfterCursor(
    int? lastSeenId, 
    int pageSize = 20)
{
    var query = context.Products.AsQueryable();
    
    if (lastSeenId.HasValue)
    {
        // 마지막으로 본 ID 이후의 데이터만 가져오기
        query = query.Where(p => p.Id > lastSeenId.Value);
    }
    
    return await query
        .OrderBy(p => p.Id)
        .Take(pageSize)
        .ToListAsync();
}

// 사용 예시
var firstPage = await GetProductsAfterCursor(null, 20);
var secondPage = await GetProductsAfterCursor(firstPage.Last().Id, 20);

// 장점:
// 1. Skip을 사용하지 않아 대용량 데이터에서도 빠름
// 2. 실시간으로 데이터가 추가되어도 중복이나 누락 없음
// 3. 무한 스크롤 구현에 최적화</list<product>

// Fluent API를 사용한 인덱스 정의
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    // 단일 컬럼 인덱스
    modelBuilder.Entity<product>()
        .HasIndex(p => p.Name)
        .HasDatabaseName("IX_Product_Name");
    
    // 복합 인덱스 (여러 컬럼)
    modelBuilder.Entity<order>()
        .HasIndex(o => new { o.CustomerId, o.OrderDate })
        .HasDatabaseName("IX_Order_Customer_Date");
    
    // 유니크 인덱스
    modelBuilder.Entity<user>()
        .HasIndex(u => u.Email)
        .IsUnique()
        .HasDatabaseName("IX_User_Email_Unique");
    
    // 필터링된 인덱스 (조건부 인덱스)
    modelBuilder.Entity<product>()
        .HasIndex(p => p.Price)
        .HasFilter("[IsActive] = 1")  // 활성 상품만 인덱싱
        .HasDatabaseName("IX_Product_Price_Active");
}</product></user></order></product>

// 엔티티 클래스에 직접 정의
[Index(nameof(Email), IsUnique = true)]
[Index(nameof(LastName), nameof(FirstName))]  // 복합 인덱스
public class User
{
    public int Id { get; set; }
    public string Email { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public DateTime CreatedAt { get; set; }
}

// 간단한 경우에는 이 방법이 더 직관적이야!

// SQL Server에서 실행 계획 확인
// EF Core 로깅 활성화
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
    optionsBuilder
        .UseSqlServer(connectionString)
        .LogTo(Console.WriteLine, LogLevel.Information)
        .EnableSensitiveDataLogging();  // 파라미터 값도 로깅
}

// 실행되는 SQL을 확인하고, SSMS에서 실행 계획을 분석
// Index Seek vs Table Scan을 비교해봐
// Index Seek이면 인덱스가 잘 작동하는 거야!

// 1,000개의 상품 가격을 10% 인상하는 경우
var products = await context.Products
    .Where(p => p.CategoryId == 5)
    .ToListAsync();

foreach (var product in products)
{
    product.Price *= 1.1m;
    await context.SaveChangesAsync();  // 매번 DB 왕복! 😱
}

// 문제점:
// 1. 1,000번의 UPDATE 쿼리 실행
// 2. 1,000번의 네트워크 왕복
// 3. 엄청나게 느림 (수십 초 소요)

// SaveChanges를 루프 밖으로 이동
var products = await context.Products
    .Where(p => p.CategoryId == 5)
    .ToListAsync();

foreach (var product in products)
{
    product.Price *= 1.1m;
}

await context.SaveChangesAsync();  // 한 번만 호출!

// EF Core는 변경사항을 모아서 배치로 처리
// 훨씬 빠름! (몇 초 이내)

// ExecuteUpdate를 사용한 직접 업데이트
await context.Products
    .Where(p => p.CategoryId == 5)
    .ExecuteUpdateAsync(setters => setters
        .SetProperty(p => p.Price, p => p.Price * 1.1m)
        .SetProperty(p => p.UpdatedAt, DateTime.UtcNow));

// 실행되는 SQL:
// UPDATE Products 
// SET Price = Price * 1.1, UpdatedAt = GETUTCDATE()
// WHERE CategoryId = 5

// 장점:
// 1. 단 1개의 UPDATE 쿼리로 모든 행 업데이트
// 2. 메모리에 데이터를 로드하지 않음
// 3. 엄청나게 빠름! (밀리초 단위)

// 오래된 로그 데이터 삭제
await context.Logs
    .Where(l => l.CreatedAt < DateTime.UtcNow.AddMonths(-6))
    .ExecuteDeleteAsync();

// 실행되는 SQL:
// DELETE FROM Logs 
// WHERE CreatedAt < @date

// 기존 방식보다 수백 배 빠를 수 있어!

// 대량 데이터 삽입 시 최적화
var newProducts = new List<product>();
for (int i = 0; i < 10000; i++)
{
    newProducts.Add(new Product 
    { 
        Name = $"Product {i}",
        Price = i * 10
    });
}

// AddRange를 사용하면 배치로 처리됨
context.Products.AddRange(newProducts);
await context.SaveChangesAsync();

// 추가 최적화: AutoDetectChanges 비활성화
context.ChangeTracker.AutoDetectChangesEnabled = false;
context.Products.AddRange(newProducts);
context.ChangeTracker.DetectChanges();  // 한 번만 호출
await context.SaveChangesAsync();
context.ChangeTracker.AutoDetectChangesEnabled = true;

// 성능이 2-3배 향상될 수 있어!</product>

// Include를 사용해서 관련 데이터를 미리 로드
var posts = await context.Posts
    .Include(p => p.Author)
    .Include(p => p.Comments)
    .ToListAsync();

// 장점: 한 번의 쿼리로 모든 데이터 로드, N+1 문제 방지
// 단점: 필요 없는 데이터까지 로드할 수 있음

// 지연 로딩 활성화 (프록시 사용)
// NuGet: Microsoft.EntityFrameworkCore.Proxies 필요
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
    optionsBuilder
        .UseSqlServer(connectionString)
        .UseLazyLoadingProxies();  // 지연 로딩 활성화
}

// 엔티티의 네비게이션 속성을 virtual로 선언
public class Post
{
    public int Id { get; set; }
    public string Title { get; set; }
    public virtual Author Author { get; set; }  // virtual 키워드!
    public virtual ICollection<comment> Comments { get; set; }
}

// 사용
var post = await context.Posts.FirstAsync();
var authorName = post.Author.Name;  // 이 시점에 Author 로드!

// 장점: 필요할 때만 로드, 코드가 간단
// 단점: N+1 문제 발생 가능, 예측하기 어려움</comment>

// 필요한 시점에 명시적으로 로드
var post = await context.Posts.FirstAsync();

// 나중에 Author가 필요해졌을 때
await context.Entry(post)
    .Reference(p => p.Author)  // 단일 참조
    .LoadAsync();

// 컬렉션 로드
await context.Entry(post)
    .Collection(p => p.Comments)  // 컬렉션
    .LoadAsync();

// 필터링하면서 로드
await context.Entry(post)
    .Collection(p => p.Comments)
    .Query()
    .Where(c => c.IsApproved)
    .LoadAsync();

// 장점: 세밀한 제어 가능, 조건부 로딩 가능
// 단점: 코드가 복잡해질 수 있음

// 블로그 포스트와 함께 댓글(10개), 태그(5개)를 로드
var posts = await context.Posts
    .Include(p => p.Comments)  // 10개
    .Include(p => p.Tags)      // 5개
    .ToListAsync();

// 실행되는 SQL:
// SELECT * FROM Posts p
// LEFT JOIN Comments c ON p.Id = c.PostId
// LEFT JOIN Tags t ON p.Id = t.PostId

// 문제: 결과 행 수가 1 * 10 * 5 = 50행!
// 실제로는 1개의 포스트인데 50행을 전송하고 처리해야 함
// 네트워크 트래픽 증가 + 메모리 낭비

// 쿼리를 분할해서 실행
var posts = await context.Posts
    .Include(p => p.Comments)
    .Include(p => p.Tags)
    .AsSplitQuery()  // 쿼리 분할!
    .ToListAsync();

// 실행되는 SQL (3개의 쿼리로 분할):
// 1. SELECT * FROM Posts
// 2. SELECT * FROM Comments WHERE PostId IN (...)
// 3. SELECT * FROM Tags WHERE PostId IN (...)

// 각 쿼리가 독립적으로 실행되어 카티션 곱 문제 해결!
// 전송되는 데이터: 1 + 10 + 5 = 16행 (50행 → 16행)

// DbContext 설정에서 기본값을 SplitQuery로 변경
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
    optionsBuilder
        .UseSqlServer(connectionString)
        .UseQuerySplittingBehavior(QuerySplittingBehavior.SplitQuery);
}

// 이제 기본적으로 쿼리가 분할됨
// 필요한 경우 .AsSingleQuery()로 단일 쿼리 사용 가능

// FromSqlRaw를 사용한 원시 SQL
var products = await context.Products
    .FromSqlRaw(@"
        SELECT p.* 
        FROM Products p
        INNER JOIN Categories c ON p.CategoryId = c.Id
        WHERE c.Name = {0} AND p.Price > {1}
        ORDER BY p.SalesCount DESC",
        categoryName, minPrice)
    .ToListAsync();

// 장점:
// 1. 복잡한 쿼리를 직접 제어
// 2. 데이터베이스 특화 기능 사용 가능
// 3. 성능 최적화가 쉬움

// 주의: SQL 인젝션 방지를 위해 파라미터 사용 필수!

// 저장 프로시저 호출
var result = await context.Products
    .FromSqlRaw("EXEC GetTopSellingProducts @CategoryId = {0}", categoryId)
    .ToListAsync();

// ExecuteSqlRaw로 업데이트/삭제 (반환값 없음)
var affectedRows = await context.Database
    .ExecuteSqlRawAsync(@"
        UPDATE Products 
        SET Price = Price * 1.1 
        WHERE CategoryId = {0}", categoryId);

// 복잡한 조인이 필요한 경우 데이터베이스 뷰 생성
// SQL:
// CREATE VIEW vw_ProductSummary AS
// SELECT 
//     p.Id, p.Name, p.Price,
//     c.Name AS CategoryName,
//     COUNT(r.Id) AS ReviewCount,
//     AVG(r.Rating) AS AverageRating
// FROM Products p
// LEFT JOIN Categories c ON p.CategoryId = c.Id
// LEFT JOIN Reviews r ON p.Id = r.ProductId
// GROUP BY p.Id, p.Name, p.Price, c.Name

// EF Core에서 뷰를 엔티티로 매핑
[Keyless]  // 뷰는 보통 기본 키가 없음
public class ProductSummary
{
    public int Id { get; set; }
    public string Name { get; set; }
    public decimal Price { get; set; }
    public string CategoryName { get; set; }
    public int ReviewCount { get; set; }
    public double AverageRating { get; set; }
}

// OnModelCreating에서 뷰 매핑
modelBuilder.Entity<productsummary>()
    .ToView("vw_ProductSummary")
    .HasNoKey();

// 사용 - 복잡한 조인 없이 간단하게!
var summaries = await context.Set<productsummary>()
    .Where(s => s.AverageRating >= 4.0)
    .ToListAsync();</productsummary></productsummary>

// 자주 계산되는 값은 계산된 컬럼으로 저장
public class Order
{
    public int Id { get; set; }
    public decimal Subtotal { get; set; }
    public decimal TaxRate { get; set; }
    
    // 계산된 컬럼 (데이터베이스에서 자동 계산)
    public decimal TotalAmount { get; set; }
}

// OnModelCreating에서 설정
modelBuilder.Entity<order>()
    .Property(o => o.TotalAmount)
    .HasComputedColumnSql("[Subtotal] * (1 + [TaxRate])");

// 이제 TotalAmount는 자동으로 계산됨
// 쿼리할 때마다 계산할 필요 없음!

// 영구 저장 옵션 (stored)
modelBuilder.Entity<order>()
    .Property(o => o.TotalAmount)
    .HasComputedColumnSql("[Subtotal] * (1 + [TaxRate])", stored: true);
// stored: true면 값이 물리적으로 저장되어 더 빠름</order></order>

// 읽기/쓰기 분리 아키텍처
public class MyDbContext : DbContext
{
    private readonly bool _isReadOnly;
    
    public MyDbContext(DbContextOptions<mydbcontext> options, bool isReadOnly = false) 
        : base(options)
    {
        _isReadOnly = isReadOnly;
        
        if (_isReadOnly)
        {
            // 읽기 전용 모드에서는 변경 추적 비활성화
            ChangeTracker.QueryTrackingBehavior = QueryTrackingBehavior.NoTracking;
            ChangeTracker.AutoDetectChangesEnabled = false;
        }
    }
}

// DI 등록
services.AddDbContext<mydbcontext>(options =>
    options.UseSqlServer(writeConnectionString));

services.AddDbContext<mydbcontext>(options =>
    options.UseSqlServer(readReplicaConnectionString),
    contextLifetime: ServiceLifetime.Scoped,
    optionsLifetime: ServiceLifetime.Singleton);

// 사용
public class ProductService
{
    private readonly MyDbContext _writeContext;
    private readonly MyDbContext _readContext;
    
    public ProductService(
        [FromKeyedServices("write")] MyDbContext writeContext,
        [FromKeyedServices("read")] MyDbContext readContext)
    {
        _writeContext = writeContext;
        _readContext = readContext;
    }
    
    // 읽기는 복제본에서
    public async Task<list<product>> GetProductsAsync()
    {
        return await _readContext.Products.ToListAsync();
    }
    
    // 쓰기는 마스터에서
    public async Task AddProductAsync(Product product)
    {
        _writeContext.Products.Add(product);
        await _writeContext.SaveChangesAsync();
    }
}</list<product></mydbcontext></mydbcontext></mydbcontext>

// 최악의 코드 (실제로 이렇게 작성된 경우가 많아!)
public async Task<list<productdto>> GetProducts(int page)
{
    var products = await _context.Products
        .ToListAsync();  // 전체 데이터 로드!
    
    var result = new List<productdto>();
    
    foreach (var product in products)
    {
        // 각 상품마다 개별 쿼리 실행 (N+1 문제)
        var category = await _context.Categories
            .FirstOrDefaultAsync(c => c.Id == product.CategoryId);
        
        var reviews = await _context.Reviews
            .Where(r => r.ProductId == product.Id)
            .ToListAsync();
        
        var images = await _context.ProductImages
            .Where(i => i.ProductId == product.Id)
            .ToListAsync();
        
        result.Add(new ProductDto
        {
            Id = product.Id,
            Name = product.Name,
            Price = product.Price,
            CategoryName = category?.Name,
            ReviewCount = reviews.Count,
            AverageRating = reviews.Any() ? reviews.Average(r => r.Rating) : 0,
            ImageUrls = images.Select(i => i.Url).ToList()
        });
    }
    
    // 페이징을 메모리에서 처리!
    return result
        .Skip((page - 1) * 20)
        .Take(20)
        .ToList();
}

// 실행되는 쿼리 개수: 1 + (N * 3) = 1 + (10000 * 3) = 30,001개!
// 전송되는 데이터: 수백 MB
// 실행 시간: 8-12초</productdto></list<productdto>

// 최적화된 버전
public async Task<pagedresult<productdto>> GetProducts(int page, int pageSize = 20)
{
    // 1단계: 필요한 데이터만 프로젝션 + 페이징
    var query = _context.Products
        .AsNoTracking()  // 읽기 전용
        .Where(p => p.IsActive)  // 활성 상품만
        .Select(p => new ProductDto
        {
            Id = p.Id,
            Name = p.Name,
            Price = p.Price,
            CategoryName = p.Category.Name,  // 조인 자동 처리
            ReviewCount = p.Reviews.Count(),  // 집계 함수
            AverageRating = p.Reviews.Any() 
                ? p.Reviews.Average(r => r.Rating) 
                : 0,
            ImageUrls = p.Images
                .OrderBy(i => i.Order)
                .Take(3)  // 처음 3개만
                .Select(i => i.Url)
                .ToList()
        });
    
    // 2단계: 전체 개수 조회 (캐싱 가능)
    var totalCount = await query.CountAsync();
    
    // 3단계: 페이징 적용
    var items = await query
        .OrderBy(p => p.Name)
        .Skip((page - 1) * pageSize)
        .Take(pageSize)
        .ToListAsync();
    
    return new PagedResult<productdto>
    {
        Items = items,
        TotalCount = totalCount,
        PageNumber = page,
        PageSize = pageSize
    };
}

// 실행되는 쿼리 개수: 2개 (count + select)
// 전송되는 데이터: 수십 KB
// 실행 시간: 0.2-0.5초</productdto></pagedresult<productdto>

// 인덱스 추가
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    // 자주 검색되는 컬럼에 인덱스
    modelBuilder.Entity<product>()
        .HasIndex(p => new { p.IsActive, p.CategoryId, p.Name });
    
    // 외래 키에 인덱스
    modelBuilder.Entity<review>()
        .HasIndex(r => r.ProductId);
    
    modelBuilder.Entity<productimage>()
        .HasIndex(i => new { i.ProductId, i.Order });
}

// 컴파일된 쿼리로 더욱 최적화
private static readonly Func<mydbcontext, int,="" task<list<productdto="">>> 
    _getProductsQuery = EF.CompileAsyncQuery(
        (MyDbContext context, int page, int pageSize) =>
            context.Products
                .AsNoTracking()
                .Where(p => p.IsActive)
                .Select(p => new ProductDto
                {
                    // ... 프로젝션
                })
                .OrderBy(p => p.Name)
                .Skip((page - 1) * pageSize)
                .Take(pageSize)
                .ToList());

// 캐싱 추가 (Redis 또는 메모리 캐시)
public async Task<pagedresult<productdto>> GetProductsCached(int page)
{
    var cacheKey = $"products_page_{page}";
    
    if (_cache.TryGetValue(cacheKey, out PagedResult<productdto> cached))
    {
        return cached;
    }
    
    var result = await GetProducts(page);
    
    _cache.Set(cacheKey, result, TimeSpan.FromMinutes(5));
    
    return result;
}</productdto></pagedresult<productdto></mydbcontext,></productimage></review></product>