public void SetState(ClientState state)
 {
     _cstate = state;
     switch (state)
     {
         case ClientState.kCLIENT_STATE_LOGINSERVER_CONNECT_IN_PROGRESS:
             _state = "kCLIENT_STATE_LOGINSERVER_CONNECT_IN_PROGRESS";
             break;
         case ClientState.kCLIENT_STATE_LOGINSERVER_CONNECT_COMPLETE:
             _state = "kCLIENT_STATE_LOGINSERVER_CONNECT_COMPLETE";
             break;
         case ClientState.kCLIENT_STATE_LOGIN_IN_PROGRESS:
             _state = "kCLIENT_STATE_LOGIN_IN_PROGRESS";
             break;
         case ClientState.kCLIENT_STATE_LOGIN_SUCCESS:
             _state = "kCLIENT_STATE_LOGIN_SUCCESS";
             break;
         case ClientState.kCLIENT_STATE_CHARACTER_LIST_RECEIVED:
             _state = "kCLIENT_STATE_CHARACTER_LIST_RECEIVED";
             break;
         case ClientState.kCLIENT_STATE_WORLD_LIST_RECEIVED:
             _state = "kCLIENT_STATE_WORLD_LIST_RECEIVED";
             break;
     }
 }

    private void cancelJoining()
    {
        Debug.Log("Cancel joining");

        clientState=ClientState.ClientSearch;
        Network.Disconnect();
    }

 void _presentationClient_OnChanged(object sender, ClientState e)
 {
     if (OnChanged != null)
     {
         OnChanged.Invoke(sender, e);
     }
 }

 public ReadFileService(ClientState clientState, string semantics, int fileRegisterId)
     : base(clientState)
 {
     FileRegisterId = fileRegisterId;
     Semantics = semantics;
     ReadedFile = null;
 }

    private void JoinServer(HostData hostData)
    {
        Debug.Log("Joining to server: "+hostData.gameName+" | "+hostData.ip[0]+":"+hostData.port.ToString());

        clientState=ClientState.ClientJoin;
        Network.Connect(hostData);
    }

        private void tReceive()
        {
            byte[] buffer = new byte[4096];
            int bytesRead;

            while(true)
            {
                bytesRead = 0;

                try
                {
                    bytesRead = stream.Read(buffer, 0, 4096);
                    observer.OnNotify(new MessageWrapper(MessageType.Normal, buffer, Id));
                }
                catch
                {
                    State = ClientState.Disconnected;
                    observer.OnNotify(new MessageWrapper(MessageType.Disconnect, null, Id));
                    break;
                }

                if (bytesRead == 0)
                {
                    State = ClientState.Disconnected;
                    observer.OnNotify(new MessageWrapper(MessageType.Disconnect, null, Id));
                    break;
                }
            }
        }

 private void UpdateUserInterface(ClientState currentState)
 {
     if (currentState == ClientState.SignedIn) {
         //Listen for events of changes of the contact's information
         lyncClient.Self.Contact.ContactInformationChanged +=
             new EventHandler<ContactInformationChangedEventArgs>(SelfContact_ContactInformationChanged);
     }
 }

 public CreateFileService(ClientState clientState, string filename, int numberOfDataServers, int readQuorum, int writeQuorum)
     : base(clientState)
 {
     FileName = filename;
     NumberOfDataServers = numberOfDataServers;
     ReadQuorum = readQuorum;
     WriteQuorum = writeQuorum;
 }

 public Task Execute(Uri recentFeedUri, EventProcessor eventProcessor, HttpResourceClient httpResourceClient, ClientState clientState)
 {
     foreach (var item in ((IEnumerable<SyndicationItem>)encounteredItems).Reverse())
     {
         eventProcessor.Process(item);
         clientState.RecordSuccessfullyProcessed(item);
     }
     return new Terminate();
 }

 public ClientServant(TcpClient client)
 {
     m_id = null;
     m_state = ClientState.Initial;
     m_client = client;
     m_readingThread = new Thread(Reading);
     m_writingQueue = new Queue<Message>();
     m_writingThread = new Thread(Writing);
     m_clientIPEndPoint = client.Client.RemoteEndPoint as IPEndPoint;
 }

        public string GetContent(ClientState state)
        {
            Guid clientGuid = new Guid(state.ClientGuid);
            if (!NotificationStore.ContainsKey(clientGuid))
                return "";

            string result = new JavaScriptSerializer().Serialize(NotificationStore[clientGuid]);
            NotificationStore[clientGuid].Clear();
            return result;
        }

 public void Open()
 {
     try {
         OpenConnection();
         OnOpen();
         state = ClientState.Open;
     } catch (Exception) {
         state = ClientState.Broken;
         throw;
     }
 }

 public void Close()
 {
     try {
         CloseConnection();
         OnClosed();
         state = ClientState.Closed;
     } catch (Exception) {
         state = ClientState.Broken;
         throw;
     }
 }

        public AddIntlPortDialogBox(ClientState client)
        {
            InitializeComponent();

            foreach (var country in client.GetAllCountries())
            {
                //this.originComboBox.Items.Add(countries.Name);
                ComboBoxItem cbi = new ComboBoxItem();
                cbi.Content = country.Name;
                cbi.Tag = country.ID;
                this.countries.Items.Add(cbi);
            }
        }

        public MqttClient(string clientId, IMqttClient client)
        {
            if (clientId.Length < 1 || clientId.Length > 23)
            {
                throw new ArgumentException("Client identifier must be between 1 and 23 charascters.");
            }

            _clientState = ClientState.Disconnected;
            ClientId = clientId;
            _client = client;
            _client.OnMessageReceived += ClientOnMessageReceived;
            _client.OnNetworkDisconnected += ClientOnOnNetworkDisconnected;
            _manager = new StateMachineManager(_client);
        }

 public Task Connect(EndPoint endPoint)
 {
     var tcs = new TaskCompletionSource<bool>();
     _pipeline.OpenConnection(endPoint,
         ex =>
         {
             _state = ClientState.Connect;
             if (ex != null)
                 tcs.SetException(ProcessException(ex));
             else
                 tcs.SetResult(true);
         });
     return tcs.Task;
 }

 public bool CheckClient(ClientState state)
 {
     HttpCookie notificationClientCookie = state.CurrentContext.Request.Cookies.Get(guidCookieName);
     HttpCookie notificationClientTokenCookie = state.CurrentContext.Request.Cookies.Get(tokenCookieName);
     if (notificationClientCookie != null && !string.IsNullOrEmpty(notificationClientCookie.Value) &&
         notificationClientTokenCookie != null && !string.IsNullOrEmpty(notificationClientTokenCookie.Value))
     {
         if (string.Compare(notificationClientTokenCookie.Value, (GenerateToken(state, notificationClientCookie.Value)), true) == 0)
         {
             state.ClientGuid = notificationClientCookie.Value;
             return true;
         }
     }
     return false;
 }

 public SharpMessagingClient(string identity, IExtensionRegistry extensionRegistry)
 {
     _extensionService = new ExtensionService(extensionRegistry, DeliverMessage);
     _state = ClientState.ClientToServerHandshake1;
     _connection = new Connection.Connection(identity, _extensionService, false, _bufferManager)
     {
         ExtensionFrameReceived = OnExtensionFrame,
         MessageFrameReceived = OnMessageFrame,
         WriteCompleted = OnWriteCompleted,
         //ReceiveBufferSize = 65535
     };
     _connection.HandshakeReceived += OnServerHandshakeFrame;
     _connection.Disconnected += OnDisconnected;
     _connection.Fault += OnConnectionFault;
 }

        public Task Execute(Uri recentFeedUri, EventProcessor eventProcessor, HttpResourceClient httpResourceClient, ClientState clientState)
        {
            var entry = feed.Items.ElementAt(entryIndex);

            if (!clientState.HaveAlreadyProcessed(entry))
            {
                encounteredItems.Add(entry);

                if (feed.Items.Count() > entryIndex + 1)
                {
                    return new NavigateEntryTask(feed, entryIndex + 1, encounteredItems);
                }
                return new NavigatePreviousArchiveTask(feed, encounteredItems);
            }

            return new ProcessItemsTask(encounteredItems);
        }

        public Connection(TcpClient c, ServerHost s)
        {
            Client = c;
            Server = s;
            ClientStream = Client.GetStream();
            cancelToken = cTokenSource.Token;

            originIP = Client.Client.RemoteEndPoint.ToString();

            Client.LingerState = new LingerOption(false, 0);

            State = ClientState.CONNECTED;

            Server.Connections.Add(this);

            Helper.LogConsole("Connection", string.Format("New connection from {0}", originIP));
            Task.Run(WaitForData, cancelToken).ConfigureAwait(false);
            Task.Run(DoPostConnect);
        }