Practical Data Modeling With C# and SQL Server

A good data model can be the difference between a successful, manageable application and one that breaks with every change request.
Course info
Rating
(404)
Level
Beginner
Updated
Jun 21, 2014
Duration
2h 33m
Table of contents
Description
Course info
Rating
(404)
Level
Beginner
Updated
Jun 21, 2014
Duration
2h 33m
Description

A good data model can be the difference between a successful, manageable application and one that breaks with every change request. This course will walk through the design of a practical data model that is refined through each module, using a fun example application for its inspiration.

About the author
About the author

Jason is the founder of Bam! Pow! Software Solutions, LLC. He has over 20 years experience as a business analyst, project manager and software developer. Jason has written numerous applications for the financial industry ranging from portfolio management and accounting systems to contact relationship management systems to trading systems.

More from the author
Introduction to Inverted Triangle CSS
Beginner
1h 33m
Jul 14, 2017
Creating Server-Side Excel Workbooks
Intermediate
2h 16m
Dec 18, 2014
Section Introduction Transcripts
Section Introduction Transcripts

Origin Story! Birth of a Data Model
It's not likely that the perfect data model is going to just land in your lap. It takes time, attention to your client's needs, an understanding of those needs, and creativity on your part to design the data model that's perfect for the application you're building. While a good data model has lots of different components, in this module we're going to focus on two of the core components. We'll also talk about some tools and techniques that you can use to determine the components that are appropriate for your data model. Throughout this course we'll be designing a data model for a comic book catalog, so we'll start talking about the components specific to that model. We'll also use C# and T-SQL to show you in code how to build out that data model in those two platforms.

Clones! Replicants! The Importance of Normalization
When designing a data model it's important to think about the repercussions of how that design will affect the application and the data going forward. Sometimes a simple design can lead to unexpected problems like redundant data and data that's very difficult to maintain. In this module we're going to introduce the concept of normalization. We'll talk about what normalization is and what it means for our data model. We'll revisit the components of a data model and see how adding normalization into the mix affects what components we need to add. And we'll get back into our specific comic book catalog data model and see how normalization is going to change our design.

Coding the Data Model
What started as a very simple single entity data model, has evolved into a much more complex robust and flexible data model due to the process of normalization. In this module we're going to use what we've learned about normalization to reflect the changes that we made into our model into our class library in C# and into our database in SQL Server.

Erased From Existence! Maintaining Data Integrity Over Time
Any good data model is going to have data accuracy and integrity at the top of the list of important features, but during design we may sometimes overlook the need to keep track of changes as they occur over time. In this module we're going to talk about maintaining data integrity over time. We'll discuss the problems that may occur if we fail to track these changes. We'll revisit the components of a data model again and see how time may influence our designs. We'll go back to our data model, the comic book catalog, and see how introducing the component of time will affect our model. We'll also dig back into Visual Studio and SQL Server Management Studio to make these changes in our C# and SQL Server code.

Everything's Connected: Removing Unnecessary Dependencies
Sometimes when we're designing a data model we make connections between entities or add relationships that make sense initially, but as we get deeper into our design they end up posing a problem due to unnecessary dependencies that we've created. In this module we're going to look at how to remove unnecessary dependencies. We'll start by examining the problems that an unnecessary dependency can cause. We'll look at our comic book catalog data model and determine the best way to remove those unnecessary dependencies we discovered from that model. And of course we'll use C# and SQL Server to make those same changes within our class library and our database.

Final Issue!
Together we've taken our data model from a concept, to a single entity data model, to a complex model with multiple entities. We discussed the process of building a data model and highlighted many of the problems that you're likely to encounter as you build your own model. In this module we're going to take a quick look back and revisit some of the key topics that we've discussed throughout the course. We introduced several of the key components that you'll need to build any good data model. We'll touch base with that list one last time. We'll also revisit some of the concepts that we discussed when it comes time for you to build your own data model. And of course, we'll take one last look at the normalization process. At the end of this module we're going to take a brief look forward to see what the next step for our data model could be.