為WPF, UWP 及 Xamarin實現一個簡單的消息組件

原文地址：Implementing a simple messenger component for WPF, UWP and Xamarin

歡迎大家關注我的公眾號：程序員在新西蘭

了解新西蘭IT行業真實碼農生活
請長按上方二維碼關注“程序員在新西蘭”

 

最初的需求是我需要開發一個實現Socket發送/接收的WPF應用程序。 首先，我用MVVM模式創建了一個基本的WPF應用程序。 然后，我做了一個項目來完成所有與Socket通信有關的工作。 接下來，我必須將Socket項目集成到ViewModel項目中，以操作Socket連接。
顯然，我們可以為此使用event。 例如，我們可以有一個名為“ SocketServer”的類，該類具有一個事件來接收Socket數據包，然后在ViewModel層中對其進行訂閱。 但這意味着我們必須創建“ SocketServer”類的實例，該類將ViewModel層與套接字項目耦合在一起。 我希望創建一個中間件以解耦它們。 因此，發布者和訂閱者不需要彼此了解。

在我使用 MvvmCross 作為MVVM框架時，我發現MvvmCross提供了一個名為 Messenger 的插件以在ViewModel之間進行通信。 但是它依賴於某些MvvmCross庫，這意味着如果我想在其他項目中使用此插件，則必須引用MvvmCross。 這對我當前的情況而言並不理想，因為實際上，套接字項目沒有要求引用MvvmCross。 因此，我做了一個專注於發布/訂閱模式的項目，並刪除了對MvvmCross的依賴。 現在，我可以在任何WPF，UWP和Xamarin項目中重復使用它。 該項目位於此處：https://github.com/yanxiaodi/CoreMessenger 。讓我們深入了解更多細節。

信息

Message是在此系統中表示消息的抽象類：

    public abstract class Message
    {
        public object Sender { get; private set; }
        protected Message(object sender)
        {
            Sender = sender ?? throw new ArgumentNullException(nameof(sender));
        }
    }

我們應該創建從該抽象類派生的不同消息的實例。 它有一個名為“sender”的參數，因此訂閱者可以獲取發送者的實例。 但這不是強制性的。

訂閱

BaseSubscription是訂閱的基類。 代碼如下：

    public abstract class BaseSubscription
    {
        public Guid Id { get; private set; }
        public SubscriptionPriority Priority { get; private set; }
        public string Tag { get; private set; }
        public abstract Task<bool> Invoke(object message);
        protected BaseSubscription(SubscriptionPriority priority, string tag)
        {
            Id = Guid.NewGuid();
            Priority = priority;
            Tag = tag;
        }
    }

它具有一個“ Id”屬性和一個“ tag”屬性，因此您可以放置一些標簽來區分或分組訂閱實例。 “ Priority”屬性是一個枚舉類型，用於指示訂閱的優先級，因此將按預期順序調用訂閱。
訂閱有兩種類型。 一是“StrongSubscription”：

    public class StrongSubscription<TMessage> : BaseSubscription where TMessage : Message
    {
        private readonly Action<TMessage> _action;

        public StrongSubscription(Action<TMessage> action,
            SubscriptionPriority priority, string tag): base(priority, tag)
        {
            _action = action;
        }
        public override async Task<bool> Invoke(object message)
        {
            var typedMessage = message as TMessage;
            if (typedMessage == null)
            {
                throw new Exception($"Unexpected message {message.ToString()}");
            }
            await Task.Run(() => _action?.Invoke(typedMessage));
            return true;
        }
    }

它繼承了BaseSubscription並覆蓋了Invoke()方法。 基本上，它具有一個名為“ _action”的字段，該字段在創建實例時定義。 當我們發布消息時，訂閱將調用Invoke()方法來執行操作。 我們使用Task來包裝動作，以便可以利用異步操作的優勢。

這是名為“ WeakSubscription”的另一種“ Subscription”：

    public class WeakSubscription<TMessage> : BaseSubscription where TMessage : Message
    {
        private readonly WeakReference<Action<TMessage>> _weakReference;

        public WeakSubscription(Action<TMessage> action,
            SubscriptionPriority priority, string tag) : base(priority, tag)
        {
            _weakReference = new WeakReference<Action<TMessage>>(action);
        }

        public override async Task<bool> Invoke(object message)
        {
            var typedMessage = message as TMessage;
            if (typedMessage == null)
            {
                throw new Exception($"Unexpected message {message.ToString()}");
            }
            Action<TMessage> action;
            if (!_weakReference.TryGetTarget(out action))
            {
                return false;
            }
            await Task.Run(() => action?.Invoke(typedMessage));
            return true;
        }
    }

它與強訂閱的區別在於action存儲在“ WeakReference”字段中。 您可以在這里了解更多信息：WeakReference 類。 它用於表示類型化的弱引用，該弱引用引用一個對象，同時仍允許該對象被垃圾回收回收。 在使用它之前，我們需要使用TryGetTarget(T)方法檢查目標是否已由GC收集。 如果此方法返回false，則表示該引用已被GC收集。
如果使用StrongSubscription，Messenger將保留對回調方法的強引用，並且Garbage Collection將不會破壞訂閱。 在這種情況下，您需要明確取消訂閱，以避免內存泄漏。 否則，可以使用WeakSubscription，當對象超出范圍時，會自動刪除訂閱。

MessengerHub

MessengerHub是整個應用程序域中的一個單例實例。 我們不需要使用“依賴注入”來創建實例，因為它的目的是明確的，我們只有一個實例。 這是實現單例模式的簡單方法：

public class MessengerHub
{
        private static readonly Lazy<MessengerHub> lazy = new Lazy<MessengerHub>(() => new MessengerHub());
        private MessengerHub() { }
        public static MessengerHub Instance
        {
            get
            {
                return lazy.Value;
            }
        }
}

MessengerHub維護一個Dictionary來維護訂閱的實例，如下所示：

private readonly ConcurrentDictionary<Type, ConcurrentDictionary<Guid, BaseSubscription>> _subscriptions =
            new ConcurrentDictionary<Type, ConcurrentDictionary<Guid, BaseSubscription>>();

該Dictionary的Key是“Message”的類型，Value是一個Dictionary，其中包含該特定“Message”的一組訂閱。 顯然，一種類型可能具有多個訂閱。

訂閱

MessageHub公開了幾種重要的方法來訂閱/取消訂閱/發布消息。
Subscribe()方法如下所示：

        public SubscriptionToken Subscribe<TMessage>(Action<TMessage> action,
            ReferenceType referenceType = ReferenceType.Weak,
            SubscriptionPriority priority = SubscriptionPriority.Normal, string tag = null) where TMessage : Message
        {
            if (action == null)
            {
                throw new ArgumentNullException(nameof(action));
            }
            BaseSubscription subscription = BuildSubscription(action, referenceType, priority, tag);
            return SubscribeInternal(action, subscription);
        }

        private SubscriptionToken SubscribeInternal<TMessage>(Action<TMessage> action, BaseSubscription subscription)
            where TMessage : Message
        {
            if (!_subscriptions.TryGetValue(typeof(TMessage), out var messageSubscriptions))
            {
                messageSubscriptions = new ConcurrentDictionary<Guid, BaseSubscription>();
                _subscriptions[typeof(TMessage)] = messageSubscriptions;
            }
            messageSubscriptions[subscription.Id] = subscription;
            return new SubscriptionToken(subscription.Id, async () => await UnsubscribeInternal<TMessage>(subscription.Id), action);
        }

當我們訂閱消息時，我們創建Subscription的實例並將其添加到字典中。 根據您的選擇，它可能是強引用或者弱引用。 然后它將創建一個SubscriptionToken，這是一個實現IDisposable接口來管理訂閱的類：

    public sealed class SubscriptionToken : IDisposable
    {
        public Guid Id { get; private set; }
        private readonly Action _disposeMe;
        private readonly object _dependentObject;

        public SubscriptionToken(Guid id, Action disposeMe, object dependentObject)
        {
            Id = id;
            _disposeMe = disposeMe;
            _dependentObject = dependentObject;
        }

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        private void Dispose(bool isDisposing)
        {
            if (isDisposing)
            {
                _disposeMe();
            }
        }
    }

當我們創建SubscriptionToken的實例時，實際上我們傳遞了一個方法來銷毀自己-因此，當調用Dispose方法時，它將首先取消訂閱。

退訂

取消訂閱消息的方法如下所示：

        public async Task Unsubscribe<TMessage>(SubscriptionToken subscriptionToken) where TMessage : Message
        {
            await UnsubscribeInternal<TMessage>(subscriptionToken.Id);
        }
        private async Task UnsubscribeInternal<TMessage>(Guid subscriptionId) where TMessage : Message
        {
            if (_subscriptions.TryGetValue(typeof(TMessage), out var messageSubscriptions))
            {
                if (messageSubscriptions.ContainsKey(subscriptionId))
                {
                    var result = messageSubscriptions.TryRemove(subscriptionId, out BaseSubscription value);
                }
            }
        }

這很簡單。 當我們取消訂閱消息時，訂閱將從字典中刪除。

發布

好了，我們已經訂閱了該消息，並創建了存儲在字典中的訂閱實例。 我們現在可以發布消息。 發布消息的方法如下所示：

        public async Task Publish<TMessage>(TMessage message) where TMessage : Message
        {
            if (message == null)
            {
                throw new ArgumentNullException(nameof(message));
            }
            List<BaseSubscription> toPublish = null;
            Type messageType = message.GetType();

            if (_subscriptions.TryGetValue(messageType, out var messageSubscriptions))
            {
                toPublish = messageSubscriptions.Values.OrderByDescending(x => x.Priority).ToList();
            }

            if (toPublish == null || toPublish.Count == 0)
            {
                return;
            }

            List<Guid> deadSubscriptionIds = new List<Guid>();
            foreach (var subscription in toPublish)
            {
                // Execute the action for this message.
                var result = await subscription.Invoke(message);
                if (!result)
                {
                    deadSubscriptionIds.Add(subscription.Id);
                }
            }

            if (deadSubscriptionIds.Any())
            {
                await PurgeDeadSubscriptions(messageType, deadSubscriptionIds);
            }
        }  

當我們發布一條消息時，MessageHub將查詢字典以檢索該消息的訂閱，然后循環執行操作。
我們需要注意的另一件事是，由於某些訂閱可能是弱引用，因此我們需要檢查執行結果。 如果失敗，我們需要將其從訂閱中刪除。

用法

從NuGet安裝：

PM> Install-Package FunCoding.CoreMessenger

在整個應用程序域中，將“ MessengerHub.Instance”用作單例模式。它提供了以下方法：
-發布：

public async Task Publish<TMessage>(TMessage message)

-訂閱：

public SubscriptionToken Subscribe<TMessage>(Action<TMessage> action, ReferenceType referenceType = ReferenceType.Weak, SubscriptionPriority priority = SubscriptionPriority.Normal, string tag = null)

-取消訂閱：

public async Task Unsubscribe<TMessage>(SubscriptionToken subscriptionToken)

創建Message類

首先，定義不同組件之間從Message繼承的Message類，如下所示：

public class TestMessage : Message
{
    public string ExtraContent { get; private set; }
    public TestMessage(object sender, string content) : base(sender)
    {
        ExtraContent = content;
    }
}

然后在組件A中創建Message的實例，如下所示：

var message = new TestMessage(this, "Test Content");

訂閱

定義一個SubscriptionToken實例來存儲訂閱。在組件B中訂閱“消息”，如下所示：

public class HomeViewModel
    {
        private readonly SubscriptionToken _subscriptionTokenForTestMessage;
        public HomeViewModel()
        {
            _subscriptionTokenForTestMessage = 
                MessengerHub.Instance.Subscribe<TestMessage>(OnTestMessageReceived,
                ReferenceType.Weak, SubscriptionPriority.Normal);
        }

        private void OnTestMessageReceived(TestMessage message)
        {
#if DEBUG
            System.Diagnostics.Debug.WriteLine($"Received messages of type {message.GetType().ToString()}. Content: {message.Content}");
#endif
        }
    }

發布Message

在組件A中發布“消息”：

public async Task PublishMessage()
{
    await MessengerHub.Instance.Publish(new TestMessage(this, $"Hello World!"));
}

就是這么簡單。

參數

Subscribe方法的完整簽名為：

public SubscriptionToken Subscribe<TMessage>(Action<TMessage> action,
            ReferenceType referenceType = ReferenceType.Weak,
            SubscriptionPriority priority = SubscriptionPriority.Normal, string tag = null) where TMessage : Message

您可以指定以下參數：
-ReferenceType。默認值為“ ReferenceType.Weak”，因此您不必擔心內存泄漏。一旦SubscriptionToken實例超出范圍，GC便可以自動收集它（但不確定何時）。如果需要保留強引用，請將參數指定為ReferenceType.Strong，以使GC無法收集它。
-SubscriptionPriority。默認值為SubscriptionPriority.Normal。有時需要控制一個“消息”的訂閱的執行順序。在這種情況下，請為訂閱指定不同的優先級以控制執行順序。注意，該參數不適用於不同的Message。
-Tag。檢查訂閱的當前狀態，是可選的。

退訂

您可以使用以下方法取消訂閱：
-使用“Unsubscribe”方法，如下所示：

await MessengerHub.Instance.Unsubscribe<TestMessage>(_subscriptionTokenForTestMessage);

-使用SubscriptionToken的Dispose方法：

_subscriptionTokenForTestMessage.Dispose();

在許多情況下，您不會直接調用這些方法。如果使用強訂閱類型，則可能會導致內存泄漏問題。因此，建議使用“ ReferenceType.Weak”。請注意，如果令牌未存儲在上下文中，則GC可能會立即收集它。例如：

public void MayNotEverReceiveAMessage()
{
    var token = MessengerHub.Instance.Subscribe<TestMessage>((message) => {
        // Do something here
    });
    // token goes out of scope now
    // - so will be garbage collected *at some point*
    // - so the action may never get called
}

與MvvmCross.Messenger的差異

如果您使用MvvmCross開發應用程序，請直接使用MvvmCross.Messenger。我提取了一些主要方法並刪除了對“ MvvmCross”組件的依賴，因此它可以在沒有“ MvvmCross”的任何WPF，UWP和Xamarin項目中使用。另外，Publish方法始終在后台運行，以避免阻塞UI。但是您應該知道何時需要返回UI線程，尤其是當您需要與UI控件進行交互時。另一個區別是無需使用DI來創建MessageHub實例，該實例是所有應用程序域中的單例實例。如果解決方案包含需要相互通信的多個組件，則將很有用。 DI將使其更加復雜。

​