public ConnectionItem(ConnectionManager connectionManager)
            {
                ArgumentVerifier.CheckObjectArgument(connectionManager, "connectionManager");

                this.name = connectionManager.Name;
                this.connectionManager = connectionManager;
            }

 private void newConnectionRequest(ConnectionManager.ConnectionInformation connection)
 {
     ConnectionHandeler handeler = new ConnectionHandeler(connection);
     handeler.Disconnection += serverDisconnected;
     AddConnection(handeler);
     handeler.Start();
 }

        public void Initialize(ConnectionManager connectionManager, IServiceProvider serviceProvider)
        {
            this._connectionManager = connectionManager;
            this._serviceProvider = serviceProvider;

            ConfigureControlsFromConnectionManager();
        }

 /// <summary>
 /// Create an instance of <see cref="IBatcher"/> according to the configuration 
 /// and the capabilities of the driver
 /// </summary>
 /// <remarks>
 /// By default, .Net doesn't have any batching capabilities, drivers that does have
 /// batching support need to override this method and return their own batcher.
 /// </remarks>
 public override IBatcher CreateBatcher(ConnectionManager connectionManager)
 {
     if (connectionManager.Factory.IsBatchUpdateEnabled)
         return new OracleDataClientBatchingBatcher(connectionManager);
     else
         return new NonBatchingBatcher(connectionManager);
 }

 public ConnectionRun(RunData runData)
     : base(runData)
 {
     var connectionManager = new ConnectionManager(Resolver);
     _context = connectionManager.GetConnectionContext<StressConnection>();
     _transportConnection = (ITransportConnection)_context.Connection;
 }

        /// <summary>
        /// Constructor. Inicializa instancias de la clase ConnectionManagerTester
        /// </summary>
        public ConnectionManagerTester()
        {
            /*
             * Primero se crea el CommandManager. Este gestiona los comandos de
             * sistema como alive, busy, ready, etc. Ahorra trabajo.
             * Adicionalmente se suscriben los eventos (apuntador a funcion)
             * para manejar las notificaciones de la clase
            */
            commandManager = new CommandManager();
            commandManager.Started += new CommandManagerStatusChangedEventHandler(commandManager_Started);
            commandManager.Stopped += new CommandManagerStatusChangedEventHandler(commandManager_Stopped);
            commandManager.CommandReceived += new CommandReceivedEventHandler(commandManager_CommandReceived);
            commandManager.ResponseReceived += new ResponseReceivedEventHandler(commandManager_ResponseReceived);

            /*
             * Ahora se inicializa el ConnectionManager. Bajo el esquema actual
             * todas las aplicaciones son servidores y es el blackboard el que
             * se conecta a ellas (asi solo es necesario configurar una
             * aplicacion). Se le indica nombre del modulo, puerto de conexion
             * y el gestor de comandos. El modulo y puerto deben ser
             * configurados en el blackboard
            */
            connectionManager = new ConnectionManager("TESTER", 2000, 2000, IPAddress.Loopback, commandManager);
            connectionManager.Started += new ConnectionManagerStatusChangedEventHandler(connectionManager_Started);
            connectionManager.Stopped += new ConnectionManagerStatusChangedEventHandler(connectionManager_Stopped);
            connectionManager.ClientDisconnected += new TcpClientDisconnectedEventHandler(connectionManager_ClientDisconnected);
            connectionManager.ClientConnected += new TcpClientConnectedEventHandler(connectionManager_ClientConnected);

            // Configuro el reloj
            sw = new System.Diagnostics.Stopwatch();
        }

        public SQLServerWrapper(ConnectionManager cm, object txn)
        {
            this.cm = cm;
            this.txn = txn;

            this.StartSession();
        }

        public RouterActor(bool useDefault = true)
        {
            ConnectionMode connectionMode = ConnectionMode.ConnectionModeRemoteConnectionless;
            IConnectionManager connectionManager = new ConnectionManager();
            FalconConnection falconConnection = default(FalconConnection);
                            if (useDefault)
                                falconConnection = connectionManager.GetDefaultConnection();
                            else
                                falconConnection = connectionManager.GetConnection("", 1);

            _connection = ConnectionObjectFactory.CreateUnlicensedConnectionObject(null);
            _auto = new AutoDisposeConnectionObject(_connection);
            _connection.Mode = connectionMode;

            if (falconConnection.guidEdi == Guid.Empty)
                throw new Exception("Operation was aborted");
                        DeviceOpenError err = _connection.Open2("{" + falconConnection.guidEdi.ToString() + "}",
                                    falconConnection.Parameters);
            if (err != DeviceOpenError.DeviceOpenErrorNoError)
            {
                throw new InvalidOperationException(string.Format("Could not open connection: {0}", err.ToString()));
            }

            beginConfirmedGroupDataChannel();
        }

        private static async Task RunClientAsync(Uri address, CancellationToken token)
        {
            ClientEventSource eventSource = ClientEventSource.Instance;

            NetNamedPipeBinding binding = new NetNamedPipeBinding(NetNamedPipeSecurityMode.None);
            binding.OpenTimeout = TimeSpan.FromSeconds(1.0d);
            binding.SendTimeout = TimeSpan.FromSeconds(1.0d);
            binding.ReceiveTimeout = TimeSpan.FromSeconds(1.0d);
            binding.CloseTimeout = TimeSpan.FromSeconds(1.0d);

            CalculatorChannelFactory factory = new CalculatorChannelFactory(binding, new EndpointAddress(address), eventSource);
            await factory.OpenAsync();

            ConnectionManager<ICalculatorClientAsync> connectionManager = new ConnectionManager<ICalculatorClientAsync>(factory);

            using (ProxyInvoker<ICalculatorClientAsync> proxy = new ProxyInvoker<ICalculatorClientAsync>(connectionManager))
            {
                Random random = new Random();

                while (!token.IsCancellationRequested)
                {
                    try
                    {
                        await proxy.InvokeAsync(c => InvokeRandomAsync(random, c));
                    }
                    catch (Exception)
                    {
                    }

                    await Task.Delay(TimeSpan.FromMilliseconds(250.0d));
                }
            }

            await factory.CloseAsync();
        }

    public void connect(string args)
    {
        string[] javascriptArgs = JsonHelper.Deserialize<string[]>(args);
        string macAddress = javascriptArgs[0];
        connectionCallbackId = javascriptArgs[1];

        connectionManager = new ConnectionManager();
        connectionManager.Initialize(); // TODO can't we put this in the constructor?
        connectionManager.ByteReceived += connectionManager_ByteReceived;

        connectionManager.ConnectionSuccess += connectionManager_ConnectionSuccess;
        connectionManager.ConnectionFailure += connectionManager_ConnectionFailure;

        try
        {
            HostName deviceHostName = new HostName(macAddress);
            connectionManager.Connect(deviceHostName);
        }
        catch (Exception ex)
        {
            Debug.WriteLine(ex);
            connectionManager_ConnectionFailure("Invalid Hostname");
        }

    }

        public ContactRepository(ConnectionManager connectionManager)
        {
            connMgr = connectionManager;

            //Create the Contact table if it doesn't exist
            connMgr.Database.CreateEntityTable<Contact>();
        }

        public override IDTSComponentMetaData100 AddDestAdapter(IDTSPipeline100 pipeline, ConnectionManager destConnMgr, out IDTSDesigntimeComponent100 destDesignTimeComp)
        {
            if (String.IsNullOrEmpty(quotedTableName))
            {
                throw new ArgumentException("Destination table name is empty");
            }
            IDTSComponentMetaData100 destComp = pipeline.ComponentMetaDataCollection.New();
            destComp.ComponentClassID = OLEDB_DEST_GUID;
            destComp.ValidateExternalMetadata = true;
            destDesignTimeComp = destComp.Instantiate();
            destDesignTimeComp.ProvideComponentProperties();
            destComp.Name = "OleDB Destination - Sql Server";
            destDesignTimeComp.SetComponentProperty("AccessMode", 0);
            destDesignTimeComp.SetComponentProperty("OpenRowset", quotedTableName);

            // set connection
            destComp.RuntimeConnectionCollection[0].ConnectionManager = DtsConvert.GetExtendedInterface(destConnMgr);
            destComp.RuntimeConnectionCollection[0].ConnectionManagerID = destConnMgr.ID;

            // get metadata
            destDesignTimeComp.AcquireConnections(null);
            destDesignTimeComp.ReinitializeMetaData();
            destDesignTimeComp.ReleaseConnections();

            extCols = destComp.InputCollection[0].ExternalMetadataColumnCollection;

            return destComp;
        }

        public WinSCPWrapper(ConnectionManager cm, object txn)
        {
            this.cm = cm;
            this.txn = txn;

            this.StartSession();
        }

        internal static void SetupListener(int Port)
        {
            SessionManagement.Init();
			manager = new ConnectionManager(Port, 5, new HeartbeatParser(), false);

			manager.connectionEvent += manager_connectionEvent;
        }

        void IDtsConnectionManagerUI.Initialize(ConnectionManager connectionManager, IServiceProvider serviceProvider)
        {
            Debug.Assert((connectionManager != null) && (serviceProvider != null));

            this._serviceProvider = serviceProvider;
            this._connectionManager = connectionManager;
        }

 public AppManager(ConnectionManager connectionManager, 
     IDeviceInfo deviceInfo,
     AccountManager accountManager) : base(connectionManager)
 {
     _deviceInfo = deviceInfo;
     _accountManager = accountManager;
 }

        // Setup function
        public void Setup()
        {
            _transport = new SerialTransport {CurrentSerialSettings = {DtrEnable = false}};
            // some boards (e.g. Sparkfun Pro Micro) DtrEnable may need to be true.                        
            // We do not need to set serial port and baud rate: it will be found by the connection manager                                                           

            // Initialize the command messenger with the Serial Port transport layer
            // Set if it is communicating with a 16- or 32-bit Arduino board
            _cmdMessenger = new CmdMessenger(_transport, BoardType.Bit16)
            {
                PrintLfCr = false // Do not print newLine at end of command, to reduce data being sent
            };

            // The Connection manager is capable or storing connection settings, in order to reconnect more quickly  
            // the next time the application is run. You can determine yourself where and how to store the settings
            // by supplying a class, that implements ISerialConnectionStorer. For convenience, CmdMessenger provides
            //  simple binary file storage functionality
            var serialConnectionStorer = new SerialConnectionStorer("SerialConnectionManagerSettings.cfg");

            // We don't need to provide a handler for the Identify command - this is a job for Connection Manager.
            _connectionManager = new SerialConnectionManager(
                _transport as SerialTransport, 
                _cmdMessenger,
                (int) Command.Identify, 
                CommunicationIdentifier,
                serialConnectionStorer)
            {
                // Enable watchdog functionality.
                WatchdogEnabled = true,

                // Instead of scanning for the connected port, you can disable scanning and only try the port set in CurrentSerialSettings
                //DeviceScanEnabled = false
            };

            // Show all connection progress on command line             
            _connectionManager.Progress += (sender, eventArgs) =>
            {
                // If you want to reduce verbosity, you can only show events of level <=2 or ==1
                if (eventArgs.Level <= 3) Console.WriteLine(eventArgs.Description);
            };

            // If connection found, tell the arduino to turn the (internal) led on
            _connectionManager.ConnectionFound += (sender, eventArgs) =>
            {
                // Create command
                var command = new SendCommand((int)Command.TurnLedOn);
                // Send command
                _cmdMessenger.SendCommand(command);
            };

            //You can also do something when the connection is lost
            _connectionManager.ConnectionTimeout += (sender, eventArgs) =>
            {
                //Do something
            };

            // Finally - activate connection manager
            _connectionManager.StartConnectionManager();
        }

 public void ShouldLeaveOpenConnectionOpen()
 {
     DbConnection connection = Substitute.For<DbConnection>();
     connection.State.Returns(ConnectionState.Open);
     ConnectionManager manager = new ConnectionManager(connection);
     manager.Dispose();
     connection.Received(0).Close();
 }

        public ConnectionHandeling(int port, int maxConnections, int connectionsPerIP, bool enabeNagles)
        {
			this.liveConnections = new Hashtable(maxConnections);
			this.manager = new ConnectionManager(port, maxConnections, new InitialPacketParser(), !enabeNagles);
			//this.manager = new SocketManager();
			//int portID, int maxConnections, int connectionsPerIP, IDataParser parser, bool disableNaglesAlgorithm)
			//this.manager.init(port, maxConnections, connectionsPerIP, new InitialPacketParser(), !enabeNagles);
        }

 internal BuildManager(GlobalManager globalManager)
 {
     _globalManager = globalManager;
     _connectionManager = new ConnectionManager(globalManager);
     _colorManager = new ColorManager(globalManager);
     _sizeManager = new SizeManager(globalManager);
     _jsonTreeManager = new JsonTreeManager(globalManager);
 }