networking - Udp confiable en c#

file-transfer reliability

Question

Hay varios artículos en Internet sobre cómo hacer que udp sea confiable. No he podido encontrar uno en c #. Entonces quizás pueda implementar mi algoritmo.

de investigar en Internet, creo que udp tiene dos problemas:

1. no garantiza que todos los datos lleguen a su destino.
2. los datos pueden llegar a su destino en un orden diferente
3. tal vez hay un tercer problema que me falta para hacerlo confiable

si está interesado en saber por qué quiero que udp sea confiable y por qué no uso tcp, mire esta pregunta . Créame, he estado tratando de hacer tcp punch holing por tanto tiempo.

de todos modos, tal vez ya hay una biblioteca que puedo usar con c # que me permitirá hacer esto. Debido a que he notado que he podido encontrar una biblioteca, he estado pensando en el siguiente algoritmo:

"Imagine que hay una computadora A y una computadora B y la computadora A es la que está enviando el archivo a la computadora B";

aquí están los pasos en los que he estado pensando:

1) la computadora A abre el archivo para leer y digamos que es de 5000 bytes. eso significa que la computadora A tendrá que enviar 5000 bytes a la computadora B asegurándose de que no se pierden ni bytes ni en el orden correcto.

2) la computadora A obtiene los primeros 500 bytes del archivo y obtiene el hash de esos bytes. así que ahora la computadora A tiene dos cosas, el hash de esos 500 bytes y también los bytes. (el hash será un algoritmo eficiente como md5 para asegurarse de que los datos se reciban en el orden correcto, es decir md5 (1,2,3)! = md5 (2,1,3))

3) la generación de imágenes del hash de esos primeros 500 bytes resulta ser kj82lkdi930fi1.

4) la computadora B debería estar escuchando un hash y bytes.

5) la computadora A envía el hash a la computadora B. y envía los 500 bytes también. tan pronto como envía que comienza a esperar una respuesta.

6) la computadora B ahora debería recibir el hash y los bytes. la computadora b realiza el mismo algoritmo md5 en los bytes recibidos. si ese resultado es igual al hash que se recibió, entonces responde de nuevo a A con {1,1,1,1,1,1} de lo contrario, responde con {2,2,2,2,2,2,2}

6.5) supongamos que la computadora B obtuvo los datos en el orden correcto para que responda {1,1,1,1,1,} también guarda el código hash en la memoria o matriz.

7) la computadora A debe esperar una respuesta para enviar los siguientes 500 bytes. digamos que recibe {1,1,1}. porque recibió un 1, sabe que puede continuar y envía los siguientes 500 bytes con un nuevo código hash de esos 500 bytes.

8) la computadora A envía los siguientes 500 bytes con su código hash.

9) pretendemos que la computadora B no recibió los datos por lo que no responde de nuevo a A. la computadora B aún esperará por bytes y un hash

8) dado que el equipo A no ha recibido un 1,1,1,1,1 o 2,2,2,2,2 durante un período de tiempo razonable, A enviará los mismos bytes y el hash nuevamente por un segundo hora.

9) supongamos que la computadora B recibe el hash y los bytes, pero los bytes se recibieron en un orden diferente. cuando la computadora B calcula el hash en esos bytes, ese hash no coincidirá con el hash que se recibió. como resultado, responderá de nuevo con {2,2,2,2,2,2}

10) si la computadora A recibe el 2,2,2,2,2,2, enviará los mismos bytes y hash. si no recibió el 2,2,2,2,2 por algún motivo, enviará los mismos bytes y hash después de un período de tiempo. pretendamos que la computadora A recibe 2,2,2,2,2

11) la computadora A envía los mismos bytes y hash por tercera vez.

12) la computadora B recibe el hash y los bytes en el orden correcto. como resultado, responde 1,1,1,1,1,1 y guarda ese hash anterior en la memoria. (recuerda el paso 6.5)

13) permite que la computadora simulada A no reciba la respuesta 1,1,1,1 de B. Luego enviará los mismos bytes por cuarta vez.

14) la computadora B verifica los valores hash y si es igual al último que fue aceptado, entonces responde 1,1,1,1 nuevamente sin escribir esos bytes en el archivo.

15) el algoritmo continúa así hasta que se transfiere el archivo.

.

.

.

Quiero decir que obviamente hay otras cosas que necesito agregar a este algoritmo, como dejar que la computadora B sepa cuando se realiza la transferencia. tal vez buscando más errores. ¿Qué sucede si la computadora A se desconecta por un tiempo prolongado? Pero el protocolo principal será algo así como el que describí.

Entonces, ¿crees que debería comenzar a implementar este algoritmo? debería aumentar y enviar más bytes cada vez. Me refiero a enviar 1000 en lugar de 500? Hay muchos artículos en Internet que le informan sobre varias técnicas, pero muy pocas le dan un ejemplo práctico del idioma que desea. En este caso, necesito esto en c #.

Answer 1

El tercer problema es que los datos pueden corromperse cuando lo recibe.

Puede comenzar leyendo TCP RFC solo para comprender cómo TCP hace que la comunicación sea confiable. Tener ese conocimiento puede implementar algunas de sus técnicas usando UDP como transporte.

También eche un vistazo a esta biblioteca de red UDP http://code.google.com/p/lidgren-network-gen3/