dotnet/efcore
Efcore
Entity Framework Core is an object-relational mapper that enables developers to interact with database systems using strongly-typed code. It serves as a comprehensive data access framework, providing a unified interface for mapping application objects to relational and non-relational database schemas while managing the lifecycle of data operations through a central context.
The project distinguishes itself through a provider-based architecture that decouples core data access logic from specific database engines, allowing for consistent interaction across diverse storage systems. It features a sophisticated query translation engine that converts language-integrated queries into optimized, database-specific commands, alongside a robust migration toolset that automates schema evolution by synchronizing the physical database structure with the application model.
Beyond its core mapping and query capabilities, the framework provides extensive tooling for database scaffolding, reverse engineering, and automated code generation. It supports complex data modeling requirements, including inheritance hierarchies, owned entity relationships, and custom mapping configurations, while offering built-in mechanisms for transaction management, concurrency control, and connection resiliency.
The framework includes comprehensive observability and testing utilities, such as command interception, operation logging, and in-memory database simulation for isolated testing. It is designed for integration with standard dependency injection containers and provides configuration hooks to customize scaffolding and migration logic.
Features
- Object-Relational Mappers - Provides a comprehensive framework for mapping application objects to relational and non-relational database schemas.
- CRUD Interfaces - Executes create, read, update, and delete operations using strongly-typed object-oriented syntax.
- Object-Relational Mapping - Maps application objects to database schemas to enable strongly-typed data persistence and retrieval.
- Entity Mappings - Translates application objects into database tables and columns, allowing interaction with data using strongly-typed code.
- Database Schema Migrations - Automates incremental schema evolution to keep database structures synchronized with application models.
- LINQ Expression Translators - Converts language-integrated query expressions into optimized database-specific command trees for execution on the remote data store.
- Entity Relationship Models - Links object references to database primary and foreign keys to synchronize state between application models and relational schemas.
- Database Abstraction Layers - Decouples core data access logic from specific database engines using pluggable drivers that implement engine-specific translation and connection handling.
- Database Migration Tools - Tracks and applies incremental schema changes to ensure database compatibility with application code.
- Asynchronous Database Command Execution - Executes database operations through a non-blocking I/O stack to maintain application responsiveness and improve throughput.
- Data Access Abstractions - Provides a repository pattern to decouple application logic from database operations, enabling mock-based testing.
- Database Connectivity - Connects to diverse relational and non-relational databases using a pluggable provider architecture.
- Retry Policies - Automatically retries failed database commands to maintain stability during transient connection errors.
- Database Query Optimizations - Translates query logic into database-specific commands to minimize data transfer and leverage server-side performance.
- Database Relationship Mappings - Maps complex database relationships like many-to-many associations into strongly-typed object models during the scaffolding process.
- Database Transaction Management - Groups multiple database operations into a single atomic transaction to ensure data integrity and consistent state across complex object graphs.
- Primary Keys - Designates unique identifiers for entities to ensure records are distinct and referenceable.
- Entity Relationships - Modifies foreign key associations by updating navigation properties on tracked objects to point to different related entities.
- SQLite Drivers - Entity Framework maps application objects to relational tables and manages data operations to enable interaction with SQLite database engines.
- Entity Identity Maps - Maintains a registry of loaded entity instances to ensure object consistency and detect modifications for automated persistence.
- Entity Tracking - Configures whether retrieved data is monitored for changes to enable automatic persistence.
- Data Access Context Configurations - Entity Framework automates the instantiation of data access objects by integrating with dependency injection containers or custom factory implementations during development.
- SQL Server Connectors - Entity Framework maps application objects to database tables and queries to enable interaction with SQL Server, Azure SQL, and Azure Synapse Analytics.
- Dependency Injection Containers - Integrates with standard dependency injection containers to manage the lifecycle of data access contexts automatically.
- Metadata Mapping - Uses a central configuration model to define the relationship between application classes and database schemas through conventions or fluent definitions.
- Scaffolding Generators - Generates entity classes and data access configurations by inspecting existing database schemas.
- Data Access and Processing - Object-database mapper for managing relational data models.
- Object Relational Mappers - Official object-relational mapper for .NET applications.
- Persistence Frameworks - Official object-relational mapper for .NET.
- Bulk Data Operations - Performs direct database updates and deletions without loading entities into memory for improved performance.
- Column Mappings - Configures mapping of object properties to database columns, including data types, nullability, and collations.
- Concurrency Control - Identifies data modifications by other processes using concurrency tokens to validate row state.
- LINQ Integration - Wraps raw SQL queries as subqueries to allow further filtering, sorting, or projection using standard language-integrated query operators.
- Persistent Filters - Attaches persistent filters to entity types that automatically restrict all database queries based on defined criteria.
- Data Type Mappings - Maps complex data structures, inheritance hierarchies, and custom types between application objects and database schemas.
- Database Access Layers - Automates the generation of entity models and context classes from existing database schemas.
- Reverse Engineering Tools - Entity Framework generates code-based models and context classes by inspecting an existing database structure to bootstrap data access layers.
- Atomic Transactions - Groups multiple data operations into atomic units of work to maintain data integrity.
- Database Query Joins - Connects data sources based on matching keys to generate combined results using relational joins.
- Owned Entities - Defines dependent entity types that are managed and persisted as a single aggregate unit with their owner.
- Cascade Deletions - Configures relationships to automatically remove child records when a parent entity is deleted.
- Identity Maps - Ensures that multiple references to the same database record point to a single object instance.
- Relation Loading Strategies - Retrieves associated entities using eager, explicit, or lazy loading patterns to populate navigation properties.
- Database Lifecycle Management - Drops or updates databases to specific migration states to maintain alignment with the application model.
- Development-Time Generators - Automates the creation of migration scripts and model classes by inspecting database schemas during development.
- Conflict Resolution - Provides mechanisms to resolve data collisions by accessing current, original, and database-stored values.
- Nullability Synchronization - Ensures entity properties and database columns remain synchronized regarding nullability requirements.
- Filter Overrides - Disables active query filters for specific operations to allow access to restricted or hidden data.
- Database Connection Managers - Manages database connections and entity tracking through a central context class.
- Database Integrations - Integrates various database platforms through a consistent programming interface and provider-based architecture.
- Database Migration Management - Organizes schema changes into distinct sets by associating migration histories with specific database providers or context configurations.
- Database Task Automation - Provides command-line operations to generate migrations, scaffold models, and manage the lifecycle of database structures during development.
- Ambient Transactions - Enlists operations into shared transaction scopes that propagate automatically across asynchronous calls.
- Retriable Transactions - Wraps multiple database operations within a single execution strategy block to ensure the entire group is replayed if a transient failure occurs.
- Automatic Persistence - Detects and saves new objects referenced through navigation properties automatically when the parent entity is added to the tracking context.
- Owned Collections - Handles one-to-many relationships for owned types, automatically managing identity requirements.
- Grouped Aggregations - Groups query results by keys and applies scalar aggregate functions like sum or count.
- Multi-Database Connections - Manages multiple concurrent database connections and data sources within a single application.
- Alternate Keys - Establishes additional unique identifiers for entities to enforce uniqueness and support relational mapping.
- Raw SQL Execution - Runs custom SQL statements against a database to retrieve entity data or scalar values using parameterization.
- Context Lifecycle Managers - Controls the creation and disposal of data access instances to ensure they align with specific application scopes or unit-of-work requirements.
- Schema Migration Tools - Creates specialized migration operations to decouple database logic from schema definitions.
- Database Schema Scripting - Entity Framework produces SQL scripts from model changes or migration ranges to facilitate manual or automated updates to the database schema.
- Disconnected Persistence - Entity Framework synchronizes changes from detached objects to the database by determining whether to insert, update, or delete records based on their current state.
- Database Command Interceptors - Inspects and modifies database commands before or after execution to provide hooks for logging or modification.
- Migration - Produces source code for schema changes and model snapshots to keep application models synchronized with the current database state.
- Database Compatibility Layers - Adjusts generated SQL syntax to match specific database engine versions for optimal compatibility.
- Database Logging - Captures and outputs internal database activity and execution details to logging providers for monitoring.
- Database Connection Configurations - Configures a data access context to connect to specific database providers and manage connection strings or provider-specific settings.
- Database Performance Optimizers - Precompiles database models and queries to reduce startup time and improve execution speed.
- Database Schema Managers - Provides utilities to programmatically create or drop database tables based on the application model for testing and development environments.
- Database Transactions - Enforces database isolation levels to ensure data consistency and handle concurrency during transactions.
- Relationship Severing - Severs associations between entities by clearing navigation properties.
- Generated Columns - Supports database columns that automatically derive values from other columns or expressions.
- In-Memory Databases - Maintains a volatile, non-persistent data store in memory to facilitate automated testing without a live database.
- Join Operations - Executes left join operations by identifying patterns to include records even when no matching inner data exists.
- Naming Conventions - Extends or modifies default mapping heuristics to support custom naming and structural patterns.
- NoSQL Databases - Provides secure connectivity and data access for document-based NoSQL database systems.
- Metadata Inspection - Retrieves information about configured database contexts and checks for pending model changes.
- Result Streaming APIs - Processes large datasets incrementally by returning an asynchronous enumerable for client-side composition.
- Schema Generation Utilities - Produces raw SQL commands required to create a database schema without executing them against the target database.
- Keyless Entities - Enables data retrieval from database views or tables that do not support primary keys.
- Deployment Bundle Generators - Packages database update logic into standalone executables to deploy schema changes across environments without requiring the full application runtime.
- Scaffolding Configuration - Allows customization of generated code by filtering tables, adjusting naming conventions, and organizing output files during scaffolding.
- Context Factories - Provides factory-based instantiation for data access contexts when standard dependency injection scopes are insufficient.
- Concurrency Tokens - Entity Framework configures specific properties to act as version markers, either by leveraging native database-generated values or by manually tracking state within the application code.
- Database Value Generation - Configures properties to have values generated by the database or application logic during insertion or updates.
- Graph Traversal - Traverses complex object hierarchies to apply tracking states to related data structures.
