impsnetworkchange.cs

破解的飞信源代码

namespace Imps.Utils
{
    using Imps.Client.Base;
    using System;
    using System.Collections.Generic;
    using System.Net;
    using System.Net.NetworkInformation;
    using System.Runtime.CompilerServices;

    public class IMPSNetworkChange
    {
        private Dictionary<string, OperationalStatus> _adapterStatus = new Dictionary<string, OperationalStatus>();
        private static IMPSNetworkChange _instance = null;
        private static object _lock = new object();
        private volatile bool _networkError;

        public event NetworkAddressChangedEventHandler NetworkAddressChanged;

        public event NetworkAvailabilityChangedEventHandler NetworkAvailabilityChanged;

        public event EventHandler NetworkRestored;

        private IMPSNetworkChange()
        {
            this.InitEventHandler();
            this.InitAdatperStatus();
        }

        public NetworkInterface GetAdapterByIP(IPEndPoint ipEndPoint)
        {
            List<NetworkInterface> physicNetworkInterfaces = this.GetPhysicNetworkInterfaces();
            NetworkInterface interface2 = null;
            try
            {
                List<NetworkInterface>.Enumerator enumerator = physicNetworkInterfaces.GetEnumerator();
                try
                {
                    while (enumerator.MoveNext())
                    {
                        NetworkInterface interface3 = enumerator.get_Current();
                        using (IEnumerator<UnicastIPAddressInformation> enumerator2 = interface3.GetIPProperties().get_UnicastAddresses().GetEnumerator())
                        {
                            while (enumerator2.MoveNext())
                            {
                                if (enumerator2.get_Current().get_Address().ToString() == ipEndPoint.Address.ToString())
                                {
                                    interface2 = interface3;
                                    goto Label_006F;
                                }
                            }
                        }
                    Label_006F:
                        if (interface2 != null)
                        {
                            return interface2;
                        }
                    }
                    return interface2;
                }
                finally
                {
                    enumerator.Dispose();
                }
            }
            catch
            {
            }
            return interface2;
        }

        private List<NetworkInterface> GetPhysicNetworkInterfaces()
        {
            List<NetworkInterface> list = new List<NetworkInterface>();
            try
            {
                foreach (NetworkInterface interface2 in NetworkInterface.GetAllNetworkInterfaces())
                {
                    if ((interface2.get_NetworkInterfaceType() != 0x18) && (interface2.get_NetworkInterfaceType() != 1))
                    {
                        list.Add(interface2);
                    }
                }
            }
            catch
            {
            }
            return list;
        }

        private void InitAdatperStatus()
        {
            List<NetworkInterface> physicNetworkInterfaces = this.GetPhysicNetworkInterfaces();
            try
            {
                for (int i = 0; i < physicNetworkInterfaces.get_Count(); i++)
                {
                    this.TryAddAdapterStatus(physicNetworkInterfaces.get_Item(i).get_Id(), physicNetworkInterfaces.get_Item(i).get_OperationalStatus());
                }
            }
            catch (Exception)
            {
            }
        }

        private void InitEventHandler()
        {
            if (Environment.OSVersion.Version >= OS.Windows2000)
            {
                try
                {
                    NetworkChange.add_NetworkAddressChanged(new NetworkAddressChangedEventHandler(this, (IntPtr) this.NetworkChange_NetworkAddressChanged));
                    NetworkChange.add_NetworkAvailabilityChanged(new NetworkAvailabilityChangedEventHandler(this, (IntPtr) this.NetworkChange_NetworkAvailabilityChanged));
                }
                catch
                {
                }
            }
        }

        private void NetworkChange_NetworkAddressChanged(object sender, EventArgs e)
        {
            ConnectionFactory.Reset();
            List<NetworkInterface> physicNetworkInterfaces = this.GetPhysicNetworkInterfaces();
            bool flag = false;
            List<NetworkInterface>.Enumerator enumerator = physicNetworkInterfaces.GetEnumerator();
            try
            {
                while (enumerator.MoveNext())
                {
                    NetworkInterface interface2 = enumerator.get_Current();
                    if (interface2.get_OperationalStatus() == 1)
                    {
                        if (this._adapterStatus.ContainsKey(interface2.get_Id()))
                        {
                            if (this._adapterStatus.get_Item(interface2.get_Id()) != interface2.get_OperationalStatus())
                            {
                                this.NetworkError = false;
                                flag = true;
                            }
                            this._adapterStatus.set_Item(interface2.get_Id(), interface2.get_OperationalStatus());
                        }
                        else
                        {
                            if (interface2.get_OperationalStatus() == 1)
                            {
                                this.NetworkError = false;
                            }
                            this._adapterStatus.Add(interface2.get_Id(), interface2.get_OperationalStatus());
                            flag = true;
                        }
                    }
                    else
                    {
                        if (this._adapterStatus.ContainsKey(interface2.get_Id()))
                        {
                            if (this._adapterStatus.get_Item(interface2.get_Id()) != interface2.get_OperationalStatus())
                            {
                                flag = true;
                            }
                            this._adapterStatus.set_Item(interface2.get_Id(), interface2.get_OperationalStatus());
                        }
                        else
                        {
                            this._adapterStatus.Add(interface2.get_Id(), interface2.get_OperationalStatus());
                            flag = true;
                        }
                        this.NetworkError = true;
                    }
                }
            }
            finally
            {
                enumerator.Dispose();
            }
            string[] textArray = new string[this._adapterStatus.get_Keys().get_Count()];
            this._adapterStatus.get_Keys().CopyTo(textArray, 0);
            for (int i = 0; i < textArray.Length; i++)
            {
                bool flag2 = false;
                List<NetworkInterface>.Enumerator enumerator2 = physicNetworkInterfaces.GetEnumerator();
                try
                {
                    while (enumerator2.MoveNext())
                    {
                        NetworkInterface interface3 = enumerator2.get_Current();
                        if (textArray[i] == interface3.get_Id())
                        {
                            flag2 = true;
                            goto Label_019E;
                        }
                    }
                }
                finally
                {
                    enumerator2.Dispose();
                }
            Label_019E:
                if (!flag2)
                {
                    this._adapterStatus.set_Item(textArray[i], 2);
                    flag = true;
                    this.NetworkError = true;
                }
            }
            if (!flag && (this.NetworkRestored != null))
            {
                this.NetworkRestored(this, EventArgs.Empty);
            }
            if (this.NetworkAddressChanged != null)
            {
                this.NetworkAddressChanged.Invoke(sender, e);
            }
        }

        private void NetworkChange_NetworkAvailabilityChanged(object sender, NetworkAvailabilityEventArgs e)
        {
            if (!e.get_IsAvailable())
            {
                this.NetworkError = true;
            }
            else
            {
                this.NetworkError = false;
            }
            if (this.NetworkAvailabilityChanged != null)
            {
                this.NetworkAvailabilityChanged.Invoke(sender, e);
            }
        }

        private void TryAddAdapterStatus(string id, OperationalStatus status)
        {
            try
            {
                if (!this._adapterStatus.ContainsKey(id))
                {
                    lock (this)
                    {
                        if (!this._adapterStatus.ContainsKey(id))
                        {
                            this._adapterStatus.Add(id, status);
                        }
                    }
                }
            }
            catch (Exception)
            {
            }
        }

        public static IMPSNetworkChange Instance
        {
            get
            {
                if (_instance == null)
                {
                    lock (_lock)
                    {
                        if (_instance == null)
                        {
                            _instance = new IMPSNetworkChange();
                        }
                    }
                }
                return _instance;
            }
        }

        public bool NetworkError
        {
            get
            {
                lock (_lock)
                {
                    return this._networkError;
                }
            }
            internal set
            {
                lock (_lock)
                {
                    if (this._networkError != value)
                    {
                        if ((this._networkError && !value) && (this.NetworkRestored != null))
                        {
                            try
                            {
                                this.NetworkRestored(null, EventArgs.Empty);
                            }
                            catch
                            {
                            }
                        }
                        this._networkError = value;
                    }
                }
            }
        }
    }
}