[C#]PROBLEMA CON SEMPLICE CHAT

[SUPERALEX]

Sto facendo una chat client-server facile ovvero server ascolta client si connette iniziano a parlare..è una cosa single threaded quindi in teoria una volta che il client si connette il server può anche smettere di ascoltare x altri..solo che ho 2 domande primo perchè quando avvio il server che si mette in ascolto dopo un pò si blocca e viene fuori che l'applicazione nn risponde anche se ho copiato la procedura standard da altri progetti che nn si bloccano..poi una volta che il client è connesso mi chiedevo come fare x far si che il server sia sempre pronto a ricevere i messaggi che gli arrivano..pensavo a un ciclo infinito che continua a invocare la funzione che guarda se ci sono dati disponibili ma nn mi sembra una bella cosa..cmq è fatto così:
private void StartServer(int porta)
{
try
{

this.eventi.AppendText("Avvio server\n");

ip = IPAddress.Parse("192.168.0.2");


listener = new TcpListener(ip, porta);
listener.Start();
while (true)
{
client = listener.AcceptTcpClient();
this.eventi.AppendText("Client connesso!!\n");
chat();
break;
}

private void chat()
{
this.stream = client.GetStream();
int n=0;
while (true)
{
if (stream.DataAvailable)
{
recMessage(n);
n = 1;
}
}
}

nn guardate come è scritto formalmente perchè ho fatto varie prove anche stupide x vedere se risolvevo..il bello è che quando clicco per avviarlo nn vengono fuori le scritte degli eventi avvio server ecc mentre alcune volte sono uscite:confused:

[!k-0t1c!]

Se posti il codice completo posso darti una mano, ad occhio e croce ti dico che sicuramente:
1. manca il catch per il try in StartServer
2. Non ha senso mettere while(true) se all'interno c'è un break eseguito incondizionatamente
3. Se è tutto su un solo thread allora è logico che si blocchi perché non processi gli eventi generati dall'utente, mentre se è su più threads devi controllare di effettuare il lock di tutto quel che è condiviso e può essere sia letto sia scritto altrimenti il tuo codice non è thread safe, devi verificare che non ci siano race conditions o deadlocks.

[SUPERALEX]

il catch c'è nn lo messo perchè era inutile la parte incriminata è quella so anche che il while è inutile ma avevo provato senza allora l'ho messo così avevo detto di nn guardare il codice in se x se..cmq è a singolo thread proprio perchè c'è un solo client che si connette e col quale parla il form2 è il client
public partial class Form1 : Form
{
private TcpListener listener;
private IPAddress ip;
NetworkStream stream;
String nick = null;
TcpClient client;

public Form1()
{
InitializeComponent();


}

private void Form1_Load(object sender, EventArgs e)
{
Form form2 = new Form2();
form2.Show();



}



private void StartServer(int porta)
{
try
{

this.eventi.AppendText("Avvio server\n");
/*ip = Dns.GetHostEntry("LocalHost").AddressList[0];*/
ip = IPAddress.Parse("192.168.0.2");


listener = new TcpListener(ip, porta);
listener.Start();
while (true)
{
client = listener.AcceptTcpClient();
this.eventi.AppendText("Client connesso!!\n");
chat();
break;
}

}
catch (Exception e)
{
MessageBox.Show("errore");
}


}

private void chat()
{
this.stream = client.GetStream();
int n=0;
while (true)
{
if (stream.DataAvailable)
{
recMessage(n);
n = 1;
}
}
}

private void reset()
{
this.eventi.AppendText("Server fermato\n");

}

private void stopServer()
{
stream.Close();
client.Close();
listener.Stop();

}

private void showInfo()
{
MessageBox.Show("Inserire un numero compreso tra 1024 e 65536");
}

private void recMessage(int n)
{
if (stream.CanRead)
{

byte[] readBuffer = new byte[1024];
StringBuilder completeMessage = new StringBuilder();
int num = 0;

// Incoming message may be larger than the buffer size.
do
{
num = stream.Read(readBuffer, 0, readBuffer.Length);
if (num == 0) return;
completeMessage.AppendFormat("{0}", Encoding.ASCII.GetString(readBuffer, 0, num));
} while (stream.DataAvailable);
if (String.Compare(completeMessage.ToString(), "close") == 0) stopServer();

if (n == 0)
{
nick = completeMessage.ToString();
lista.AppendText("Il client è " + nick);
}
else view.AppendText("" + nick + ": "+ completeMessage);

}




}

private void sendMessage()
{
byte[] writebuffer;
String mex;
writebuffer = Encoding.ASCII.GetBytes(testo.Text);
if (writebuffer.Length == 0) throw new Exception();

stream.Write(writebuffer, 0, writebuffer.Length);

view.AppendText("\nServer: " + testo.Text);
testo.Clear();

}

private void l(object sender, MouseEventArgs e)
{

}

private void start_Click(object sender, EventArgs e)
{

try
{

int port;
port = Int32.Parse(porta.Text);
if (port < 1024 || port > 65536) throw new Exception();
this.eventi.AppendText("Porta accettata\n");
StartServer(port);
}
catch (Exception ex)
{
MessageBox.Show("Numero di porta errato!!Inserire un numero intero compreso tra 1024 e 65536");
reset();

}
}

private void clear_Click(object sender, EventArgs e)
{
testo.Clear();
}

private void finish_Click(object sender, EventArgs e)
{
stopServer();
}





}

[!k-0t1c!]

Considerando che mantieni la connessione aperta per tutta la durata della chat e che si tratta di TCP, l'uso che fai dello stream è terribile.
Innanzitutto devi definire se è consentito mandare due messaggi di seguito; in secondo luogo definisci una lunghezza massima del messaggio. Se ciascuno manda un solo messaggio e aspetta la risposta basta fare stream.Read cercando di leggere la lunghezza massima del messaggio e controllare che non ritorni 0. Quando ritorna 0 la connessione è stata chiusa. A quel punto liberi le risorse ed esci. Quando ritorna un valore, è il numero di bytes letti, e te li gestisci come vuoi. Tutto sta comunque in un do/while dove la condizione è che l'ultima lettura non sia 0. Se vuoi lasciare la possibilità di mandare due messaggi di seguito allora la cosa più comoda e semplice è avere due threads (puoi condividere la connessione facilmente). Inoltre ricorda che stream.DataAvailable non ti garantisce affatto che tutti i dati inviati dal client siano già stati ricevuti, quindi per come stanno le cose su una rete reale potresti facilmente troncare la ricezione prematuramente.

[SUPERALEX]

uno può scrivere quanto vuole..ma senza multithread..quindi nn so come fare perchè sia sempre pronto a ricevere e contemporaneamente a mandare

[!k-0t1c!]

Senza multithreading lo scenario che hai in mente non esiste, non in maniera decente.

[SUPERALEX]

ok allora mettiamo che ognuno manda un messaggio alla volta..cmq deve stare sempre in ascolto perchè nn può sapere quando l'altro scriverà..e deve anche capire quando il messaggio è finito..

[!k-0t1c!]

Un messaggio alla volta, visto che si tratta di testo e non di dati, lo puoi gestire stabilendo una lunghezza massima del messaggio (arbitraria) e poi usando codice di questo genere:

var buf = new byte[LUNGHEZZA_MASSIMA_MESSAGGIO];
var letti = stream.Read(buf, 0, LUNGHEZZA_MASSIMA_MESSAGGIO);
if(letti != 0) //letti contiene la lunghezza del messaggio
{
//uso UTF8 arbitrariamente, puoi usare ASCII o Unicode o quel che preferisci
string messaggio = Encoding.UTF8.GetString(buf.Take(letti).ToArray()); //usiamo LINQ to Objects per evitare gli \0 finali nella string. si può fare anche diversamente ma così è più conciso.
//fai quel che vuoi con messaggio
}
else
{
//gestisci il caso in cui la connessione è stata chiusa
}

E dopo aver ricevuto il messaggio dovresti dar la possibilità all'utente di mandare il suo. Resta il fatto che senza multithreading, mentre il programma è in attesa di un messaggio se l'utente prova ad interagirci il sistema dirà all'utente che il programma non risponde etc etc.

[SUPERALEX]

ok ma questo deve essere in un ciclo infinito a ripetizione cioè continua a cercare di leggere finchè nn arrivano..ma se dopo che li ha ricevuti (e cmq continua a leggere il nulla)uno schiaccia il tasto x inviare li invia cmq no

[!k-0t1c!]

Il tuo ultimo post ha poco senso, cerca di esplicitare di più la sequenza temporale delle azioni e i soggetti. Ad ogni modo il codice di cui sopra è solo la parte di ricezione di un messaggio. Durante la sua esecuzione in un contesto a thread unico non è possibile interagire ulteriormente con il programma, ed in seguito all'esecuzione puoi integrare la parte che dovrebbe gestire l'invio e racchiudere tutto in un ciclo while con condizione che verifichi che la connessione è aperta. In questo modo hai ricezione-invio-ricezione-invio...

[SUPERALEX]

si ma l'invio dovrebbe avvenire ogni qualvolta uno schiaccia il pulsante invia nn quando lo decide il codice..è la ricezione che deve stare sempre all'erta

[!k-0t1c!]

Infatti, nessuno ti vieta di fare così. E la ricezione in un contesto a thread singolo non può "stare sempre all'erta" in maniera affidabile. Ad ogni modo ti consiglio di studiare qualcosa a livello di protocolli e di guardare qualche implementazione reale perché sembri avere le idee abbastanza confuse sulla materia e questa non mi pare la sede adatta per chiarirle.

[SUPERALEX]

ho provato con i thread che ne dici?l'unica cosa è che se avvio il form 1 nn mi visualizza il client nn so perchè mentre prima se lo facevo senza dargli un thread apposito appariva
namespace CHAT_FORM
{
public partial class Form1 : Form
{
private TcpListener listener;
private IPAddress ip;
NetworkStream stream;
String nick = null;
TcpClient client;
Thread recThread;
Thread sendThread;
Thread clientThread;

public Form1()
{
InitializeComponent();


}

private void Form1_Load(object sender, EventArgs e)
{
Form form2 = new Form2();
clientThread = new Thread(new ThreadStart(form2.Show));
clientThread.Start();





}



private void StartServer(int porta)
{
try
{

this.eventi.AppendText("Avvio server\n");

ip = IPAddress.Parse("127.0.0.1");


listener = new TcpListener(ip, porta);
listener.Start();
while (true)
{
client = listener.AcceptTcpClient();
this.eventi.AppendText("Client connesso!!\n");

recThread = new Thread(new ThreadStart(chat));
recThread.Start(client);
break;
}

}
catch (Exception e)
{
MessageBox.Show("errore");
}


}

private void chat()
{

this.stream = client.GetStream();
int n=0;
while (true)
{

recMessage(n,stream);
n = 1;

}
}

private void reset()
{
this.eventi.AppendText("Server fermato\n");

}

private void stopServer()
{
stream.Close();
client.Close();
listener.Stop();

}

private void showInfo()
{
MessageBox.Show("Inserire un numero compreso tra 1024 e 65536");
}

private void recMessage(int n,NetworkStream stream)
{
if (stream.CanRead)
{

byte[] readBuffer = new byte[1024];
StringBuilder completeMessage = new StringBuilder();
int num = 0;

// Incoming message may be larger than the buffer size.
do
{
num = stream.Read(readBuffer, 0, readBuffer.Length);

completeMessage.AppendFormat("{0}", Encoding.ASCII.GetString(readBuffer, 0, num));
} while (num>0);
if (String.Compare(completeMessage.ToString(), "close") == 0) stopServer();

if (n == 0)
{
nick = completeMessage.ToString();
lista.AppendText("Il client è " + nick);
}
else view.AppendText("" + nick + ": "+ completeMessage);

}




}

private void sendMessage()
{
byte[] writebuffer;
String mex;
writebuffer = Encoding.ASCII.GetBytes(testo.Text);
if (writebuffer.Length == 0) throw new Exception();

stream.Write(writebuffer, 0, writebuffer.Length);

view.AppendText("\nServer: " + testo.Text);
testo.Clear();

}

private void l(object sender, MouseEventArgs e)
{

}

private void start_Click(object sender, EventArgs e)
{

try
{

int port;
port = Int32.Parse(porta.Text);
if (port < 1024 || port > 65536) throw new Exception();
this.eventi.AppendText("Porta accettata\n");
StartServer(port);
}
catch (Exception ex)
{
MessageBox.Show("Numero di porta errato!!Inserire un numero intero compreso tra 1024 e 65536");
reset();

}
}

private void clear_Click(object sender, EventArgs e)
{
testo.Clear();
}

private void finish_Click(object sender, EventArgs e)
{
stopServer();
}

private void send_Click(object sender, EventArgs e)
{
sendThread = new Thread(new ThreadStart(sendMessage));
sendThread.Start();
do
{

if (!sendThread.IsAlive) sendThread.Abort();
} while (sendThread.IsAlive);
}





}
}

[gugoXX]

Per un problema del genere ti consiglierei di usare dei datagrammi UDP