आपके एप्लिकेशन में डाउनलोडिंग गति की गणना

प्रागितिहास

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

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

और फिर एक उपयोगकर्ता एक तार्किक समस्या के साथ प्रकट होता है - एक बड़े समूह में यह स्पष्ट नहीं है कि प्रगति मुश्किल से क्यों रेंग रही है - क्या मुझे बहुत सारी फाइलें या कम गति डाउनलोड करने की आवश्यकता है? जैसा कि मैंने ऊपर उल्लेख किया है - फ़ाइलों की संख्या अग्रिम में ज्ञात नहीं है। इसलिए, मैंने एक गति काउंटर जोड़ने का फैसला किया।

के विश्लेषण

यह उन लोगों को देखने का अच्छा अभ्यास है जो पहले से ही इसी तरह की समस्या को हल कर चुके हैं ताकि पहिया को फिर से न लगाया जाए। अलग-अलग सॉफ़्टवेयर इन विभिन्न कार्यों को बंद कर देते हैं, लेकिन प्रदर्शन बहुत अधिक समान दिखता है:

uTorrent	DownloadMaster

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

तो, हमें एक सरल अंक चाहिए जैसे 10 MB/s या ऐसा कुछ। हम इसकी गणना कैसे करते हैं?

सिद्धांत और अभ्यास

मौजूदा डाउनलोड कार्यान्वयन ने HttpWebRequest उपयोग किया और मैंने स्वयं डाउनलोड को फिर से नहीं करने का निर्णय लिया - कार्य तंत्र को स्पर्श न करें।

इसलिए, बिना किसी गणना के प्रारंभिक कार्यान्वयन:

  var request = WebRequest.Create(uri); var response = await request.GetResponseAsync(); using (var ms = new MemoryStream()) { await response.GetResponseStream().CopyToAsync(ms); return ms.ToArray(); } 

इस तरह के एपीआई के स्तर पर, आप केवल एक फ़ाइल के पूर्ण डाउनलोड का जवाब दे सकते हैं, छोटे समूहों के लिए (या यहां तक ​​कि एक फ़ाइल के लिए) आप वास्तव में गति की गणना नहीं कर सकते। हम CopyToAsync स्रोत कोड का पालन करते हैं, वहां से सरल तर्क कॉपी-पेस्ट करते हैं:

  byte[] buffer = new byte[bufferSize]; int bytesRead; while ((bytesRead = await ReadAsync(buffer, 0, buffer.Length, cancellationToken).ConfigureAwait(false)) != 0) { await destination.WriteAsync(buffer, 0, bytesRead, cancellationToken).ConfigureAwait(false); } 

अब हम नेटवर्क पर हमें दिए गए हर बफर का जवाब दे सकते हैं।

इसलिए, सबसे पहले, हम BoxToAsync के बजाय क्या करते हैं:

  public static async Task<byte[]> GetBytesAsync(this Stream from) { using (var memory = new MemoryStream()) { byte[] buffer = new byte[81920]; int bytesRead; while ((bytesRead = await from.ReadAsync(buffer, 0, buffer.Length).ConfigureAwait(false)) != 0) { await memory.WriteAsync(buffer, 0, bytesRead).ConfigureAwait(false); NetworkSpeed.AddInfo(bytesRead); } return memory.ToArray(); } } 

केवल एक चीज वास्तव में जोड़ी गई है NetworkSpeed.AddInfo । और केवल एक चीज जिसे हम संचारित करते हैं वह है बाइट्स की संख्या डाउनलोड की गई।

डाउनलोड करने के लिए कोड इस तरह दिखता है:

  var request = WebRequest.Create(uri); var response = await request.GetResponseAsync(); var array = await response.GetResponseStream().GetBytesAsync(); 

  var client = new WebClient(); var lastRecorded = 0L; client.DownloadProgressChanged += (sender, eventArgs) => { NetworkSpeed.AddInfo(eventArgs.BytesReceived - lastRecorded); lastRecorded = eventArgs.BytesReceived; }; var array = await client.DownloadDataTaskAsync(uri); 

  var httpClient = new HttpClient(); var content = await httpClient.GetStreamAsync(uri); var array = await content.GetBytesAsync(); 

खैर, आधी समस्या हल हो गई है - हम जानते हैं कि हमने कितना डाउनलोड किया। हम गति की ओर मुड़ते हैं।

विकिपीडिया के अनुसार:

डेटा ट्रांसफर दर - समय की प्रति यूनिट प्रेषित डेटा की मात्रा।

पहला अनुभवहीन दृष्टिकोण

हमारे पास एक वॉल्यूम है। समय को स्टार्टअप से शाब्दिक रूप से लिया जा सकता है और DateTime.Now साथ अंतर पा सकते हैं। लो और शेयर करो?
कंसोल उपयोगिताओं जैसे कर्ल के लिए, यह संभव है और समझ में आता है।
लेकिन अगर आपका आवेदन थोड़ा अधिक जटिल है, तो शाब्दिक रूप से ठहराव बटन नाटकीय रूप से आपके जीवन को जटिल बना देगा।

ठहराव के बारे में थोड़ा
शायद मैं बहुत भोला हूँ, या शायद सवाल वास्तव में इतना सरल नहीं है - लेकिन ठहराव मुझे लगातार सोचने पर मजबूर करता है। डाउनलोड करते समय एक ठहराव कम से कम तीन तरीकों से व्यवहार कर सकता है:

• इंटरप्ट फाइल अपलोड, इसके बाद फिर से शुरू
• बस आगे फ़ाइल डाउनलोड न करें, आशा है कि सर्वर के बाद भी जारी रहेगा
• पहले से ही डाउनलोड की गई फ़ाइलें डाउनलोड करें, नए डाउनलोड न करें, नए डाउनलोड करें

चूंकि पहले से डाउनलोड की गई जानकारी के नुकसान के लिए पहले दो नेतृत्व, मैं तीसरे का उपयोग करता हूं।
थोड़ा अधिक, मैंने देखा कि गति को एक बिंदु पर ठीक समय पर ठीक करने की आवश्यकता है। तो, एक विराम इस मामले को जटिल करता है:

• आप ठीक से गणना नहीं कर सकते कि औसत गति क्या थी, बस थोड़ी देर के लिए वॉल्यूम ले रहा था
• एक ठहराव के बाहरी कारण हो सकते हैं जो गति और चैनल को बदल देंगे (प्रदाता के नेटवर्क को फिर से कनेक्ट करना, वीपीएन पर स्विच करना, पूरे चैनल को लेने वाले uTorrent को समाप्त करना), जिससे वास्तविक गति में बदलाव होगा
  वास्तव में, एक ठहराव किसी भी संकेतक को पहले और बाद में विभाजित करता है। यह विशेष रूप से नीचे दिए गए कोड को प्रभावित नहीं करता है, बस एक मिनट की मजेदार जानकारी के बारे में सोचने के लिए।

दूसरा भोला दृष्टिकोण

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

  public class NetworkSpeed { public static double TotalSpeed { get { return totalSpeed; } } private static double totalSpeed = 0; private const uint TimerInterval = 1000; private static Timer speedTimer = new Timer(state => { var now = 0L; while (ReceivedStorage.TryDequeue(out var added)) now += added; totalSpeed = now; }, null, 0, TimerInterval); private static readonly ConcurrentQueue<long> ReceivedStorage = new ConcurrentQueue<long>(); public static void Clear() { while (ReceivedStorage.TryDequeue(out _)) { } totalSpeed = 0; } public static void AddInfo(long received) { ReceivedStorage.Enqueue(received); } } 

पहले विकल्प की तुलना में, इस तरह के कार्यान्वयन से एक विराम का जवाब देना शुरू होता है - डेटा आने के बाद अगले सेकंड में गति 0 तक गिर जाती है।
लेकिन, इसके नुकसान भी हैं। हम 80kb के बफर के साथ काम कर रहे हैं, जिसका अर्थ है कि एक सेकंड में शुरू किया गया डाउनलोड केवल अगले में प्रदर्शित होगा। और समानांतर डाउनलोड की एक बड़ी धारा के साथ, ऐसी माप त्रुटियां कुछ भी प्रदर्शित करेंगी - मेरे पास वास्तविक संख्याओं के 30% तक का प्रसार था। मैंने देखा नहीं हो सकता है, लेकिन 100 से अधिक Mbit बहुत संदिग्ध लग रहे थे ।

तीसरा तरीका

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

कार्यान्वयन थोड़ा जटिल है, लेकिन सामान्य तौर पर, ऐसा कुछ नहीं है:

  public class NetworkSpeed { public static double TotalSpeed { get { return totalSpeed; } } private static double totalSpeed = 0; private const uint Seconds = 3; private const uint TimerInterval = 1000; private static Timer speedTimer = new Timer(state => { var now = 0L; while (ReceivedStorage.TryDequeue(out var added)) now += added; LastSpeeds.Enqueue(now); totalSpeed = LastSpeeds.Average(); OnUpdated(totalSpeed); }, null, 0, TimerInterval); private static readonly LimitedConcurrentQueue<double> LastSpeeds = new LimitedConcurrentQueue<double>(Seconds); private static readonly ConcurrentQueue<long> ReceivedStorage = new ConcurrentQueue<long>(); public static void Clear() { while (ReceivedStorage.TryDequeue(out _)) { } while (LastSpeeds.TryDequeue(out _)) { } totalSpeed = 0; } public static void AddInfo(long received) { ReceivedStorage.Enqueue(received); } public static event Action<double> Updated; private class LimitedConcurrentQueue<T> : ConcurrentQueue<T> { public uint Limit { get; } public new void Enqueue(T item) { while (Count >= Limit) TryDequeue(out _); base.Enqueue(item); } public LimitedConcurrentQueue(uint limit) { Limit = limit; } } private static void OnUpdated(double obj) { Updated?.Invoke(obj); } } 

कुछ बिंदु:

• कार्यान्वयन के समय, मुझे तत्वों की संख्या पर एक सीमा के साथ समाप्त कतार नहीं मिली और इसे इंटरनेट पर ले लिया, इसके ऊपर के कोड में LimitedConcurrentQueue ।
• किसी कारण से INotifyPropertyChanged को लागू करने के बजाय, Action , व्यावहारिक रूप से समान है, मुझे इसके कारण याद नहीं हैं। तर्क सरल है - संकेतक बदल रहा है, उपयोगकर्ताओं को इस बारे में सूचित करने की आवश्यकता है। कार्यान्वयन कोई भी हो सकता है, यहां तक ​​कि IObservable , जिनके लिए यह अधिक सुविधाजनक है।

और थोड़ी पठनीयता

एपीआई बाइट्स में गति देता है, पठनीयता के लिए एक सरल (इंटरनेट पर लिया गया) उपयोगी है

  public static string HumanizeByteSize(this long byteCount) { string[] suf = { "B", "KB", "MB", "GB", "TB", "PB", "EB" }; //Longs run out around EB if (byteCount == 0) return "0" + suf[0]; long bytes = Math.Abs(byteCount); int place = Convert.ToInt32(Math.Floor(Math.Log(bytes, 1024))); double num = Math.Round(bytes / Math.Pow(1024, place), 1); return Math.Sign(byteCount) * num + suf[place]; } public static string HumanizeByteSize(this double byteCount) { if (double.IsNaN(byteCount) || double.IsInfinity(byteCount) || byteCount == 0) return string.Empty; return HumanizeByteSize((long)byteCount); } 

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

यह अंततः कैसा दिखता है:

निष्कर्ष

यह गिनती की गति के एक प्रतीत होता है कि कार्य से निपटने के लिए दिलचस्प था। और भले ही कोड काम करता है और कुछ नंबर देता है, मैं आलोचकों को सुनना चाहता हूं - मैंने क्या याद किया, मैं कैसे बेहतर कर सकता था, शायद कुछ तैयार समाधान हैं।

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

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