ການປະຕິບັດອະນຸສັນຍາ Udp ທີ່ເຊື່ອຖືໄດ້ສໍາລັບ .Net

ອິນເຕີເນັດໄດ້ປ່ຽນແປງເປັນເວລາດົນນານກ່ອນຫນ້ານີ້. ຫນຶ່ງໃນໂປໂຕຄອນຕົ້ນຕໍຂອງອິນເຕີເນັດ - UDP ຖືກນໍາໃຊ້ໂດຍແອັບພລິເຄຊັນບໍ່ພຽງແຕ່ສົ່ງຂໍ້ມູນແລະການອອກອາກາດ, ແຕ່ຍັງສະຫນອງການເຊື່ອມຕໍ່ "peer-to-peer" ລະຫວ່າງ nodes ເຄືອຂ່າຍ. ເນື່ອງຈາກການອອກແບບທີ່ງ່າຍດາຍຂອງມັນ, ໂປໂຕຄອນນີ້ມີການນໍາໃຊ້ທີ່ບໍ່ໄດ້ວາງແຜນໄວ້ກ່ອນຫນ້ານີ້, ແນວໃດກໍ່ຕາມ, ຂໍ້ບົກຜ່ອງຂອງໂປໂຕຄອນ, ເຊັ່ນ: ການຂາດການຮັບປະກັນ, ບໍ່ໄດ້ຫາຍໄປທຸກບ່ອນ. ບົດ​ຄວາມ​ນີ້​ອະ​ທິ​ບາຍ​ການ​ປະ​ຕິ​ບັດ​ຂອງ​ອະ​ນຸ​ສັນ​ຍາ​ການ​ຈັດ​ສົ່ງ​ທີ່​ຮັບ​ປະ​ກັນ​ຜ່ານ UDP​.
ເນື້ອຫາ:ເຂົ້າ
ຂໍ້ກໍານົດພິທີການ
ສ່ວນຫົວ UDP ທີ່ເຊື່ອຖືໄດ້
ຫຼັກການທົ່ວໄປຂອງອະນຸສັນຍາ
ໝົດເວລາ ແລະເຄື່ອງຈັບເວລາໂປຣໂຕຄໍ
ແຜນວາດສະຖານະສາຍສົ່ງ UDP ທີ່ເຊື່ອຖືໄດ້
ເລິກເຂົ້າໄປໃນລະຫັດ. ຫນ່ວຍ​ຄວບ​ຄຸມ​ສາຍ​ສົ່ງ​
ເລິກເຂົ້າໄປໃນລະຫັດ. ລັດ

• ວິທີ DisposeByTimeout
• ProcessPackets ວິທີການ
• ວິທີການຮັບ Packet
• ສົ່ງວິທີການຫຸ້ມຫໍ່

ເລິກເຂົ້າໄປໃນລະຫັດ. ການສ້າງແລະສ້າງການເຊື່ອມຕໍ່
ເລິກເຂົ້າໄປໃນລະຫັດ. ການປິດການເຊື່ອມຕໍ່ໃນເວລາຫມົດເວລາ
ເລິກເຂົ້າໄປໃນລະຫັດ. ການຟື້ນຟູການໂອນຂໍ້ມູນ
UDP API ທີ່ເຊື່ອຖືໄດ້
ສະຫລຸບ
ການເຊື່ອມຕໍ່ທີ່ເປັນປະໂຫຍດແລະບົດຄວາມ

ເຂົ້າ

ສະຖາປັດຕະຍະກໍາຕົ້ນສະບັບຂອງອິນເຕີເນັດໄດ້ສົມມຸດພື້ນທີ່ທີ່ຢູ່ດຽວກັນເຊິ່ງແຕ່ລະ node ມີທີ່ຢູ່ IP ທົ່ວໂລກແລະເປັນເອກະລັກແລະສາມາດສື່ສານໂດຍກົງກັບ nodes ອື່ນໆ. ໃນປັດຈຸບັນອິນເຕີເນັດ, ໃນຄວາມເປັນຈິງ, ມີສະຖາປັດຕະຍະກໍາທີ່ແຕກຕ່າງກັນ - ພື້ນທີ່ຫນຶ່ງຂອງທີ່ຢູ່ IP ທົ່ວໂລກແລະຫຼາຍພື້ນທີ່ທີ່ມີທີ່ຢູ່ສ່ວນຕົວເຊື່ອງໄວ້ຢູ່ຫລັງອຸປະກອນ NAT.ໃນສະຖາປັດຕະຍະກໍານີ້, ພຽງແຕ່ອຸປະກອນທີ່ຢູ່ໃນພື້ນທີ່ທີ່ຢູ່ທົ່ວໂລກສາມາດຕິດຕໍ່ສື່ສານກັບທຸກຄົນໃນເຄືອຂ່າຍໄດ້ຢ່າງງ່າຍດາຍເພາະວ່າພວກເຂົາມີທີ່ຢູ່ IP ທີ່ເປັນເອກະລັກ, ທົ່ວໂລກ. node ໃນເຄືອຂ່າຍສ່ວນຕົວສາມາດເຊື່ອມຕໍ່ກັບ nodes ອື່ນໆໃນເຄືອຂ່າຍດຽວກັນ, ແລະຍັງສາມາດເຊື່ອມຕໍ່ກັບ nodes ທີ່ມີຊື່ສຽງອື່ນໆໃນພື້ນທີ່ທີ່ຢູ່ທົ່ວໂລກ. ການໂຕ້ຕອບນີ້ແມ່ນບັນລຸໄດ້ສ່ວນໃຫຍ່ເນື່ອງຈາກກົນໄກການແປທີ່ຢູ່ເຄືອຂ່າຍ. ອຸປະກອນ NAT, ເຊັ່ນ Wi-Fi routers, ສ້າງລາຍການຕາຕະລາງການແປພາສາພິເສດສໍາລັບການເຊື່ອມຕໍ່ຂາອອກແລະແກ້ໄຂທີ່ຢູ່ IP ແລະຕົວເລກພອດໃນແພັກເກັດ. ນີ້ອະນຸຍາດໃຫ້ການເຊື່ອມຕໍ່ຂາອອກຈາກເຄືອຂ່າຍເອກະຊົນໄປຫາເຈົ້າພາບໃນພື້ນທີ່ທີ່ຢູ່ທົ່ວໂລກ. ແຕ່ໃນເວລາດຽວກັນ, ອຸປະກອນ NAT ປົກກະຕິແລ້ວຈະຂັດຂວາງການຈະລາຈອນຂາເຂົ້າທັງຫມົດເວັ້ນເສຍແຕ່ກົດລະບຽບແຍກຕ່າງຫາກສໍາລັບການເຊື່ອມຕໍ່ຂາເຂົ້າ.

ສະຖາປັດຕະຍະກໍາຂອງອິນເຕີເນັດນີ້ແມ່ນຖືກຕ້ອງພຽງພໍສໍາລັບການສື່ສານຂອງລູກຄ້າກັບເຄື່ອງແມ່ຂ່າຍ, ບ່ອນທີ່ລູກຄ້າສາມາດຢູ່ໃນເຄືອຂ່າຍສ່ວນຕົວ, ແລະເຄື່ອງແມ່ຂ່າຍມີທີ່ຢູ່ທົ່ວໂລກ. ແຕ່ມັນສ້າງຄວາມຫຍຸ້ງຍາກສໍາລັບການເຊື່ອມຕໍ່ໂດຍກົງຂອງສອງ nodes ລະຫວ່າງ ຕ່າງ ເຄືອ​ຂ່າຍ​ສ່ວນ​ຕົວ​. ການເຊື່ອມຕໍ່ໂດຍກົງລະຫວ່າງສອງ nodes ແມ່ນສໍາຄັນສໍາລັບຄໍາຮ້ອງສະຫມັກ peer-to-peer ເຊັ່ນການສົ່ງສຽງ (Skype), ການເຂົ້າເຖິງຄອມພິວເຕີຈາກໄລຍະໄກ (TeamViewer), ຫຼືເກມອອນໄລນ໌.

ຫນຶ່ງໃນວິທີການທີ່ມີປະສິດທິພາບທີ່ສຸດສໍາລັບການສ້າງຕັ້ງການເຊື່ອມຕໍ່ peer-to-peer ລະຫວ່າງອຸປະກອນໃນເຄືອຂ່າຍເອກະຊົນທີ່ແຕກຕ່າງກັນແມ່ນເອີ້ນວ່າການເຈາະຮູ. ເຕັກນິກນີ້ຖືກນໍາໃຊ້ຫຼາຍທີ່ສຸດກັບຄໍາຮ້ອງສະຫມັກໂດຍອີງໃສ່ໂປໂຕຄອນ UDP.

ແຕ່ຖ້າຄໍາຮ້ອງສະຫມັກຂອງທ່ານຕ້ອງການການຮັບປະກັນການຈັດສົ່ງຂໍ້ມູນ, ຕົວຢ່າງ, ທ່ານໂອນໄຟລ໌ລະຫວ່າງຄອມພິວເຕີ, ຫຼັງຈາກນັ້ນການນໍາໃຊ້ UDP ຈະມີຄວາມຫຍຸ້ງຍາກຫຼາຍອັນເນື່ອງມາຈາກຄວາມຈິງທີ່ວ່າ UDP ບໍ່ແມ່ນໂປໂຕຄອນການຈັດສົ່ງທີ່ຮັບປະກັນແລະບໍ່ສະຫນອງການຈັດສົ່ງແພັກເກັດ, ບໍ່ຄືກັບ TCP. ພິທີການ.

ໃນກໍລະນີນີ້, ເພື່ອຮັບປະກັນການຈັດສົ່ງແພັກເກັດທີ່ຮັບປະກັນ, ມັນຈໍາເປັນຕ້ອງປະຕິບັດໂປໂຕຄອນຊັ້ນຄໍາຮ້ອງສະຫມັກທີ່ສະຫນອງການເຮັດວຽກທີ່ຈໍາເປັນແລະເຮັດວຽກຫຼາຍກວ່າ UDP.

ຂ້ອຍຕ້ອງການສັງເກດທັນທີວ່າມີເຕັກນິກການເຈາະຮູ TCP ສໍາລັບການສ້າງຕັ້ງການເຊື່ອມຕໍ່ TCP ລະຫວ່າງ nodes ໃນເຄືອຂ່າຍເອກະຊົນທີ່ແຕກຕ່າງກັນ, ແຕ່ເນື່ອງຈາກການຂາດການສະຫນັບສະຫນູນມັນໂດຍອຸປະກອນ NAT ຫຼາຍ, ມັນມັກຈະບໍ່ຖືວ່າເປັນວິທີຕົ້ນຕໍໃນການເຊື່ອມຕໍ່. ຂໍ້ດັ່ງກ່າວ.

ສໍາລັບສ່ວນທີ່ເຫຼືອຂອງບົດຄວາມນີ້, ຂ້າພະເຈົ້າຈະສຸມໃສ່ພຽງແຕ່ການປະຕິບັດຂອງອະນຸສັນຍາການຈັດສົ່ງທີ່ຮັບປະກັນ. ການປະຕິບັດເຕັກນິກການເຈາະຮູ UDP ຈະຖືກອະທິບາຍໄວ້ໃນບົດຄວາມຕໍ່ໄປນີ້.

ຂໍ້ກໍານົດພິທີການ

1. ການ​ຈັດ​ສົ່ງ​ຊອງ​ທີ່​ເຊື່ອ​ຖື​ໄດ້​ປະ​ຕິ​ບັດ​ໂດຍ​ຜ່ານ​ກົນ​ໄກ​ຄໍາ​ຄຶດ​ຄໍາ​ເຫັນ​ໃນ​ທາງ​ບວກ (ອັນ​ທີ່​ເອີ້ນ​ວ່າ​ການ​ຮັບ​ຮູ້​ໃນ​ທາງ​ບວກ​)
2. ຄວາມຕ້ອງການສໍາລັບການໂອນຂໍ້ມູນໃຫຍ່ທີ່ມີປະສິດທິພາບ, i.e. ໂປໂຕຄອນຕ້ອງຫຼີກເວັ້ນການສົ່ງຕໍ່ແພັກເກັດທີ່ບໍ່ຈໍາເປັນ
3. ມັນຄວນຈະເປັນໄປໄດ້ທີ່ຈະຍົກເລີກກົນໄກການຢືນຢັນການຈັດສົ່ງ (ຄວາມສາມາດໃນການເຮັດວຽກເປັນໂປໂຕຄອນ UDP "ບໍລິສຸດ").
4. ຄວາມສາມາດໃນການປະຕິບັດຮູບແບບຄໍາສັ່ງ, ດ້ວຍການຢືນຢັນຂອງແຕ່ລະຂໍ້ຄວາມ
5. ຫົວໜ່ວຍພື້ນຖານຂອງການໂອນຂໍ້ມູນຜ່ານໂປຣໂຕຄໍຕ້ອງເປັນຂໍ້ຄວາມ

ຂໍ້ກໍານົດເຫຼົ່ານີ້ສ່ວນຫຼາຍແມ່ນກົງກັນກັບຂໍ້ກໍານົດຂອງໂປໂຕຄອນຂໍ້ມູນທີ່ເຊື່ອຖືໄດ້ທີ່ໄດ້ອະທິບາຍໄວ້ໃນ rfc908 и rfc1151, ແລະຂ້າພະເຈົ້າໄດ້ອີງໃສ່ມາດຕະຖານເຫຼົ່ານັ້ນໃນເວລາທີ່ການພັດທະນາອະນຸສັນຍານີ້.

ເພື່ອເຂົ້າໃຈຄວາມຕ້ອງການເຫຼົ່ານີ້, ໃຫ້ພວກເຮົາເບິ່ງເວລາຂອງການໂອນຂໍ້ມູນລະຫວ່າງສອງໂຫນດເຄືອຂ່າຍໂດຍໃຊ້ໂປໂຕຄອນ TCP ແລະ UDP. ໃຫ້ໃນທັງສອງກໍລະນີ, ພວກເຮົາຈະສູນເສຍຊອງຫນຶ່ງ.
ການໂອນຂໍ້ມູນທີ່ບໍ່ມີການໂຕ້ຕອບຜ່ານ TCP:

ດັ່ງທີ່ເຈົ້າສາມາດເຫັນໄດ້ຈາກແຜນວາດ, ໃນກໍລະນີຂອງການສູນເສຍແພັກເກັດ, TCP ຈະກວດພົບແພັກເກັດທີ່ສູນເສຍແລະລາຍງານໃຫ້ຜູ້ສົ່ງໂດຍການຮ້ອງຂໍໃຫ້ມີຈໍານວນສ່ວນທີ່ສູນເສຍ.
ການໂອນຂໍ້ມູນຜ່ານ UDP Protocol:

UDP ບໍ່ໄດ້ດໍາເນີນຂັ້ນຕອນການກວດສອບການສູນເສຍໃດໆ. ການຄວບຄຸມຄວາມຜິດພາດຂອງລະບົບສາຍສົ່ງໃນອະນຸສັນຍາ UDP ແມ່ນຄວາມຮັບຜິດຊອບທັງຫມົດຂອງແອັບພລິເຄຊັນ.

ການກວດຫາຄວາມຜິດພາດໃນໂປໂຕຄອນ TCP ແມ່ນບັນລຸໄດ້ໂດຍການສ້າງຕັ້ງການເຊື່ອມຕໍ່ກັບໂຫນດສິ້ນສຸດ, ເກັບຮັກສາສະຖານະຂອງການເຊື່ອມຕໍ່ນັ້ນ, ຊີ້ບອກຈໍານວນ bytes ທີ່ສົ່ງໃນແຕ່ລະຫົວຂອງແພັກເກັດ, ແລະແຈ້ງໃບຮັບເງິນໂດຍໃຊ້ຕົວເລກການຮັບຮູ້.

ນອກຈາກນັ້ນ, ເພື່ອປັບປຸງການປະຕິບັດ (i. e. ສົ່ງຫຼາຍກວ່າຫນຶ່ງສ່ວນໂດຍບໍ່ໄດ້ຮັບການຍອມຮັບ), ໂປໂຕຄອນ TCP ໃຊ້ອັນທີ່ເອີ້ນວ່າປ່ອງຢ້ຽມສົ່ງ - ຈໍານວນ bytes ຂອງຂໍ້ມູນທີ່ຜູ້ສົ່ງຂອງ segment ຄາດວ່າຈະໄດ້ຮັບ.

ສໍາລັບຂໍ້ມູນເພີ່ມເຕີມກ່ຽວກັບ TCP protocol, ເບິ່ງ rfc793, ຈາກ UDP ກັບ rfc768ບ່ອນທີ່, ໃນຄວາມເປັນຈິງ, ພວກເຂົາເຈົ້າຖືກກໍານົດ.

ຈາກຂ້າງເທິງ, ມັນເປັນທີ່ຊັດເຈນວ່າເພື່ອສ້າງໂປໂຕຄອນການຈັດສົ່ງຂໍ້ຄວາມທີ່ເຊື່ອຖືໄດ້ຫຼາຍກວ່າ UDP (ຕໍ່ໄປນີ້ເອີ້ນວ່າ. UDP ທີ່ເຊື່ອຖືໄດ້), ມັນຈໍາເປັນຕ້ອງປະຕິບັດກົນໄກການໂອນຂໍ້ມູນທີ່ຄ້າຍຄືກັນກັບ TCP. ຄື:

• ບັນທຶກສະຖານະການເຊື່ອມຕໍ່
• ໃຊ້ເລກສ່ວນ
• ໃຊ້ຊຸດການຢືນຢັນພິເສດ
• ໃຊ້ກົນໄກ windowing ແບບງ່າຍດາຍເພື່ອເພີ່ມການສົ່ງຜ່ານໂປຣໂຕຄໍ

ນອກຈາກນັ້ນ, ທ່ານຕ້ອງການ:

• ສັນຍານການເລີ່ມຕົ້ນຂອງຂໍ້ຄວາມ, ເພື່ອຈັດສັນຊັບພະຍາກອນສໍາລັບການເຊື່ອມຕໍ່
• ສົ່ງສັນຍານການສິ້ນສຸດຂອງຂໍ້ຄວາມ, ເພື່ອຖ່າຍທອດຂໍ້ຄວາມທີ່ໄດ້ຮັບໄປຫາແອັບພລິເຄຊັນເທິງນ້ໍາແລະປ່ອຍຊັບພະຍາກອນໂປຣໂຕຄໍ
• ອະ​ນຸ​ຍາດ​ໃຫ້​ອະ​ນຸ​ຍາດ​ການ​ເຊື່ອມ​ຕໍ່​ສະ​ເພາະ​ເພື່ອ​ປິດ​ການ​ໃຊ້​ງານ​ກົນ​ໄກ​ການ​ຢັ້ງ​ຢືນ​ການ​ຈັດ​ສົ່ງ​ທີ່​ຈະ​ເຮັດ​ວຽກ​ເປັນ "ບໍ​ລິ​ສຸດ​" UDP

ສ່ວນຫົວ UDP ທີ່ເຊື່ອຖືໄດ້

ຈື່ໄວ້ວ່າ UDP datagram ແມ່ນ encapsulated ໃນ IP datagram. ແພັກເກັດ UDP ທີ່ເຊື່ອຖືໄດ້ແມ່ນ "ຫໍ່" ຢ່າງເຫມາະສົມເຂົ້າໄປໃນ UDP datagram.
ການຫຸ້ມຫໍ່ຫົວ UDP ທີ່ເຊື່ອຖືໄດ້:

ໂຄງສ້າງຂອງຫົວ UDP ທີ່ເຊື່ອຖືໄດ້ແມ່ນຂ້ອນຂ້າງງ່າຍດາຍ:

• ທຸງ - package control flags
• MessageType - ປະເພດຂໍ້ຄວາມທີ່ໃຊ້ໂດຍແອັບພລິເຄຊັນເທິງກະແສເພື່ອສະໝັກຮັບຂໍ້ຄວາມສະເພາະ
• TransmissionId - ຈໍາ​ນວນ​ຂອງ​ການ​ສົ່ງ​, ຮ່ວມ​ກັບ​ທີ່​ຢູ່​ແລະ​ພອດ​ຂອງ​ຜູ້​ຮັບ​, ເປັນ​ເອ​ກະ​ລັກ​ລະ​ບຸ​ການ​ເຊື່ອມ​ຕໍ່​.
• PacketNumber - ເລກແພັກເກັດ
• ຕົວເລືອກ - ຕົວເລືອກໂປຣໂຕຄໍເພີ່ມເຕີມ. ໃນກໍລະນີຂອງຊຸດທໍາອິດ, ມັນຖືກນໍາໃຊ້ເພື່ອຊີ້ບອກຂະຫນາດຂອງຂໍ້ຄວາມ

ທຸງ​ດັ່ງ​ຕໍ່​ໄປ​ນີ້​:

• FirstPacket - ຊຸດທໍາອິດຂອງຂໍ້ຄວາມ
• NoAsk - ຂໍ້ຄວາມບໍ່ຮຽກຮ້ອງໃຫ້ມີກົນໄກການຮັບຮູ້ເພື່ອເປີດໃຊ້ງານ
• LastPacket - ຊຸດສຸດທ້າຍຂອງຂໍ້ຄວາມ
• RequestForPacket - ຊຸດ​ການ​ຢັ້ງ​ຢືນ​ຫຼື​ການ​ຮ້ອງ​ຂໍ​ສໍາ​ລັບ​ການ​ສູນ​ເສຍ​ຊອງ​

ຫຼັກການທົ່ວໄປຂອງອະນຸສັນຍາ

ເນື່ອງຈາກ UDP ທີ່ເຊື່ອຖືໄດ້ແມ່ນສຸມໃສ່ການຮັບປະກັນການສົ່ງຂໍ້ຄວາມລະຫວ່າງສອງ nodes, ມັນຕ້ອງສາມາດສ້າງການເຊື່ອມຕໍ່ກັບອີກດ້ານຫນຶ່ງ. ເພື່ອສ້າງການເຊື່ອມຕໍ່, ຜູ້ສົ່ງຈະສົ່ງແພັກເກັດທີ່ມີທຸງ FirstPacket, ຄໍາຕອບທີ່ຈະຫມາຍຄວາມວ່າການເຊື່ອມຕໍ່ໄດ້ຖືກສ້າງຕັ້ງຂຶ້ນ. ແພັກເກັດຮັບການຕອບຮັບທັງໝົດ, ຫຼືເວົ້າອີກຢ່າງໜຶ່ງ, ແພັກເກັດຮັບການຮັບຮູ້, ກຳນົດຄ່າຂອງຊ່ອງ PacketNumber ສະເໝີເປັນໜຶ່ງຫຼາຍກວ່າຄ່າ PacketNumber ທີ່ໃຫຍ່ທີ່ສຸດຂອງແພັກເກັດທີ່ໄດ້ຮັບສຳເລັດ. ຊ່ອງຕົວເລືອກສໍາລັບແພັກເກັດທໍາອິດທີ່ສົ່ງແມ່ນຂະຫນາດຂອງຂໍ້ຄວາມ.

ກົນໄກທີ່ຄ້າຍຄືກັນແມ່ນໃຊ້ເພື່ອຢຸດການເຊື່ອມຕໍ່. ທຸງ LastPacket ຖືກຕັ້ງຢູ່ໃນແພັກເກັດສຸດທ້າຍຂອງຂໍ້ຄວາມ. ໃນຊອງຕອບຮັບ, ຕົວເລກຂອງຊອງສຸດທ້າຍ + 1 ແມ່ນຊີ້ໃຫ້ເຫັນ, ເຊິ່ງສໍາລັບດ້ານທີ່ໄດ້ຮັບຫມາຍຄວາມວ່າການຈັດສົ່ງຂໍ້ຄວາມສົບຜົນສໍາເລັດ.
ແຜນ​ວາດ​ການ​ສ້າງ​ຕັ້ງ​ແລະ​ການ​ສິ້ນ​ສຸດ​ການ​ເຊື່ອມ​ຕໍ່​:

ເມື່ອການເຊື່ອມຕໍ່ໄດ້ຖືກສ້າງຕັ້ງຂຶ້ນ, ການໂອນຂໍ້ມູນເລີ່ມຕົ້ນ. ຂໍ້​ມູນ​ແມ່ນ​ໄດ້​ຮັບ​ການ​ສົ່ງ​ອອກ​ໃນ​ຕັນ​ຂອງ​ຊອງ​. ແຕ່ລະບລັອກ, ຍົກເວັ້ນອັນສຸດທ້າຍ, ມີຈໍານວນແພັກເກັດຄົງທີ່. ມັນເທົ່າກັບຂະຫນາດປ່ອງຢ້ຽມຮັບ / ສົ່ງ. ຂໍ້ມູນບລັອກສຸດທ້າຍອາດມີແພັກເກັດໜ້ອຍລົງ. ຫຼັງຈາກການສົ່ງແຕ່ລະຕັນ, ຝ່າຍສົ່ງລໍຖ້າການຢືນຢັນການຈັດສົ່ງຫຼືການຮ້ອງຂໍໃຫ້ສົ່ງຄືນແພັກເກັດທີ່ສູນເສຍໄປ, ເຮັດໃຫ້ປ່ອງຢ້ຽມຮັບ / ສົ່ງເປີດເພື່ອຮັບຄໍາຕອບ. ຫຼັງ​ຈາກ​ໄດ້​ຮັບ​ການ​ຢືນ​ຢັນ​ການ​ຈັດ​ສົ່ງ block, ການ​ຮັບ / ສົ່ງ​ປ່ອງ​ຢ້ຽມ​ປ່ຽນ​ແລະ​ການ​ຕໍ່​ໄປ​ຂອງ​ຂໍ້​ມູນ​ໄດ້​ຖືກ​ສົ່ງ​ໄປ​.

ດ້ານທີ່ໄດ້ຮັບແມ່ນໄດ້ຮັບຊອງ. ແຕ່ລະແພັກເກັດຖືກກວດສອບເພື່ອເບິ່ງວ່າມັນຕົກຢູ່ໃນປ່ອງຢ້ຽມສົ່ງ. ການຫຸ້ມຫໍ່ແລະຊ້ໍາກັນທີ່ບໍ່ຕົກຢູ່ໃນປ່ອງຢ້ຽມແມ່ນການກັ່ນຕອງອອກ. ເນື່ອງຈາກວ່າ ຖ້າຂະຫນາດຂອງປ່ອງຢ້ຽມຖືກແກ້ໄຂແລະຄືກັນສໍາລັບຜູ້ຮັບແລະຜູ້ສົ່ງ, ຫຼັງຈາກນັ້ນ, ໃນກໍລະນີຂອງຕັນຂອງແພັກເກັດຖືກສົ່ງໂດຍບໍ່ມີການສູນເສຍ, ປ່ອງຢ້ຽມຈະຖືກປ່ຽນໄປເພື່ອຮັບແພັກເກັດຂອງຂໍ້ມູນຕໍ່ໄປແລະການຢືນຢັນການຈັດສົ່ງແມ່ນ. ສົ່ງ. ຖ້າປ່ອງຢ້ຽມບໍ່ຕື່ມຂໍ້ມູນພາຍໃນໄລຍະເວລາທີ່ກໍານົດໄວ້ໂດຍເຄື່ອງຈັບເວລາເຮັດວຽກ, ຫຼັງຈາກນັ້ນການກວດສອບຈະຖືກເລີ່ມຕົ້ນທີ່ແພັກເກັດທີ່ຍັງບໍ່ໄດ້ສົ່ງແລະຄໍາຮ້ອງຂໍການຈັດສົ່ງຄືນຈະຖືກສົ່ງ.
ແຜນວາດການສົ່ງຕໍ່:

ໝົດເວລາ ແລະເຄື່ອງຈັບເວລາໂປຣໂຕຄໍ

ມີຫຼາຍເຫດຜົນວ່າເປັນຫຍັງການເຊື່ອມຕໍ່ບໍ່ສາມາດຖືກສ້າງຕັ້ງຂຶ້ນ. ຕົວຢ່າງ, ຖ້າຝ່າຍຮັບແມ່ນອອບໄລນ໌. ໃນກໍລະນີນີ້, ເມື່ອພະຍາຍາມສ້າງການເຊື່ອມຕໍ່, ການເຊື່ອມຕໍ່ຈະຖືກປິດໂດຍຫມົດເວລາ. ການປະຕິບັດ UDP ທີ່ເຊື່ອຖືໄດ້ໃຊ້ສອງຕົວຈັບເວລາເພື່ອກໍານົດເວລາຫມົດເວລາ. ທໍາອິດ, ເຄື່ອງຈັບເວລາເຮັດວຽກ, ຖືກນໍາໃຊ້ເພື່ອລໍຖ້າການຕອບສະຫນອງຈາກເຈົ້າພາບຫ່າງໄກສອກຫຼີກ. ຖ້າມັນໄຟໄຫມ້ຢູ່ຂ້າງຜູ້ສົ່ງ, ຫຼັງຈາກນັ້ນແພັກເກັດທີ່ສົ່ງສຸດທ້າຍແມ່ນ resent. ຖ້າເຄື່ອງຈັບເວລາໝົດອາຍຸຢູ່ຜູ້ຮັບ, ການກວດສອບແພັກເກັດທີ່ສູນຫາຍຈະຖືກປະຕິບັດ ແລະ ການຮ້ອງຂໍການຈັດສົ່ງຄືນຈະຖືກສົ່ງ.

ເຄື່ອງຈັບເວລາທີສອງແມ່ນຈໍາເປັນເພື່ອປິດການເຊື່ອມຕໍ່ໃນກໍລະນີທີ່ຂາດການສື່ສານລະຫວ່າງໂຫນດ. ສໍາລັບຝ່າຍຜູ້ສົ່ງ, ມັນເລີ່ມຕົ້ນທັນທີຫຼັງຈາກເວລາເຮັດວຽກຫມົດອາຍຸ, ແລະລໍຖ້າການຕອບສະຫນອງຈາກ node ຫ່າງໄກສອກຫຼີກ. ຖ້າບໍ່ມີການຕອບສະຫນອງພາຍໃນໄລຍະເວລາທີ່ກໍານົດ, ການເຊື່ອມຕໍ່ຖືກປິດແລະຊັບພະຍາກອນຖືກປ່ອຍອອກມາ. ສໍາລັບດ້ານການຮັບ, ເຄື່ອງຈັບເວລາໃກ້ຊິດຂອງການເຊື່ອມຕໍ່ແມ່ນເລີ່ມຕົ້ນຫຼັງຈາກເວລາເຮັດວຽກຫມົດອາຍຸສອງຄັ້ງ. ນີ້ແມ່ນສິ່ງຈໍາເປັນເພື່ອຮັບປະກັນການສູນເສຍຊຸດການຢືນຢັນ. ເມື່ອເຄື່ອງຈັບເວລາຫມົດອາຍຸ, ການເຊື່ອມຕໍ່ກໍ່ຖືກປິດແລະຊັບພະຍາກອນຖືກປ່ອຍອອກມາ.

ແຜນວາດສະຖານະສາຍສົ່ງ UDP ທີ່ເຊື່ອຖືໄດ້

ຫຼັກການຂອງໂປໂຕຄອນຖືກປະຕິບັດຢູ່ໃນເຄື່ອງຂອງລັດທີ່ຈໍາກັດ, ແຕ່ລະລັດທີ່ຮັບຜິດຊອບຕໍ່ເຫດຜົນທີ່ແນ່ນອນຂອງການປຸງແຕ່ງແພັກເກັດ.
ແຜນວາດລັດ UDP ທີ່ເຊື່ອຖືໄດ້:

ປິດ - ບໍ່ແມ່ນລັດແທ້ໆ, ມັນເປັນຈຸດເລີ່ມຕົ້ນແລະຈຸດສິ້ນສຸດຂອງ automaton. ສໍາລັບລັດ ປິດ ຕັນຄວບຄຸມລະບົບສາຍສົ່ງແມ່ນໄດ້ຮັບ, ເຊິ່ງ, ການປະຕິບັດເຄື່ອງແມ່ຂ່າຍ UDP asynchronous, ສົ່ງຕໍ່ແພັກເກັດໄປຫາການເຊື່ອມຕໍ່ທີ່ເຫມາະສົມແລະເລີ່ມຕົ້ນການປຸງແຕ່ງຂອງລັດ.

FirstPacketSending – ສະຖານະເບື້ອງຕົ້ນທີ່ການເຊື່ອມຕໍ່ຂາອອກແມ່ນເມື່ອຂໍ້ຄວາມຖືກສົ່ງ.

ໃນສະຖານະນີ້, ຊຸດທໍາອິດສໍາລັບຂໍ້ຄວາມປົກກະຕິແມ່ນຖືກສົ່ງໄປ. ສໍາລັບຂໍ້ຄວາມທີ່ບໍ່ມີການຢືນຢັນການສົ່ງ, ນີ້ແມ່ນສະຖານະດຽວທີ່ຂໍ້ຄວາມທັງຫມົດຖືກສົ່ງໄປ.

ວົງຈອນການສົ່ງ – ພື້ນ​ຖານ​ສະ​ຖາ​ນະ​ການ​ສໍາ​ລັບ​ການ​ສົ່ງ​ຂອງ​ຊອງ​ຂໍ້​ຄວາມ​.

ການຫັນປ່ຽນໄປຈາກລັດ FirstPacketSending ປະຕິບັດຫຼັງຈາກຊຸດທໍາອິດຂອງຂໍ້ຄວາມໄດ້ຖືກສົ່ງ. ມັນແມ່ນຢູ່ໃນສະຖານະນີ້ວ່າການຮັບຮູ້ແລະການຮ້ອງຂໍທັງຫມົດສໍາລັບ retransmissions ມາ. ການອອກຈາກມັນເປັນໄປໄດ້ໃນສອງກໍລະນີ - ໃນກໍລະນີຂອງການສົ່ງຂໍ້ຄວາມສົບຜົນສໍາເລັດຫຼືເວລາຫມົດເວລາ.

FirstPacket ໄດ້ຮັບ - ສະຖານະເບື້ອງຕົ້ນສຳລັບຜູ້ຮັບຂໍ້ຄວາມ.

ມັນກວດສອບຄວາມຖືກຕ້ອງຂອງການເລີ່ມຕົ້ນຂອງການສົ່ງຕໍ່, ສ້າງໂຄງສ້າງທີ່ຈໍາເປັນ, ແລະສົ່ງການຮັບຮູ້ການຮັບຂອງຊຸດທໍາອິດ.

ສໍາລັບຂໍ້ຄວາມທີ່ປະກອບດ້ວຍຊອງດຽວແລະຖືກສົ່ງໂດຍບໍ່ມີການນໍາໃຊ້ຫຼັກຖານສະແດງການຈັດສົ່ງ, ນີ້ແມ່ນລັດດຽວ. ຫຼັງຈາກການປະມວນຜົນຂໍ້ຄວາມດັ່ງກ່າວ, ການເຊື່ອມຕໍ່ຖືກປິດ.

ການຕິດຕັ້ງ - ລັດ​ພື້ນ​ຖານ​ສໍາ​ລັບ​ການ​ໄດ້​ຮັບ​ຊອງ​ຂໍ້​ຄວາມ​.

ມັນຂຽນແພັກເກັດໃສ່ບ່ອນເກັບມ້ຽນຊົ່ວຄາວ, ກວດເບິ່ງການສູນເສຍແພັກເກັດ, ສົ່ງການຮັບຮູ້ສໍາລັບການຈັດສົ່ງຊອງແພັກເກັດແລະຂໍ້ຄວາມທັງຫມົດ, ແລະສົ່ງຄໍາຮ້ອງຂໍການຈັດສົ່ງຄືນຂອງແພັກເກັດທີ່ສູນເສຍ. ໃນກໍລະນີທີ່ໄດ້ຮັບຜົນສໍາເລັດຂອງຂໍ້ຄວາມທັງຫມົດ, ການເຊື່ອມຕໍ່ເຂົ້າໄປໃນລັດ ສໍາເລັດຖ້າບໍ່ດັ່ງນັ້ນ, ການໝົດເວລາອອກ.

ສໍາເລັດ - ປິດການເຊື່ອມຕໍ່ໃນກໍລະນີທີ່ໄດ້ຮັບຂໍ້ຄວາມທັງໝົດສຳເລັດ.

ລັດນີ້ແມ່ນມີຄວາມຈໍາເປັນສໍາລັບການຊຸມນຸມຂອງຂໍ້ຄວາມແລະສໍາລັບກໍລະນີໃນເວລາທີ່ການຢັ້ງຢືນການຈັດສົ່ງຂອງຂໍ້ຄວາມໄດ້ສູນເສຍໄປໃນທາງກັບຜູ້ສົ່ງ. ສະຖານະນີ້ຖືກປິດໄວ້ໂດຍການໝົດເວລາ, ແຕ່ການເຊື່ອມຕໍ່ຖືກຖືວ່າປິດຢ່າງສຳເລັດຜົນ.

ເລິກເຂົ້າໄປໃນລະຫັດ. ຫນ່ວຍ​ຄວບ​ຄຸມ​ສາຍ​ສົ່ງ​

ຫນຶ່ງໃນອົງປະກອບທີ່ສໍາຄັນຂອງ UDP ທີ່ເຊື່ອຖືໄດ້ແມ່ນຕັນຄວບຄຸມລະບົບສາຍສົ່ງ. ວຽກງານຂອງຕັນນີ້ແມ່ນເພື່ອເກັບຮັກສາການເຊື່ອມຕໍ່ໃນປະຈຸບັນແລະອົງປະກອບຊ່ວຍ, ແຈກຢາຍແພັກເກັດທີ່ເຂົ້າມາໃນການເຊື່ອມຕໍ່ທີ່ສອດຄ້ອງກັນ, ສະຫນອງການໂຕ້ຕອບສໍາລັບການສົ່ງແພັກເກັດໄປຫາການເຊື່ອມຕໍ່, ແລະປະຕິບັດ API ຂອງໂປໂຕຄອນ. ບລັອກຄວບຄຸມລະບົບສາຍສົ່ງໄດ້ຮັບແພັກເກັດຈາກຊັ້ນ UDP ແລະສົ່ງຕໍ່ໄປຫາເຄື່ອງຂອງລັດເພື່ອປະມວນຜົນ. ເພື່ອໃຫ້ໄດ້ຮັບແພັກເກັດ, ມັນປະຕິບັດເຄື່ອງແມ່ຂ່າຍ UDP ແບບ asynchronous.
ສະມາຊິກບາງຄົນຂອງຫ້ອງຮຽນ ReliableUdpConnectionControlBlock:

internal class ReliableUdpConnectionControlBlock : IDisposable
{
  // массив байт для указанного ключа. Используется для сборки входящих сообщений    
  public ConcurrentDictionary<Tuple<EndPoint, Int32>, byte[]> IncomingStreams { get; private set;}
  // массив байт для указанного ключа. Используется для отправки исходящих сообщений.
  public ConcurrentDictionary<Tuple<EndPoint, Int32>, byte[]> OutcomingStreams { get; private set; }
  // connection record для указанного ключа.
  private readonly ConcurrentDictionary<Tuple<EndPoint, Int32>, ReliableUdpConnectionRecord> m_listOfHandlers;
  // список подписчиков на сообщения.
  private readonly List<ReliableUdpSubscribeObject> m_subscribers;    
  // локальный сокет    
  private Socket m_socketIn;
  // порт для входящих сообщений
  private int m_port;
  // локальный IP адрес
  private IPAddress m_ipAddress;    
  // локальная конечная точка    
  public IPEndPoint LocalEndpoint { get; private set; }    
  // коллекция предварительно инициализированных
  // состояний конечного автомата
  public StatesCollection States { get; private set; }
  // генератор случайных чисел. Используется для создания TransmissionId
  private readonly RNGCryptoServiceProvider m_randomCrypto;    	
  //...
}

ການປະຕິບັດຂອງເຄື່ອງແມ່ຂ່າຍ UDP asynchronous:

private void Receive()
{
  EndPoint connectedClient = new IPEndPoint(IPAddress.Any, 0);
  // создаем новый буфер, для каждого socket.BeginReceiveFrom 
  byte[] buffer = new byte[DefaultMaxPacketSize + ReliableUdpHeader.Length];
  // передаем буфер в качестве параметра для асинхронного метода
  this.m_socketIn.BeginReceiveFrom(buffer, 0, buffer.Length, SocketFlags.None, ref connectedClient, EndReceive, buffer);
}   

private void EndReceive(IAsyncResult ar)
{
  EndPoint connectedClient = new IPEndPoint(IPAddress.Any, 0);
  int bytesRead = this.m_socketIn.EndReceiveFrom(ar, ref connectedClient);
  //пакет получен, готовы принимать следующий        
  Receive();
  // т.к. простейший способ решить вопрос с буфером - получить ссылку на него 
  // из IAsyncResult.AsyncState        
  byte[] bytes = ((byte[]) ar.AsyncState).Slice(0, bytesRead);
  // получаем заголовок пакета        
  ReliableUdpHeader header;
  if (!ReliableUdpStateTools.ReadReliableUdpHeader(bytes, out header))
  {          
    // пришел некорректный пакет - отбрасываем его
    return;
  }
  // конструируем ключ для определения connection record’а для пакета
  Tuple<EndPoint, Int32> key = new Tuple<EndPoint, Int32>(connectedClient, header.TransmissionId);
  // получаем существующую connection record или создаем новую
  ReliableUdpConnectionRecord record = m_listOfHandlers.GetOrAdd(key, new ReliableUdpConnectionRecord(key, this, header.ReliableUdpMessageType));
  // запускаем пакет в обработку в конечный автомат
  record.State.ReceivePacket(record, header, bytes);
}

ສໍາລັບແຕ່ລະການໂອນຂໍ້ຄວາມ, ໂຄງສ້າງຖືກສ້າງຂື້ນທີ່ປະກອບດ້ວຍຂໍ້ມູນກ່ຽວກັບການເຊື່ອມຕໍ່. ໂຄງສ້າງດັ່ງກ່າວເອີ້ນວ່າ ບັນທຶກການເຊື່ອມຕໍ່.
ສະມາຊິກບາງຄົນຂອງຫ້ອງຮຽນ ReliableUdpConnectionRecord:

internal class ReliableUdpConnectionRecord : IDisposable
{    
  // массив байт с сообщением    
  public byte[] IncomingStream { get; set; }
  // ссылка на состояние конечного автомата    
  public ReliableUdpState State { get; set; }    
  // пара, однозначно определяющая connection record
  // в блоке управления передачей     
  public Tuple<EndPoint, Int32> Key { get; private set;}
  // нижняя граница приемного окна    
  public int WindowLowerBound;
  // размер окна передачи
  public readonly int WindowSize;     
  // номер пакета для отправки
  public int SndNext;
  // количество пакетов для отправки
  public int NumberOfPackets;
  // номер передачи (именно он и есть вторая часть Tuple)
  // для каждого сообщения свой	
  public readonly Int32 TransmissionId;
  // удаленный IP endpoint – собственно получатель сообщения
  public readonly IPEndPoint RemoteClient;
  // размер пакета, во избежание фрагментации на IP уровне
  // не должен превышать MTU – (IP.Header + UDP.Header + RelaibleUDP.Header)
  public readonly int BufferSize;
  // блок управления передачей
  public readonly ReliableUdpConnectionControlBlock Tcb;
  // инкапсулирует результаты асинхронной операции для BeginSendMessage/EndSendMessage
  public readonly AsyncResultSendMessage AsyncResult;
  // не отправлять пакеты подтверждения
  public bool IsNoAnswerNeeded;
  // последний корректно полученный пакет (всегда устанавливается в наибольший номер)
  public int RcvCurrent;
  // массив с номерами потерянных пакетов
  public int[] LostPackets { get; private set; }
  // пришел ли последний пакет. Используется как bool.
  public int IsLastPacketReceived = 0;
  //...
}

ເລິກເຂົ້າໄປໃນລະຫັດ. ລັດ

ລັດປະຕິບັດເຄື່ອງຈັກຂອງລັດຂອງອະນຸສັນຍາ UDP ທີ່ເຊື່ອຖືໄດ້, ບ່ອນທີ່ການປະມວນຜົນຕົ້ນຕໍຂອງແພັກເກັດເກີດຂຶ້ນ. ຫ້ອງຮຽນ abstract ReliableUdpState ສະຫນອງການໂຕ້ຕອບສໍາລັບລັດ:

ເຫດຜົນທັງຫມົດຂອງໂປໂຕຄອນແມ່ນປະຕິບັດໂດຍຊັ້ນຮຽນທີ່ນໍາສະເຫນີຂ້າງເທິງ, ພ້ອມກັບຊັ້ນຊ່ວຍທີ່ສະຫນອງວິທີການສະຖິດ, ເຊັ່ນ: ການສ້າງສ່ວນຫົວ ReliableUdp ຈາກບັນທຶກການເຊື່ອມຕໍ່.

ຕໍ່ໄປ, ພວກເຮົາຈະພິຈາລະນາຢ່າງລະອຽດກ່ຽວກັບການປະຕິບັດວິທີການໂຕ້ຕອບທີ່ກໍານົດສູດການຄິດໄລ່ພື້ນຖານຂອງໂປໂຕຄອນ.

ວິທີ DisposeByTimeout

ວິທີການ DisposeByTimeout ແມ່ນຮັບຜິດຊອບສໍາລັບການປ່ອຍຊັບພະຍາກອນການເຊື່ອມຕໍ່ຫຼັງຈາກຫມົດເວລາແລະສໍາລັບສັນຍານການສົ່ງຂໍ້ຄວາມສົບຜົນສໍາເລັດ / ບໍ່ສໍາເລັດ.
ReliableUdpState.DisposeByTimeout:

protected virtual void DisposeByTimeout(object record)
{
  ReliableUdpConnectionRecord connectionRecord = (ReliableUdpConnectionRecord) record;      
  if (record.AsyncResult != null)
  {
    connectionRecord.AsyncResult.SetAsCompleted(false);
  }
  connectionRecord.Dispose();
}

ມັນພຽງແຕ່ overridden ໃນລັດ ສໍາເລັດ.
ສຳເລັດແລ້ວ.DisposeByTimeout:

protected override void DisposeByTimeout(object record)
{
  ReliableUdpConnectionRecord connectionRecord = (ReliableUdpConnectionRecord) record;
  // сообщаем об успешном получении сообщения
  SetAsCompleted(connectionRecord);        
}

ProcessPackets ວິທີການ

ວິທີການ ProcessPackets ແມ່ນຮັບຜິດຊອບສໍາລັບການປະມວນຜົນເພີ່ມເຕີມຂອງຊຸດຫຼືຊຸດ. ໂທຫາໂດຍກົງຫຼືຜ່ານເຄື່ອງຈັບເວລາລໍຖ້າແພັກເກັດ.

ສາມາດ ການຕິດຕັ້ງ ວິທີການແມ່ນ overridden ແລະຮັບຜິດຊອບໃນການກວດສອບຊຸດທີ່ສູນເສຍແລະການຫັນປ່ຽນໄປສູ່ລັດ ສໍາເລັດ, ໃນກໍລະນີທີ່ໄດ້ຮັບຊອງສຸດທ້າຍແລະຜ່ານການກວດສອບສົບຜົນສໍາເລັດ
Assembling.ProcessPackets:

public override void ProcessPackets(ReliableUdpConnectionRecord connectionRecord)
{
  if (connectionRecord.IsDone != 0)
    return;
  if (!ReliableUdpStateTools.CheckForNoPacketLoss(connectionRecord, connectionRecord.IsLastPacketReceived != 0))
  {
    // есть потерянные пакеты, отсылаем запросы на них
    foreach (int seqNum in connectionRecord.LostPackets)
    {
      if (seqNum != 0)
      {
        ReliableUdpStateTools.SendAskForLostPacket(connectionRecord, seqNum);
      }
    }
    // устанавливаем таймер во второй раз, для повторной попытки передачи
    if (!connectionRecord.TimerSecondTry)
    {
      connectionRecord.WaitForPacketsTimer.Change(connectionRecord.ShortTimerPeriod, -1);
      connectionRecord.TimerSecondTry = true;
      return;
    }
    // если после двух попыток срабатываний WaitForPacketTimer 
    // не удалось получить пакеты - запускаем таймер завершения соединения
    StartCloseWaitTimer(connectionRecord);
  }
  else if (connectionRecord.IsLastPacketReceived != 0)
  // успешная проверка 
  {
    // высылаем подтверждение о получении блока данных
    ReliableUdpStateTools.SendAcknowledgePacket(connectionRecord);
    connectionRecord.State = connectionRecord.Tcb.States.Completed;
    connectionRecord.State.ProcessPackets(connectionRecord);
    // вместо моментальной реализации ресурсов
    // запускаем таймер, на случай, если
    // если последний ack не дойдет до отправителя и он запросит его снова.
    // по срабатыванию таймера - реализуем ресурсы
    // в состоянии Completed метод таймера переопределен
    StartCloseWaitTimer(connectionRecord);
  }
  // это случай, когда ack на блок пакетов был потерян
  else
  {
    if (!connectionRecord.TimerSecondTry)
    {
      ReliableUdpStateTools.SendAcknowledgePacket(connectionRecord);
      connectionRecord.WaitForPacketsTimer.Change(connectionRecord.ShortTimerPeriod, -1);
      connectionRecord.TimerSecondTry = true;
      return;
    }
    // запускаем таймер завершения соединения
    StartCloseWaitTimer(connectionRecord);
  }
}

ສາມາດ ວົງຈອນການສົ່ງ ວິທີການນີ້ແມ່ນເອີ້ນວ່າພຽງແຕ່ຈັບເວລາ, ແລະຮັບຜິດຊອບສໍາລັບການສົ່ງຄືນຂໍ້ຄວາມສຸດທ້າຍ, ເຊັ່ນດຽວກັນກັບການເຮັດໃຫ້ການເຊື່ອມຕໍ່ຈັບເວລາໃກ້ຊິດ.
SendingCycle.ProcessPackets:

public override void ProcessPackets(ReliableUdpConnectionRecord connectionRecord)
{
  if (connectionRecord.IsDone != 0)
    return;        
  // отправляем повторно последний пакет 
  // ( в случае восстановления соединения узел-приемник заново отправит запросы, которые до него не дошли)        
  ReliableUdpStateTools.SendPacket(connectionRecord, ReliableUdpStateTools.RetransmissionCreateUdpPayload(connectionRecord, connectionRecord.SndNext - 1));
  // включаем таймер CloseWait – для ожидания восстановления соединения или его завершения
  StartCloseWaitTimer(connectionRecord);
}

ສາມາດ ສໍາເລັດ ວິທີການຢຸດເຊົາການຈັບເວລາແລ່ນແລະສົ່ງຂໍ້ຄວາມໄປຫາຜູ້ຈອງ.
ສຳເລັດແລ້ວ.ProcessPackets:

public override void ProcessPackets(ReliableUdpConnectionRecord connectionRecord)
{
  if (connectionRecord.WaitForPacketsTimer != null)
    connectionRecord.WaitForPacketsTimer.Dispose();
  // собираем сообщение и передаем его подписчикам
  ReliableUdpStateTools.CreateMessageFromMemoryStream(connectionRecord);
}

ວິທີການຮັບ Packet

ສາມາດ FirstPacket ໄດ້ຮັບ ວຽກງານຕົ້ນຕໍຂອງວິທີການແມ່ນເພື່ອກໍານົດວ່າຊຸດຂໍ້ຄວາມທໍາອິດມາຮອດໃນການໂຕ້ຕອບ, ແລະຍັງເກັບກໍາຂໍ້ຄວາມທີ່ປະກອບດ້ວຍຊອງດຽວ.
FirstPacketReceived.ReceivePacket:

public override void ReceivePacket(ReliableUdpConnectionRecord connectionRecord, ReliableUdpHeader header, byte[] payload)
{
  if (!header.Flags.HasFlag(ReliableUdpHeaderFlags.FirstPacket))
    // отбрасываем пакет
    return;
  // комбинация двух флагов - FirstPacket и LastPacket - говорит что у нас единственное сообщение
  if (header.Flags.HasFlag(ReliableUdpHeaderFlags.FirstPacket) &
      header.Flags.HasFlag(ReliableUdpHeaderFlags.LastPacket))
  {
    ReliableUdpStateTools.CreateMessageFromSinglePacket(connectionRecord, header, payload.Slice(ReliableUdpHeader.Length, payload.Length));
    if (!header.Flags.HasFlag(ReliableUdpHeaderFlags.NoAsk))
    {
      // отправляем пакет подтверждение          
      ReliableUdpStateTools.SendAcknowledgePacket(connectionRecord);
    }
    SetAsCompleted(connectionRecord);
    return;
  }
  // by design все packet numbers начинаются с 0;
  if (header.PacketNumber != 0)          
    return;
  ReliableUdpStateTools.InitIncomingBytesStorage(connectionRecord, header);
  ReliableUdpStateTools.WritePacketData(connectionRecord, header, payload);
  // считаем кол-во пакетов, которые должны прийти
  connectionRecord.NumberOfPackets = (int)Math.Ceiling((double) ((double) connectionRecord.IncomingStream.Length/(double) connectionRecord.BufferSize));
  // записываем номер последнего полученного пакета (0)
  connectionRecord.RcvCurrent = header.PacketNumber;
  // после сдвинули окно приема на 1
  connectionRecord.WindowLowerBound++;
  // переключаем состояние
  connectionRecord.State = connectionRecord.Tcb.States.Assembling;
  // если не требуется механизм подтверждение
  // запускаем таймер который высвободит все структуры         
  if (header.Flags.HasFlag(ReliableUdpHeaderFlags.NoAsk))
  {
    connectionRecord.CloseWaitTimer = new Timer(DisposeByTimeout, connectionRecord, connectionRecord.ShortTimerPeriod, -1);
  }
  else
  {
    ReliableUdpStateTools.SendAcknowledgePacket(connectionRecord);
    connectionRecord.WaitForPacketsTimer = new Timer(CheckByTimer, connectionRecord, connectionRecord.ShortTimerPeriod, -1);
  }
}

ສາມາດ ວົງຈອນການສົ່ງ ວິທີການນີ້ແມ່ນ overridden ເພື່ອຍອມຮັບການຈັດສົ່ງແລະການຮ້ອງຂໍ retransmission.
SendingCycle.ReceivePacket:

public override void ReceivePacket(ReliableUdpConnectionRecord connectionRecord, ReliableUdpHeader header, byte[] payload)
{
  if (connectionRecord.IsDone != 0)
    return;
  if (!header.Flags.HasFlag(ReliableUdpHeaderFlags.RequestForPacket))
    return;
  // расчет конечной границы окна
  // берется граница окна + 1, для получения подтверждений доставки
  int windowHighestBound = Math.Min((connectionRecord.WindowLowerBound + connectionRecord.WindowSize), (connectionRecord.NumberOfPackets));
  // проверка на попадание в окно        
  if (header.PacketNumber < connectionRecord.WindowLowerBound || header.PacketNumber > windowHighestBound)
    return;
  connectionRecord.WaitForPacketsTimer.Change(connectionRecord.ShortTimerPeriod, -1);
  if (connectionRecord.CloseWaitTimer != null)
    connectionRecord.CloseWaitTimer.Change(-1, -1);
  // проверить на последний пакет:
  if (header.PacketNumber == connectionRecord.NumberOfPackets)
  {
    // передача завершена
    Interlocked.Increment(ref connectionRecord.IsDone);
    SetAsCompleted(connectionRecord);
    return;
  }
  // это ответ на первый пакет c подтверждением         
  if ((header.Flags.HasFlag(ReliableUdpHeaderFlags.FirstPacket) && header.PacketNumber == 1))
  {
    // без сдвига окна
    SendPacket(connectionRecord);
  }
  // пришло подтверждение о получении блока данных
  else if (header.PacketNumber == windowHighestBound)
  {
    // сдвигаем окно прием/передачи
    connectionRecord.WindowLowerBound += connectionRecord.WindowSize;
    // обнуляем массив контроля передачи
    connectionRecord.WindowControlArray.Nullify();
    // отправляем блок пакетов
    SendPacket(connectionRecord);
  }
  // это запрос на повторную передачу – отправляем требуемый пакет          
  else
    ReliableUdpStateTools.SendPacket(connectionRecord, ReliableUdpStateTools.RetransmissionCreateUdpPayload(connectionRecord, header.PacketNumber));
}

ສາມາດ ການຕິດຕັ້ງ ໃນວິທີການ ReceivePacket, ການເຮັດວຽກຕົ້ນຕໍຂອງການປະກອບຂໍ້ຄວາມຈາກແພັກເກັດທີ່ເຂົ້າມາແມ່ນເກີດຂື້ນ.
Assembling.ReceivePacket:

public override void ReceivePacket(ReliableUdpConnectionRecord connectionRecord, ReliableUdpHeader header, byte[] payload)
{
  if (connectionRecord.IsDone != 0)
    return;
  // обработка пакетов с отключенным механизмом подтверждения доставки
  if (header.Flags.HasFlag(ReliableUdpHeaderFlags.NoAsk))
  {
    // сбрасываем таймер
    connectionRecord.CloseWaitTimer.Change(connectionRecord.LongTimerPeriod, -1);
    // записываем данные
    ReliableUdpStateTools.WritePacketData(connectionRecord, header, payload);
    // если получили пакет с последним флагом - делаем завершаем          
    if (header.Flags.HasFlag(ReliableUdpHeaderFlags.LastPacket))
    {
      connectionRecord.State = connectionRecord.Tcb.States.Completed;
      connectionRecord.State.ProcessPackets(connectionRecord);
    }
    return;
  }        
  // расчет конечной границы окна
  int windowHighestBound = Math.Min((connectionRecord.WindowLowerBound + connectionRecord.WindowSize - 1), (connectionRecord.NumberOfPackets - 1));
  // отбрасываем не попадающие в окно пакеты
  if (header.PacketNumber < connectionRecord.WindowLowerBound || header.PacketNumber > (windowHighestBound))
    return;
  // отбрасываем дубликаты
  if (connectionRecord.WindowControlArray.Contains(header.PacketNumber))
    return;
  // записываем данные 
  ReliableUdpStateTools.WritePacketData(connectionRecord, header, payload);
  // увеличиваем счетчик пакетов        
  connectionRecord.PacketCounter++;
  // записываем в массив управления окном текущий номер пакета        
  connectionRecord.WindowControlArray[header.PacketNumber - connectionRecord.WindowLowerBound] = header.PacketNumber;
  // устанавливаем наибольший пришедший пакет        
  if (header.PacketNumber > connectionRecord.RcvCurrent)
    connectionRecord.RcvCurrent = header.PacketNumber;
  // перезапускам таймеры        
  connectionRecord.TimerSecondTry = false;
  connectionRecord.WaitForPacketsTimer.Change(connectionRecord.ShortTimerPeriod, -1);
  if (connectionRecord.CloseWaitTimer != null)
    connectionRecord.CloseWaitTimer.Change(-1, -1);
  // если пришел последний пакет
  if (header.Flags.HasFlag(ReliableUdpHeaderFlags.LastPacket))
  {
    Interlocked.Increment(ref connectionRecord.IsLastPacketReceived);
  }
  // если нам пришли все пакеты окна, то сбрасываем счетчик
  // и высылаем пакет подтверждение
  else if (connectionRecord.PacketCounter == connectionRecord.WindowSize)
  {
    // сбрасываем счетчик.      
    connectionRecord.PacketCounter = 0;
    // сдвинули окно передачи
    connectionRecord.WindowLowerBound += connectionRecord.WindowSize;
    // обнуление массива управления передачей
    connectionRecord.WindowControlArray.Nullify();
    ReliableUdpStateTools.SendAcknowledgePacket(connectionRecord);
  }
  // если последний пакет уже имеется        
  if (Thread.VolatileRead(ref connectionRecord.IsLastPacketReceived) != 0)
  {
    // проверяем пакеты          
    ProcessPackets(connectionRecord);
  }
}

ສາມາດ ສໍາເລັດ ວຽກງານດຽວຂອງວິທີການແມ່ນເພື່ອສົ່ງການຮັບຮູ້ຄືນໃຫມ່ຂອງການຈັດສົ່ງສົບຜົນສໍາເລັດຂອງຂໍ້ຄວາມ.
ສຳເລັດແລ້ວ.ReceivePacket:

public override void ReceivePacket(ReliableUdpConnectionRecord connectionRecord, ReliableUdpHeader header, byte[] payload)
{
  // повторная отправка последнего пакета в связи с тем,
  // что последний ack не дошел до отправителя
  if (header.Flags.HasFlag(ReliableUdpHeaderFlags.LastPacket))
  {
    ReliableUdpStateTools.SendAcknowledgePacket(connectionRecord);
  }
}

ສົ່ງວິທີການຫຸ້ມຫໍ່

ສາມາດ FirstPacketSending ວິທີການນີ້ສົ່ງຂໍ້ມູນຊຸດທໍາອິດ, ຫຼືຖ້າຂໍ້ຄວາມບໍ່ຕ້ອງການການຢືນຢັນການຈັດສົ່ງ, ຂໍ້ຄວາມທັງຫມົດ.
FirstPacketSending.SendPacket:

public override void SendPacket(ReliableUdpConnectionRecord connectionRecord)
{
  connectionRecord.PacketCounter = 0;
  connectionRecord.SndNext = 0;
  connectionRecord.WindowLowerBound = 0;       
  // если подтверждения не требуется - отправляем все пакеты
  // и высвобождаем ресурсы
  if (connectionRecord.IsNoAnswerNeeded)
  {
    // Здесь происходит отправка As Is
    do
    {
      ReliableUdpStateTools.SendPacket(connectionRecord, ReliableUdpStateTools.CreateUdpPayload(connectionRecord, ReliableUdpStateTools. CreateReliableUdpHeader(connectionRecord)));
      connectionRecord.SndNext++;
    } while (connectionRecord.SndNext < connectionRecord.NumberOfPackets);
    SetAsCompleted(connectionRecord);
    return;
  }
  // создаем заголовок пакета и отправляем его 
  ReliableUdpHeader header = ReliableUdpStateTools.CreateReliableUdpHeader(connectionRecord);
  ReliableUdpStateTools.SendPacket(connectionRecord, ReliableUdpStateTools.CreateUdpPayload(connectionRecord, header));
  // увеличиваем счетчик
  connectionRecord.SndNext++;
  // сдвигаем окно
  connectionRecord.WindowLowerBound++;
  connectionRecord.State = connectionRecord.Tcb.States.SendingCycle;
  // Запускаем таймер
  connectionRecord.WaitForPacketsTimer = new Timer(CheckByTimer, connectionRecord, connectionRecord.ShortTimerPeriod, -1);
}

ສາມາດ ວົງຈອນການສົ່ງ ໃນວິທີການນີ້, ຕັນຂອງແພັກເກັດຖືກສົ່ງ.
SendingCycle.SendPacket:

public override void SendPacket(ReliableUdpConnectionRecord connectionRecord)
{      
  // отправляем блок пакетов      
  for (connectionRecord.PacketCounter = 0;
        connectionRecord.PacketCounter < connectionRecord.WindowSize &&
        connectionRecord.SndNext < connectionRecord.NumberOfPackets;
        connectionRecord.PacketCounter++)
  {
    ReliableUdpHeader header = ReliableUdpStateTools.CreateReliableUdpHeader(connectionRecord);
    ReliableUdpStateTools.SendPacket(connectionRecord, ReliableUdpStateTools.CreateUdpPayload(connectionRecord, header));
    connectionRecord.SndNext++;
  }
  // на случай большого окна передачи, перезапускаем таймер после отправки
  connectionRecord.WaitForPacketsTimer.Change( connectionRecord.ShortTimerPeriod, -1 );
  if ( connectionRecord.CloseWaitTimer != null )
  {
    connectionRecord.CloseWaitTimer.Change( -1, -1 );
  }
}

ເລິກເຂົ້າໄປໃນລະຫັດ. ການສ້າງແລະສ້າງການເຊື່ອມຕໍ່

ໃນປັດຈຸບັນທີ່ພວກເຮົາໄດ້ເຫັນລັດພື້ນຖານແລະວິທີການທີ່ໃຊ້ໃນການຈັດການລັດ, ໃຫ້ພວກເຮົາທໍາລາຍຕົວຢ່າງຈໍານວນຫນ້ອຍຂອງວິທີການເຮັດວຽກຂອງໂປໂຕຄອນໃນລາຍລະອຽດເພີ່ມເຕີມ.
ແຜນວາດການສົ່ງຂໍ້ມູນພາຍໃຕ້ເງື່ອນໄຂປົກກະຕິ:

ພິຈາລະນາລາຍລະອຽດການສ້າງ ບັນທຶກການເຊື່ອມຕໍ່ ເພື່ອເຊື່ອມຕໍ່ແລະສົ່ງຊຸດທໍາອິດ. ການໂອນຍ້າຍແມ່ນເລີ່ມຕົ້ນໂດຍແອັບພລິເຄຊັນທີ່ເອີ້ນ API ສົ່ງຂໍ້ຄວາມ. ຕໍ່ໄປ, ວິທີການ StartTransmission ຂອງຕັນຄວບຄຸມລະບົບສາຍສົ່ງແມ່ນ invoked, ເຊິ່ງເລີ່ມຕົ້ນການສົ່ງຂໍ້ມູນສໍາລັບຂໍ້ຄວາມໃຫມ່.
ການສ້າງການເຊື່ອມຕໍ່ຂາອອກ:

private void StartTransmission(ReliableUdpMessage reliableUdpMessage, EndPoint endPoint, AsyncResultSendMessage asyncResult)
{
  if (m_isListenerStarted == 0)
  {
    if (this.LocalEndpoint == null)
    {
      throw new ArgumentNullException( "", "You must use constructor with parameters or start listener before sending message" );
    }
    // запускаем обработку входящих пакетов
    StartListener(LocalEndpoint);
  }
  // создаем ключ для словаря, на основе EndPoint и ReliableUdpHeader.TransmissionId        
  byte[] transmissionId = new byte[4];
  // создаем случайный номер transmissionId        
  m_randomCrypto.GetBytes(transmissionId);
  Tuple<EndPoint, Int32> key = new Tuple<EndPoint, Int32>(endPoint, BitConverter.ToInt32(transmissionId, 0));
  // создаем новую запись для соединения и проверяем, 
  // существует ли уже такой номер в наших словарях
  if (!m_listOfHandlers.TryAdd(key, new ReliableUdpConnectionRecord(key, this, reliableUdpMessage, asyncResult)))
  {
    // если существует – то повторно генерируем случайный номер 
    m_randomCrypto.GetBytes(transmissionId);
    key = new Tuple<EndPoint, Int32>(endPoint, BitConverter.ToInt32(transmissionId, 0));
    if (!m_listOfHandlers.TryAdd(key, new ReliableUdpConnectionRecord(key, this, reliableUdpMessage, asyncResult)))
      // если снова не удалось – генерируем исключение
      throw new ArgumentException("Pair TransmissionId & EndPoint is already exists in the dictionary");
  }
  // запустили состояние в обработку         
  m_listOfHandlers[key].State.SendPacket(m_listOfHandlers[key]);
}

ການສົ່ງແພັກເກັດທໍາອິດ (FirstPacketSending state):

public override void SendPacket(ReliableUdpConnectionRecord connectionRecord)
{
  connectionRecord.PacketCounter = 0;
  connectionRecord.SndNext = 0;
  connectionRecord.WindowLowerBound = 0;       
  // ... 
  // создаем заголовок пакета и отправляем его 
  ReliableUdpHeader header = ReliableUdpStateTools.CreateReliableUdpHeader(connectionRecord);
  ReliableUdpStateTools.SendPacket(connectionRecord, ReliableUdpStateTools.CreateUdpPayload(connectionRecord, header));
  // увеличиваем счетчик
  connectionRecord.SndNext++;
  // сдвигаем окно
  connectionRecord.WindowLowerBound++;
  // переходим в состояние SendingCycle
  connectionRecord.State = connectionRecord.Tcb.States.SendingCycle;
  // Запускаем таймер
  connectionRecord.WaitForPacketsTimer = new Timer(CheckByTimer, connectionRecord, connectionRecord.ShortTimerPeriod, -1);
}

ຫຼັງຈາກສົ່ງຊຸດທໍາອິດ, ຜູ້ສົ່ງເຂົ້າໄປໃນລັດ ວົງຈອນການສົ່ງ - ລໍ​ຖ້າ​ສໍາ​ລັບ​ການ​ຢືນ​ຢັນ​ການ​ຈັດ​ສົ່ງ​ຊຸດ​.
ດ້ານທີ່ໄດ້ຮັບ, ໂດຍໃຊ້ວິທີການ EndReceive, ຮັບແພັກເກັດທີ່ສົ່ງ, ສ້າງໃຫມ່ ບັນທຶກການເຊື່ອມຕໍ່ ແລະສົ່ງຕໍ່ແພັກເກັດນີ້, ໂດຍມີສ່ວນຫົວທີ່ແຍກກ່ອນ, ໄປຫາວິທີການຮັບແພັກເກັດຂອງລັດສຳລັບການປະມວນຜົນ. FirstPacket ໄດ້ຮັບ
ການສ້າງການເຊື່ອມຕໍ່ຢູ່ດ້ານການຮັບ:

private void EndReceive(IAsyncResult ar)
{
  // ...
  // пакет получен
  // парсим заголовок пакета        
  ReliableUdpHeader header;
  if (!ReliableUdpStateTools.ReadReliableUdpHeader(bytes, out header))
  {          
    // пришел некорректный пакет - отбрасываем его
    return;
  }
  // конструируем ключ для определения connection record’а для пакета
  Tuple<EndPoint, Int32> key = new Tuple<EndPoint, Int32>(connectedClient, header.TransmissionId);
  // получаем существующую connection record или создаем новую
  ReliableUdpConnectionRecord record = m_listOfHandlers.GetOrAdd(key, new ReliableUdpConnectionRecord(key, this, header. ReliableUdpMessageType));
  // запускаем пакет в обработку в конечный автомат
  record.State.ReceivePacket(record, header, bytes);
}

ການ​ໄດ້​ຮັບ​ຊອງ​ທໍາ​ອິດ​ແລະ​ການ​ສົ່ງ​ການ​ຮັບ​ຮູ້ (FirstPacketReceived ລັດ​)​:

public override void ReceivePacket(ReliableUdpConnectionRecord connectionRecord, ReliableUdpHeader header, byte[] payload)
{
  if (!header.Flags.HasFlag(ReliableUdpHeaderFlags.FirstPacket))
    // отбрасываем пакет
    return;
  // ...
  // by design все packet numbers начинаются с 0;
  if (header.PacketNumber != 0)          
    return;
  // инициализируем массив для хранения частей сообщения
  ReliableUdpStateTools.InitIncomingBytesStorage(connectionRecord, header);
  // записываем данные пакет в массив
  ReliableUdpStateTools.WritePacketData(connectionRecord, header, payload);
  // считаем кол-во пакетов, которые должны прийти
  connectionRecord.NumberOfPackets = (int)Math.Ceiling((double) ((double) connectionRecord.IncomingStream.Length/(double) connectionRecord.BufferSize));
  // записываем номер последнего полученного пакета (0)
  connectionRecord.RcvCurrent = header.PacketNumber;
  // после сдвинули окно приема на 1
  connectionRecord.WindowLowerBound++;
  // переключаем состояние
  connectionRecord.State = connectionRecord.Tcb.States.Assembling;  
  if (/*если не требуется механизм подтверждение*/)
  // ...
  else
  {
    // отправляем подтверждение
    ReliableUdpStateTools.SendAcknowledgePacket(connectionRecord);
    connectionRecord.WaitForPacketsTimer = new Timer(CheckByTimer, connectionRecord, connectionRecord.ShortTimerPeriod, -1);
  }
}

ເລິກເຂົ້າໄປໃນລະຫັດ. ການປິດການເຊື່ອມຕໍ່ໃນເວລາຫມົດເວລາ

ການຈັດການເວລາຫມົດເວລາແມ່ນສ່ວນຫນຶ່ງທີ່ສໍາຄັນຂອງ UDP ທີ່ເຊື່ອຖືໄດ້. ພິຈາລະນາຕົວຢ່າງທີ່ໂຫນດກາງລົ້ມເຫລວແລະການຈັດສົ່ງຂໍ້ມູນໃນທັງສອງທິດທາງກາຍເປັນເປັນໄປບໍ່ໄດ້.
ແຜນຜັງສໍາລັບການປິດການເຊື່ອມຕໍ່ໂດຍການຫມົດເວລາ:

ດັ່ງທີ່ເຫັນໄດ້ຈາກແຜນວາດ, ເຄື່ອງຈັບເວລາເຮັດວຽກຂອງຜູ້ສົ່ງເລີ່ມຕົ້ນທັນທີຫຼັງຈາກການສົ່ງແພັກເກັດ. ນີ້ເກີດຂື້ນໃນວິທີການ SendPacket ຂອງລັດ ວົງຈອນການສົ່ງ.
ເປີດ​ໃຊ້​ງານ​ໂມງ​ຈັບ​ເວ​ລາ​ເຮັດ​ວຽກ (SendingCycle state):

public override void SendPacket(ReliableUdpConnectionRecord connectionRecord)
{      
  // отправляем блок пакетов   
  // ...   
  // перезапускаем таймер после отправки
  connectionRecord.WaitForPacketsTimer.Change( connectionRecord.ShortTimerPeriod, -1 );
  if ( connectionRecord.CloseWaitTimer != null )
    connectionRecord.CloseWaitTimer.Change( -1, -1 );
}

ໄລຍະເວລາຈັບເວລາຖືກກໍານົດເມື່ອການເຊື່ອມຕໍ່ຖືກສ້າງ. ShortTimerPeriod ເລີ່ມຕົ້ນແມ່ນ 5 ວິນາທີ. ໃນຕົວຢ່າງ, ມັນຖືກກໍານົດເປັນ 1,5 ວິນາທີ.

ສໍາລັບການເຊື່ອມຕໍ່ຂາເຂົ້າ, ເຄື່ອງຈັບເວລາເລີ່ມຕົ້ນຫຼັງຈາກໄດ້ຮັບແພັກເກັດຂໍ້ມູນຂາເຂົ້າສຸດທ້າຍ, ນີ້ຈະເກີດຂື້ນໃນວິທີການ ReceivePacket ຂອງລັດ. ການຕິດຕັ້ງ
ເປີດ​ໃຊ້​ງານ​ໂມງ​ຈັບ​ເວ​ລາ​ເຮັດ​ວຽກ (ສະ​ຖາ​ນະ​ການ​ປະ​ກອບ​)​:

public override void ReceivePacket(ReliableUdpConnectionRecord connectionRecord, ReliableUdpHeader header, byte[] payload)
{
  // ... 
  // перезапускаем таймеры        
  connectionRecord.TimerSecondTry = false;
  connectionRecord.WaitForPacketsTimer.Change(connectionRecord.ShortTimerPeriod, -1);
  if (connectionRecord.CloseWaitTimer != null)
    connectionRecord.CloseWaitTimer.Change(-1, -1);
  // ...
}

ບໍ່ມີແພັກເກັດໃດໆມາຮອດການເຊື່ອມຕໍ່ຂາເຂົ້າໃນຂະນະທີ່ລໍຖ້າໂມງຈັບເວລາເຮັດວຽກ. ເຄື່ອງຈັບເວລາໄດ້ປິດລົງແລະເອີ້ນວ່າວິທີການ ProcessPackets, ບ່ອນທີ່ຊຸດທີ່ສູນເສຍໄດ້ຖືກພົບເຫັນແລະການຮ້ອງຂໍການຈັດສົ່ງຄືນໄດ້ຖືກສົ່ງເປັນຄັ້ງທໍາອິດ.
ກຳລັງສົ່ງຄຳຮ້ອງຂໍການຈັດສົ່ງຄືນ (ສະຖານະປະກອບ):

public override void ProcessPackets(ReliableUdpConnectionRecord connectionRecord)
{
  // ...        
  if (/*проверка на потерянные пакеты */)
  {
    // отправляем запросы на повторную доставку
    // устанавливаем таймер во второй раз, для повторной попытки передачи
    if (!connectionRecord.TimerSecondTry)
    {
      connectionRecord.WaitForPacketsTimer.Change(connectionRecord.ShortTimerPeriod, -1);
    connectionRecord.TimerSecondTry = true;
    return;
    }
  // если после двух попыток срабатываний WaitForPacketTimer 
  // не удалось получить пакеты - запускаем таймер завершения соединения
  StartCloseWaitTimer(connectionRecord);
  }
  else if (/*пришел последний пакет и успешная проверка */)
  {
    // ...
    StartCloseWaitTimer(connectionRecord);
  }
  // если ack на блок пакетов был потерян
  else
  { 
    if (!connectionRecord.TimerSecondTry)
    {
      // повторно отсылаем ack
      connectionRecord.WaitForPacketsTimer.Change(connectionRecord.ShortTimerPeriod, -1);
      connectionRecord.TimerSecondTry = true;
      return;
    }
    // запускаем таймер завершения соединения
    StartCloseWaitTimer(connectionRecord);
  }
}

ຕົວແປ TimerSecondTry ຖືກຕັ້ງເປັນ ທີ່ແທ້ຈິງ. ຕົວແປນີ້ແມ່ນຮັບຜິດຊອບສໍາລັບການເປີດເຄື່ອງຈັບເວລາເຮັດວຽກຄືນໃຫມ່.

ຢູ່ຂ້າງຜູ້ສົ່ງ, ເຄື່ອງຈັບເວລາເຮັດວຽກຍັງຖືກກະຕຸ້ນ ແລະແພັກເກັດທີ່ສົ່ງຫຼ້າສຸດຖືກສົ່ງຄືນ.
ເປີດໃຊ້ຕົວຈັບເວລາປິດການເຊື່ອມຕໍ່ (ສະຖານະວົງຈອນການສົ່ງ):

public override void ProcessPackets(ReliableUdpConnectionRecord connectionRecord)
{
  // ...        
  // отправляем повторно последний пакет 
  // ...        
  // включаем таймер CloseWait – для ожидания восстановления соединения или его завершения
  StartCloseWaitTimer(connectionRecord);
}

ຫຼັງຈາກນັ້ນ, ເຄື່ອງຈັບເວລາປິດການເຊື່ອມຕໍ່ເລີ່ມຕົ້ນໃນການເຊື່ອມຕໍ່ຂາອອກ.
ReliableUdpState.StartCloseWaitTimer:

protected void StartCloseWaitTimer(ReliableUdpConnectionRecord connectionRecord)
{
  if (connectionRecord.CloseWaitTimer != null)
    connectionRecord.CloseWaitTimer.Change(connectionRecord.LongTimerPeriod, -1);
  else
    connectionRecord.CloseWaitTimer = new Timer(DisposeByTimeout, connectionRecord, connectionRecord.LongTimerPeriod, -1);
}

ໄລຍະເວລາການໝົດເວລາຂອງການເຊື່ອມຕໍ່ປິດແມ່ນ 30 ວິນາທີຕາມຄ່າເລີ່ມຕົ້ນ.

ຫຼັງຈາກເວລາສັ້ນໆ, ເຄື່ອງຈັບເວລາເຮັດວຽກຢູ່ຝ່າຍຜູ້ຮັບກໍ່ໄຟອີກເທື່ອຫນຶ່ງ, ການຮ້ອງຂໍຖືກສົ່ງອີກເທື່ອຫນຶ່ງ, ຫຼັງຈາກນັ້ນ, ເຄື່ອງຈັບເວລາປິດການເຊື່ອມຕໍ່ເລີ່ມຕົ້ນສໍາລັບການເຊື່ອມຕໍ່ຂາເຂົ້າ.

ເມື່ອເຄື່ອງຈັບເວລາປິດໄຟ, ຊັບພະຍາກອນທັງຫມົດຂອງບັນທຶກການເຊື່ອມຕໍ່ທັງສອງຈະຖືກປ່ອຍອອກມາ. ຜູ້​ສົ່ງ​ລາຍ​ງານ​ຄວາມ​ລົ້ມ​ເຫຼວ​ຂອງ​ການ​ຈັດ​ສົ່ງ​ກັບ​ຄໍາ​ຮ້ອງ​ສະ​ຫມັກ​ຕົ້ນ​ຕໍ (ເບິ່ງ UDP API ທີ່ເຊື່ອຖືໄດ້).
ປ່ອຍຊັບພະຍາກອນບັນທຶກການເຊື່ອມຕໍ່:

public void Dispose()
{
  try
  {
    System.Threading.Monitor.Enter(this.LockerReceive);
  }
  finally
  {
    Interlocked.Increment(ref this.IsDone);
    if (WaitForPacketsTimer != null)
    {
      WaitForPacketsTimer.Dispose();
    }
    if (CloseWaitTimer != null)
    {
      CloseWaitTimer.Dispose();
    }
    byte[] stream;
    Tcb.IncomingStreams.TryRemove(Key, out stream);
    stream = null;
    Tcb.OutcomingStreams.TryRemove(Key, out stream);
    stream = null;
    System.Threading.Monitor.Exit(this.LockerReceive);
  }
}

ເລິກເຂົ້າໄປໃນລະຫັດ. ການຟື້ນຟູການໂອນຂໍ້ມູນ

ແຜນ​ວາດ​ການ​ຟື້ນ​ຟູ​ການ​ສົ່ງ​ຂໍ້​ມູນ​ໃນ​ກໍ​ລະ​ນີ​ຂອງ​ການ​ສູນ​ເສຍ packet​:

ດັ່ງທີ່ໄດ້ສົນທະນາແລ້ວໃນການປິດການເຊື່ອມຕໍ່ໃນເວລາຫມົດເວລາ, ເມື່ອເວລາເຮັດວຽກຫມົດເວລາ, ຜູ້ຮັບຈະກວດເບິ່ງແພັກເກັດທີ່ສູນເສຍ. ໃນກໍລະນີຂອງການສູນເສຍແພັກເກັດ, ບັນຊີລາຍຊື່ຂອງຈໍານວນຊອງທີ່ບໍ່ໄດ້ໄປຫາຜູ້ຮັບຈະຖືກລວບລວມ. ຕົວເລກເຫຼົ່ານີ້ຖືກໃສ່ເຂົ້າໄປໃນອາເຣ LostPackets ຂອງການເຊື່ອມຕໍ່ສະເພາະ, ແລະການຮ້ອງຂໍການຈັດສົ່ງຄືນແມ່ນຖືກສົ່ງໄປ.
ການ​ສົ່ງ​ຄໍາ​ຮ້ອງ​ສະ​ຫມັກ​ເພື່ອ​ສົ່ງ​ຄືນ​ການ​ຫຸ້ມ​ຫໍ່ (ສະ​ຖາ​ນະ​ການ​ປະ​ກອບ​):

public override void ProcessPackets(ReliableUdpConnectionRecord connectionRecord)
{
  //...
  if (!ReliableUdpStateTools.CheckForNoPacketLoss(connectionRecord, connectionRecord.IsLastPacketReceived != 0))
  {
    // есть потерянные пакеты, отсылаем запросы на них
    foreach (int seqNum in connectionRecord.LostPackets)
    {
      if (seqNum != 0)
      {
        ReliableUdpStateTools.SendAskForLostPacket(connectionRecord, seqNum);
      }
    }
    // ...
  }
}

ຜູ້ສົ່ງຈະຍອມຮັບຄໍາຮ້ອງຂໍການຈັດສົ່ງຄືນແລະສົ່ງຊຸດທີ່ຂາດຫາຍໄປ. ມັນເປັນມູນຄ່າທີ່ສັງເກດວ່າໃນເວລານີ້ຜູ້ສົ່ງໄດ້ເລີ່ມການຈັບເວລາໃກ້ຊິດຂອງການເຊື່ອມຕໍ່ແລະ, ເມື່ອໄດ້ຮັບການຮ້ອງຂໍ, ມັນຖືກຕັ້ງຄືນໃຫມ່.
ສົ່ງແພັກເກັດທີ່ເສຍໄປຄືນໃໝ່ (ສະຖານະການສົ່ງຮອບວຽນ):

public override void ReceivePacket(ReliableUdpConnectionRecord connectionRecord, ReliableUdpHeader header, byte[] payload)
{
  // ...
  connectionRecord.WaitForPacketsTimer.Change(connectionRecord.ShortTimerPeriod, -1);
  // сброс таймера закрытия соединения 
  if (connectionRecord.CloseWaitTimer != null)
    connectionRecord.CloseWaitTimer.Change(-1, -1);
  // ...
  // это запрос на повторную передачу – отправляем требуемый пакет          
  else
    ReliableUdpStateTools.SendPacket(connectionRecord, ReliableUdpStateTools.RetransmissionCreateUdpPayload(connectionRecord, header.PacketNumber));
}

ແພັກເກັດທີ່ຫຼົງໄຫຼ (ຊຸດທີ 3 ໃນແຜນວາດ) ແມ່ນໄດ້ຮັບໂດຍການເຊື່ອມຕໍ່ຂາເຂົ້າ. ການກວດສອບແມ່ນເຮັດເພື່ອເບິ່ງວ່າປ່ອງຢ້ຽມຮັບແມ່ນເຕັມແລະການສົ່ງຂໍ້ມູນປົກກະຕິຖືກຟື້ນຟູ.
ການ​ກວດ​ສອບ​ການ hits ໃນ​ປ່ອງ​ຢ້ຽມ​ທີ່​ໄດ້​ຮັບ (ສະ​ຖາ​ນະ​ການ​ປະ​ກອບ​)​:

public override void ReceivePacket(ReliableUdpConnectionRecord connectionRecord, ReliableUdpHeader header, byte[] payload)
{
  // ...
  // увеличиваем счетчик пакетов        
  connectionRecord.PacketCounter++;
  // записываем в массив управления окном текущий номер пакета        
  connectionRecord.WindowControlArray[header.PacketNumber - connectionRecord.WindowLowerBound] = header.PacketNumber;
  // устанавливаем наибольший пришедший пакет        
  if (header.PacketNumber > connectionRecord.RcvCurrent)
    connectionRecord.RcvCurrent = header.PacketNumber;
  // перезапускам таймеры        
  connectionRecord.TimerSecondTry = false;
  connectionRecord.WaitForPacketsTimer.Change(connectionRecord.ShortTimerPeriod, -1);
  if (connectionRecord.CloseWaitTimer != null)
    connectionRecord.CloseWaitTimer.Change(-1, -1);
  // ...
  // если нам пришли все пакеты окна, то сбрасываем счетчик
  // и высылаем пакет подтверждение
  else if (connectionRecord.PacketCounter == connectionRecord.WindowSize)
  {
    // сбрасываем счетчик.      
    connectionRecord.PacketCounter = 0;
    // сдвинули окно передачи
    connectionRecord.WindowLowerBound += connectionRecord.WindowSize;
    // обнуление массива управления передачей
    connectionRecord.WindowControlArray.Nullify();
    ReliableUdpStateTools.SendAcknowledgePacket(connectionRecord);
  }
  // ...
}

UDP API ທີ່ເຊື່ອຖືໄດ້

ເພື່ອພົວພັນກັບໂປໂຕຄອນການໂອນຂໍ້ມູນ, ມີຫ້ອງຮຽນ Udp Reliable ເປີດ, ເຊິ່ງແມ່ນ wrapper ເທິງຕົວຄວບຄຸມການໂອນຍ້າຍ. ນີ້ແມ່ນສະມາຊິກທີ່ສໍາຄັນທີ່ສຸດຂອງຫ້ອງຮຽນ:

public sealed class ReliableUdp : IDisposable
{
  // получает локальную конечную точку
  public IPEndPoint LocalEndpoint    
  // создает экземпляр ReliableUdp и запускает
  // прослушивание входящих пакетов на указанном IP адресе
  // и порту. Значение 0 для порта означает использование
  // динамически выделенного порта
  public ReliableUdp(IPAddress localAddress, int port = 0) 
  // подписка на получение входящих сообщений
  public ReliableUdpSubscribeObject SubscribeOnMessages(ReliableUdpMessageCallback callback, ReliableUdpMessageTypes messageType = ReliableUdpMessageTypes.Any, IPEndPoint ipEndPoint = null)    
  // отписка от получения сообщений
  public void Unsubscribe(ReliableUdpSubscribeObject subscribeObject)
  // асинхронно отправить сообщение 
  // Примечание: совместимость с XP и Server 2003 не теряется, т.к. используется .NET Framework 4.0
  public Task<bool> SendMessageAsync(ReliableUdpMessage reliableUdpMessage, IPEndPoint remoteEndPoint, CancellationToken cToken)
  // начать асинхронную отправку сообщения
  public IAsyncResult BeginSendMessage(ReliableUdpMessage reliableUdpMessage, IPEndPoint remoteEndPoint, AsyncCallback asyncCallback, Object state)
  // получить результат асинхронной отправки
  public bool EndSendMessage(IAsyncResult asyncResult)  
  // очистить ресурсы
  public void Dispose()    
}

ຂໍ້ຄວາມແມ່ນໄດ້ຮັບໂດຍການສະຫມັກ. ລາຍເຊັນຂອງຜູ້ແທນສຳລັບວິທີການໂທກັບ:

public delegate void ReliableUdpMessageCallback( ReliableUdpMessage reliableUdpMessage, IPEndPoint remoteClient );

ຂໍ້ຄວາມ:

public class ReliableUdpMessage
{
  // тип сообщения, простое перечисление
  public ReliableUdpMessageTypes Type { get; private set; }
  // данные сообщения
  public byte[] Body { get; private set; }
  // если установлено в true – механизм подтверждения доставки будет отключен
  // для передачи конкретного сообщения
  public bool NoAsk { get; private set; }
}

ເພື່ອຈອງປະເພດຂໍ້ຄວາມສະເພາະ ແລະ/ຫຼືຜູ້ສົ່ງສະເພາະ, ສອງຕົວກໍານົດທາງເລືອກແມ່ນຖືກນໍາໃຊ້: ReliableUdpMessageTypes messageType ແລະ IPEndPoint ipEndPoint.

ປະເພດຂໍ້ຄວາມ:

public enum ReliableUdpMessageTypes : short
{ 
  // Любое
  Any = 0,
  // Запрос к STUN server 
  StunRequest = 1,
  // Ответ от STUN server
  StunResponse = 2,
  // Передача файла
  FileTransfer =3,
  // ...
}

ຂໍ້ຄວາມຖືກສົ່ງແບບ asynchronous; ສໍາລັບການນີ້, ໂປໂຕຄອນປະຕິບັດຮູບແບບການຂຽນໂປລແກລມ asynchronous:

public IAsyncResult BeginSendMessage(ReliableUdpMessage reliableUdpMessage, IPEndPoint remoteEndPoint, AsyncCallback asyncCallback, Object state)

ຜົນໄດ້ຮັບຂອງການສົ່ງຂໍ້ຄວາມຈະເປັນຄວາມຈິງ - ຖ້າຂໍ້ຄວາມມາຮອດຜູ້ຮັບຢ່າງສໍາເລັດຜົນແລະຜິດ - ຖ້າການເຊື່ອມຕໍ່ຖືກປິດໃນເວລາຫມົດເວລາ:

public bool EndSendMessage(IAsyncResult asyncResult)

ສະຫລຸບ

ຫຼາຍບໍ່ໄດ້ຖືກອະທິບາຍໃນບົດຄວາມນີ້. ກົນໄກການຈັບຄູ່ກະທູ້, ຂໍ້ຍົກເວັ້ນແລະການຈັດການຄວາມຜິດພາດ, ການປະຕິບັດວິທີການສົ່ງຂໍ້ຄວາມ asynchronous. ແຕ່ຫຼັກຂອງໂປໂຕຄອນ, ລາຍລະອຽດຂອງເຫດຜົນສໍາລັບການປຸງແຕ່ງແພັກເກັດ, ການສ້າງການເຊື່ອມຕໍ່, ແລະການຈັດການເວລາຫມົດເວລາ, ຄວນຈະແຈ້ງສໍາລັບທ່ານ.

ສະບັບທີ່ສະແດງໃຫ້ເຫັນຂອງໂປໂຕຄອນການຈັດສົ່ງທີ່ເຊື່ອຖືໄດ້ແມ່ນແຂງແຮງແລະມີຄວາມຍືດຫຍຸ່ນພຽງພໍທີ່ຈະຕອບສະຫນອງຄວາມຕ້ອງການທີ່ກໍານົດໄວ້ກ່ອນຫນ້ານີ້. ແຕ່ຂ້ອຍຕ້ອງການເພີ່ມວ່າການປະຕິບັດທີ່ໄດ້ອະທິບາຍສາມາດປັບປຸງໄດ້. ຕົວຢ່າງ, ເພື່ອເພີ່ມການສົ່ງຜ່ານແລະການປ່ຽນແປງໄລຍະເວລາ timer, ກົນໄກເຊັ່ນ: ປ່ອງຢ້ຽມເລື່ອນແລະ RTT ສາມາດຖືກເພີ່ມເຂົ້າໃນໂປໂຕຄອນ, ມັນຍັງເປັນປະໂຫຍດທີ່ຈະປະຕິບັດກົນໄກການກໍານົດ MTU ລະຫວ່າງການເຊື່ອມຕໍ່ (ແຕ່ພຽງແຕ່ຖ້າຂໍ້ຄວາມຂະຫນາດໃຫຍ່ຖືກສົ່ງ) .

ຂໍ​ຂອບ​ໃຈ​ທ່ານ​ສໍາ​ລັບ​ການ​ເອົາ​ໃຈ​ໃສ່​ຂອງ​ທ່ານ​, ຂ້າ​ພະ​ເຈົ້າ​ຫວັງ​ວ່າ​ຈະ​ຄໍາ​ເຫັນ​ແລະ​ຄໍາ​ເຫັນ​ຂອງ​ທ່ານ​.

PS ສໍາລັບຜູ້ທີ່ມີຄວາມສົນໃຈໃນລາຍລະອຽດຫຼືພຽງແຕ່ຕ້ອງການທີ່ຈະທົດສອບໂປໂຕຄອນ, ການເຊື່ອມຕໍ່ກັບໂຄງການໃນ GitHube:
ໂຄງການ UDP ທີ່ເຊື່ອຖືໄດ້

ການເຊື່ອມຕໍ່ທີ່ເປັນປະໂຫຍດແລະບົດຄວາມ

1. ຂໍ້ກໍານົດຂອງໂປໂຕຄອນ TCP: ໃນພາສາອັງກິດ и ໃນພາສາລັດເຊຍ
2. ຂໍ້ກໍານົດຂອງໂປໂຕຄອນ UDP: ໃນພາສາອັງກິດ и ໃນພາສາລັດເຊຍ
3. ການສົນທະນາກ່ຽວກັບພິທີການ RUDP: draft-ietf-sigtran-reliable-udp-00
4. ອະນຸສັນຍາຂໍ້ມູນທີ່ເຊື່ອຖືໄດ້: rfc908 и rfc1151
5. ການປະຕິບັດງ່າຍດາຍຂອງການຢືນຢັນການຈັດສົ່ງຜ່ານ UDP: ຄວບຄຸມເຄືອຂ່າຍທັງໝົດຂອງເຈົ້າດ້ວຍ .NET ແລະ UDP
6. ບົດຄວາມອະທິບາຍກົນໄກການຂ້າມຜ່ານ NAT: ການ​ສື່​ສານ Peer-to-Peer ທົ່ວ​ເຄືອ​ຂ່າຍ​ຜູ້​ແປ​ທີ່​ຢູ່​
7. ການປະຕິບັດຮູບແບບການຂຽນໂປລແກລມ asynchronous: ການປະຕິບັດຕົວແບບການຂຽນໂປລແກລມ Asynchronous CLR и ວິທີການປະຕິບັດຮູບແບບການອອກແບບ IAsyncResult
8. ການ Porting the asynchronous programming model to the task-based asynchronous pattern (APM in TAP):
   TPL ແລະແບບດັ້ງເດີມ .NET Asynchronous Programming
   Interop ກັບຮູບແບບ Asynchronous ແລະປະເພດອື່ນໆ

ອັບເດດ: ຂອບໃຈ Mayorovp и ຊິດສະຕີ ສໍາລັບຄວາມຄິດຂອງການເພີ່ມວຽກງານໃນການໂຕ້ຕອບ. ຄວາມເຂົ້າກັນໄດ້ຂອງຫ້ອງສະຫມຸດກັບລະບົບປະຕິບັດການເກົ່າແມ່ນບໍ່ຖືກລະເມີດ, ເພາະວ່າ ຂອບວຽກທີ 4 ຮອງຮັບທັງເຊີບເວີ XP ແລະ 2003.

ແຫຼ່ງຂໍ້ມູນ: www.habr.com