MVVM in WPF Survival Guide From A to Z

MVVM in WPF Survival Guide From A to Z, available at $64.99, has an average rating of 4, with 93 lectures, 2 quizzes, based on 775 reviews, and has 4776 subscribers.

You will learn about 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 This course is ideal for individuals who are Intermediate developers who want to learn MVVM or Experts who applied MVVM, but lack the deep understanding of it or It is not for beginners with the lack of C# experience or no WPF experience It is particularly useful for Intermediate developers who want to learn MVVM or Experts who applied MVVM, but lack the deep understanding of it or It is not for beginners with the lack of C# experience or no WPF experience.

Enroll now: MVVM in WPF Survival Guide From A to Z

Summary

Title: MVVM in WPF Survival Guide From A to Z

Price: $64.99

Average Rating: 4

Number of Lectures: 93

Number of Quizzes: 2

Number of Published Lectures: 93

Number of Published Quizzes: 2

Number of Curriculum Items: 95

Number of Published Curriculum Objects: 95

Original Price: $34.99

Quality Status: approved

Status: Live

What You Will 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

Who Should Attend

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

Target Audiences

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 (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

Course Curriculum

Chapter 1: Introduction to MVVM

Lecture 1: How to Ask Questions

Lecture 2: Join .NET Community of Students

Lecture 3: Introduction

Lecture 4: Applications Maintaining

Lecture 5: Why MVVM?

Lecture 6: MVVM in a Nutshell

Lecture 7: Services in MVVM

Lecture 8: Educational Application Overview

Lecture 9: Problems of Monolithic Design

Lecture 10: Downsides of MVVM

Lecture 11: Conclusion

Chapter 2: Connecting Views and ViewModels

Lecture 1: Outline

Lecture 2: Naming Conventions

Lecture 3: Preparing the Solution

Lecture 4: View-First VS ViewModel-First

Lecture 5: View-First Intro

Lecture 6: Straightforward View-First Implementation

Lecture 7: View-First via ViewModel-Locator. AutoWiring.

Lecture 8: Dependency Injection and Inversion of Control

Lecture 9: Bootstrapper and IoC. Intro

Lecture 10: Bootstrapper and IoC. Demo

Lecture 11: Design-Time Data. Intro

Lecture 12: Design-Time Data. Demo: Separate ViewModels and Mixing In.

Lecture 13: Design-Time Data. Demo: Avoiding Duplication.

Lecture 14: View-First via ViewModel-Locator. Locator as a Container.

Lecture 15: ViewModel-First. Intro

Lecture 16: ViewModel-First. Demo

Lecture 17: Conclusion

Chapter 3: Communicating Views and ViewModels

Lecture 1: Outline

Lecture 2: Commands in WPF and MVVM

Lecture 3: RelayCommand. Intro

Lecture 4: RelayCommand. Demo

Lecture 5: Behaviors. Intro

Lecture 6: Attached Behaviors

Lecture 7: Blend Behaviors

Lecture 8: MessageBus. Intro

Lecture 9: MessageBus. Demo

Lecture 10: Conclusion

Chapter 4: Navigation and Other Services

Lecture 1: Outline

Lecture 2: Locating MVVM Components

Lecture 3: UI-Composition

Lecture 4: Navigation without Parameters

Lecture 5: Navigation with Parameters

Lecture 6: Homework: Navigation without MessageBus

Lecture 7: Dialogs. Intro

Lecture 8: Dialogs API Demo

Lecture 9: Applying Dialogs API

Lecture 10: Making INotifyPropertyChanged Less Painful

Lecture 11: Conclusion

Chapter 5: Models and Validation

Lecture 1: Outline

Lecture 2: Models Wrapping

Lecture 3: Stateful ViewModel VS Stateless ViewModel

Lecture 4: Validation. Intro

Lecture 5: Validation. Demo 1.

Lecture 6: Validation. Demo 2.

Lecture 7: Homework: Apply Validation for managing the state of UI

Lecture 8: Conclusion

Chapter 6: MVVM Frameworks

Lecture 1: Outline

Lecture 2: MVVM Frameworks

Lecture 3: Prism and MVVM-Light

Lecture 4: Caliburn.Micro. Intro

Lecture 5: Caliburn.Micro. Demo

Lecture 6: Conclusion

Chapter 7: Wrap Up

Lecture 1: Final Words

Chapter 8: Appendix A. Unit Testing.

Lecture 1: Unit Tests for ViewModels

Chapter 9: Appendix B: Implementing a Real-World Application

Lecture 1: Outline

Lecture 2: True or False Game

Lecture 3: Constructing MainWindow.xaml

Lecture 4: Implementing Logic of MainWindow

Lecture 5: Constructing GameWindow.xaml

Lecture 6: Implementing Logic of GameWindow

Lecture 7: Problems of Monolithic Design

Lecture 8: Preparing MVVM-based Application

Lecture 9: Bootstrapping with Caliburn.Micro and Castle.Windsor

Lecture 10: Bringing Models and Services

Lecture 11: Implementing the Remaining Part

Chapter 10: Appendix C1: Dependency Inversion Principle.

Lecture 1: Outline

Lecture 2: DIP Definition

Lecture 3: Dependencies

Lecture 4: Volatile and Stable Dependencies

Lecture 5: Definitions of IoC and DI

Lecture 6: DIP Violation Demo

Lecture 7: Refactoring to a Better Design Applying DI

Lecture 8: DI Techniques

Lecture 9: Architectural Implications

Lecture 10: Common Smells of DIP Violation

Lecture 11: Conclusion

Chapter 11: Appendix C2: Introduction to DI-Containers (IoC-Containers)

Instructors

Engineer Spock
Software Engineer – 1000+ Reviews, Average Score – 4.5

Rating Distribution

1 stars: 43 votes

2 stars: 50 votes

3 stars: 142 votes

4 stars: 250 votes

5 stars: 290 votes

Frequently Asked Questions

How long do I have access to the course materials?

You can view and review the lecture materials indefinitely, like an on-demand channel.

Can I take my courses with me wherever I go?

Definitely! If you have an internet connection, courses on Udemy are available on any device at any time. If you don’t have an internet connection, some instructors also let their students download course lectures. That’s up to the instructor though, so make sure you get on their good side!