private void NetworkInformationOnNetworkStatusChanged(object sender)
        {
            ConnectionType = GetConnectionType();

            if(ConnectionChanged != null)
                ConnectionChanged();
        }

        public Instance(AppSettings settings, string instanceName, ConnectionType type)
        {
            //is this necessary to store?
            _connectionType = type;

            _settings = settings;

            if (!_settings.WorkingPath.Exists)
            {
                _settings.WorkingPath.Create();
            }

            if (!_settings.TransferPath.Exists)
            {
                _settings.TransferPath.Create();
            }

            Connection = new Connection(type, settings, instanceName);

            Connection.Service.Instance = this;

            Connection.LostConnection += new EventHandler<ExceptionEventArgs>(Connection_LostConnection);
            Connection.MessageReceived += new EventHandler<MessageEventArgs>(Connection_MessageReceived);
            Connection.MessageSending += new EventHandler<MessageEventArgs>(Connection_MessageSending);
            Connection.ConnectionMade += new EventHandler(Connection_ConnectionMade);
            Connection.ConnectionTermainated += new EventHandler(Connection_ConnectionTermainated);
        }

 public Connection(string source, string destination, ConnectionType type, string fbType)
 {
     Source = source;
     Destination = destination;
     Type = type;
     FBType = fbType;
 }

        static void ReadConfig()
        {
            if (!IsInitialized)
                throw new InvalidOperationException("AuthServer config not initialized.");

            AuthDBType          = config.Read("AuthDB.Type", ConnectionType.MySql);
            AuthDBHost          = config.Read("AuthDB.Host", "127.0.0.1");
            AuthDBPort          = config.Read("AuthDB.Port", 3306);
            AuthDBUser          = config.Read("AuthDB.User", "root");
            AuthDBPassword      = config.Read("AuthDB.Password", "");
            AuthDBDataBase      = config.Read("AuthDB.Database", "AuthDB");

            AuthDBMinPoolSize   = config.Read("AuthDB.MinPoolSize", 5);
            AuthDBMaxPoolSize   = config.Read("AuthDB.MaxPoolSize", 30);

            BindIP              = config.Read("Bind.IP", "0.0.0.0");
            BindPort            = config.Read("Bind.Port", 1119);

            RealmListUpdateTime = config.Read("RealmList.UpdateTime", 5) * 60000;

            PatchFileDirectory  = config.Read("Patch.File.Directory", "PatchFiles");

            WorldServiceHost = config.Read("WorldService.Host", "127.0.0.1");
            WorldServiceName = config.Read("WorldService.Name", "WorldService");
        }

        public void AddConnection(TermNode termNode, ConnectionType type)
        {
            if (this._connectedTerms == null)
                this._connectedTerms = new Dictionary<TermNode, ConnectionType>();

            this._connectedTerms.Add(termNode, type);
        }

        public Connector()
        {
            Type[] types = new Type[] { typeof(Connector), typeof(PuzzleElement),typeof(PageElement),
                typeof(GoalElement), typeof(MissionElement), typeof(ContextSoundElement), typeof(UG_Elements.UG_ContentItem),
                typeof(QuestionElement)};

            ConnectionType acceptedBottom = new ConnectionType(ThumbPosition.Bottom,
                                                            typeof(Connector),
                                                            ThumbPosition.Top,
                                                            types);

            ConnectionType acceptedRight = new ConnectionType(ThumbPosition.Right,
                                                            typeof(Connector),
                                                            ThumbPosition.Top,
                                                            types);

            ConnectionType acceptedLeft= new ConnectionType(ThumbPosition.Left,
                                                            typeof(Connector),
                                                            ThumbPosition.Top,
                                                            types);

            Connections.Add(ThumbPosition.Bottom,acceptedBottom);
            Connections.Add(ThumbPosition.Right, acceptedRight);
            Connections.Add(ThumbPosition.Left, acceptedLeft);
        }

 public ServerThread(string localAddress, int localPort, ConnectionType connectionType)
 {
     _LocalAddress = localAddress;
     _LocalPort = localPort;
     _ConnectionType = connectionType;
     _Paused = false;
 }

        internal ConnectorSettings(ConnectionType cType)
        {
            ConnectionType = cType;

            if (cType == ConnectionType.MYSQL)
            {
                if (!File.Exists(Environment.CurrentDirectory + "/MySql.Data.dll"))
                {
                    Console.WriteLine("MySql.Data.dll doesn't exist.");

                    return;
                }

                assembly = Assembly.LoadFile(Environment.CurrentDirectory + "/MySql.Data.dll");
                type = "MySql.Data.MySqlClient.MySql";
            }
            else if (cType == ConnectionType.MSSQL)
            {
                // System.Data, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
                #pragma warning disable 612 // For mono...
                #pragma warning disable 618 // Visual studio...
                assembly = Assembly.LoadWithPartialName("System.Data");
                #pragma warning restore 612
                #pragma warning restore 618

                type = "System.Data.SqlClient.Sql";
            }
        }

        public static List<MobileConnection> GetPhoneNumbers(int customerid,ConnectionType type)
        {
            List<MobileConnection> mobileConnectionList = new List<MobileConnection>();
            using (SqlConnection myConnection = new SqlConnection(ConfigurationManager.ConnectionStrings[Connection.ConnectionName].ConnectionString))
            {
                string sqlstmt = "select c.customerid, c.pnumber, c.schemeid \"schemeid\", s.ctype, s.provider from [dbo].[MobileConnection] c INNER JOIN [dbo].[MobileScheme] s ON c.schemeid = s.id where c.customerid = @customerid and s.ctype = @type";
                SqlCommand myCommand = new SqlCommand(sqlstmt, myConnection);
                myCommand.CommandType = CommandType.Text;
                myCommand.Parameters.AddWithValue("@customerid", customerid);
                myCommand.Parameters.AddWithValue("@type", type);

                myConnection.Open();
                using (SqlDataReader myReader = myCommand.ExecuteReader())
                {
                    while (myReader.Read())
                    {
                        MobileConnection mobileConnection = FillDataRecord(myReader);
                        mobileConnectionList.Add(mobileConnection);
                    }
                    myReader.Close();
                }
                myConnection.Close();
            }
            return mobileConnectionList;
        }

 public void SetConfig(ConnectionType conType, string host, int port, bool useSSL, string username, string password)
 {
     // Get new Worker by conType
     // For now only use IMAP
     createWorker(conType);
     _emailWorker.SetConfig(host, port, useSSL, username, password);
 }

 private string GenerateSettingKey(ConnectionType connectionType, DownloadContentType downloadContentType)
 {
     var res = "";
     switch (connectionType)
     {
         case ConnectionType.Mobile:
             res += "Mobile";
             break;
         case ConnectionType.Wlan:
             res += "Wlan";
             break;
         case ConnectionType.None:
             res += "None";
             break;
     }
     switch (downloadContentType)
     {
         case DownloadContentType.Any:
             res += "Any";
             break;
         case DownloadContentType.Article:
             res += "Article";
             break;
         case DownloadContentType.Feed:
             res += "Feed";
             break;
         case DownloadContentType.Image:
             res += "Image";
             break;
     }
     return res;
 }

 public DBHelper(ConnectionType conncetionType, DataBaseType DBMSType,string strDBFileNamePath)
 {
     DbConnectionType = conncetionType;
     dbType = DBMSType;
     S_DBFILENAME = strDBFileNamePath;
     oFactory = DbProviderFactories.GetFactory(RetreiveConnectionString());
 }

 public Connection(Point e1, Point e2, ConnectionType t, Figure so)
 {
     endpoint1 = e1;
     endpoint2 = e2;
     type = t;
     segmentOrArc = so;
 }

            public void Add(string key, Guid connectionId, ConnectionType connectionType)
            {
                lock (_connections)
                {
                    Connections connection;
                    if (!_connections.TryGetValue(key, out connection))
                    {
                        connection = new Connections();
                        if (connectionType == ConnectionType.Device)
                        {
                            connection.DeviceConnectionId = connectionId;
                        }
                        else
                        {
                            connection.UserConnectionId = connectionId;
                        }
                        _connections.Add(key, connection);
                    }

                    lock (connection)
                    {
                        if (connectionType == ConnectionType.Device)
                        {
                            connection.DeviceConnectionId = connectionId;
                        }
                        else
                        {
                            connection.UserConnectionId = connectionId;
                        }
                    }
                }
            }

        internal static List<string> GetListenerPrefixes(ConnectionType connection, string[] hosts, int[] ports)
        {
            List<string> prefixes = new List<string>();

            foreach (string ip in hosts)
            {
                //Go through each port on that IP
                foreach (int port in ports)
                {
                    //If only http, then add that suffix and continue
                    if (connection == ConnectionType.Http)
                    {
                        prefixes.Add("http://" + ip + ":" + port + "/");
                        continue;
                    }

                    //If only https, add that suffix and continue
                    if (connection == ConnectionType.Https)
                    {
                        prefixes.Add("https://" + ip + ":" + port + "/");
                        continue;
                    }

                    if (connection == ConnectionType.Both)
                    {
                        //Http and Https
                        prefixes.Add("http://" + ip + ":" + port + "/");
                        prefixes.Add("https://" + ip + ":" + port + "/");
                    }
                }
            }
            return prefixes;
        }

 public AddConnectionAction(uint page, uint sentence, string term, ConnectionType connectionType)
 {
     this.Page = page;
     this.Sentence = sentence;
     this.Term = term;
     this.ConnectionType = connectionType;
 }

        public ConnectionSet GetConnection(INode node, IRelationship relationship, ConnectionType connectionType)
        {
            if (Connections.ContainsKey(node))
            {
                if (Connections[node].ContainsKey(relationship))
                {
                    if (Connections[node][relationship].ContainsKey(connectionType))
                    {
                        return Connections[node][relationship][connectionType];
                    }
                }
                else
                {
                    Connections[node][relationship] = new Dictionary<ConnectionType, ConnectionSet>();
                }
            }
            else
            {
                Connections[node] = new Dictionary<IRelationship, Dictionary<ConnectionType, ConnectionSet>>();
                Connections[node][relationship] = new Dictionary<ConnectionType, ConnectionSet>();
            }

            ConnectionSet newConnectionSet = new ConnectionSet() { Node = node, Relationship = relationship, ConnectionType = connectionType };

            Connections[node][relationship][connectionType] = newConnectionSet;

            return newConnectionSet;
        }

    public void AttemptConnection( string ipAddressString, string portString )
    {
        debugLog.ReceiveMessage ( "\tAttempting Connection to " + ipAddressString + " on " + portString );

        connecting = true;
        connectionType = ConnectionType.Connecting;
        debugLog.ReceiveMessage ( "\tConnection Type Set to Connecting" );

        try
        {

            IPAddress ipAddress = Dns.GetHostEntry ( ipAddressString ).AddressList[0];
            IPEndPoint remoteEndPoint = new IPEndPoint ( ipAddress, Convert.ToInt32 ( portString ));

            Socket client = new Socket ( AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp );

            client.BeginConnect ( remoteEndPoint, new AsyncCallback ( ConnectCallback ), client );

            Send ( client, "This is a test<EOF>" );

            Receive ( client );

            UnityEngine.Debug.Log ( "Response received : " + response );

            client.Shutdown ( SocketShutdown.Both );
            client.Close ();
        } catch ( Exception connectionError )
        {

            UnityEngine.Debug.LogError ( connectionError );
        }
    }

 /**
  * @param t connection type
  * @param target the Address of the target node
  * @param token unique token used to associate all connection setup messages
  *              with each other
  */
 public ConnectToMessage(ConnectionType t, NodeInfo target, string token)
 {
   _ct = Connection.ConnectionTypeToString(t);
   _target_ni = target;
   _neighbors = new NodeInfo[0]; //Make sure this isn't null
   _token = token;
 }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="builder"></param>
        internal Connection(Server server, ConnectionBuilder builder)
        {
            _connectionType = builder.ConnectionType;
            _bufferSize = builder.BufferSize;

            Created = DateTime.UtcNow;
            Server = server;

            var socket = new TSocket(server.Host, server.Port, server.Timeout * 1000);

            switch (_connectionType)
            {
                case ConnectionType.Simple:
                    _transport = socket;
                    break;

                case ConnectionType.Buffered:
                    _transport = new TBufferedTransport(socket, _bufferSize);
                    break;

                case ConnectionType.Framed:
                    _transport = new TFramedTransport(socket);
                    break;
            }

            _protocol = new TBinaryProtocol(_transport);
            _client = new Cassandra.Client(_protocol);
        }