Xamarin.Forms中是否存在多个依赖项实例？

我已经从XLabs镜像了一些代码，以便在我的设备上获取网络状态跟踪：

我已经将它与这里的编码标准保持一致，并更改了一些方法名称——一切都很正常，除了android实现中的某些原因，我无法让我的事件处理程序响应，就像在iOS上一样

这是我对Android的改编：

[assembly: Dependency(typeof(STM.Droid.DependencyInjection.Network))]
[assembly: UsesPermission("android.permission.ACCESS_NETWORK_STATE")]
[assembly: UsesPermission("android.permission.ACCESS_WIFI_STATE")]
[assembly: UsesPermission("android.permission.CHANGE_NETWORK_STATE")]
[assembly: UsesPermission("android.permission.CHANGE_WIFI_STATE")]
namespace Namespace.Droid
{
    [BroadcastReceiver(Enabled = true)]
    [IntentFilter(new [] { Android.Net.ConnectivityManager.ConnectivityAction })]
    public class Network : BroadcastReceiver, INetwork
    {
        /// <summary>
        /// Internets the connection status.
        /// </summary>
        /// <returns>NetworkStatus.</returns>
        public NetworkStatus GetConnectionStatus()
        {
            var status = NetworkStatus.NotReachable;

            using (var cm = (ConnectivityManager)Application.Context.GetSystemService(Context.ConnectivityService))
            using (var ni = cm.ActiveNetworkInfo)
            {
                if (ni != null && ni.IsConnectedOrConnecting)
                {
                    var name = ni.TypeName.ToUpper();
                    if (name.Contains("WIFI"))
                    {
                        status = NetworkStatus.ReachableViaWiFiNetwork;
                    }
                    else if (name.Contains("MOBILE"))
                    {
                        status = NetworkStatus.ReachableViaCarrierDataNetwork;
                    }
                    else
                    {
                        status = NetworkStatus.ReachableViaUnknownNetwork;
                    }
                }
            }

            return status;
        }

        private readonly object lockObject = new object();
        private EventHandler<NetworkStatus> _reachabilityChanged;
        public event EventHandler<NetworkStatus> ReachabilityChanged
        {
            add
            {
                lock (this.lockObject)
                {
                    this._reachabilityChanged += value;
                }
            }

            remove
            {
                lock (this.lockObject)
                {
                    this._reachabilityChanged -= value;
                }
            }
        }

        /// <summary>
        /// Occurs when [reachability changed].
        /// </summary>
//      public event EventHandler<NetworkStatus> ReachabilityChanged;

        /// <summary>
        /// Determines whether the specified host is reachable.
        /// </summary>
        /// <param name="host">The host.</param>
        /// <param name="timeout">The timeout.</param>
        public Task<bool> IsReachableAsync(string host, TimeSpan timeout)
        {
            return Task.Run(
                () =>
                {
                    try
                    {
                        var address = InetAddress.GetByName(host);

                        return address != null; // && (address.IsReachable((int)timeout.TotalMilliseconds) || );
                    }
                    catch (UnknownHostException)
                    {
                        return false;
                    }
                });
        }

        /// <summary>
        /// Determines whether [is reachable by wifi] [the specified host].
        /// </summary>
        /// <param name="host">The host.</param>
        /// <param name="timeout">The timeout.</param>
        public async Task<bool> IsReachableByWifiAsync(string host, TimeSpan timeout)
        {
            return GetConnectionStatus() == NetworkStatus.ReachableViaWiFiNetwork && await IsReachableAsync(host, timeout);
        }

        /// <summary>
        /// This gets called by OS when the <see cref="ConnectivityManager.ConnectivityAction"/> <see cref="Intent"/> fires.
        /// </summary>
        /// <param name="context">Context for the intent.</param>
        /// <param name="intent">Intent information.</param>
        public override void OnReceive(Context context, Intent intent)
        {
            // this is a workaround - which oddly enough forwards events the way i would expect it to.
            MessagingCenter.Send(this as INetwork, string.Empty, GetConnectionStatus());

            // THIS IS ALWAYS NULL!
            var handler = _reachabilityChanged;
            if (handler != null)
            {
                var connectionStatus = this.GetConnectionStatus();
                handler(this, connectionStatus);
            }
        }
    }
}

[程序集：依赖项（typeof（STM.Droid.DependencyInjection.Network））]
[程序集：UsesPermission（“android.permission.ACCESS\u NETWORK\u STATE”）]
[程序集：UsesPermission（“android.permission.ACCESS\u WIFI\u STATE”）]
[程序集：UsesPermission（“android.permission.CHANGE\u NETWORK\u STATE”）]
[程序集：UsesPermission（“android.permission.CHANGE\u WIFI\u STATE”）]
名称空间.Droid
{
[广播接收器（已启用=真）]
[IntentFilter（新[]{Android.Net.ConnectivityManager.ConnectivityAction}]
公共类网络：BroadcastReceiver，INetwork
{
/// 
///Internet连接状态。
/// 
///网络状态。
公用网络状态GetConnectionStatus（）
{
var status=NetworkStatus.NotReachable；
使用（var cm=（ConnectivityManager）Application.Context.GetSystemService（Context.ConnectivityService））
使用（var ni=cm.ActiveNetworkInfo）
{
如果（ni！=null&&ni.IsConnectedOrConnecting）
{
var name=ni.TypeName.ToUpper（）；
如果（名称包含（“WIFI”））
{
状态=网络状态。可通过WifineTwork访问；
}
else if（name.Contains（“移动”））
{
状态=NetworkStatus.ReachableViaCarrierDataNetwork；
}
其他的
{
状态=网络状态。通过未知网络可访问；
}
}
}
返回状态；
}
私有只读对象lockObject=新对象（）；
私有事件处理程序\u可达性已更改；
公共事件事件处理程序可访问性已更改
{
添加
{
lock（this.lockObject）
{
此._reachabilityChanged+=值；
}
}
去除
{
lock（this.lockObject）
{
此.\u可达性更改-=值；
}
}
}
/// 
///在[可达性更改]时发生。
/// 
//公共事件事件处理程序可访问性已更改；
/// 
///确定指定的主机是否可访问。
/// 
///主持人。
///超时。
公共任务IsReachableAsync（字符串主机，TimeSpan超时）
{
返回任务。运行(
() =>
{
尝试
{
var address=InetAddress.GetByName（主机）；
返回地址！=null；//&（address.IsReachable（（int）timeout.total毫秒）| |）；
}
捕获（未知后异常）
{
返回false；
}
});
}
/// 
///确定[是否可通过wifi访问][指定的主机]。
/// 
///主持人。
///超时。
公共异步任务IsReachableByWifiAsync（字符串主机，TimeSpan超时）
{
return GetConnectionStatus（）==NetworkStatus.reachable通过WifineTwork&&wait isreachable异步（主机，超时）；
}
/// 
///当操作系统触发时，它会被调用。
/// 
///意图的上下文。
///意图信息。
公共覆盖void OnReceive（上下文、意图）
{
//这是一个变通办法——奇怪的是，它以我预期的方式将事件向前推进。
MessagingCenter.Send（作为INetwork，string.Empty，GetConnectionStatus（））发送；
//这总是空的！
var handler=_reachabilityChanged；
if（处理程序！=null）
{
var connectionStatus=this.GetConnectionStatus（）；
处理程序（此，连接状态）；
}
}
}
}

问题中的错误发生在OnReceive中

在调试过程中，我注意到处理程序正确地连接到了PCL端——奇怪的是，在_reachabilityChanged字段上只会有null

正如调试表明的那样，我显然正在

{md50e2cce2f1202796e628729fe0540389b。Network@b422684}

关于“this”的droid OnReceive方法

在PCL方面，我得到了

{md50e2cce2f1202796e628729fe0540389b。Network@b562641}

调用DependencyService.Get时

在我看来，处理程序列表为空的原因似乎是因为我在另一个实例上订阅了我的处理程序，因此当网络的另一个实例调用OnReceive时，不会获得任何处理程序

Xamarin.Forms DependencyService是否可以提供一个实例的两个或多个实例？因为那会让我大吃一惊

更新：

如果有人需要解决方法，这也可以：

public event EventHandler<NetworkStatus> ReachabilityChanged
        {
            add { MessagingCenter.Subscribe(value.Target, string.Empty, (INetwork d, NetworkStatus a) => value(d, a)); }
            remove { MessagingCenter.Unsubscribe<INetwork>(value.Target, string.Empty); }
        }

公共事件事件处理程序可访问性已更改
{
添加{MessagingCenter.Subscribe（value.Target，string.Empty，（INetwork d，NetworkStatus a）=>value（d，a））；}
删除{MessagingCenter.Unsubscribe（value.Target，string.Empty）；}
}

用于新实例

\u client=DependencyService.Get（DependencyFetchTarget.NewInstance）
默认情况下，
DependencyService
为保留