სანდო Udp პროტოკოლის დანერგვა .Net-ისთვის

ინტერნეტი დიდი ხნის წინ შეიცვალა. ინტერნეტის ერთ-ერთი მთავარი პროტოკოლი - UDP გამოიყენება აპლიკაციების მიერ არა მხოლოდ დატაგრამების და მაუწყებლობის მიწოდებისთვის, არამედ ქსელის კვანძებს შორის "თანხმობამდე" კავშირების უზრუნველსაყოფად. მარტივი დიზაინის გამო, ამ პროტოკოლს აქვს მრავალი ადრე დაუგეგმავი გამოყენება, თუმცა პროტოკოლის ნაკლოვანებები, როგორიცაა გარანტირებული მიწოდების არარსებობა, არსად გამქრალა. ეს სტატია აღწერს გარანტირებული მიწოდების პროტოკოლის განხორციელებას UDP-ზე.
შინაარსი:Entry
პროტოკოლის მოთხოვნები
სანდო UDP სათაური
პროტოკოლის ზოგადი პრინციპები
ვადები და პროტოკოლის ტაიმერი
საიმედო UDP გადაცემის მდგომარეობის დიაგრამა
უფრო ღრმად შევიდა კოდი. გადაცემის კონტროლის განყოფილება
უფრო ღრმად შევიდა კოდი. შტატები

• DisposeByTimeout მეთოდი
• ProcessPackets მეთოდი
• ReceivePacket მეთოდი
• პაკეტის გაგზავნის მეთოდი

უფრო ღრმად შევიდა კოდი. კავშირების შექმნა და დამყარება
უფრო ღრმად შევიდა კოდი. კავშირის დახურვა დროის ამოწურვისას
უფრო ღრმად შევიდა კოდი. მონაცემთა გადაცემის აღდგენა
სანდო UDP API
დასკვნა
სასარგებლო ბმულები და სტატიები

Entry

ინტერნეტის თავდაპირველი არქიტექტურა ითვალისწინებდა მისამართების ერთგვაროვან სივრცეს, რომელშიც თითოეულ კვანძს ჰქონდა გლობალური და უნიკალური IP მისამართი და შეეძლო პირდაპირ დაუკავშირდეს სხვა კვანძებს. ახლა ინტერნეტს, ფაქტობრივად, აქვს განსხვავებული არქიტექტურა - გლობალური IP მისამართების ერთი არე და მრავალი უბანი, სადაც პირადი მისამართები იმალება NAT მოწყობილობების მიღმა.ამ არქიტექტურაში, მხოლოდ გლობალურ მისამართთა სივრცეში არსებულ მოწყობილობებს შეუძლიათ ადვილად დაუკავშირდნენ ნებისმიერს ქსელში, რადგან მათ აქვთ უნიკალური, გლობალურად მარშრუტირებადი IP მისამართი. კერძო ქსელის კვანძს შეუძლია დაუკავშირდეს იმავე ქსელის სხვა კვანძებს და ასევე შეიძლება დაუკავშირდეს სხვა ცნობილ კვანძებს გლობალური მისამართების სივრცეში. ეს ურთიერთქმედება ძირითადად მიიღწევა ქსელის მისამართის თარგმნის მექანიზმის წყალობით. NAT მოწყობილობები, როგორიცაა Wi-Fi მარშრუტიზატორები, ქმნიან თარგმანის ცხრილის სპეციალურ ჩანაწერებს გამავალი კავშირებისთვის და ცვლიან IP მისამართებს და პორტების ნომრებს პაკეტებში. ეს საშუალებას იძლევა გამავალი კავშირები კერძო ქსელიდან ჰოსტებთან გლობალური მისამართების სივრცეში. მაგრამ ამავე დროს, NAT მოწყობილობები, როგორც წესი, ბლოკავს ყველა შემომავალ ტრაფიკს, თუ შემომავალი კავშირების ცალკეული წესები არ არის დადგენილი.

ინტერნეტის ეს არქიტექტურა საკმარისად სწორია კლიენტ-სერვერის კომუნიკაციისთვის, სადაც კლიენტები შეიძლება იყვნენ კერძო ქსელებში, ხოლო სერვერებს აქვთ გლობალური მისამართი. მაგრამ ეს ქმნის სირთულეებს ორი კვანძის პირდაპირი კავშირისთვის სხვადასხვა კერძო ქსელები. პირდაპირი კავშირი ორ კვანძს შორის მნიშვნელოვანია peer-to-peer აპლიკაციებისთვის, როგორიცაა ხმის გადაცემა (Skype), კომპიუტერზე დისტანციური წვდომის მოპოვება (TeamViewer) ან ონლაინ თამაშები.

ერთ-ერთ ყველაზე ეფექტურ მეთოდს სხვადასხვა კერძო ქსელში მოწყობილ მოწყობილობებს შორის თანატოლებთან კავშირის დამყარების მიზნით, ხვრელის დარტყმა ეწოდება. ეს ტექნიკა ყველაზე ხშირად გამოიყენება UDP პროტოკოლზე დაფუძნებულ აპლიკაციებთან.

მაგრამ თუ თქვენს აპლიკაციას სჭირდება მონაცემთა გარანტირებული მიწოდება, მაგალითად, თქვენ გადარიცხავთ ფაილებს კომპიუტერებს შორის, მაშინ UDP-ს გამოყენებას ბევრი სირთულე ექნება იმის გამო, რომ UDP არ არის გარანტირებული მიწოდების პროტოკოლი და არ უზრუნველყოფს პაკეტის მიწოდებას წესრიგში, განსხვავებით TCP-ისგან. ოქმი.

ამ შემთხვევაში, პაკეტის გარანტირებული მიწოდების უზრუნველსაყოფად, საჭიროა აპლიკაციის ფენის პროტოკოლის დანერგვა, რომელიც უზრუნველყოფს აუცილებელ ფუნქციონირებას და მუშაობს UDP-ზე.

მსურს დაუყოვნებლივ აღვნიშნო, რომ არსებობს TCP ხვრელების ტექნიკა სხვადასხვა კერძო ქსელში კვანძებს შორის TCP კავშირების დასამყარებლად, მაგრამ მრავალი NAT მოწყობილობის მიერ მისი მხარდაჭერის არარსებობის გამო, ეს ჩვეულებრივ არ განიხილება, როგორც დაკავშირების მთავარი გზა. ასეთი კვანძები.

ამ სტატიის დარჩენილი ნაწილისთვის მე მხოლოდ გარანტირებული მიწოდების პროტოკოლის განხორციელებაზე გავამახვილებ ყურადღებას. UDP ხვრელების ტექნიკის განხორციელება აღწერილი იქნება შემდეგ სტატიებში.

პროტოკოლის მოთხოვნები

1. სანდო პაკეტის მიწოდება, რომელიც განხორციელებულია დადებითი გამოხმაურების მექანიზმით (ე.წ. პოზიტიური აღიარება)
2. დიდი მონაცემების ეფექტური გადაცემის საჭიროება, ე.ი. პროტოკოლმა თავიდან უნდა აიცილოს არასაჭირო პაკეტის რელეები
3. შესაძლებელი უნდა იყოს მიწოდების დადასტურების მექანიზმის გაუქმება ("სუფთა" UDP პროტოკოლის ფუნქციონირების შესაძლებლობა)
4. ბრძანების რეჟიმის განხორციელების შესაძლებლობა, თითოეული შეტყობინების დადასტურებით
5. პროტოკოლზე მონაცემთა გადაცემის ძირითადი ერთეული უნდა იყოს შეტყობინება

ეს მოთხოვნები დიდწილად ემთხვევა სანდო მონაცემთა პროტოკოლის მოთხოვნებს, რომლებიც აღწერილია rfc908 и rfc1151და მე ვეყრდნობოდი ამ სტანდარტებს ამ პროტოკოლის შემუშავებისას.

ამ მოთხოვნების გასაგებად, მოდით შევხედოთ მონაცემთა გადაცემის ვადებს ორ ქსელურ კვანძს შორის TCP და UDP პროტოკოლების გამოყენებით. მოდით ორივე შემთხვევაში დაგვკარგავს ერთი პაკეტი.
არაინტერაქტიული მონაცემების გადაცემა TCP-ზე:

როგორც სქემიდან ხედავთ, პაკეტის დაკარგვის შემთხვევაში, TCP აღმოაჩენს დაკარგულ პაკეტს და აცნობებს მას გამომგზავნს დაკარგული სეგმენტის ნომრის მოთხოვნით.
მონაცემთა გადაცემა UDP პროტოკოლით:

UDP არ იღებს ზარალის გამოვლენის ნაბიჯებს. UDP პროტოკოლში გადაცემის შეცდომების კონტროლი მთლიანად აპლიკაციის პასუხისმგებლობაა.

TCP პროტოკოლში შეცდომის გამოვლენა მიიღწევა ბოლო კვანძთან კავშირის დამყარებით, ამ კავშირის მდგომარეობის შენახვით, თითოეულ პაკეტის სათაურში გაგზავნილი ბაიტების რაოდენობის მითითებით და ქვითრების შეტყობინებით დადასტურების ნომრის გამოყენებით.

გარდა ამისა, შესრულების გასაუმჯობესებლად (ანუ ერთზე მეტი სეგმენტის გაგზავნა დადასტურების მიღების გარეშე), TCP პროტოკოლი იყენებს ეგრეთ წოდებულ გადაცემის ფანჯარას - მონაცემთა ბაიტების რაოდენობას, რომელსაც სეგმენტის გამგზავნი მოელის.

დამატებითი ინფორმაციისთვის TCP პროტოკოლის შესახებ იხ rfc793, UDP-დან rfc768სადაც, ფაქტობრივად, ისინი განსაზღვრულია.

ზემოაღნიშნულიდან ირკვევა, რომ UDP-ზე შეტყობინების მიწოდების საიმედო პროტოკოლის შესაქმნელად (შემდგომში სანდო UDP), საჭიროა TCP-ის მსგავსი მონაცემთა გადაცემის მექანიზმების დანერგვა. კერძოდ:

• კავშირის მდგომარეობის შენახვა
• გამოიყენეთ სეგმენტის ნუმერაცია
• გამოიყენეთ სპეციალური დადასტურების პაკეტები
• გამოიყენეთ გამარტივებული ფანჯრის მექანიზმი პროტოკოლის გამტარუნარიანობის გასაზრდელად

გარდა ამისა, გჭირდებათ:

• შეტყობინების დაწყების სიგნალი, რათა გამოყოს რესურსები კავშირისთვის
• გაგზავნეთ შეტყობინების დასასრულის სიგნალი, გადასცეს მიღებული შეტყობინება ზემოთ ნაკადის აპლიკაციაში და გაათავისუფლოს პროტოკოლის რესურსები
• ნება მიეცით კავშირის სპეციფიკურ პროტოკოლს გამორთოს მიწოდების დადასტურების მექანიზმი "სუფთა" UDP-ის სახით

სანდო UDP სათაური

შეგახსენებთ, რომ UDP დატაგრამა ჩასმულია IP დატაგრამაში. სანდო UDP პაკეტი სათანადოდ "შეფუთულია" UDP დატაგრამაში.
საიმედო UDP სათაურის ინკაპსულაცია:

საიმედო UDP სათაურის სტრუქტურა საკმაოდ მარტივია:

• დროშები - პაკეტის კონტროლის დროშები
• MessageType - შეტყობინებების ტიპი, რომელსაც იყენებენ ზედა ნაკადის აპლიკაციები კონკრეტული შეტყობინებების გამოსაწერად
• TransmissionId - გადაცემის ნომერი, მიმღების მისამართთან და პორტთან ერთად, ცალსახად განსაზღვრავს კავშირს
• PacketNumber - პაკეტის ნომერი
• ოფციები - დამატებითი პროტოკოლის პარამეტრები. პირველი პაკეტის შემთხვევაში, იგი გამოიყენება შეტყობინების ზომის მითითებისთვის

დროშები ასეთია:

• FirstPacket - შეტყობინების პირველი პაკეტი
• NoAsk - შეტყობინება არ საჭიროებს დადასტურების მექანიზმის ჩართვას
• LastPacket - შეტყობინების ბოლო პაკეტი
• RequestForPacket - დადასტურების პაკეტი ან დაკარგული პაკეტის მოთხოვნა

პროტოკოლის ზოგადი პრინციპები

ვინაიდან სანდო UDP ორიენტირებულია ორ კვანძს შორის შეტყობინების გარანტირებულ გადაცემაზე, მას უნდა შეეძლოს კავშირის დამყარება მეორე მხარესთან. კავშირის დასამყარებლად, გამგზავნი აგზავნის პაკეტს FirstPacket დროშით, რომელზეც პასუხი ნიშნავს კავშირის დამყარებას. ყველა საპასუხო პაკეტი, ან სხვა სიტყვებით რომ ვთქვათ, დადასტურების პაკეტები, ყოველთვის ადგენს PacketNumber ველის მნიშვნელობას ერთით მეტი, ვიდრე წარმატებით მიღებული პაკეტების უდიდესი PacketNumber მნიშვნელობა. ოფციების ველი პირველი გაგზავნილი პაკეტისთვის არის შეტყობინების ზომა.

მსგავსი მექანიზმი გამოიყენება კავშირის შესაწყვეტად. LastPacket დროშა დაყენებულია შეტყობინების ბოლო პაკეტზე. საპასუხო პაკეტში მითითებულია ბოლო პაკეტის ნომერი + 1, რაც მიმღები მხარისთვის ნიშნავს შეტყობინების წარმატებულ მიწოდებას.
კავშირის დამყარებისა და შეწყვეტის დიაგრამა:

როდესაც კავშირი დამყარდება, მონაცემთა გადაცემა იწყება. მონაცემები გადაიცემა პაკეტების ბლოკებში. თითოეული ბლოკი, გარდა უკანასკნელისა, შეიცავს პაკეტების ფიქსირებულ რაოდენობას. ის უდრის მიღების/გადაცემის ფანჯრის ზომას. მონაცემთა ბოლო ბლოკს შეიძლება ჰქონდეს ნაკლები პაკეტები. თითოეული ბლოკის გაგზავნის შემდეგ, გამგზავნ მხარე ელოდება მიწოდების დადასტურებას ან მოთხოვნას დაკარგული პაკეტების ხელახლა მიწოდების შესახებ, ტოვებს მიღების/გადაცემის ფანჯარას ღია პასუხების მისაღებად. ბლოკის მიწოდების დადასტურების მიღების შემდეგ, მიღების/გადაცემის ფანჯარა იცვლება და იგზავნება მონაცემთა შემდეგი ბლოკი.

მიმღები მხარე იღებს პაკეტებს. თითოეული პაკეტი მოწმდება, რათა ნახოთ, მოხვდება თუ არა გადაცემის ფანჯარაში. პაკეტები და დუბლიკატები, რომლებიც არ მოხვდება ფანჯარაში, იფილტრება. იმიტომ რომ თუ ფანჯრის ზომა ფიქსირდება და იგივეა მიმღებისთვის და გამგზავნისთვის, მაშინ პაკეტების ბლოკის დაკარგვის გარეშე მიწოდების შემთხვევაში, ფანჯარა გადადის მონაცემთა შემდეგი ბლოკის პაკეტების მისაღებად და მიწოდების დადასტურება ხდება. გაგზავნილი. თუ ფანჯარა არ ივსება სამუშაო ტაიმერის მიერ დადგენილ ვადაში, მაშინ დაიწყება შემოწმება, რომლებზედაც არ იქნა მიწოდებული პაკეტები და გაიგზავნება მოთხოვნა ხელახლა მიწოდებაზე.
ხელახალი გადაცემის დიაგრამა:

ვადები და პროტოკოლის ტაიმერი

კავშირის დამყარების რამდენიმე მიზეზი არსებობს. მაგალითად, თუ მიმღები მხარე ხაზგარეშეა. ამ შემთხვევაში, კავშირის დამყარების მცდელობისას, კავშირი დაიხურება დროის ამოწურვის გამო. სანდო UDP დანერგვა იყენებს ორ ტაიმერს დროის ამოწურვის დასაყენებლად. პირველი, სამუშაო ტაიმერი, გამოიყენება დისტანციური მასპინძლის პასუხის მოლოდინში. თუ ის ეშვება გამგზავნის მხარეს, მაშინ ბოლო გაგზავნილი პაკეტი ხელახლა იგზავნება. თუ ტაიმერი იწურება მიმღებზე, მაშინ ხდება დაკარგული პაკეტების შემოწმება და იგზავნება მოთხოვნა ხელახლა მიწოდების შესახებ.

მეორე ტაიმერი საჭიროა კავშირის დახურვისას კვანძებს შორის კომუნიკაციის ნაკლებობის შემთხვევაში. გამგზავნის მხრიდან, ის იწყება სამუშაო ტაიმერის ვადის ამოწურვისთანავე და ელოდება პასუხს დისტანციური კვანძიდან. თუ პასუხი არ იქნება მითითებულ ვადაში, კავშირი წყდება და რესურსები იხსნება. მიმღები მხარისთვის, კავშირის დახურვის ტაიმერი იწყება სამუშაო ტაიმერის ორჯერ ამოწურვის შემდეგ. ეს აუცილებელია დადასტურების პაკეტის დაკარგვის თავიდან ასაცილებლად. როდესაც ტაიმერი ამოიწურება, კავშირი ასევე წყდება და რესურსები იხსნება.

საიმედო UDP გადაცემის მდგომარეობის დიაგრამა

პროტოკოლის პრინციპები დანერგილია სასრული მდგომარეობის მანქანაში, რომლის თითოეული მდგომარეობა პასუხისმგებელია პაკეტის დამუშავების გარკვეულ ლოგიკაზე.
სანდო UDP მდგომარეობის დიაგრამა:

დახურვის - ეს ნამდვილად არ არის სახელმწიფო, ეს არის საწყისი და დასასრული წერტილი ავტომატისთვის. სახელმწიფოსთვის დახურვის მიიღება გადაცემის კონტროლის ბლოკი, რომელიც ასინქრონული UDP სერვერის დანერგვით, პაკეტებს გადასცემს შესაბამის კავშირებს და იწყებს მდგომარეობის დამუშავებას.

FirstPacketSending – საწყისი მდგომარეობა, რომელშიც არის გამავალი კავშირი შეტყობინების გაგზავნისას.

ამ მდგომარეობაში იგზავნება პირველი პაკეტი ნორმალური შეტყობინებებისთვის. შეტყობინებებისთვის გაგზავნის დადასტურების გარეშე, ეს არის ერთადერთი მდგომარეობა, სადაც იგზავნება მთელი შეტყობინება.

გაგზავნის ციკლი – ძირითადი მდგომარეობა შეტყობინებების პაკეტების გადაცემისთვის.

მასზე გადასვლა სახელმწიფოდან FirstPacketSending შესრულებულია შეტყობინების პირველი პაკეტის გაგზავნის შემდეგ. სწორედ ამ მდგომარეობაში მოდის ყველა აღიარება და მოთხოვნა ხელახალი გადაცემის შესახებ. მისგან გასვლა შესაძლებელია ორ შემთხვევაში - შეტყობინების წარმატებულად მიწოდების შემთხვევაში ან ტაიმაუტით.

FirstPacketReceived – საწყისი მდგომარეობა შეტყობინების მიმღებისთვის.

ის ამოწმებს გადაცემის დასაწყისის სისწორეს, ქმნის საჭირო სტრუქტურებს და აგზავნის პირველი პაკეტის მიღების დადასტურებას.

შეტყობინებისთვის, რომელიც შედგება ერთი პაკეტისგან და გაიგზავნა მიწოდების მტკიცებულების გარეშე, ეს ერთადერთი მდგომარეობაა. ასეთი შეტყობინების დამუშავების შემდეგ, კავშირი იხურება.

იკრიბება - ძირითადი მდგომარეობა შეტყობინებების პაკეტების მისაღებად.

ის წერს პაკეტებს დროებით შესანახად, ამოწმებს პაკეტების დაკარგვას, აგზავნის დადასტურებას პაკეტების ბლოკისა და მთელი შეტყობინების მიწოდებისთვის და აგზავნის მოთხოვნას დაკარგული პაკეტების ხელახლა მიწოდებისთვის. მთელი შეტყობინების წარმატებით მიღების შემთხვევაში, კავშირი გადადის მდგომარეობაში დასრულებული, წინააღმდეგ შემთხვევაში, დრო გადის.

დასრულებული – კავშირის დახურვა მთელი შეტყობინების წარმატებით მიღების შემთხვევაში.

ეს მდგომარეობა აუცილებელია შეტყობინების შეკრებისთვის და იმ შემთხვევისთვის, როდესაც შეტყობინების მიწოდების დადასტურება დაიკარგა გამგზავნის გზაზე. ამ მდგომარეობიდან გასვლა ხდება დროის ამოწურვით, მაგრამ კავშირი წარმატებით დახურულად ითვლება.

უფრო ღრმად შევიდა კოდი. გადაცემის კონტროლის განყოფილება

საიმედო 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 მეთოდი

ProcessPackets მეთოდი პასუხისმგებელია პაკეტის ან პაკეტების დამატებით დამუშავებაზე. დარეკვა პირდაპირ ან პაკეტის მოლოდინის ტაიმერის საშუალებით.

მდგომარეობაში იკრიბება მეთოდი აკრძალულია და პასუხისმგებელია დაკარგული პაკეტების შემოწმებაზე და მდგომარეობაზე გადასვლაზე დასრულებული, ბოლო პაკეტის მიღების და წარმატებული შემოწმების გავლის შემთხვევაში
Assembling.ProcessPackets:

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

მდგომარეობაში გაგზავნის ციკლი ეს მეთოდი გამოძახებულია მხოლოდ ტაიმერზე და პასუხისმგებელია ბოლო შეტყობინების ხელახლა გაგზავნაზე, ასევე კავშირის დახურვის ტაიმერის ჩართვაზე.
SendingCycle.ProcessPackets:

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

მდგომარეობაში დასრულებული მეთოდი აჩერებს გაშვებულ ტაიმერს და აგზავნის შეტყობინებას აბონენტებს.
Completed.ProcessPackets:

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

ReceivePacket მეთოდი

მდგომარეობაში FirstPacketReceived მეთოდის მთავარი ამოცანაა დაადგინოს, მართლაც მოვიდა თუ არა პირველი შეტყობინებების პაკეტი ინტერფეისში, და ასევე შეაგროვოს შეტყობინება, რომელიც შედგება ერთი პაკეტისგან.
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 მეთოდში ხდება შემომავალი პაკეტებიდან შეტყობინების აწყობის ძირითადი სამუშაო.
Assembling.ReceivePacket:

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

მდგომარეობაში დასრულებული მეთოდის ერთადერთი ამოცანაა შეტყობინების გაგზავნა წარმატებული მიწოდების შესახებ.
დასრულდა. ReceivePacket:

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

პაკეტის გაგზავნის მეთოდი

მდგომარეობაში FirstPacketSending ეს მეთოდი აგზავნის მონაცემთა პირველ პაკეტს, ან, თუ შეტყობინება არ საჭიროებს მიწოდების დადასტურებას, მთელ შეტყობინებას.
FirstPacketSending.SendPacket:

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

მდგომარეობაში გაგზავნის ციკლი ამ მეთოდით იგზავნება პაკეტების ბლოკი.
SendingCycle.SendPacket:

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

უფრო ღრმად შევიდა კოდი. კავშირების შექმნა და დამყარება

ახლა, როდესაც ჩვენ ვნახეთ ძირითადი მდგომარეობები და მდგომარეობების დამუშავების მეთოდები, მოდით ჩამოვყოთ რამდენიმე მაგალითი, თუ როგორ მუშაობს პროტოკოლი ცოტა უფრო დეტალურად.
მონაცემთა გადაცემის დიაგრამა ნორმალურ პირობებში:

დეტალურად განიხილეთ შექმნა კავშირის ჩანაწერი პირველი პაკეტის დასაკავშირებლად და გაგზავნისთვის. გადაცემა ყოველთვის ინიცირებულია აპლიკაციის მიერ, რომელიც უწოდებს გაგზავნის შეტყობინების API-ს. შემდეგი, გამოიძახება გადაცემის მართვის ბლოკის StartTransmission მეთოდი, რომელიც იწყებს მონაცემთა გადაცემას ახალი შეტყობინებისთვის.
გამავალი კავშირის შექმნა:

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 მდგომარეობა):

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 მეთოდის გამოყენებით, იღებს გაგზავნილ პაკეტს, ქმნის ახალს კავშირის ჩანაწერი და გადასცემს ამ პაკეტს, წინასწარ გაანალიზებული სათაურით, დამუშავების მდგომარეობის ReceivePacket მეთოდს FirstPacketReceived
კავშირის შექმნა მიმღებ მხარეს:

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

პირველი პაკეტის მიღება და დადასტურების გაგზავნა (FirstPacketReceived მდგომარეობა):

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

უფრო ღრმად შევიდა კოდი. კავშირის დახურვა დროის ამოწურვისას

ვადის გატარება საიმედო UDP-ის მნიშვნელოვანი ნაწილია. განვიხილოთ მაგალითი, როდესაც შუალედური კვანძი ვერ მოხერხდა და მონაცემთა მიწოდება ორივე მიმართულებით შეუძლებელი გახდა.
კავშირის დახურვის დიაგრამა ვადამდე:

როგორც სქემიდან ჩანს, გამგზავნის სამუშაო ტაიმერი იწყება პაკეტების ბლოკის გაგზავნისთანავე. ეს ხდება სახელმწიფოს SendPacket მეთოდში გაგზავნის ციკლი.
სამუშაო ტაიმერის ჩართვა (SendingCycle მდგომარეობა):

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

კავშირის შექმნისას დგინდება ტაიმერის პერიოდები. ნაგულისხმევი ShortTimerPeriod არის 5 წამი. მაგალითში დაყენებულია 1,5 წამზე.

შემომავალი კავშირისთვის, ტაიმერი იწყება ბოლო შემომავალი მონაცემთა პაკეტის მიღების შემდეგ, ეს ხდება სახელმწიფოს ReceivePacket მეთოდით. იკრიბება
სამუშაო ტაიმერის ჩართვა (აწყობის მდგომარეობა):

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

სამუშაო ტაიმერის მოლოდინში შემომავალ კავშირზე პაკეტები აღარ შემოსულა. ტაიმერი გაითიშა და გამოიძახა ProcessPackets მეთოდი, სადაც იპოვეს დაკარგული პაკეტები და პირველად გაიგზავნა ხელახალი მიწოდების მოთხოვნა.
ხელახლა მიწოდების მოთხოვნების გაგზავნა (შეკრების მდგომარეობა):

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

TimerSecondTry ცვლადი დაყენებულია მართალია. ეს ცვლადი პასუხისმგებელია სამუშაო ტაიმერის გადატვირთვაზე.

გამგზავნის მხრივ, სამუშაო ტაიმერი ასევე ამოქმედდება და ბოლო გაგზავნილი პაკეტი ხელახლა იგზავნება.
კავშირის დახურვის ტაიმერის ჩართვა (SendingCycle მდგომარეობა):

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

გამგზავნი მიიღებს ხელახლა მიწოდების მოთხოვნას და გაუგზავნის დაკარგული პაკეტებს. აღსანიშნავია, რომ ამ მომენტში გამგზავნმა უკვე დაიწყო კავშირის დახურვის ტაიმერი და მოთხოვნის მიღებისას ის გადატვირთულია.
დაკარგული პაკეტების ხელახლა გაგზავნა (SendingCycle მდგომარეობა):

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)

შეტყობინების გაგზავნის შედეგი იქნება true - თუ შეტყობინება წარმატებით მიაღწია მიმღებს და false - თუ კავშირი დაიხურა დროის ამოწურვის გამო:

public bool EndSendMessage(IAsyncResult asyncResult)

დასკვნა

ამ სტატიაში ბევრი რამ არ არის აღწერილი. თემების შესატყვისი მექანიზმები, გამონაკლისის და შეცდომების დამუშავება, ასინქრონული შეტყობინების გაგზავნის მეთოდების დანერგვა. მაგრამ პროტოკოლის არსი, პაკეტების დამუშავების ლოგიკის აღწერა, კავშირის დამყარება და ვადების დამუშავება, გასაგები უნდა იყოს თქვენთვის.

საიმედო მიწოდების პროტოკოლის დემონსტრირებული ვერსია საკმარისად ძლიერი და მოქნილია, რომ დააკმაყოფილოს ადრე განსაზღვრული მოთხოვნები. მაგრამ მე მინდა დავამატო, რომ აღწერილი განხორციელება შეიძლება გაუმჯობესდეს. მაგალითად, გამტარუნარიანობის გასაზრდელად და ტაიმერის პერიოდების დინამიურად შესაცვლელად, პროტოკოლს შეიძლება დაემატოს ისეთი მექანიზმები, როგორიცაა მოცურების ფანჯარა და RTT, ასევე სასარგებლო იქნება MTU-ის განსაზღვრის მექანიზმის დანერგვა კავშირის კვანძებს შორის (მაგრამ მხოლოდ დიდი შეტყობინებების გაგზავნის შემთხვევაში). .

გმადლობთ ყურადღებისთვის, ველი თქვენს კომენტარებს და კომენტარებს.

PS მათთვის, ვისაც აინტერესებს დეტალები ან უბრალოდ სურს პროტოკოლის ტესტირება, პროექტის ბმული GitHube-ზე:
სანდო UDP პროექტი

სასარგებლო ბმულები და სტატიები

1. TCP პროტოკოლის სპეციფიკაცია: ინგლისურ ენაზე и на русском
2. UDP პროტოკოლის სპეციფიკაცია: ინგლისურ ენაზე и на русском
3. RUDP პროტოკოლის განხილვა: draft-ietf-sigtran-reliable-udp-00
4. სანდო მონაცემთა პროტოკოლი: rfc908 и rfc1151
5. UDP-ზე მიტანის დადასტურების მარტივი განხორციელება: აიღეთ თქვენი ქსელის სრული კონტროლი .NET-ით და UDP-ით
6. სტატია, რომელიც აღწერს NAT-ის გავლის მექანიზმებს: Peer-to-Peer კომუნიკაცია ქსელის მისამართების მთარგმნელებში
7. ასინქრონული პროგრამირების მოდელის დანერგვა: CLR ასინქრონული პროგრამირების მოდელის დანერგვა и როგორ განვახორციელოთ IAsyncResult დიზაინის ნიმუში
8. ასინქრონული პროგრამირების მოდელის პორტირება ამოცანებზე დაფუძნებულ ასინქრონულ შაბლონზე (APM TAP-ში):
   TPL და ტრადიციული .NET ასინქრონული პროგრამირება
   ურთიერთქმედება სხვა ასინქრონულ ნიმუშებთან და ტიპებთან

განახლება: გმადლობთ მაიოროვპ и სიდრისტიჟ ინტერფეისში დავალების დამატების იდეისთვის. ბიბლიოთეკის თავსებადობა ძველ ოპერაციულ სისტემებთან არ ირღვევა, რადგან მე-4 ჩარჩო მხარს უჭერს ორივე XP და 2003 სერვერს.

წყარო: www.habr.com