Solving MVVM Binding for Custom Control in WinUI with CommunityToolkit.Mvvm

Learn how to effectively implement `MVVM` binding with a custom control in `WinUI 3` using `ObservableCollection` while maintaining a clear separation of concerns in your application.
---
This video is based on the question https://stackoverflow.com/q/75939850/ asked by the user 'TheSpixxyQ' ( https://stackoverflow.com/u/6641322/ ) and on the answer https://stackoverflow.com/a/75940812/ provided by the user 'Andrew KeepCoding' ( https://stackoverflow.com/u/2411960/ ) at 'Stack Overflow' website. Thanks to these great users and Stackexchange community for their contributions.

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: MVVM Bind model to custom control code behind

Also, Content (except music) licensed under CC BY-SA https://meta.stackexchange.com/help/l...
The original Question post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license, and the original Answer post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license.

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
Solving MVVM Binding for Custom Control in WinUI with CommunityToolkit.Mvvm

In the world of Modern Windows applications, leveraging the Model-View-ViewModel (MVVM) pattern effectively is crucial for creating maintainable and testable code. In this guide, we'll tackle a specific challenge encountered while building a WinUI application that employs a custom control and requires a refined approach to data binding while adhering to MVVM principles.

Introduction to the Problem

When creating a WinUI application that makes use of a Win2D canvas, you might wonder how to best manage the relationship between your model and a custom control without tightly coupling them. The objective here is to bind an ObservableCollection<Polygon> to a CanvasControl while maintaining a clean separation between your model, view, and view model. Let’s analyze this in detail.

Your Setup

Here’s a brief overview of your development environment and setup:

You’re utilizing CommunityToolkit.Mvvm for implementing MVVM.

Your application injects ViewModels using Dependency Injection (DI).

You have created a custom CanvasControl, responsible for rendering polygons defined in your model.

Code Overview

The custom canvas renders dynamic shapes based on a Polygon model defined as follows:

[[See Video to Reveal this Text or Code Snippet]]

The challenge arises when you want to ensure that interaction with these polygons (like drag-and-drop) reflects changes back to your underlying model without compromising your MVVM structure.

Proposed Solutions

Let’s explore two potential solutions you’ve considered and offer a recommended approach to achieve a clean MVVM implementation.

Solution 1: ObservableCollection of PolygonViewModel

You pondered creating an ObservableCollection<PolygonViewModel> and using a mapping strategy to convert Polygon models into PolygonViewModel instances. However, linking your custom control directly to PolygonViewModel may violate the modular principles of MVVM, as controls should remain agnostic to view models similar to standard controls like TextBox.

Solution 2: Use of a PolygonItem in the View Layer

Another idea was to create a PolygonItem object specifically in the view layer. This way, it could bind directly to ObservableCollection<Polygon> with a potential value converter. However, you'll find that if the converter resides in the ViewModel, it won't have access to the view layer's properties—leading to complexities that deviate from ideal practice.

Recommended Approach: Integrated Custom Control

A better approach is to reconsider the necessity of separating polygons from your custom canvas. Here’s how you can structure your custom control effectively:

Step 1: Create a Custom Control

Define your AwesomeCanvas control, which will directly interact with your ObservableCollection in the code-behind:

[[See Video to Reveal this Text or Code Snippet]]

Step 2: Bind in XAML

Use the AwesomeCanvas in your XAML page, binding it to the ViewModel's ObservableCollection:

[[See Video to Reveal this Text or Code Snippet]]

Step 3: Manage Commands in the ViewModel

Your MainPageViewModel can also manage commands to add or remove polygons seamlessly:

[[See Video to Reveal this Text or Code Snippet]]

Conclusion

In summary, when addressing the binding of a custom control to models in a WinUI application while upholding MVVM, maintain the separation of concerns by utilizing a carefully structured custom control that acts as an intermediary with the model. By embedding your collection handling in the control itself and using straightforward binding techniques, you retain flexibility and clean architectural principles.

With careful a