/// <summary>
        /// Encerra a execucao dos processos de leitura e escrita da Conexao do cliente.
        /// </summary>
        public void Desconectar()
        {
            statusEscrita = false;
            statusLeitura = false;

            if (TcpUtil.ConexaoTcpValida(TcpCliente))
            {
                lock (TcpCliente)
                {
                    TcpCliente.Client.Shutdown(SocketShutdown.Both);
                    TcpCliente.Client.Dispose();
                    TcpCliente.Close();
                }
            }
        }
        /// <summary>
        /// Responsável por processar a chegada e envio de mensagens
        /// (enfileirar novas mensagens e processar mensagens de escrita).
        /// </summary>
        protected virtual void RnProcessarLeitura()
        {
            LogDebug(string.Format("\nManager iniciou comunicação com {0} - Cronograma:{1} | {2} iniciou... ", LoginCliente, OidCronograma, Thread.CurrentThread.Name));
            String        mensagemJson = "";
            MensagemDto   m;
            List <string> mensagens;
            string        msgAtual = "";

            while (statusLeitura)
            {
                try
                {
                    //validar caso de perda de conexão com o WexMultiAccessClient
                    if (!TcpUtil.ConexaoTcpValida(TcpCliente))
                    {
                        if (AoOcorrerDesconexaoInesperada != null)
                        {
                            AoOcorrerDesconexaoInesperada(this, new DesconexaoInesperadaEventArgs(LoginCliente, OidCronograma));
                        }
                        statusLeitura = false;
                        continue;
                    }
                    if (!statusLeitura)
                    {
                        continue;
                    }
                    if (!TcpCliente.GetStream().DataAvailable)
                    {
                        Thread.Sleep(15);
                        continue;
                    }
                    mensagemJson = TcpUtil.ReceberMensagemTcp(TcpCliente);
                    if (mensagemJson.Trim() == "")
                    {
                        continue;
                    }

                    if (mensagemJson.Contains("\n"))
                    {
                        mensagens = mensagemJson.Split('\n').ToList();
                        foreach (string msg in mensagens)
                        {
                            if (String.IsNullOrEmpty(msg))
                            {
                                continue;
                            }

                            msgAtual = msg.Trim();
                            if (Buffer != "")
                            {
                                msgAtual = Buffer + msgAtual;
                                Buffer   = "";
                            }

                            m = Mensagem.DeserializarMensagemDto(TcpUtil.RemoverStringProtecaoDeIntegridade(msgAtual));
                            LogDebug(String.Format("\nManager recebeu a mensagem {0} | Autor: {1} | Cronograma: {2}\nMensagem Json:{3}", m.Tipo, LoginCliente, OidCronograma, msgAtual));
                            FilaLeitura.Enqueue(m);
                            msgAtual = "";
                        }
                    }
                    else
                    {
                        Buffer += mensagemJson;
                    }
                }
                catch (JsonException ex)
                {
                    LogInfo(String.Format("Exception: {0}" + Environment.NewLine + " StackTrace: {1}", ex.Message, ex.StackTrace));
                    LogDebug(string.Format("\nConexaoCliente do {3} (Leitura) - Mensagem Json:{2}Excessão:{0}\nCallStack{1} Categoria: JsonConvert", ex.Message, ex.StackTrace, msgAtual, LoginCliente));
                    continue;
                }
                catch (InvalidOperationException ex)
                {
                    LogInfo(String.Format("Exception: {0}" + Environment.NewLine + " StackTrace: {1}", ex.Message, ex.StackTrace));
                    LogDebug(string.Format("\nOcorreu a excessão:{0}\nLocal:{1} Thread: {2}", ex.Message, ex.StackTrace, Thread.CurrentThread.Name), ex);
                    Desconectar();
                }
                catch (Exception ex)
                {
                    LogInfo(String.Format("Exception: {0}" + Environment.NewLine + " StackTrace: {1}", ex.Message, ex.StackTrace));
                    LogDebug(string.Format("\nOcorreu a excessão:{0}\nLocal:{1} Thread: {2}", ex.Message, ex.StackTrace, Thread.CurrentThread.Name));
                    Desconectar();
                }

                Thread.Sleep(10);
            }
            LogDebug(string.Format("\nManager finalizou comunicação com {0} - Cronograma:{1} | {2} finalizou... ", LoginCliente, OidCronograma, Thread.CurrentThread.Name));
        }