5 Modern Alternatives to MessagingCenter in .NET MAUI 9

Join our exclusive WhatsApp group for Xamarin and .NET MAUI developers to connect with experts, share insights, and get help with your projects. Whether you're a beginner or an experienced developer, this group is the perfect place to enhance your skills and collaborate with the community.

Sending Messages in .NET MAUI 9 — Modern Alternatives to MessagingCenter

Short summary: MessagingCenter was handy in Xamarin.Forms for broadcast-style communication across pages/viewmodels/services. In .NET MAUI (.NET 9) you should use modern, safer, and more testable approaches. This post covers five alternatives. For each option we’ll walk step-by-step: diagram → code (string & class) → detailed explanation.

---

1. WeakReferenceMessenger (CommunityToolkit.Mvvm) — Recommended

Sender → Messenger → Receiver (weak references used by messenger)

String Message Example

// Send
WeakReferenceMessenger.Default.Send("Hello from Page A");

// Receive
WeakReferenceMessenger.Default.Register<string>(this, (recipient, message) =>
{
    Console.WriteLine($"Received string: {message}");
});

// Unregister
WeakReferenceMessenger.Default.Unregister<string>(this);

Class Message Example

public class LoginSuccessMessage
{
    public string Username { get; set; }
}

// Send
WeakReferenceMessenger.Default.Send(new LoginSuccessMessage { Username = "Kirti" });

// Receive
WeakReferenceMessenger.Default.Register<LoginSuccessMessage>(this, (r, msg) =>
{
    Console.WriteLine($"Welcome {msg.Username}");
});

// Unregister
WeakReferenceMessenger.Default.Unregister<LoginSuccessMessage>(this);

Explanation: Strongly typed messages avoid fragile string keys. Uses weak references, so recipients don’t block garbage collection. Still best practice: explicitly unregister in OnDisappearing or Dispose. Great for most apps with MVVM.

---

2. Prism EventAggregator

Publisher → EventAggregator → Subscriber (use tokens to unsubscribe)

String Example

using Prism.Events;

// Define event
public class MessageEvent : PubSubEvent<string> { }

// Subscribe
var token = _eventAggregator.GetEvent<MessageEvent>().Subscribe(msg =>
{
    Console.WriteLine($"Prism received: {msg}");
});

// Publish
_eventAggregator.GetEvent<MessageEvent>().Publish("Hello from Prism");

// Unsubscribe
_eventAggregator.GetEvent<MessageEvent>().Unsubscribe(token);

Class Example

public class UserEvent : PubSubEvent<User> { }

public class User { public string Name { get; set; } }

// Subscribe
var token = _eventAggregator.GetEvent<UserEvent>().Subscribe(user =>
{
    Console.WriteLine($"User: {user.Name}");
});

// Publish
_eventAggregator.GetEvent<UserEvent>().Publish(new User { Name = "Kirti" });

Explanation: Integrates tightly with Prism DI/navigation. Use tokens to unsubscribe. Best for large, modular apps.

---

Table of Contents for .Net Maui

• What is .NET MAUI and why it’s important
• Applying the MVVM pattern for cleaner architecture
• Working with Renderers and Mappers
• Storing data locally using SQLite and Preferences
• Image Picker from gallery
• Sending push notifications using Firebase
• Publishing your app to Android and iOS stores
• 🌟 Explore More Topics

---

---

3. Events & Delegates (Static)

Publisher → Static Event → Subscriber (manual unsubscribe required)

String Example

public static class AppEvents
{
    public static event Action<string> OnMessage;
    public static void Send(string msg) => OnMessage?.Invoke(msg);
}

AppEvents.OnMessage += msg => Console.WriteLine(msg);
AppEvents.Send("Hello Events");

Class Example

public class User { public string Name { get; set; } }

public static class UserEvents
{
    public static event Action<User> OnLogin;
    public static void Raise(User u) => OnLogin?.Invoke(u);
}

UserEvents.OnLogin += u => Console.WriteLine(u.Name);
UserEvents.Raise(new User { Name = "Kirti" });

Explanation: Very simple, but requires careful unsubscribe to avoid leaks. Tightly coupled, not ideal for big apps.

---

4. Dependency Injection Message Service

Publisher → IMessageService (DI singleton) → Subscriber (injectable, testable)

String Example

public interface IMessageService
{
    event Action<string> OnMessage;
    void Send(string msg);
}

public class MessageService : IMessageService
{
    public event Action<string> OnMessage;
    public void Send(string msg) => OnMessage?.Invoke(msg);
}

// Register in MauiProgram.cs
builder.Services.AddSingleton<IMessageService, MessageService>();

// Usage
_messageService.OnMessage += msg => Console.WriteLine(msg);
_messageService.Send("Hello DI");

Class Example

public class UserMessage { public string Name { get; set; } }

public interface IUserMessageService
{
    event Action<UserMessage> OnLogin;
    void Send(UserMessage msg);
}

public class UserMessageService : IUserMessageService
{
    public event Action<UserMessage> OnLogin;
    public void Send(UserMessage msg) => OnLogin?.Invoke(msg);
}

Explanation: Fully DI-friendly, testable. Requires unsubscribing when consumers are disposed.

---

5. Reactive Extensions (Rx)

Publisher → Rx Subject → Subscriber (dispose subscription when done)

String Example

using System.Reactive.Subjects;

public static class RxBus
{
    private static readonly Subject<string> _subject = new();
    public static IObservable<string> Messages => _subject;
    public static void Send(string msg) => _subject.OnNext(msg);
}

var disp = RxBus.Messages.Subscribe(msg => Console.WriteLine(msg));
RxBus.Send("Hello Rx");
disp.Dispose();

Class Example

public class User { public string Name { get; set; } }

public static class RxUserBus
{
    private static readonly Subject<User> _subject = new();
    public static IObservable<User> Users => _subject;
    public static void Send(User u) => _subject.OnNext(u);
}

var disp = RxUserBus.Users.Subscribe(u => Console.WriteLine(u.Name));
RxUserBus.Send(new User { Name = "Kirti" });
disp.Dispose();

Explanation: Powerful: you can filter, transform, and combine streams. Must remember to dispose subscriptions. Ideal for apps already using reactive programming.

---

Conclusion

Default choice: WeakReferenceMessenger.
Big Prism apps: EventAggregator.
Simple cases: Events or DI.
Complex/reactive UIs: Rx.

Each option can replace MessagingCenter effectively depending on project size and architecture.