🔧 AutoMapper가 뭐길래?

자, 이제 본격적으로 AutoMapper를 알아보자! 🎯

AutoMapper는 .NET 생태계에서 가장 유명한 객체-객체 매핑 라이브러리야. 2009년에 Jimmy Bogard가 만들었고, 지금까지도 활발하게 유지보수되고 있어. 기본 아이디어는 간단해: "규칙 기반으로 한 객체의 속성을 다른 객체의 속성으로 자동 복사"하는 거지.

예를 들어볼게. AutoMapper 없이 수동으로 매핑하면 이렇게 해야 해:

public UserDto ConvertToDto(User user)
{
    return new UserDto
    {
        Id = user.Id,
        Name = user.Name,
        Email = user.Email,
        Age = user.Age,
        PhoneNumber = user.PhoneNumber,
        Address = user.Address,
        City = user.City,
        Country = user.Country,
        PostalCode = user.PostalCode,
        // ... 속성이 20개, 30개라면? 😱
    };
}

속성이 몇 개 안 되면 괜찮은데, 실무에서는 속성이 수십 개인 경우도 많아. 게다가 이런 변환 메서드가 프로젝트 전체에 수백 개씩 있다면? 코드 중복도 심하고, 나중에 속성 하나 추가하려면 모든 곳을 다 수정해야 해. 😭

AutoMapper를 사용하면 이렇게 바뀌어:

// 설정 (한 번만)
var config = new MapperConfiguration(cfg => {
    cfg.CreateMap<User, UserDto>();
});

var mapper = config.CreateMapper();

// 사용 (매우 간단!)
UserDto dto = mapper.Map<UserDto>(user);

와우! ✨ 단 한 줄로 모든 속성이 자동으로 매핑돼. AutoMapper는 속성 이름이 같으면 자동으로 연결해주거든. 이게 바로 Convention over Configuration (설정보다 관례) 원칙이야.

📦 AutoMapper 설치 및 기본 설정

자, 이제 실전으로 들어가보자! 먼저 AutoMapper를 프로젝트에 설치해야겠지? 🛠️

Install-Package AutoMapper
Install-Package AutoMapper.Extensions.Microsoft.DependencyInjection

또는 .NET CLI를 사용한다면:

dotnet add package AutoMapper
dotnet add package AutoMapper.Extensions.Microsoft.DependencyInjection

두 번째 패키지는 ASP.NET Core의 의존성 주입(DI) 컨테이너와 AutoMapper를 통합하기 위한 거야. 요즘 대부분의 프로젝트가 DI를 사용하니까 거의 필수라고 보면 돼. 🔌

using AutoMapper;

public class UserProfile : Profile
{
    public UserProfile()
    {
        // User 엔티티를 UserDto로 매핑
        CreateMap<User, UserDto>();
        
        // 양방향 매핑이 필요하면
        CreateMap<UserDto, User>();
        
        // 다른 매핑들도 여기에 추가
        CreateMap<Product, ProductDto>();
        CreateMap<Order, OrderDto>();
    }
}

Profile 클래스는 관련된 매핑들을 묶어주는 역할을 해. 예를 들어 UserProfile, ProductProfile, OrderProfile 이런 식으로 도메인별로 나눌 수 있지. 📂

// Program.cs (.NET 6 이상)
var builder = WebApplication.CreateBuilder(args);

// AutoMapper 등록 - 어셈블리 스캔 방식
builder.Services.AddAutoMapper(typeof(Program));

// 또는 특정 Profile 클래스 지정
// builder.Services.AddAutoMapper(typeof(UserProfile));

var app = builder.Build();
// ... 나머지 설정

AddAutoMapper(typeof(Program))은 Program 클래스가 있는 어셈블리를 스캔해서 모든 Profile 클래스를 자동으로 찾아 등록해줘. 정말 편리하지? 🎉

using AutoMapper;
using Microsoft.AspNetCore.Mvc;

[ApiController]
[Route("api/[controller]")]
public class UsersController : ControllerBase
{
    private readonly IMapper _mapper;
    private readonly IUserService _userService;
    
    public UsersController(IMapper mapper, IUserService userService)
    {
        _mapper = mapper;
        _userService = userService;
    }
    
    [HttpGet("{id}")]
    public async Task<ActionResult<UserDto>> GetUser(int id)
    {
        var user = await _userService.GetByIdAsync(id);
        
        if (user == null)
            return NotFound();
        
        // 매핑 수행!
        var userDto = _mapper.Map<UserDto>(user);
        
        return Ok(userDto);
    }
    
    [HttpGet]
    public async Task<ActionResult<List<UserDto>>> GetAllUsers()
    {
        var users = await _userService.GetAllAsync();
        
        // 컬렉션도 한 번에 매핑 가능!
        var userDtos = _mapper.Map<List<UserDto>>(users);
        
        return Ok(userDtos);
    }
}

보다시피 _mapper.Map<TDestination>(source) 형태로 사용하면 돼. 컬렉션(List, Array 등)도 자동으로 처리해주니까 정말 편해! 🚀

🎨 매핑 커스터마이징 - 기본부터 고급까지

AutoMapper의 진짜 강력함은 커스터마이징에 있어. 단순히 같은 이름의 속성만 매핑하는 게 아니라, 복잡한 변환 로직도 우아하게 처리할 수 있거든. 하나씩 살펴보자! 🎯

1️⃣ 속성명이 다를 때 - ForMember

가장 흔한 케이스야. 소스와 대상의 속성명이 다를 때 어떻게 매핑할지 명시적으로 지정하는 거지.

public class User
{
    public int Id { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public DateTime BirthDate { get; set; }
}

public class UserDto
{
    public int UserId { get; set; }  // Id와 이름이 다름
    public string FullName { get; set; }  // FirstName + LastName 조합
    public int Age { get; set; }  // BirthDate로부터 계산
}

// Profile 설정
public class UserProfile : Profile
{
    public UserProfile()
    {
        CreateMap<User, UserDto>()
            .ForMember(dest => dest.UserId, 
                opt => opt.MapFrom(src => src.Id))
            .ForMember(dest => dest.FullName, 
                opt => opt.MapFrom(src => $"{src.FirstName} {src.LastName}"))
            .ForMember(dest => dest.Age, 
                opt => opt.MapFrom(src => CalculateAge(src.BirthDate)));
    }
    
    private int CalculateAge(DateTime birthDate)
    {
        var today = DateTime.Today;
        var age = today.Year - birthDate.Year;
        if (birthDate.Date > today.AddYears(-age)) age--;
        return age;
    }
}

ForMember는 대상(destination) 속성을 지정하고, MapFrom으로 소스에서 어떻게 값을 가져올지 정의해. 람다 표현식을 사용하니까 복잡한 로직도 자유롭게 작성할 수 있어! ✨

2️⃣ 특정 속성 무시하기 - Ignore

때로는 특정 속성을 매핑하고 싶지 않을 때가 있어. 예를 들어 DTO에는 있지만 수동으로 설정해야 하는 속성이라든지.

public class CreateUserDto
{
    public string Username { get; set; }
    public string Email { get; set; }
    public string Password { get; set; }
    public DateTime CreatedAt { get; set; }  // 서버에서 자동 설정
}

public class UserProfile : Profile
{
    public UserProfile()
    {
        CreateMap<CreateUserDto, User>()
            .ForMember(dest => dest.CreatedAt, opt => opt.Ignore())
            .ForMember(dest => dest.Id, opt => opt.Ignore());
    }
}

3️⃣ 조건부 매핑 - Condition

특정 조건을 만족할 때만 매핑하고 싶다면 Condition을 사용해:

CreateMap<User, UserDto>()
    .ForMember(dest => dest.Email, opt => 
    {
        opt.Condition(src => !string.IsNullOrEmpty(src.Email));
        opt.MapFrom(src => src.Email);
    });

4️⃣ Null 값 처리 - NullSubstitute

소스 값이 null일 때 기본값을 지정할 수 있어:

CreateMap<User, UserDto>()
    .ForMember(dest => dest.PhoneNumber, 
        opt => opt.NullSubstitute("번호 없음"));

5️⃣ 중첩 객체 매핑 - Nested Mapping

객체 안에 또 다른 객체가 있는 경우도 자동으로 처리돼. 단, 해당 타입에 대한 매핑 설정이 있어야 해:

public class User
{
    public int Id { get; set; }
    public string Name { get; set; }
    public Address Address { get; set; }  // 중첩 객체
}

public class Address
{
    public string Street { get; set; }
    public string City { get; set; }
    public string Country { get; set; }
}

public class UserDto
{
    public int Id { get; set; }
    public string Name { get; set; }
    public AddressDto Address { get; set; }
}

public class AddressDto
{
    public string Street { get; set; }
    public string City { get; set; }
    public string Country { get; set; }
}

// Profile 설정
public class MappingProfile : Profile
{
    public MappingProfile()
    {
        CreateMap<User, UserDto>();  // User 매핑
        CreateMap<Address, AddressDto>();  // Address 매핑도 정의
    }
}

AutoMapper가 User.Address를 매핑할 때 자동으로 Address → AddressDto 매핑을 찾아서 적용해줘. 똑똑하지? 🧠

6️⃣ Flattening (평탄화)

이건 AutoMapper의 정말 멋진 기능 중 하나야! 중첩된 객체를 평평하게 펼칠 수 있어:

public class Order
{
    public int Id { get; set; }
    public Customer Customer { get; set; }
}

public class Customer
{
    public string Name { get; set; }
    public string Email { get; set; }
}

public class OrderDto
{
    public int Id { get; set; }
    public string CustomerName { get; set; }  // Customer.Name
    public string CustomerEmail { get; set; }  // Customer.Email
}

// Profile 설정 - 추가 설정 필요 없음!
CreateMap<Order, OrderDto>();

놀랍게도 CustomerName이라는 속성명을 보고 AutoMapper가 자동으로 Customer.Name을 찾아서 매핑해줘! 이게 바로 PascalCase 분할 규칙이야. Customer + Name을 인식하는 거지. 🎉

7️⃣ Reverse Mapping (역방향 매핑)

양방향 매핑이 필요할 때 ReverseMap()을 사용하면 돼:

CreateMap<User, UserDto>()
    .ForMember(dest => dest.FullName, 
        opt => opt.MapFrom(src => $"{src.FirstName} {src.LastName}"))
    .ReverseMap()
    .ForMember(dest => dest.FirstName, 
        opt => opt.MapFrom(src => src.FullName.Split(' ')[0]))
    .ForMember(dest => dest.LastName, 
        opt => opt.MapFrom(src => src.FullName.Split(' ')[1]));

ReverseMap() 이후의 ForMember는 역방향(UserDto → User) 매핑에 적용돼. 편리하지? 🔄

🏗️ DTO 패턴 설계 전략

AutoMapper 사용법을 알았으니, 이제 DTO를 어떻게 설계해야 하는지 이야기해보자. DTO 패턴은 단순해 보이지만, 제대로 설계하지 않으면 오히려 복잡도만 증가할 수 있어. 🎨

📋 DTO 명명 규칙

일관된 명명 규칙은 코드 가독성을 크게 높여줘. 실무에서 많이 사용하는 패턴들을 소개할게:

// 1. 조회용 (Read)
public class UserDto { }
public class UserDetailDto { }  // 상세 정보
public class UserSummaryDto { }  // 요약 정보
public class UserListItemDto { }  // 목록용

// 2. 생성용 (Create)
public class CreateUserDto { }
public class CreateUserRequest { }
public class UserCreateCommand { }

// 3. 수정용 (Update)
public class UpdateUserDto { }
public class UpdateUserRequest { }
public class UserUpdateCommand { }

// 4. 응답용 (Response)
public class UserResponse { }
public class CreateUserResponse { }
public class ApiResponse<T> { }

// 5. 검색/필터용
public class UserSearchDto { }
public class UserFilterDto { }
public class UserQueryParameters { }

팀마다 선호하는 스타일이 다를 수 있지만, 중요한 건 일관성이야. 한 프로젝트 내에서는 하나의 규칙을 정해서 쭉 따라가는 게 좋아. 📏

🎯 DTO 분리 전략

"DTO를 얼마나 세분화해야 할까?"는 자주 받는 질문이야. 정답은 없지만, 몇 가지 가이드라인을 줄게:

// ❌ 나쁜 예: 모든 용도를 하나로
public class UserDto
{
    public int Id { get; set; }
    public string Username { get; set; }
    public string Password { get; set; }  // 조회 시 노출되면 안 됨!
    public string Email { get; set; }
    public DateTime CreatedAt { get; set; }
    public DateTime? UpdatedAt { get; set; }
    // ... 수십 개의 속성
}

// ✅ 좋은 예: 용도별로 분리
public class UserProfileDto  // 프로필 조회용
{
    public int Id { get; set; }
    public string Username { get; set; }
    public string Email { get; set; }
    public string ProfileImageUrl { get; set; }
}

public class CreateUserDto  // 회원가입용
{
    public string Username { get; set; }
    public string Password { get; set; }
    public string Email { get; set; }
}

public class UpdateUserProfileDto  // 프로필 수정용
{
    public string Email { get; set; }
    public string ProfileImageUrl { get; set; }
    // Id나 Username은 수정 불가하므로 제외
}

// 관리자용 DTO
public class AdminUserDto
{
    public int Id { get; set; }
    public string Username { get; set; }
    public string Email { get; set; }
    public DateTime CreatedAt { get; set; }
    public DateTime LastLoginAt { get; set; }
    public bool IsActive { get; set; }
    public string IpAddress { get; set; }
    public List<string> Roles { get; set; }
}

// 일반 사용자용 DTO (자기 정보 조회)
public class MyProfileDto
{
    public string Username { get; set; }
    public string Email { get; set; }
    public DateTime CreatedAt { get; set; }
}

// 공개 프로필 DTO (다른 사용자가 볼 때)
public class PublicUserDto
{
    public string Username { get; set; }
    public string ProfileImageUrl { get; set; }
    // 이메일, 생성일 등 민감정보 제외
}

🔗 DTO 상속과 조합

DTO 간에 공통 속성이 많다면 상속이나 조합을 고려해볼 수 있어:

// 기본 DTO
public class BaseUserDto
{
    public int Id { get; set; }
    public string Username { get; set; }
}

// 상속을 통한 확장
public class UserDetailDto : BaseUserDto
{
    public string Email { get; set; }
    public string PhoneNumber { get; set; }
    public AddressDto Address { get; set; }
}

// 조합을 통한 구성
public class OrderDto
{
    public int Id { get; set; }
    public DateTime OrderDate { get; set; }
    public UserSummaryDto Customer { get; set; }  // 조합
    public List<OrderItemDto> Items { get; set; }
}

하지만 주의할 점! 상속을 남용하면 오히려 복잡해질 수 있어. 명확성이 재사용성보다 중요하다는 걸 기억해. ⚠️

📦 DTO 폴더 구조

프로젝트가 커지면 DTO 파일도 엄청 많아져. 체계적인 폴더 구조가 필요해:

📁 MyProject.Api
  📁 DTOs
    📁 Users
      📄 UserDto.cs
      📄 CreateUserDto.cs
      📄 UpdateUserDto.cs
      📄 UserProfileDto.cs
    📁 Products
      📄 ProductDto.cs
      📄 CreateProductDto.cs
      📄 ProductListItemDto.cs
    📁 Orders
      📄 OrderDto.cs
      📄 OrderDetailDto.cs
      📄 CreateOrderDto.cs
    📁 Common
      📄 PagedResultDto.cs
      📄 ApiResponseDto.cs
  📁 Mappings
    📄 UserProfile.cs
    📄 ProductProfile.cs
    📄 OrderProfile.cs

도메인별로 폴더를 나누고, 공통으로 사용하는 DTO는 Common 폴더에 모아두는 거지. AutoMapper Profile도 별도 폴더로 관리하면 찾기 쉬워! 📂

⚡ 성능 최적화 팁

AutoMapper는 편리하지만, 잘못 사용하면 성능 문제가 생길 수 있어. 실전에서 꼭 알아야 할 최적화 팁들을 공유할게! 🚀

1️⃣ ProjectTo 사용하기

Entity Framework Core와 함께 사용할 때 가장 중요한 최적화야. ProjectTo를 사용하면 데이터베이스 쿼리 단계에서 필요한 컬럼만 선택해:

// ❌ 나쁜 예: 모든 데이터를 메모리로 가져온 후 매핑
var users = await _context.Users.ToListAsync();
var userDtos = _mapper.Map<List<UserDto>>(users);

// ✅ 좋은 예: 쿼리 단계에서 필요한 컬럼만 선택
var userDtos = await _context.Users
    .ProjectTo<UserDto>(_mapper.ConfigurationProvider)
    .ToListAsync();

ProjectTo를 사용하면 SQL 쿼리가 이렇게 바뀌어:

-- ProjectTo 사용 전
SELECT * FROM Users;  -- 모든 컬럼

-- ProjectTo 사용 후
SELECT Id, Username, Email FROM Users;  -- 필요한 컬럼만

데이터가 많을수록 성능 차이가 엄청나! 특히 컬럼이 수십 개인 테이블에서는 필수야. ⚡

2️⃣ 매핑 설정 검증하기

런타임에 매핑 오류가 발생하면 디버깅이 어려워. 애플리케이션 시작 시 설정을 검증하자:

// Program.cs
var app = builder.Build();

// 개발 환경에서만 검증 (성능 영향 있음)
if (app.Environment.IsDevelopment())
{
    var mapper = app.Services.GetRequiredService<IMapper>();
    mapper.ConfigurationProvider.AssertConfigurationIsValid();
}

app.Run();

AssertConfigurationIsValid()는 모든 매핑 설정을 검사해서 문제가 있으면 예외를 던져. 배포 전에 꼭 확인하자! ✅

3️⃣ 컬렉션 매핑 최적화

대량의 데이터를 매핑할 때는 컬렉션 타입 선택이 중요해:

// List보다 IEnumerable이 더 효율적일 수 있음
public class OrderDto
{
    public int Id { get; set; }
    public IEnumerable<OrderItemDto> Items { get; set; }  // List 대신
}

// 읽기 전용이면 IReadOnlyCollection 사용
public class ProductDto
{
    public int Id { get; set; }
    public IReadOnlyCollection<string> Tags { get; set; }
}

4️⃣ 불필요한 매핑 피하기

모든 걸 매핑할 필요는 없어. 간단한 경우는 수동 매핑이 더 빠를 수 있어:

// 속성이 1~2개면 수동 매핑도 고려
public class SimpleDto
{
    public int Id { get; set; }
    public string Name { get; set; }
}

// 이 정도는 AutoMapper 없이도 OK
var dto = new SimpleDto 
{ 
    Id = entity.Id, 
    Name = entity.Name 
};

AutoMapper는 리플렉션을 사용하기 때문에 약간의 오버헤드가 있어. 성능이 극도로 중요한 핫패스(hot path)에서는 수동 매핑을 고려해봐. 🔥

5️⃣ 매핑 캐싱 활용

AutoMapper는 내부적으로 매핑 계획을 캐싱해. 하지만 동적으로 매핑을 생성하면 캐시 효과가 떨어져:

// ❌ 나쁜 예: 매번 새로운 매핑 생성
var config = new MapperConfiguration(cfg => 
{
    cfg.CreateMap<User, UserDto>();
});
var mapper = config.CreateMapper();  // 매번 생성하지 마!

// ✅ 좋은 예: DI 컨테이너에서 싱글톤으로 주입받기
public class UserService
{
    private readonly IMapper _mapper;  // 재사용
    
    public UserService(IMapper mapper)
    {
        _mapper = mapper;
    }
}

🛡️ 실전 예제: 완전한 CRUD API 구현

이론은 충분히 배웠으니, 이제 실전 예제를 만들어보자! 간단한 블로그 시스템의 게시글(Post) 관리 API를 AutoMapper와 DTO 패턴으로 구현해볼게. 💻

📝 Step 1: 엔티티 정의

// Domain/Entities/Post.cs
public class Post
{
    public int Id { get; set; }
    public string Title { get; set; }
    public string Content { get; set; }
    public string Slug { get; set; }
    public int AuthorId { get; set; }
    public User Author { get; set; }
    public DateTime CreatedAt { get; set; }
    public DateTime? UpdatedAt { get; set; }
    public DateTime? PublishedAt { get; set; }
    public bool IsPublished { get; set; }
    public bool IsDeleted { get; set; }
    public int ViewCount { get; set; }
    public List<Comment> Comments { get; set; }
    public List<Tag> Tags { get; set; }
}

public class User
{
    public int Id { get; set; }
    public string Username { get; set; }
    public string Email { get; set; }
    public string PasswordHash { get; set; }
    public string DisplayName { get; set; }
    public string AvatarUrl { get; set; }
}

public class Comment
{
    public int Id { get; set; }
    public string Content { get; set; }
    public int AuthorId { get; set; }
    public User Author { get; set; }
    public DateTime CreatedAt { get; set; }
}

public class Tag
{
    public int Id { get; set; }
    public string Name { get; set; }
}

📦 Step 2: DTO 정의

// DTOs/Posts/PostDto.cs
public class PostDto
{
    public int Id { get; set; }
    public string Title { get; set; }
    public string Slug { get; set; }
    public string Excerpt { get; set; }  // Content의 요약
    public AuthorDto Author { get; set; }
    public DateTime CreatedAt { get; set; }
    public DateTime? PublishedAt { get; set; }
    public int ViewCount { get; set; }
    public int CommentCount { get; set; }
    public List<string> Tags { get; set; }
}

// DTOs/Posts/PostDetailDto.cs
public class PostDetailDto
{
    public int Id { get; set; }
    public string Title { get; set; }
    public string Content { get; set; }
    public string Slug { get; set; }
    public AuthorDto Author { get; set; }
    public DateTime CreatedAt { get; set; }
    public DateTime? UpdatedAt { get; set; }
    public DateTime? PublishedAt { get; set; }
    public int ViewCount { get; set; }
    public List<CommentDto> Comments { get; set; }
    public List<string> Tags { get; set; }
}

// DTOs/Posts/CreatePostDto.cs
public class CreatePostDto
{
    [Required]
    [StringLength(200)]
    public string Title { get; set; }
    
    [Required]
    public string Content { get; set; }
    
    public List<string> Tags { get; set; }
    
    public bool PublishImmediately { get; set; }
}

// DTOs/Posts/UpdatePostDto.cs
public class UpdatePostDto
{
    [StringLength(200)]
    public string Title { get; set; }
    
    public string Content { get; set; }
    
    public List<string> Tags { get; set; }
}

// DTOs/Common/AuthorDto.cs
public class AuthorDto
{
    public int Id { get; set; }
    public string Username { get; set; }
    public string DisplayName { get; set; }
    public string AvatarUrl { get; set; }
}

// DTOs/Comments/CommentDto.cs
public class CommentDto
{
    public int Id { get; set; }
    public string Content { get; set; }
    public AuthorDto Author { get; set; }
    public DateTime CreatedAt { get; set; }
}

🗺️ Step 3: AutoMapper Profile 설정

// Mappings/PostProfile.cs
public class PostProfile : Profile
{
    public PostProfile()
    {
        // Post → PostDto
        CreateMap<Post, PostDto>()
            .ForMember(dest => dest.Excerpt, 
                opt => opt.MapFrom(src => CreateExcerpt(src.Content, 150)))
            .ForMember(dest => dest.CommentCount, 
                opt => opt.MapFrom(src => src.Comments.Count))
            .ForMember(dest => dest.Tags, 
                opt => opt.MapFrom(src => src.Tags.Select(t => t.Name).ToList()));
        
        // Post → PostDetailDto
        CreateMap<Post, PostDetailDto>()
            .ForMember(dest => dest.Tags, 
                opt => opt.MapFrom(src => src.Tags.Select(t => t.Name).ToList()));
        
        // CreatePostDto → Post
        CreateMap<CreatePostDto, Post>()
            .ForMember(dest => dest.Slug, 
                opt => opt.MapFrom(src => GenerateSlug(src.Title)))
            .ForMember(dest => dest.CreatedAt, 
                opt => opt.MapFrom(src => DateTime.UtcNow))
            .ForMember(dest => dest.IsPublished, 
                opt => opt.MapFrom(src => src.PublishImmediately))
            .ForMember(dest => dest.PublishedAt, 
                opt => opt.MapFrom(src => src.PublishImmediately ? DateTime.UtcNow : (DateTime?)null))
            .ForMember(dest => dest.Tags, opt => opt.Ignore())  // 별도 처리
            .ForMember(dest => dest.Id, opt => opt.Ignore())
            .ForMember(dest => dest.AuthorId, opt => opt.Ignore())
            .ForMember(dest => dest.ViewCount, opt => opt.Ignore())
            .ForMember(dest => dest.Comments, opt => opt.Ignore());
        
        // UpdatePostDto → Post
        CreateMap<UpdatePostDto, Post>()
            .ForMember(dest => dest.UpdatedAt, 
                opt => opt.MapFrom(src => DateTime.UtcNow))
            .ForMember(dest => dest.Slug, 
                opt => opt.MapFrom((src, dest) => 
                    !string.IsNullOrEmpty(src.Title) ? GenerateSlug(src.Title) : dest.Slug))
            .ForMember(dest => dest.Tags, opt => opt.Ignore())
            .ForAllMembers(opts => opts.Condition((src, dest, srcMember) => srcMember != null));
        
        // User → AuthorDto
        CreateMap<User, AuthorDto>();
        
        // Comment → CommentDto
        CreateMap<Comment, CommentDto>();
    }
    
    private string CreateExcerpt(string content, int maxLength)
    {
        if (string.IsNullOrEmpty(content))
            return string.Empty;
        
        var plainText = System.Text.RegularExpressions.Regex.Replace(content, "<.*?>", string.Empty);
        return plainText.Length <= maxLength 
            ? plainText 
            : plainText.Substring(0, maxLength) + "...";
    }
    
    private string GenerateSlug(string title)
    {
        if (string.IsNullOrEmpty(title))
            return string.Empty;
        
        return title.ToLower()
            .Replace(" ", "-")
            .Replace("?", "")
            .Replace("!", "")
            .Replace(".", "");
    }
}

🎮 Step 4: 서비스 레이어

// Services/PostService.cs
public interface IPostService
{
    Task<PagedResult<PostDto>> GetPostsAsync(int page, int pageSize);
    Task<PostDetailDto> GetPostByIdAsync(int id);
    Task<PostDetailDto> GetPostBySlugAsync(string slug);
    Task<PostDetailDto> CreatePostAsync(CreatePostDto dto, int authorId);
    Task<PostDetailDto> UpdatePostAsync(int id, UpdatePostDto dto);
    Task<bool> DeletePostAsync(int id);
}

public class PostService : IPostService
{
    private readonly ApplicationDbContext _context;
    private readonly IMapper _mapper;
    
    public PostService(ApplicationDbContext context, IMapper mapper)
    {
        _context = context;
        _mapper = mapper;
    }
    
    public async Task<PagedResult<PostDto>> GetPostsAsync(int page, int pageSize)
    {
        var query = _context.Posts
            .Include(p => p.Author)
            .Include(p => p.Tags)
            .Include(p => p.Comments)
            .Where(p => !p.IsDeleted && p.IsPublished)
            .OrderByDescending(p => p.PublishedAt);
        
        var totalCount = await query.CountAsync();
        
        // ProjectTo 사용으로 성능 최적화!
        var posts = await query
            .Skip((page - 1) * pageSize)
            .Take(pageSize)
            .ProjectTo<PostDto>(_mapper.ConfigurationProvider)
            .ToListAsync();
        
        return new PagedResult<PostDto>
        {
            Items = posts,
            TotalCount = totalCount,
            Page = page,
            PageSize = pageSize
        };
    }
    
    public async Task<PostDetailDto> GetPostBySlugAsync(string slug)
    {
        var post = await _context.Posts
            .Include(p => p.Author)
            .Include(p => p.Tags)
            .Include(p => p.Comments)
                .ThenInclude(c => c.Author)
            .FirstOrDefaultAsync(p => p.Slug == slug && !p.IsDeleted);
        
        if (post == null)
            return null;
        
        // 조회수 증가
        post.ViewCount++;
        await _context.SaveChangesAsync();
        
        return _mapper.Map<PostDetailDto>(post);
    }
    
    public async Task<PostDetailDto> CreatePostAsync(CreatePostDto dto, int authorId)
    {
        var post = _mapper.Map<Post>(dto);
        post.AuthorId = authorId;
        
        // 태그 처리
        if (dto.Tags != null && dto.Tags.Any())
        {
            post.Tags = new List<Tag>();
            foreach (var tagName in dto.Tags)
            {
                var tag = await _context.Tags
                    .FirstOrDefaultAsync(t => t.Name == tagName);
                
                if (tag == null)
                {
                    tag = new Tag { Name = tagName };
                    _context.Tags.Add(tag);
                }
                
                post.Tags.Add(tag);
            }
        }
        
        _context.Posts.Add(post);
        await _context.SaveChangesAsync();
        
        // 생성된 게시글 다시 조회 (관계 포함)
        var createdPost = await _context.Posts
            .Include(p => p.Author)
            .Include(p => p.Tags)
            .Include(p => p.Comments)
            .FirstOrDefaultAsync(p => p.Id == post.Id);
        
        return _mapper.Map<PostDetailDto>(createdPost);
    }
    
    public async Task<PostDetailDto> UpdatePostAsync(int id, UpdatePostDto dto)
    {
        var post = await _context.Posts
            .Include(p => p.Tags)
            .FirstOrDefaultAsync(p => p.Id == id && !p.IsDeleted);
        
        if (post == null)
            return null;
        
        // AutoMapper로 변경사항 적용
        _mapper.Map(dto, post);
        
        // 태그 업데이트
        if (dto.Tags != null)
        {
            post.Tags.Clear();
            foreach (var tagName in dto.Tags)
            {
                var tag = await _context.Tags
                    .FirstOrDefaultAsync(t => t.Name == tagName);
                
                if (tag == null)
                {
                    tag = new Tag { Name = tagName };
                    _context.Tags.Add(tag);
                }
                
                post.Tags.Add(tag);
            }
        }
        
        await _context.SaveChangesAsync();
        
        // 업데이트된 게시글 다시 조회
        var updatedPost = await _context.Posts
            .Include(p => p.Author)
            .Include(p => p.Tags)
            .Include(p => p.Comments)
            .FirstOrDefaultAsync(p => p.Id == id);
        
        return _mapper.Map<PostDetailDto>(updatedPost);
    }
    
    public async Task<bool> DeletePostAsync(int id)
    {
        var post = await _context.Posts.FindAsync(id);
        
        if (post == null || post.IsDeleted)
            return false;
        
        // 소프트 삭제
        post.IsDeleted = true;
        await _context.SaveChangesAsync();
        
        return true;
    }
}

🌐 Step 5: API 컨트롤러

// Controllers/PostsController.cs
[ApiController]
[Route("api/[controller]")]
public class PostsController : ControllerBase
{
    private readonly IPostService _postService;
    
    public PostsController(IPostService postService)
    {
        _postService = postService;
    }
    
    /// <summary>
    /// 게시글 목록 조회
    /// </summary>
    [HttpGet]
    [ProducesResponseType(typeof(PagedResult<PostDto>), 200)]
    public async Task<ActionResult<PagedResult<PostDto>>> GetPosts(
        [FromQuery] int page = 1, 
        [FromQuery] int pageSize = 10)
    {
        if (page < 1 || pageSize < 1 || pageSize > 100)
            return BadRequest("Invalid pagination parameters");
        
        var result = await _postService.GetPostsAsync(page, pageSize);
        return Ok(result);
    }
    
    /// <summary>
    /// 게시글 상세 조회 (Slug 기반)
    /// </summary>
    [HttpGet("{slug}")]
    [ProducesResponseType(typeof(PostDetailDto), 200)]
    [ProducesResponseType(404)]
    public async Task<ActionResult<PostDetailDto>> GetPost(string slug)
    {
        var post = await _postService.GetPostBySlugAsync(slug);
        
        if (post == null)
            return NotFound();
        
        return Ok(post);
    }
    
    /// <summary>
    /// 게시글 생성
    /// </summary>
    [HttpPost]
    [Authorize]
    [ProducesResponseType(typeof(PostDetailDto), 201)]
    [ProducesResponseType(400)]
    public async Task<ActionResult<PostDetailDto>> CreatePost([FromBody] CreatePostDto dto)
    {
        if (!ModelState.IsValid)
            return BadRequest(ModelState);
        
        // 현재 로그인한 사용자 ID 가져오기
        var authorId = int.Parse(User.FindFirst(ClaimTypes.NameIdentifier)?.Value);
        
        var post = await _postService.CreatePostAsync(dto, authorId);
        
        return CreatedAtAction(
            nameof(GetPost), 
            new { slug = post.Slug }, 
            post);
    }
    
    /// <summary>
    /// 게시글 수정
    /// </summary>
    [HttpPut("{id}")]
    [Authorize]
    [ProducesResponseType(typeof(PostDetailDto), 200)]
    [ProducesResponseType(404)]
    public async Task<ActionResult<PostDetailDto>> UpdatePost(
        int id, 
        [FromBody] UpdatePostDto dto)
    {
        if (!ModelState.IsValid)
            return BadRequest(ModelState);
        
        var post = await _postService.UpdatePostAsync(id, dto);
        
        if (post == null)
            return NotFound();
        
        return Ok(post);
    }
    
    /// <summary>
    /// 게시글 삭제
    /// </summary>
    [HttpDelete("{id}")]
    [Authorize]
    [ProducesResponseType(204)]
    [ProducesResponseType(404)]
    public async Task<IActionResult> DeletePost(int id)
    {
        var result = await _postService.DeletePostAsync(id);
        
        if (!result)
            return NotFound();
        
        return NoContent();
    }
}

와! 꽤 긴 코드였지? 😅 하지만 이게 실제 프로젝트에서 사용하는 패턴이야. 각 계층이 명확히 분리되어 있고, AutoMapper 덕분에 매핑 코드가 깔끔하게 정리됐어. ✨

🚨 흔한 실수와 해결 방법

AutoMapper를 사용하다 보면 누구나 한 번쯤 겪는 실수들이 있어. 미리 알고 있으면 삽질을 줄일 수 있지! 💡

❌ 실수 1: 순환 참조 문제

// 문제 상황
public class Post
{
    public int Id { get; set; }
    public User Author { get; set; }
}

public class User
{
    public int Id { get; set; }
    public List<Post> Posts { get; set; }  // 순환 참조!
}

// 방법 1: DTO에서 순환 참조 제거
public class PostDto
{
    public int Id { get; set; }
    public AuthorDto Author { get; set; }  // User 전체가 아닌 요약 정보만
}

public class AuthorDto
{
    public int Id { get; set; }
    public string Name { get; set; }
    // Posts 속성 없음!
}

// 방법 2: MaxDepth 설정
CreateMap<Post, PostDto>()
    .ForMember(dest => dest.Author, opt => opt.MaxDepth(1));

❌ 실수 2: 매핑 설정 누락

AutoMapperMappingException: Missing type map configuration

// Profile에 매핑 추가
public class MappingProfile : Profile
{
    public MappingProfile()
    {
        CreateMap<Source, Destination>();
        
        // 중첩 객체도 잊지 말고!
        CreateMap<NestedSource, NestedDestination>();
    }
}

// 또는 AssertConfigurationIsValid로 미리 검증
mapper.ConfigurationProvider.AssertConfigurationIsValid();

❌ 실수 3: 컬렉션 매핑 시 null 처리 안 함

CreateMap<Post, PostDto>()
    .ForMember(dest => dest.Tags, opt => 
    {
        opt.PreCondition(src => src.Tags != null);
        opt.MapFrom(src => src.Tags.Select(t => t.Name).ToList());
    })
    // 또는 null 대신 빈 리스트
    .ForMember(dest => dest.Tags, opt => 
        opt.MapFrom(src => src.Tags != null 
            ? src.Tags.Select(t => t.Name).ToList() 
            : new List<string>()));

❌ 실수 4: 기존 객체 업데이트 시 실수

// 방법 1: ForAllMembers + Condition
CreateMap<UpdateUserDto, User>()
    .ForAllMembers(opts => 
        opts.Condition((src, dest, srcMember) => srcMember != null));

// 방법 2: 수동으로 null 체크
public async Task UpdateUserAsync(int id, UpdateUserDto dto)
{
    var user = await _context.Users.FindAsync(id);
    
    if (!string.IsNullOrEmpty(dto.Name))
        user.Name = dto.Name;
    
    if (!string.IsNullOrEmpty(dto.Email))
        user.Email = dto.Email;
    
    // ... 나머지 속성
}

❌ 실수 5: 성능 고려 없이 Include 남발

// ❌ 나쁜 예
var posts = await _context.Posts
    .Include(p => p.Author)
        .ThenInclude(a => a.Posts)  // 불필요!
    .Include(p => p.Comments)
        .ThenInclude(c => c.Author)
            .ThenInclude(a => a.Posts)  // 더욱 불필요!
    .ToListAsync();

// ✅ 좋은 예: ProjectTo 사용
var posts = await _context.Posts
    .ProjectTo<PostDto>(_mapper.ConfigurationProvider)
    .ToListAsync();
// AutoMapper가 필요한 것만 자동으로 조인!

🎓 고급 기법과 팁

기본은 마스터했으니, 이제 좀 더 고급 기법들을 알아보자! 🚀

1️⃣ Value Resolver 사용하기

복잡한 매핑 로직을 별도 클래스로 분리하면 재사용성과 테스트 용이성이 높아져:

// Value Resolver 정의
public class FullNameResolver : IValueResolver<User, UserDto, string>
{
    public string Resolve(User source, UserDto destination, string destMember, ResolutionContext context)
    {
        return $"{source.FirstName} {source.MiddleName} {source.LastName}".Trim();
    }
}

// Profile에서 사용
public class UserProfile : Profile
{
    public UserProfile()
    {
        CreateMap<User, UserDto>()
            .ForMember(dest => dest.FullName, 
                opt => opt.MapFrom<FullNameResolver>());
    }
}

// DI 등록
builder.Services.AddTransient<FullNameResolver>();

2️⃣ Type Converter 활용

특정 타입 간 변환 로직을 정의할 수 있어:

// DateTime을 특정 포맷 문자열로 변환
public class DateTimeToStringConverter : ITypeConverter<DateTime, string>
{
    public string Convert(DateTime source, string destination, ResolutionContext context)
    {
        return source.ToString("yyyy-MM-dd HH:mm:ss");
    }
}

// Profile에 등록
public class MappingProfile : Profile
{
    public MappingProfile()
    {
        CreateMap<DateTime, string>().ConvertUsing<DateTimeToStringConverter>();
        
        // 이제 DateTime → string 매핑이 자동으로 이 컨버터 사용
        CreateMap<Post, PostDto>();  // CreatedAt이 자동 변환됨
    }
}

3️⃣ Before/After Map 훅

매핑 전후에 추가 로직을 실행할 수 있어:

CreateMap<CreatePostDto, Post>()
    .BeforeMap((src, dest) =>
    {
        // 매핑 전 실행
        Console.WriteLine($"Creating post: {src.Title}");
    })
    .AfterMap((src, dest) =>
    {
        // 매핑 후 실행
        dest.Slug = dest.Slug?.ToLower();
        Console.WriteLine($"Post created with slug: {dest.Slug}");
    });

4️⃣ 조건부 매핑 고급 활용

CreateMap<User, UserDto>()
    // 조건에 따라 다른 값 매핑
    .ForMember(dest => dest.Status, opt => opt.MapFrom(src =>
        src.IsActive ? "활성" :
        src.IsSuspended ? "정지" :
        src.IsDeleted ? "삭제" : "알 수 없음"))
    // 특정 조건일 때만 매핑
    .ForMember(dest => dest.Email, opt =>
    {
        opt.Condition(src => src.EmailVerified);
        opt.MapFrom(src => src.Email);
    });

5️⃣ 동적 매핑 (Runtime에 결정)

// 사용자 역할에 따라 다른 DTO로 매핑
public async Task<object> GetUserProfile(int userId, string role)
{
    var user = await _context.Users.FindAsync(userId);
    
    return role switch
    {
        "Admin" => _mapper.Map<AdminUserDto>(user),
        "User" => _mapper.Map<UserDto>(user),
        "Guest" => _mapper.Map<PublicUserDto>(user),
        _ => throw new ArgumentException("Invalid role")
    };
}

6️⃣ 글로벌 설정

var config = new MapperConfiguration(cfg =>
{
    // 모든 매핑에 적용되는 글로벌 설정
    cfg.AllowNullCollections = true;  // null 컬렉션 허용
    cfg.AllowNullDestinationValues = true;  // null 대상 값 허용
    
    // 명명 규칙 설정
    cfg.SourceMemberNamingConvention = new LowerUnderscoreNamingConvention();
    cfg.DestinationMemberNamingConvention = new PascalCaseNamingConvention();
    
    // 프로필 추가
    cfg.AddProfile<UserProfile>();
    cfg.AddProfile<PostProfile>();
});

🌟 실무 베스트 프랙티스

지금까지 배운 내용을 바탕으로, 실무에서 꼭 지켜야 할 베스트 프랙티스를 정리해볼게! 📚

📁 MyProject.Solution
  📁 MyProject.Domain
    📁 Entities
      📄 User.cs
      📄 Post.cs
      📄 Comment.cs
  📁 MyProject.Application
    📁 DTOs
      📁 Users
        📄 UserDto.cs
        📄 CreateUserDto.cs
        📄 UpdateUserDto.cs
      📁 Posts
        📄 PostDto.cs
        📄 PostDetailDto.cs
        📄 CreatePostDto.cs
    📁 Mappings
      📄 UserProfile.cs
      📄 PostProfile.cs
    📁 Services
      📄 IUserService.cs
      📄 UserService.cs
  📁 MyProject.Api
    📁 Controllers
      📄 UsersController.cs
      📄 PostsController.cs
    📄 Program.cs
  📁 MyProject.Tests
    📁 Mappings
      📄 UserProfileTests.cs
      📄 PostProfileTests.cs
    📁 Services
      📄 UserServiceTests.cs