FROM ENTITY TO CONTEXT

About the Book

What does an enterprise EF Core model look like when the DbContext stops being a dumping ground and every entity gets its own professional configuration file?

From Entity to Context is the EF Core configuration companion to the NEXUS-1 schema atlas. It takes the database backbone defined in From Schema to System and shows how that structure can be mapped cleanly into C# using Entity Framework Core, Fluent API, configuration classes, migrations, indexes, relationships, defaults, constraints, and schema-aware folder organization.

This is not a general EF Core tutorial. It is a practical configuration atlas for a large industrial digital-twin platform. The focus is Code First, but not Code First as a toy example. The book shows how Code First can be organized in an enterprise-level project where the model is too large to live inside one OnModelCreating method.

The central idea is simple:

One entity should have one clear mapping, and the context should remain clean.

Instead of filling the DbContext with hundreds or thousands of mapping lines, each entity receives its own IEntityTypeConfiguration<T> class. Keys, table names, schema names, indexes, precision, default values, relationships, delete behavior, row versions, lookup-table conventions, and foreign-key names are placed where they belong: beside the entity they configure.

The result is a model that a programmer can navigate, review, test, migrate, and maintain.

What This Book Contains

The book contains the complete EF Core configuration atlas for the NEXUS-1 companion system.

It includes:

• EF Core Code First reminder chapter
• clean DbContext pattern
• ApplyConfigurationsFromAssembly
• schema-based folder structure
• configuration classes using IEntityTypeConfiguration<T>
• Fluent API mapping examples
• table and schema naming conventions
• primary-key configuration
• alternate keys and unique indexes
• required and optional properties
• SQL Server default values
• DATETIME2, decimal precision, and string-length conventions
• row-version and concurrency patterns
• lookup-table configuration patterns
• cross-schema foreign-key mapping
• migration and verification notes
• configuration indexes for the full atlas

The schema sectors covered are:

1. CorePlatform
2. Security
3. Organization
4. ReactorFleet
5. Instrumentation
6. DigitalTwin
7. AlarmManagement
8. EventManagement
9. Maintenance
10. RootCause
11. ReinforcementLearning
12. Robotics
13. RadiationMonitoring
14. EmergencyPreparedness
15. Compliance
16. Reporting
17. Audit

Together, these chapters show how the full NEXUS-1 data model can be represented in EF Core without losing structure, naming discipline, or database clarity.

Why This Book Exists

From Schema to System answered one question:

If the NEXUS-1 digital twin lived in one coherent SQL Server database, what would that database look like?

From Entity to Context answers the next question:

If that database is mapped professionally in a .NET application, what should the EF Core configuration layer look like?

The answer is not one giant DbContext.
It is not a pile of attributes scattered across entity classes.
It is not a migration file nobody understands.

The answer is a configuration atlas: one entity, one configuration file, one clear place where the database contract is expressed in C#.

Who This Book Is For

This book is written for:

• .NET developers
• EF Core developers
• backend engineers
• software architects
• database-aware C# programmers
• developers working on large enterprise systems
• readers of the NEXUS-1 series who want the C# mapping layer behind the schema

You do not need nuclear-industry experience to read it. The nuclear digital-twin setting is the reference system, not the prerequisite. The real subject is enterprise EF Core organization for large, schema-rich applications.

If you have ever opened a project where OnModelCreating became unreadable, where indexes had random generated names, where relationship configuration was scattered, or where nobody knew which class truly owned the database mapping, this book is for you.

What Makes It Different

Most EF Core examples are intentionally small. They show a few entities, a simple DbContext, and perhaps one or two Fluent API rules. That is useful for learning the basics, but it does not show what happens when the model grows into dozens or hundreds of tables across multiple bounded contexts.

This book starts where small examples stop.

It shows:

• how to keep DbContext clean in a large project
• how to organize configuration files by schema
• how to use Fluent API as the database contract
• how to give indexes and constraints stable professional names
• how to map lookup tables consistently
• how to configure cross-schema relationships
• how to keep Code First readable at scale
• how to prepare migrations that a real team can review
• how to make EF Core serve the database model instead of hiding it

The result is not only EF Core code. It is a way of keeping a large C# data model honest.

Honest Boundary

NEXUS-1 is a Phase-0 demonstration and educational companion system. The EF Core mappings in this book are serious software-architecture material, but they are not certified nuclear software, not a licensed plant data model, not safety-class implementation guidance, and not connected to any real facility.

The purpose of this book is to show how a complex digital-twin schema can be mapped professionally in EF Core using Code First discipline, configuration classes, clear naming, and explicit relationships.

It is a configuration atlas, not an operating manual.

In One Sentence

From Entity to Context is the complete EF Core configuration atlas for the NEXUS-1 digital-twin platform: one entity, one mapping, clean context.

Author: Grigorios Kyriakos Agathangelidis
Greek name: Γρηγόριος Κυριάκος Αγαθαγγελίδης
Also searchable as: Αγαθαγγελίδης Γρηγόριος, Αγαθαγγελιδης Γρηγοριος, Grigorios Agathangelidis.