.NET MAUI - Good Bye MessagingCenter, Welcome WeakReferenceManager

MessagingCenter.Send(this, "NotificationMessage");

MessagingCenter.Subscribe<SenderObject>(this, "NotificationMessage", ((sender, e)=> { // Take action here });

MessagingCenter.Unsubscribe<SenderObject>(this, "NotificationMessage");

using CommunityToolkit.Mvvm.Messaging.Messages;
namespace adsMauiPublisherSubscriber {
    public class OpenWindowMessage: ValueChangedMessage < bool > {
        public OpenWindowMessage(bool value): base(value) {}
    }
}

The next step is implementing a ViewModel where you will also see the message in action. Add a new class called ViewModel.cs to the project, with the following code:

using CommunityToolkit.Mvvm.Messaging;
namespace adsMauiPublisherSubscriber {
    public class ViewModel {
        public Command OpenWindowCommand {
            get {
                return new Command(() => {
                    WeakReferenceMessenger.Default.Send(new OpenWindowMessage(true));
                });
            }
        }
    }
}

This is a very simple class with only one command, which is okay for instructional purposes. The OpenWindowCommand will be later bound to a button in the UI. When invoked, it sends a broadcast message. This is accomplished by invoking the Send method over a single instance of the WeakReferenceMessenger class, represented by the Default property. The method takes a message as an argument, and the constructor needs you to supply the value that you want to be sent to subscribers along with the message. Here the code is sending true, so that callers understand that a new page must be opened. Again, remember that you can implement and send instances of more complex types depending on the structure of your information.

Adding a secondary page

Because we want to demonstrate how to open a new page from the main one via messages, it is necessary adding a new ContentPage to the project. Right-click the project name and select Add, New Item. In the Add New Item dialog select the .NET MAUI node on the left and then the .NET MAUI ContentPage (XAML) template. You can leave the default name unchanged, this is not relevant now. The only work needed on this page is sending another message when the page is closing. This can be accomplished by handling the OnDisappearing method as follows:

protected override void OnDisappearing() {
    base.OnDisappearing();
    WeakReferenceMessenger.Default.Send(new OpenWindowMessage(false));
}

The code sends the same message, but this time the value is false. This will make callers understand what happened on this side.

Registering for broadcast messages

Open the MainPage.xaml file and change the content for the Button object as follows:

<Button
    x:Name="OpenWindowBtn"
    Text="Click me" Command="{Binding OpenWindowCommand}"
    HorizontalOptions="Center" />

This binds the button to a command in the ViewModel. In the code-behind file, replace the full code with the following (comments follow below):

using CommunityToolkit.Mvvm.Messaging;
namespace adsMauiPublisherSubscriber;
public partial class MainPage: ContentPage {
    private ViewModel WindowViewModel {
        get;
        set;
    }
    public MainPage() {
        InitializeComponent();
        WindowViewModel = new ViewModel();
        WeakReferenceMessenger.Default.Register < OpenWindowMessage > (this, HandleOpenWindowMessage);
        BindingContext = WindowViewModel;
    }
    private async void HandleOpenWindowMessage(object recipient, OpenWindowMessage message) {
        switch (message.Value) {
            case true:
                await Navigation.PushAsync(new NewPage1());
                break;
            default:
                await DisplayAlert("Alert", "Secondary window was closed", "OK");
                break;
        }
    }
}

In the constructor of the page, a new instance of the ViewModel is created and assigned to the page as the data source (BindingContext). The page is also subscribing for messages of type OpenWindowMessage, without knowing who the sender is. Registering to a message is accomplished via the Register method of the WeakRefernceMessenger class, which takes the message type as the generic type parameter, plus the instance of the subscriber (this) and a method that contains the action to take when the message is intercepted. In this case, the action is handled by the HandleOpenWindowMessage method, which is responsible for opening the secondary page or showing an alert when the secondary page is closed, depending on the value of the message.

Unsubscribing from messages

In the real-world development, you should also unsubscribe from messages when no longer needed. This can be accomplished by invoking the Unregister method as follows:

WeakReferenceMessenger.Default.Unregister<OpenWindowMessage>(this);

The Unregister method takes the message type as the generic parameter and the instance of the subscriber object. In the sample code, it is not necessary to do this because messages are subscribed in the main page, so closing the main page will also close the app and certainly unsubscribe from messages. But if you are handling messages on a secondary page, you should unsubscribe explicitly when no longer necessary.

Running the sample code

The following screenshots are taken from an Android simulator, but the result should be similar if you work with other devices as the project is cross-platform. If you run the sample app, you can see how the secondary page is opened when you click the button on the Main Page, but it is happening via command bindings and messages (not button clicks),

When this page is closed, the message is received and handled with a different value, so an alert is displayed,

Conclusions

As a developer working with .NET MAUI, it is very important that you know how to implement and handle broadcast messages especially if you target .NET 7 and if you need to work with the MVVM pattern. This article has explained how to do this in a simplified yet effective way.