નેટ માટે વિશ્વસનીય Udp પ્રોટોકોલનું અમલીકરણ

ઇન્ટરનેટ લાંબા સમય પહેલા બદલાઈ ગયું છે. ઈન્ટરનેટના મુખ્ય પ્રોટોકોલ્સમાંથી એક - UDP નો ઉપયોગ એપ્લીકેશનો દ્વારા માત્ર ડેટાગ્રામ અને બ્રોડકાસ્ટ પહોંચાડવા માટે જ નહીં, પણ નેટવર્ક નોડ્સ વચ્ચે "પીઅર-ટુ-પીઅર" કનેક્શન્સ પ્રદાન કરવા માટે પણ થાય છે. તેની સરળ ડિઝાઇનને લીધે, આ પ્રોટોકોલના અગાઉ ઘણા બિનઆયોજિત ઉપયોગો છે, જો કે, પ્રોટોકોલની ખામીઓ, જેમ કે ગેરંટીડ ડિલિવરીની અછત, ક્યાંય અદૃશ્ય થઈ નથી. આ લેખ UDP પર બાંયધરીકૃત ડિલિવરી પ્રોટોકોલના અમલીકરણનું વર્ણન કરે છે.
અનુક્રમણિકા:પરિચય
પ્રોટોકોલ જરૂરીયાતો
વિશ્વસનીય UDP હેડર
પ્રોટોકોલના સામાન્ય સિદ્ધાંતો
સમયસમાપ્તિ અને પ્રોટોકોલ ટાઈમર
વિશ્વસનીય UDP ટ્રાન્સમિશન સ્ટેટ ડાયાગ્રામ
કોડમાં વધુ ઊંડે. ટ્રાન્સમિશન કંટ્રોલ યુનિટ
કોડમાં વધુ ઊંડે. રાજ્યો

• DisposeByTimeout પદ્ધતિ
• પ્રોસેસપેકેટ્સ પદ્ધતિ
• રીસીવપેકેટ પદ્ધતિ
• પેકેટ પદ્ધતિ મોકલો

કોડમાં વધુ ઊંડે. જોડાણો બનાવવા અને સ્થાપિત કરવા
કોડમાં વધુ ઊંડે. સમયસમાપ્તિ પર કનેક્શન બંધ કરી રહ્યું છે
કોડમાં વધુ ઊંડે. ડેટા ટ્રાન્સફર પુનઃસ્થાપિત કરી રહ્યું છે
વિશ્વસનીય UDP API
નિષ્કર્ષ
ઉપયોગી લિંક્સ અને લેખો

પરિચય

ઈન્ટરનેટના મૂળ આર્કિટેક્ચરે એક સમાન સરનામું સ્થાન ધારણ કર્યું હતું જેમાં દરેક નોડનું વૈશ્વિક અને અનન્ય IP સરનામું હતું અને તે અન્ય નોડ્સ સાથે સીધો સંચાર કરી શકે છે. હવે ઈન્ટરનેટ, વાસ્તવમાં, એક અલગ આર્કિટેક્ચર ધરાવે છે - વૈશ્વિક IP સરનામાઓનો એક વિસ્તાર અને NAT ઉપકરણોની પાછળ છુપાયેલા ખાનગી સરનામાંવાળા ઘણા વિસ્તારો.આ આર્કિટેક્ચરમાં, વૈશ્વિક એડ્રેસ સ્પેસમાંના ઉપકરણો જ નેટવર્ક પરની કોઈપણ વ્યક્તિ સાથે સરળતાથી વાતચીત કરી શકે છે કારણ કે તેમની પાસે અનન્ય, વૈશ્વિક રીતે રૂટેબલ IP સરનામું છે. ખાનગી નેટવર્ક પરનો નોડ એ જ નેટવર્ક પરના અન્ય નોડ્સ સાથે કનેક્ટ થઈ શકે છે, અને વૈશ્વિક સરનામાંની જગ્યામાં અન્ય જાણીતા નોડ્સ સાથે પણ કનેક્ટ થઈ શકે છે. આ ક્રિયાપ્રતિક્રિયા મોટે ભાગે નેટવર્ક સરનામાં અનુવાદ પદ્ધતિને કારણે પ્રાપ્ત થાય છે. NAT ઉપકરણો, જેમ કે Wi-Fi રાઉટર્સ, આઉટગોઇંગ કનેક્શન્સ માટે વિશિષ્ટ અનુવાદ કોષ્ટક એન્ટ્રી બનાવે છે અને પેકેટોમાં IP સરનામાઓ અને પોર્ટ નંબરોને સંશોધિત કરે છે. આ ખાનગી નેટવર્કથી ગ્લોબલ એડ્રેસ સ્પેસમાં હોસ્ટ માટે આઉટગોઇંગ કનેક્શન્સને મંજૂરી આપે છે. પરંતુ તે જ સમયે, NAT ઉપકરણો સામાન્ય રીતે તમામ ઇનકમિંગ ટ્રાફિકને અવરોધિત કરે છે સિવાય કે ઇનકમિંગ કનેક્શન્સ માટે અલગ નિયમો સેટ કરવામાં આવે.

ઇન્ટરનેટનું આ આર્કિટેક્ચર ક્લાયંટ-સર્વર કમ્યુનિકેશન માટે પૂરતું યોગ્ય છે, જ્યાં ક્લાયન્ટ ખાનગી નેટવર્કમાં હોઈ શકે છે, અને સર્વર પાસે વૈશ્વિક સરનામું છે. પરંતુ તે વચ્ચે બે ગાંઠોના સીધા જોડાણ માટે મુશ્કેલીઓ ઊભી કરે છે વિવિધ ખાનગી નેટવર્ક્સ. પીઅર-ટુ-પીઅર એપ્લીકેશન જેમ કે વોઈસ ટ્રાન્સમિશન (સ્કાયપે), કોમ્પ્યુટર (ટીમવ્યુઅર)માં રીમોટ એક્સેસ મેળવવી અથવા ઓનલાઈન ગેમિંગ માટે બે નોડ્સ વચ્ચે સીધો જોડાણ મહત્વપૂર્ણ છે.

વિવિધ ખાનગી નેટવર્ક્સ પરના ઉપકરણો વચ્ચે પીઅર-ટુ-પીઅર કનેક્શન સ્થાપિત કરવા માટેની સૌથી અસરકારક પદ્ધતિઓમાંની એકને હોલ પંચિંગ કહેવામાં આવે છે. આ તકનીકનો ઉપયોગ UDP પ્રોટોકોલ પર આધારિત એપ્લિકેશનો સાથે સામાન્ય રીતે થાય છે.

પરંતુ જો તમારી એપ્લિકેશનને ડેટાની બાંયધરીકૃત ડિલિવરીની જરૂર હોય, ઉદાહરણ તરીકે, તમે કમ્પ્યુટર્સ વચ્ચે ફાઇલો સ્થાનાંતરિત કરો છો, તો UDP નો ઉપયોગ કરવામાં ઘણી મુશ્કેલીઓ હશે કારણ કે UDP એ ગેરંટીકૃત ડિલિવરી પ્રોટોકોલ નથી અને TCPથી વિપરીત, ક્રમમાં પેકેટ ડિલિવરી પ્રદાન કરતું નથી. પ્રોટોકોલ

આ કિસ્સામાં, બાંયધરીકૃત પેકેટ ડિલિવરીની ખાતરી કરવા માટે, એપ્લીકેશન લેયર પ્રોટોકોલનો અમલ કરવો જરૂરી છે જે જરૂરી કાર્યક્ષમતા પ્રદાન કરે છે અને UDP પર કાર્ય કરે છે.

હું હમણાં જ નોંધવા માંગુ છું કે વિવિધ ખાનગી નેટવર્ક્સમાં નોડ્સ વચ્ચે TCP કનેક્શન સ્થાપિત કરવા માટે TCP હોલ પંચિંગ ટેકનિક છે, પરંતુ ઘણા NAT ઉપકરણો દ્વારા તેના માટે સમર્થનના અભાવને કારણે, તેને સામાન્ય રીતે કનેક્ટ કરવાની મુખ્ય રીત તરીકે ગણવામાં આવતી નથી. આવા ગાંઠો.

આ લેખના બાકીના ભાગમાં, હું ફક્ત ગેરંટીકૃત ડિલિવરી પ્રોટોકોલના અમલીકરણ પર ધ્યાન કેન્દ્રિત કરીશ. UDP હોલ પંચિંગ ટેકનિકના અમલીકરણનું વર્ણન નીચેના લેખોમાં કરવામાં આવશે.

પ્રોટોકોલ જરૂરીયાતો

1. સકારાત્મક પ્રતિસાદ પદ્ધતિ (કહેવાતા હકારાત્મક સ્વીકૃતિ) દ્વારા વિશ્વસનીય પેકેટ વિતરણ
2. મોટા ડેટાના કાર્યક્ષમ ટ્રાન્સફરની જરૂરિયાત, એટલે કે. પ્રોટોકોલે બિનજરૂરી પેકેટ રિલે કરવાનું ટાળવું જોઈએ
3. ડિલિવરી કન્ફર્મેશન મિકેનિઝમ ("શુદ્ધ" UDP પ્રોટોકોલ તરીકે કાર્ય કરવાની ક્ષમતા) રદ કરવાનું શક્ય હોવું જોઈએ.
4. દરેક સંદેશની પુષ્ટિ સાથે, આદેશ મોડને અમલમાં મૂકવાની ક્ષમતા
5. પ્રોટોકોલ પર ડેટા ટ્રાન્સફરનું મૂળભૂત એકમ સંદેશ હોવું આવશ્યક છે

આ આવશ્યકતાઓ મોટાભાગે આમાં વર્ણવેલ વિશ્વસનીય ડેટા પ્રોટોકોલ આવશ્યકતાઓ સાથે સુસંગત છે આરએફસી 908 и આરએફસી 1151, અને આ પ્રોટોકોલ વિકસાવતી વખતે મેં તે ધોરણો પર આધાર રાખ્યો હતો.

આ જરૂરિયાતોને સમજવા માટે, ચાલો TCP અને UDP પ્રોટોકોલનો ઉપયોગ કરીને બે નેટવર્ક નોડ્સ વચ્ચે ડેટા ટ્રાન્સફરનો સમય જોઈએ. ચાલો બંને કિસ્સાઓમાં અમારી પાસે એક પેકેટ ખોવાઈ જશે.
TCP પર નોન-ઇન્ટરેક્ટિવ ડેટાનું ટ્રાન્સફર:

જેમ તમે ડાયાગ્રામમાંથી જોઈ શકો છો, પેકેટ ખોવાઈ જવાના કિસ્સામાં, TCP ખોવાઈ ગયેલા પેકેટને શોધી કાઢશે અને ખોવાયેલા સેગમેન્ટનો નંબર પૂછીને મોકલનારને તેની જાણ કરશે.
UDP પ્રોટોકોલ દ્વારા ડેટા ટ્રાન્સફર:

UDP ખોટ શોધવાના કોઈ પગલાં લેતું નથી. UDP પ્રોટોકોલમાં ટ્રાન્સમિશન ભૂલોનું નિયંત્રણ સંપૂર્ણપણે એપ્લિકેશનની જવાબદારી છે.

TCP પ્રોટોકોલમાં ભૂલ શોધ એ એન્ડ નોડ સાથે કનેક્શન સ્થાપિત કરીને, તે કનેક્શનની સ્થિતિને સ્ટોર કરીને, દરેક પેકેટ હેડરમાં મોકલવામાં આવેલી બાઈટ્સની સંખ્યા સૂચવીને અને સ્વીકૃતિ નંબરનો ઉપયોગ કરીને રસીદોને સૂચિત કરીને પ્રાપ્ત થાય છે.

વધુમાં, કામગીરી બહેતર બનાવવા માટે (એટલે ​​​​કે સ્વીકૃતિ પ્રાપ્ત કર્યા વિના એક કરતા વધુ સેગમેન્ટ મોકલો), TCP પ્રોટોકોલ કહેવાતી ટ્રાન્સમિશન વિન્ડોનો ઉપયોગ કરે છે - ડેટાના બાઈટની સંખ્યા જે સેગમેન્ટના પ્રેષકને પ્રાપ્ત થવાની અપેક્ષા છે.

TCP પ્રોટોકોલ વિશે વધુ માહિતી માટે, જુઓ આરએફસી 793, UDP થી આરએફસી 768જ્યાં, હકીકતમાં, તેઓ વ્યાખ્યાયિત થયેલ છે.

ઉપરથી, તે સ્પષ્ટ છે કે UDP પર વિશ્વસનીય સંદેશ વિતરણ પ્રોટોકોલ બનાવવા માટે (ત્યારબાદ વિશ્વસનીય UDP), તે TCP જેવી જ ડેટા ટ્રાન્સફર મિકેનિઝમ્સ લાગુ કરવા માટે જરૂરી છે. જેમ કે:

• કનેક્શન સ્થિતિ સાચવો
• સેગમેન્ટ નંબરિંગનો ઉપયોગ કરો
• ખાસ પુષ્ટિકરણ પેકેજોનો ઉપયોગ કરો
• પ્રોટોકોલ થ્રુપુટ વધારવા માટે સરળ વિન્ડોઇંગ મિકેનિઝમનો ઉપયોગ કરો

વધુમાં, તમારે જરૂર છે:

• કનેક્શન માટે સંસાધનો ફાળવવા માટે, સંદેશની શરૂઆતનો સંકેત આપો
• પ્રાપ્ત સંદેશને અપસ્ટ્રીમ એપ્લિકેશનમાં પસાર કરવા અને પ્રોટોકોલ સંસાધનો છોડવા માટે સંદેશના અંતનો સંકેત આપો
• કનેક્શન-વિશિષ્ટ પ્રોટોકોલને "શુદ્ધ" UDP તરીકે કાર્ય કરવા માટે ડિલિવરી પુષ્ટિકરણ પદ્ધતિને અક્ષમ કરવાની મંજૂરી આપો

વિશ્વસનીય UDP હેડર

યાદ કરો કે UDP ડેટાગ્રામ IP ડેટાગ્રામમાં સમાવિષ્ટ છે. વિશ્વસનીય UDP પેકેટ UDP ડેટાગ્રામમાં યોગ્ય રીતે "આવરિત" છે.
વિશ્વસનીય UDP હેડર એન્કેપ્સ્યુલેશન:

વિશ્વસનીય UDP હેડરની રચના એકદમ સરળ છે:

• ફ્લેગ્સ - પેકેજ નિયંત્રણ ફ્લેગ્સ
• MessageType - અપસ્ટ્રીમ એપ્લીકેશનો દ્વારા ચોક્કસ સંદેશાઓ પર સબ્સ્ક્રાઇબ કરવા માટે ઉપયોગમાં લેવાતો સંદેશ પ્રકાર
• ટ્રાન્સમિશન આઈડી - ટ્રાન્સમિશનની સંખ્યા, પ્રાપ્તકર્તાના સરનામા અને પોર્ટ સાથે, જોડાણને અનન્ય રીતે ઓળખે છે
• PacketNumber - પેકેટ નંબર
• વિકલ્પો - વધારાના પ્રોટોકોલ વિકલ્પો. પ્રથમ પેકેટના કિસ્સામાં, તેનો ઉપયોગ સંદેશનું કદ દર્શાવવા માટે થાય છે

ધ્વજ નીચે મુજબ છે:

• ફર્સ્ટપેકેટ - સંદેશનું પ્રથમ પેકેટ
• NoAsk - સંદેશને સક્ષમ કરવા માટે સ્વીકૃતિ પદ્ધતિની જરૂર નથી
• લાસ્ટપેકેટ - સંદેશનું છેલ્લું પેકેટ
• RequestForPacket - પુષ્ટિ પેકેટ અથવા ખોવાયેલા પેકેટ માટેની વિનંતી

પ્રોટોકોલના સામાન્ય સિદ્ધાંતો

વિશ્વસનીય UDP બે ગાંઠો વચ્ચે બાંયધરીકૃત સંદેશા પ્રસારણ પર કેન્દ્રિત હોવાથી, તે બીજી બાજુ સાથે જોડાણ સ્થાપિત કરવામાં સક્ષમ હોવું જોઈએ. કનેક્શન સ્થાપિત કરવા માટે, પ્રેષક ફર્સ્ટપેકેટ ફ્લેગ સાથે એક પેકેટ મોકલે છે, જેનો પ્રતિસાદ અર્થ એ થશે કે જોડાણ સ્થાપિત થયું છે. બધા પ્રતિભાવ પેકેટો, અથવા, અન્ય શબ્દોમાં, સ્વીકૃતિ પેકેટો, હંમેશા PacketNumber ફીલ્ડનું મૂલ્ય સફળતાપૂર્વક પ્રાપ્ત થયેલા પેકેટોના સૌથી મોટા PacketNumber મૂલ્ય કરતાં વધુ એક પર સેટ કરે છે. મોકલેલ પ્રથમ પેકેટ માટે વિકલ્પો ફીલ્ડ એ સંદેશનું કદ છે.

કનેક્શનને સમાપ્ત કરવા માટે સમાન પદ્ધતિનો ઉપયોગ થાય છે. LastPacket ધ્વજ સંદેશના છેલ્લા પેકેટ પર સેટ કરેલ છે. પ્રતિભાવ પેકેટમાં છેલ્લા પેકેટની સંખ્યા + 1 હોય છે, જેનો અર્થ પ્રાપ્ત કરનાર બાજુ માટે સંદેશની સફળ ડિલિવરી થાય છે.
કનેક્શન સ્થાપના અને સમાપ્તિ રેખાકૃતિ:

જ્યારે કનેક્શન સ્થાપિત થાય છે, ત્યારે ડેટા ટ્રાન્સફર શરૂ થાય છે. ડેટા પેકેટોના બ્લોકમાં પ્રસારિત થાય છે. દરેક બ્લોક, છેલ્લા એક સિવાય, પેકેટોની નિશ્ચિત સંખ્યા ધરાવે છે. તે પ્રાપ્ત/પ્રસારણ વિન્ડો માપ સમાન છે. ડેટાના છેલ્લા બ્લોકમાં ઓછા પેકેટ હોઈ શકે છે. દરેક બ્લોક મોકલ્યા પછી, મોકલનાર બાજુ ડિલિવરી કન્ફર્મેશનની રાહ જુએ છે અથવા ખોવાયેલા પેકેટને ફરીથી ડિલિવર કરવાની વિનંતીની રાહ જુએ છે, પ્રતિસાદો મેળવવા માટે રિસિવ/ટ્રાન્સમિટ વિન્ડો ખુલ્લી રાખીને. બ્લોક ડિલિવરીની પુષ્ટિ પ્રાપ્ત કર્યા પછી, પ્રાપ્ત/ટ્રાન્સમિટ વિન્ડો શિફ્ટ થાય છે અને ડેટાનો આગળનો બ્લોક મોકલવામાં આવે છે.

પ્રાપ્ત કરનાર બાજુ પેકેટો મેળવે છે. દરેક પેકેટ ટ્રાન્સમિશન વિન્ડોની અંદર આવે છે કે કેમ તે જોવા માટે તપાસવામાં આવે છે. પેકેટો અને ડુપ્લિકેટ્સ જે વિન્ડોમાં આવતા નથી તે ફિલ્ટર કરવામાં આવે છે. કારણ કે જો વિન્ડોનું કદ નિશ્ચિત હોય અને પ્રાપ્તકર્તા અને પ્રેષક માટે સમાન હોય, તો પેકેટના બ્લોકને નુકશાન વિના પહોંચાડવાના કિસ્સામાં, વિન્ડોને ડેટાના આગલા બ્લોકના પેકેટો પ્રાપ્ત કરવા માટે ખસેડવામાં આવે છે અને ડિલિવરીની પુષ્ટિ થાય છે. મોકલેલ. જો વર્ક ટાઈમર દ્વારા નિર્ધારિત સમયગાળાની અંદર વિન્ડો ભરાય નહીં, તો ચેક શરૂ કરવામાં આવશે કે જેના પર પેકેટો વિતરિત કરવામાં આવ્યા નથી અને પુનઃડિલિવરી માટેની વિનંતીઓ મોકલવામાં આવશે.
રીટ્રાન્સમિશન ડાયાગ્રામ:

સમયસમાપ્તિ અને પ્રોટોકોલ ટાઈમર

કનેક્શન સ્થાપિત કરી શકાતું નથી તેના ઘણા કારણો છે. ઉદાહરણ તરીકે, જો પ્રાપ્ત કરનાર પક્ષ ઑફલાઇન હોય. આ કિસ્સામાં, કનેક્શન સ્થાપિત કરવાનો પ્રયાસ કરતી વખતે, સમયસમાપ્તિ દ્વારા જોડાણ બંધ થઈ જશે. વિશ્વસનીય UDP અમલીકરણ સમયસમાપ્તિ સેટ કરવા માટે બે ટાઈમરનો ઉપયોગ કરે છે. પ્રથમ, કાર્યકારી ટાઈમરનો ઉપયોગ રિમોટ હોસ્ટ તરફથી પ્રતિસાદની રાહ જોવા માટે થાય છે. જો તે પ્રેષક બાજુ પર ફાયર થાય છે, તો છેલ્લું મોકલેલું પેકેટ ફરીથી મોકલવામાં આવે છે. જો ટાઈમર પ્રાપ્તકર્તા પર સમાપ્ત થાય છે, તો પછી ખોવાયેલા પેકેટોની તપાસ કરવામાં આવે છે અને ફરીથી વિતરણ માટેની વિનંતીઓ મોકલવામાં આવે છે.

નોડ્સ વચ્ચેના સંચારના અભાવના કિસ્સામાં કનેક્શનને બંધ કરવા માટે બીજા ટાઈમરની જરૂર છે. પ્રેષક બાજુ માટે, તે કાર્યકારી ટાઈમર સમાપ્ત થયા પછી તરત જ શરૂ થાય છે, અને રિમોટ નોડ તરફથી પ્રતિસાદની રાહ જુએ છે. જો નિર્દિષ્ટ સમયગાળામાં કોઈ પ્રતિસાદ ન મળે, તો કનેક્શન સમાપ્ત કરવામાં આવે છે અને સંસાધનો બહાર પાડવામાં આવે છે. રીસીવિંગ બાજુ માટે, કનેક્શન ક્લોઝ ટાઈમર વર્ક ટાઈમર બે વાર સમાપ્ત થયા પછી શરૂ થાય છે. કન્ફર્મેશન પેકેટની ખોટ સામે વીમો લેવા માટે આ જરૂરી છે. જ્યારે ટાઈમર સમાપ્ત થાય છે, ત્યારે કનેક્શન પણ સમાપ્ત થાય છે અને સંસાધનો પ્રકાશિત થાય છે.

વિશ્વસનીય UDP ટ્રાન્સમિશન સ્ટેટ ડાયાગ્રામ

પ્રોટોકોલના સિદ્ધાંતો મર્યાદિત રાજ્ય મશીનમાં લાગુ કરવામાં આવે છે, જેમાંથી દરેક રાજ્ય પેકેટ પ્રક્રિયાના ચોક્કસ તર્ક માટે જવાબદાર છે.
વિશ્વસનીય UDP સ્ટેટ ડાયાગ્રામ:

બંધ - ખરેખર એક રાજ્ય નથી, તે ઓટોમેટન માટે શરૂઆત અને અંતિમ બિંદુ છે. રાજ્ય માટે બંધ ટ્રાન્સમિશન કંટ્રોલ બ્લોક પ્રાપ્ત થાય છે, જે, અસુમેળ UDP સર્વરને અમલમાં મૂકીને, પેકેટોને યોગ્ય જોડાણો પર ફોરવર્ડ કરે છે અને સ્ટેટ પ્રોસેસિંગ શરૂ કરે છે.

FirstPacketSending - પ્રારંભિક સ્થિતિ જેમાં સંદેશ મોકલવામાં આવે ત્યારે આઉટગોઇંગ કનેક્શન હોય છે.

આ સ્થિતિમાં, સામાન્ય સંદેશાઓ માટે પ્રથમ પેકેટ મોકલવામાં આવે છે. પુષ્ટિકરણ વિનાના સંદેશાઓ માટે, આ એકમાત્ર રાજ્ય છે જ્યાં સમગ્ર સંદેશ મોકલવામાં આવે છે.

સાયકલ મોકલો - સંદેશ પેકેટના પ્રસારણ માટે ગ્રાઉન્ડ સ્ટેટ.

રાજ્યમાંથી તેમાં સંક્રમણ FirstPacketSending સંદેશનું પ્રથમ પેકેટ મોકલ્યા પછી હાથ ધરવામાં આવે છે. તે આ સ્થિતિમાં છે કે તમામ સ્વીકૃતિઓ અને પુનઃપ્રસારણ માટેની વિનંતીઓ આવે છે. તેમાંથી બહાર નીકળવું બે કિસ્સાઓમાં શક્ય છે - સંદેશના સફળ વિતરણના કિસ્સામાં અથવા સમય સમાપ્ત થવાના કિસ્સામાં.

ફર્સ્ટપેકેટ પ્રાપ્ત થયું - સંદેશ પ્રાપ્તકર્તા માટે પ્રારંભિક સ્થિતિ.

તે ટ્રાન્સમિશનની શરૂઆતની શુદ્ધતા તપાસે છે, જરૂરી બંધારણ બનાવે છે અને પ્રથમ પેકેટની રસીદ મોકલે છે.

એવા સંદેશ માટે કે જેમાં એક જ પેકેટ હોય અને ડિલિવરીના પુરાવાનો ઉપયોગ કર્યા વિના મોકલવામાં આવ્યો હોય, આ એકમાત્ર રાજ્ય છે. આવા સંદેશ પર પ્રક્રિયા કર્યા પછી, કનેક્શન બંધ છે.

એસેમ્બલિંગ - સંદેશ પેકેટો પ્રાપ્ત કરવા માટેની મૂળભૂત સ્થિતિ.

તે અસ્થાયી સંગ્રહ માટે પેકેટો લખે છે, પેકેટની ખોટ તપાસે છે, પેકેટોના બ્લોક અને સમગ્ર સંદેશની ડિલિવરી માટે સ્વીકૃતિઓ મોકલે છે અને ખોવાયેલા પેકેટોની પુનઃ ડિલિવરી માટે વિનંતીઓ મોકલે છે. સમગ્ર સંદેશની સફળ પ્રાપ્તિના કિસ્સામાં, કનેક્શન રાજ્યમાં જાય છે પૂર્ણ, અન્યથા, સમયસમાપ્તિ બહાર નીકળી જાય છે.

પૂર્ણ - સમગ્ર સંદેશની સફળતાપૂર્વક પ્રાપ્તિના કિસ્સામાં કનેક્શન બંધ કરવું.

આ સ્થિતિ સંદેશની એસેમ્બલી માટે અને તે કેસ માટે જરૂરી છે જ્યારે પ્રેષકના માર્ગમાં સંદેશની ડિલિવરી પુષ્ટિ ખોવાઈ ગઈ હતી. આ સ્થિતિ સમયસમાપ્તિ દ્વારા બહાર નીકળી છે, પરંતુ કનેક્શન સફળતાપૂર્વક બંધ માનવામાં આવે છે.

કોડમાં વધુ ઊંડે. ટ્રાન્સમિશન કંટ્રોલ યુનિટ

વિશ્વસનીય 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));
}

સક્ષમ એસેમ્બલિંગ ReceivePacket પદ્ધતિમાં, આવનારા પેકેટોમાંથી સંદેશને એસેમ્બલ કરવાનું મુખ્ય કાર્ય થાય છે.
એસેમ્બલીંગ.રિસીવપેકેટ:

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

સક્ષમ પૂર્ણ પદ્ધતિનું એકમાત્ર કાર્ય સંદેશના સફળ વિતરણની પુનઃ સ્વીકૃતિ મોકલવાનું છે.
પૂર્ણ થયું.પેકેટ પ્રાપ્ત કરો:

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

પેકેટ પદ્ધતિ મોકલો

સક્ષમ FirstPacketSending આ પદ્ધતિ ડેટાનું પ્રથમ પેકેટ મોકલે છે, અથવા જો સંદેશને ડિલિવરી પુષ્ટિની જરૂર નથી, તો સમગ્ર સંદેશ.
FirstPacketSending.SendPacket:

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

સક્ષમ સાયકલ મોકલો આ પદ્ધતિમાં, પેકેટોનો બ્લોક મોકલવામાં આવે છે.
SendingCycle.SendPacket:

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

કોડમાં વધુ ઊંડે. જોડાણો બનાવવા અને સ્થાપિત કરવા

હવે જ્યારે આપણે મૂળભૂત સ્થિતિઓ અને રાજ્યોને હેન્ડલ કરવા માટે ઉપયોગમાં લેવાતી પદ્ધતિઓ જોઈ છે, ચાલો પ્રોટોકોલ કેવી રીતે કાર્ય કરે છે તેના થોડા ઉદાહરણોને થોડી વધુ વિગતમાં તોડીએ.
સામાન્ય સ્થિતિમાં ડેટા ટ્રાન્સમિશન ડાયાગ્રામ:

રચનાને વિગતવાર ધ્યાનમાં લો કનેક્શન રેકોર્ડ કનેક્ટ કરવા અને પ્રથમ પેકેટ મોકલવા માટે. ટ્રાન્સફર હંમેશા એપ્લીકેશન દ્વારા શરૂ કરવામાં આવે છે જે સેન્ડ મેસેજ API ને કૉલ કરે છે. આગળ, ટ્રાન્સમિશન કંટ્રોલ બ્લોકની સ્ટાર્ટ ટ્રાન્સમિશન પદ્ધતિનો ઉપયોગ કરવામાં આવે છે, જે નવા સંદેશ માટે ડેટાનું પ્રસારણ શરૂ કરે છે.
આઉટગોઇંગ કનેક્શન બનાવવું:

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

કાર્યકારી ટાઈમરની રાહ જોતી વખતે ઇનકમિંગ કનેક્શન પર કોઈ વધુ પેકેટ આવ્યા નથી. ટાઈમર બંધ થઈ ગયું અને પ્રોસેસપેકેટ્સ પદ્ધતિને બોલાવવામાં આવી, જ્યાં ખોવાયેલા પેકેટો મળ્યા અને ફરીથી ડિલિવરી વિનંતીઓ પ્રથમ વખત મોકલવામાં આવી.
પુનઃ વિતરણ વિનંતીઓ મોકલી રહ્યું છે (એસેમ્બલિંગ સ્ટેટ):

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 પ્રોટોકોલની ચર્ચા: ડ્રાફ્ટ-ietf-sigtran-reliable-udp-00
4. વિશ્વસનીય ડેટા પ્રોટોકોલ: આરએફસી 908 и આરએફસી 1151
5. UDP પર ડિલિવરી કન્ફર્મેશનનું સરળ અમલીકરણ: .NET અને UDP સાથે તમારા નેટવર્કિંગ પર સંપૂર્ણ નિયંત્રણ લો
6. NAT ટ્રાવર્સલ મિકેનિઝમ્સનું વર્ણન કરતો લેખ: પીઅર-ટુ-પીઅર કોમ્યુનિકેશન સમગ્ર નેટવર્ક એડ્રેસ ટ્રાન્સલેટર
7. અસુમેળ પ્રોગ્રામિંગ મોડેલનું અમલીકરણ: CLR અસિંક્રોનસ પ્રોગ્રામિંગ મોડલનો અમલ и IAsyncResult ડિઝાઇન પેટર્નનો અમલ કેવી રીતે કરવો
8. અસુમેળ પ્રોગ્રામિંગ મોડલને કાર્ય-આધારિત અસુમેળ પેટર્ન (TAP માં APM):
   TPL અને પરંપરાગત .NET અસિંક્રોનસ પ્રોગ્રામિંગ
   અન્ય અસિંક્રોનસ પેટર્ન અને પ્રકારો સાથે ઇન્ટરઓપ કરો

અપડેટ: આભાર mayorovp и sidristij ઇન્ટરફેસમાં કાર્ય ઉમેરવાના વિચાર માટે. જૂની ઓપરેટિંગ સિસ્ટમો સાથે લાઇબ્રેરીની સુસંગતતાનું ઉલ્લંઘન થતું નથી, કારણ કે 4થું ફ્રેમવર્ક XP અને 2003 સર્વરને સપોર્ટ કરે છે.

સોર્સ: www.habr.com