Buenas.
Tengo un servidor, que recibe conexiones de muchos clientes, lo hago usando las clases TcpListener para el servidor y TcpClient para los clientes con su respectivo NetworkStream para enviar y recibir datos.
Entonces, quiero que veais el codigo a ver si veis algo mal, por que si lo depuro, y voy linea por linea con el F11 dandole paso yo funciona perfecto, en el momento que lo dejo libre, falla, por lo cual no puedo saber donde es, un ejemplo, para enviar un string a la conexion hago esto en el que va a recibir:
public string recibirString()
{
if (stream == null)
stream = conexion.GetStream();
int longitud = recibirLongitud();
//stream = conexion.GetStream();
Byte[] bytes = new Byte[longitud];
Int32 i;
String datos = String.Empty;
if ((i = stream.Read(bytes, 0, bytes.Length)) != 0)
{
datos = System.Text.Encoding.UTF8.GetString(bytes, 0, i);
return datos;
}
return datos;
}
y recibirLongitud es:
private int recibirLongitud()
{
if (stream == null)
stream = conexion.GetStream();
Int32 longitud = 0;
Byte[] longitudByte = new Byte[4];
//stream = conexion.GetStream();
stream.Read(longitudByte, 0, longitudByte.Length);
longitud = BitConverter.ToInt32(longitudByte, 0);
return longitud;
}
Eso el que lo recibe, y el que envia hace esto cuando ese esta esperando a recibir:
public bool enviarString(string mensaje)
{
if (stream == null)
stream = conexion.GetStream();
try
{
Byte[] paquete = System.Text.Encoding.UTF8.GetBytes(mensaje);
enviarLongitud(paquete);
stream.Write(paquete, 0, paquete.Length);
stream.Flush();
return true;
}
catch { return false; }
}
donde enviarLongitud es:
private bool enviarLongitud(Byte[] paquete)
{
if (stream == null)
stream = conexion.GetStream();
try
{
int longitud = paquete.Length;
byte[] longitudBytes = BitConverter.GetBytes(longitud);
stream.Write(longitudBytes, 0, longitudBytes.Length);
stream.Flush();
return true;
}
catch { return false; }
}
Graaaacias por leer.
Algun comentario? :(
EDITO: stream en este caso seria el NetworkStream y conexion es el TcpClient.
la lectura la tenes que hacer con un while, hasta que hayas leido la misma longuitud de caracter que los esperados.
no basta con un simple "read" por que por el protocolo TCP los mensajes llegan cortados
while (BytesRecidos < BytesEsperados) {
if ((B = ELStream.Read(byteBuffer, BytesRecibidos,
BytesRecibidos - BytesEsperados)) == 0) {
Console.WriteLine("fallo");
break;
}
BytesRecibidos += B;
}
Espero que se entienda xD , si empieza a leer 0 bytes, es que algo funciona mal =)
Estas seguro de eso? yo esque internamente no se como funciona, pero recibir recibe bien, el problema es que despues de recibir, en algun momento, el stream o el tcpClient se peta y da un DisposedObject, pero recibir, cuando recibe, recibe bien.
EDIT: Lo que realmente me jode, es que si pongo un punto de interrupcion, y voy paso a paso, en el que envia los datos, con el F11, haciendolo, va todo perfecto, le mande lo que le mande y las veces que se lo mande, pero en el momento que quito el punto de interrupcion, se peta. :S:S me esta jodiendo mucho eso.
seguro estoy,
proba cerrando los sockets una vez terminada la funcion.
stream.Close();
la longuitud la podes representar con un int de 4 bytes, por lo menos yo lo hacia asi para saber el peso de lo esperado sin complicaciones.
Ya he probado con eso, lo que pasa es que la conexion es continua, si hago el stream.Close() peta por todos lados, por que tanto cliente como servidor estan en continua comunicacion, creo que igual he encontrado el problema, por que he reducido el tamaño de los paquetes que envia y ya no peta, es decir, hay un maximo para enviar de 1 tirada? se puede aumentar si lo hay? solo estoy enviando puro string :S me extraña que sea algo de esto por que entonces ya si quisiera enviar una imagen me puede dar algo pero.... si reduciendo el tamaño a enviar ha funcionado.... :S
hace lo del while que te puse al principio , ya que i y bytes.Lenght pueden no coincidir, te tenes que asegurar que lo haga antes de decifrarlo
if ((i = stream.Read(bytes, 0, bytes.Length)) != 0)
{
datos = System.Text.Encoding.UTF8.GetString(bytes, 0, i);
return datos;
}
fijate asi
int recibidos=0;int Rcvd;
while (recibidos < bytes.Lenght) {
if ((Rcvd = stream.Read(bytes, recibidos,
bytes.Length - recibidos)) == 0) {
Console.WriteLine("error");
break;
}
datos = System.Text.Encoding.UTF8.GetString(bytes, 0, bytes.Lenght);
return datos;
Voy a probarlo ahora mismo, otra duda, el stream = conexion.GetStream(); cuando hay que hacerlo? con 1 vez basta? o cada vez que vaya a enviar y recibir?
con una vez basta, pero el servidor y el cliente tiene que estar sintonizados para cuando el cliente termine de recibir lo que el servidor tenga para enviar ambos cierren los sockets, sino el servidor no podria recibir otra solicitud.
ademas una vez que se termine el proceso, el servidor deberia quedar parado en un punto de espera para responde a una nueva solicitud.
te aconsejo que leas tcp/ip sockets in c # si te quedan muchas dudas
Cita de: SmogMX en 9 Noviembre 2010, 23:44 PM
la lectura la tenes que hacer con un while, hasta que hayas leido la misma longuitud de caracter que los esperados.
no basta con un simple "read" por que por el protocolo TCP los mensajes llegan cortados
while (BytesRecidos < BytesEsperados) {
if ((B = ELStream.Read(byteBuffer, BytesRecibidos,
BytesRecibidos - BytesEsperados)) == 0) {
Console.WriteLine("fallo");
break;
}
BytesRecibidos += B;
}
Espero que se entienda xD , si empieza a leer 0 bytes, es que algo funciona mal =)
En el if, el bytesRecibidos - bytesEsperado mmmm no va bien bien, bytesRecibidos la primera vez es 0 por que hemos recibido 0, y los esperados son 1000 alomejor, 0 - 1000 peta por argumentException que querias poner exactamente? Se ha quedado asi:
public string recibirString()
{
if (stream == null)
stream = conexion.GetStream();
int longitud = recibirLongitud();
Byte[] bytes = new Byte[longitud];
Int32 i;
String datos = String.Empty;
int bytesRecibidos = 0;
while (bytesRecibidos < longitud)
{
if ((i = stream.Read(bytes, bytesRecibidos, bytesRecibidos - longitud)) == 0)
{
break;
}
bytesRecibidos += i;
}
return datos;
}
Si, esta bastante controlado el tema de los sockets, ya te digo que el programa funciona, si el paquete no es grande, y aun siendo grande, si lo hago linea a linea, tambien va.
tenes razon , es BytesEsperado-BytesRecibidos lo bytes que tiene que tratar de leer
Asi funciona:
while (bytesRecibidos < longitud)
{
i = stream.Read(bytes, bytesRecibidos, 1);
bytesRecibidos += i;
}
datos = System.Text.Encoding.UTF8.GetString(bytes, 0, bytes.Length);
return datos;
el stream.Read devuelve 1 o 0? o que valores devuelve? por que funciona igual con un 1 como ultimo parametro y con BytesEsperado-BytesRecibidos??
stream.Read devuelve la cantidad de Bytes que pudo leer,
si pones 1 en vez de BytesEsperados-BytesRecibidos vas a estar leyendo de a un byte.
ya funciona todo bien ?
Si, muchas gracias, ademas voy a dejar lo de bytesEsperados - BytesRecibidos, pero no entiendo muy bien por que asi va y como lo tenia yo no pero bueno :S lo estudiare mejor mañana que tengo que madrugar xD
AAAAAhhh vale vale, es por si de una tacada, no puede leer entero el paquete, vuelve a leer lo que le falta, por eso le sumas la "i" que es lo que ha podido leer, vaaale vale, muchas gracias :)
Acá en este subforo hay dos guías buenas de Sockets y TcpListener/Client , están en el recopilatorio, solo en caso de que no las hayan leído! :)
Si, me los he leido, pero son algo basicos para este caso en concreto, que ya estaba todo eso hecho y que fallaba cuando el paquete era demasiado grande y se partia en 2 y yo solo leia el primer trozo que llegaba, por otro lado aprovecho para preguntar una duda, con un TcpListener por 1 puerto, y 1 solo TcpClient a ese puerto, no puedo tener 2 threads mandando datos es decir, por ejemplo, si quisiera estar enviando por un lado informacion de posibles errores cuando salte, y por otro lado estar contestando las peticiones del servidor? :S No se si me explico, creo que me toca abrir 2 puertos, pero no quiero hacer eso jeje entonces quizas haya alguna manera de que envie uno un poco, el otro otro poco, y asi parezca que lo hacen los dos a al vez y en realidad lo hacen de 1 en 1? Se me entiende? xD
ola bueno ahi dejo mi granito de arena si ayuda en algo chevre
ServidorPaquete
private UdpClient cliente;
private IPEndPoint puntoRecepcion;
// inicializa las variables y el subproceso para recibir paquetes
private void ServidorPaquetesForm_Load( object sender, EventArgs e )
{
cliente = new UdpClient(50000);
puntoRecepcion = new IPEndPoint(new IPAddress(0), 0);
Thread lecturaThread = new Thread(new ThreadStart(EsperarPaquetes));
lecturaThread.Start();
}
// cierra el servidor
private void ServidorPaquetesForm_FormClosing( object sender,
FormClosingEventArgs e )
{
System.Environment.Exit( System.Environment.ExitCode );
} // fin del método ServidorPaquetesForm_FormClosing
// delegado que permite llamar al método MostrarMensaje
// en el subproceso que crea y mantiene la GUI
private delegate void DisplayDelegate( string message );
// el método MostrarMensaje establece la propiedad Text de mostrarTextBox
// de una manera segura para el proceso
private void MostrarMensaje( string mensaje )
{
// si la modificación de mostrarTextBox no es segura para el subproceso
if ( mostrarTextBox.InvokeRequired )
{
// usa el método heredado Invoke para ejecutar MostrarMensaje
// a través de un delegado
Invoke( new DisplayDelegate( MostrarMensaje ),
new object[] { mensaje } );
} // fin de if
else // sí se puede modificar mostrarTextBox en el subproceso actual
mostrarTextBox.Text += mensaje;
}
// espera a que llegue un paquete
public void EsperarPaquetes()
{
while ( true )
{
// prepara el paquete
byte[] datos = cliente.Receive( ref puntoRecepcion );
MostrarMensaje( "\r\nSe recibió paquete:" +
"\r\nLongitud: " + datos.Length +
"\r\nContenido: " +
System.Text.Encoding.ASCII.GetString( datos ) );
// devuelve (eco) la información del paquete de vuelta al cliente
MostrarMensaje( "\r\n\r\nEnviando de vuelta datos al cliente..." );
cliente.Send( datos, datos.Length, puntoRecepcion );
MostrarMensaje( "\r\nPaquete enviado\r\n" );
} // fin de while
}
ClientePaquete
private UdpClient cliente;
private IPEndPoint puntoRecepcion;
// inicializa las variables y el subproceso para recibir paquetes
private void ClientePaquetesForm_Load( object sender, EventArgs e )
{
puntoRecepcion = new IPEndPoint( new IPAddress( 0 ), 0 );
cliente = new UdpClient( 50001 );
Thread subproceso =
new Thread( new ThreadStart( EsperarPaquetes ) );
subproceso.Start();
} // fin del método ClientePaquetesForm_Load
// cierra el cliente
private void ClientePaquetesForm_FormClosing( object sender,
FormClosingEventArgs e )
{
System.Environment.Exit( System.Environment.ExitCode );
} // fin del método ClientePaquetesForm_FormClosing
// delegado que permite llamar al método MostrarMensaje
// en el subproceso que crea y mantiene la GUI
private delegate void DisplayDelegate( string message );
// el método MostrarMensaje establece la propiedad Text de mostrarTextBox
// de una manera segura para el subproceso
private void MostrarMensaje( string mensaje )
{
// si la modificación de mostrarTextBox no es segura para el subproceso
if ( mostrarTextBox.InvokeRequired )
{
// usa el método heredado Invoke para ejecutar MostrarMensaje
// a través de un delegado
Invoke( new DisplayDelegate( MostrarMensaje ),
new object[] { mensaje } );
} // fin de if
else // sí se puede modificar mostrarTextBox en el subproceso actual
mostrarTextBox.Text += mensaje;
} // fin del método MostrarMensaje
// envía un paquete
private void entradaTextBox_KeyDown( object sender, KeyEventArgs e )
{
if ( e.KeyCode == Keys.Enter )
{
// crea un paquete (datagrama) como objeto string
string paquete = entradaTextBox.Text;
mostrarTextBox.Text +=
"\r\nEnviando paquete que contiene: " + paquete;
// convierte el paquete en arreglo de bytes
byte[] datos = System.Text.Encoding.ASCII.GetBytes( paquete );
// envía el paquete al servidor en el puerto 50000
cliente.Send( datos, datos.Length, "127.0.0.1", 50000 );
mostrarTextBox.Text += "\r\nPaquete enviado\r\n";
entradaTextBox.Clear();
} // fin de if
} // fin del método entradaTextBox_KeyDown
// espera a que lleguen los paquetes
public void EsperarPaquetes()
{
while ( true )
{
// recibe arreglo de bytes del servidor
byte[] datos = cliente.Receive( ref puntoRecepcion );
// envía el paquete de datos al control TextBox
MostrarMensaje( "\r\nPaquete recibido:" +
"\r\nLongitud: " + datos.Length + "\r\nContenido: " +
System.Text.Encoding.ASCII.GetString( datos ) + "\r\n" );
} // fin de while
} // fin del método EsperarPaquetes