Transactions in Entity Framework

Slides:



Advertisements
Similar presentations
NoSQL Databases NoSQL Concepts SoftUni Team Technical Trainers Software University
Advertisements

Databases Telerik Software Academy
Entity Framework Performance SoftUni Team Technical Trainers Software University
Processing Redis with.NET How to Operate with Redis Databases SoftUni Team Technical Trainers Software University
Test-Driven Development Learn the "Test First" Approach to Coding SoftUni Team Technical Trainers Software University
Asynchronous Web Services Writing Asynchronous Web Services SoftUni Team Technical Trainers Software University
ORM Basics Repository Pattern, Models, Entity Manager Ivan Yonkov Technical Trainer Software University
Doctrine The PHP ORM SoftUni Team Technical Trainers Software University
XML Processing SoftUni Team Database Applications Technical Trainers
Version Control Systems
Auto Mapping Objects SoftUni Team Database Applications
Working with Fluent API Inheritance Strategies
Static Members and Namespaces
Introduction to Entity framework
Databases basics Course Introduction SoftUni Team Databases basics
Interface Segregation / Dependency Inversion
Introduction to MVC SoftUni Team Introduction to MVC
Deploying Web Application
PHP MVC Frameworks Course Introduction SoftUni Team Technical Trainers
C# Database Fundamentals with Microsoft SQL Server
Introduction to Entity Framework
Application Architecture, Redux
ASP.NET Integration Testing
ASP.NET Unit Testing Unit Testing Web API SoftUni Team ASP.NET
Classes, Properties, Constructors, Objects, Namespaces
Mocking tools for easier unit testing
Parsing JSON JSON.NET, LINQ-to-JSON
State Management Cookies, Sessions SoftUni Team State Management
EF Code First (Advanced)
PHP MVC Frameworks MVC Fundamentals SoftUni Team Technical Trainers
C# Databases Advanced with Microsoft SQL Server
OOP Course - Virtual Trip
EF Advanced Querying Optimize Performance SoftUni Team Advanced
EF Relations Object Composition
Entity Framework: Code First
Parsing XML XDocument and LINQ
Repeating Code Multiple Times
Entity Framework DB From Code, OOP Introduction
Data Definition and Data Types
Databases advanced Course Introduction SoftUni Team Databases advanced
Install and configure theme
Entity Framework: Relations
Caching Data in ASP.NET MVC
Functional Programming
ASP.NET Razor Engine SoftUni Team ASP.NET MVC Introduction
C# Advanced Course Introduction SoftUni Team C# Technical Trainers
Databases Advanced Course Introduction SoftUni Team Databases Advanced
Best Practices and Architecture
Best practices and architecture
How to connect natively?
Data Definition and Data Types
Multidimensional Arrays, Sets, Dictionaries
Extending functionality using Collections
Exporting and Importing Data
ASP.NET Filters SoftUni Team ASP.NET MVC Introduction
Making big SPA applications
Manual Mapping and AutoMapper Library
Functional Programming
C# Advanced Course Introduction SoftUni Team C# Technical Trainers
Exporting and Importing Data
Introduction to TypeScript & Angular
CSS Transitions and Animations
Train the Trainers Course
Spring Data Advanced Querying
Software Quality Assurance
Version Control Systems
JavaScript Frameworks & AngularJS
Entity Framework Advanced Querying SoftUni Team Technical Trainers
Lean .NET stack for building modern web apps
CSS Transitions and Animations
Presentation transcript:

Transactions in Entity Framework SQL Transactions in Entity Framework Database Applications SoftUni Team Technical Trainers Software University http://softuni.bg © Software University Foundation – http://softuni.org This work is licensed under the Creative Commons Attribution-NonCommercial-ShareAlike license.

Table of Contents Implicit Transactions in EF Using TransactionScope Transactional DbContext.SaveChanges() Optimistic Concurrency Control in EF: Last Wins and First Wins Strategies Using TransactionScope Using EF Explicit Transactions

Implicit Transactions in Entity Framework

Transactions in Entity Framework (EF) In EF DbContext.SaveChanges() implicitly runs in a transaction Either all changes are persisted, or none of them var context = new SoftUniEntities(); var town = new Town { Name = "Developer City " }; context.Towns.Add(town); var addr = new Address { AddressText = "5, Dev Rd.", Town = town }; context.Addresses.Add(addr); var ev = new Event { Address = addr, Name = "Party", Date = new DateTime(2015, 1, 1) }; context.Events.Add(ev); context.SaveChanges(); Implicit transaction: either town + address + event will be inserted or nothing

Transactional EF SaveChanges() Live Demo

Optimistic Concurrency Control in EF EF runs in optimistic concurrency mode (no locking) By default the conflict resolution strategy in EF is "last wins" The last change overwrites all previous concurrent changes Enabling "first wins" strategy for certain property in EF: ConcurrencyMode=Fixed (in DB first project) [ConcurrencyCheck] (in code first projects)

Last wins: the second user overwrites the first user's changes Last Wins – Example var contextFirst = new SoftUniEntities(); var lastProjectFirstUser = contextFirst.Projects .OrderByDescending(p => p.ProjectID).First(); lastProjectFirstUser.Name = "Changed by the First User"; // The second user changes the same record var contextSecondUser = new SoftUniEntities(); var lastProjectSecond = contextSecondUser.Projects lastProjectSecond.Name = "Changed by the Second User"; // Conflicting changes: last wins contextFirst.SaveChanges(); contextSecondUser.SaveChanges(); Last wins: the second user overwrites the first user's changes

First wins: the second user gets DbUpdateConcurrencyException First Wins – Example var contextFirst = new SoftUniEntities(); var lastTownFirstUser = contextFirst .Towns.OrderByDescending( t => t.TownID).First(); lastTownFirstUser.Name = "First User"; var contextSecondUser = new SoftUniEntities(); var lastTownSecondUser = contextSecondUser.Towns .OrderByDescending(t => t.TownID).First(); lastTownSecondUser.Name = "Second User"; contextFirst.SaveChanges(); contextSecondUser.SaveChanges(); First wins: the second user gets DbUpdateConcurrencyException

Optimistic Concurrency in EF Live Demo

Managing Transactions in .NET Apps TransactionScope Managing Transactions in .NET Apps

TransactionScope Class In .NET environment we can implement implicit transactions with TransactionScope Each operation in transaction scope joins the existing ambient transaction Advantages of TransactionScope Easier to implement, more efficient Supports distributed transactions (MSDTC) Disadvantages: May not be supported in cloud environment

Using TransactionScope When instantiating TransactionScope You either join the existing (ambient) transaction Or create a new ambient transaction Or you don't apply transactional logic at all The transaction coordinator (MSDTC) determines to which transaction to participate based on If there is an existing active transaction The value of the TransactionScopeOption parameter

The TransactionScope Class TransactionScopeOption specifies which transaction to be used (new / existing / none) TransactionScopeOption Transaction Already Exists? Action Required (default) No New transaction is created Yes Existing ambient transaction is used RequiresNew New transaction is explicitly created Suppress No transaction is used

TransactionScope – Example void RootMethod() { using (TransactionScope tran = new TransactionScope()) /* Perform transactional work here */ SomeMethod(); tran.Complete(); } void SomeMethod() using (TransactionScope tran = new TransactionScope(TransactionScopeOption.Required)) Create a new transaction Joins the existing transaction

Completing a TransactionScope The method Complete() informs the transaction coordinator that it is acceptable to commit the transaction If not called, the transaction will be rolled back Calling it doesn't guarantee that the transaction will be committed At the end of the using block of the root transaction, it is committed Only if the root transaction scope and all joined transaction scopes have called Complete()

TransactionScope Live Demo

Explicit Transactions in EF Using Database.BeginTransaction()

Explicit Transactions in EF var context = new SoftUniEntities(); using (var dbContextTransaction = context.Database.BeginTransaction()) { try context.Database.ExecuteSqlCommand("UPDATE Employees " + "SET Salary = Salary * 1.2 WHERE LastName = 'Wilson'"); var empsQuery = context.Employees.Where( e => e.Town.Projects.Count() >= 5); foreach (var emp in empsQuery) emp.JobTitle += "Senior " + emp.JobTitle; context.SaveChanges(); dbContextTransaction.Commit(); } catch (Exception) dbContextTransaction.Rollback();

Explicit Transactions in EF Live Demo

Transactions in Entity Framework https://softuni.bg/courses/database-applications/ © Software University Foundation – http://softuni.org This work is licensed under the Creative Commons Attribution-NonCommercial-ShareAlike license.

License This course (slides, examples, demos, videos, homework, etc.) is licensed under the "Creative Commons Attribution- NonCommercial-ShareAlike 4.0 International" license Attribution: this work may contain portions from "Databases" course by Telerik Academy under CC-BY-NC-SA license © Software University Foundation – http://softuni.org This work is licensed under the Creative Commons Attribution-NonCommercial-ShareAlike license.

Free Trainings @ Software University Software University Foundation – softuni.org Software University – High-Quality Education, Profession and Job for Software Developers softuni.bg Software University @ Facebook facebook.com/SoftwareUniversity Software University @ YouTube youtube.com/SoftwareUniversity Software University Forums – forum.softuni.bg © Software University Foundation – http://softuni.org This work is licensed under the Creative Commons Attribution-NonCommercial-ShareAlike license.