कुशल सी # बाइनरी संदेश के लिए स्ट्रीम ऑफ़ बाइट्स पार्स करने के लिए बाइट कतार

Question

पैकेट मैं बदलने के लिए क्या मैं आमतौर पर के रूप में एक परिपत्र-बफर + लागू करेगा कोशिश कर रहा हूँ। कतार का कार्य इनकमिंग बाइट्स (जैसे सीरियल पोर्ट या डेटा की कुछ अन्य धाराओं) को बफर करना है, जबकि एक पार्सर कतार में बाइट्स की जांच करता है और संदेश पैकेट का पता लगाता है और निष्कर्ष निकालता है।

मानदंड:

• बढ़ सकता है (यानी तय आकार नहीं)

• = 1 बाइट एक समय में कतारबद्ध किया जा सकता है

• = 1 बाइट्स हो सकता है एक समय में dequeued

• कुशल

मैं सिर्फ

System.Collections.Generic.Queue<byte> 

का उपयोग करने के लिए परीक्षा रहा हूँ ... लेकिन मुझे यकीन है कि अगर यह सबसे कारगर प्रकार का उपयोग करने के लिए है नहीं कर रहा हूँ। कोई सुझाव?

वहाँ मैं क्या करने की कोशिश कर रहा हूँ कर के किसी भी होशियार तरीके हैं? (उदाहरण के लिए दिलचस्प सुझाव here)

आपके सुझावों के लिए धन्यवाद & इनपुट।

Prembo।

Answer 1

Queue<byte> एक byte[] के द्वारा समर्थित है, लेकिन आप बेहतर प्रदर्शन देखना होगा अगर करने के लिए/कॉपी करने के बजाय Array.Copy का उपयोग कर को कतारबद्ध/विपंक्ति तरीकों के माध्यम से पाशन अंतर्निहित बफर से। तो व्यक्तिगत रूप से, यदि Queue<byte> आपको वह प्रदर्शन नहीं देता है जो आप चाहते हैं, तो आप अपनी खुद की कतार कक्षा लागू कर सकते हैं जो QueueMultiple और DequeueMultiple विधियों को प्रदान करता है।

Answer 2

खैर, Queue<byte> स्मृति के मामले में कुशल हो जाएगा। यह दृश्यों के पीछे मूल रूप से byte[] होगा। यदि आप एक समय में पूरे हिस्सों को डेक्यू या एनक्यू करना चाहते हैं तो यह काम करने के लिए थोड़ा अजीब हो सकता है। प्रत्येक ऑपरेशन को एक बाइट के लिए ओ (1) को अमूर्त किया जाना चाहिए, जिसके कारण ओ (एन) आकार एन के एक हिस्से को एनक्यू्यू या डेक्यू करने के लिए प्रेरित किया जाता है ... लेकिन स्केलिंग कारक बफर ब्लॉक प्रति (कहें) से अधिक होगा।

Answer 3

कैसे भेजे बाइट्स प्राप्त कर रहे हैं और कैसे पार्सर उन्हें जांच करता है, तो आप एक Queue<byte[]> पर विचार हो सकता है पर निर्भर करता है।

Answer 4

मैं जानता हूँ कि मैं कर रहा हूँ नहीं सहायक हो, लेकिन आप अपना खुद का एक लिख सकते हैं।
सैद्धांतिक हिस्सा:
कतार पूंछ

 
0             n 
|----------------------------------------------------| 
       |      | 
       head      tail 

के लिए byte[] और 2 अनुक्रमित, सिर के लिए 1 और 1 में होना चाहिए हर बार जब आप k बाइट्स जोड़ने की जरूरत है आप पूंछ k इकाइयों छोड़ चले जाते हैं और में डाल नई जगह ने वहां डेटा बनाया।

 
0             n 
|-------------------------------new data-------------| 
       |    |  | 
       head   new tail old tail 

हर बार जब आप k बाइट्स पॉप की जरूरत है आप सिर k इकाइयों छोड़ दिया ले जाने और अंतरिक्ष खो से डेटा ले।

 
0             n 
|-------new data-------------------------------------| 
     |  |      | 
    new head head      tail 

मामले सिर और पूंछ में टकराते हैं, आप कंटेनर का आकार दोगुना और नया करने के लिए प्रत्येक आधा कॉपी करना होगा।

ध्यान रखें: यदि आप 1234 जोड़ने और फिर 2 पत्र पॉप आप मिल जाएगा 34

(मैं अगर मैं समुदाय विकी के रूप में इस पोस्ट चिन्हित करना चाहिए पता नहीं है)

Answer 5

यहाँ an efficient implementation की है एक बफर मैंने कुछ समय पहले लिखा था:

• Resizeable: डेटा को क़तार में और बफर अतिप्रवाह अपवाद नहीं फेंक अनुमति देता है;
• कुशल: विपंक्ति डेटा