private void EmIO_Manager_InSync(object sender, bool state)
        {
            EmIO_InSync?.Invoke(sender, state);

            if (SocketIO_Client == null)
            {
                return;
            }

            if (state)
            {
                List <byte> toSend = new List <byte>();

                if (WaitingForInputUpdate)
                {
                    for (int i = 1; i <= EmIO_Manager.ActiveSets.Count(); i++)
                    {
                        toSend.AddRange(EmIO_Manager.ActiveSets[i.ToString()].Inputs);
                    }

                    SocketIO_Client.Write(new SocketIOArgs(toSend).GetSocketCommandString(2));

                    WaitingForInputUpdate = false;

                    return;
                }

                if (WaitingForOutputUpdate)
                {
                    for (int i = 1; i <= EmIO_Manager.ActiveSets.Count(); i++)
                    {
                        toSend.AddRange(EmIO_Manager.ActiveSets[i.ToString()].Outputs);
                    }

                    SocketIO_Client.Write(new SocketIOArgs(toSend).GetSocketCommandString(11));

                    WaitingForOutputUpdate = false;

                    return;
                }
            }
        }
        private void ConnectionCleanup()
        {
            if (Connection != null)
            {
                Connection.ConnectState   -= Connection_ConnectState;
                Connection.QueueJobUpdate -= Connection_QueueUpdate;
            }

            if (EmRobots_Manager != null)
            {
                EmRobots_Manager.InSync -= EmRobots_Manager_InSync;
                EmRobots_Manager.Stop();
                EmRobots_Manager = null;
            }
            this.Queue(false, new Action(() => EmRobots_InSync?.Invoke(this, false)));

            if (EmIO_Manager != null)
            {
                EmIO_Manager.InSync -= EmIO_Manager_InSync;
                EmIO_Manager.Stop();

                EmIO_Manager = null;
            }
            this.Queue(false, new Action(() => EmIO_InSync?.Invoke(this, false)));

            if (EmQueue_Manager != null)
            {
                EmQueue_Manager.InSync -= EmQueue_Manager_InSync;
                EmQueue_Manager.Stop();

                EmQueue_Manager = null;
            }
            this.Queue(false, new Action(() => EmQueue_InSync?.Invoke(this, false)));

            Connection?.Close();
            Connection?.Dispose();
            Connection = null;
        }