When multiple users are editing the same data, concurrency effects can result in lost work or errors. This course teaches you how to prevent concurrency errors at database level, and for business transactions that span multiple pages and postbacks.
When developing applications where multiple users can edit the same data, concurrency effects can result in work being overwritten and inconsistent data being read, which can cost a business time, money, and frustration. In this course, Enterprise Patterns: Concurrency in Business Applications, you'll learn how to recognize and prevent these types of errors. First, you'll explore how to use isolation levels within database transactions. Next, you'll discover how to implement optimistic and pessimistic concurrency in code for long-running business transactions. Finally, you'll learn how to design a locking framework for your application. When you’re finished with this course, you'll have a foundational knowledge of concurrency patterns that will help you as you move forward to design more robust, enterprise applications. Software required: Microsoft Visual Studio.
Neil is a solutions architect and developer, with a passion for web development, architecture, and security. He has worked in large and small IT organizations, written articles on development, and spoken at local .NET user groups. Neil has several Microsoft Certifications, including MCPD, MCSA, and MCSD.
Course Overview Hi everybody. My name is Neil Morrissey, and welcome to my course, Enterprise Patterns: Concurrency in Business Applications. When more than one user tries to update the same piece of data at the same time, a whole host of concurrency errors can occur like lost updates, dirty reads, and phantom reads. Not only can users lose work, but strange errors can appear in everything from the user interface, to calculations, to even reports if you don't take concurrency into account when designing your application. In this course, we'll examine how to prevent concurrency issues at two levels. At the database level, we'll look at how isolation levels work in system transactions, and then at a higher level, we'll examine concurrency in business transactions, where a user performs operations that span multiple pages and post backs before committing their data. If someone else modifies the data during that time, work can get overwritten and lost. We'll be examining concurrency control for business transactions using design patterns from Martin Fowler's famous book, Patterns of Enterprise Application Architecture. The examples in this course are in the latest versions of ASP. NET Core and Entity Framework Core, but these are design patterns, you're going to learn the concepts really well, so regardless of what language and platform you code in, you'll gain an understanding of how to implement these patterns. Some of the major topics we'll cover include understanding and recognizing types of concurrency errors, how to handle concurrency at the database level using transactions and isolation levels, as well as features of Entity Framework Core, how to implement optimistic and pessimistic concurrency control, how to handle concurrency for groups of objects like a customer and their addresses, and how to build concurrency control into a framework in your application, so you can ensure that you and other developers on your team don't bypass your concurrency strategy. This is a topic that's often overlooked in system design, so knowing these patterns will add to your toolbox and make you a better application designer and developer. While you don't need any prior experience to follow the concepts and patterns in this course, if you want to get the most out of the demos, you'll need a basic understanding of ASP. NET and the Entity Framework. I'm really excited to show you how you can use these patterns to make your applications more robust, so I hope you'll join me on this journey to learn Enterprise Patterns: Concurrency and Business applications here on Pluralsight.