Repository/Service Pattern Issues .NET Core

Having some architecture issues that I'm trying to work through. I need to find a better way to do what I'm trying to do.

Below is a brief mockup of how my services/repos look. My problem is I am getting a circular reference when activating them. The problem is there is code in each service that I need for example in the LoadService I may need to trigger a method in the CustomerService and vice versa.

Need help to understand the best approach here. I am trying to get these services in a SRP as much as possible.

LoadRepository

public class LoadRepository 
{
    private readonly DBContext _DBContext;

    public LoadRepository(DBContext DBContext)
    {
        _DBContext = DBContext;
    }

    public override DbSet<LoadEntity> LoadDbSet()
    {
        return _DBContext.Load;
    }
}

LoadService

public class LoadService 
{
    private readonly LoadRepository _loadRepository;
    private readonly ICustomerService _customerService;

    public LoadService(
        LoadRepository loadRepository,
        ICustomerService customerService
    ) 
    {
        _loadRepository = loadRepository;
        _customerService = customerService;
    }    
}

CustomerRepository

public class CustomerRepository 
{
    private readonly DBContext _DBContext;

    public CustomerRepository(DBContext DBContext)
    {
        _DBContext = DBContext;
    }

    public override DbSet<CustomerEntity> LoadDbSet()
    {
        return _DBContext.Customer;
    }
}

CustomerService

public class CustomerService 
{
    private readonly CustomerRepository _customerRepository;
    private readonly ILoadService _loadService;

    public CustomerService(
        CustomerRepository customerRepository,
        ILoadService loadService
    ) 
    {
        _customerRepository = customerRepository;
        _loadService = loadService;
    }    
}

In my personal experience it is better to avoid dependencies on the same level referencing each other. Move common functionality into some helper classes and/or inject all needed repositories into the corresponding services. For example :

public class LoadService 
{
    private readonly LoadRepository _loadRepository;
    private readonly CustomerRepository _customerRepository;

    public LoadService(
        LoadRepository loadRepository,
        CustomerRepository customerRepository
    ) 
    {
        _loadRepository = loadRepository;
        _customerRepository = customerService;
    }        
}

Another approach to mitigate the problem (if currently refactoring is to much of headache) - use lazy injection via factories, for example something like the following using factory via Func:

// default DI does not provide automatic Func registration
Services.AddScoped<Func<ICustomerService>>(sp => () => sp.GetRequiredService<>(ICustomerService))

public class LoadService 
{
    private readonly LoadRepository _loadRepository;
    private readonly Func<ICustomerService> _customerServiceFactory;


    public LoadService(
        LoadRepository loadRepository,
        Func<ICustomerService> customerService
    ) 
    {
        _loadRepository = loadRepository;
        _customerServiceFactory = customerService;
    }   
}

And when it is needed invoke the factory - _customerServiceFactory().SomeMethod(). Though note that this method can result in SO if you have cycle in invocations (i.e. ICustomerService.Foo() calls ILoadService.Bar() which calls ICustomerService.Foo()) which can be caught only in runtime.