dotnet/efcore

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.

Star history