Baixe Criando um Chat - Parte 1: Criando o Cliente e outras Esquemas em PDF para Tecnologia de Informação, somente na Docsity!
C # - Criando um Chat - Parte
1 - O Cliente
Neste artigo eu vou mostrar como criar um Chat procurando ser bem objetivo e mantendo as coisas o simples possível.
Na verdade uma aplicação de Chat (bate-papo) consiste em duas aplicações:
O cliente - Se conecta com o servidor envia e recebe mensagens; O Servidor - que trata as conexões, armazenando-as em uma hash table e distribui as mensagens para quem estiver conectado; (O servidor do Chat será capaz de aceitar tantos clientes quanto forem permitidos pela hash table(você pode definir um limite na tabela), e que também irá acompanhar todas as mensagens que estão indo e voltando em sua propria janela do chat.)
Para poder acompanhar e entender tudo que vamos fazer é necessário que se tenha conhecimento sobre os seguintes tópicos:
Multi-Threading Eventos, Delegates Redes
Vamos iniciar criando o cliente.
Chat - Criando a aplicação cliente
A aplicação cliente é a mais simples, já que tudo o que ela tem a fazer é tentar se conectar ao servidor de bate-papo, pedir um nome de usuário, começar a ouvir as mensagens e enviar suas próprias e, finalmente, desligar.
Inicie o Visual C# 2010 Express Edition e crie um novo projeto do tipo Windows Appliation com o nome ChatCliente :
Vamos alterar o nome do formulário form1.cs criado por padrão no projeto para frmCliente.cs e a seguir definir o leiaute conforme mostra a figura abaixo no formulário:
private IPAddress enderecoIP; private bool Conectado;
3- Código do evento Click do botão Conectar que verifica se estamos conectados e inicia a conexão;
private void btnConectar_Click(object sender, System.EventArgs e) { // se não esta conectando aguarda a conexão if (Conectado == false) { // Inicializa a conexão InicializaConexao(); } else // Se esta conectado entao desconecta { FechaConexao("Desconectado a pedido do usuário."); } }
4- Código da rotina IncializaConexao ():
private void InicializaConexao() {
// Trata o endereço IP informado em um objeto IPAdress enderecoIP = IPAddress.Parse(txtServidorIP.Text); // Inicia uma nova conexão TCP com o servidor chat tcpServidor = new TcpClient(); tcpServidor.Connect(enderecoIP, 2502);
// AJuda a verificar se estamos conectados ou não Conectado = true;
// Prepara o formulário NomeUsuario = txtUsuario.Text;
// Desabilita e habilita os campos apropriados txtServidorIP.Enabled = false; txtUsuario.Enabled = false; txtMensagem.Enabled = true; btnEnviar.Enabled = true; btnConectar.Text = "Desconectado";
// Envia o nome do usuário ao servidor stwEnviador = new StreamWriter(tcpServidor.GetStream()); stwEnviador.WriteLine(txtUsuario.Text); stwEnviador.Flush();
//Inicia a thread para receber mensagens e nova comunicação mensagemThread = new Thread(new ThreadStart(RecebeMensagens)); mensagemThread.Start(); }
O endereço IP é analisado a partir do TextBox em um
objeto IPAddress , e então abrimos uma conexão TCP para esse
endereço. A porta é 2502, mas você pode usar qualquer porta
disponível. Em seguida, preparar os controles no formulário,
desativando alguns e habilitando outros.
Alteramos também a legenda de btnConetar para exibir a
mensagem "Desconectado". Através de um Stream , informamos ao
servidor o nome de usuário, e imediatamente depois que começamos
uma nova thread que chama o método RecebeMensagens () que irá
ouvir as mensagens recebidas a partir de agora.
Colocando isso em uma thread separada, a nossa aplicação é
totalmente utilizável, enquanto ele está escutando as mensagens do
servidor e mantem a conexão ativa.
5- Código da rotina RecebeMensagens
private void RecebeMensagens() { // recebe a resposta do servidor strReceptor = new StreamReader(tcpServidor.GetStream()); string ConResposta = strReceptor.ReadLine(); // Se o primeiro caracater da resposta é 1 a conexão foi feita com sucesso if (ConResposta[0] == '1') { // Atualiza o formulário para informar que esta conectado this.Invoke(new AtualizaLogCallBack(this.AtualizaLog), new object[] { "Conectado com sucesso!" }); } else // Se o primeiro caractere não for 1 a conexão falhou { string Motivo = "Não Conectado: "; // Extrai o motivo da mensagem resposta. O motivo começa no 3o caractere Motivo += ConResposta.Substring(2, ConResposta.Length - 2); // Atualiza o formulário como o motivo da falha na conexão this.Invoke(new FechaConexaoCallBack(this.FechaConexao), new object[] { Motivo }); // Sai do método return; }
// Enquanto estiver conectado le as linhas que estão chegando do servidor while (Conectado) { // exibe mensagems no Textbox this.Invoke(new AtualizaLogCallBack(this.AtualizaLog), new object[] { strReceptor.ReadLine() }); } }
Um novo leitor dee stream está ligado ao cliente TCP. Ele vai ouvir as mensagens recebidas. Mas antes de tudo, lemos a primeira linha vindo do servidor. O motivo é que sabemos que a primeira linha contém uma resposta nos dizendo se estamos ou não conectados com êxito.
Para enviar uma mensagem usamos o evento click do botão Enviar ou quando a tecla Enter for pressionada. Nestes casos chamamos a rotina EnviaMensagem () conforme os itens 7 e 8 acima.
9- Código da rotina EnviaMensagem
// Envia a mensagem para o servidor private void EnviaMensagem() { if (txtMensagem.Lines.Length >= 1) { //escreve a mensagem da caixa de texto stwEnviador.WriteLine(txtMensagem.Text); stwEnviador.Flush(); txtMensagem.Lines = null; } txtMensagem.Text = ""; }
A rotina EnviaMenagem() apenas verifica se o número de linhas é maior ou igual a 1, e então escreve a linha para a conexão TCP através do objeto StreamWriter. A chamda ao método Flush() garante que as mensagens estão sendo enviadas de imediato.
10 - Código da rotina FechaConexao
// Fecha a conexão com o servidor private void FechaConexao(string Motivo) { // Mostra o motivo porque a conexão encerrou txtLog.AppendText(Motivo + "\r\n"); // Habilita e desabilita os controles apropriados no formulario txtServidorIP.Enabled = true; txtUsuario.Enabled = true; txtMensagem.Enabled = false; btnEnviar.Enabled = false; btnConectar.Text = "Conectado";
// Fecha os objetos Conectado = false; stwEnviador.Close(); strReceptor.Close(); tcpServidor.Close(); }
Para fechar a conexão chamamos o método FechaConexao e neste código temos que o formulário está sendo trazido de volta para o estado não conectado, e a conexão TCP e os streams estão sendo fechados. Mas o que acontece se o usuário não clicar para desconectar mas apenas fechar o aplicativo enquanto a conexão com o servidor está ativa?
Nós certamente não queremos deixar a conexão aberta como esta até que ele morra por conta própria. Felizmente existe o evento ApplicationExit que é acionado quando o aplicativo for fechado, e é aí que podemos fechar a nossa
conexão. Para tratar este evento vamos alterar o código do construtor do formulário conforme abaixo:
11- Definição do tratamento do evento ApplicationOnExit
public frmCliente() { // Na saida da aplicação : desconectar Application.ApplicationExit += new EventHandler(OnApplicationExit); InitializeComponent(); }
12- Código do evento OnApplicationExit()
// O tratador de evento para a saida da aplicação public void OnApplicationExit(object sender, EventArgs e) { if (Conectado == true) { // Fecha as conexões, streams, etc... Conectado = false; stwEnviador.Close(); strReceptor.Close(); tcpServidor.Close(); } }
O código do evento OnApplicationExit() vai ocorrer quando o usuário fechar o aplicativo diretamente com a conexão ativa e vai verificar se estamos conectados e fechar as conexões e os recursos usados
Pegue a primeira parte do projeto completo aqui: ChatCliente.zip
Na segunda parte do artigo irei mostrar a criação do Servidor que irá receber
e distribuir as mensagens recebidas: C # - Criando um Chat - Parte 2 - O
Servidor (inativo)
"Meus filhinhos , estas coisas vos escrevo, para que não pequeis; e
se alguém pecar, temos um advogado para com o Pai, Jesus Cristo,
o justo." I João 2:
