Aggregate initialization with required fields in Domain Driven Design

I have the following model:

public class Invoice{
    public Invoide(Guid customerId, string customerName){
        CustomerId = customerId;
        CustomerName = customerName;
    }

    [Required]
    public Guid Id{get;set;}

    [Required]
    public Guid CustomerId {get;set;}

    [Required(AllowEmptyStrings=false)]
    // The name is also stored to be independend from future customer changes
    public string CustomerName {get;set;}

    public IEnumerable<InvoiceItem> Items {get;set;}
}

public class InvoiceCreate: Dto{
    public Guid CustomerId{get;set;}
}

To create a new invoice I have the following classes:

public class InvoiceService : IInvoiceService{
    
    public InvoiceService(
        IInvoiceRepository invoiceReposiory, 
        ICustomerRepository customerRepository
    ){
      _invoiceRepository = invoiceRepository;
      _customerRepository = customerRepository;    
    }

    public async Task<Invoice> CreateAsync(Invoice invoice){
       ...
    }
}

public class InvoicesController{
    public InvoicesController(IInvoiceService invoiceService){
        ...
    }

    public async Task<IActionResult> CreateInvoiceAsync([FromBody] InvoiceCreate createDto)
    {
        Invoice invoice = new Invoice(
            createDto.CustomerId,
            ???? // CustomerName?
        )
    }
}

In this scenario I'm not sure where to fill the CustomerName because it is loaded from another repository and doesn't come from Request.

According to the domain driven design the customer name must be set on initialization because it is an required field. This would mean, that I need to load the customer in the Controller and the service must trust the "Controller-Layer" that this would be fine. (Otherwise if the service also loads the customer, I have duplicate DB-Requests)

The other solution would be to keep the required field empty and fill it in InvoiceService after initialization. But this would contradict the DDD Pattern and lead to an inconstitent invoice Model. In addition to that "DateTimes" cannot be kept empty.

What is the right solution to have a clean and stable procedure?

Your Invoice service should not expect an Invoice in CreateAsync. You should use the request Dto.

public class InvoiceService : IInvoiceService{
    
    public InvoiceService(
        IInvoiceRepository invoiceReposiory, 
        ICustomerRepository customerRepository
    ){
      _invoiceRepository = invoiceRepository;
      _customerRepository = customerRepository;    
    }

    public async Task<Invoice> CreateAsync(InvoiceCreate invoiceCreate){
       Customer customer = await _customerRepository.FindAsync(invoiceCreate.CustomerId);

       Invoice invoice = new Invoice(customer.Id, customer.Name);

       await _invoiceRepository.AddAsync(invoice);
    }
}

Alternatively, accept a Customer entity in the constructor of the Invoice:

public class Invoice{
    public Invoide(Customer customer){
        CustomerId = customer.Id;
        CustomerName = customer.Name;
    }

and then in your service use:

public async Task<Invoice> CreateAsync(InvoiceCreate invoiceCreate){
   Customer customer = await _customerRepository.FindAsync(invoiceCreate.CustomerId);

   Invoice invoice = new Invoice(customer);

   await _invoiceRepository.AddAsync(invoice);
}

In the meantime, your controller should be responsible for providing an Api endpoint and applying security checks before passing the Dto down to the service:

public class InvoicesController{
    public InvoicesController(IInvoiceService invoiceService){
        ...
    }
    
    [Authorize]
    public async Task<IActionResult> CreateInvoiceAsync([FromBody] InvoiceCreate createDto)
    {
        Invoice invoice = await _invoiceService.CreateAsync(createDto);
    }
}