public void ExcuteSQLBulkCopy(DataTable Datatable, string TableName, ConnectionState connectionstate, ref bool executionSucceeded)
        {
            try
            {
                if (objConnection.State == System.Data.ConnectionState.Closed)
                {
                    objConnection.Open();
                }

                SqlBulkCopy.BatchSize = Datatable.Rows.Count;
                SqlBulkCopy.BulkCopyTimeout = 0;
                SqlBulkCopy.DestinationTableName = TableName;
                SqlBulkCopy.WriteToServer(Datatable);
                SqlBulkCopy.Close();
                executionSucceeded = true;
            }
            catch (Exception ex)
            {
                executionSucceeded = false;
                HandleExceptions(ex);
            }
            finally
            {
                //SqlBulkCopy.ColumnMappings.Clear();

                if (connectionstate == ConnectionState.CloseOnExit)
                {
                    if (objConnection.State == System.Data.ConnectionState.Open)
                    {
                        objConnection.Close();
                    }
                }
            }
        }

 private void OnStateChanged(ConnectionState newState)
 {
     if (_stateChanged != null)
     {
         _stateChanged(this, newState);
     }
 }

 private SerialConnection()
 {
     Devices = new ObservableCollection<DeviceInformation>();
     State = ConnectionState.Disconnected;
     Debugger = Debugger.Instance;
     LookForBluetoothDevices();
 }

        public override void Open()
        {
            if (State == ConnectionState.Open)
                throw new Exception("Connection is already open");

            _state = ConnectionState.Open;
        }

        public override void Close()
        {
            if (State == ConnectionState.Closed)
                throw new Exception("Connection is already closed");

            _state = ConnectionState.Closed;
        }

 private void connectionChanged(ConnectionInformation information, ConnectionState state)
 {
     if (state == ConnectionState.CLOSED)
     {
         CloseConnection(information);
     }
 }

 public void OnStateChanged(ConnectionState connectionState)
 {
     if (callback != null)
     {
         callback(connectionState);
     }
 }

        public bool Open()
        {
            if (m_State == ConnectionState.Disconnected)
            {
                int numUnits = m_PM3.DiscoverUnits();
                if (numUnits > 0)
                {
                    try
                    {
                        m_Port = 0;
                        m_State = ConnectionState.Connected;
                    }
                    catch (PM3Exception e)
                    {
                        Debug.WriteLine(string.Format("[Connection.Open] {0}", e.Message));
                    }
                }
            }
            else
            {
                Debug.WriteLine("[Connection.Open] Connection already open");
            }

            return IsOpen;
        }

        public void AcceptCallback(IAsyncResult result)
        {
            // Get the socket that handles the client request
            // listener represents the connection 'server' (that waits for clients to connect) and not the
            // individual client connections
            Socket listener = (Socket)result.AsyncState;
            Socket handler = listener.EndAccept(result);

            // Tell the main client thread we got one client so that it can keep waiting for others :)
            gAllDone.Set();

            // From now on this is a separate thread :) cool!
            // Lets keep the state of this thing shall we?
            ConnectionState state = new ConnectionState();
            state.mSocket = handler;

            // TODO: Implement version control here
            // Valid connections start with a 'YELLOW' to which we respond 'SUP'
            byte[] yellowShakeBuffer = new byte[16];
            int read = handler.Receive(yellowShakeBuffer);
            string yellowString = ServerApi.CONNECTION_ENCODING.GetString(yellowShakeBuffer, 0, read);
            if (yellowString.Equals("YELLOW"))
            {
                // Answer and start waiting for data baby!
                handler.Send(ServerApi.CONNECTION_ENCODING.GetBytes("SUP"));
                handler.BeginReceive(state.mBuffer, 0, ConnectionState.BufferSize, SocketFlags.Peek,
                                    new AsyncCallback(ReadCallback), state);
            }
            else
            {
                // Ooops, not a valid client!
                handler.Close();
            }
        }

 public bool SendCSAFECommand(uint[] cmdData, ushort cmdDataCount, uint[] rspData, ref ushort rspDataCount)
 {
     if (IsOpen)
     {
         try
         {
             m_PM3.SendCSAFECommand(m_Port, cmdData, cmdDataCount, rspData, ref rspDataCount);
             return true;
         }
         catch (WriteFailedException e)
         {
             m_State = ConnectionState.SendError;
             Debug.WriteLine(string.Format("[Connection.SendCSAFECommand] {0}", e.Message));
         }
         catch (ReadTimeoutException e)
         {
             m_State = ConnectionState.SendError;
             Debug.WriteLine(string.Format("[Connection.SendCSAFECommand] {0}", e.Message));
         }
         catch (DeviceClosedException e)
         {
             m_State = ConnectionState.Disconnected;
             Debug.WriteLine(string.Format("[Connection.SendCSAFECommand] {0}", e.Message));
         }
     }
     return false;
 }

        public override void Open()
        {
            m_StorageAccount = CloudStorageAccount.Parse(m_ConnectionString);
            m_State = ConnectionState.Open;

            // TODO (Matt Magurany 8/14/2012): Consider creating an HTTP request for batching here
        }

 /// <summary>Executes behavior.</summary>
 /// <param name="state">Connection state.</param>
 public void Handle(ConnectionState state)
 {
     if (state == ConnectionState.Connected)
         _viewModel.IsBusy = false;
     else
         ErrorManager.Error(state.ToString());
 }

        private async void OnMessageReceived(object sender, MessageReceivedEventArgs args)
        {
            if (OnData == null) return;

            var exceptionOccured = false;
            try
            {
                var text = args.Message;
                OnData(sender, new DataReceivedEventArgs { TextData = text });
            }
            catch (Exception)
            {
                exceptionOccured = true;
            }
            // cannot await in catch
            if (exceptionOccured)
            {
                _connectionState = ConnectionState.Failed;
                try
                {
                    await Reconnect();
                }
                catch (Exception e)
                {
                    Error(e);
                }
            }
        }

        protected async Task BeginConnect(CancellationToken parentCancelToken)
        {
            try
            {
                using (await _lock.LockAsync().ConfigureAwait(false))
                {
                    _parentCancelToken = parentCancelToken;

                    await _taskManager.Stop().ConfigureAwait(false);
                    _taskManager.ClearException();
                    State = ConnectionState.Connecting;

                    _cancelSource = new CancellationTokenSource();
                    CancelToken = CancellationTokenSource.CreateLinkedTokenSource(_cancelSource.Token, parentCancelToken).Token;
                    _lastHeartbeat = DateTime.UtcNow;

                    await _engine.Connect(Host, CancelToken).ConfigureAwait(false);
                    await Run().ConfigureAwait(false);
                }
            }
            catch (Exception ex)
            {
                //TODO: Should this be inside the lock?
                await _taskManager.SignalError(ex).ConfigureAwait(false);
                throw;
            }
        }

        public CiiClient()
        {
            logger = Logger.Instance;
            StatusCallbacks = new Dictionary<uint, ReceiveStatusHandler>();
            statusCallbacksLock = new object();

            loginAcceptEvent = new AutoResetEvent(false);
            messagesInFlight = new CiiMessagesInFlight();
            connectionState = ConnectionState.NotConnected;

            //
            //  Prebuild the Communications arrays
            //
            MessageTypeGet = BitConverter.GetBytes((uint)CiiMessageType.MtGetCommand);
            MessageTypeAction = BitConverter.GetBytes((uint)CiiMessageType.MtActionCommand);
            BytesLogin = BitConverter.GetBytes((uint)CiiMessageType.MtLogin);

            asyncErrorEvent = new AutoResetEvent(false);
            asyncErrors = new Queue<string>();
            asyncErrorsLock = new object();
            asyncErrorThread = new Thread(AsyncErrorThread);
            asyncErrorThread.IsBackground = true;
            asyncErrorThread.Priority = ThreadPriority.AboveNormal;
            asyncErrorThread.Name = "AsyncErrorThread";
            asyncErrorThread.Start();
        }

        public AudioClient(DiscordClient client, Server server, int id)
		{
            Id = id;
            _config = client.Config;
            Service = client.Services.Get<AudioService>();
            Config = Service.Config;
            Serializer = client.Serializer;
            _gatewayState = (int)ConnectionState.Disconnected;

            //Logging
            Logger = client.Log.CreateLogger($"AudioClient #{id}");

            //Async
            _taskManager = new TaskManager(Cleanup, false);
            _connectionLock = new AsyncLock();
            CancelToken = new CancellationToken(true);

            //Networking
            if (Config.EnableMultiserver)
            {
                ClientAPI = new JsonRestClient(_config, DiscordConfig.ClientAPIUrl, client.Log.CreateLogger($"ClientAPI #{id}"));
                GatewaySocket = new GatewaySocket(_config, client.Serializer, client.Log.CreateLogger($"Gateway #{id}"));
                GatewaySocket.Connected += (s, e) =>
                {
                    if (_gatewayState == ConnectionState.Connecting)
                        EndGatewayConnect();
                };
            }
            else
                GatewaySocket = client.GatewaySocket;
            GatewaySocket.ReceivedDispatch += (s, e) => OnReceivedEvent(e);
            VoiceSocket = new VoiceSocket(_config, Config, client.Serializer, client.Log.CreateLogger($"Voice #{id}"));
            VoiceSocket.Server = server;
            OutputStream = new OutStream(this);
        }

        private static Uri uri = new Uri("net.tcp://localhost:57000"); // объектное представление универсального кода ресурсов (URI)

        #endregion Fields

        #region Constructors

        /// <summary>
        /// Инициализирует новый экземпляр класса
        /// </summary>
        private DevManClient()
        {
            devContext = new DevManClientContext();
            devContext.onUpdate += new EventHandler(devContext_onUpdate);

            connectionState = ConnectionState.Default;
        }

 public CqlConnection()
 {
     _ConnectionState = ConnectionState.Closed;
     _Config = new CqlConnectionConfiguration();
     _CurrentKeyspace = "";
     _ActualConnection = null;
 }

        public void ConnectTo(string hostName, ushort port = 80)
        {
            // Disconnect from any existing connection
            Disconnect();

            // Get the IP address from the host name string
            IPAddress[] addresses = Dns.GetHostAddresses(hostName);
            if( addresses.Length > 0 )
            {
                try
                {
                    mSocket.Connect(addresses[0], port);
                    mState = ConnectionState.Connecting;
                }
                catch( SocketException ex )
                {
                    if (ex.ErrorCode == 10035)
                    {
                        // Would Block
                        mState = ConnectionState.Connecting;
                    }
                    else
                        Console.WriteLine(ex.Message);
                }
            }
        }

		private void connectionChanged(ConnectionInformation information, ConnectionState state)
		{
			if (state == ConnectionState.closed)
			{
				this.CloseConnection(information);
			}
		}