Архитектура Onion в ASP.NET Core MVC

// Интерфейс в Domain слое
public interface IUserRepository 
{
    User GetById(int id);
    void Save(User user);
}
 
// Реализация во внешнем слое
public class SqlUserRepository : IUserRepository 
{
    private readonly ApplicationDbContext _context;
    
    public SqlUserRepository(ApplicationDbContext context) 
    {
        _context = context;
    }
    
    public User GetById(int id) 
    {
        return _context.Users.Find(id);
    }
    
    public void Save(User user) 
    {
        _context.Users.Update(user);
        _context.SaveChanges();
    }
}

services.AddScoped<IUserRepository, SqlUserRepository>();

Solution 'MyApp'
├── MyApp.Domain
├── MyApp.Application
├── MyApp.Infrastructure
├── MyApp.Services
└── MyApp.Web

// Базовая сущность
public abstract class BaseEntity
{
    public long Id { get; set; }
    public DateTime CreatedAt { get; set; }
    public DateTime ModifiedAt { get; set; }
    public string CreatedBy { get; set; }
    public string ModifiedBy { get; set; }
}
 
// Доменная сущность
public class User : BaseEntity
{
    public string UserName { get; private set; }
    public string Email { get; private set; }
    public string PasswordHash { get; private set; }
    public UserProfile Profile { get; private set; }
    
    // Конструктор
    public User(string userName, string email, string passwordHash)
    {
        if (string.IsNullOrEmpty(userName))
            throw new ArgumentException("UserName cannot be empty");
            
        if (string.IsNullOrEmpty(email))
            throw new ArgumentException("Email cannot be empty");
            
        UserName = userName;
        Email = email;
        PasswordHash = passwordHash;
        CreatedAt = DateTime.UtcNow;
        ModifiedAt = DateTime.UtcNow;
    }
    
    // Методы, выражающие поведение
    public void ChangeEmail(string newEmail)
    {
        if (string.IsNullOrEmpty(newEmail))
            throw new ArgumentException("Email cannot be empty");
            
        Email = newEmail;
        ModifiedAt = DateTime.UtcNow;
    }
    
    public void SetProfile(UserProfile profile)
    {
        Profile = profile ?? throw new ArgumentNullException(nameof(profile));
        ModifiedAt = DateTime.UtcNow;
    }
}
 
// Еще одна доменная сущность
public class UserProfile : BaseEntity
{
    public string FirstName { get; private set; }
    public string LastName { get; private set; }
    public string Address { get; private set; }
    public User User { get; private set; }
    
    // Конструктор и методы
    // ...
}

public interface IRepository<T> where T : BaseEntity
{
    IEnumerable<T> GetAll();
    T GetById(long id);
    void Add(T entity);
    void Update(T entity);
    void Delete(T entity);
    void SaveChanges();
}
 
public interface IUserRepository : IRepository<User>
{
    User GetByEmail(string email);
    User GetByUserName(string userName);
}

public class ApplicationDbContext : DbContext
{
    public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options)
        : base(options)
    {
    }
    
    public DbSet<User> Users { get; set; }
    public DbSet<UserProfile> UserProfiles { get; set; }
    
    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        // Конфигурация маппинга
        modelBuilder.Entity<User>(entity =>
        {
            entity.HasKey(e => e.Id);
            entity.Property(e => e.UserName).IsRequired();
            entity.Property(e => e.Email).IsRequired();
            entity.HasOne(e => e.Profile)
                  .WithOne(e => e.User)
                  .HasForeignKey<UserProfile>(e => e.Id);
        });
        
        // Конфигурация для других сущностей
        // ...
    }
}

public class Repository<T> : IRepository<T> where T : BaseEntity
{
    protected readonly ApplicationDbContext Context;
    protected readonly DbSet<T> DbSet;
    
    public Repository(ApplicationDbContext context)
    {
        Context = context;
        DbSet = context.Set<T>();
    }
    
    public IEnumerable<T> GetAll()
    {
        return DbSet.AsNoTracking().ToList();
    }
    
    public T GetById(long id)
    {
        return DbSet.Find(id);
    }
    
    public void Add(T entity)
    {
        DbSet.Add(entity);
    }
    
    public void Update(T entity)
    {
        DbSet.Update(entity);
    }
    
    public void Delete(T entity)
    {
        DbSet.Remove(entity);
    }
    
    public void SaveChanges()
    {
        Context.SaveChanges();
    }
}
 
public class UserRepository : Repository<User>, IUserRepository
{
    public UserRepository(ApplicationDbContext context) : base(context)
    {
    }
    
    public User GetByEmail(string email)
    {
        return DbSet.FirstOrDefault(u => u.Email == email);
    }
    
    public User GetByUserName(string userName)
    {
        return DbSet.FirstOrDefault(u => u.UserName == userName);
    }
}

public class UserDto
{
    public long Id { get; set; }
    public string UserName { get; set; }
    public string Email { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string Address { get; set; }
}
 
public class CreateUserDto
{
    public string UserName { get; set; }
    public string Email { get; set; }
    public string Password { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string Address { get; set; }
}

public interface IUserService
{
    IEnumerable<UserDto> GetAllUsers();
    UserDto GetUserById(long id);
    UserDto GetUserByEmail(string email);
    void CreateUser(CreateUserDto userDto);
    void UpdateUser(UserDto userDto);
    void DeleteUser(long id);
}

public class MappingProfile : Profile
{
    public MappingProfile()
    {
        CreateMap<User, UserDto>()
            .ForMember(dest => dest.FirstName, opt => opt.MapFrom(src => src.Profile.FirstName))
            .ForMember(dest => dest.LastName, opt => opt.MapFrom(src => src.Profile.LastName))
            .ForMember(dest => dest.Address, opt => opt.MapFrom(src => src.Profile.Address));
            
        CreateMap<CreateUserDto, User>()
            .ConstructUsing(src => new User(src.UserName, src.Email, 
                            // В реальном проекте здесь был бы хеш пароля
                            src.Password));
    }
}

public class UserService : IUserService
{
    private readonly IUserRepository _userRepository;
    private readonly IMapper _mapper;
    
    public UserService(IUserRepository userRepository, IMapper mapper)
    {
        _userRepository = userRepository;
        _mapper = mapper;
    }
    
    public IEnumerable<UserDto> GetAllUsers()
    {
        var users = _userRepository.GetAll();
        return _mapper.Map<IEnumerable<UserDto>>(users);
    }
    
    public UserDto GetUserById(long id)
    {
        var user = _userRepository.GetById(id);
        return user == null ? null : _mapper.Map<UserDto>(user);
    }
    
    public UserDto GetUserByEmail(string email)
    {
        var user = _userRepository.GetByEmail(email);
        return user == null ? null : _mapper.Map<UserDto>(user);
    }
    
    public void CreateUser(CreateUserDto userDto)
    {
        // Проверка, что пользователь с таким email не существует
        if (_userRepository.GetByEmail(userDto.Email) != null)
            throw new ApplicationException("User with this email already exists");
            
        var user = _mapper.Map<User>(userDto);
        
        // Создание профиля пользователя
        var profile = new UserProfile
        {
            FirstName = userDto.FirstName,
            LastName = userDto.LastName,
            Address = userDto.Address,
            CreatedAt = DateTime.UtcNow,
            ModifiedAt = DateTime.UtcNow
        };
        
        user.SetProfile(profile);
        _userRepository.Add(user);
        _userRepository.SaveChanges();
    }
    
    public void UpdateUser(UserDto userDto)
    {
        var user = _userRepository.GetById(userDto.Id);
        if (user == null)
            throw new ApplicationException("User not found");
            
        // Обновление email через метод домена для сохранения инвариантов
        if (user.Email != userDto.Email)
            user.ChangeEmail(userDto.Email);
            
        // Обновление профиля
        if (user.Profile != null)
        {
            user.Profile.FirstName = userDto.FirstName;
            user.Profile.LastName = userDto.LastName;
            user.Profile.Address = userDto.Address;
            user.Profile.ModifiedAt = DateTime.UtcNow;
        }
        
        _userRepository.Update(user);
        _userRepository.SaveChanges();
    }
    
    public void DeleteUser(long id)
    {
        var user = _userRepository.GetById(id);
        if (user == null)
            throw new ApplicationException("User not found");
            
        _userRepository.Delete(user);
        _userRepository.SaveChanges();
    }
}

public class UserController : Controller
{
    private readonly IUserService _userService;
    
    public UserController(IUserService userService)
    {
        _userService = userService;
    }
    
    public IActionResult Index()
    {
        var users = _userService.GetAllUsers();
        return View(users);
    }
    
    public IActionResult Details(long id)
    {
        var user = _userService.GetUserById(id);
        if (user == null)
            return NotFound();
            
        return View(user);
    }
    
    [HttpGet]
    public IActionResult Create()
    {
        return View();
    }
    
    [HttpPost]
    [ValidateAntiForgeryToken]
    public IActionResult Create(CreateUserDto model)
    {
        if (ModelState.IsValid)
        {
            try
            {
                _userService.CreateUser(model);
                return RedirectToAction(nameof(Index));
            }
            catch (ApplicationException ex)
            {
                ModelState.AddModelError("", ex.Message);
            }
        }
        
        return View(model);
    }
    
    // Другие экшены для обновления и удаления...
}

public class CreateUserDto
{
    [Required(ErrorMessage = "Имя пользователя обязательно")]
    [StringLength(50, MinimumLength = 3, ErrorMessage = "Имя должно быть от 3 до 50 символов")]
    public string UserName { get; set; }
    
    [Required(ErrorMessage = "Email обязателен")]
    [EmailAddress(ErrorMessage = "Некорректный формат email")]
    public string Email { get; set; }
    
    [Required(ErrorMessage = "Пароль обязателен")]
    [StringLength(100, MinimumLength = 6, ErrorMessage = "Пароль должен быть не менее 6 символов")]
    public string Password { get; set; }
    
    // Другие поля...
}

public class CreateUserValidator : AbstractValidator<CreateUserDto>
{
    private readonly IUserRepository _userRepository;
    
    public CreateUserValidator(IUserRepository userRepository)
    {
        _userRepository = userRepository;
        
        RuleFor(x => x.UserName)
            .Must(BeUniqueUserName).WithMessage("Пользователь с таким именем уже существует");
            
        RuleFor(x => x.Email)
            .Must(BeUniqueEmail).WithMessage("Пользователь с таким email уже существует");
    }
    
    private bool BeUniqueUserName(string userName)
    {
        return _userRepository.GetByUserName(userName) == null;
    }
    
    private bool BeUniqueEmail(string email)
    {
        return _userRepository.GetByEmail(email) == null;
    }
}

// Startup.cs
public void ConfigureServices(IServiceCollection services)
{
    // Другие регистрации...
    
    services.AddTransient<IValidator<CreateUserDto>, CreateUserValidator>();
    services.AddMvc(options =>
    {
        options.Filters.Add(typeof(ValidationActionFilter));
    });
}
 
// ValidationActionFilter.cs
public class ValidationActionFilter : IActionFilter
{
    private readonly IServiceProvider _serviceProvider;
    
    public ValidationActionFilter(IServiceProvider serviceProvider)
    {
        _serviceProvider = serviceProvider;
    }
    
    public void OnActionExecuting(ActionExecutingContext context)
    {
        if (!context.ModelState.IsValid)
            return;
            
        foreach (var argument in context.ActionArguments)
        {
            var validatorType = typeof(IValidator<>).MakeGenericType(argument.Value.GetType());
            var validator = _serviceProvider.GetService(validatorType) as IValidatorBase;
            
            if (validator != null)
            {
                var validationContext = new ValidationContext(argument.Value);
                var validationResult = validator.Validate(validationContext);
                
                foreach (var error in validationResult.Errors)
                {
                    context.ModelState.AddModelError(error.PropertyName, error.ErrorMessage);
                }
            }
        }
    }
    
    public void OnActionExecuted(ActionExecutedContext context)
    {
        // Ничего не делаем
    }
}

public void ConfigureServices(IServiceCollection services)
{
    // Контекст базы данных обычно регистрируется как Scoped
    services.AddDbContext<ApplicationDbContext>(options => 
        options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));
    
    // Репозитории как Scoped, так как они используют DbContext
    services.AddScoped(typeof(IRepository<>), typeof(Repository<>));
    services.AddScoped<IUserRepository, UserRepository>();
    
    // Сервисы как Scoped или Transient, в зависимости от их состояния
    services.AddScoped<IUserService, UserService>();
    
    // Вспомогательные утилиты часто как Singleton
    services.AddSingleton<IEmailSender, EmailSender>();
    
    // Автомаппер
    services.AddAutoMapper(typeof(Startup));
    
    // MVC
    services.AddControllersWithViews();
}

public interface IUnitOfWork : IDisposable
{
    IUserRepository Users { get; }
    IUserProfileRepository UserProfiles { get; }
    // Другие репозитории...
    
    int SaveChanges();
    Task<int> SaveChangesAsync();
}
 
public class UnitOfWork : IUnitOfWork
{
    private readonly ApplicationDbContext _context;
    private IUserRepository _userRepository;
    private IUserProfileRepository _userProfileRepository;
    
    public UnitOfWork(ApplicationDbContext context)
    {
        _context = context;
    }
    
    public IUserRepository Users => 
        _userRepository ??= new UserRepository(_context);
        
    public IUserProfileRepository UserProfiles => 
        _userProfileRepository ??= new UserProfileRepository(_context);
    
    public int SaveChanges()
    {
        return _context.SaveChanges();
    }
    
    public async Task<int> SaveChangesAsync()
    {
        return await _context.SaveChangesAsync();
    }
    
    public void Dispose()
    {
        _context.Dispose();
    }
}

services.AddScoped<IUnitOfWork, UnitOfWork>();

public class UserService : IUserService
{
    private readonly IUnitOfWork _unitOfWork;
    private readonly IMapper _mapper;
    
    public UserService(IUnitOfWork unitOfWork, IMapper mapper)
    {
        _unitOfWork = unitOfWork;
        _mapper = mapper;
    }
    
    public void CreateUser(CreateUserDto userDto)
    {
        // Проверка уникальности email
        if (_unitOfWork.Users.GetByEmail(userDto.Email) != null)
            throw new ApplicationException("User with this email already exists");
        
        var user = _mapper.Map<User>(userDto);
        
        // Создание профиля пользователя
        var profile = new UserProfile
        {
            FirstName = userDto.FirstName,
            LastName = userDto.LastName,
            Address = userDto.Address,
            CreatedAt = DateTime.UtcNow,
            ModifiedAt = DateTime.UtcNow
        };
        
        user.SetProfile(profile);
        
        // Добавление и сохранение в одной транзакции
        _unitOfWork.Users.Add(user);
        _unitOfWork.SaveChanges();
    }
    
    // Другие методы...
}

   services.AddTransient<IEmailValidator, EmailValidator>();

   services.AddScoped<IUserService, UserService>();

   services.AddSingleton<ICacheManager, MemoryCacheManager>();

   services.AddTransient<Func<PaymentType, IPaymentProcessor>>(serviceProvider => paymentType =>
   {
       return paymentType switch
       {
           PaymentType.CreditCard => serviceProvider.GetService<ICreditCardProcessor>(),
           PaymentType.PayPal => serviceProvider.GetService<IPayPalProcessor>(),
           _ => throw new NotSupportedException($"Payment type {paymentType} not supported")
       };
   });

public void ConfigureServices(IServiceCollection services)
{
    // Базовые сервисы ASP.NET Core
    services.AddControllersWithViews();
    
    // Не вызываем BuildServiceProvider здесь!
}
 
public void ConfigureContainer(ContainerBuilder builder)
{
    // Регистрация репозиториев
    builder.RegisterGeneric(typeof(Repository<>))
           .As(typeof(IRepository<>))
           .InstancePerLifetimeScope();
           
    // Регистрация всех реализаций интерфейса
    builder.RegisterAssemblyTypes(Assembly.GetExecutingAssembly())
           .Where(t => t.Name.EndsWith("Repository"))
           .AsImplementedInterfaces()
           .InstancePerLifetimeScope();
           
    // Регистрация сервисов
    builder.RegisterAssemblyTypes(Assembly.GetExecutingAssembly())
           .Where(t => t.Name.EndsWith("Service"))
           .AsImplementedInterfaces()
           .InstancePerLifetimeScope();
           
    // Условная регистрация
    builder.Register<IPaymentProcessor>(c =>
    {
        var env = c.Resolve<IHostEnvironment>();
        if (env.IsDevelopment())
            return new MockPaymentProcessor();
        else
            return new RealPaymentProcessor(c.Resolve<IConfiguration>());
    }).InstancePerLifetimeScope();
    
    // Декораторы
    builder.RegisterType<UserRepository>().As<IUserRepository>();
    builder.RegisterDecorator<CachingUserRepository, IUserRepository>();
}

public class AuditingRepository<T> : IRepository<T> where T : BaseEntity
{
    private readonly IRepository<T> _repository;
    private readonly IAuditLogger _auditLogger;
    
    public AuditingRepository(IRepository<T> repository, IAuditLogger auditLogger)
    {
        _repository = repository;
        _auditLogger = auditLogger;
    }
    
    public void Add(T entity)
    {
        _repository.Add(entity);
        _auditLogger.LogAddition(typeof(T).Name, entity.Id);
    }
    
    public void Update(T entity)
    {
        _repository.Update(entity);
        _auditLogger.LogUpdate(typeof(T).Name, entity.Id);
    }
    
    // Остальные методы...
}

public class CreateUserCommand : IRequest<long>
{
 public string UserName { get; set; }
 public string Email { get; set; }
 public string Password { get; set; }
 public string FirstName { get; set; }
 public string LastName { get; set; }
 public string Address { get; set; }
}
 
public class CreateUserCommandHandler : IRequestHandler<CreateUserCommand, long>
{
 private readonly IUserRepository _userRepository;
 private readonly IPasswordHasher _passwordHasher;
 
 public CreateUserCommandHandler(IUserRepository userRepository, IPasswordHasher passwordHasher)
 {
     _userRepository = userRepository;
     _passwordHasher = passwordHasher;
 }
 
 public async Task<long> Handle(CreateUserCommand request, CancellationToken cancellationToken)
 {
     // Проверка уникальности email
     if (await _userRepository.GetByEmailAsync(request.Email) != null)
         throw new ApplicationException("User with this email already exists");
     
     // Создание пользователя
     var user = new User(
         request.UserName,
         request.Email,
         _passwordHasher.HashPassword(request.Password)
     );
     
     // Создание профиля
     var profile = new UserProfile
     {
         FirstName = request.FirstName,
         LastName = request.LastName,
         Address = request.Address,
         CreatedAt = DateTime.UtcNow,
         ModifiedAt = DateTime.UtcNow
     };
     
     user.SetProfile(profile);
     
     // Сохранение в БД
     await _userRepository.AddAsync(user);
     await _userRepository.SaveChangesAsync();
     
     return user.Id;
 }
}

public class GetUserByIdQuery : IRequest<UserDto>
{
 public long Id { get; set; }
}
 
public class GetUserByIdQueryHandler : IRequestHandler<GetUserByIdQuery, UserDto>
{
 private readonly IUserRepository _userRepository;
 private readonly IMapper _mapper;
 
 public GetUserByIdQueryHandler(IUserRepository userRepository, IMapper mapper)
 {
     _userRepository = userRepository;
     _mapper = mapper;
 }
 
 public async Task<UserDto> Handle(GetUserByIdQuery request, CancellationToken cancellationToken)
 {
     var user = await _userRepository.GetByIdAsync(request.Id);
     return user == null ? null : _mapper.Map<UserDto>(user);
 }
}

public class UserController : Controller
{
 private readonly IMediator _mediator;
 
 public UserController(IMediator mediator)
 {
     _mediator = mediator;
 }
 
 [HttpGet("{id}")]
 public async Task<ActionResult<UserDto>> GetUser(long id)
 {
     var query = new GetUserByIdQuery { Id = id };
     var result = await _mediator.Send(query);
     
     if (result == null)
         return NotFound();
         
     return Ok(result);
 }
 
 [HttpPost]
 public async Task<ActionResult<long>> CreateUser(CreateUserCommand command)
 {
     try
     {
         var userId = await _mediator.Send(command);
         return CreatedAtAction(nameof(GetUser), new { id = userId }, null);
     }
     catch (ApplicationException ex)
     {
         return BadRequest(ex.Message);
     }
 }
}

public class ValidationBehavior<TRequest, TResponse> : IPipelineBehavior<TRequest, TResponse>
{
 private readonly IValidator<TRequest> _validator;
 
 public ValidationBehavior(IValidator<TRequest> validator = null)
 {
     _validator = validator;
 }
 
 public async Task<TResponse> Handle(TRequest request, CancellationToken cancellationToken, RequestHandlerDelegate<TResponse> next)
 {
     if (_validator == null)
         return await next();
     
     var validationResult = await _validator.ValidateAsync(request, cancellationToken);
     if (validationResult.IsValid)
         return await next();
     
     throw new ValidationException(validationResult.Errors);
 }
}

services.AddTransient(typeof(IPipelineBehavior<,>), typeof(ValidationBehavior<,>));

public class UserServiceTests
{
   private readonly Mock<IUserRepository> _mockUserRepository;
   private readonly Mock<IMapper> _mockMapper;
   private readonly UserService _userService;
   
   public UserServiceTests()
   {
       _mockUserRepository = new Mock<IUserRepository>();
       _mockMapper = new Mock<IMapper>();
       _userService = new UserService(_mockUserRepository.Object, _mockMapper.Object);
   }
   
   [Fact]
   public void GetUserById_WhenUserExists_ReturnsUserDto()
   {
       // Arrange
       var userId = 1L;
       var user = new User("testuser", "test@example.com", "hash");
       var userDto = new UserDto { Id = userId, UserName = "testuser", Email = "test@example.com" };
       
       _mockUserRepository.Setup(r => r.GetById(userId)).Returns(user);
       _mockMapper.Setup(m => m.Map<UserDto>(user)).Returns(userDto);
       
       // Act
       var result = _userService.GetUserById(userId);
       
       // Assert
       Assert.NotNull(result);
       Assert.Equal(userDto.UserName, result.UserName);
       
       // Verify repository was called correctly
       _mockUserRepository.Verify(r => r.GetById(userId), Times.Once);
   }
}

public class UserControllerIntegrationTests : IClassFixture<WebApplicationFactory<Startup>>
{
   private readonly WebApplicationFactory<Startup> _factory;
   
   public UserControllerIntegrationTests(WebApplicationFactory<Startup> factory)
   {
       _factory = factory.WithWebHostBuilder(builder =>
       {
           builder.ConfigureServices(services =>
           {
               // Заменяем настоящий DbContext на тестовый с In-Memory базой
               services.RemoveAll(typeof(ApplicationDbContext));
               services.AddDbContext<ApplicationDbContext>(options =>
                   options.UseInMemoryDatabase("TestDb"));
                   
               // Инициализируем тестовые данные
               var sp = services.BuildServiceProvider();
               using var scope = sp.CreateScope();
               var db = scope.ServiceProvider.GetRequiredService<ApplicationDbContext>();
               // Добавление тестовых пользователей...
           });
       });
   }
   
   [Fact]
   public async Task GetUser_ReturnsSuccessAndCorrectContentType()
   {
       // Arrange
       var client = _factory.CreateClient();
       
       // Act
       var response = await client.GetAsync("/api/users/1");
       
       // Assert
       response.EnsureSuccessStatusCode();
       Assert.Equal("application/json; charset=utf-8", 
                   response.Content.Headers.ContentType.ToString());
   }
}

public class InMemoryUserRepository : IUserRepository
{
   private readonly List<User> _users = new List<User>();
   private long _nextId = 1;
   
   public User GetById(long id)
   {
       return _users.FirstOrDefault(u => u.Id == id);
   }
   
   public void Add(User user)
   {
       user.Id = _nextId++;
       _users.Add(user);
   }
   
   // Другие методы...
}

OnionArchitecture.sln
├── src
│   ├── OnionArchitecture.Domain
│   ├── OnionArchitecture.Application
│   ├── OnionArchitecture.Infrastructure
│   └── OnionArchitecture.Web
└── tests
    ├── OnionArchitecture.Domain.Tests
    ├── OnionArchitecture.Application.Tests
    └── OnionArchitecture.Infrastructure.Tests

// OnionArchitecture.Domain/Entities/User.cs
public class User : BaseEntity
{
    private User() { } // Для EF Core
 
    public User(string username, string email, string passwordHash)
    {
        Username = username ?? throw new ArgumentNullException(nameof(username));
        Email = email ?? throw new ArgumentNullException(nameof(email));
        PasswordHash = passwordHash ?? throw new ArgumentNullException(nameof(passwordHash));
        CreatedAt = DateTime.UtcNow;
    }
 
    public string Username { get; private set; }
    public string Email { get; private set; }
    public string PasswordHash { get; private set; }
    public UserProfile Profile { get; private set; }
 
    public void UpdateEmail(string email)
    {
        Email = email ?? throw new ArgumentNullException(nameof(email));
        ModifiedAt = DateTime.UtcNow;
    }
 
    public void SetProfile(UserProfile profile)
    {
        Profile = profile ?? throw new ArgumentNullException(nameof(profile));
        ModifiedAt = DateTime.UtcNow;
    }
}

// OnionArchitecture.Domain/Repositories/IUserRepository.cs
public interface IUserRepository
{
    Task<User> GetByIdAsync(int id);
    Task<User> GetByEmailAsync(string email);
    Task<IEnumerable<User>> GetAllAsync();
    Task AddAsync(User user);
    void Update(User user);
    void Remove(User user);
    Task<int> SaveChangesAsync();
}

// OnionArchitecture.Application/DTOs/UserDto.cs
public class UserDto
{
    public int Id { get; set; }
    public string Username { get; set; }
    public string Email { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public DateTime CreatedAt { get; set; }
}
 
// OnionArchitecture.Application/Services/IUserService.cs
public interface IUserService
{
    Task<UserDto> GetByIdAsync(int id);
    Task<IEnumerable<UserDto>> GetAllAsync();
    Task<int> CreateAsync(CreateUserDto createUserDto);
    Task UpdateAsync(UpdateUserDto updateUserDto);
    Task DeleteAsync(int id);
}

// OnionArchitecture.Application/Services/UserService.cs
public class UserService : IUserService
{
    private readonly IUserRepository _userRepository;
    private readonly IMapper _mapper;
    private readonly IPasswordHasher _passwordHasher;
 
    public UserService(IUserRepository userRepository, IMapper mapper, IPasswordHasher passwordHasher)
    {
        _userRepository = userRepository;
        _mapper = mapper;
        _passwordHasher = passwordHasher;
    }
 
    public async Task<UserDto> GetByIdAsync(int id)
    {
        var user = await _userRepository.GetByIdAsync(id);
        return user != null ? _mapper.Map<UserDto>(user) : null;
    }
 
    public async Task<int> CreateAsync(CreateUserDto createUserDto)
    {
        // Проверка уникальности email
        if (await _userRepository.GetByEmailAsync(createUserDto.Email) != null)
            throw new ApplicationException("Email already exists");
 
        // Создаем пользователя
        var passwordHash = _passwordHasher.HashPassword(createUserDto.Password);
        var user = new User(createUserDto.Username, createUserDto.Email, passwordHash);
 
        // Создаем профиль
        var profile = new UserProfile(createUserDto.FirstName, createUserDto.LastName);
        user.SetProfile(profile);
 
        // Сохраняем
        await _userRepository.AddAsync(user);
        await _userRepository.SaveChangesAsync();
 
        return user.Id;
    }
 
    // Остальные методы...
}

// OnionArchitecture.Infrastructure/Data/ApplicationDbContext.cs
public class ApplicationDbContext : DbContext
{
    public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options) : base(options) {}
 
    public DbSet<User> Users { get; set; }
    public DbSet<UserProfile> UserProfiles { get; set; }
 
    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        // Конфигурация моделей...
    }
}
 
// OnionArchitecture.Infrastructure/Repositories/UserRepository.cs
public class UserRepository : IUserRepository
{
    private readonly ApplicationDbContext _context;
 
    public UserRepository(ApplicationDbContext context)
    {
        _context = context;
    }
 
    public async Task<User> GetByIdAsync(int id)
    {
        return await _context.Users
            .Include(u => u.Profile)
            .FirstOrDefaultAsync(u => u.Id == id);
    }
 
    // Остальные методы...
}

// OnionArchitecture.Web/Controllers/UsersController.cs
[ApiController]
[Route("api/[controller]")]
public class UsersController : ControllerBase
{
    private readonly IUserService _userService;
 
    public UsersController(IUserService userService)
    {
        _userService = userService;
    }
 
    [HttpGet("{id}")]
    public async Task<ActionResult<UserDto>> GetUser(int id)
    {
        var user = await _userService.GetByIdAsync(id);
        if (user == null)
            return NotFound();
 
        return user;
    }
 
    [HttpPost]
    public async Task<ActionResult<int>> CreateUser(CreateUserDto createUserDto)
    {
        try
        {
            var userId = await _userService.CreateAsync(createUserDto);
            return CreatedAtAction(nameof(GetUser), new { id = userId }, null);
        }
        catch (ApplicationException ex)
        {
            return BadRequest(ex.Message);
        }
    }
 
    // Остальные методы...
}

public void ConfigureServices(IServiceCollection services)
{
    // DbContext
    services.AddDbContext<ApplicationDbContext>(options =>
        options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));
 
    // Репозитории
    services.AddScoped<IUserRepository, UserRepository>();
 
    // Сервисы
    services.AddScoped<IUserService, UserService>();
    services.AddScoped<IPasswordHasher, BCryptPasswordHasher>();
 
    // AutoMapper
    services.AddAutoMapper(typeof(MappingProfile));
 
    services.AddControllers();
}