.Net-നുള്ള വിശ്വസനീയമായ Udp പ്രോട്ടോക്കോൾ നടപ്പിലാക്കൽ

ഇന്റർനെറ്റ് വളരെക്കാലം മുമ്പ് മാറിയിരിക്കുന്നു. ഇന്റർനെറ്റിന്റെ പ്രധാന പ്രോട്ടോക്കോളുകളിൽ ഒന്ന് - യുഡിപി ഡാറ്റാഗ്രാമുകളും പ്രക്ഷേപണങ്ങളും നൽകുന്നതിന് മാത്രമല്ല, നെറ്റ്‌വർക്ക് നോഡുകൾക്കിടയിൽ "പിയർ-ടു-പിയർ" കണക്ഷനുകൾ നൽകാനും ആപ്ലിക്കേഷനുകൾ ഉപയോഗിക്കുന്നു. ലളിതമായ രൂപകൽപ്പന കാരണം, ഈ പ്രോട്ടോക്കോളിന് മുമ്പ് ആസൂത്രണം ചെയ്യാത്ത നിരവധി ഉപയോഗങ്ങളുണ്ട്, എന്നിരുന്നാലും, പ്രോട്ടോക്കോളിന്റെ പോരായ്മകൾ, ഗ്യാരണ്ടി ഡെലിവറി അഭാവം പോലെ, എവിടെയും അപ്രത്യക്ഷമായിട്ടില്ല. UDP-യിൽ ഗ്യാരണ്ടീഡ് ഡെലിവറി പ്രോട്ടോക്കോൾ നടപ്പിലാക്കുന്നതിനെ ഈ ലേഖനം വിവരിക്കുന്നു.
ഉള്ളടക്കം:എൻട്രി
പ്രോട്ടോക്കോൾ ആവശ്യകതകൾ
വിശ്വസനീയമായ UDP തലക്കെട്ട്
പ്രോട്ടോക്കോളിന്റെ പൊതു തത്വങ്ങൾ
ടൈംഔട്ടുകളും പ്രോട്ടോക്കോൾ ടൈമറുകളും
വിശ്വസനീയമായ UDP ട്രാൻസ്മിഷൻ സ്റ്റേറ്റ് ഡയഗ്രം
കോഡിലേക്ക് കൂടുതൽ ആഴത്തിൽ. ട്രാൻസ്മിഷൻ കൺട്രോൾ യൂണിറ്റ്
കോഡിലേക്ക് ആഴത്തിൽ. പ്രസ്താവിക്കുന്നു

• DisposeByTimeout രീതി
• ProcessPackets രീതി
• റിസീവ് പാക്കറ്റ് രീതി
• പാക്കറ്റ് രീതി അയയ്ക്കുക

കോഡിലേക്ക് കൂടുതൽ ആഴത്തിൽ. കണക്ഷനുകൾ സൃഷ്ടിക്കുകയും സ്ഥാപിക്കുകയും ചെയ്യുന്നു
കോഡിലേക്ക് ആഴത്തിൽ. കാലഹരണപ്പെടുമ്പോൾ കണക്ഷൻ ക്ലോസ് ചെയ്യുന്നു
കോഡിലേക്ക് ആഴത്തിൽ. ഡാറ്റ കൈമാറ്റം പുനഃസ്ഥാപിക്കുന്നു
വിശ്വസനീയമായ UDP API
തീരുമാനം
ഉപയോഗപ്രദമായ ലിങ്കുകളും ലേഖനങ്ങളും

എൻട്രി

ഇൻറർനെറ്റിന്റെ യഥാർത്ഥ ആർക്കിടെക്ചർ, ഓരോ നോഡിനും ആഗോളവും അതുല്യവുമായ ഐപി വിലാസം ഉള്ളതും മറ്റ് നോഡുകളുമായി നേരിട്ട് ആശയവിനിമയം നടത്താൻ കഴിയുന്നതുമായ ഒരു ഏകീകൃത വിലാസ ഇടം അനുമാനിച്ചു. ഇപ്പോൾ ഇൻറർനെറ്റിന് വ്യത്യസ്‌തമായ ഒരു ആർക്കിടെക്ചർ ഉണ്ട് - ആഗോള IP വിലാസങ്ങളുടെ ഒരു മേഖലയും NAT ഉപകരണങ്ങൾക്ക് പിന്നിൽ മറഞ്ഞിരിക്കുന്ന സ്വകാര്യ വിലാസങ്ങളുള്ള നിരവധി മേഖലകളും.ഈ ആർക്കിടെക്ചറിൽ, ആഗോള അഡ്രസ് സ്‌പെയ്‌സിലെ ഉപകരണങ്ങൾക്ക് മാത്രമേ നെറ്റ്‌വർക്കിലെ ആരുമായും എളുപ്പത്തിൽ ആശയവിനിമയം നടത്താൻ കഴിയൂ, കാരണം അവയ്ക്ക് സവിശേഷവും ആഗോളതലത്തിൽ റൂട്ട് ചെയ്യാവുന്നതുമായ ഐപി വിലാസമുണ്ട്. ഒരു സ്വകാര്യ നെറ്റ്‌വർക്കിലെ ഒരു നോഡിന് അതേ നെറ്റ്‌വർക്കിലെ മറ്റ് നോഡുകളിലേക്ക് കണക്റ്റുചെയ്യാനാകും, കൂടാതെ ആഗോള വിലാസ സ്‌പെയ്‌സിലെ മറ്റ് അറിയപ്പെടുന്ന നോഡുകളിലേക്ക് കണക്റ്റുചെയ്യാനും കഴിയും. നെറ്റ്‌വർക്ക് വിലാസ വിവർത്തന സംവിധാനം മൂലമാണ് ഈ ഇടപെടൽ പ്രധാനമായും കൈവരിക്കുന്നത്. Wi-Fi റൂട്ടറുകൾ പോലെയുള്ള NAT ഉപകരണങ്ങൾ ഔട്ട്‌ഗോയിംഗ് കണക്ഷനുകൾക്കായി പ്രത്യേക വിവർത്തന പട്ടിക എൻട്രികൾ സൃഷ്ടിക്കുകയും പാക്കറ്റുകളിലെ IP വിലാസങ്ങളും പോർട്ട് നമ്പറുകളും പരിഷ്‌ക്കരിക്കുകയും ചെയ്യുന്നു. ഇത് സ്വകാര്യ നെറ്റ്‌വർക്കിൽ നിന്ന് ആഗോള വിലാസ സ്‌പെയ്‌സിലെ ഹോസ്റ്റുകളിലേക്കുള്ള ഔട്ട്‌ഗോയിംഗ് കണക്ഷനുകളെ അനുവദിക്കുന്നു. എന്നാൽ അതേ സമയം, ഇൻകമിംഗ് കണക്ഷനുകൾക്കായി പ്രത്യേക നിയമങ്ങൾ സജ്ജമാക്കിയില്ലെങ്കിൽ NAT ഉപകരണങ്ങൾ സാധാരണയായി എല്ലാ ഇൻകമിംഗ് ട്രാഫിക്കും തടയുന്നു.

ക്ലയന്റ്-സെർവർ ആശയവിനിമയത്തിന് ഇന്റർനെറ്റിന്റെ ഈ ആർക്കിടെക്ചർ മതിയായതാണ്, അവിടെ ക്ലയന്റുകൾക്ക് സ്വകാര്യ നെറ്റ്‌വർക്കുകളിൽ ആയിരിക്കാം, കൂടാതെ സെർവറുകൾക്ക് ഒരു ആഗോള വിലാസമുണ്ട്. എന്നാൽ രണ്ട് നോഡുകളുടെ നേരിട്ടുള്ള കണക്ഷനുള്ള ബുദ്ധിമുട്ടുകൾ സൃഷ്ടിക്കുന്നു വിവിധ സ്വകാര്യ നെറ്റ്‌വർക്കുകൾ. വോയിസ് ട്രാൻസ്മിഷൻ (സ്കൈപ്പ്), കമ്പ്യൂട്ടറിലേക്ക് റിമോട്ട് ആക്സസ് നേടൽ (ടീംവ്യൂവർ) അല്ലെങ്കിൽ ഓൺലൈൻ ഗെയിമിംഗ് പോലുള്ള പിയർ-ടു-പിയർ ആപ്ലിക്കേഷനുകൾക്ക് രണ്ട് നോഡുകൾ തമ്മിലുള്ള നേരിട്ടുള്ള കണക്ഷൻ പ്രധാനമാണ്.

വ്യത്യസ്ത സ്വകാര്യ നെറ്റ്‌വർക്കുകളിലെ ഉപകരണങ്ങൾക്കിടയിൽ പിയർ-ടു-പിയർ കണക്ഷൻ സ്ഥാപിക്കുന്നതിനുള്ള ഏറ്റവും ഫലപ്രദമായ രീതികളിലൊന്നാണ് ഹോൾ പഞ്ചിംഗ്. UDP പ്രോട്ടോക്കോൾ അടിസ്ഥാനമാക്കിയുള്ള ആപ്ലിക്കേഷനുകളിലാണ് ഈ സാങ്കേതികവിദ്യ സാധാരണയായി ഉപയോഗിക്കുന്നത്.

എന്നാൽ നിങ്ങളുടെ അപ്ലിക്കേഷന് ഡാറ്റയുടെ ഗ്യാരണ്ടീഡ് ഡെലിവറി ആവശ്യമാണെങ്കിൽ, ഉദാഹരണത്തിന്, നിങ്ങൾ കമ്പ്യൂട്ടറുകൾക്കിടയിൽ ഫയലുകൾ കൈമാറുന്നു, യുഡിപി ഒരു ഗ്യാരണ്ടി ഡെലിവറി പ്രോട്ടോക്കോൾ അല്ലാത്തതിനാൽ ടിസിപിയിൽ നിന്ന് വ്യത്യസ്തമായി പാക്കറ്റ് ഡെലിവറി ക്രമത്തിൽ നൽകാത്തതിനാൽ യുഡിപി ഉപയോഗിക്കുന്നതിന് വളരെയധികം ബുദ്ധിമുട്ടുകൾ ഉണ്ടാകും. പ്രോട്ടോക്കോൾ.

ഈ സാഹചര്യത്തിൽ, ഗ്യാരണ്ടീഡ് പാക്കറ്റ് ഡെലിവറി ഉറപ്പാക്കാൻ, യുഡിപിയിൽ ആവശ്യമായ പ്രവർത്തനക്ഷമതയും പ്രവർത്തനവും നൽകുന്ന ഒരു ആപ്ലിക്കേഷൻ ലെയർ പ്രോട്ടോക്കോൾ നടപ്പിലാക്കേണ്ടതുണ്ട്.

വ്യത്യസ്ത സ്വകാര്യ നെറ്റ്‌വർക്കുകളിൽ നോഡുകൾക്കിടയിൽ ടിസിപി കണക്ഷനുകൾ സ്ഥാപിക്കുന്നതിന് ഒരു ടിസിപി ഹോൾ പഞ്ചിംഗ് ടെക്നിക് ഉണ്ടെന്ന് ഞാൻ ഉടനടി ശ്രദ്ധിക്കാൻ ആഗ്രഹിക്കുന്നു, എന്നാൽ പല NAT ഉപകരണങ്ങളും ഇതിന് പിന്തുണയില്ലാത്തതിനാൽ, ഇത് സാധാരണയായി കണക്റ്റുചെയ്യാനുള്ള പ്രധാന മാർഗമായി കണക്കാക്കില്ല. അത്തരം നോഡുകൾ.

ഈ ലേഖനത്തിന്റെ ബാക്കി ഭാഗങ്ങളിൽ, ഗ്യാരണ്ടീഡ് ഡെലിവറി പ്രോട്ടോക്കോൾ നടപ്പിലാക്കുന്നതിൽ മാത്രം ഞാൻ ശ്രദ്ധ കേന്ദ്രീകരിക്കും. യുഡിപി ഹോൾ പഞ്ചിംഗ് ടെക്നിക് നടപ്പിലാക്കുന്നത് ഇനിപ്പറയുന്ന ലേഖനങ്ങളിൽ വിവരിക്കും.

പ്രോട്ടോക്കോൾ ആവശ്യകതകൾ

1. ഒരു പോസിറ്റീവ് ഫീഡ്‌ബാക്ക് മെക്കാനിസത്തിലൂടെ നടപ്പിലാക്കിയ വിശ്വസനീയമായ പാക്കറ്റ് ഡെലിവറി (പോസിറ്റീവ് അംഗീകാരം എന്ന് വിളിക്കപ്പെടുന്നവ)
2. വലിയ ഡാറ്റയുടെ കാര്യക്ഷമമായ കൈമാറ്റത്തിന്റെ ആവശ്യകത, അതായത്. പ്രോട്ടോക്കോൾ അനാവശ്യ പാക്കറ്റ് റിലേയിംഗ് ഒഴിവാക്കണം
3. ഡെലിവറി സ്ഥിരീകരണ സംവിധാനം ("ശുദ്ധമായ" UDP പ്രോട്ടോക്കോൾ ആയി പ്രവർത്തിക്കാനുള്ള കഴിവ്) റദ്ദാക്കുന്നത് സാധ്യമായിരിക്കണം.
4. ഓരോ സന്ദേശത്തിന്റെയും സ്ഥിരീകരണത്തോടെ കമാൻഡ് മോഡ് നടപ്പിലാക്കാനുള്ള കഴിവ്
5. പ്രോട്ടോക്കോൾ വഴിയുള്ള ഡാറ്റ കൈമാറ്റത്തിന്റെ അടിസ്ഥാന യൂണിറ്റ് ഒരു സന്ദേശമായിരിക്കണം

ഈ ആവശ്യകതകൾ പ്രധാനമായും വിവരിച്ചിരിക്കുന്ന വിശ്വസനീയമായ ഡാറ്റാ പ്രോട്ടോക്കോൾ ആവശ്യകതകളുമായി പൊരുത്തപ്പെടുന്നു ആർഎഫ്സി 908 и ആർഎഫ്സി 1151, ഈ പ്രോട്ടോക്കോൾ വികസിപ്പിക്കുമ്പോൾ ഞാൻ ആ മാനദണ്ഡങ്ങളെ ആശ്രയിച്ചു.

ഈ ആവശ്യകതകൾ മനസിലാക്കാൻ, TCP, UDP പ്രോട്ടോക്കോളുകൾ ഉപയോഗിച്ച് രണ്ട് നെറ്റ്‌വർക്ക് നോഡുകൾ തമ്മിലുള്ള ഡാറ്റ കൈമാറ്റത്തിന്റെ സമയം നോക്കാം. രണ്ട് സാഹചര്യങ്ങളിലും നമുക്ക് ഒരു പാക്കറ്റ് നഷ്ടപ്പെടും.
ടിസിപി വഴി നോൺ-ഇന്ററാക്ടീവ് ഡാറ്റ കൈമാറ്റം:

ഡയഗ്രാമിൽ നിന്ന് നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, പാക്കറ്റ് നഷ്‌ടപ്പെടുകയാണെങ്കിൽ, നഷ്ടപ്പെട്ട പാക്കറ്റ് TCP കണ്ടെത്തുകയും നഷ്‌ടപ്പെട്ട സെഗ്‌മെന്റിന്റെ നമ്പർ ചോദിച്ച് അയച്ചയാളെ അറിയിക്കുകയും ചെയ്യും.
UDP പ്രോട്ടോക്കോൾ വഴി ഡാറ്റ കൈമാറ്റം:

UDP നഷ്ടം കണ്ടെത്തുന്നതിനുള്ള നടപടികളൊന്നും സ്വീകരിക്കുന്നില്ല. UDP പ്രോട്ടോക്കോളിലെ ട്രാൻസ്മിഷൻ പിശകുകളുടെ നിയന്ത്രണം പൂർണ്ണമായും ആപ്ലിക്കേഷന്റെ ഉത്തരവാദിത്തമാണ്.

ഒരു എൻഡ് നോഡുമായി ഒരു കണക്ഷൻ സ്ഥാപിച്ച്, ആ കണക്ഷന്റെ അവസ്ഥ സംഭരിച്ചുകൊണ്ട്, ഓരോ പാക്കറ്റ് ഹെഡറിലും അയച്ച ബൈറ്റുകളുടെ എണ്ണം സൂചിപ്പിച്ചും ഒരു അക്നോളജ്മെന്റ് നമ്പർ ഉപയോഗിച്ച് രസീതുകൾ അറിയിക്കുന്നതിലൂടെയും TCP പ്രോട്ടോക്കോളിൽ പിശക് കണ്ടെത്തൽ സാധ്യമാണ്.

കൂടാതെ, പ്രകടനം മെച്ചപ്പെടുത്തുന്നതിന് (അതായത് ഒരു അംഗീകാരം ലഭിക്കാതെ ഒന്നിലധികം സെഗ്‌മെന്റുകൾ അയയ്‌ക്കുക), TCP പ്രോട്ടോക്കോൾ ട്രാൻസ്മിഷൻ വിൻഡോ എന്ന് വിളിക്കുന്നു - സെഗ്‌മെന്റിന്റെ അയക്കുന്നയാൾക്ക് ലഭിക്കുമെന്ന് പ്രതീക്ഷിക്കുന്ന ഡാറ്റയുടെ ബൈറ്റുകളുടെ എണ്ണം.

TCP പ്രോട്ടോക്കോളിനെക്കുറിച്ചുള്ള കൂടുതൽ വിവരങ്ങൾക്ക്, കാണുക ആർഎഫ്സി 793, UDP മുതൽ ആർഎഫ്സി 768എവിടെ, വാസ്തവത്തിൽ, അവ നിർവചിക്കപ്പെട്ടിരിക്കുന്നു.

മുകളിൽ പറഞ്ഞവയിൽ നിന്ന്, UDP-യിൽ വിശ്വസനീയമായ ഒരു സന്ദേശ വിതരണ പ്രോട്ടോക്കോൾ സൃഷ്ടിക്കുന്നതിന് (ഇനി മുതൽ വിശ്വസനീയമായ UDP), ടിസിപിക്ക് സമാനമായ ഡാറ്റാ ട്രാൻസ്ഫർ മെക്കാനിസങ്ങൾ നടപ്പിലാക്കേണ്ടത് ആവശ്യമാണ്. അതായത്:

• കണക്ഷൻ നില സംരക്ഷിക്കുക
• സെഗ്മെന്റ് നമ്പറിംഗ് ഉപയോഗിക്കുക
• പ്രത്യേക സ്ഥിരീകരണ പാക്കേജുകൾ ഉപയോഗിക്കുക
• പ്രോട്ടോക്കോൾ ത്രൂപുട്ട് വർദ്ധിപ്പിക്കുന്നതിന് ഒരു ലളിതമായ വിൻഡോ സംവിധാനം ഉപയോഗിക്കുക

കൂടാതെ, നിങ്ങൾക്ക് ഇത് ആവശ്യമാണ്:

• കണക്ഷനുള്ള വിഭവങ്ങൾ അനുവദിക്കുന്നതിന് ഒരു സന്ദേശത്തിന്റെ ആരംഭം സൂചിപ്പിക്കുക
• ലഭിച്ച സന്ദേശം അപ്‌സ്ട്രീം ആപ്ലിക്കേഷനിലേക്ക് കൈമാറുന്നതിനും പ്രോട്ടോക്കോൾ ഉറവിടങ്ങൾ റിലീസ് ചെയ്യുന്നതിനും ഒരു സന്ദേശത്തിന്റെ അവസാനം സൂചന നൽകുക
• "ശുദ്ധമായ" UDP ആയി പ്രവർത്തിക്കാൻ ഡെലിവറി സ്ഥിരീകരണ സംവിധാനം പ്രവർത്തനരഹിതമാക്കാൻ കണക്ഷൻ-നിർദ്ദിഷ്ട പ്രോട്ടോക്കോൾ അനുവദിക്കുക

വിശ്വസനീയമായ UDP തലക്കെട്ട്

ഒരു യുഡിപി ഡാറ്റഗ്രാം ഒരു ഐപി ഡാറ്റാഗ്രാമിൽ ഉൾപ്പെടുത്തിയിരിക്കുന്നത് ഓർക്കുക. വിശ്വസനീയമായ UDP പാക്കറ്റ് ഒരു UDP ഡാറ്റാഗ്രാമിലേക്ക് ഉചിതമായി "പൊതിഞ്ഞിരിക്കുന്നു".
വിശ്വസനീയമായ UDP തലക്കെട്ട് എൻക്യാപ്‌സുലേഷൻ:

വിശ്വസനീയമായ UDP തലക്കെട്ടിന്റെ ഘടന വളരെ ലളിതമാണ്:

• പതാകകൾ - പാക്കേജ് നിയന്ത്രണ ഫ്ലാഗുകൾ
• MessageType - നിർദ്ദിഷ്ട സന്ദേശങ്ങൾ സബ്‌സ്‌ക്രൈബുചെയ്യാൻ അപ്‌സ്ട്രീം ആപ്ലിക്കേഷനുകൾ ഉപയോഗിക്കുന്ന സന്ദേശ തരം
• TransmissionId - ട്രാൻസ്മിഷൻ നമ്പർ, സ്വീകർത്താവിന്റെ വിലാസവും പോർട്ടും ചേർന്ന്, കണക്ഷനെ അദ്വിതീയമായി തിരിച്ചറിയുന്നു
• പാക്കറ്റ് നമ്പർ - പാക്കറ്റ് നമ്പർ
• ഓപ്ഷനുകൾ - അധിക പ്രോട്ടോക്കോൾ ഓപ്ഷനുകൾ. ആദ്യത്തെ പാക്കറ്റിന്റെ കാര്യത്തിൽ, സന്ദേശത്തിന്റെ വലുപ്പം സൂചിപ്പിക്കാൻ ഇത് ഉപയോഗിക്കുന്നു

പതാകകൾ ഇപ്രകാരമാണ്:

• ആദ്യപാക്കറ്റ് - സന്ദേശത്തിന്റെ ആദ്യ പാക്കറ്റ്
• NoAsk - സന്ദേശത്തിന് ഒരു അംഗീകാര സംവിധാനം പ്രവർത്തനക്ഷമമാക്കേണ്ട ആവശ്യമില്ല
• LastPacket - സന്ദേശത്തിന്റെ അവസാന പാക്കറ്റ്
• RequestForPacket - സ്ഥിരീകരണ പാക്കറ്റ് അല്ലെങ്കിൽ നഷ്ടപ്പെട്ട പാക്കറ്റിനായി അഭ്യർത്ഥിക്കുക

പ്രോട്ടോക്കോളിന്റെ പൊതു തത്വങ്ങൾ

വിശ്വസനീയമായ UDP രണ്ട് നോഡുകൾക്കിടയിലുള്ള ഗ്യാരണ്ടീഡ് സന്ദേശ പ്രക്ഷേപണത്തിൽ ശ്രദ്ധ കേന്ദ്രീകരിച്ചിരിക്കുന്നതിനാൽ, അതിന് മറുവശവുമായി ഒരു ബന്ധം സ്ഥാപിക്കാൻ കഴിയണം. ഒരു കണക്ഷൻ സ്ഥാപിക്കുന്നതിന്, അയച്ചയാൾ ഫസ്റ്റ്പാക്കറ്റ് ഫ്ലാഗ് ഉള്ള ഒരു പാക്കറ്റ് അയയ്ക്കുന്നു, അതിനുള്ള പ്രതികരണം കണക്ഷൻ സ്ഥാപിച്ചു എന്നാണ് അർത്ഥമാക്കുന്നത്. എല്ലാ പ്രതികരണ പാക്കറ്റുകളും, അല്ലെങ്കിൽ, മറ്റൊരു വിധത്തിൽ പറഞ്ഞാൽ, അക്‌നോളജ്‌മെന്റ് പാക്കറ്റുകളും, പാക്കറ്റ് നമ്പർ ഫീൽഡിന്റെ മൂല്യം, വിജയകരമായി ലഭിച്ച പാക്കറ്റുകളുടെ ഏറ്റവും വലിയ പാക്കറ്റ് നമ്പർ മൂല്യത്തേക്കാൾ ഒന്നായി സജ്ജീകരിക്കുന്നു. ആദ്യം അയച്ച പാക്കറ്റിനുള്ള ഓപ്ഷനുകൾ ഫീൽഡ് സന്ദേശത്തിന്റെ വലുപ്പമാണ്.

ഒരു കണക്ഷൻ അവസാനിപ്പിക്കാൻ സമാനമായ ഒരു സംവിധാനം ഉപയോഗിക്കുന്നു. സന്ദേശത്തിന്റെ അവസാന പാക്കറ്റിൽ LastPacket ഫ്ലാഗ് സജ്ജീകരിച്ചിരിക്കുന്നു. പ്രതികരണ പാക്കറ്റിൽ, അവസാന പാക്കറ്റിന്റെ നമ്പർ + 1 സൂചിപ്പിച്ചിരിക്കുന്നു, ഇത് സ്വീകരിക്കുന്ന വശത്തിന് സന്ദേശത്തിന്റെ വിജയകരമായ ഡെലിവറി എന്നാണ് അർത്ഥമാക്കുന്നത്.
കണക്ഷൻ സ്ഥാപിക്കലും അവസാനിപ്പിക്കലും ഡയഗ്രം:

കണക്ഷൻ സ്ഥാപിക്കുമ്പോൾ, ഡാറ്റ കൈമാറ്റം ആരംഭിക്കുന്നു. പാക്കറ്റുകളുടെ ബ്ലോക്കുകളിലാണ് ഡാറ്റ കൈമാറുന്നത്. അവസാനത്തേത് ഒഴികെ ഓരോ ബ്ലോക്കിലും ഒരു നിശ്ചിത എണ്ണം പാക്കറ്റുകൾ അടങ്ങിയിരിക്കുന്നു. ഇത് സ്വീകരിക്കുന്ന/പ്രക്ഷേപണം ചെയ്യുന്ന വിൻഡോ വലുപ്പത്തിന് തുല്യമാണ്. ഡാറ്റയുടെ അവസാന ബ്ലോക്കിൽ കുറച്ച് പാക്കറ്റുകൾ ഉണ്ടായിരിക്കാം. ഓരോ ബ്ലോക്കും അയച്ചതിന് ശേഷം, ഡെലിവറി സ്ഥിരീകരണത്തിനോ നഷ്‌ടപ്പെട്ട പാക്കറ്റുകൾ വീണ്ടും ഡെലിവറി ചെയ്യുന്നതിനുള്ള അഭ്യർത്ഥനയ്‌ക്കോ വേണ്ടി അയയ്ക്കുന്ന വശം കാത്തിരിക്കുന്നു, പ്രതികരണങ്ങൾ സ്വീകരിക്കുന്നതിന് സ്വീകരിക്കുന്ന/ട്രാൻസ്മിറ്റ് വിൻഡോ തുറന്ന് വിടുന്നു. ബ്ലോക്ക് ഡെലിവറി സ്ഥിരീകരണം ലഭിച്ചതിന് ശേഷം, സ്വീകരിക്കുക/ട്രാൻസ്മിറ്റ് വിൻഡോ മാറുകയും ഡാറ്റയുടെ അടുത്ത ബ്ലോക്ക് അയയ്ക്കുകയും ചെയ്യുന്നു.

സ്വീകരിക്കുന്ന വശം പാക്കറ്റുകൾ സ്വീകരിക്കുന്നു. ഓരോ പാക്കറ്റും ട്രാൻസ്മിഷൻ വിൻഡോയിൽ വീഴുന്നുണ്ടോ എന്ന് പരിശോധിക്കുന്നു. വിൻഡോയിൽ വീഴാത്ത പാക്കറ്റുകളും ഡ്യൂപ്ലിക്കേറ്റുകളും ഫിൽട്ടർ ചെയ്യുന്നു. കാരണം വിൻഡോയുടെ വലുപ്പം നിശ്ചയിച്ചിരിക്കുന്നതും സ്വീകർത്താവിനും അയയ്ക്കുന്നയാൾക്കും ഒരേപോലെയാണെങ്കിൽ, ഒരു ബ്ലോക്ക് പാക്കറ്റുകൾ നഷ്‌ടപ്പെടാതെ ഡെലിവർ ചെയ്യുന്ന സാഹചര്യത്തിൽ, അടുത്ത ഡാറ്റാ ബ്ലോക്കിന്റെ പാക്കറ്റുകൾ സ്വീകരിക്കുന്നതിന് വിൻഡോ മാറ്റുകയും ഡെലിവറി സ്ഥിരീകരണം അയച്ചു. വർക്ക് ടൈമർ സജ്ജീകരിച്ച കാലയളവിനുള്ളിൽ വിൻഡോ പൂരിപ്പിച്ചില്ലെങ്കിൽ, ഏതൊക്കെ പാക്കറ്റുകൾ ഡെലിവർ ചെയ്തിട്ടില്ലെന്ന് ഒരു പരിശോധന ആരംഭിക്കുകയും വീണ്ടും ഡെലിവറി അഭ്യർത്ഥനകൾ അയയ്ക്കുകയും ചെയ്യും.
റീട്രാൻസ്മിഷൻ ഡയഗ്രം:

ടൈംഔട്ടുകളും പ്രോട്ടോക്കോൾ ടൈമറുകളും

ഒരു കണക്ഷൻ സ്ഥാപിക്കാൻ കഴിയാത്തതിന് നിരവധി കാരണങ്ങളുണ്ട്. ഉദാഹരണത്തിന്, സ്വീകരിക്കുന്ന പാർട്ടി ഓഫ്‌ലൈനാണെങ്കിൽ. ഈ സാഹചര്യത്തിൽ, ഒരു കണക്ഷൻ സ്ഥാപിക്കാൻ ശ്രമിക്കുമ്പോൾ, കാലഹരണപ്പെടുമ്പോൾ കണക്ഷൻ അടയ്ക്കും. വിശ്വസനീയമായ UDP നടപ്പിലാക്കൽ സമയപരിധി സജ്ജീകരിക്കാൻ രണ്ട് ടൈമറുകൾ ഉപയോഗിക്കുന്നു. റിമോട്ട് ഹോസ്റ്റിൽ നിന്നുള്ള പ്രതികരണത്തിനായി കാത്തിരിക്കാൻ ആദ്യത്തേത്, വർക്കിംഗ് ടൈമർ ഉപയോഗിക്കുന്നു. അത് അയച്ചയാളുടെ ഭാഗത്ത് തീപിടിക്കുകയാണെങ്കിൽ, അവസാനം അയച്ച പാക്കറ്റ് വീണ്ടും അയച്ചു. സ്വീകർത്താവിൽ ടൈമർ കാലഹരണപ്പെടുകയാണെങ്കിൽ, നഷ്ടപ്പെട്ട പാക്കറ്റുകൾക്കായി ഒരു പരിശോധന നടത്തുകയും വീണ്ടും ഡെലിവറി ചെയ്യുന്നതിനുള്ള അഭ്യർത്ഥനകൾ അയയ്ക്കുകയും ചെയ്യും.

നോഡുകൾ തമ്മിലുള്ള ആശയവിനിമയത്തിന്റെ അഭാവത്തിൽ കണക്ഷൻ അടയ്ക്കുന്നതിന് രണ്ടാമത്തെ ടൈമർ ആവശ്യമാണ്. അയച്ചയാളെ സംബന്ധിച്ചിടത്തോളം, വർക്കിംഗ് ടൈമർ കാലഹരണപ്പെട്ട ഉടൻ തന്നെ ഇത് ആരംഭിക്കുകയും റിമോട്ട് നോഡിൽ നിന്നുള്ള പ്രതികരണത്തിനായി കാത്തിരിക്കുകയും ചെയ്യുന്നു. നിർദ്ദിഷ്ട കാലയളവിനുള്ളിൽ പ്രതികരണമില്ലെങ്കിൽ, കണക്ഷൻ അവസാനിപ്പിക്കുകയും ഉറവിടങ്ങൾ പുറത്തുവിടുകയും ചെയ്യും. സ്വീകരിക്കുന്ന ഭാഗത്തിന്, വർക്ക് ടൈമർ രണ്ടുതവണ കാലഹരണപ്പെട്ടതിന് ശേഷം കണക്ഷൻ ക്ലോസ് ടൈമർ ആരംഭിക്കുന്നു. സ്ഥിരീകരണ പാക്കറ്റിന്റെ നഷ്ടത്തിനെതിരെ ഇൻഷ്വർ ചെയ്യുന്നതിന് ഇത് ആവശ്യമാണ്. ടൈമർ കാലഹരണപ്പെടുമ്പോൾ, കണക്ഷനും അവസാനിപ്പിക്കുകയും ഉറവിടങ്ങൾ പുറത്തുവിടുകയും ചെയ്യുന്നു.

വിശ്വസനീയമായ UDP ട്രാൻസ്മിഷൻ സ്റ്റേറ്റ് ഡയഗ്രം

പ്രോട്ടോക്കോളിന്റെ തത്വങ്ങൾ ഒരു ഫിനിറ്റ് സ്റ്റേറ്റ് മെഷീനിൽ നടപ്പിലാക്കുന്നു, ഓരോ അവസ്ഥയും പാക്കറ്റ് പ്രോസസ്സിംഗിന്റെ ഒരു നിശ്ചിത ലോജിക്കിന് ഉത്തരവാദിയാണ്.
വിശ്വസനീയമായ UDP സ്റ്റേറ്റ് ഡയഗ്രം:

അടച്ച - യഥാർത്ഥത്തിൽ ഒരു സംസ്ഥാനമല്ല, ഇത് ഓട്ടോമാറ്റണിന്റെ ആരംഭവും അവസാനവും ആണ്. സംസ്ഥാനത്തിന് അടച്ച ഒരു ട്രാൻസ്മിഷൻ കൺട്രോൾ ബ്ലോക്ക് ലഭിക്കുന്നു, ഇത് ഒരു അസിൻക്രണസ് യുഡിപി സെർവർ നടപ്പിലാക്കി, ഉചിതമായ കണക്ഷനുകളിലേക്ക് പാക്കറ്റുകൾ കൈമാറുകയും സ്റ്റേറ്റ് പ്രോസസ്സിംഗ് ആരംഭിക്കുകയും ചെയ്യുന്നു.

ആദ്യപാക്കറ്റ് അയയ്ക്കുന്നു - സന്ദേശം അയയ്‌ക്കുമ്പോൾ ഔട്ട്‌ഗോയിംഗ് കണക്ഷന്റെ പ്രാരംഭ അവസ്ഥ.

ഈ അവസ്ഥയിൽ, സാധാരണ സന്ദേശങ്ങൾക്കുള്ള ആദ്യ പാക്കറ്റ് അയച്ചു. അയക്കുന്ന സ്ഥിരീകരണം ഇല്ലാത്ത സന്ദേശങ്ങൾക്ക്, മുഴുവൻ സന്ദേശവും അയക്കുന്ന ഒരേയൊരു സംസ്ഥാനമാണിത്.

അയക്കുന്ന സൈക്കിൾ - സന്ദേശ പാക്കറ്റുകളുടെ പ്രക്ഷേപണത്തിനുള്ള ഗ്രൗണ്ട് സ്റ്റേറ്റ്.

സംസ്ഥാനത്ത് നിന്ന് അതിലേക്കുള്ള മാറ്റം ആദ്യപാക്കറ്റ് അയയ്ക്കുന്നു സന്ദേശത്തിന്റെ ആദ്യ പാക്കറ്റ് അയച്ചതിന് ശേഷം നടപ്പിലാക്കുന്നു. ഈ അവസ്ഥയിലാണ് പുനഃസംപ്രേക്ഷണത്തിനുള്ള എല്ലാ അംഗീകാരങ്ങളും അഭ്യർത്ഥനകളും വരുന്നത്. അതിൽ നിന്ന് പുറത്തുകടക്കുന്നത് രണ്ട് സന്ദർഭങ്ങളിൽ സാധ്യമാണ് - സന്ദേശത്തിന്റെ വിജയകരമായ ഡെലിവറി അല്ലെങ്കിൽ കാലഹരണപ്പെടൽ.

ആദ്യപാക്കറ്റ് ലഭിച്ചു - സന്ദേശം സ്വീകർത്താവിന്റെ പ്രാരംഭ അവസ്ഥ.

ഇത് പ്രക്ഷേപണത്തിന്റെ തുടക്കത്തിന്റെ കൃത്യത പരിശോധിക്കുന്നു, ആവശ്യമായ ഘടനകൾ സൃഷ്ടിക്കുന്നു, ആദ്യ പാക്കറ്റിന്റെ രസീതിയുടെ ഒരു അംഗീകാരം അയയ്ക്കുന്നു.

ഒരൊറ്റ പാക്കറ്റ് അടങ്ങിയതും ഡെലിവറി തെളിവ് ഉപയോഗിക്കാതെ അയച്ചതുമായ ഒരു സന്ദേശത്തിന്, ഇത് മാത്രമാണ് സംസ്ഥാനം. അത്തരമൊരു സന്ദേശം പ്രോസസ്സ് ചെയ്ത ശേഷം, കണക്ഷൻ അടച്ചു.

അസംബ്ലിംഗ് - സന്ദേശ പാക്കറ്റുകൾ സ്വീകരിക്കുന്നതിനുള്ള അടിസ്ഥാന അവസ്ഥ.

ഇത് താൽക്കാലിക സംഭരണത്തിലേക്ക് പാക്കറ്റുകൾ എഴുതുന്നു, പാക്കറ്റ് നഷ്ടം പരിശോധിക്കുന്നു, ഒരു ബ്ലോക്ക് പാക്കറ്റുകളും മുഴുവൻ സന്ദേശവും ഡെലിവറി ചെയ്യുന്നതിനുള്ള അംഗീകാരങ്ങൾ അയയ്ക്കുന്നു, നഷ്ടപ്പെട്ട പാക്കറ്റുകൾ വീണ്ടും ഡെലിവറി ചെയ്യുന്നതിനുള്ള അഭ്യർത്ഥനകൾ അയയ്ക്കുന്നു. മുഴുവൻ സന്ദേശവും വിജയകരമാണെങ്കിൽ, കണക്ഷൻ സംസ്ഥാനത്തേക്ക് പോകുന്നു പൂർത്തിയായി, അല്ലെങ്കിൽ, ഒരു കാലഹരണപ്പെടൽ പുറപ്പെടുന്നു.

പൂർത്തിയായി - മുഴുവൻ സന്ദേശവും വിജയകരമാണെങ്കിൽ കണക്ഷൻ അവസാനിപ്പിക്കുന്നു.

സന്ദേശത്തിന്റെ അസംബ്ലിക്കും സന്ദേശത്തിന്റെ ഡെലിവറി സ്ഥിരീകരണം അയച്ചയാളിലേക്കുള്ള വഴിയിൽ നഷ്‌ടമായ സന്ദർഭത്തിനും ഈ അവസ്ഥ ആവശ്യമാണ്. ഈ അവസ്ഥ കാലഹരണപ്പെടുമ്പോൾ പുറത്തുകടന്നു, പക്ഷേ കണക്ഷൻ വിജയകരമായി അവസാനിച്ചതായി കണക്കാക്കുന്നു.

കോഡിലേക്ക് കൂടുതൽ ആഴത്തിൽ. ട്രാൻസ്മിഷൻ കൺട്രോൾ യൂണിറ്റ്

വിശ്വസനീയമായ യുഡിപിയുടെ പ്രധാന ഘടകങ്ങളിലൊന്നാണ് ട്രാൻസ്മിഷൻ കൺട്രോൾ ബ്ലോക്ക്. നിലവിലെ കണക്ഷനുകളും സഹായ ഘടകങ്ങളും സംഭരിക്കുക, അനുബന്ധ കണക്ഷനുകളിലേക്ക് ഇൻകമിംഗ് പാക്കറ്റുകൾ വിതരണം ചെയ്യുക, ഒരു കണക്ഷനിലേക്ക് പാക്കറ്റുകൾ അയയ്ക്കുന്നതിനുള്ള ഒരു ഇന്റർഫേസ് നൽകുക, പ്രോട്ടോക്കോൾ API നടപ്പിലാക്കുക എന്നിവയാണ് ഈ ബ്ലോക്കിന്റെ ചുമതല. ട്രാൻസ്മിഷൻ കൺട്രോൾ ബ്ലോക്ക് യുഡിപി ലെയറിൽ നിന്ന് പാക്കറ്റുകൾ സ്വീകരിക്കുകയും പ്രോസസ്സിംഗിനായി സ്റ്റേറ്റ് മെഷീനിലേക്ക് കൈമാറുകയും ചെയ്യുന്നു. പാക്കറ്റുകൾ സ്വീകരിക്കുന്നതിന്, ഇത് ഒരു അസിൻക്രണസ് യുഡിപി സെർവർ നടപ്പിലാക്കുന്നു.
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;    	
  //...
}

അസിൻക്രണസ് യുഡിപി സെർവർ നടപ്പിലാക്കൽ:

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

കോഡിലേക്ക് ആഴത്തിൽ. പ്രസ്താവിക്കുന്നു

പാക്കറ്റുകളുടെ പ്രധാന പ്രോസസ്സിംഗ് നടക്കുന്ന വിശ്വസനീയമായ യുഡിപി പ്രോട്ടോക്കോളിന്റെ സ്റ്റേറ്റ് മെഷീൻ സംസ്ഥാനങ്ങൾ നടപ്പിലാക്കുന്നു. 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();
}

സംസ്ഥാനത്ത് അത് മറികടക്കുക മാത്രമാണ് ചെയ്യുന്നത് പൂർത്തിയായി.
പൂർത്തിയായി. സമയപരിധി പ്രകാരം ഡിസ്പോസ് ചെയ്യുക:

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

റിസീവ് പാക്കറ്റ് രീതി

കഴിവുള്ള ആദ്യപാക്കറ്റ് ലഭിച്ചു ആദ്യ സന്ദേശ പാക്കറ്റ് യഥാർത്ഥത്തിൽ ഇന്റർഫേസിൽ എത്തിയോ എന്ന് നിർണ്ണയിക്കുക, കൂടാതെ ഒരൊറ്റ പാക്കറ്റ് അടങ്ങിയ ഒരു സന്ദേശം ശേഖരിക്കുക എന്നതാണ് രീതിയുടെ പ്രധാന ദൌത്യം.
ആദ്യപാക്കറ്റ് ലഭിച്ചു. സ്വീകരിക്കുന്ന പാക്കറ്റ്:

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

ആദ്യ പാക്കറ്റ് അയയ്‌ക്കുന്നു (ആദ്യപാക്കറ്റ് അയയ്‌ക്കുന്ന അവസ്ഥ):

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

കോഡിലേക്ക് ആഴത്തിൽ. കാലഹരണപ്പെടുമ്പോൾ കണക്ഷൻ ക്ലോസ് ചെയ്യുന്നു

വിശ്വസനീയമായ യുഡിപിയുടെ ഒരു പ്രധാന ഭാഗമാണ് ടൈംഔട്ട് കൈകാര്യം ചെയ്യൽ. ഒരു ഇന്റർമീഡിയറ്റ് നോഡ് പരാജയപ്പെടുകയും രണ്ട് ദിശകളിലുമുള്ള ഡാറ്റ ഡെലിവറി അസാധ്യമാവുകയും ചെയ്ത ഒരു ഉദാഹരണം പരിഗണിക്കുക.
കാലഹരണപ്പെടുമ്പോൾ ഒരു കണക്ഷൻ അടയ്ക്കുന്നതിനുള്ള ഡയഗ്രം:

ഡയഗ്രാമിൽ നിന്ന് കാണാൻ കഴിയുന്നത് പോലെ, ഒരു ബ്ലോക്ക് പാക്കറ്റുകൾ അയച്ചതിന് ശേഷം അയച്ചയാളുടെ വർക്ക് ടൈമർ ഉടൻ ആരംഭിക്കുന്നു. സംസ്ഥാനത്തിന്റെ 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. വിശ്വസനീയമായ ഡാറ്റ പ്രോട്ടോക്കോൾ: ആർഎഫ്സി 908 и ആർഎഫ്സി 1151
5. യുഡിപി വഴിയുള്ള ഡെലിവറി സ്ഥിരീകരണത്തിന്റെ ലളിതമായ നടപ്പാക്കൽ: .NET, UDP എന്നിവ ഉപയോഗിച്ച് നിങ്ങളുടെ നെറ്റ്‌വർക്കിംഗിന്റെ പൂർണ്ണ നിയന്ത്രണം ഏറ്റെടുക്കുക
6. NAT ട്രാവേഴ്സൽ മെക്കാനിസങ്ങൾ വിവരിക്കുന്ന ലേഖനം: നെറ്റ്‌വർക്ക് വിലാസം വിവർത്തകരിലുടനീളം പിയർ-ടു-പിയർ ആശയവിനിമയം
7. അസിൻക്രണസ് പ്രോഗ്രാമിംഗ് മോഡൽ നടപ്പിലാക്കൽ: CLR അസിൻക്രണസ് പ്രോഗ്രാമിംഗ് മോഡൽ നടപ്പിലാക്കുന്നു и IAsyncResult ഡിസൈൻ പാറ്റേൺ എങ്ങനെ നടപ്പിലാക്കാം
8. അസിൻക്രണസ് പ്രോഗ്രാമിംഗ് മോഡൽ ടാസ്‌ക് അധിഷ്‌ഠിത അസിൻക്രണസ് പാറ്റേണിലേക്ക് (TAP-ലെ APM) പോർട്ട് ചെയ്യുന്നു:
   TPL ഉം പരമ്പരാഗത .NET അസിൻക്രണസ് പ്രോഗ്രാമിംഗും
   മറ്റ് അസിൻക്രണസ് പാറ്റേണുകളും തരങ്ങളും ഉപയോഗിച്ച് ഇടപെടുക

അപ്ഡേറ്റ്: നന്ദി മേയറോവ്പി и സിദ്രിസ്റ്റിജ് ഇന്റർഫേസിലേക്ക് ഒരു ടാസ്ക് ചേർക്കുന്നതിനുള്ള ആശയത്തിനായി. പഴയ ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങളുമായുള്ള ലൈബ്രറിയുടെ അനുയോജ്യത ലംഘിക്കപ്പെടുന്നില്ല, കാരണം നാലാമത്തെ ചട്ടക്കൂട് XP, 4 സെർവർ എന്നിവയെ പിന്തുണയ്ക്കുന്നു.

അവലംബം: www.habr.com