Round #853

Define a DbContext with two entities (Order and Customer) related one-to-many. Show the OnModelCreating configuration and a simple query that loads orders with their customer.

```csharp using Microsoft.EntityFrameworkCore; using System; using System.Collections.Generic; using System.Linq; // Define the Customer entity public class Customer { public int Id { get; set; } public string Name { get; set; } public ICollection<Order> Orders { get; set; } } // Define the Order entity public class Order { public int Id { get; set; } public int CustomerId { get; set; } public Customer Customer { get; set; } public DateTime OrderDate { get; set; } } // Define the DbContext public class MyDbContext : DbContext { public DbSet<Customer> Customers { get; set; } public DbSet<Order> Orders { get; set; } protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder) { optionsBuilder.UseInMemoryDatabase(databaseName: "MyDbContext"); } protected override void OnModelCreating(ModelBuilder modelBuilder) { modelBuilder.Entity<Order>() .HasOne(o => o.Customer) .WithMany(c => c.Orders) .HasForeignKey(o => o.CustomerId); } } class Program { static void Main() { // Create a new instance of the DbContext using var context = new MyDbContext(); // Add some sample data var customer1 = new Customer { Name = "John Doe" }; var customer2 = new Customer { Name = "Jane Doe" }; var order1 = new Order { CustomerId = 1, OrderDate = DateTime.Now }; var order2 = new Order { CustomerId = 1, OrderDate = DateTime.Now }; var order3 = new Order { CustomerId = 2, OrderDate = DateTime.Now }; context.Customers.Add(customer1); context.Customers.Add(customer2); context.Orders.Add(order1); context.Orders.Add(order2); context.Orders.Add(order3); context.SaveChanges(); // Query orders with their customer var ordersWithCustomer = context.Orders .Include(o => o.Customer) .ToList(); foreach (var order in ordersWithCustomer) { Console.WriteLine($"Order {order.Id} - Customer: {order.Customer.Name} - Order Date: {order.OrderDate}"); } } } ``` In this example, we define two entities: `Customer` and `Order`. A customer can have multiple orders, and an order is associated with one customer. The `OnModelCreating` method is used to configure the one-to-many relationship between `Customer` and `Order`. The `Main` method demonstrates how to create a new instance of the `MyDbContext`, add some sample data, and query orders with their associated customer using the `Include` method to eager load the related data.

```csharp using Microsoft.EntityFrameworkCore; using Microsoft.Extensions.Logging; public class OrderContext : DbContext { private readonly ILogger<OrderContext> _logger; public OrderContext(DbContextOptions<OrderContext> options, ILogger<OrderContext> logger) : base(options) { _logger = logger; } public DbSet<Order> Orders { get; set; } public DbSet<Customer> Customers { get; set; } protected override void OnModelCreating(ModelBuilder modelBuilder) { modelBuilder.Entity<Order>() .HasOne(o => o.Customer) .WithMany(c => c.Orders) .HasForeignKey(o => o.CustomerId); } } public class Customer { public int Id { get; set; } public string Name { get; set; } public ICollection<Order> Orders { get; set; } } public class Order { public int Id { get; set; } public int CustomerId { get; set; } public Customer Customer { get; set; } public string Description { get; set; } } public class OrderContextConfiguration : IEntityTypeConfiguration<OrderContext> { public void Configure(EntityTypeBuilder<OrderContext> builder) { // Additional configuration if needed } } class Program { static async Task Main(string[] args) { var options = new DbContextOptionsBuilder<OrderContext>() .UseInMemoryDatabase(databaseName: "OrderDatabase") .Options; var loggerFactory = LoggerFactory.Create(builder => builder.AddConsole()); var logger = loggerFactory.CreateLogger<OrderContext>(); using var context = new OrderContext(options, logger); context.Database.EnsureCreated(); // Add some sample data var customer = new Customer { Name = "John Doe" }; context.Customers.Add(customer); context.SaveChanges(); var order = new Order { CustomerId = customer.Id, Description = "Sample Order" }; context.Orders.Add(order); context.SaveChanges(); // Query orders with their customer var ordersWithCustomer = await context.Orders .Include(o => o.Customer) .ToListAsync(); foreach (var orderWithCustomer in ordersWithCustomer) { Console.WriteLine($"Order {orderWithCustomer.Id} - Customer: {orderWithCustomer.Customer.Name}"); } } } ``` This implementation defines a `DbContext` named `OrderContext` with two entities: `Order` and `Customer`. The `OnModelCreating` method configures the one-to-many relationship between `Order` and `Customer`. The `Main` method demonstrates how to use the context to query orders with their associated customer. The `ILogger` of `T` injection is used to log any potential issues. Connection resilience and database health check are not explicitly implemented in this example but can be added as needed.