1. C# 프로젝트 구조화의 중요성 🎯

프로젝트 구조화가 왜 중요한지 생각해본 적 있어? 간단한 비유를 들어볼게. 네가 방을 정리하지 않고 모든 물건을 바닥에 던져두면 어떻게 될까? 필요한 물건을 찾는 데 엄청난 시간이 걸리겠지! 코드도 마찬가지야. 체계적인 구조 없이 모든 코드를 한 곳에 던져두면 유지보수는 악몽이 되고 말아. 🙈

재능넷 같은 플랫폼을 생각해봐. 만약 모든 재능이 카테고리 없이 한 페이지에 나열되어 있다면? 사용자는 원하는 서비스를 찾기 위해 수백 개의 항목을 스크롤해야 할 거야. 하지만 잘 분류된 카테고리 시스템 덕분에 사용자는 원하는 재능을 빠르게 찾을 수 있지. C# 프로젝트도 마찬가지야. 잘 구조화된 프로젝트는 개발자가 필요한 코드를 빠르게 찾고 이해할 수 있게 해줘. 🔍

위 그림에서 볼 수 있듯이, 구조화되지 않은 프로젝트는 복잡하고 이해하기 어려운 반면, 잘 구조화된 프로젝트는 명확한 계층과 책임 분리를 통해 코드를 더 쉽게 관리할 수 있게 해줘. 이제 C# 프로젝트를 어떻게 구조화할지 자세히 알아보자! 🧐

2. 기본적인 프로젝트 구조 이해하기 📂

C# 프로젝트의 기본 구조부터 알아볼까? Visual Studio에서 새 프로젝트를 만들면 기본적으로 생성되는 파일과 폴더들이 있어. 이것들이 어떤 역할을 하는지 이해하는 것부터 시작하자! 🚀

기본 구조를 이해하는 것은 좋은 프로젝트 구조를 설계하는 첫 걸음이야. 이 기본 구조 위에 우리의 비즈니스 로직과 기능들을 체계적으로 추가해 나갈 거야. 😊

MyAwesomeProject/
├── MyAwesomeProject.sln              # 솔루션 파일
├── src/                              # 소스 코드 폴더
│   ├── MyAwesomeProject.Core/        # 핵심 비즈니스 로직
│   │   ├── Models/                   # 도메인 모델 클래스들
│   │   ├── Services/                 # 비즈니스 서비스 구현
│   │   └── Interfaces/               # 인터페이스 정의
│   ├── MyAwesomeProject.Data/        # 데이터 액세스 레이어
│   │   ├── Repositories/             # 리포지토리 패턴 구현
│   │   ├── Context/                  # 데이터베이스 컨텍스트
│   │   └── Migrations/               # 데이터베이스 마이그레이션
│   └── MyAwesomeProject.Web/         # 웹 애플리케이션 프로젝트
│       ├── Controllers/              # MVC 컨트롤러
│       ├── Views/                    # MVC 뷰
│       ├── wwwroot/                  # 정적 파일(CSS, JS 등)
│       └── Program.cs                # 애플리케이션 진입점
├── tests/                            # 테스트 프로젝트 폴더
│   ├── MyAwesomeProject.Core.Tests/  # 핵심 로직 단위 테스트
│   ├── MyAwesomeProject.Data.Tests/  # 데이터 레이어 테스트
│   └── MyAwesomeProject.Web.Tests/   # 웹 프로젝트 테스트
└── docs/                             # 문서화 폴더
    ├── api/                          # API 문서
    └── guides/                       # 사용자 가이드
            

위 구조는 많은 전문 개발자들이 선호하는 방식이야. 소스 코드(src)와 테스트(tests)를 명확히 분리하고, 각 프로젝트는 단일 책임을 가지도록 구성했어. 이런 구조는 특히 중대형 프로젝트에서 코드 관리와 협업을 훨씬 쉽게 만들어줘. 마치 재능넷에서 다양한 재능들이 카테고리별로 잘 정리되어 있어서 원하는 서비스를 쉽게 찾을 수 있는 것처럼 말이야! 🎯

이제 기본 구조를 이해했으니, 솔루션과 프로젝트 간의 관계를 어떻게 설계할지 알아보자. 이 부분은 특히 프로젝트가 커질수록 더 중요해져! 👇

3. 솔루션과 프로젝트 관계 설계하기 🧩

C#에서 솔루션과 프로젝트의 관계는 어떻게 설계하는 게 좋을까? 이 부분은 많은 초보 개발자들이 헷갈려하는 부분이야. 간단히 설명하자면, 솔루션은 여러 프로젝트를 담는 컨테이너고, 각 프로젝트는 특정 기능이나 책임을 가진 코드 모음이야. 🧠

위 다이어그램에서 볼 수 있듯이, 일반적으로 UI 프로젝트는 Data 프로젝트를 참조하고, Data 프로젝트는 Core 프로젝트를 참조해. 이런 구조는 의존성이 한 방향으로만 흐르도록 해서 코드의 결합도를 낮추고 유지보수성을 높여줘. 😎

어떤 전략을 선택할지는 프로젝트의 크기와 복잡성, 팀의 규모, 그리고 비즈니스 요구사항에 따라 달라질 수 있어. 작은 프로젝트라면 단일 프로젝트로 시작해서 필요에 따라 분리하는 것도 좋은 전략이야. 🌱

솔루션과 프로젝트 구조를 잘 설계하면 코드 탐색이 쉬워지고, 새로운 팀원도 빠르게 적응할 수 있어. 마치 재능넷에서 원하는 서비스를 쉽게 찾을 수 있는 것처럼, 잘 구조화된 코드베이스에서는 필요한 코드를 빠르게 찾을 수 있지! 🔍

4. 클래스 및 네임스페이스 구성 전략 🏗️

프로젝트 구조를 잡았다면, 이제 그 안에 클래스와 네임스페이스를 어떻게 구성할지 생각해봐야 해. 이 부분은 코드의 가독성과 유지보수성에 직접적인 영향을 미치는 중요한 요소야! 🧐

CompanyName.ProductName.ModuleName.ComponentType

// 예시
MyCompany.MyApp.Core.Models
MyCompany.MyApp.Core.Services
MyCompany.MyApp.Data.Repositories
MyCompany.MyApp.Web.Controllers
            

예를 들어, 사용자 관리 기능을 구현한다고 생각해보자. 이런 식으로 클래스와 네임스페이스를 구성할 수 있어:

// 도메인 모델
namespace MyApp.Core.Models.Users
{
    public class User { /* ... */ }
    public class UserProfile { /* ... */ }
    public class UserSettings { /* ... */ }
}

// 서비스 인터페이스
namespace MyApp.Core.Services.Users
{
    public interface IUserService { /* ... */ }
    public interface IAuthenticationService { /* ... */ }
}

// 서비스 구현
namespace MyApp.Core.Services.Users.Implementations
{
    public class UserService : IUserService { /* ... */ }
    public class AuthenticationService : IAuthenticationService { /* ... */ }
}

// 데이터 액세스
namespace MyApp.Data.Repositories.Users
{
    public class UserRepository : IUserRepository { /* ... */ }
}

// API 컨트롤러
namespace MyApp.Web.Controllers.Users
{
    public class UserController : ControllerBase { /* ... */ }
    public class AuthController : ControllerBase { /* ... */ }
}
        

이런 구조는 코드의 위치를 직관적으로 예측할 수 있게 해줘. 예를 들어, 사용자 관련 서비스를 찾고 싶다면 MyApp.Core.Services.Users 네임스페이스를 살펴보면 되지! 😊

일관된 명명 규칙을 따르는 것은 코드 가독성을 크게 향상시켜줘. 팀 내에서 이러한 규칙을 문서화하고 공유하는 것이 좋아! 🤝

클래스와 네임스페이스를 잘 구성하면, 마치 잘 정리된 도서관처럼 필요한 코드를 빠르게 찾을 수 있어. 재능넷에서 원하는 서비스를 카테고리별로 쉽게 찾을 수 있는 것과 비슷하지! 이제 의존성 관리와 의존성 주입에 대해 알아보자. 👇

5. 의존성 관리와 DI(의존성 주입) 활용하기 💉

모듈화된 코드를 작성할 때 가장 중요한 개념 중 하나가 바로 의존성 관리야. 의존성 주입(Dependency Injection, DI)은 현대 C# 애플리케이션에서 거의 필수적인 패턴이 되었어. 이 패턴을 사용하면 코드의 결합도를 낮추고 테스트 가능성을 높일 수 있지! 🎯

public class UserService
{
    private readonly UserRepository _repository;
    
    public UserService()
    {
        // 직접 의존성 생성 - 강한 결합
        _repository = new UserRepository();
    }
    
    public User GetUser(int id)
    {
        return _repository.GetById(id);
    }
}
            

public class UserService
{
    private readonly IUserRepository _repository;
    
    // 생성자를 통한 의존성 주입
    public UserService(IUserRepository repository)
    {
        _repository = repository ?? throw new ArgumentNullException(nameof(repository));
    }
    
    public User GetUser(int id)
    {
        return _repository.GetById(id);
    }
}
            

의존성 주입을 사용하면 구체적인 구현체가 아닌 인터페이스에 의존하게 되어 코드가 더 유연해져. 예를 들어, 실제 데이터베이스 대신 메모리 내 저장소를 사용하는 테스트 코드를 쉽게 작성할 수 있지! 🧩

// Program.cs 또는 Startup.cs에서
public void ConfigureServices(IServiceCollection services)
{
    // 싱글톤 - 애플리케이션 생명주기 동안 하나의 인스턴스만 생성
    services.AddSingleton();
    
    // 스코프 - 요청마다 하나의 인스턴스 생성 (웹 애플리케이션에서 주로 사용)
    services.AddScoped();
    services.AddScoped();
    
    // 트랜지언트 - 요청될 때마다 새 인스턴스 생성
    services.AddTransient();
}
            

public class UserService
{
    private readonly IUserRepository _repository;
    
    public UserService(IUserRepository repository)
    {
        _repository = repository;
    }
}
            

public class UserService
{
    public ILogger Logger { get; set; }
    
    public void DoSomething()
    {
        Logger?.Log("작업 수행 중...");
    }
}
            

public class NotificationService
{
    public void SendNotification(string message, IMessageSender sender)
    {
        sender.Send(message);
    }
}
            

생성자 주입이 가장 권장되는 방식이야. 필수 의존성을 명확히 표현하고, 불변성을 보장하며, 테스트하기 쉽기 때문이지. 😊

의존성 주입을 활용하면 코드가 더 모듈화되고 테스트하기 쉬워져. 마치 재능넷에서 다양한 전문가들이 각자의 영역에서 서비스를 제공하듯이, 각 클래스도 자신의 책임에만 집중할 수 있게 되지! 이제 더 구체적인 모듈화 패턴에 대해 알아보자. 👇

6. 모듈화 패턴 적용하기 🧩

모듈화는 복잡한 시스템을 관리 가능한 작은 부분으로 나누는 과정이야. 잘 모듈화된 코드는 이해하기 쉽고, 재사용성이 높으며, 유지보수가 용이해. C#에서 활용할 수 있는 다양한 모듈화 패턴을 살펴보자! 🔍

이러한 원칙들을 바탕으로 다양한 모듈화 패턴을 적용할 수 있어. 가장 많이 사용되는 패턴들을 살펴보자! 👇

// 인터페이스 정의
public interface IUserRepository
{
    User GetById(int id);
    IEnumerable GetAll();
    void Add(User user);
    void Update(User user);
    void Delete(int id);
}

// 구현체 - EF Core 사용
public class EfUserRepository : IUserRepository
{
    private readonly AppDbContext _context;
    
    public EfUserRepository(AppDbContext context)
    {
        _context = context;
    }
    
    public User GetById(int id)
    {
        return _context.Users.Find(id);
    }
    
    // 나머지 메서드 구현...
}

// 비즈니스 로직에서 사용
public class UserService
{
    private readonly IUserRepository _repository;
    
    public UserService(IUserRepository repository)
    {
        _repository = repository;
    }
    
    public User GetUserDetails(int id)
    {
        var user = _repository.GetById(id);
        if (user == null)
            throw new NotFoundException("User not found");
            
        return user;
    }
}
            

// 서비스 인터페이스
public interface IOrderService
{
    Order CreateOrder(OrderRequest request);
    void CancelOrder(int orderId);
    OrderStatus GetOrderStatus(int orderId);
}

// 서비스 구현
public class OrderService : IOrderService
{
    private readonly IOrderRepository _orderRepository;
    private readonly IPaymentService _paymentService;
    private readonly INotificationService _notificationService;
    
    public OrderService(
        IOrderRepository orderRepository,
        IPaymentService paymentService,
        INotificationService notificationService)
    {
        _orderRepository = orderRepository;
        _paymentService = paymentService;
        _notificationService = notificationService;
    }
    
    public Order CreateOrder(OrderRequest request)
    {
        // 주문 유효성 검사
        ValidateOrder(request);
        
        // 주문 생성
        var order = new Order
        {
            CustomerId = request.CustomerId,
            Items = request.Items,
            TotalAmount = CalculateTotalAmount(request.Items)
        };
        
        // 결제 처리
        var paymentResult = _paymentService.ProcessPayment(order);
        if (paymentResult.Success)
        {
            order.Status = OrderStatus.Paid;
            _orderRepository.Add(order);
            
            // 알림 전송
            _notificationService.SendOrderConfirmation(order);
            
            return order;
        }
        
        throw new PaymentFailedException(paymentResult.ErrorMessage);
    }
    
    // 나머지 메서드 구현...
}
            

// 팩토리 인터페이스
public interface INotificationFactory
{
    INotificationSender CreateSender(NotificationType type);
}

// 팩토리 구현
public class NotificationFactory : INotificationFactory
{
    public INotificationSender CreateSender(NotificationType type)
    {
        return type switch
        {
            NotificationType.Email => new EmailSender(),
            NotificationType.SMS => new SmsSender(),
            NotificationType.PushNotification => new PushNotificationSender(),
            _ => throw new ArgumentException($"Unsupported notification type: {type}")
        };
    }
}

// 사용 예
public class NotificationService
{
    private readonly INotificationFactory _factory;
    
    public NotificationService(INotificationFactory factory)
    {
        _factory = factory;
    }
    
    public void SendNotification(string message, NotificationType type)
    {
        var sender = _factory.CreateSender(type);
        sender.Send(message);
    }
}
            

// 전략 인터페이스
public interface IDiscountStrategy
{
    decimal CalculateDiscount(Order order);
}

// 구체적인 전략들
public class NoDiscount : IDiscountStrategy
{
    public decimal CalculateDiscount(Order order) => 0;
}

public class PercentageDiscount : IDiscountStrategy
{
    private readonly decimal _percentage;
    
    public PercentageDiscount(decimal percentage)
    {
        _percentage = percentage;
    }
    
    public decimal CalculateDiscount(Order order)
    {
        return order.TotalAmount * _percentage / 100;
    }
}

public class BulkDiscount : IDiscountStrategy
{
    public decimal CalculateDiscount(Order order)
    {
        return order.Items.Count > 10 ? order.TotalAmount * 0.15m : 0;
    }
}

// 컨텍스트 클래스
public class PriceCalculator
{
    private IDiscountStrategy _discountStrategy;
    
    public PriceCalculator(IDiscountStrategy discountStrategy)
    {
        _discountStrategy = discountStrategy;
    }
    
    public void SetDiscountStrategy(IDiscountStrategy discountStrategy)
    {
        _discountStrategy = discountStrategy;
    }
    
    public decimal CalculateFinalPrice(Order order)
    {
        var discount = _discountStrategy.CalculateDiscount(order);
        return order.TotalAmount - discount;
    }
}
            

// 우리 시스템의 인터페이스
public interface IPaymentProcessor
{
    PaymentResult ProcessPayment(decimal amount, string cardNumber, string cvv);
}

// 외부 결제 서비스 (변경할 수 없는 코드)
public class ExternalPaymentService
{
    public bool MakePayment(PaymentDetails details)
    {
        // 외부 서비스의 결제 처리 로직
        Console.WriteLine($"Processing payment of {details.Amount} with card ending in {details.CardNumber.Substring(details.CardNumber.Length - 4)}");
        return true;
    }
}

public class PaymentDetails
{
    public decimal Amount { get; set; }
    public string CardNumber { get; set; }
    public string SecurityCode { get; set; }
    public string ExpiryDate { get; set; }
}

// 어댑터 클래스
public class ExternalPaymentAdapter : IPaymentProcessor
{
    private readonly ExternalPaymentService _externalService;
    
    public ExternalPaymentAdapter(ExternalPaymentService externalService)
    {
        _externalService = externalService;
    }
    
    public PaymentResult ProcessPayment(decimal amount, string cardNumber, string cvv)
    {
        var details = new PaymentDetails
        {
            Amount = amount,
            CardNumber = cardNumber,
            SecurityCode = cvv,
            ExpiryDate = "12/25" // 예시 값
        };
        
        bool success = _externalService.MakePayment(details);
        
        return new PaymentResult
        {
            Success = success,
            TransactionId = Guid.NewGuid().ToString(),
            ErrorMessage = success ? null : "Payment processing failed"
        };
    }
}
            

이러한 패턴들을 적절히 조합하면 코드의 모듈성이 크게 향상돼. 각 모듈은 자신의 책임에만 집중하고, 다른 모듈과는 잘 정의된 인터페이스를 통해 소통하게 되지. 마치 재능넷에서 각 전문가가 자신의 분야에서 최고의 서비스를 제공하는 것처럼 말이야! 🌟

이제 이러한 모듈화 패턴들을 어떻게 레이어드 아키텍처로 구성할 수 있는지 알아보자. 👇

7. 레이어드 아키텍처 구현하기 🏢

레이어드 아키텍처는 애플리케이션을 여러 수평적 계층으로 나누는 방식이야. 각 계층은 특정 책임을 가지며, 일반적으로 상위 계층은 하위 계층에 의존하는 구조를 가져. 이런 구조는 관심사 분리를 촉진하고 코드의 유지보수성을 높여줘! 🏗️

이제 각 레이어를 C# 프로젝트로 어떻게 구현할 수 있는지 살펴보자! 👇

// ASP.NET Core MVC 컨트롤러 예시
namespace MyApp.Web.Controllers
{
    public class ProductController : Controller
    {
        private readonly IProductService _productService;
        
        public ProductController(IProductService productService)
        {
            _productService = productService;
        }
        
        public async Task Index()
        {
            var products = await _productService.GetAllProductsAsync();
            return View(products);
        }
        
        public async Task Details(int id)
        {
            var product = await _productService.GetProductByIdAsync(id);
            if (product == null)
                return NotFound();
                
            return View(product);
        }
        
        [HttpPost]
        public async Task Create(ProductCreateViewModel model)
        {
            if (!ModelState.IsValid)
                return View(model);
                
            await _productService.CreateProductAsync(model.ToProduct());
            return RedirectToAction(nameof(Index));
        }
    }
}
            

// 서비스 인터페이스
namespace MyApp.Core.Services
{
    public interface IProductService
    {
        Task> GetAllProductsAsync();
        Task GetProductByIdAsync(int id);
        Task CreateProductAsync(Product product);
        Task UpdateProductAsync(Product product);
        Task DeleteProductAsync(int id);
    }
}

// 서비스 구현
namespace MyApp.Core.Services.Implementations
{
    public class ProductService : IProductService
    {
        private readonly IProductRepository _productRepository;
        private readonly IProductValidator _validator;
        private readonly ILogger _logger;
        
        public ProductService(
            IProductRepository productRepository,
            IProductValidator validator,
            ILogger logger)
        {
            _productRepository = productRepository;
            _validator = validator;
            _logger = logger;
        }
        
        public async Task> GetAllProductsAsync()
        {
            return await _productRepository.GetAllAsync();
        }
        
        public async Task GetProductByIdAsync(int id)
        {
            return await _productRepository.GetByIdAsync(id);
        }
        
        public async Task CreateProductAsync(Product product)
        {
            // 비즈니스 규칙 검증
            var validationResult = _validator.Validate(product);
            if (!validationResult.IsValid)
            {
                _logger.LogWarning("Product validation failed: {Errors}", 
                    string.Join(", ", validationResult.Errors));
                throw new ValidationException(validationResult.Errors);
            }
            
            // 중복 체크
            var existingProduct = await _productRepository.GetBySkuAsync(product.Sku);
            if (existingProduct != null)
            {
                throw new DuplicateResourceException($"Product with SKU '{product.Sku}' already exists");
            }
            
            // 저장
            await _productRepository.AddAsync(product);
            
            _logger.LogInformation("Product created: {ProductId}", product.Id);
            return product;
        }
        
        // 나머지 메서드 구현...
    }
}
            

// 리포지토리 인터페이스
namespace MyApp.Data.Repositories
{
    public interface IProductRepository
    {
        Task> GetAllAsync();
        Task GetByIdAsync(int id);
        Task GetBySkuAsync(string sku);
        Task AddAsync(Product product);
        Task UpdateAsync(Product product);
        Task DeleteAsync(int id);
    }
}

// EF Core 리포지토리 구현
namespace MyApp.Data.Repositories.Implementations
{
    public class EfProductRepository : IProductRepository
    {
        private readonly AppDbContext _dbContext;
        
        public EfProductRepository(AppDbContext dbContext)
        {
            _dbContext = dbContext;
        }
        
        public async Task> GetAllAsync()
        {
            return await _dbContext.Products
                .Include(p => p.Category)
                .ToListAsync();
        }
        
        public async Task GetByIdAsync(int id)
        {
            return await _dbContext.Products
                .Include(p => p.Category)
                .FirstOrDefaultAsync(p => p.Id == id);
        }
        
        public async Task GetBySkuAsync(string sku)
        {
            return await _dbContext.Products
                .FirstOrDefaultAsync(p => p.Sku == sku);
        }
        
        public async Task AddAsync(Product product)
        {
            await _dbContext.Products.AddAsync(product);
            await _dbContext.SaveChangesAsync();
        }
        
        // 나머지 메서드 구현...
    }
}
            

// 예외 처리 미들웨어
namespace MyApp.Infrastructure.Middleware
{
    public class ExceptionHandlingMiddleware
    {
        private readonly RequestDelegate _next;
        private readonly ILogger _logger;
        
        public ExceptionHandlingMiddleware(
            RequestDelegate next,
            ILogger logger)
        {
            _next = next;
            _logger = logger;
        }
        
        public async Task InvokeAsync(HttpContext context)
        {
            try
            {
                await _next(context);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "An unhandled exception occurred");
                await HandleExceptionAsync(context, ex);
            }
        }
        
        private static async Task HandleExceptionAsync(HttpContext context, Exception exception)
        {
            context.Response.ContentType = "application/json";
            
            var response = new ErrorResponse();
            
            switch (exception)
            {
                case NotFoundException notFoundEx:
                    context.Response.StatusCode = StatusCodes.Status404NotFound;
                    response.Message = notFoundEx.Message;
                    break;
                    
                case ValidationException validationEx:
                    context.Response.StatusCode = StatusCodes.Status400BadRequest;
                    response.Message = "Validation failed";
                    response.Errors = validationEx.Errors;
                    break;
                    
                default:
                    context.Response.StatusCode = StatusCodes.Status500InternalServerError;
                    response.Message = "An unexpected error occurred";
                    break;
            }
            
            await context.Response.WriteAsync(JsonSerializer.Serialize(response));
        }
    }
}
            

레이어드 아키텍처의 핵심은 각 레이어가 자신의 책임에만 집중하고, 다른 레이어와는 잘 정의된 인터페이스를 통해 소통한다는 점이야. 이렇게 하면 코드의 결합도가 낮아지고 유지보수성이 향상돼! 😊

레이어드 아키텍처는 많은 기업 애플리케이션에서 널리 사용되는 패턴이야. 재능넷과 같은 웹 애플리케이션도 이런 구조로 구현되어 있을 가능성이 높아. 각 레이어가 명확한 책임을 가지고 있어서 기능 추가나 변경이 용이하기 때문이지! 🌟

이제 테스트 가능한 구조를 어떻게 만들 수 있는지 알아보자. 👇

8. 테스트 가능한 구조 만들기 🧪

잘 설계된 프로젝트는 테스트하기 쉬운 구조를 가져야 해. 테스트 가능한 코드는 버그를 줄이고, 리팩토링을 용이하게 하며, 코드 품질을 높여줘. C# 프로젝트에서 테스트 가능한 구조를 만드는 방법을 알아보자! 🔍

MyAwesomeProject/
├── src/
│   ├── MyAwesomeProject.Core/
│   ├── MyAwesomeProject.Data/
│   └── MyAwesomeProject.Web/
├── tests/
│   ├── MyAwesomeProject.Core.Tests/
│   ├── MyAwesomeProject.Data.Tests/
│   └── MyAwesomeProject.Web.Tests/
            

MyAwesomeProject.Core.Tests/
├── Services/
│   ├── UserServiceTests.cs
│   ├── OrderServiceTests.cs
│   └── PaymentServiceTests.cs
├── Validators/
│   ├── UserValidatorTests.cs
│   └── OrderValidatorTests.cs
└── Helpers/
    └── StringHelperTests.cs
            

using System;
using System.Threading.Tasks;
using Moq;
using Xunit;
using MyApp.Core.Models;
using MyApp.Core.Services;
using MyApp.Core.Repositories;
using MyApp.Core.Exceptions;

namespace MyApp.Core.Tests.Services
{
    public class ProductServiceTests
    {
        private readonly Mock _mockRepository;
        private readonly Mock _mockValidator;
        private readonly Mock> _mockLogger;
        private readonly ProductService _service;
        
        public ProductServiceTests()
        {
            // 의존성 모의 객체 설정
            _mockRepository = new Mock();
            _mockValidator = new Mock();
            _mockLogger = new Mock>();
            
            // 테스트 대상 서비스 생성
            _service = new ProductService(
                _mockRepository.Object,
                _mockValidator.Object,
                _mockLogger.Object);
        }
        
        [Fact]
        public async Task GetProductById_ExistingProduct_ReturnsProduct()
        {
            // Arrange
            var expectedProduct = new Product { Id = 1, Name = "Test Product", Price = 9.99m };
            _mockRepository.Setup(repo => repo.GetByIdAsync(1))
                .ReturnsAsync(expectedProduct);
                
            // Act
            var result = await _service.GetProductByIdAsync(1);
            
            // Assert
            Assert.NotNull(result);
            Assert.Equal(expectedProduct.Id, result.Id);
            Assert.Equal(expectedProduct.Name, result.Name);
            Assert.Equal(expectedProduct.Price, result.Price);
        }
        
        [Fact]
        public async Task GetProductById_NonExistingProduct_ReturnsNull()
        {
            // Arrange
            _mockRepository.Setup(repo => repo.GetByIdAsync(999))
                .ReturnsAsync((Product)null);
                
            // Act
            var result = await _service.GetProductByIdAsync(999);
            
            // Assert
            Assert.Null(result);
        }
        
        [Fact]
        public async Task CreateProduct_ValidProduct_AddsToRepository()
        {
            // Arrange
            var product = new Product { Name = "New Product", Price = 19.99m, Sku = "NP001" };
            
            _mockValidator.Setup(v => v.Validate(product))
                .Returns(new ValidationResult { IsValid = true });
                
            _mockRepository.Setup(repo => repo.GetBySkuAsync(product.Sku))
                .ReturnsAsync((Product)null);
                
            // Act
            await _service.CreateProductAsync(product);
            
            // Assert
            _mockRepository.Verify(repo => repo.AddAsync(product), Times.Once);
        }
        
        [Fact]
        public async Task CreateProduct_InvalidProduct_ThrowsValidationException()
        {
            // Arrange
            var product = new Product { Name = "", Price = -1m };
            var errors = new[] { "Name is required", "Price must be positive" };
            
            _mockValidator.Setup(v => v.Validate(product))
                .Returns(new ValidationResult 
                { 
                    IsValid = false, 
                    Errors = errors 
                });
                
            // Act & Assert
            var exception = await Assert.ThrowsAsync(
                () => _service.CreateProductAsync(product));
                
            Assert.Equal(errors, exception.Errors);
        }
        
        [Fact]
        public async Task CreateProduct_DuplicateSku_ThrowsDuplicateResourceException()
        {
            // Arrange
            var product = new Product { Name = "New Product", Price = 19.99m, Sku = "NP001" };
            var existingProduct = new Product { Id = 1, Name = "Existing", Price = 9.99m, Sku = "NP001" };
            
            _mockValidator.Setup(v => v.Validate(product))
                .Returns(new ValidationResult { IsValid = true });
                
            _mockRepository.Setup(repo => repo.GetBySkuAsync(product.Sku))
                .ReturnsAsync(existingProduct);
                
            // Act & Assert
            await Assert.ThrowsAsync(
                () => _service.CreateProductAsync(product));
                
            _mockRepository.Verify(repo => repo.AddAsync(It.IsAny()), Times.Never);
        }
    }
}
            

using System;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.EntityFrameworkCore;
using Xunit;
using MyApp.Data;
using MyApp.Data.Repositories;
using MyApp.Core.Models;

namespace MyApp.Data.Tests.Repositories
{
    public class ProductRepositoryTests : IDisposable
    {
        private readonly AppDbContext _dbContext;
        private readonly ProductRepository _repository;
        
        public ProductRepositoryTests()
        {
            // 인메모리 데이터베이스 설정
            var options = new DbContextOptionsBuilder()
                .UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString())
                .Options;
                
            _dbContext = new AppDbContext(options);
            _repository = new ProductRepository(_dbContext);
            
            // 테스트 데이터 설정
            SeedDatabase();
        }
        
        private void SeedDatabase()
        {
            _dbContext.Products.AddRange(
                new Product { Id = 1, Name = "Product 1", Price = 9.99m, Sku = "P001" },
                new Product { Id = 2, Name = "Product 2", Price = 19.99m, Sku = "P002" },
                new Product { Id = 3, Name = "Product 3", Price = 29.99m, Sku = "P003" }
            );
            
            _dbContext.SaveChanges();
        }
        
        [Fact]
        public async Task GetAllAsync_ReturnsAllProducts()
        {
            // Act
            var products = await _repository.GetAllAsync();
            
            // Assert
            Assert.Equal(3, products.Count());
        }
        
        [Fact]
        public async Task GetByIdAsync_ExistingId_ReturnsProduct()
        {
            // Act
            var product = await _repository.GetByIdAsync(2);
            
            // Assert
            Assert.NotNull(product);
            Assert.Equal("Product 2", product.Name);
            Assert.Equal(19.99m, product.Price);
        }
        
        [Fact]
        public async Task GetByIdAsync_NonExistingId_ReturnsNull()
        {
            // Act
            var product = await _repository.GetByIdAsync(999);
            
            // Assert
            Assert.Null(product);
        }
        
        [Fact]
        public async Task AddAsync_NewProduct_AddsToDatabase()
        {
            // Arrange
            var newProduct = new Product
            {
                Name = "New Product",
                Price = 39.99m,
                Sku = "P004"
            };
            
            // Act
            await _repository.AddAsync(newProduct);
            
            // Assert
            Assert.NotEqual(0, newProduct.Id); // ID가 할당되었는지 확인
            
            var savedProduct = await _dbContext.Products.FindAsync(newProduct.Id);
            Assert.NotNull(savedProduct);
            Assert.Equal("New Product", savedProduct.Name);
        }
        
        // 리소스 정리
        public void Dispose()
        {
            _dbContext.Database.EnsureDeleted();
            _dbContext.Dispose();
        }
    }
}
            

테스트 가능한 코드를 작성하면 자연스럽게 더 나은 설계가 됩니다. 의존성 주입, 인터페이스 기반 설계, 단일 책임 원칙 등은 테스트 용이성을 높이면서 동시에 코드 품질도 향상시켜주지! 🌟

테스트는 코드의 품질을 보장하는 안전망 역할을 해. 마치 재능넷에서 서비스 품질을 검증하는 리뷰 시스템처럼, 테스트는 코드의 품질을 검증해주는 중요한 도구야. 이제 대규모 프로젝트를 관리하는 전략에 대해 알아보자! 👇

9. 대규모 프로젝트 관리 전략 🏢

프로젝트가 커질수록 코드 관리는 더 복잡해져. 대규모 C# 프로젝트를 효과적으로 관리하려면 추가적인 전략과 도구가 필요해. 수십 명의 개발자가 함께 작업하는 대형 프로젝트에서 사용하는 전략들을 알아보자! 🏗️

MyModularApp/
├── src/
│   ├── MyModularApp.SharedKernel/        # 공유 인터페이스, 모델, 유틸리티
│   ├── MyModularApp.Modules.Users/       # 사용자 관리 모듈
│   │   ├── Domain/                       # 도메인 모델
│   │   ├── Application/                  # 애플리케이션 서비스
│   │   ├── Infrastructure/               # 인프라 구현
│   │   └── API/                          # 모듈 API
│   ├── MyModularApp.Modules.Products/    # 제품 관리 모듈
│   │   ├── Domain/
│   │   ├── Application/
│   │   ├── Infrastructure/
│   │   └── API/
│   ├── MyModularApp.Modules.Orders/      # 주문 관리 모듈
│   │   ├── Domain/
│   │   ├── Application/
│   │   ├── Infrastructure/
│   │   └── API/
│   └── MyModularApp.Web/                 # 웹 애플리케이션 호스트
├── tests/
│   ├── MyModularApp.Modules.Users.Tests/
│   ├── MyModularApp.Modules.Products.Tests/
│   └── MyModularApp.Modules.Orders.Tests/
            

// Startup.cs에서 기능 플래그 설정
public void ConfigureServices(IServiceCollection services)
{
    // Microsoft.FeatureManagement 패키지 사용
    services.AddFeatureManagement()
        .AddFeatureFilter()
        .AddFeatureFilter();
        
    // 나머지 서비스 등록...
}

// 컨트롤러에서 기능 플래그 사용
public class ProductController : Controller
{
    private readonly IFeatureManager _featureManager;
    
    public ProductController(IFeatureManager featureManager)
    {
        _featureManager = featureManager;
    }
    
    public async Task Index()
    {
        ViewBag.NewUIEnabled = await _featureManager.IsEnabledAsync("NewProductUI");
        
        return View();
    }
    
    [FeatureGate("AdvancedFiltering")]
    public IActionResult AdvancedSearch()
    {
        // 이 액션은 'AdvancedFiltering' 기능이 활성화된 경우에만 접근 가능
        return View();
    }
}
            

// 명령 (Command)
public class CreateProductCommand : IRequest
{
    public string Name { get; set; }
    public string Description { get; set; }
    public decimal Price { get; set; }
    public string Category { get; set; }
}

// 명령 핸들러 (Command Handler)
public class CreateProductCommandHandler : IRequestHandler
{
    private readonly IProductRepository _repository;
    
    public CreateProductCommandHandler(IProductRepository repository)
    {
        _repository = repository;
    }
    
    public async Task Handle(CreateProductCommand command, CancellationToken cancellationToken)
    {
        var product = new Product
        {
            Name = command.Name,
            Description = command.Description,
            Price = command.Price,
            Category = command.Category
        };
        
        await _repository.AddAsync(product);
        
        return product.Id;
    }
}

// 쿼리 (Query)
public class GetProductByIdQuery : IRequest
{
    public int Id { get; set; }
}

// 쿼리 핸들러 (Query Handler)
public class GetProductByIdQueryHandler : IRequestHandler
{
    private readonly IProductReadRepository _readRepository;
    
    public GetProductByIdQueryHandler(IProductReadRepository readRepository)
    {
        _readRepository = readRepository;
    }
    
    public async Task Handle(GetProductByIdQuery query, CancellationToken cancellationToken)
    {
        return await _readRepository.GetProductDtoByIdAsync(query.Id);
    }
}

// 컨트롤러에서 사용
public class ProductController : ControllerBase
{
    private readonly IMediator _mediator;
    
    public ProductController(IMediator mediator)
    {
        _mediator = mediator;
    }
    
    [HttpGet("{id}")]
    public async Task> GetById(int id)
    {
        var query = new GetProductByIdQuery { Id = id };
        var result = await _mediator.Send(query);
        
        if (result == null)
            return NotFound();
            
        return result;
    }
    
    [HttpPost]
    public async Task> Create(CreateProductCommand command)
    {
        var productId = await _mediator.Send(command);
        return CreatedAtAction(nameof(GetById), new { id = productId }, productId);
    }
}
            

대규모 프로젝트 관리의 핵심은 명확한 경계와 책임 분리야. 각 모듈이나 서비스가 자신의 영역에만 집중할 수 있도록 설계하면, 전체 시스템의 복잡성을 관리하기 쉬워져. 마치 재능넷에서 각 전문가가 자신의 분야에서 최고의 서비스를 제공하는 것처럼 말이야! 🌟

이제 실전 프로젝트 구조화 사례를 통해 이론을 실제로 어떻게 적용할 수 있는지 알아보자. 👇

10. 실전 프로젝트 구조화 사례 분석 🔍

지금까지 배운 개념들을 실제 프로젝트에 어떻게 적용할 수 있는지 몇 가지 사례를 통해 알아보자! 실제 프로젝트 구조를 분석하면 이론이 어떻게 실전에서 활용되는지 더 잘 이해할 수 있어. 🧐

ECommerceApp/
├── src/
│   ├── ECommerceApp.Core/                # 핵심 비즈니스 로직
│   │   ├── Domain/                       # 도메인 모델
│   │   │   ├── Products/
│   │   │   ├── Orders/
│   │   │   ├── Customers/
│   │   │   └── Shared/
│   │   ├── Interfaces/                   # 인터페이스 정의
│   │   │   ├── Repositories/
│   │   │   ├── Services/
│   │   │   └── Infrastructure/
│   │   ├── Services/                     # 비즈니스 서비스
│   │   │   ├── ProductService.cs
│   │   │   ├── OrderService.cs
│   │   │   ├── CustomerService.cs
│   │   │   └── PaymentService.cs
│   │   └── Exceptions/                   # 사용자 정의 예외
│   │
│   ├── ECommerceApp.Infrastructure/      # 인프라 구현
│   │   ├── Data/                         # 데이터 액세스
│   │   │   ├── Context/
│   │   │   ├── Repositories/
│   │   │   ├── Migrations/
│   │   │   └── Configurations/
│   │   ├── Services/                     # 외부 서비스 통합
│   │   │   ├── EmailService.cs
│   │   │   ├── PaymentGatewayService.cs
│   │   │   └── ShippingService.cs
│   │   ├── Logging/                      # 로깅 구현
│   │   └── Security/                     # 보안 관련 구현
│   │
│   ├── ECommerceApp.Web/                 # 웹 애플리케이션
│   │   ├── Controllers/                  # MVC 컨트롤러
│   │   ├── Views/                        # MVC 뷰
│   │   ├── ViewModels/                   # 뷰모델
│   │   ├── Filters/                      # 액션 필터
│   │   ├── Middleware/                   # 커스텀 미들웨어
│   │   ├── wwwroot/                      # 정적 파일
│   │   ├── Program.cs                    # 진입점
│   │   └── Startup.cs                    # 애플리케이션 설정
│   │
│   └── ECommerceApp.API/                 # Web API
│       ├── Controllers/                  # API 컨트롤러
│       ├── Models/                       # API 모델
│       ├── Filters/                      # API 필터
│       ├── Program.cs                    # 진입점
│       └── Startup.cs                    # API 설정
│
├── tests/
│   ├── ECommerceApp.Core.Tests/          # 핵심 로직 테스트
│   ├── ECommerceApp.Infrastructure.Tests/ # 인프라 테스트
│   ├── ECommerceApp.Web.Tests/           # 웹 테스트
│   └── ECommerceApp.API.Tests/           # API 테스트
│
└── tools/                                # 유틸리티 스크립트
    ├── CodeGen/                          # 코드 생성 도구
    └── DbMigrator/                       # DB 마이그레이션 도구
            

// Startup.cs
public void ConfigureServices(IServiceCollection services)
{
    // 데이터베이스 컨텍스트 등록
    services.AddDbContext(options =>
        options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));
    
    // 리포지토리 등록
    services.AddScoped();
    services.AddScoped();
    services.AddScoped();
    
    // 서비스 등록
    services.AddScoped();
    services.AddScoped();
    services.AddScoped();
    services.AddScoped();
    
    // 인프라 서비스 등록
    services.AddTransient();
    services.AddTransient();
    services.AddTransient();
    
    // 기타 서비스 등록
    services.AddSingleton(sp => LogManager.GetLogger("ECommerceApp"));
    services.AddSingleton();
    
    // MVC 설정
    services.AddControllersWithViews();
}
            

CrmSystem/
├── src/
│   ├── CrmSystem.Domain/                 # 도메인 레이어
│   │   ├── Customers/                    # 고객 집계 루트
│   │   │   ├── Customer.cs               # 엔티티
│   │   │   ├── Events/                   # 도메인 이벤트
│   │   │   ├── ValueObjects/             # 값 객체
│   │   │   └── Specifications/           # 명세
│   │   ├── Sales/                        # 영업 집계 루트
│   │   ├── Marketing/                    # 마케팅 집계 루트
│   │   └── Shared/                       # 공유 개념
│   │
│   ├── CrmSystem.Application/            # 애플리케이션 레이어
│   │   ├── Customers/                    # 고객 관련 기능
│   │   │   ├── Commands/                 # 명령
│   │   │   ├── Queries/                  # 쿼리
│   │   │   ├── EventHandlers/            # 이벤트 핸들러
│   │   │   └── DTOs/                     # 데이터 전송 객체
│   │   ├── Sales/                        # 영업 관련 기능
│   │   ├── Marketing/                    # 마케팅 관련 기능
│   │   └── Common/                       # 공통 기능
│   │
│   ├── CrmSystem.Infrastructure/         # 인프라 레이어
│   │   ├── Persistence/                  # 영속성
│   │   │   ├── Configurations/           # EF 구성
│   │   │   ├── Repositories/             # 리포지토리 구현
│   │   │   ├── QueryServices/            # 쿼리 서비스
│   │   │   └── Migrations/               # DB 마이그레이션
│   │   ├── Identity/                     # 인증/인가
│   │   ├── Messaging/                    # 메시징 인프라
│   │   └── Services/                     # 외부 서비스
│   │
│   ├── CrmSystem.API/                    # API 레이어
│   │   ├── Controllers/                  # API 컨트롤러
│   │   ├── Filters/                      # API 필터
│   │   └── Middleware/                   # 커스텀 미들웨어
│   │
│   └── CrmSystem.UI/                     # 사용자 인터페이스
│       ├── Pages/                        # Razor Pages
│       ├── ViewModels/                   # 뷰모델
│       └── Services/                     # UI 서비스
│
├── tests/
│   ├── CrmSystem.Domain.Tests/           # 도메인 테스트
│   ├── CrmSystem.Application.Tests/      # 애플리케이션 테스트
│   ├── CrmSystem.Infrastructure.Tests/   # 인프라 테스트
│   └── CrmSystem.API.Tests/              # API 테스트
            

SaasPlatform/
├── services/
│   ├── identity-service/                 # 인증/인가 서비스
│   │   ├── SaasPlatform.Identity.API/    # API 프로젝트
│   │   ├── SaasPlatform.Identity.Core/   # 핵심 로직
│   │   ├── SaasPlatform.Identity.Data/   # 데이터 액세스
│   │   └── SaasPlatform.Identity.Tests/  # 테스트
│   │
│   ├── tenant-service/                   # 테넌트 관리 서비스
│   │   ├── SaasPlatform.Tenant.API/
│   │   ├── SaasPlatform.Tenant.Core/
│   │   ├── SaasPlatform.Tenant.Data/
│   │   └── SaasPlatform.Tenant.Tests/
│   │
│   ├── billing-service/                  # 결제 서비스
│   │   ├── SaasPlatform.Billing.API/
│   │   ├── SaasPlatform.Billing.Core/
│   │   ├── SaasPlatform.Billing.Data/
│   │   └── SaasPlatform.Billing.Tests/
│   │
│   └── notification-service/             # 알림 서비스
│       ├── SaasPlatform.Notification.API/
│       ├── SaasPlatform.Notification.Core/
│       ├── SaasPlatform.Notification.Data/
│       └── SaasPlatform.Notification.Tests/
│
├── gateway/                              # API 게이트웨이
│   └── SaasPlatform.Gateway/
│
├── web/                                  # 웹 프론트엔드
│   └── SaasPlatform.Web/
│
├── mobile/                               # 모바일 앱
│   ├── SaasPlatform.Mobile.Android/
│   └── SaasPlatform.Mobile.iOS/
│
└── shared/                               # 공유 라이브러리
    ├── SaasPlatform.Shared.Messaging/    # 메시징 인프라
    ├── SaasPlatform.Shared.Logging/      # 로깅 인프라
    └── SaasPlatform.Shared.Security/     # 보안 인프라
            

실제 프로젝트에서는 이론적인 패턴을 그대로 적용하기보다 프로젝트의 특성에 맞게 조정하는 경우가 많아. 중요한 것은 선택한 구조가 팀과 비즈니스 요구사항에 적합한지 여부야. 재능넷처럼 다양한 사용자와 서비스를 다루는 플랫폼이라면, 확장성과 유연성을 고려한 모듈화된 구조가 적합할 거야! 🌟

이제 우리가 배운 모든 내용을 종합해서 프로젝트를 구조화하고 모듈화하는 데 적용할 수 있을 거야. 어떤 프로젝트든 잘 구조화된 코드는 개발 생산성과 코드 품질을 크게 향상시켜준다는 점을 기억하자! 👍

결론: 나만의 C# 프로젝트 구조화 전략 만들기 🏆

지금까지 C# 프로젝트 구조화와 모듈화에 대해 깊이 있게 알아봤어. 좋은 프로젝트 구조는 마법처럼 저절로 생기는 것이 아니라, 신중한 계획과 지속적인 개선을 통해 만들어진다는 점을 기억하자! 🌱

프로젝트 구조화는 정답이 없는 여정이야. 중요한 것은 팀과 프로젝트의 특성에 맞는 구조를 찾고, 그것을 일관되게 적용하는 것이지. 재능넷처럼 다양한 기능과 사용자를 다루는 플랫폼이라면, 확장성과 유지보수성을 고려한 모듈화된 구조가 특히 중요할 거야. 🏗️

마지막으로, 코드 구조화는 기술적인 결정일 뿐만 아니라 팀의 협업 방식에도 큰 영향을 미친다는 점을 기억하자. 가장 좋은 구조는 팀원 모두가 이해하고 효과적으로 작업할 수 있는 구조야. 함께 성장하고 발전하는 코드베이스를 만들어 나가길 바랄게! 🚀