IOS और Android के लिए C # async

Xamarin ने iOS और Android पर C # 5 Async / प्रतीक्षा का समर्थन जोड़ा है। .NET Async बेस क्लासेस के अलावा, Xamarin.iOS में 174 एसिंक्रोनस तरीके दिखाई दिए और Xamarin.Android में 337। Xamarin मोबाइल , जो एड्रेस बुक, कैमरा और जियोलोकेशन को क्रॉस-प्लेटफॉर्म एक्सेस प्रदान करता है, वह भी एसिंक्रोनस हो गया है। Async के पूर्ण समर्थन में घटक , उदाहरण के लिए, बादल बैकेंड पार्स ।

इस महत्वपूर्ण घटना के बारे में एक वेबिनार के कैट डिकोडिंग और अनुवाद के तहत।




प्रोग्रामर उत्तरदायी एप्लिकेशन बनाना चाहते हैं, इसलिए वे अतुल्यकालिक प्रोग्रामिंग का उपयोग करते हैं।

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

स्मार्टफोन पर लगभग कोई भी ऑपरेशन लंबा हो सकता है: फाइल सिस्टम के साथ काम करना, चित्र को स्केल करना, डेटाबेस को क्वेरी करना। और जब आप नेटवर्क पर कुछ डाउनलोड करते हैं, तो आप आमतौर पर यह अनुमान नहीं लगा सकते हैं कि इसमें कितना समय लगेगा। और 64 मिलीसेकंड से अधिक नहीं बाद में उपयोगकर्ता को जवाब देने के लिए, हम कॉलबैक के साथ आए। वे अब NodeJS के साथ बहुत लोकप्रिय हैं।

यदि आप बहुत सारे कॉलबैक का उपयोग करते हैं, तो कोड अपठनीय और संशोधित करना मुश्किल हो जाता है, इसे कॉलबैक हेल कहा जाता है।



समस्या यह है कि कोड के इस टुकड़े का निष्पादन आदेश स्पष्ट और समझने में मुश्किल नहीं है। हम फ़ंक्शन, लूप, फ़ंक्शन कॉल के बारे में नहीं सोच सकते हैं, हम कोड के छोटे ब्लॉकों के बारे में सोचना शुरू करते हैं जो कोड के अन्य छोटे ब्लॉकों को कॉल करते हैं।

इस तरह के कोड में नए कार्यों को जोड़ना एक बहुत ही मुश्किल काम है, मेरा सिर दर्द होता है जब मैं सिर्फ इस पद्धति को बदलने के बारे में सोचता हूं। और सबसे दिलचस्प यह है कि हम अभी तक त्रुटियों को संसाधित नहीं कर रहे हैं। मैं ऐसा नहीं करना चाहता, मैं हार मानता हूं।


एद्जर दीक्जस्त्र

स्थैतिक संरचनाओं को समझने के लिए हमारे मस्तिष्क को तेज किया जाता है, समय में विकसित होने वाली प्रक्रियाओं का प्रतिनिधित्व करने की हमारी क्षमता खराब रूप से विकसित होती है। इसलिए, हमें यह समझने के लिए प्रोग्राम कोड और उसके निष्पादन की प्रक्रिया के बीच के अंतर को कम करना चाहिए कि प्रोग्राम को उसके कोड द्वारा यथासंभव सरल कैसे निष्पादित किया जाएगा।

उसका मतलब था GOTO का उपयोग करना, हमने कॉलबैक का उपयोग करते समय उसी समस्या का सामना किया। लेकिन प्रगति अभी भी स्थिर नहीं है, हम नए मुहावरे, नई भाषाएं बनाते हैं, संकलक को हमारे लिए काम करना सिखाते हैं। और C # में async / wait नया मुहावरा है जो कॉलबैक को बदल सकता है।

async Task SnapAndPostAsync() { try { Busy = true; UpdateUIStatus ("Taking a picture"); var picker = new Xamarin.Media.MediaPicker (); var mFile = await picker.TakePhotoAsync (new Xamarin.Media.StoreCameraMediaOptions ()); var tagsCtrl = new GetTagsUIViewontroller (mFile.GetStream ()); // Call new iOS await API await PresentViewControllerAsync (tagsCtrl, true); UpdateUIStatus ("Submitting picture to server"); await PostPicToServiceAsync (mFile.GetStream (), tagsCtrl.Tags); UpdateUIStatus ("Success"); } catch (OperationCanceledException) { UpdateUIStatus ("Canceled"); } finally { Busy = false; } } 

यहाँ async / प्रतीक्षा का उपयोग करने का एक उदाहरण है। यह कोड सुसंगत और समझने योग्य लगता है, नई सुविधाओं को जोड़ना आसान है। और पूरा अंतर यह है कि मैंने फ़ंक्शन हेडर में async शब्द जोड़ा है, जो कि विधि को अतुल्यकालिक के रूप में चिह्नित करता है और फिर प्रतीक्षा का उपयोग करता है। ये कीवर्ड संकलक को बताते हैं: "कृपया डेवलपर के लिए काम करें, इस कोड को फिर से लिखें, इसे कई स्वतंत्र टुकड़ों में विभाजित करें।" वास्तव में, आउटपुट समान कॉलबैक, समान राज्य नियंत्रण, केवल स्वचालित रूप से बनाया जाएगा। और आप कोड को क्रमिक रूप से पढ़ सकते हैं, जैसा कि दिक्जस्ट्रा के नीचे है।

उदाहरण में, हमने टास्क <T> टाइप किया। यह पृष्ठभूमि में होने वाले संचालन को प्रबंधित करने में हमारी मदद करता है। टास्क कार्य की स्थिति को अंजाम देता है (प्रक्रिया में, पूर्ण, रद्द), निष्पादन के दौरान होने वाले परिणाम और अपवाद। कार्य दो प्रकार के होते हैं: मान वापस नहीं करना और प्रकार T का मान वापस करना।



ऐसे कई दिलचस्प काम हैं जो आप टास्क के साथ कर सकते हैं। यदि आपके पास कई कार्य हैं, तो आप उनमें से किसी एक या सभी को पूरा करने के लिए इंतजार कर सकते हैं। या श्रृंखला और क्रमिक रूप से निष्पादित।

आप अन्य कार्य से मिलकर एक कार्य बना सकते हैं। उदाहरण के लिए, आप विभिन्न सर्वर दर्पणों से डेटा प्राप्त करने के लिए तीन कार्य चला सकते हैं और उन्हें एक कार्य में लपेट सकते हैं, जो तीनों में से किसी एक के पूरा होते ही पूरा हो जाएगा और उसका परिणाम लौटाएगा।

आइए एक और उदाहरण देखें। मैं वास्तव में उसकी निरंतरता के लिए उसे पसंद करता हूं। यह विधि फ़ाइल को डाउनलोड करती है, यदि यह पहले से ही डिस्क पर है, तो हम उपयोगकर्ता से फ़ाइल को अधिलेखित करने के लिए कहते हैं या नहीं, अगर वह कहता है "हाँ" - फ़ाइल को अधिलेखित करें, अन्यथा हम काम करना बंद कर देते हैं।

 async Task DownloadFile (Uri uri, string target) { if (File.Exists (target)){ switch (await ShowAlert ("File Exists", "Do you want to overwrite the file?", "yes", "no")){ case 0: break; case 1: return; } } var stream = await Http.Get (uri); await stream.SaveTo(target); } 

जैसा कि आप आईओएस और एंड्रॉइड में याद करते हैं, एक कॉलबैक में एक सिस्टम मैसेज का नतीजा हमारे सामने आता है, यानी कि एसिंक्स के बिना, हमें एक मैसेज बनाना था, उसे कॉन्फ़िगर करना था, कॉलबैक असाइन करना था। Async के मामले में, कंपाइलर हमारे लिए यह सब करता है। और वह अद्भुत है।

आइए देखें कि ज़ामरीन के अंदर शोएर्ट को कैसे लागू किया जाता है।

 public static Task<int> ShowAlert(string title, string message, params string [] buttons) { var tcs = new TaskCompletionSource<int> (); var alert = new UIAlertView { Title = title, Message = message }; foreach (var button in buttons) alert.AddButton (button); alert.Clicked += (s, e) => tcs.TrySetResult (e.ButtonIndex); alert.Show (); return tcs.Task; } 

अंत से तीसरी पंक्ति पर ध्यान दें, यह वह स्थान है जहां जादू होता है। इसलिए हम परिणाम को अतुल्यकालिक विधियों में वापस करते हैं। बेशक, एक सिस्टम संदेश प्रदर्शित करना एक बहुत ही सरल कार्य है, लेकिन मुझे लगता है कि यह आपको अपना खुद का लिखने की प्रेरणा देगा।

जैसा कि मैंने उल्लेख किया है, Xamarin मोबाइल प्लेटफॉर्म के लिए Async .NET5 आधार वर्गों और विशेष विधियों का समर्थन करता है। सटीक होने के लिए, Xamarin.iOS 174 एसिंक्रोनस तरीके प्रदान करता है, और Xamarin.Android - 337. इसके अलावा, Xamarin मोबाइल एसिंक्रोनस बन गया है, जो एड्रेस बुक, कैमरा और जियोलोकेशन को क्रॉस-प्लेटफॉर्म एक्सेस प्रदान करता है। कई घटक अतुल्यकालिक भी हो जाते हैं, जैसे कि क्लाउड बैकेंड पार्स ।

अगर एपीआई विधि कॉल में 50 मिलीसेकंड से अधिक समय लग सकता है, तो हम इसका अतुल्यकालिक संस्करण बनाते हैं। संदर्भ के आधार पर, आप विधि के एक तुल्यकालिक या अतुल्यकालिक संस्करण का उपयोग कर सकते हैं।

Async / इंतजार का समर्थन बिल्कुल वैसी ही स्थिति है जब Xamarin iOS और Android प्लेटफार्मों के साथ काम करना बहुत सरल करता है और केवल एक आवरण के रूप में बंद हो जाता है।

(लगभग लेन क्रेग डन का हिस्सा शुरू होता है, ऐसा लगता है कि वह टास्क-आधारित एसिंक्रोनस पैटर्न को पुनः प्राप्त कर रहा है )

आइए बड़े उदाहरण देखें। Github पर सभी कोड उपलब्ध हैं ।

नेस्टेड कॉलबैक, कई स्थानों पर त्रुटि से निपटने, यूआई स्ट्रीम पर स्विच करने पर ध्यान दें जब हमें उपयोगकर्ता इंटरफ़ेस को अपडेट करने की आवश्यकता होती है। Pfft। कोड को पढ़ना मुश्किल है और, विशेष रूप से, संशोधन।

 public void DownloadHomepage() { var webClient = new WebClient(); webClient.DownloadStringCompleted += (sender, e) => { if(e.Cancelled || e.Error != null) { // do something with error } string contents = e.Result; int length = contents.Length; InvokeOnMainThread (() => { ResultTextView.Text += "Downloaded the html and found out the length.\n\n"; }); webClient.DownloadDataCompleted += (sender1, e1) => { if(e1.Cancelled || e1.Error != null) { // do something with error } SaveBytesToFile(e1.Result, "team.jpg"); InvokeOnMainThread (() => { ResultTextView.Text += "Downloaded the image.\n"; DownloadedImageView.Image = UIImage.FromFile (localPath); }); ALAssetsLibrary library = new ALAssetsLibrary(); var dict = new NSDictionary(); library.WriteImageToSavedPhotosAlbum (DownloadedImageView.Image.CGImage, dict, (s2,e2) => { InvokeOnMainThread (() => { ResultTextView.Text += "Saved to album assetUrl\n"; }); if (downloaded != null) downloaded(length); }); }; webClient.DownloadDataAsync(new Uri("http://xamarin.com/images/about/team.jpg")); }; webClient.DownloadStringAsync(new Uri("http://xamarin.com/")); } 

समान चीज़ों का उपयोग करते हुए async / प्रतीक्षा करें:

 public async Task<int> DownloadHomepageAsync() { try { var httpClient = new HttpClient(); Task<string> contentsTask = httpClient.GetStringAsync("http://xamarin.com"); string contents = await contentsTask; int length = contents.Length; ResultTextView.Text += "Downloaded the html and found out the length.\n\n"; byte[] imageBytes = await httpClient.GetByteArrayAsync("http://xamarin.com/images/about/team.jpg"); SaveBytesToFile(imageBytes, "team.jpg"); ResultTextView.Text += "Downloaded the image.\n"; DownloadedImageView.Image = UIImage.FromFile (localPath); ALAssetsLibrary library = new ALAssetsLibrary(); var dict = new NSDictionary(); var assetUrl = await library.WriteImageToSavedPhotosAlbumAsync (DownloadedImageView.Image.CGImage, dict); ResultTextView.Text += "Saved to album assetUrl = " + assetUrl + "\n"; ResultTextView.Text += "\n\n\n" + contents; // just dump the entire HTML return length; } catch { // do something with error return -1; } } 

क्या आपने तुलना की है? नया कोड रैखिक है, पढ़ने में आसान है, त्रुटि से निपटने को एक स्थान पर एकत्र किया जाता है।

आप Xamarin में उपलब्ध एक नए एपीआई ऑब्जेक्ट HttpClient को भी देख सकते हैं। कोड में, हम xamarin.com होम पेज के html को डाउनलोड करने की कोशिश कर रहे हैं। GetStringAsync को कॉल करने के बाद, एक समानांतर धागा तुरंत शुरू होता है, जो साइट से HTML डाउनलोड करता है। और यह हमारे पास लौटता है टास्क, इस ऑपरेशन का एक लिंक। जब हम इंतजार करते हैं, तो हम कहते हैं कि हम इस ऑपरेशन के परिणाम के बिना जारी नहीं रख सकते हैं, नियंत्रण को मुख्य प्रक्रिया में स्थानांतरित कर दिया गया है। जब लाइन प्राप्त होती है, तो प्रतीक्षा के बाद अगली पंक्ति में हमारी विधि पर नियंत्रण वापस करें, हम इसकी लंबाई की गणना करते हैं और उपयोगकर्ता इंटरफ़ेस को अपडेट करते हैं।

जब हम httpClient.GetByteArrayAsync को कॉल करते हैं, तो हम एक मध्यवर्ती टास्क नहीं बनाते हैं, लेकिन तुरंत अनुरोध के परिणाम की प्रतीक्षा करते हैं। छवि को डाउनलोड करना एक अन्य पृष्ठभूमि प्रक्रिया में होगा और जब यह नियंत्रण समाप्त हो जाएगा तो हमारी विधि पर वापस आ जाएगी, हम छवि को बचाएंगे और उपयोगकर्ता इंटरफ़ेस को अपडेट करेंगे।

कोड सुसंगत और समझने योग्य है।

मैंने कोई भी त्रुटि से निपटने नहीं किया, लेकिन यह मुश्किल नहीं है। इससे कोई फर्क नहीं पड़ता कि विधि कोड में या HttpClient बैकग्राउंड थ्रेड में कोई त्रुटि होती है, हम इसे कैच ब्लॉक में प्राप्त करते हैं। संकलक हमारे लिए यह काम करता है।

मैंने रंगों के साथ कोड में विभिन्न कार्यों को चिह्नित किया है, आइए पुराने और नए संस्करणों की तुलना करें:


ध्यान दें कि पुराना कोड कितना असंगत है, त्रुटि और मुख्य धागे तक पहुंच कैसे पूरे कोड में फैली हुई है। पठनीयता और कोड समर्थन के मामले में async / प्रतीक्षित संस्करण बहुत बेहतर है।

Async / प्रतीक्षा में जा रहा है

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


Async विधियाँ शून्य, कार्य या कार्य <T> लौटा सकती हैं। शून्य केवल घटना संचालकों के लिए लागू है। यदि आपकी विधि वापस आती है, तो कार्य <T> का उपयोग करें, अन्यथा, बस कार्य। यदि आप टास्क <टी> का उपयोग करते हैं, तो एक नियमित विधि से मान लौटाएं, कंपाइलर बाकी काम करेगा।

Await का उपयोग केवल async चिह्नित विधियों पर किया जा सकता है। आवा को कैच और अंत में ब्लॉक में इस्तेमाल नहीं किया जा सकता है।

हैंडलिंग में त्रुटि

यदि आपको किसी कार्य के लिए प्रतीक्षा करने के लिए कहा जाता है, तो अंदर होने वाले किसी भी अपवाद को कार्य की प्रतीक्षा करने वाली विधि में फेंक दिया जाएगा।

नोट: शून्य पर लौटने वाले अतुल्यकालिक तरीके अपवादों को पुनर्निर्देशित करने के लिए कहीं नहीं हैं, वे वर्तमान थ्रेड में दिखाई देंगे और एप्लिकेशन क्रैश हो जाएंगे।

 try { //   t    await t; ResultTextView.Text += "** Downloaded " + t.Result.Length + " bytes\n"; } catch(OperationCancelledException) {// t  } catch(Exception exc) { //      t ResultTextView.Text += "--Download Error: " + exc.Messsage + "\n"; } 

कार्य रद्द करें

एक सक्रिय कार्य को रद्द किया जा सकता है, यह विशेष रूप से लंबे कार्यों जैसे कि नेटवर्क के साथ काम करने के लिए महत्वपूर्ण है। आप कोड से कार्य को रद्द करने का निर्णय ले सकते हैं या उपयोगकर्ता को बहुत लंबे ऑपरेशन को रद्द करने का विकल्प प्रदान कर सकते हैं।

रद्दीकरण टोकन पैरामीटर को अतुल्यकालिक विधि से पारित करके रद्द किया जाता है। आप बनाए गए टोकन को अन्य कार्यों में स्थानांतरित कर सकते हैं, इसलिए आप कार्य समूहों को रद्द कर सकते हैं।

 var cts = new CancellationTokenSource(); var intResult = await DownloadHomepageAsync(cts.Token); //        cts.Cancel(); 

प्रगति प्रदर्शन

कार्य संचालन की प्रगति के बारे में प्रतीक्षा पद्धति को सूचित कर सकता है, उदाहरण के लिए, डाउनलोड किए गए बाइट्स की वर्तमान संख्या को संचारित करें।
ऐसा करने के लिए, आपको IProgress प्राप्त करने वाले संस्करण के साथ एसिंक्रोनस विधि को ओवरलोड करने की आवश्यकता है।

 public class Progress<T> : IProgress<T> { public Progress; public Progress(Action<T> handler); protected virtual void OnReport(T value); public event EventHandler<T> ProgressChanged; //      } 

कार्य संयोजन

Task.WhenAny और Task.WhenAll के तरीकों का उपयोग करके कई कार्यों को एक में जोड़ा जा सकता है। उदाहरण के लिए, आप फ़ाइलों को एक में डाउनलोड करने के कार्यों को जोड़कर कई फ़ाइलों को डाउनलोड करते हैं, आप तब तक इंतजार कर सकते हैं जब तक कि पहली फ़ाइल डाउनलोड होने के बाद उन सभी को डाउनलोड या जारी न रखा जाए।

 while(tasks.Count > 0) { // ,         //t —    var t = await Task.WhenAny(tasks); tasks.Remove(t); try { await t; //   t   ResultTextView.Text += "++ Downloaded " + t.Result.length + " bytes\n"; } catch(OperationCancelledException) {} catch(Exception exc) { //     t ResultTextView.text += "-- Download Error: " + exc.Message + "\n"; } } 

इस उदाहरण में, हम साइट से तीन तस्वीरें डाउनलोड करते हैं, उनमें से एक के लिंक के कारण 403 त्रुटि होगी। इसलिए, सभी कार्यों को कार्य सूची में जोड़ें और सूची खाली होने तक उन्हें लूप में संसाधित करें। हम Task.WhenAny के माध्यम से एक समग्र कार्य बनाते हैं और इसे पूरा करने की उम्मीद करते हैं, यह तब पूरा हो जाएगा जब कोई भी नेस्टेड कार्य पूरा हो जाए और इसे हमें t में वापस कर दें। पूर्ण कार्य को सूची से हटा दें और कार्य का परिणाम प्राप्त करने के लिए प्रतीक्षा टी को निष्पादित करें। T के निष्पादन के दौरान होने वाले अपवाद कॉल करने के बाद पॉप अप हो जाएंगे। कार्यों का संयोजन उसी प्रकार के संचालन के लिए एक शक्तिशाली उपकरण है, इस पर एक नज़र डालें।

Microsoft दस्तावेज़ में C # async के बारे में और पढ़ें , Xamarin वेबसाइट पर iOS और Android API के लिए समर्थन। वेबिनार के लिए भंडार में अनुप्रयोगों के उदाहरण।

---

हमारे हब्र-ब्लॉग (ऊपरी दाएं बटन) की सदस्यता लें। हर गुरुवार, मोबाइल विकास, विपणन और मोबाइल स्टूडियो व्यवसाय के बारे में उपयोगी लेख। निम्नलिखित लेख (12 सितंबर) "मोबाइल स्टूडियो में बिक्री कैसे आयोजित की जाती है": प्रक्रियाओं, रिपोर्ट, एक मेगाप्लान, एक स्व-लिखित सीआरएम और इसके व्यावसायिक विकास के तरीके के बारे में हमारे विक्रेता का बयान।