ការអនុវត្តពិធីការ Udp ដែលអាចទុកចិត្តបានសម្រាប់ .Net

អ៊ិនធឺណិតបានផ្លាស់ប្តូរជាយូរមកហើយ។ ពិធីការសំខាន់មួយនៃអ៊ីនធឺណិត - UDP ត្រូវបានប្រើដោយកម្មវិធីមិនត្រឹមតែដើម្បីបញ្ជូនទិន្នន័យ និងការចាក់ផ្សាយប៉ុណ្ណោះទេ ប៉ុន្តែថែមទាំងផ្តល់នូវការតភ្ជាប់ "ពីមួយទៅមួយ" រវាងថ្នាំងបណ្តាញ។ ដោយសារតែការរចនាដ៏សាមញ្ញរបស់វា ពិធីការនេះមានការប្រើប្រាស់ជាច្រើនដែលមិនបានគ្រោងទុកពីមុនមក ទោះជាយ៉ាងណាក៏ដោយ ភាពខ្វះខាតនៃពិធីការ ដូចជាកង្វះការធានាមិនបាត់ទៅណាឡើយ។ អត្ថបទនេះពិពណ៌នាអំពីការអនុវត្តពិធីការចែកចាយដែលមានការធានាលើ UDP ។
មាតិកា:ធាតុ
តម្រូវការពិធីសារ
ក្បាល UDP ដែលអាចទុកចិត្តបាន។
គោលការណ៍ទូទៅនៃពិធីសារ
ការអស់ពេល និងកម្មវិធីកំណត់ពេលវេលាពិធីការ
ដ្យាក្រាមស្ថានភាពបញ្ជូន UDP ដែលអាចទុកចិត្តបាន។
កាន់តែស៊ីជម្រៅទៅក្នុងកូដ។ អង្គភាពត្រួតពិនិត្យការបញ្ជូន
កាន់តែស៊ីជម្រៅទៅក្នុងកូដ។ រដ្ឋ

• វិធីសាស្រ្ត DisposeByTimeout
• វិធីសាស្ត្រដំណើរការកញ្ចប់
• វិធីសាស្ត្រទទួលកញ្ចប់
• វិធីសាស្ត្រផ្ញើកញ្ចប់

កាន់តែស៊ីជម្រៅទៅក្នុងកូដ។ ការបង្កើត និងបង្កើតការតភ្ជាប់
កាន់តែស៊ីជម្រៅទៅក្នុងកូដ។ ការបិទការតភ្ជាប់នៅពេលអស់ពេល
កាន់តែស៊ីជម្រៅទៅក្នុងកូដ។ ការស្តារការផ្ទេរទិន្នន័យ
UDP API ដែលអាចទុកចិត្តបាន។
សេចក្តីសន្និដ្ឋាន
តំណភ្ជាប់ និងអត្ថបទមានប្រយោជន៍

ធាតុ

ស្ថាបត្យកម្មដើមនៃអ៊ិនធឺណិតសន្មតថាជាកន្លែងអាសយដ្ឋានដូចគ្នា ដែលថ្នាំងនីមួយៗមានអាសយដ្ឋាន IP សកល និងតែមួយគត់ ហើយអាចទំនាក់ទំនងដោយផ្ទាល់ជាមួយថ្នាំងផ្សេងទៀត។ ឥឡូវនេះអ៊ិនធឺណិតតាមការពិតមានស្ថាបត្យកម្មផ្សេងគ្នា - តំបន់មួយនៃអាសយដ្ឋាន IP សកលនិងតំបន់ជាច្រើនដែលមានអាសយដ្ឋានឯកជនលាក់នៅពីក្រោយឧបករណ៍ NAT ។នៅក្នុងស្ថាបត្យកម្មនេះ មានតែឧបករណ៍នៅក្នុងចន្លោះអាសយដ្ឋានសកលប៉ុណ្ណោះដែលអាចទាក់ទងជាមួយនរណាម្នាក់នៅលើបណ្តាញបានយ៉ាងងាយស្រួល ដោយសារពួកវាមានអាសយដ្ឋាន IP តែមួយគត់ដែលអាចដំណើរការបានទូទាំងពិភពលោក។ ថ្នាំងនៅលើបណ្តាញឯកជនអាចភ្ជាប់ទៅថ្នាំងផ្សេងទៀតនៅលើបណ្តាញតែមួយ ហើយក៏អាចភ្ជាប់ទៅថ្នាំងល្បីផ្សេងទៀតនៅក្នុងចន្លោះអាសយដ្ឋានសកលផងដែរ។ អន្តរកម្មនេះត្រូវបានសម្រេចភាគច្រើនដោយសារតែយន្តការបកប្រែអាសយដ្ឋានបណ្តាញ។ ឧបករណ៍ NAT ដូចជារ៉ោតទ័រ Wi-Fi បង្កើតធាតុតារាងបកប្រែពិសេសសម្រាប់ការតភ្ជាប់ចេញ និងកែប្រែអាសយដ្ឋាន IP និងលេខច្រកក្នុងកញ្ចប់ព័ត៌មាន។ នេះអនុញ្ញាតឱ្យមានការតភ្ជាប់ចេញពីបណ្តាញឯកជនទៅកាន់ម៉ាស៊ីននៅក្នុងចន្លោះអាសយដ្ឋានសកល។ ប៉ុន្តែនៅពេលជាមួយគ្នានោះ ឧបករណ៍ NAT ជាធម្មតារារាំងចរាចរណ៍ចូលទាំងអស់ លុះត្រាតែមានច្បាប់ដាច់ដោយឡែកសម្រាប់ការតភ្ជាប់ចូល។

ស្ថាបត្យកម្មនៃអ៊ីនធឺណិតនេះគឺត្រឹមត្រូវគ្រប់គ្រាន់សម្រាប់ការទំនាក់ទំនងអតិថិជន-ម៉ាស៊ីនមេ ដែលអតិថិជនអាចនៅក្នុងបណ្តាញឯកជន ហើយម៉ាស៊ីនមេមានអាសយដ្ឋានសកល។ ប៉ុន្តែវាបង្កើតការលំបាកសម្រាប់ការតភ្ជាប់ដោយផ្ទាល់នៃថ្នាំងពីររវាង ផ្សេងៗ បណ្តាញឯកជន។ ការតភ្ជាប់ដោយផ្ទាល់រវាងថ្នាំងពីរគឺមានសារៈសំខាន់សម្រាប់កម្មវិធីពីគ្នាទៅវិញទៅមកដូចជាការបញ្ជូនសំឡេង (Skype) ការទទួលបានពីចម្ងាយទៅកាន់កុំព្យូទ័រ (TeamViewer) ឬហ្គេមអនឡាញ។

វិធីសាស្រ្តដ៏មានប្រសិទ្ធភាពបំផុតមួយសម្រាប់បង្កើតការតភ្ជាប់ពីមួយទៅមួយរវាងឧបករណ៍នៅលើបណ្តាញឯកជនផ្សេងៗគ្នាត្រូវបានគេហៅថាការដាល់រន្ធ។ បច្ចេកទេសនេះត្រូវបានប្រើជាទូទៅបំផុតជាមួយកម្មវិធីដោយផ្អែកលើពិធីការ UDP ។

ប៉ុន្តែប្រសិនបើកម្មវិធីរបស់អ្នកទាមទារការចែកចាយទិន្នន័យដែលមានការធានា ជាឧទាហរណ៍ អ្នកផ្ទេរឯកសាររវាងកុំព្យូទ័រ នោះការប្រើ UDP នឹងមានការលំបាកជាច្រើនដោយសារតែ UDP មិនមែនជាពិធីការចែកចាយដែលមានការធានា ហើយមិនផ្តល់ការចែកចាយកញ្ចប់ព័ត៌មានតាមលំដាប់លំដោយ មិនដូច TCP ទេ។ ពិធីការ។

ក្នុងករណីនេះ ដើម្បីធានាបាននូវការចែកចាយកញ្ចប់ព័ត៌មាន វាត្រូវបានទាមទារដើម្បីអនុវត្តពិធីការស្រទាប់កម្មវិធីដែលផ្តល់មុខងារចាំបាច់ និងដំណើរការលើ UDP ។

ខ្ញុំចង់កត់សម្គាល់ភ្លាមៗថាមានបច្ចេកទេសដាល់រន្ធ TCP សម្រាប់បង្កើតការតភ្ជាប់ TCP រវាងថ្នាំងនៅក្នុងបណ្តាញឯកជនផ្សេងៗគ្នា ប៉ុន្តែដោយសារការខ្វះខាតការគាំទ្រសម្រាប់វាដោយឧបករណ៍ NAT ជាច្រើន ជាធម្មតាវាមិនត្រូវបានចាត់ទុកថាជាវិធីចម្បងក្នុងការតភ្ជាប់នោះទេ។ ថ្នាំងបែបនេះ។

សម្រាប់អត្ថបទដែលនៅសេសសល់នេះ ខ្ញុំនឹងផ្តោតតែលើការអនុវត្តពិធីការចែកចាយដែលមានការធានាប៉ុណ្ណោះ។ ការអនុវត្តបច្ចេកទេសដាល់រន្ធ UDP នឹងត្រូវបានពិពណ៌នានៅក្នុងអត្ថបទខាងក្រោម។

តម្រូវការពិធីសារ

1. ការផ្តល់កញ្ចប់ព័ត៌មានដែលអាចជឿទុកចិត្តបានត្រូវបានអនុវត្តតាមរយៈយន្តការមតិត្រឡប់វិជ្ជមាន (ហៅថាការទទួលស្គាល់ជាវិជ្ជមាន)
2. តម្រូវការសម្រាប់ការផ្ទេរទិន្នន័យធំប្រកបដោយប្រសិទ្ធភាព i.e. ពិធីការត្រូវតែជៀសវាងការបញ្ជូនបន្តកញ្ចប់ព័ត៌មានដែលមិនចាំបាច់
3. វាគួរតែអាចលុបចោលយន្តការបញ្ជាក់ការចែកចាយ (សមត្ថភាពក្នុងការដំណើរការជាពិធីការ UDP "សុទ្ធ")
4. សមត្ថភាពក្នុងការអនុវត្តរបៀបពាក្យបញ្ជាដោយមានការបញ្ជាក់ពីសារនីមួយៗ
5. ឯកតាមូលដ្ឋាននៃការផ្ទេរទិន្នន័យលើពិធីការត្រូវតែជាសារ

តម្រូវការទាំងនេះភាគច្រើនស្របគ្នានឹងតម្រូវការពិធីសារទិន្នន័យដែលអាចទុកចិត្តបានដែលបានពិពណ៌នានៅក្នុង rfc ១១២៣ и rfc ១១២៣ហើយខ្ញុំពឹងផ្អែកលើស្តង់ដារទាំងនោះនៅពេលបង្កើតពិធីការនេះ។

ដើម្បីយល់ពីតម្រូវការទាំងនេះ សូមក្រឡេកមើលពេលវេលានៃការផ្ទេរទិន្នន័យរវាងថ្នាំងបណ្តាញពីរដោយប្រើពិធីការ TCP និង UDP ។ អនុញ្ញាតឱ្យក្នុងករណីទាំងពីរយើងនឹងមានកញ្ចប់មួយបាត់។
ការផ្ទេរទិន្នន័យមិនអន្តរកម្មលើ TCP៖

ដូចដែលអ្នកអាចមើលឃើញពីដ្យាក្រាម ក្នុងករណីបាត់បង់កញ្ចប់ព័ត៌មាន TCP នឹងរកឃើញកញ្ចប់ព័ត៌មានដែលបាត់ ហើយរាយការណ៍វាទៅអ្នកផ្ញើដោយសួររកចំនួនផ្នែកដែលបាត់។
ការផ្ទេរទិន្នន័យតាមរយៈពិធីការ UDP៖

UDP មិនចាត់វិធានការស្វែងរកការបាត់បង់ណាមួយឡើយ។ ការត្រួតពិនិត្យកំហុសនៃការបញ្ជូននៅក្នុងពិធីការ UDP គឺជាការទទួលខុសត្រូវទាំងស្រុងនៃកម្មវិធី។

ការរកឃើញកំហុសនៅក្នុងពិធីការ TCP ត្រូវបានសម្រេចដោយការបង្កើតការតភ្ជាប់ជាមួយថ្នាំងបញ្ចប់ រក្សាទុកស្ថានភាពនៃការតភ្ជាប់នោះ បង្ហាញពីចំនួនបៃដែលបានផ្ញើនៅក្នុងបឋមកថានៃកញ្ចប់ព័ត៌មាននីមួយៗ និងការជូនដំណឹងបង្កាន់ដៃដោយប្រើលេខទទួលស្គាល់។

លើសពីនេះទៀត ដើម្បីបង្កើនការអនុវត្ត (ឧ. ផ្ញើច្រើនជាងមួយផ្នែកដោយមិនទទួលបានការទទួលស្គាល់) ពិធីការ TCP ប្រើអ្វីដែលគេហៅថា បង្អួចបញ្ជូន - ចំនួនបៃនៃទិន្នន័យដែលអ្នកផ្ញើនៃផ្នែករំពឹងថានឹងទទួលបាន។

សម្រាប់ព័ត៌មានបន្ថែមអំពីពិធីការ TCP សូមមើល rfc ១១២៣ពី UDP ទៅ rfc ១១២៣ដែលជាកន្លែងដែលជាការពិតពួកគេត្រូវបានកំណត់។

ពីខាងលើ វាច្បាស់ណាស់ថាដើម្បីបង្កើតពិធីការបញ្ជូនសារដែលអាចទុកចិត្តបានលើ UDP (តទៅនេះហៅថា UDP ដែលអាចទុកចិត្តបាន។) វាត្រូវបានទាមទារដើម្បីអនុវត្តយន្តការផ្ទេរទិន្នន័យស្រដៀងនឹង TCP ។ ពោលគឺ៖

• រក្សាទុកស្ថានភាពការតភ្ជាប់
• ប្រើលេខរៀងផ្នែក
• ប្រើកញ្ចប់បញ្ជាក់ពិសេស
• ប្រើយន្តការបើកបង្អួចសាមញ្ញ ដើម្បីបង្កើនដំណើរការនៃពិធីការ

លើសពីនេះទៀតអ្នកត្រូវការ:

• ជាសញ្ញានៃការចាប់ផ្តើមសារ ដើម្បីបែងចែកធនធានសម្រាប់ការតភ្ជាប់
• ផ្តល់សញ្ញាចុងបញ្ចប់នៃសារ ដើម្បីបញ្ជូនសារដែលបានទទួលទៅកម្មវិធីខាងលើ និងបញ្ចេញធនធានពិធីការ
• អនុញ្ញាតឱ្យពិធីការជាក់លាក់នៃការតភ្ជាប់ដើម្បីបិទយន្តការបញ្ជាក់ការចែកចាយដើម្បីដំណើរការជា UDP "បរិសុទ្ធ"

ក្បាល UDP ដែលអាចទុកចិត្តបាន។

សូមចាំថា UDP datagram ត្រូវបានរុំព័ទ្ធក្នុង IP datagram។ កញ្ចប់ព័ត៌មាន UDP ដែលអាចជឿទុកចិត្តបានត្រូវបាន "រុំ" យ៉ាងត្រឹមត្រូវទៅក្នុង UDP datagram ។
ការវេចខ្ចប់បឋមកថា UDP ដែលអាចទុកចិត្តបាន៖

រចនាសម្ព័ន្ធនៃបឋមកថា UDP ដែលអាចជឿទុកចិត្តបានគឺសាមញ្ញណាស់:

• ទង់ជាតិ - ទង់គ្រប់គ្រងកញ្ចប់
• MessageType - ប្រភេទសារដែលប្រើដោយកម្មវិធីខាងលើដើម្បីជាវសារជាក់លាក់
• TransmissionId - ចំនួននៃការបញ្ជូន រួមជាមួយនឹងអាសយដ្ឋាន និងច្រករបស់អ្នកទទួល កំណត់អត្តសញ្ញាណការតភ្ជាប់តែមួយគត់។
• លេខកញ្ចប់ - លេខកញ្ចប់
• ជម្រើស - ជម្រើសពិធីការបន្ថែម។ ក្នុង​ករណី​នៃ​កញ្ចប់​ទីមួយ វា​ត្រូវ​បាន​ប្រើ​ដើម្បី​បង្ហាញ​ទំហំ​នៃ​សារ

ទង់ជាតិមានដូចខាងក្រោម៖

• FirstPacket - កញ្ចប់ដំបូងនៃសារ
• NoAsk - សារមិនតម្រូវឱ្យមានយន្តការទទួលស្គាល់ដើម្បីបើកដំណើរការទេ។
• LastPacket - កញ្ចប់ចុងក្រោយនៃសារ
• RequestForPacket - កញ្ចប់ព័ត៌មានបញ្ជាក់ ឬស្នើសុំកញ្ចប់ព័ត៌មានដែលបាត់

គោលការណ៍ទូទៅនៃពិធីសារ

ដោយសារ UDP ដែលអាចទុកចិត្តបានគឺផ្តោតលើការបញ្ជូនសារដែលមានការធានារវាងថ្នាំងពីរ វាត្រូវតែអាចបង្កើតការតភ្ជាប់ជាមួយភាគីម្ខាងទៀត។ ដើម្បីបង្កើតការតភ្ជាប់ អ្នកផ្ញើផ្ញើកញ្ចប់ព័ត៌មានដែលមានទង់ FirstPacket ការឆ្លើយតបដែលនឹងមានន័យថាការតភ្ជាប់ត្រូវបានបង្កើតឡើង។ កញ្ចប់ព័ត៌មានឆ្លើយតបទាំងអស់ ឬនិយាយម្យ៉ាងទៀត កញ្ចប់ព័ត៌មានទទួលស្គាល់ តែងតែកំណត់តម្លៃនៃប្រអប់លេខកញ្ចប់ទៅមួយច្រើនជាងតម្លៃកញ្ចប់លេខធំបំផុតនៃកញ្ចប់ព័ត៌មានដែលទទួលបានដោយជោគជ័យ។ វាលជម្រើសសម្រាប់កញ្ចប់ព័ត៌មានដំបូងដែលបានផ្ញើគឺជាទំហំនៃសារ។

យន្តការស្រដៀងគ្នានេះត្រូវបានប្រើដើម្បីបញ្ចប់ការតភ្ជាប់។ ទង់ LastPacket ត្រូវបានកំណត់នៅលើកញ្ចប់ព័ត៌មានចុងក្រោយនៃសារ។ នៅក្នុងកញ្ចប់ឆ្លើយតប ចំនួននៃកញ្ចប់ព័ត៌មានចុងក្រោយ + 1 ត្រូវបានចង្អុលបង្ហាញ ដែលសម្រាប់ផ្នែកទទួលមានន័យថាការបញ្ជូនសារដោយជោគជ័យ។
ដ្យាក្រាម​ការ​បង្កើត​និង​ការ​បញ្ចប់​ការ​តភ្ជាប់៖

នៅពេលដែលការតភ្ជាប់ត្រូវបានបង្កើតឡើង ការផ្ទេរទិន្នន័យចាប់ផ្តើម។ ទិន្នន័យត្រូវបានបញ្ជូនជាបណ្តុំនៃកញ្ចប់ព័ត៌មាន។ ប្លុកនីមួយៗ លើកលែងតែមួយចុងក្រោយ មានកញ្ចប់ព័ត៌មានចំនួនថេរ។ វាស្មើនឹងទំហំបង្អួចទទួល/បញ្ជូន។ ប្លុកទិន្នន័យចុងក្រោយអាចមានកញ្ចប់ព័ត៌មានតិចជាង។ បន្ទាប់ពីផ្ញើប្លុកនីមួយៗ ភាគីផ្ញើរង់ចាំការបញ្ជាក់ការដឹកជញ្ជូន ឬសំណើដើម្បីបញ្ជូនកញ្ចប់ដែលបាត់សារជាថ្មី ដោយទុកឱ្យបង្អួចទទួល/បញ្ជូនបើកដើម្បីទទួលការឆ្លើយតប។ បន្ទាប់ពីទទួលបានការបញ្ជាក់ពីការដឹកជញ្ជូនប្លុក បង្អួចទទួល/បញ្ជូនផ្លាស់ប្តូរ ហើយប្លុកបន្ទាប់នៃទិន្នន័យត្រូវបានផ្ញើ។

ភាគីទទួលទទួលកញ្ចប់។ កញ្ចប់នីមួយៗត្រូវបានពិនិត្យ ដើម្បីមើលថាតើវាធ្លាក់ក្នុងបង្អួចបញ្ជូនឬអត់។ កញ្ចប់​និង​ស្ទួន​ដែល​មិន​ធ្លាក់​ចូល​ក្នុង​បង្អួច​ត្រូវ​បាន​ច្រោះ​ចេញ។ ដោយសារតែ ប្រសិនបើទំហំនៃវិនដូត្រូវបានជួសជុល ហើយដូចគ្នាសម្រាប់អ្នកទទួល និងអ្នកផ្ញើ នោះក្នុងករណីដែលប្លុកនៃកញ្ចប់ព័ត៌មានត្រូវបានបញ្ជូនដោយមិនបាត់បង់ នោះបង្អួចត្រូវបានប្តូរទៅទទួលកញ្ចប់ព័ត៌មាននៃប្លុកបន្ទាប់នៃទិន្នន័យ ហើយការបញ្ជាក់អំពីការដឹកជញ្ជូនគឺ បានផ្ញើ។ ប្រសិនបើវិនដូមិនបំពេញក្នុងរយៈពេលកំណត់ដោយកម្មវិធីកំណត់ម៉ោងការងារទេ នោះការត្រួតពិនិត្យនឹងត្រូវបានចាប់ផ្តើមដែលកញ្ចប់ព័ត៌មានមិនទាន់ត្រូវបានបញ្ជូន ហើយសំណើសម្រាប់ការដឹកជញ្ជូនឡើងវិញនឹងត្រូវបានផ្ញើ។
ដ្យាក្រាមបញ្ជូនបន្ត៖

ការអស់ពេល និងកម្មវិធីកំណត់ពេលវេលាពិធីការ

មានហេតុផលជាច្រើនដែលការតភ្ជាប់មិនអាចបង្កើតបាន។ ឧទាហរណ៍ ប្រសិនបើភាគីទទួលមិនមានអ៊ីនធឺណិត។ ក្នុងករណីនេះ នៅពេលព្យាយាមបង្កើតការតភ្ជាប់ ការតភ្ជាប់នឹងត្រូវបានបិទដោយអស់ពេល។ ការអនុវត្ត UDP ដែលអាចទុកចិត្តបានប្រើកម្មវិធីកំណត់ម៉ោងពីរដើម្បីកំណត់ពេលវេលាអស់ពេល។ ទីមួយ កម្មវិធីកំណត់ម៉ោងធ្វើការ ត្រូវបានប្រើដើម្បីរង់ចាំការឆ្លើយតបពីម៉ាស៊ីនពីចម្ងាយ។ ប្រសិនបើវាឆេះនៅផ្នែកអ្នកផ្ញើ នោះកញ្ចប់ព័ត៌មានដែលបានផ្ញើចុងក្រោយនឹងត្រលប់មកវិញ។ ប្រសិនបើកម្មវិធីកំណត់ម៉ោងផុតកំណត់នៅអ្នកទទួល នោះការត្រួតពិនិត្យកញ្ចប់ព័ត៌មានដែលបាត់ត្រូវបានអនុវត្ត ហើយសំណើសម្រាប់ការដឹកជញ្ជូនឡើងវិញត្រូវបានផ្ញើ។

ឧបករណ៍កំណត់ម៉ោងទីពីរគឺត្រូវការដើម្បីបិទការតភ្ជាប់ក្នុងករណីដែលខ្វះទំនាក់ទំនងរវាងថ្នាំង។ សម្រាប់ភាគីអ្នកផ្ញើ វាចាប់ផ្តើមភ្លាមៗបន្ទាប់ពីកម្មវិធីកំណត់ម៉ោងធ្វើការផុតកំណត់ ហើយរង់ចាំការឆ្លើយតបពីថ្នាំងពីចម្ងាយ។ ប្រសិនបើមិនមានការឆ្លើយតបក្នុងរយៈពេលដែលបានបញ្ជាក់ទេ ការតភ្ជាប់ត្រូវបានបញ្ចប់ ហើយធនធានត្រូវបានបញ្ចេញ។ សម្រាប់ផ្នែកទទួល ឧបករណ៍កំណត់ម៉ោងបិទនៃការតភ្ជាប់ត្រូវបានចាប់ផ្តើមបន្ទាប់ពីកម្មវិធីកំណត់ម៉ោងការងារផុតកំណត់ពីរដង។ នេះគឺចាំបាច់ដើម្បីធានាប្រឆាំងនឹងការបាត់បង់កញ្ចប់ព័ត៌មានបញ្ជាក់។ នៅពេលដែលកម្មវិធីកំណត់ម៉ោងផុតកំណត់ ការតភ្ជាប់ក៏ត្រូវបានបិទ ហើយធនធានត្រូវបានបញ្ចេញ។

ដ្យាក្រាមស្ថានភាពបញ្ជូន UDP ដែលអាចទុកចិត្តបាន។

គោលការណ៍នៃពិធីការត្រូវបានអនុវត្តនៅក្នុងម៉ាស៊ីនរដ្ឋកំណត់ ដែលរដ្ឋនីមួយៗទទួលខុសត្រូវចំពោះតក្កវិជ្ជាជាក់លាក់នៃដំណើរការកញ្ចប់ព័ត៌មាន។
ដ្យាក្រាមរដ្ឋ UDP ដែលអាចទុកចិត្តបាន៖

​បិទ - មិនមែនជារដ្ឋទេ វាជាចំណុចចាប់ផ្តើម និងបញ្ចប់សម្រាប់ automaton ។ សម្រាប់រដ្ឋ ​បិទ ប្លុកត្រួតពិនិត្យការបញ្ជូនត្រូវបានទទួល ដែលអនុវត្តម៉ាស៊ីនមេ UDP អសមកាល បញ្ជូនកញ្ចប់ព័ត៌មានទៅកាន់ការតភ្ជាប់ដែលសមស្រប ហើយចាប់ផ្តើមដំណើរការរដ្ឋ។

ការផ្ញើកញ្ចប់ដំបូង - ស្ថានភាពដំបូងដែលការតភ្ជាប់ចេញគឺនៅពេលដែលសារត្រូវបានផ្ញើ។

នៅក្នុងស្ថានភាពនេះ កញ្ចប់ដំបូងសម្រាប់សារធម្មតាត្រូវបានផ្ញើ។ សម្រាប់​សារ​ដែល​មិន​មាន​ការ​ផ្ញើ​បញ្ជាក់ នេះ​ជា​ស្ថានភាព​តែ​មួយ​គត់​ដែល​សារ​ទាំង​មូល​ត្រូវ​បាន​ផ្ញើ។

វដ្តបញ្ជូន - ស្ថានភាពមូលដ្ឋានសម្រាប់ការបញ្ជូនកញ្ចប់សារ។

ការផ្លាស់ប្តូរទៅវាពីរដ្ឋ ការផ្ញើកញ្ចប់ដំបូង ត្រូវបានអនុវត្តបន្ទាប់ពីកញ្ចប់ដំបូងនៃសារត្រូវបានផ្ញើ។ វាស្ថិតនៅក្នុងស្ថានភាពនេះ ដែលរាល់ការទទួលស្គាល់ និងសំណើសម្រាប់ការបញ្ជូនសារឡើងវិញមក។ ការចាកចេញពីវាគឺអាចធ្វើទៅបានក្នុងករណីពីរ - ក្នុងករណីដែលការបញ្ជូនសារបានជោគជ័យឬដោយការអស់ពេល។

កញ្ចប់ទីមួយបានទទួល - ស្ថានភាពដំបូងសម្រាប់អ្នកទទួលសារ។

វាពិនិត្យភាពត្រឹមត្រូវនៃការចាប់ផ្តើមនៃការបញ្ជូន បង្កើតរចនាសម្ព័ន្ធចាំបាច់ និងផ្ញើការទទួលស្គាល់នៃការទទួលកញ្ចប់ព័ត៌មានដំបូង។

សម្រាប់សារដែលមានកញ្ចប់តែមួយ ហើយត្រូវបានផ្ញើដោយមិនប្រើភស្តុតាងនៃការដឹកជញ្ជូន នេះគឺជារដ្ឋតែមួយគត់។ បន្ទាប់ពីដំណើរការសារបែបនេះ ការតភ្ជាប់ត្រូវបានបិទ។

ដំឡើង - ស្ថានភាពមូលដ្ឋានសម្រាប់ការទទួលកញ្ចប់សារ។

វាសរសេរកញ្ចប់ព័ត៌មានទៅកន្លែងផ្ទុកបណ្តោះអាសន្ន ពិនិត្យមើលការបាត់បង់កញ្ចប់ព័ត៌មាន ផ្ញើការទទួលស្គាល់សម្រាប់ការចែកចាយកញ្ចប់កញ្ចប់ព័ត៌មាន និងសារទាំងមូល និងផ្ញើសំណើសម្រាប់ការដឹកជញ្ជូនឡើងវិញនៃកញ្ចប់ព័ត៌មានដែលបាត់។ ក្នុងករណីដែលបានទទួលជោគជ័យនៃសារទាំងមូល ការតភ្ជាប់ចូលទៅក្នុងរដ្ឋ បានបញ្ចប់បើមិនដូច្នេះទេ ការអស់ពេលចេញ។

បានបញ្ចប់ - បិទការតភ្ជាប់ក្នុងករណីទទួលបានសារទាំងមូលដោយជោគជ័យ។

រដ្ឋនេះគឺចាំបាច់សម្រាប់ការជួបប្រជុំគ្នានៃសារ និងសម្រាប់ករណីនៅពេលដែលការបញ្ជាក់ការបញ្ជូនសារត្រូវបានបាត់បង់នៅតាមផ្លូវទៅកាន់អ្នកផ្ញើ។ ស្ថានភាពនេះត្រូវបានចាកចេញដោយការអស់ពេល ប៉ុន្តែការតភ្ជាប់ត្រូវបានចាត់ទុកថាបានបិទដោយជោគជ័យ។

កាន់តែស៊ីជម្រៅទៅក្នុងកូដ។ អង្គភាពត្រួតពិនិត្យការបញ្ជូន

ធាតុសំខាន់មួយនៃ UDP ដែលអាចទុកចិត្តបានគឺប្លុកត្រួតពិនិត្យការបញ្ជូន។ ភារកិច្ចនៃប្លុកនេះគឺដើម្បីរក្សាទុកការតភ្ជាប់បច្ចុប្បន្ន និងធាតុជំនួយ ចែកចាយកញ្ចប់ព័ត៌មានចូលទៅកាន់ការតភ្ជាប់ដែលត្រូវគ្នា ផ្តល់ចំណុចប្រទាក់សម្រាប់ការផ្ញើកញ្ចប់ព័ត៌មានទៅកាន់ការតភ្ជាប់ និងអនុវត្តពិធីការ API ។ ប្លុកត្រួតពិនិត្យការបញ្ជូនទទួលបានកញ្ចប់ព័ត៌មានពីស្រទាប់ UDP ហើយបញ្ជូនវាទៅម៉ាស៊ីនរដ្ឋសម្រាប់ដំណើរការ។ ដើម្បីទទួលបានកញ្ចប់ព័ត៌មាន វាអនុវត្តម៉ាស៊ីនមេ UDP អសមកាល។
សមាជិកមួយចំនួននៃថ្នាក់ 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 អសមកាល៖

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 ដែលអាចទុកចិត្តបាន ដែលដំណើរការសំខាន់នៃកញ្ចប់ព័ត៌មានកើតឡើង។ ថ្នាក់អរូបី 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();
}

វាត្រូវបានបដិសេធតែនៅក្នុងរដ្ឋប៉ុណ្ណោះ។ បានបញ្ចប់.
បានបញ្ចប់។ DisposeByTimeout៖

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

វិធីសាស្ត្រដំណើរការកញ្ចប់

វិធីសាស្ត្រ 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);
}

អាច បានបញ្ចប់ វិធីសាស្រ្តបញ្ឈប់កម្មវិធីកំណត់ម៉ោងដែលកំពុងដំណើរការ ហើយផ្ញើសារទៅកាន់អ្នកជាវ។
បានបញ្ចប់។ កញ្ចប់ដំណើរការ៖

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

វិធីសាស្ត្រទទួលកញ្ចប់

អាច កញ្ចប់ទីមួយបានទទួល ភារកិច្ចចម្បងនៃវិធីសាស្ត្រគឺដើម្បីកំណត់ថាតើកញ្ចប់សារដំបូងពិតជាបានមកដល់ចំណុចប្រទាក់ ហើយក៏ដើម្បីប្រមូលសារដែលមានកញ្ចប់ព័ត៌មានតែមួយ។
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);
  }
}

អាច វដ្តបញ្ជូន វិធីសាស្រ្តនេះត្រូវបានបដិសេធដើម្បីទទួលយកការទទួលស្គាល់ការដឹកជញ្ជូន និងសំណើបញ្ជូនឡើងវិញ។
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));
}

អាច ដំឡើង នៅក្នុងវិធីទទួលកញ្ចប់ព័ត៌មាន ការងារចម្បងនៃការប្រមូលផ្តុំសារពីកញ្ចប់ព័ត៌មានចូលកើតឡើង។
ការប្រមូលផ្តុំ.ទទួលកញ្ចប់៖

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);
  }
}

អាច បានបញ្ចប់ ភារកិច្ចតែមួយគត់នៃវិធីសាស្រ្តគឺដើម្បីផ្ញើការទទួលស្គាល់ឡើងវិញនៃការបញ្ជូនសារដោយជោគជ័យ។
បានបញ្ចប់។ កញ្ចប់ទទួល៖

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

វិធីសាស្ត្រផ្ញើកញ្ចប់

អាច ការផ្ញើកញ្ចប់ដំបូង វិធីសាស្ត្រនេះផ្ញើកញ្ចប់ទិន្នន័យដំបូង ឬប្រសិនបើសារមិនតម្រូវឱ្យមានការបញ្ជាក់ការបញ្ជូនទេ សារទាំងមូល។
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 នៃប្លុកត្រួតពិនិត្យការបញ្ជូនត្រូវបានហៅ ដែលចាប់ផ្តើមការបញ្ជូនទិន្នន័យសម្រាប់សារថ្មី។
បង្កើតការតភ្ជាប់ចេញ៖

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 ទទួលកញ្ចប់ព័ត៌មានដែលបានផ្ញើ បង្កើតថ្មី។ កំណត់ត្រាការតភ្ជាប់ ហើយឆ្លងកាត់កញ្ចប់ព័ត៌មាននេះ ជាមួយនឹងបឋមកថាដែលបានញែកជាមុនទៅកាន់វិធីសាស្ត្រទទួលកញ្ចប់ព័ត៌មាននៃរដ្ឋសម្រាប់ដំណើរការ កញ្ចប់ទីមួយបានទទួល
បង្កើតការតភ្ជាប់នៅផ្នែកទទួល៖

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);
}

ការទទួលកញ្ចប់ព័ត៌មានដំបូង និងផ្ញើការទទួលស្គាល់ (រដ្ឋទទួលកញ្ចប់ដំបូង):

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 នៃរដ្ឋ វដ្តបញ្ជូន.
បើកដំណើរការកម្មវិធីកំណត់ម៉ោងធ្វើការ (ស្ថានភាពបញ្ជូនវដ្ត)៖

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 វិនាទី។

សម្រាប់ការតភ្ជាប់ចូល កម្មវិធីកំណត់ម៉ោងចាប់ផ្តើមបន្ទាប់ពីទទួលបានកញ្ចប់ទិន្នន័យចុងក្រោយ ដែលវាកើតឡើងនៅក្នុងវិធីសាស្ត្រទទួលកញ្ចប់ព័ត៌មានរបស់រដ្ឋ ដំឡើង
បើកដំណើរការកម្មវិធីកំណត់ម៉ោងការងារ (ស្ថានភាពប្រមូលផ្តុំ)៖

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);
  }
}

កាន់តែស៊ីជម្រៅទៅក្នុងកូដ។ ការស្តារការផ្ទេរទិន្នន័យ

ដ្យាក្រាមស្តារការបញ្ជូនទិន្នន័យក្នុងករណីបាត់បង់កញ្ចប់ព័ត៌មាន៖

ដូចដែលបានពិភាក្សារួចហើយក្នុងការបិទការតភ្ជាប់នៅពេលអស់ពេល នៅពេលដែលអ្នកកំណត់ម៉ោងធ្វើការផុតកំណត់ អ្នកទទួលនឹងពិនិត្យមើលកញ្ចប់ព័ត៌មានដែលបាត់។ ក្នុងករណីបាត់បង់កញ្ចប់ព័ត៌មាន បញ្ជីនៃចំនួនកញ្ចប់ព័ត៌មានដែលមិនបានទៅដល់អ្នកទទួលនឹងត្រូវបានចងក្រង។ លេខទាំងនេះត្រូវបានបញ្ចូលទៅក្នុងអារេ 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 ក្នុងដ្យាក្រាម) ត្រូវបានទទួលដោយការតភ្ជាប់ចូល។ ការត្រួតពិនិត្យត្រូវបានធ្វើឡើងដើម្បីមើលថាតើបង្អួចទទួលគឺពេញហើយការបញ្ជូនទិន្នន័យធម្មតាត្រូវបានស្ដារឡើងវិញ។
ពិនិត្យរកមើលការចុចនៅក្នុងបង្អួចទទួល (ស្ថានភាពប្រមូលផ្តុំ):

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 ដែល​អាច​ជឿ​ទុក​ចិត្ត​បាន​បើក ដែល​ជា​ការ​រុំ​លើ​ប្លុក​គ្រប់គ្រង​ការ​ផ្ទេរ។ នេះគឺជាសមាជិកសំខាន់ៗនៃថ្នាក់៖

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,
  // ...
}

សារ​ត្រូវ​បាន​ផ្ញើ​ដោយ​អសមកាល​សម្រាប់​នេះ ពិធីការ​អនុវត្ត​គំរូ​កម្មវិធី​អសមកាល៖

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

លទ្ធផលនៃការផ្ញើសារនឹងពិត - ប្រសិនបើសារបានទៅដល់អ្នកទទួលដោយជោគជ័យ និងមិនពិត - ប្រសិនបើការតភ្ជាប់ត្រូវបានបិទដោយអស់ពេល៖

public bool EndSendMessage(IAsyncResult asyncResult)

សេចក្តីសន្និដ្ឋាន

ភាគច្រើនមិនត្រូវបានពិពណ៌នានៅក្នុងអត្ថបទនេះទេ។ យន្តការផ្គូផ្គងខ្សែស្រឡាយ ការលើកលែង និងការដោះស្រាយកំហុស ការអនុវត្តវិធីសាស្ត្រផ្ញើសារអសមកាល។ ប៉ុន្តែស្នូលនៃពិធីការ ការពិពណ៌នាអំពីតក្កវិជ្ជាសម្រាប់ដំណើរការកញ្ចប់ព័ត៌មាន ការបង្កើតការតភ្ជាប់ និងការគ្រប់គ្រងការអស់ពេល គួរតែច្បាស់សម្រាប់អ្នក។

កំណែដែលបានបង្ហាញនៃពិធីការចែកចាយដែលអាចទុកចិត្តបានគឺរឹងមាំ និងអាចបត់បែនបានគ្រប់គ្រាន់ដើម្បីបំពេញតាមតម្រូវការដែលបានកំណត់ពីមុន។ ប៉ុន្តែខ្ញុំចង់បន្ថែមថាការអនុវត្តដែលបានពិពណ៌នាអាចត្រូវបានកែលម្អ។ ជាឧទាហរណ៍ ដើម្បីបង្កើនការបញ្ជូនបន្ត និងផ្លាស់ប្តូរពេលវេលាកំណត់ថាមវន្ត យន្តការដូចជាបង្អួចរអិល និង RTT អាចត្រូវបានបន្ថែមទៅពិធីការ វាក៏នឹងមានប្រយោជន៍ផងដែរក្នុងការអនុវត្តយន្តការសម្រាប់កំណត់ MTU រវាងថ្នាំងការតភ្ជាប់ (ប៉ុន្តែប្រសិនបើសារធំត្រូវបានផ្ញើ) .

សូមអរគុណចំពោះការយកចិត្តទុកដាក់របស់អ្នក ខ្ញុំទន្ទឹងរង់ចាំមតិយោបល់ និងយោបល់របស់អ្នក។

PS សម្រាប់​អ្នក​ដែល​ចាប់​អារម្មណ៍​លម្អិត​ឬ​គ្រាន់​តែ​ចង់​សាកល្បង​ពិធីការ​, តំណ​ទៅ​កាន់​គម្រោង​នៅ​លើ GitHube​:
គម្រោង UDP ដែលអាចទុកចិត្តបាន។

តំណភ្ជាប់ និងអត្ថបទមានប្រយោជន៍

1. លក្ខណៈបច្ចេកទេសនៃពិធីការ TCP៖ ជាភាសាអង់គ្លេស и នៅ​ក្នុង​ប្រទេស​រុស្ស៊ី
2. ការកំណត់ពិធីការ UDP៖ ជាភាសាអង់គ្លេស и នៅ​ក្នុង​ប្រទេស​រុស្ស៊ី
3. ការពិភាក្សាអំពីពិធីសារ RUDP៖ draft-ietf-sigtran-reliable-udp-00
4. ពិធីសារទិន្នន័យដែលអាចទុកចិត្តបាន៖ rfc ១១២៣ и rfc ១១២៣
5. ការអនុវត្តសាមញ្ញនៃការបញ្ជាក់ការចែកចាយលើ UDP៖ គ្រប់គ្រងសរុបនៃបណ្តាញរបស់អ្នកជាមួយ .NET និង UDP
6. អត្ថបទពិពណ៌នាអំពីយន្តការឆ្លងកាត់ NAT៖ ការប្រាស្រ័យទាក់ទងពីមិត្តភ័ក្តិឆ្លងតាមបណ្តាញអ្នកបកប្រែអាសយដ្ឋាន
7. ការអនុវត្តគំរូកម្មវិធីអសមកាល៖ ការអនុវត្ត CLR Asynchronous Programming Model и របៀបអនុវត្តគំរូរចនា IAsyncResult
8. ការបញ្ជូនគំរូកម្មវិធីអសមកាលទៅលំនាំអសមកាលផ្អែកលើភារកិច្ច (APM ក្នុង TAP)៖
   កម្មវិធី TPL និងប្រពៃណី .NET Asynchronous Programming
   អន្តរកម្មជាមួយលំនាំ និងប្រភេទអសមកាលផ្សេងទៀត។

បច្ចុប្បន្នភាព៖ សូមអរគុណ Mayorovp и ស៊ីដរីស្ត សម្រាប់គំនិតនៃការបន្ថែមភារកិច្ចទៅចំណុចប្រទាក់។ ភាពឆបគ្នានៃបណ្ណាល័យជាមួយប្រព័ន្ធប្រតិបត្តិការចាស់មិនត្រូវបានរំលោភទេព្រោះ ក្របខ័ណ្ឌទី 4 គាំទ្រទាំងម៉ាស៊ីនមេ XP និង 2003 ។

ប្រភព: www.habr.com