Teach on Udemy

Turn what you know into an opportunity and reach millions around the world.

Learn More

Your cart is empty.

Keep shopping

MVVM in WPF Survival Guide From A to Z

Name: MVVM in WPF Survival Guide From A to Z
Rating: 3.9 (831 reviews)

Learn how to create a maintainable Windows application applying MVVM to WPF. Introduction to Caliburn.Micro.

Created byEngineer Spock

Last updated 7/2020

English

What you'll learn

Logically and physically structuring WPF applications according to MVVM pattern
Apply either View-First or ViewModel-First approach
Set up Design-Time Data
Build a communication bridge between Views and ViewModels
Correctly apply a static message bus
Organize navigation
Validate Models
Build your own MVVM framework

Course content

11 sections • 93 lectures • 4h 24m total length

How to Ask Questions0:23
Join .NET Community of Students0:02
Introduction3:57
Explore the fundamentals of MVVM for WPF, including connecting views and viewmodels, design-time data, an IoC-container, navigation and dialogs, parameterized viewmodels, and testing to boost maintainability and testability.
Applications Maintaining2:26
In this lecture we will address the problem of maintainability and testability of applications.
Why MVVM?3:41
Why MVVM became a standard for developing WPF applications? We will answer to this question and briefly look at the historical background.
MVVM in a Nutshell7:25
You will learn from which components MVVM consists of and what their responsibilities are.
Services in MVVM1:57
What are Services and what is their role in the MVVM-based applications?
Educational Application Overview3:51
In this lecture you'll take a brief look at the simple educational application we will be working with throughout the course.
Problems of Monolithic Design2:43
In this lecture you'll learn why monolithic design is the pure evil in most cases.
Downsides of MVVM1:58
In this lecture you'll learn what to expect from learning and applying the MVVM pattern.
Conclusion1:25
In this lecture we sum up the things we talked about in this module.

Outline0:55
In this lecture we will outline the topics connected with the problem of marrying up Views and ViewModels in MVVM-based applications.
Naming Conventions1:47
In this lecture you'll learn how to name the MVVM components: how to name Views and ViewModels.
Preparing the Solution4:15
In this lecture we will make some preliminary preparations before diving into the MVVM.
View-First VS ViewModel-First0:47
In this lecture you'll learn what approaches for connecting Views and ViewModels exist within the MVVM pattern.
View-First Intro2:29
In this lecture you'll learn what the View-First approach is in essence.
Straightforward View-First Implementation3:43
In this practical lecture you'll learn how to apply the View-First approach straightforwardly. It means we will look at how to create ViewModels in XAML and code-behind.
View-First via ViewModel-Locator. AutoWiring.3:13
In this lecture you'll learn what the ViewModel-Locator pattern is. You'll see how to automatically connect ViewModels to Views.
Dependency Injection and Inversion of Control0:12
Bootstrapper and IoC. Intro3:12
In this lecture you'll briefly look at what the "Inversion of Control" is and what the bootstrapping means.
Bootstrapper and IoC. Demo4:09
In this lecture you'll learn how to construct the Bootstrapper within the MVVM pattern and how to attach the IoC-container.
Design-Time Data. Intro1:49
This lecture reveals the problem of validating the layout of data in the design-time (design-mode).
Design-Time Data. Demo: Separate ViewModels and Mixing In.4:14
In this lecture you'll see how to create separate ViewModels suited specifically for loading the design-time data. After that you'll look at how to mix the runtime and design-time logic.
Design-Time Data. Demo: Avoiding Duplication.2:27
In this lecture you'll see the slick approach to instantiating ViewModels in order to inject into them design-time dependencies. This allows to avoid mixing the runtime and design-time logic as well as to avoid creation of any additional ViewModels.
View-First via ViewModel-Locator. Locator as a Container.1:53
We've detracted a little bit. So, in this lecture we get back to the main topic of this module: marrying up Views and ViewModels. In this lecture you'll learn another form of the ViewModel-Locator pattern when it poses itself as a container of ViewModels.
ViewModel-First. Intro1:38
At last! We've reached the ViewModel-First approach. So, what it is?
ViewModel-First. Demo5:09
In this lecture you'll learn how to apply the ViewModel-First approach in practice.
Conclusion1:05
Let's wrap up all the things you've learned in this module.

Outline0:41
We will outline to main topics of this module.
Commands in WPF and MVVM1:46
In this module you'll learn what commands in WPF are.
RelayCommand. Intro1:03
In this lecture you'll look at the reusable implementation of the ICommand interface.
RelayCommand. Demo6:10
In this lecture you'll look at how to apply the RelayCommand implementation in practice.
Behaviors. Intro2:10
Commands system in WPF is not sufficient for building the full-fledged communication bridge between Views and ViewModels. Behaviors are for the rescue.
Attached Behaviors3:03
Learn how to develop and apply so-called "Attached Behaviors".
Blend Behaviors2:02
Blend Behaviors are more powerful than bear Attached Behaviors. Look at them in practice.
MessageBus. Intro0:48
In this lecture you'll learn what is the "MessageBus" (EventAggregator) pattern in essence.
MessageBus. Demo3:51
In this lecture you'll learn how to apply "MessageBus" (EventAggregator) in practice.
Conclusion1:00
Let's wrap up the main topics of this module.

Outline0:49
In this lecture we will outline the main topics of this module.
Locating MVVM Components1:39
In this lecture we will talk about structuring solutions from the MVVM perspectives. Is it better to keep all the Views and ViewModels in a single project?
UI-Composition1:02
In this lecture I'll introduce you to the concept of UI-Composition.
Navigation without Parameters3:55
Learn how to navigate to ViewModels which don't require parameters to be passed in via their constructors.
Navigation with Parameters3:11
Learn how to navigate to ViewModels which require parameters to be passed in their constructors.
Homework: Navigation without MessageBus0:48
A little homework for students.
Dialogs. Intro0:33
Introduction to the problem of opening dialogs.
Dialogs API Demo4:02
In this lecture you'll see one of the approaches to opening dialogs in MVVM.
Applying Dialogs API4:24
In this lecture you'll see how to apply the API we discussed in the previous lecture.
Making INotifyPropertyChanged Less Painful1:33
In this lecture you'll learn how to keep the reusable INPC implementation in the MVVM framework.
Conclusion0:53
Let's wrap up the main topics of this module.

Outline0:38
In this lecture we will outline the main topics of this module.
Models Wrapping1:30
Learn why you may want to wrap a model in MVVM.
Stateful ViewModel VS Stateless ViewModel1:43
Learn the different between two different approaches to managing the state of data: Stateful ViewModel and Stateless ViewModel.
Validation. Intro1:45
Learn how you can implement validation in WPF.
Validation. Demo 1.2:06
Learn how to implement and apply the INotifyDataErrorInfo interface for validation.
Validation. Demo 2.4:04
Learn how to implement and apply the INotifyDataErrorInfo interface for validation.
Homework: Apply Validation for managing the state of UI0:05
Do a little homework.
Conclusion0:58
Wrap up the main topics of this module.

Outline0:56
We will outline the main topics of this module.
MVVM Frameworks1:34
In this lecture you'll learn what modern popular MVVM frameworks exist.
Prism and MVVM-Light2:07
In this lecture we will take a brief look at Prism and MVVM-Light.
Caliburn.Micro. Intro2:49
In this lecture you'll be introduced to the Caliburn.Micro MVVM framework.
Caliburn.Micro. Demo3:44
Learn how to use the Caliburn.Micro MVVM framework in practice.
Conclusion0:49
Wrap up the main topics of this module.

Outline1:10
Learn to build a real-world Wpf application by authoring Xaml layouts, creating two windows, and implementing mvvm using code-behind and an mvvm framework to improve maintainability.
"True or False" Game1:48
Develop a true or false game in a WPF application to illustrate MVVM concepts, including a statement editor, XML-based storage, and a two-window interface in a .NET Framework 4.5 project.
Constructing MainWindow.xaml12:01
Construct a WPF main window using a dock panel with a top file menu, a bottom button row, a numeric up-down, a true/false checkbox, and a full-width statement editor.
Implementing Logic of MainWindow11:37
Create a serializable statement class and a persistence layer to save and load statements via XML in a WPF main window. Implement add, edit, navigate, and UI state management.
Constructing GameWindow.xaml4:10
Construct a two-row game window in wpf (GameWindow.xaml) using a grid, a text block in the first row, and exit, false, and true buttons with a state display.
Implementing Logic of GameWindow3:38
Implement the game window logic by wiring event handlers, managing statements, a counter, and a score; process true/false answers and show the final score.
Problems of Monolithic Design0:09
Preparing MVVM-based Application4:38
Explore why mvvm in wpf is complex and learn bootstrapping, ioc setup, and creating a structured solution with Caliburn Micro, Castle Windsor, and Extended WPF Toolkit.
Bootstrapping with Caliburn.Micro and Castle.Windsor6:27
Bootstrap a Caliburn Micro framework app with a Windsor container, register view models and services, and drive ActiveItem on the shell view to activate the main view.
Bringing Models and Services2:54
Implement a dialog service to keep view models testable and enforce separation of presentation concerns, by updating the statement model with INotifyPropertyChanged and wiring IDialogService in the Bootstrapper.
Implementing the Remaining Part6:19
Implements the remaining part by wiring the main and game views with Caliburn Micro, using design-time context, binding, and naming conventions for automated actions and unit testing.

Outline1:35
The outline of the section dedicated to Dependency Inversion Principle (DIP) and Dependency Injection (DI) where you'll learn the main definitions and concepts.
DIP Definition3:30
Learn what is Dependency Inversion Princple (DIP) in essence.
Dependencies4:49
Learn the definition of a dependency.
Volatile and Stable Dependencies2:53
Learn the difference between volatile dependencies and stable dependencies.
Definitions of IoC and DI3:18
Learn what is "inversion of control" and "dependency injection".
DIP Violation Demo2:47
Look at an example of DIP violation on practice.
Refactoring to a Better Design Applying DI8:31
Look at the refactoring process based on Dependency Injection (DI) that leads to a better design of the application.
DI Techniques7:09
Learn different Dependency Injection (DI) techniques such as Constructor Injection, Property Injection and Method Injection.
Architectural Implications5:24
Learn about the architectural implications of dependency injection.
Common Smells of DIP Violation2:37
Learn about the common smells of Dependency Inversion Principle (DIP) violation.
Conclusion2:03
A conclusion of the section dedicated to Dependency Inversion Principle (DIP) and Dependency Injection (DI). Recap what you learned.

Requirements

You should already have a decent C# and a little bit of WPF experience.

Description

MVVM (stands for Model-View-ViewModel) is a well-known architectural pattern in the world of WPF. Most enterprise level WPF applications are MVVM-based.

Learn deeply the concepts lying behind the MVVM pattern in order to understand what MVVM is in essence and how to pragmatically apply it to a WPF application. This is a great MVVM tutorial for beginners (beginners in MVVM, don't forget to look at prerequisites)!

Teaching Approach

No fluff, no ranting, no beating the air. I respect your time. The course material is succinct, yet comprehensive. All important concepts are covered. Particularly important topics are covered in-depth. Don't forget that this course has English subtitles, so if you don't understand my accent, feel free to turn them on.

Take this course and you will be satisfied.

Build a strong foundation in applying MVVM with this course

In the case you’re just familiar with the WPF framework, learning this course will give you a level-up since you’ll be capable of developing professional WPF applications. Applying MVVM intelligently is a “must have” skill for WPF developers.

If you are an experienced WPF developer, you might be interested in how MVVM frameworks may work under the hood. Throughout the course, we will be building a small MVVM framework similar to Caliburn.Micro.

Content and Overview

This course is primarily aimed at intermediate developers. Experts may also find interesting MVVM tricks provided in this course. If you are a beginner, be sure you’re ready to take this course, since it requires from you a solid C#-background and acquaintance with WPF.

This course provides solid theoretical base reinforced by tons of practical material. This course is very practical (except the very first introductory module).

“MVVM in WPF” is a very wide topic and it’s hardly possible to cover all the related challenges arising while applying MVVM. That’s why this course includes the most important topics understanding of which is a key for successful development. We will sacrifice some topics which may be interesting for students, but which are hardly connected with MVVM directly. What I’m talking about is, for example, the problem of setting up a full-fledged data access layer. Such topics are omitted.

The most beneficial aspect of this course is that it gives you the deep understanding of the MVVM pattern. For example, you’ll see how to pass parameters to ViewModels through constructors, without using a static message bus, or passing parameters by explicitly setting properties of a ViewModel.

In short, the course covers the following topics:

MVVM background: what is MVVM, why to use it, when to use MVVM etc.
Connecting Views and ViewModels: View-First and ViewModel-First approaches
Design-Time data support
Configuring and using an IoC-container (by the example of Castle.Windsor
Communication channel between Views and ViewModels: commands, attached and blend behaviors, static message bus (EventAggregator)
Navigation: hierarchical UI composition, how to open dialogs, including modal dialogs, navigating to parameterized ViewModels (pass parameters into their constructors)
Models and validation
MVVM toolkits: Caliburn.Micro more closely
Unit-Testing of ViewModels

In the end, we will recap what you have learned and you will try to understand where you have to go further with the intention to master your skills. Here we will have a discussion of different paths you can go on.

------------------------------------------------------------

Keywords related to the course:

MVVM in WPF
MVVM tutorial
MVVM pattern
Model-View-ViewModel MVVM tutorial
Caliburn.Micro
View-First
ViewModel-First

Who this course is for:

Intermediate developers who want to learn MVVM
Experts who applied MVVM, but lack the deep understanding of it
It is not for beginners with the lack of C# experience or no WPF experience

MVVM in WPF Survival Guide From A to Z

What you'll learn

Explore related topics

Course content

Introduction to MVVM11 lectures • 30min

Connecting Views and ViewModels17 lectures • 43min

Communicating Views and ViewModels10 lectures • 23min

Navigation and Other Services11 lectures • 23min

Models and Validation8 lectures • 13min

MVVM Frameworks6 lectures • 12min

Wrap Up1 lecture • 2min

Appendix A. Unit Testing.1 lecture • 5min

Appendix B: Implementing a Real-World Application11 lectures • 55min

Appendix C1: Dependency Inversion Principle.11 lectures • 45min

Requirements

Description

Who this course is for: