public class NetworkStatus : INetworkStatus
    {
        public NetworkStatus(IDispatcher dispatcher)
        {
            _dispatcher = dispatcher;
            _references = new List<DelegateReference>();

            NetworkInformation.NetworkStatusChanged += OnNetworkAvailabilityChanged;
            InitializeConnection();
        }

        public void AddHandler(NetworkStatusHandler handler)
        {
            lock (_referencesLock)
            {
                _references.Add(new DelegateReference(handler, false));
                PruneOldReferences();
            }
        }

        private void CheckConnection()
        {
            bool connected = _connected;
            bool flag2;

            {
                flag2 = NetworkInformation.GetInternetConnectionProfile()?.GetNetworkConnectivityLevel() == NetworkConnectivityLevel.InternetAccess;
                _connected = flag2;
            }

            if (connected != flag2)
            {
                Notify(flag2);
            }
        }

        private void InitializeConnection()
        {
            CheckConnection();
        }

        public bool IsConnected()
        {
            return _connected;
        }

        private void Notify(bool connected)
        {
            lock (_references)
            {
                PruneOldReferences();
                using (List<DelegateReference>.Enumerator enumerator = _references.GetEnumerator())
                {
                    while (enumerator.MoveNext())
                    {
                        DelegateReference current = enumerator.Current;
                        NetworkStatusHandler target = current.Target as NetworkStatusHandler;
                        if (target != null)
                        {
                            _dispatcher.RunAsync(delegate
                            {
                                target(this, connected);
                            }, DispatcherPriority.Normal);
                        }
                    }
                }
            }
        }

        private void OnNetworkAvailabilityChanged(object o)
        {
            CheckConnection();
        }

        private void PruneOldReferences()
        {
            lock (_referencesLock)
            {
                _references.RemoveAll((DelegateReference d) => d.Target == null);
            }
        }

        public void RemoveHandler(NetworkStatusHandler handler)
        {
            lock (_referencesLock)
            {
                _references.RemoveAll((DelegateReference d) => d.Target as NetworkStatusHandler == handler);
                PruneOldReferences();
            }
        }

        public void ResetNetworkMap()
        {
            InitializeConnection();
        }

        private bool _connected;

        private readonly IDispatcher _dispatcher;

        private readonly List<DelegateReference> _references;

        private readonly object _referencesLock = new object();
    }