एकल आवेदन या प्रदर्शन के लिए संघर्ष की कहानी

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

हम यूक्रेन में स्थित हैं, जहां विंडोज फोन के लिए इतने सारे स्थानीय अनुप्रयोग नहीं हैं, और राष्ट्रीय विषयों पर भी बहुत कम अनुप्रयोग हैं। एक संगीत प्रेमी होने के नाते, मैंने यूक्रेनी कलाकारों के गीत के साथ एक आवेदन करने का फैसला किया। अपने आश्चर्य के लिए, मैंने अपनी साइट पर पाया हमारे 18,000 से अधिक यूक्रेनी गीतों ने लगभग 800 कलाकारों द्वारा प्रदर्शन किया।

"बुरा नहीं है," मैंने सोचा, और एक साधारण पार्सर लिखने के लिए बैठ गया, जो सभी ग्रंथों को स्थानीय स्तर पर मेरे पास ले गया। कई वर्षों से मैं पार्सर्स और इसी तरह के अन्य अनुप्रयोगों को लिख रहा था, इसलिए इस प्रक्रिया में ज्यादा समय नहीं लगा। एचटीएमएल क्रॉलर और पार्सिंग लिखने के लिए मैंने डेटा एक्सट्रैक्टिंग एसडीके लाइब्रेरी का उपयोग किया था जो मैंने लिखा था और निस्संदेह, इन उद्देश्यों के लिए .NET दुनिया में सबसे अच्छा पुस्तकालय - एचटीएमएलजीबिलिटीपैक ।

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

यहाँ क्या हुआ है।

प्रमुख प्रदर्शन पहलू

आपको डेवलपर पर ध्यान देने की आवश्यकता है, ताकि एप्लिकेशन उच्च-प्रदर्शन हो:

आवेदन शुरू समय

आवेदन शुरू करने के लिए केवल कुछ सेकंड है। यदि प्रारंभ समय 8 सेकंड से अधिक है, तो एप्लिकेशन को मेमोरी से अनलोड किया जाएगा, और एप्लिकेशन के लेखक को बाजार में एक अतिरिक्त इकाई प्राप्त होने की संभावना होगी।

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

लेकिन एक नकारात्मक पहलू है - एप्लिकेशन लॉन्च करने के बाद संसाधनों तक पहुंच सामग्री को पढ़ने से कम समय लगता है। इसलिए, डेवलपर्स को इन मतभेदों पर विचार करने की आवश्यकता है।

आपको यह भी याद रखना होगा कि स्प्लैश स्क्रीन एनीमेशन का समर्थन नहीं करती है, क्योंकि यह एक नियमित jpeg फ़ाइल है।

डेटा लोडिंग समय

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

यदि डेटा कई सेकंड (स्थानीय भंडारण से या एक वेब सेवा के माध्यम से) डाउनलोड किया जाता है, तो वे अक्सर एक अतिरिक्त नकली पृष्ठ बनाते हैं जो स्प्लैश स्क्रीन का अनुकरण करता है, लेकिन एनीमेशन जोड़ता है (पाठ के साथ प्रगति बार "कृपया प्रतीक्षा करें ...")। डेटा डाउनलोड करने के बाद, उपयोगकर्ता उस पृष्ठ पर पुनर्निर्देशित होता है जहां डाउनलोड किया गया डेटा पहले से ही प्रदर्शित होता है, यह आश्वस्त होने के बाद कि Microsoft ने एनिमेटेड स्प्लैश स्क्रीन प्रदर्शित करने की क्षमता को जोड़ा है। यहाँ एक एनिमेटेड छप स्क्रीन बनाने के बारे में और पढ़ें।

यदि आप मुख्य स्ट्रीम में डेटा लोड कर रहे हैं, तो आमतौर पर यह इस तरह दिखता है:

public MainPage() { InitializeComponent(); DataContext = new SomeDataObject(); } 

तब उपयोगकर्ता संभवतः इंटरफ़ेस को फ्रीज कर देगा (यह पैनोरमा नियंत्रण के लिए विशेष रूप से सच है)।

आप इसे इस तरह से ठीक कर सकते हैं - तब तक प्रतीक्षा करें जब तक कि संपूर्ण UI और संसाधन पूरी तरह से लोड न हो जाएं और उसके बाद ही डेटा प्रदर्शित करें:

 public MainPage() { InitializeComponent(); this.Loaded += MainPage_Loaded; } void MainPage_Loaded(object sender, RoutedEventArgs e) { DataContext = new SomeDataObject(); } 

दूसरा विकल्प एक अलग धागे में सब कुछ लोड करने या बैकग्राउंडर बनाने का है:

 public MainPage() { InitializeComponent(); StartLoadingData(); } private void StartLoadingData() { this.Dispatcher.BeginInvoke(() => { var backroungWorker = new BackgroundWorker(); backroungWorker.DoWork += backroungWorker_DoWork; backroungWorker.RunWorkerCompleted += backroungWorker_RunWorkerCompleted; backroungWorker.RunWorkerAsync(); }); } void backroungWorker_DoWork(object sender, DoWorkEventArgs e) { // heavy operation } void backroungWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e) { this.Dispatcher.BeginInvoke(() => { // update layout with new data }); } 

हमने थोड़ा और कोड लिखा, लेकिन प्रदर्शन में सुधार किया।

खैर, भारी ऑपरेशन के दौरान प्रगति पट्टी दिखाने के लिए यह अच्छा अभ्यास है (आप Microsoft.Phone.Shell.ProgressIndicator, सिल्वरलाइट टूलकिट से एक घटक या विंडोज फोन के लिए टेलरिक रेडकंट्रोल से) का उपयोग कर सकते हैं।

स्क्रीन स्विचिंग गति

आमतौर पर पृष्ठों के बीच संक्रमण में अधिक समय नहीं लगता है, लेकिन आप सुंदर एनिमेशन जोड़कर भी इस प्रक्रिया में सुधार कर सकते हैं * (आप विंडोज फोन के लिए टेलरिक रेडकंट्रोल का भी उपयोग कर सकते हैं)।

यह "सिद्धांत का एक मिनट" था। निर्बाध रूप से मुख्य कार्य पर जाएं: डेटा लोड करना और प्रदर्शित करना।

डेटा लोड करना और प्रदर्शित करना

एक विंडोज कंसोल प्रोग्राम है जो डेटा तैयार करता है, और एक विंडोज फोन एप्लिकेशन इस डेटा को पढ़ता है।

सबसे आसान तरीका: डेटा क्रमबद्ध करना, अर्थात् XML में:

 private static void Serialize(object obj, string name) { var ser = new XmlSerializer(obj.GetType()); var sb = new StringBuilder(); var writer = new StringWriter(sb); ser.Serialize(writer, obj); File.WriteAllText(name + ".xml", sb.ToString().Replace("encoding=\"utf-16\"", null)); } private static void Deserialize(Type type) { //Assuming doc is an XML document containing a serialized object and objType is a System.Type set to the type of the object. XmlNodeReader reader = new XmlNodeReader(doc.DocumentElement); XmlSerializer ser = new XmlSerializer(objType); object obj = ser.Deserialize(reader); // Then you just need to cast obj into whatever type it is eg: var myObj = (typeof(obj))obj; } 

डेटा मॉडल इस तरह दिखता है:

 public class Artist { public Artist() { Songs = new List<Song>(); } public int Id { get; set; } public string Title { get; set; } public List<Song> Songs { get; set; } } public class Song { public int Id { get; set; } public string Title { get; set; } public string Description { get; set; } public int ArtistId { get; set; } } 

नतीजतन, हमें एक एक्सएमएल फाइल मिली, जिसमें 24 मेगाबाइट से अधिक का समय लगा।

मैंने JSON प्रारूप में अनुक्रमित करने की कोशिश की, साथ ही साथ गुणों के नामों को कम किया, जिससे आधे मेगाबाइट की बचत हुई, जिसे "सूक्ष्म" अनुकूलन कहा जा सकता है।

किसी अनुप्रयोग में 24 मेगाबाइट को खींचने के लिए सबसे अच्छा विचार नहीं है, इसलिए SQL CE डेटाबेस का उपयोग करने और उससे डेटा पढ़ने का निर्णय लिया गया।

Windows Phone एप्लिकेशन में एक कोड जोड़ा गया था जो XML फ़ाइल को पार्स करता है और सभी डेटा को स्थानीय डेटाबेस में लिखता है।

निष्कर्ष:

• जाँच करना और डेटा डालना बहुत धीमा था;
• कुछ ग्रंथों की लंबाई के कारण, मुझे DbType.NText प्रकार का उपयोग करना पड़ा;
• डेटाबेस का अंतिम आकार बहुत बड़ा था, और इसके बावजूद, आवेदन शुरू होने पर इसे स्थानीय भंडारण में फिर से लिखना आवश्यक था, जिसमें बहुत समय लगता था।

स्थानीय रूप से उत्पन्न डेटाबेस की प्रतिलिपि बनाने के लिए, पृथक संग्रहण एक्सप्लोरर उपकरण का उपयोग किया गया था:



आपके लिए काम करने के लिए पृथक भंडारण एक्सप्लोरर के लिए, आपको परियोजना में उपयुक्त पुस्तकालय जोड़ने और कोड लिखने की आवश्यकता है:



क्योंकि बेस के साथ वेरिएंट ने उड़ान भरी, अन्य अनुकूलन विकल्पों की तलाश शुरू की। यह स्पष्ट है कि जहां एक बड़ी पाठ फ़ाइल है, वहां आप इसे संग्रहकर्ता का उपयोग करके संपीड़ित कर सकते हैं। पोज़ कम्प्रेशन जिप फाइल आर्काइवर का वजन लगभग 5 मेगाबाइट से शुरू हुआ।

इस प्रकार, जब आप एप्लिकेशन शुरू करते हैं, तो आपको 1) फ़ाइल को स्थानीय भंडारण में कॉपी करना होगा 2) इसे 3 अनपैक करें) मेमोरी में फ़ाइल से डेटा लोड करें।

ज़िप संग्रह को प्रोजेक्ट में सामग्री के रूप में जोड़ा गया था, स्टार्टअप पर हम उपरोक्त सभी कार्यों को करते हैं। इसके लिए, तरीकों के विभिन्न संयोजनों का उपयोग किया गया था:

 private void CopyFromContentToStorage(IsolatedStorageFile store, string dbName) { var src = Application.GetResourceStream(new Uri(dbName, UriKind.Relative)).Stream; var dest = new IsolatedStorageFileStream(dbName, FileMode.OpenOrCreate, FileAccess.Write, store); src.Position = 0; CopyStream(src, dest); dest.Flush(); dest.Close(); src.Close(); dest.Dispose(); } private static void CopyStream(Stream input, IsolatedStorageFileStream output) { var buffer = new byte[32768]; long tempPos = input.Position; int readCount; do { readCount = input.Read(buffer, 0, buffer.Length); if (readCount > 0) { output.Write(buffer, 0, readCount); } } while (readCount > 0); input.Position = tempPos; } // load items from "fileName" file that exists in "zipName" file private static List<Artist> Load(string zipName, string fileName) { var info = Application.GetResourceStream(new Uri(zipName, UriKind.Relative)); var zipInfo = new StreamResourceInfo(info.Stream, null); var s = Application.GetResourceStream(zipInfo, new Uri(fileName, UriKind.Relative)); var serializer = new XmlSerializer(typeof (List<Artist>)); return serializer.Deserialize(s.Stream) as List<Artist>; } 

SharpZipLib पुस्तकालय भी इस्तेमाल किया गया था:

 using (ZipInputStream s = new ZipInputStream(src)) { s.Password = "123456";//if archive is encrypted ZipEntry theEntry; try { while ((theEntry = s.GetNextEntry()) != null) { string directoryName = Path.GetDirectoryName(theEntry.Name); string fileName = Path.GetFileName(theEntry.Name); // create directory if (directoryName.Length > 0) { Directory.CreateDirectory(directoryName); } if (fileName != String.Empty) { // save file to isolated storage using (BinaryWriter streamWriter = new BinaryWriter(new IsolatedStorageFileStream(theEntry.Name, FileMode.OpenOrCreate, FileAccess.Write, FileShare.Write, iso))) { int size = 2048; byte[] data = new byte[2048]; while (true) { size = s.Read(data, 0, data.Length); if (size > 0) { streamWriter.Write(data, 0, size); } else { break; } } } } } } catch (ZipException ze) { Debug.WriteLine(ze.Message); } 

मैंने कई विकल्प आज़माए हैं:

• मेटा-इनफ़ॉर्मेशन (कलाकारों की सूची और उनके गानों के लिंक) वाली फ़ाइल के साथ एक ज़िप फ़ाइल, जबकि गीत अलग-अलग फ़ाइलों में थे - प्रदर्शन में एक बड़ा शून्य, क्योंकि 18,000 फाइलें बहुत धीमी गति से पढ़ी और कॉपी की गईं;
• दो फाइलों के साथ ज़िप: कलाकारों की एक सूची के साथ, दूसरा गाने के साथ खराब है, क्योंकि कलाकार जल्दी से पढ़ते हैं, और गाने का उपयोग करते हुए - एक लंबे समय के लिए भी;
• केवल कलाकारों की सूची शुरू करते समय डाउनलोड विकल्प, और पृष्ठभूमि में, उपयोगकर्ता के लिए अदृश्य - गाने डाउनलोड करना - एक स्थिति पैदा हुई कि उपयोगकर्ता फ़ाइल को लोड करने में कामयाब होने से पहले गीत पर क्लिक करें।

यह चरण एक निष्कर्ष के साथ समाप्त हुआ: फ़ाइल एक होनी चाहिए और यह संग्रह में होना चाहिए, क्योंकि जिप फाइल को पढ़ना अपने आप में काफी तेज है।

आप फ़ाइल आकार को और कम नहीं कर सकते, आप पढ़े गए समय को कम कर सकते हैं और मेमोरी में लोड कर सकते हैं। और फिर मैंने कस्टम सीरियलाइजेशन का रास्ता अपनाया।

द्विआधारी क्रमांकन

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

माइक टैलबोट द्वारा सिल्वरलाइटसेरिज़ल को धारावाहिक के रूप में चुना गया था।

विंडोज कंसोल एप्लिकेशन में, सब कुछ काम करना चाहिए जैसा कि इसे (सीरियलाइज़ेशन / डीरिएरलाइज़ेशन) करना चाहिए, लेकिन विंडोज फोन प्रोजेक्ट में बनाई गई फ़ाइल को पढ़ने के साथ, mscorlib के विभिन्न संस्करणों से जुड़ी कठिनाइयां थीं।

परियोजना विवरण पृष्ठ में .NET और सिल्वरलाइट परियोजनाओं के बीच संगतता मुद्दों के बारे में एक पैराग्राफ है:

इन परिस्थितियों में करने के लिए महत्वपूर्ण बात यह है कि उन वर्गों को परिभाषित करना जो आप सिल्वरलाइट विधानसभा में साझा करना चाहते हैं जो केवल सिस्टम, सिस्टम.कोर और एमएसकोरलिब को संदर्भित करता है।

दुर्भाग्य से, इस समस्या को दूर करना संभव नहीं था।

तब मुझे प्रोटोबॉफ़-नेट प्रोजेक्ट मिला।

हम आवश्यक वर्गों और गुणों को चिह्नित करते हैं और आउटपुट पर बाइनरी फ़ाइल प्राप्त करते हैं:

 [ProtoContract] public class Person { [ProtoMember(1)] public int Id {get;set;} [ProtoMember(2)] public string Name {get;set:} [ProtoMember(3)] public Address Address {get;set;} } 

विंडोज फोन परियोजना से फाइल पढ़ने में कोई समस्या नहीं थी।

परिणाम क्या है?

परिणाम इस समाधान है:

1. जिप फाइल जिसमें कलाकार.बाइनरी बाइनरी निहित है, और जिप फाइल खुद कंटेंट के रूप में जुड़ी हुई है;

2. बैकग्राउंडवॉकर का उपयोग करके, यूआई को लोड करने के बाद, हम डेटा लोड करना शुरू करते हैं (हम ज़िप फ़ाइल से सीधे फ़ाइल को पढ़ते हैं और इसे स्थानीय डेटा मॉडल में दिखाते हैं):

 public List<Artist> LoadData() { var info = Application.GetResourceStream(new Uri("artists.zip", UriKind.Relative)); var zipInfo = new StreamResourceInfo(info.Stream, null); using (var file = Application.GetResourceStream(zipInfo, new Uri("artists.bin", UriKind.Relative)).Stream) { return Serializer.Deserialize<List<Artist>>(file); } } 

कुल: लूमिया 800: ~ 5-6 सेकंड पर एप्लिकेशन और पार्सिंग डेटा लॉन्च करना, जिसके बाद आप आसानी से किसी भी सामग्री को देख सकते हैं। परिणाम बेहतर हो सकता है और मैं उत्पादकता पर शोध करना और काम करना जारी रखूंगा, लेकिन यह परिणाम, मेरी राय में, बहुत बुरा नहीं है।

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

सामान्य तौर पर, सब कुछ सब कुछ के बारे में था:

• एक गीत पार्सर लिखने के लिए 1 घंटे;
• उत्पादकता में सुधार के लिए विभिन्न विकल्पों पर शोध करने के लिए 6 घंटे;
• लिखने के लिए 2 घंटे, वास्तव में, एक विंडोज फोन एप्लीकेशन;
• चिह्न बनाने और ग्राफिक फ़ाइलों को बनाने के लिए 1 घंटे;
• प्रमाणीकरण के लिए भेजने के लिए 0.25 घंटे;
• इस लेख को लिखने के लिए 1.5 घंटे।

केवल ~ 12 घंटे।



कार्य के परिणाम को यहां देखा और मूल्यांकन किया जा सकता है ।

आपका ध्यान के लिए धन्यवाद! मुझे उम्मीद है कि इस लेख के बाद विंडोज फोन स्टोर और हैबर थोड़ा बेहतर हो जाएगा!