概述

IMessenger 是 CommunityToolkit.Mvvm 中的核心消息传递接口，提供了一种松耦合的通信机制，允许应用程序中的不同组件之间高效地交换消息。本文将详细探讨 IMessenger 的使用方法和最佳实践。

Nuget 安装包

消息类型定义

在使用 IMessenger 时，我们需要定义清晰的消息类型。以下是消息类型的推荐设计：

C#
// 定义基础消息类型
public class BaseMessage
{
    public DateTime Timestamp { get; set; } = DateTime.Now;
}

// 具体的消息类型
public class UserMessage : BaseMessage
{
    public string Username { get; set; }
    public string Content { get; set; }
}

public class SystemNotificationMessage : BaseMessage
{
    public string NotificationType { get; set; }
    public string Message { get; set; }
}

消息发送与接收

配置 IMessenger

首先，在应用程序启动时配置 IMessenger：

C#
using CommunityToolkit.Mvvm.Messaging;

namespace App09
{
    internal class Program
    {
        static void Main(string[] args)
        {
            // 使用默认的弱引用消息传递器  
            var messenger = WeakReferenceMessenger.Default;

            // 创建视图模型  
            var userViewModel = new UserViewModel(messenger);
            var notificationViewModel = new NotificationViewModel(messenger);

            // 发送用户消息  
            userViewModel.SendUserMessage("rick", "这是一条测试消息!");

            // 发送系统通知  
            messenger.Send(new SystemNotificationMessage
            {
                NotificationType = "信息",
                Message = "系统已启动"
            });

            // 打印最新消息  
            Console.WriteLine(notificationViewModel.LatestMessage);

            // 显示所有消息  
            foreach (var msg in notificationViewModel.AllMessages)
            {
                if (msg is UserMessage userMsg)
                {
                    Console.WriteLine($"用户消息 [{userMsg.Timestamp}]: {userMsg.Username} - {userMsg.Content}");
                }
                else if (msg is SystemNotificationMessage sysMsg)
                {
                    Console.WriteLine($"系统通知 [{sysMsg.Timestamp}]: {sysMsg.NotificationType} - {sysMsg.Message}");
                }
            }

            Console.ReadKey();
        }
    }
}

消息发送示例

C#
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using CommunityToolkit.Mvvm.ComponentModel;
using CommunityToolkit.Mvvm.Messaging;

namespace App09
{
    // 用户视图模型  
    public class UserViewModel : ObservableObject
    {
        private readonly IMessenger _messenger;
        private ObservableCollection<UserMessage> _messageHistory = new ObservableCollection<UserMessage>();

        public ObservableCollection<UserMessage> MessageHistory
        {
            get => _messageHistory;
            set => SetProperty(ref _messageHistory, value);
        }

        public UserViewModel(IMessenger messenger)
        {
            _messenger = messenger;
        }

        public void SendUserMessage(string username, string content)
        {
            var message = new UserMessage
            {
                Username = username,
                Content = content
            };

            // 发送消息  
            _messenger.Send(message);

            // 将消息添加到历史记录  
            MessageHistory.Add(message);
        }
    }
}

消息接收示例

C#
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using CommunityToolkit.Mvvm.ComponentModel;
using CommunityToolkit.Mvvm.Messaging;

namespace App09
{
    // 通知视图模型（接收用户消息）  
    public class NotificationViewModel : ObservableObject,
        IRecipient<UserMessage>,
        IRecipient<SystemNotificationMessage>
    {
        private string _latestMessage;
        public string LatestMessage
        {
            get => _latestMessage;
            set => SetProperty(ref _latestMessage, value);
        }

        private ObservableCollection<BaseMessage> _allMessages = new ObservableCollection<BaseMessage>();
        public ObservableCollection<BaseMessage> AllMessages
        {
            get => _allMessages;
            set => SetProperty(ref _allMessages, value);
        }

        private readonly IMessenger _messenger;

        public NotificationViewModel(IMessenger messenger)
        {
            _messenger = messenger;

            // 注册消息接收  
            _messenger.Register<UserMessage>(this);
            _messenger.Register<SystemNotificationMessage>(this);
        }

        public void Receive(UserMessage message)
        {
            // 处理接收到的用户消息  
            LatestMessage = $"{message.Username}: {message.Content}";
            AllMessages.Add(message);
        }

        public void Receive(SystemNotificationMessage message)
        {
            // 处理系统通知消息  
            LatestMessage = $"系统通知 [{message.NotificationType}]: {message.Message}";
            AllMessages.Add(message);
        }

        // 取消注册（在不需要时）  
        public void Cleanup()
        {
            _messenger.Unregister<UserMessage>(this);
            _messenger.Unregister<SystemNotificationMessage>(this);
        }
    }

}

消息订阅管理

高级订阅技巧

C#
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using CommunityToolkit.Mvvm.Messaging;

namespace App09
{
    // 日志记录器  
    public class MessageLogger
    {
        private readonly IMessenger _messenger;

        public MessageLogger(IMessenger messenger)
        {
            _messenger = messenger;

            // 订阅所有消息  
            SubscribeToAllMessages();
        }

        private void SubscribeToAllMessages()
        {
            // 无条件订阅所有消息  
            _messenger.Register<Message>(this, (recipient, message) =>
            {
                Console.WriteLine($"[日志] 收到消息 - 类型：{message.Type}, 内容：{message.Content}");
            });
        }
    }
}

C#
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using CommunityToolkit.Mvvm.Messaging;

namespace App09
{
    // 消息类  
    public class Message
    {
        public string Content { get; set; }
        public MessageType Type { get; set; }

        // 消息类型枚举  
        public enum MessageType
        {
            Normal,
            Important,
            Critical
        }
    }
    // 消息订阅管理器  
    public class MessageSubscriptionManager
    {
        private readonly IMessenger _messenger;

        public MessageSubscriptionManager(IMessenger messenger)
        {
            _messenger = messenger;

            // 订阅重要和关键消息  
            SubscribeToImportantMessages();
        }

        private void SubscribeToImportantMessages()
        {
            _messenger.Register<Message>(this, (recipient, message) =>
            {
                if (message.Type >= Message.MessageType.Important)
                {
                    Console.WriteLine($"接收到重要消息：{message.Content}");
                }
            });
        }

        // 发送消息方法  
        public void SendMessage(string content, Message.MessageType type)
        {
            var message = new Message
            {
                Content = content,
                Type = type
            };

            // 发送消息  
            _messenger.Send(message);
        }
    }

}

C#
using CommunityToolkit.Mvvm.Messaging;

namespace App09
{
    internal class Program
    {
        static void Main(string[] args)
        {
            // 使用默认消息传递器  
            var messenger = WeakReferenceMessenger.Default;

            // 创建订阅管理器  
            var subscriptionManager = new MessageSubscriptionManager(messenger);

            // 创建日志记录器  
            var logger = new MessageLogger(messenger);

            // 发送不同类型的测试消息  
            Console.WriteLine("发送普通消息：");
            subscriptionManager.SendMessage("这是一条普通消息", Message.MessageType.Normal);

            Console.WriteLine("\n发送重要消息：");
            subscriptionManager.SendMessage("这是一条重要消息", Message.MessageType.Important);

            Console.WriteLine("\n发送关键消息：");
            subscriptionManager.SendMessage("这是一条关键消息", Message.MessageType.Critical);
            Console.ReadKey();
        }
    }
}

注意事项

注意事项

• 使用弱引用消息传递，避免内存泄漏
• 及时取消注册不再需要的订阅
• 定义清晰、具体的消息类型
• 考虑使用消息令牌进行更精细的消息控制
• 确保在不再需要时调用 Unregister
• 注意线程安全性
• 对于复杂的消息传递场景，考虑使用专门的消息类型

结论

CommunityToolkit.Mvvm 的 IMessenger 提供了一个强大且灵活的消息传递机制，能够显著提升应用程序的解耦和可维护性。