एक फुर्तीला रिमोट लिखना - डेस्कटॉप क्लाइंट C # और XNA में

नमस्ते, मैं दिखाऊंगा कि C # + XNA का उपयोग करके रिमोट - डेस्कटॉप क्लाइंट कैसे लिखें


इस विषय ने मुझे इस लेख को लिखने के लिए प्रेरित किया।

थोड़ा खुद से

मैंने उस लेख के दूसरे भाग के लिए बहुत लंबा समय इंतजार किया, लेकिन मैंने इंतजार नहीं किया। लेखक के अनुसार, दूसरे लेख में यूडीपी के माध्यम से एक दूरस्थ ग्राहक को छवियों को प्रसारित करने का कार्यान्वयन होना चाहिए था। उसके बाद मैंने स्वयं लेख के दूसरे भाग को लागू करने की कोशिश की, लेकिन यह हमेशा बुरी तरह से निकला। जीडीआई की धीमी ड्राइंग के कारण, कार्यक्रम केवल कंप्यूटर कोर 2 डुओ 2.66 गीगाहर्ट्ज, एनवीडिया जीफोर्स 9600 जीटी पर लटका दिया गया। मैंने विभिन्न ऑप्टिमाइज़ेशन एल्गोरिदम का उपयोग किया, लेकिन इससे बहुत मदद नहीं मिली और फिर मैंने XNA का उपयोग करने का निर्णय लिया।

ट्रांसमिशन प्रोटोकॉल चयन

मैं वास्तव में ट्रांसमिशन प्रोटोकॉल टीसीपी को चुनना चाहता था, इसके साथ कम समस्याएं हैं, लेकिन मैंने यूडीपी को चुना, क्योंकि हर कोई कहता है कि ऐसे मामलों के लिए ब्ला ब्ला ब्ला लेना बेहतर है ... आपको शायद आश्चर्य है कि यूडीपी के साथ अधिक समस्याएं क्यों हैं? उत्तर सरल है - एक यूडीपी संदेश 65,507 बाइट्स के आकार से अधिक नहीं हो सकता है, जो बहुत असुविधाजनक है। हमारे पैकेज औसतन 130,000 बाइट्स (1366x768 स्क्रीन के लिए), इस तरह के पैकेज को भेजने की कोशिश करते समय एक त्रुटि होती है, जैसा कि नीचे दिखाया गया है।


इस समस्या को हल करने के दो तरीके हैं:
1) एक बैसाखी बनाएँ
2) एक संरचना बनाएँ

1) जब से मैं आलसी हूं, मैंने एक बैसाखी चुनी। बैसाखी एक बड़े संदेश को कई छोटे लोगों में तोड़ना है और पहले संदेश में उन टुकड़ों की संख्या लिखें जो भेजे जाएंगे। मैंने एक बैसाखी कहा, क्योंकि, पहला संदेश खो जाने के बाद, कार्यक्रम नरक में जाएगा और यह छवि को सामान्य रूप से एक साथ गोंद करने में सक्षम नहीं होगा (यह नहीं पता होगा कि छवि कितने हिस्सों में टूटी हुई है)।

2) आप स्क्रीन को कई टुकड़ों में तोड़ सकते हैं और उनके निर्देशांक याद रख सकते हैं। यह सब एक संरचना में संग्रहीत करने की आवश्यकता होगी, जो बहुत सुविधाजनक है, वैसे, यह एल्गोरिदम भविष्य में अनुकूलन बनाने में मदद करेगा।

अभ्यास

मैं एक साधारण से शुरुआत करता हूँ। भेजने वाले से। हम अपनी स्क्रीन के स्क्रीनशॉट रिमोट कंप्यूटर पर भेजेंगे। मैंने डेटा लोड करने और कुछ वैरिएबल को इनिशियलाइज़ करने के लिए एक फंक्शन लिखा।

लॉन्च बिंदु हमारा रन () फ़ंक्शन होगा।

public void Run() { Load(); //       udpClient = new UdpClient(); Bitmap BackGround = new Bitmap(width, height); Graphics graphics = Graphics.FromImage(BackGround); while (true) { //    graphics.CopyFromScreen(0, 0, 0, 0, new Size(width, height)); //       byte [] bytes = ConvertToByte(BackGround); List<byte[]> lst = CutMsg(bytes); for (int i = 0; i < lst.Count; i++) { //    udpClient.Send(lst[i], lst[i].Length, ipEndPoint); } } } 

सबसे पहले, लोड () डेटा लोड किया जाता है, जिसके बाद चर घोषित किए जाते हैं और लूप किए जाते हैं। लूप में, हमें एक स्क्रीन छवि मिलती है, इसे बाइट्स के एक सरणी में परिवर्तित करें, मेरी बैसाखी का उपयोग करें (एक संदेश को कई उप संदेशों में विभाजित करें - CutMsg (बाइट्स)), सभी पैकेट भेजें।

लोड () फ़ंक्शन में कुछ भी दिलचस्प नहीं होता है।
दो पंक्तियाँ ip.txt फ़ाइल से पढ़ी जाएंगी । पहली पंक्ति आईपी पता है जिसे डेटा भेजा जाना चाहिए। दूसरी पंक्ति बंदरगाह है, जिस पर इसे भेजा जाएगा। इसके अलावा स्क्रीन की लंबाई और चौड़ाई की एक रसीद होगी।

रूपांतरण समारोह

 private byte [] ConvertToByte(Bitmap bmp) { MemoryStream memoryStream = new MemoryStream(); //       Jpeg bmp.Save(memoryStream, System.Drawing.Imaging.ImageFormat.Jpeg); return memoryStream.ToArray(); } 

और सबसे दिलचस्प बैसाखी का कार्यान्वयन है।

 private List<byte[]> CutMsg(byte[] bt) { int Lenght = bt.Length; byte[] temp; List<byte[]> msg = new List<byte[]>(); MemoryStream memoryStream = new MemoryStream(); //    2    memoryStream.Write( BitConverter.GetBytes((short)((Lenght / 65500) + 1)), 0, 2); //     memoryStream.Write(bt, 0, bt.Length); memoryStream.Position = 0; //      -   while (Lenght > 0) { temp = new byte[65500]; memoryStream.Read(temp, 0, 65500); msg.Add(temp); Lenght -= 65500; } return msg; } 

मैं डेटा को 65500 के ब्लॉक में विभाजित करता हूं (मैंने स्पष्ट रूप से प्राप्त करने के लिए संख्या को कम लिया) और इसे बाइट सरणियों की सूची में लिख दिया, जिसके बाद मैं इस शीट को वापस करता हूं।

प्राप्तकर्ता कोड

प्राप्तकर्ता के साथ सब कुछ अधिक जटिल है, मैंने अतुल्यकालिक काम के लिए प्रतिनिधियों और घटनाओं का उपयोग किया और मैं आपको कोड के साथ बोर नहीं करना चाहता, इसलिए मैं मुख्य बात लिखूंगा।

अतुल्यकालिक डेटा पुनर्प्राप्ति।

 int countErorr = 0; private void AsyncReceiver() { IPEndPoint ep = new IPEndPoint(IPAddress.Loopback, 0); while (true) { try { MemoryStream memoryStream = new MemoryStream(); byte[] bytes = udpClient.Receive(ref ep); memoryStream.Write(bytes, 2, bytes.Length - 2); int countMsg = bytes[0] - 1; if (countMsg > 10) throw new Exception("  "); for (int i = 0; i < countMsg; i++) { byte[] bt = udpClient.Receive(ref ep); memoryStream.Write(bt, 0, bt.Length); } GetData(memoryStream.ToArray()); memoryStream.Close(); } catch { countErorr++; } } } 

हम लूप को फिर से देखते हैं, फिर हमें पहला पैकेट मिलता है, उसमें से पहला बाइट पढ़ें (भविष्य के संदेशों की संख्या इस बाइट में लिखी गई है), यदि संदेश 10 से अधिक लंबा है, तो हम स्पष्ट रूप से पहला पैकेट खो देते हैं, इसलिए हम नुकसान काउंटर जोड़ते हैं, अन्यथा हमें सभी संदेश मिलते हैं - हम इसे एक में गोंद कर देते हैं और गेटडाटा इवेंट (बाइट []) बढ़ाएं।

GetData (बाइट []) में हम Texture2D प्राप्त करते हैं, इसे बाइट्स की एक सरणी से परिवर्तित करते हैं।

 private void Receive_GetData(byte[] Date) { BackGround = ConvertToTexture2D(Date); } private Texture2D ConvertToTexture2D(byte[] bytes) { MemoryStream memoryStream = new MemoryStream(bytes); System.Drawing.Bitmap bmp = (System.Drawing.Bitmap)System.Drawing.Bitmap.FromStream(memoryStream); //    .png,  Texture2D    memoryStream = new MemoryStream(); bmp.Save(memoryStream, System.Drawing.Imaging.ImageFormat.Png); //    Texture2D return Texture2D.FromStream(GraphicsDevice, memoryStream); } 

आप लेख के अंत में पूरी परियोजना को डाउनलोड कर सकते हैं, इसलिए यदि मैंने कुछ लिखा नहीं है तो निराशा न करें।

सारांश और निष्कर्ष

नतीजतन, जब "प्रेषक" और "प्राप्तकर्ता" एक साथ शुरू होते हैं, तो आपके कंप्यूटर पर पुनरावृत्ति और भारी मात्रा में नुकसान होते हैं (30 - 90 नुकसान), जब "प्रेषक" मेरे कंप्यूटर पर लॉन्च किया जाता है, और "प्राप्तकर्ता" के माता-पिता के कंप्यूटर पर, नुकसान न्यूनतम होते हैं (10 - 10) 15 नुकसान)। दोनों कंप्यूटर (माता-पिता और मेरा) 54 एमबीपीएस चैनल के साथ एक ही वाई-फाई नेटवर्क से जुड़े हैं। एक पिंग है (लगभग 250 एमएस।) - यह मुझे टीम व्यूअर पिंग की याद दिलाता है। यदि आप अनुकूलन जोड़ते हैं और बैसाखी को बदलते हैं, तो आपको छवियों को प्रसारित करने के लिए एक शानदार कार्यक्रम मिलता है।

प्रत्यावर्तन


माता-पिता का कंप्यूटर (मेरे कंप्यूटर से उनके लिए छवियों को स्थानांतरित करना)


नुकसान क्या दिखता है?


अगले लेख में, मैं कार्यक्रम को पूरा करूंगा, या बल्कि, इसे दूर से नियंत्रित करने की क्षमता जोड़ूंगा और संभवतः इसे अनुकूलित भी कर सकता हूं।

प्रोजेक्ट डाउनलोड करें
रिसीवर डाउनलोड करें
प्रेषक डाउनलोड करें (चित्र भेजें)

PS I ने github.com/Luchanso/remote-desktop github पर स्रोत कोड पुनः लोड किया