Cómo utilizar C# para implementar un programa del lado del servidor para el protocolo TCP multiproceso
//& lt; Resumen& gt
/// Clase de subproceso del cliente TCP (servidor), generada a través del hilo ThreadServerProcessor Conexión del cliente, utilizada para lectura y escritura.
///</summary>
Clase pública ThreadClientProcessor
{
//Instancia de conexión TCP
p>
TcpClient privado tcpClient
//Cuadro de mensaje, originalmente quería escribir un registro.
Sistema privado. windows .forms lista de mensajes del cuadro de lista;
Contraseña de cadena privada; //Contraseña de inicio de sesión para esta conexión
Cadena privada cmd 1 echo;
Cadena de caracteres privada Cmd2Echo
Private bool ClientLogOn//¿El cliente ha iniciado sesión?
Private bool TcpClose
Public ThreadClientProcessor(){}
//Constructor, explicación de parámetros: cliente TCP, cuadro de mensaje, contraseña de servicio (parámetros de comando de contraseña después ), cadena de respuesta del comando 1, 2 *******************.
Procesador de cliente de subproceso público (cliente de cliente TCP, ListBox listBox, cadena LogonText, cadena cmd1echo, cadena cmd2echo)
{
Lista de clientes. add(this); //Agrega la instancia actual a la lista para su control posterior.
this.tcpClient=cliente
Esto. ListaMensaje = listBox
Esto. Contraseña = LogonText
Esto. cmd 1 eco = cmd 1 eco;
Esto. cmd 2 echo = cmd 2 echo;
Esto. ClientLogOn = false
Esto. TcpClose = false
}
public static char[]CmdSplit = { ' ' }; // La cadena leída está separada por "" y con nombre+""+parámetro.
//public const string[]Cmd = new string[]{ "contraseña", "cmd1", "cmd2", "echo", "bye" }; /Esta función la escribí yo mismo. Este es sólo un ejemplo.
//Función: procesador de comandos, proporciona una cadena de comando, devuelve el resultado del procesamiento del comando y coloca el comando y el resultado del procesamiento en un archivo de texto para facilitar las actualizaciones del sistema.
Cadena pública TcpCmd(cadena s)
{
Resultado de cadena;
Probar
{
cadena cmd arg = s . Trim();
cadena[] args=cmdarg. split(CmdSplit);
Cadena cmd=args[0]. para bajar();
Cambiar (cmd)
{
Caso "contraseña":
if (args.length& gt1)
{
ClientLogOn=Contraseña. Igual a(argumentos[1].
trim());
resultado=ClientLogOn? "Inicio de sesión exitoso": "La contraseña es incorrecta, no se inició sesión";
}
Else result= "No se ingresó ninguna contraseña al iniciar sesión"; Roto;
Caso "cmd1":
resultado=ClientLogOn? este. Cmd1Echo: "Este comando no tiene permiso para ejecutarse, inicie sesión primero";
Break
Caso "cmd2":
result=ClientLogOn? este. Cmd2Echo: "Este comando no tiene permiso para ejecutarse, inicie sesión primero";
Pausa;
Caso "Echo":
Resultado = cadena. Format("Respuesta del servidor: \n {0} ", s);
Descanso
Caso "Adiós":
Esto. TcpClose = true
resultado= "Desconectado";
Roto;
Valor predeterminado:
Resultado= "Comando no reconocido";
Pausa;
}
}
Captura
{
Resultado= " Se produjo un error al analizar el comando, ingresó un comando sin sentido, TMD * * ";
}
Devuelve el resultado;
}//Finalizar comando
//Definir un hilo La función correspondiente del hilo es void start()(no start())* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *.
//El siguiente programa opera principalmente subprocesos.
Sistema público. threading.Thread tcpClientThread;
//Iniciar el hilo de conexión del cliente * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * .
Public void start()
{
tcpClientThread = new Thread(new ThreadStart(start));
tcpClientThread. prioridad = prioridad del hilo. Más bajo de lo normal;
tcpClientThread. start();
}
//Desconecta la instancia actual y finaliza el hilo * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *.
Aborto de anulación pública()
{
if (this.tcpClientThread!=null)
{
//tcpClientThread. Interrumpir();
tcpClientThread. abort();
//Asegúrate de esperar un rato para pensar en tcpClient más tarde. Close() afectará el funcionamiento de NetWorkStream.
Hilo. dormir(TimeSpan. de milisegundos(100));
tcpClient. close();
}
}
// Lista estática que contiene cada instancia de conexión (ArrayList. Add(object)< se utiliza para construir la instancia /p>
Sistema estático privado.
collections. ArrayList client list = new ArrayList();
//Desconecta todos los clientes TCP, el método estático es * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *.
Vacío estático público AbortAllClient()
{
for(int j = 0; j & ltCustomer list. count; j++)
{
//Obtenga un objeto de la lista de instancias y conviértalo en un objeto ThreadClientProcessor.
ThreadClientProcessor o =(ThreadClientProcessor)client list[j];
//Llamar al método de parada del objeto ThreadClientProcessor
o.abort();
}
//Borrar la lista de conexiones
Lista de clientes. clear();
}
//Función de conexión de lectura y escritura del hilo/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *.
Inicio vacío privado()
{
byte[]buf = nuevo byte[1024 * 1024] //búfer predefinido de 1 MB
<; p> p>int Len = 0; //La longitud real de la secuencia
flujo de red flujo de red = cliente TCP. GetStream(); //Crea una secuencia para leer y escribir Tcp.
Pruebe
{
byte[]p = codificación. UTF8.GetBytes("Bienvenido, ingrese su contraseña");
//Escribe un mensaje de bienvenida a la conexión TCP.
Si (!this.clientlogin)
Flujo de red. Write(p, 0, p . Longitud);
//Comience a leer y escribir la secuencia tcp en un bucle.
Y (!TcpClose)
{
//Si el hilo actual está en otros estados (esperando suspensión, esperando terminación...) terminar el bucle.
If (Thread.CurrentThread.ThreadState!=ThreadState.Running)
Break;
//Determine si hay algo legible en la secuencia Tcp.
if (networkStream.data disponible)
{
//Lee la matriz de bytes del búfer de la secuencia.
Len = flujo de red. read(buf, 0, buf. length);
//Convertir matriz de búfer en cadena
Cadena cmd = codificación. UTF8.GetString(buf, 0, Len);
Esto. lista de mensajes. items. add(" client:"+cmd);
// Procese la cadena almacenada en el búfer (comando de análisis) y el resultado del análisis es una cadena res.
string RES = TcpCmd(cmd);
//Convierte el resultado de retorno del comando res en una matriz de bytes.
byte[] resultado = codificación. UTF8 . GetBytes(RES);
//Envía la matriz de búfer de resultados al cliente.
Flujo de red. escribir(resultado, 0, resultado.
longitud);
Esto. MessageList.Items.Add("Respuesta del servidor:"+RES);
}
Otros
{
//Subproceso. sleep(TimeSpan. from milisegundos(200d));
//This. MessageList.Items.Add("El cliente no tiene comando");
//Si la conexión TCP actual está inactiva y el cliente no escribe, el hilo actual se detiene durante 200 ms.
Hilo. dormir(TimeSpan.from milisegundos(200d));
}
}