entity-framework/core/learn-more/community-standups.md
The .NET Data Community Standups are live-streamed monthly (roughly) on Wednesday (usually) to YouTube and Twitch. This is your opportunity to interact with the .NET Data team and community. All past episodes are available on YouTube and are listed below with links to content from the shows.
Comment on GitHub with ideas for guests, demos, or anything else you want to see.
<a name="Feb12_2026"></a>
Microsoft.Extensions.DataIngestion is new addition into Microsoft.Extensions collection and this one touches databases and AI. Exciting. Adam Sitnik, who worked on implementation, tells us what's what and maybe some behind the scenes.
Featuring:
Links:
Microsoft.Extensions.AI.Templates<a name="Nov20_2025"></a>
Join the EF team to celebrate EF 10 release, ask questions and get juicy behind the scenes stories. 😉
Featuring:
<a name="Oct16_2025"></a>
Join the .NET Data Community team as we welcome Jeremy Miller, developer of Marten, to share his insights on database migrations and the evolving capabilities of Marten.
Featuring:
Links:
<a name="Sep18_2025"></a>
Join Jiri and Nick as they share their hands-on experiences working with Dapper and Entity Framework Core in real-world .NET projects. They'll compare the strengths and trade-offs of each approach. Expect practical insights, tips, and honest reflections on when and why to choose one over the other.
Featuring:
Links:
<a name="Aug21_2025"></a>
Join us for another community standup where we welcome Lukas Eder, author of jOOQ, to show us what it can do, and what inspiration we can get for EF from it.
Featuring:
Links:
<a name="Jul17_2025"></a>
Couchbase recently released their provider for EF Core. Let's chat with the team about Couchbase, the provider and challenges fitting Couchbase concepts into EF Core's world.
Featuring:
Links:
<a name="Jun19_2025"></a>
Join us for another .NET Data Community Standup where Shay tells us about Microsoft.Extensions.VectorData.
Featuring:
Links:
<a name="May14_2025"></a>
We welcome Davide Mauri, Principal Product Manager at Microsoft, to explore the exciting new vector search capabilities in Azure SQL. With the rise of AI-powered applications and semantic search, vector databases are more relevant than ever. In this session, Davide will demonstrate how Azure SQL is evolving to meet these modern needs with integrated vector search features.
Featuring:
Links:
<a name="Apr24_2025"></a>
Jiri and Shay talk about how we test whole EF Core and Maurycy corrects them, because they have it wrong.
Featuring:
Links:
<a name="Mar19_2025"></a>
Chris Klug has some opinions about Entity Framework and wants you to know about them…
Featuring:
Links:
<a name="Mar06_2025"></a>
Join Jiri as he talks about Chroma vector database and fresh new library for .NET that you can use to interact with Chroma.
Featuring:
<a name="Jan22_2025"></a>
Join us for another .NET Data Community Standup with Chris Woodruff where he talks about context pooling, FromSql and compiled queries.
Featuring:
<a name="Nov20_2024"></a>
EF Core 9 was just released. Join us in this special session talking with industry experts about all topic EF Core.
Featuring:
<a name="June26_2024"></a>
By harnessing the power of the .NET DacFX framework and the related .NET T-SQL parser, you can improve the quality of your database schema and scripts with static T-SQL analysis.
@ErikEJ has recently revived this 15-year-old technology with support for .NET 6 and later, and has brought a number of third-party rules back from the grave.
In this EF Core community standup we will have a closer look - from generation of a simple HTML report with findings to managing and creating your own analyzer rules using modern .NET.
Featuring:
Links:
<a name="May15_2024"></a>
In this community talk, we delve into the integration of Firebird, an open-source SQL relational database management system, with .NET, a free, cross-platform, open-source developer platform. This session aims to provide an understanding of how these two powerful technologies can be combined to create robust, scalable, and efficient applications.
This talk is designed for developers of all levels interested in expanding their knowledge on database management and .NET development. Whether you're a seasoned developer or a beginner looking to broaden your skill set, this talk will provide valuable insights into the effective use of Firebird with .NET.
Join us for this enlightening session and discover how you can harness the power of Firebird in .NET to take your applications to the next level.
Featuring:
Links:
<a name="Apr17_2024"></a>
In this episode, Arthur Vickers and Jiri Cincura from the EF team discuss everything about mapping properties in EF Core. We’ll look at:
And if we get time, we’ll look at how value converters influence all this!
Featuring:
Links:
<a name="Mar20_2024"></a>
Building and debugging distributed systems challenges developers to balance complexity with the need for simplicity. Ideally, we aim for the simplicity of a monolith while benefiting from microservices' scalability and isolation. In todays meetup we will have an early look at what we are doing with Hot Chocolate 14 to integrate well with Aspire and bridge this gap, offering an approach that combines microservices' advantages with the ease of a monolith for our consumers. Also we will have a look at a lot of the new feature around Hot Chocolate 14 that will make it so much easier to build layered services with entity framework. Do not worry! We will start slow with just the simplest of services accessing a database and then go all the way in.
Featuring:
Links:
<a name="value-generation"></a>
In this episode, Arthur and members of the EF Team will explore generated property values and how value generation interacts with keys in the model. We will look at fully client-side value generation, as well as how to use identity columns, database sequences, or a hi-lo pattern for server-side generation. In addition, we’ll investigate how generated key values impact EF Core change tracking by determining if an entity will go into the Added state or not. And finally, if we have time, we’ll look at special considerations for TPC mapping, and customizations such as setting before and after save behaviors, and sentinel values.
Featuring:
Links:
<a name="window-functions"></a>
Window functions are one of the most powerful features of SQL. Did you know that you can use Window Functions in EF Core today instead of writing raw SQL? Victor Irzak joins Shay and Arthur to explore real use cases of window functions with EF Core.
Featuring:
Links:
<a name="concurrency3"></a>
In the 3rd installment of our series on concurrency, we'll dive deep into SQL isolation levels, how they work (and work differently!) across SQL Server and PostgreSQL. We'll hopefully learn a bit about how database locks, snapshots and isolation levels work together to bring some sanity into the world of concurrency.
Featuring:
Links:
<a name="concurrency2"></a>
In the last episode, we dug deep into the underpinnings of optimistic concurrency handling in EF Core. In this episode, we continue that journey to cover disconnected scenarios. That is, where the entity travels to a client and then back to the server before being updated in the database. We’ll look at the different patterns for doing updates like this in ASP.NET Core and Blazor apps and see how concurrency tokens work with each of these. We’ll also look at how ExecuteUpdate can be used with concurrency tokens, and take a look at ETag concurrency in Azure Cosmos DB.
Featuring:
Links:
<a name="concurrency1"></a>
What happens when one user is reading a record while another user is updating it? What if both users try to update the same record at the same time? In this episode of the .NET Data Community Standup, Shay and Arthur take a look at how different database isolation levels impact concurrency and performance, and then extend this to optimistic concurrency patterns supported by Entity Framework Core. This includes both manual concurrency tokens and automatic concurrency tokens like SQL Server’s “rowversion”. We’ll also dig into what happens in disconnected scenarios, and when to use the original value as opposed to the current value of the concurrency token. Finally, we’ll look at how EF Core handles optimistic concurrency with ETags when using a document database like Azure Cosmos DB.
Featuring:
Links:
<a name="new8"></a>
Arthur and Shay from the EF team are joined by members of the community to demo some of the key new features available now in Entity Framework Core 8. For example:
Featuring:
Links:
<a name="mongo"></a>
In this episode of the .NET Data Community Standup, we talk to the engineers from MongoDB who have just released the first preview of an official EF Core provider. The EF team has collaborated closely with MongoDB on this provider, which now joins the Cosmos provider as flagship document database providers for EF Core. We will demo the provider, talk about what it can and cannot do, and of course answer all your questions!
Featuring:
Links:
<a name="smaller"></a>
In addition to the big features such as primitive collections and complex types, EF8 contains many smaller features and minor improvements. In this session, Arthur and Shay from the EF team will take a look at a few of these smaller features, including:
Featuring:
Links:
<a name="complextypes"></a>
The Entity Framework team returns with new community standups after a summer break heads-down working on EF8. In this session, we’ll look at the new “complex types” feature in EF8. Complex types do not have a key or any identity outside of the object’s value, but can still be deconstructed by property to map to different columns in the database. This allows either reference or value types to be used as DDD value objects with much better fidelity than when owned types are used. We’ll show examples of using complex types and talk about and answer your questions on the behavioral differences between entity types, owned entity types, complex types, and primitive types.
Featuring:
Links:
<a name="zumero"></a>
In this session, we'll invite Eric Sink to discuss a solution for keeping a synchronized copy of the DB (using SQLite) on the client, rather than asking data for the cloud every time. This is helpful for mobile scenarios where the connectivity may be poor, but the "rep and sync" approach can reduce the time the user spends waiting on the network. Local writes are fast, sync happens in the background. We'll explore how this can be done efficiently, how to deal with conflict resolution, and other data sync-related concerns. Featuring:
Links:
<a name="power-tools"></a>
In today's standup, Erik will demonstrate the new CLI edition of EF Core Power Tools and show how he used a number of community NuGet packages to improve the user experience when creating a CLI tool.
Featuring:
Links:
<a name="primitive-collections"></a>
In this episode of the .NET Data Community Standup, the .NET Data Access team dive into new support for collections of primitive values, just released in EF Core 8 Preview 4. Collections of a primitive type can now be used as properties of an entity type and will be mapped to a JSON column in the relational database. In addition, parameters of primitive values can be passed to the database. In either case, the native JSON processing capabilities of the database are then used to exact and manipulate the primitive values, just as if they were in a table. This opens up powerful query possibilities, as well as optimizations to common problems such as translating queries that use Contains.
Featuring:
Links:
<a name="internals-models"></a>
In this session, the .NET Data Access team will dig into the EF Core internals for building a model. EF models are built using a combination of three mechanisms: conventions, mapping attributes, and the model builder API. We will explain each of these mechanisms and show how they interact. We’ll also cover how models are cached, and ways in which that caching can be controlled. And, as always, we’ll answer your questions live! Featuring:
Links:
<a name="hierarchyid"></a>
Join the .NET Data Access Team to learn about mapping hierarchical data structures to relational databases using EF Core. We’ll look at “hierarchyid” on SQL Server/Azure SQL and “ltree” on PostgresSQL, and show how to map tree structures such as a family tree, file system, or organization structure. EF Core can then be used to write LINQ queries against the hierarchy to find ancestors and descendants in various ways, as well as perform manipulation of subtrees for updates. And, as always, we’ll be here to answer your questions!
Featuring:
Links:
<a name="internals-query"></a>
In this standup, we'll dive deep under the hood to see how EF Core processes LINQ queries, translates them to SQL and executes them on your database. We'll introduce key concepts such as IQueryable and LINQ providers, and see how EF Core uses caching to make your querying lightning-fast. Join us to understand how the magic works!
Featuring:
Links:
<a name="mysql"></a>
This week, we'll be hosting Bradley Grainger and Laurents Meyer, authors of the open-source MySQL ADO.NET driver and of the Pomelo EF Core provider. Both these components work together to provide a 1st-class MySQL data access experience in .NET. We'll discuss some of the specifities of MySQL as a database, what it's like to work on open source data projects in .NET, and whatever else comes to mind!
Featuring:
Links:
<a name="sqlite"></a>
This week, Eric Sink (creator of SQLitePCL.raw) and Brice Lambson (creator of Microsoft.Data.Sqlite) join the .NET Data Access Team to discuss everything SQLite on .NET. We’ll start down low digging into different ways to get the SQLite native binaries using Eric’s packages. Then we’ll move up the stack to look at the basics of SQLite on .NET with Brice’s ADO.NET provider. Going higher still, we’ll look at how to get the most from SQLite with the EF Core provider. And, as always, we’ll be there to answer any questions you have about SQLite on .NET.
Featuring:
Links:
<a name="faq"></a>
Join the Microsoft .NET Data team to get answers to many frequently asked questions about EF Core. For example:
Featuring:
Links:
<a name="plan8"></a>
The plan has been published for EF Core 8 and other data access work in .NET 8. This includes work in five major themes:
Join the .NET Data Team for a discussion of what’s in and what’s out, and to get your questions answered.
Featuring:
Links:
<a name="new-ef7"></a>
Join the .NET Data team as we take a whirlwind tour through new features of EF Core 7.0 (EF7). This includes JSON columns, bulk updates, TPC mapping, and more!
Featuring:
Links:
<a name="conventions"></a>
EF Core uses a metadata "model" to describe how the application's entity types are mapped to the underlying database. This model is built using a set of around 60 "conventions". The model built by conventions can then be customized using mapping attributes (aka "data annotations") and/or calls to the DbModelBuilder API in OnModelCreating. EF7 allows applications to remove or modify existing conventions, as well as create new conventions. Join us for this .NET Data Community Standup to learn how to take advantage of custom model building conventions in your EF Core 7.0 applications.
Featuring:
Links:
<a name="bulkcud"></a>
EF Core 7.0 introduces the ExecuteUpdate and ExecuteDelete APIs, which allow you to easily use LINQ to express a database update or delete operation. These APIs can be far more efficient for applying changes to multiple rows based on a condition, e.g. “delete rows which have InActive set to true” (AKA bulk update scenarios). But in some scenarios, they also allow you to express changes over a single row in a much more succinct and simple way, simplifying your code. ExecuteUpdate and ExecuteDelete completely bypass EF’s change tracking and execute immediately, as opposed to when SaveChanges is called. Tune in to learn more and to explore the new possibilities that these new APIs bring!
Featuring:
Links:
<a name="json"></a>
JSON columns allow relational databases to directly store documents while retaining the overall relational structure of the data. EF7 contains provider-agnostic support for JSON columns, with an implementation for SQL Server. The JSON in these columns can queried using LINQ, allowing filtering and sorting by the elements of the documents, as well as projection of elements out of the documents into results. In addition, EF7 supports element-level change tracking of the documents and partial updates for only the changed elements when SaveChanges is called.
Featuring:
Links:
<a name="offline-sync"></a>
Learn how Azure Mobile Apps provides the tools and libraries you need to easily synchronize data between an Entity Framework Core-backed Web API and your mobile or desktop app.
Featuring:
Links:
<a name="ef7aggs"></a>
Aggregate functions such as COUNT, MAX or AVG compute a single value from multiple rows. EF7 adds support for custom provider aggregate functions, adding support for many new translations. In this episode of the .NET Data Community Standup, we’ll explore these new translations across different EF providers, and see what they could mean for more efficient data loading from the database. We’ll also go into some tricky design problems and under the hood query translation details which the team discussed while working on this feature.
Featuring:
Links:
<a name="wcf"></a>
CoreWCF is a port of the service side of Windows Communication Foundation (WCF) to .NET. The goal of this project is to enable existing WCF services to move to .NET. The CoreWCF team recently conducted a survey and will be talking about some of the responses, answering questions, and sharing insights into their roadmap for the future.
Featuring:
Links:
<a name="dbdatasource"></a>
In this episode of the .NET data community standup, we'll explore DbDataSource, a new abstraction being introduced to System.Data in .NET 7.0. DbDataSource unlocks easier integration of ADO.NET drivers with dependency injection, better management of advanced driver configuration, helps performance and more. Tune in to see improvements at the lower levels of the .NET data stack.
Featuring:
Links:
<a name="ef7interceptors"></a>
EF7 includes a variety of new interceptors and events, as well as many improvements to the existing lifecycle hooks. In this session, Arthur and others from the .NET Data team will dive into this new functionality, including examples for intercepting materialization of entities, query expression trees, identity resolution when tracking, and optimistic concurrency violations. Join us for a fun-packed ride into the world of modifying EF behavior through interception with code galore!
Featuring:
Links:
<a name="lifetimes"></a>
Arthur and others from the EF Team continue their deep dive into the architecture of Entity Framework Core. This is a code-driven discussion looking at how and why things are designed and implemented the way they are. In this session, we look at the initialization and configuration of a DbContext instance, including selection of the provider, creating DbSet instances, reading DbContextOptions, and DbContext pooling.
Featuring:
Links:
<a name="inheritance"></a>
Type inheritance hierarchies as used in object-oriented programming do not map naturally to relational database schemas. In this live stream, we will look at different strategies for inheritance mapping when using EF Core with a relational database. This includes table-per-hierarchy (TPH) mapping, table-per-type (TPT) mapping, and table-per-concrete type (TPC) mapping, which is new in EF Core 7.0 preview 5. We will look at the consequences of the mapping on the generated SQL and consider the performance and storage implications. This will result in some guidance as to when each strategy should be used.
Featuring:
Links:
<a name="internal-di"></a>
Join Arthur Vickers and others from the EF Team as we start a deep dive into the architecture of Entity Framework Core. This won’t be a formal talk, but rather a free-form discussion driven by the code where we look how and why things are designed and implemented the way they are. This week, we’ll start with the use of dependency injection (D.I.) and the “internal service provider.” This is the backbone of how EF Core works as a service-oriented architecture, where the core code, database providers, and plugins all implement services that work together to provide EF’s functionality.
Featuring:
Links:
<a name="testing2"></a>
In this second part of testing EF Core Apps, guest Jon P Smith will focus on the actual code and approaches that you need to test applications using EF Core and will address some key "pain points."
Featuring:
Links:
<a name="pagination"></a>
Lots of data? Time to page it. But what's the best approach? TAKE, SKIP, and OFFSET? What about keyset pagination? Join the .NET Data team when we page the author of "keyset pagination for EF Core" Mohammed Rahhal to discuss paging and answer your questions live.
Featuring:
Links:
<a name="update-perf"></a>
Join the Entity Framework team as they review optimizations to the update pipeline to improve performance. Come prepared with your EF7 questions as we plan to spend time in Q&A to answer your questions live.
Featuring:
Links:
<a name="t4"></a>
Prefer null setters? Property initializers? Constructor initialization? What about auto-generating database diagrams that render in markdown using Mermaid? Learn how to take control of your database scaffolding in this early look at an EF7 feature that's hot off the press
Featuring:
Links:
<a name="graphql-odata"></a>
The creator of the GraphQL library HotChocolate, Michael Staib, and Microsoft engineer and OData expert Hassan Habib discuss the various capabilities of GraphQL and OData and how they empower developers to go beyond REST.
Featuring:
Links:
<a name="20years"></a>
As .NET celebrates its 20th birthday, Entity Framework approaches its 10-year anniversary of going open source. The Entity Framework team will celebrate these milestones by inviting back the engineers and program managers who helped shipped previous versions to share their stories, demos, and anecdotes. Join Tim Laverty, Rowan Miller, Danny Simmons, Diego Vega, and more for this special edition of the .NET Data community standup.
Featuring:
Links:
<a name="stuff"></a>
Join the .NET Data team and Jon Skeet in a discussion around software versioning, issues with versioning in .NET, and… stuff. Who knows what topics may come up? Join us live to find out and have your questions answered in real time.
Featuring:
Links:
<a name="testing1"></a>
What’s the best way to run automated tests on an application that uses Entity Framework Core? Jon P Smith, author of the book “Entity Framework Core in Action” covers three ways to create automated tests for your code and looks at the EF Core test “pain points” and how to get around them.
Featuring:
Links:
<a name="ef7plan"></a>
The plan for EF7 has been published. In this episode, the EF Core/.NET Data team will review the details of the plan and answer live questions about the roadmap.
Featuring:
Links:
<a name="hotchoc12"></a>
Hot Chocolate 12 allows for more schema-building options with deeper integrations into EF core. Hot Chocolate has already implemented the new GraphQL October 2021 spec, and we will explore the new capabilities. We now support the complete stream and defer spec and will look into these new data fetching capabilities.
Featuring:
Links:
<a name="retro6"></a>
EF Core 6 has been released with a long list of features from performance improvements, temporal tables support, CI/CD-friendly migration bundles, compiled models, query improvements, enhanced Azure Cosmos DB capabilities and much more. Join the EF Core team and our community panelists as we review what's new, share the EF Core 6 story and answer your questions live.
Featuring:
Links:
<a name="nodatime"></a>
Noda Time is an alternative date and time API for .NET. It helps you to think about your data more clearly, and express operations on that data more precisely.
Featuring:
Links:
<a name="temporal"></a>
Learn about the new support in EF Core 6 for temporal tables, including creating them from migrations, transforming existing tables into temporal tables, querying historical data and point-in-time restore.
Featuring:
Links:
<a name="aspnet"></a>
Back to the basics: EF Core and ASP.NET Core from the documentation team.
Featuring:
Links:
<a name="npgsql"></a>
PostgreSQL has some advanced capabilities not usually found in other relational databases. In this session we'll go over some of them, and see how EF Core makes these accessible.
Featuring:
Links:
<a name="dapper"></a>
Dapper maintainers and key contributors Nick and Marc will show people the glorious power of Dapper and everything it can do, so they are fully informed and can choose something much better, like EF Core (their words).
Featuring:
Links:
<a name="query-filters"></a>
Why do customers want "soft delete"? What's a good practice for handling multi-tenancy in EF Core apps? The reformed programmer, Jon P. Smith, shares how to use a powerful tool in the EF Core platform, global query filters, to handle scenarios like "soft delete."
Featuring:
Links:
<a name="odata"></a>
OData is one of the best protocols out there to supercharge your ASP.NET Core APIs with so many capabilities such as shaping, filtering, batching and ordering the data on the fly - it executes it's queries on the server which tremendously improves the performance on client side. Hassan talks all things OData on the Community Standup.
Featuring:
Links:
<a name="query-plans"></a>
Learn what a query plan is, how to view EF Core query plan in LINQPad, find missing indexes, and improve performance of your queries.
Featuring:
Links:
<a name="cosmos6"></a>
EF Core may be an object relational mapper, but it also can ditch the relational and connect directly to the Azure Cosmos DB NoSQL engine. In this standup, the team will discuss the rationale behind a Cosmos DB provider, show code examples, discuss the major differences between SQL and NoSQL data and share the roadmap for future enhancements to the Azure Cosmos DB provider.
Featuring:
Links:
<a name="compiled-models"></a>
EF Core creates an internal model for entity types and their database mappings. This model is typically built once when the application starts. Starting with EF Core 6.0, it is now possible to instead build this model at compile time. This can reduce startup time by up to 67% for large models. Join us for this Community Standup, where the team will introduce compiled models and demo their use.
Featuring:
Links:
<a name="graphql1"></a>
GraphQL is a great way to expose data whether you expose your business layer in a much richer way or just map your data models to get started quickly. GraphQL gives backend engineers the tools to mold the service layer without compromises and lets the frontend engineer decide what data he or she needs to build that awesome application. Learn the what, why, and see how to build apps with GraphQL.
Featuring:
Links:
<a name="triggers"></a>
Guest Koen Bekkenutte will introduce us to the EFCore.Triggered project and discuss its advantages and how it differs from domain events and database triggers. See how it is implemented and how the project uses EF Core's ChangeTracker and SaveChanges interception. As always, the EF Core team and Koen will be responding to live Q&A.
Featuring:
Links:
<a name="contributing"></a>
Do you want to contribute to EF Core but are uncertain where to begin? We’re here to help! In this episode of the EF Core Community Standup, we will add an EF Core feature live. We’ll go through everything from forking the repo, adding the code and related tests, and generating the pull request. Learn how the codebase is organized, how to build and how to run tests and receive answers to your questions in real time direct from the team that brings you magic unicorns!
Featuring:
Links:
<a name="davide"></a>
Join Davide Mauri and the EF Core team for an interactive discussion about how Azure SQL helps cloud developers create cloud native solutions. From simple REST APIs to scalable backends, Azure SQL provides the required flexibility, scalability, and features to simplify the developer's life. Davide will cover topics ranging from JSON support and CI/CD to column-store, geospatial and graph models.
Featuring:
Links:
<a name="newbatch"></a>
Learn how to take advantage of the new advanced features recently added to EF Core Power Tools: - reverse engineer .dacpac files, renaming of tables, columns and even navigations, excluding columns, working with multiple DbContexts in the same project, map spatial columns and SQL Server stored procedures. The session will also include a look under the hood of EF Core Power Tools reverse engineering.
Featuring:
Links:
<a name="julie"></a>
Julie Lerman is an independent authority and community luminary for Entity Framework. She has been programming for nearly 30 years and has been an independent consultant since 1989. Julie is one of 150 Microsoft Regional Directors worldwide and has been awarded Microsoft MVP annually since 2003. Join Julie and the EF Core team for an "ask me anything" session: your questions answered in real-time!
Featuring:
Links:
<a name="jonp1"></a>
Guest Jon P Smith shows how he built a demo e-commerce book selling site that uses EF Core. He started with 700 books then scaled through 100,000 books to ½ million books. At each stage he compares the performance of each improvement, and the extra work to get that performance.
Featuring:
Links:
<a name="typed-exceptions"></a>
When using Entity Framework Core for data access all database exceptions are wrapped in DbUpdateException. If you need to know whether the exception was caused by a unique constraint, the value being too long, or the value missing for a required column, you need to dig into the concrete DbException subclass instance and check the error number to determine the exact cause. In this episode, learn how EntityFramework.Exceptions handles all the database-specific details and allows you to use typed exceptions for Entity Framework Core when your query violates database constraints.
Featuring:
Links:
<a name="sqlproj"></a>
MSBuild.Sdk.SqlProj is a new open source project that allows you to build SQL Server Database Projects (.sqlproj) using the new SDK-style projects cross-platform without the need to have Visual Studio installed. Jonathan will show why you would use it, how you can get started and walk you through its various features. He'll also show how you can contribute to the project.
Featuring:
Links:
<a name="survey"></a>
We asked, and you listened! Nearly 4,000 developers responded to the EF Core 2020 survey. In this edition of the community standup, senior program manager Jeremy Likness will review the survey results and discuss how they impact the plan for EF Core 6.0. The team will be available to answer your questions live.
Featuring:
Links:
<a name="frans"></a>
In this episode we welcome guest Frans Bouma, who will show us how to graphically model a domain for any .NET ORM with the LLBLGen Pro designer. Frans is also a venerable .NET data and SqlServer figure, so we will chat a lot about history and what's it's been like to make a commercial ORM in the Microsoft world.
Featuring:
Links:
<a name="efcore5"></a>
In this special edition of the EF Core Community Standup, we celebrate the release of EF Core 5.0 with a community panel. We'll welcome Entity Framework luminaries Diego Vega, Erik E Jensen, Jon P Smith and Julie Lerman to discuss their favorite features and answer your questions live.
Featuring:
Links:
<a name="collations"></a>
In this community standup, we'll be showing new features around case sensitivity and collations in 5.0. We'll also provide a glimpse into how these features were designed, and what considerations and constraints guide the EF team - performance, cross-database support, usability and more. Come see how we design EF features under the hood!
Featuring:
Links:
<a name="repository"></a>
In this episode, fellow .NET TV host David Pine will join Jeremy Likness to discuss his Cosmos DB Repository pattern .NET SDK. The SDK aims to simplify the Cosmos DB .NET SDK by abstracting away some of the complexities, exposing an elegant API surface area, and providing C.R.U.D. operations through the IRepository interface.
As always, the EF Core team will be available to answer questions live.
Featuring:
Links:
<a name="geo-nts"></a>
Joe Amenta joins us to discuss how to add spatial data to your applications to open a world of new relationships between data. He will demonstrate the "status quote" for querying spatial data from .NET and demo integrations with NetTopologSuite and EF Core.
Featuring:
Links:
<a name="migrations5"></a>
The Entity Framework Core team focused on major improvements to migrations for the EF Core 5.0 release. Learn about what's new and explore different migrations scenarios in this demo-heavy session. As always, the team will be standing by live to answer your questions!
Featuring:
Links:
<a name="dotmin-sync"></a>
The maintainer of open source software solution DotMim.Sync joins the EF Core team to discuss how the project helps keep local relational databases in sync.
Featuring:
Links:
<a name="many-to-many"></a>
Join the team as they explore the latest many-to-many mapping features implemented for EF Core 5.0 including skip navigations and more!
Featuring:
Links:
<a name="depth"></a>
Join members from the .NET teams for our community standup covering great community contributions for Framework, .NET, Languages, CLI, MSBuild, and more.
Featuring:
Links:
<a name="handlebars"></a>
Join members from the .NET teams for our community standup covering great community contributions for Framework, .NET, Languages, CLI, MSBuild, and more.
Featuring:
Links:
<a name="blazor"></a>
Join members from the .NET teams for our community standup covering great community contributions for Framework, .NET, Languages, CLI, MSBuild, and more.
Featuring:
Links:
<a name="power-tools1"></a>
Join members from the .NET teams for our community standup covering great community contributions for Framework, .NET, Languages, CLI, MSBuild, and more.
Featuring:
Links:
<a name="one"></a>
Join members from the .NET teams for our community standup covering great community contributions for Framework, .NET, Languages, CLI, MSBuild, and more.
Featuring:
Links: