public class Address : IEntity<Guid> // or use abstract GuidEntity 
{
    public Guid Id { get; set; }

    public string City { get; set; }

    public string Street { get; set; }

    public string PostalCode { get; set; }

    public virtual Customer Customer { get; set; }

    public Guid CustomerId { get; set; }
}

public class Customer : IEntity<Guid> // or use abstract GuidEntity 
{
    public Guid Id { get; set; }

    public string Name { get; set; }
}

public class SampleDbContext : DbContext
{
    // or use dbcontext options
    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        // you could also say
        // optionsBuilder.UseSqlServer("MyConnectionString")
        // for instance you could inject your configuration and do it like
        // configuration.GetConnectionString("MyDb");
        // or implement the constructor with `DbContextOptions`
        optionsBuilder.UseInMemoryDatabase("SampleInMemoryDb");
    }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        var customerBuilder = modelBuilder.Entity<Customer>();

        customerBuilder.ToTable($"{nameof(Customer)}s");

        customerBuilder.HasKey(customer => customer.Id);

        customerBuilder.Property(customer => customer.Name)
            .IsRequired();

        customerBuilder.HasIndex(customer => customer.Name)
            .IsUnique();

        var addressBuilder = modelBuilder.Entity<Address>();

        addressBuilder.ToTable($"{nameof(Address)}es");

        addressBuilder.HasKey(address => address.Id);

        addressBuilder.Property(address => address.City)
            .IsRequired();

        addressBuilder.Property(address => address.Street)
            .IsRequired();

        addressBuilder.Property(address => address.PostalCode)
            .IsRequired();

        addressBuilder.HasOne(address => address.Customer)
            .WithMany(customer => customer.Addresses)
            .HasForeignKey(address => address.CustomerId)
            .OnDelete(DeleteBehavior.Restrict);
    }
}

var serviceProvider = new ServiceCollection()
    .AddDbContext<DbContext, SampleDbContext>(ServiceLifetime.Transient); // or whatever you need here
    // generic registration
    .AddTransient(typeof(IEntityRepository<,>), typeof(EntityRepository<,>))
    .AddTransient(typeof(IPagingRepository<,>), typeof(PagingRepository<,>)))
    .BuildServiceProvider();

var customerRepository = serviceProvider.GetRequiredService<IEntityRepository<Customer, Guid>>();

var google = new Customer
{
    Id = Guid.NewGuid(),
    Name = "Google",
    Addresses = new List<Address> {
        new Address {
            Id = Guid.NewGuid(),
            City = "San Francisco",
            PostalCode = "94043",
            Street = "Silicon Valley area"
        }
    }
};

// adding the customer and saving the changes
customerRepository.Add(customer);
customerRepository.EnsureChanges(); // this returns a bool when modifiedCount > 0

// now find the customer with an expression, also eager-load the addresses

var searchGoogle = customerRepository.Find(customer => customer.Name == "Google", customer => customer.Addresses);

// we now should have customer google with one address included by eager-loading it