कैसे एसक्यूएल सर्वर से एमपी 3 बाइट्स की मात्रा, (WCF द्वारा) सी # का उपयोग कर डेस्कटॉप क्लाइंट के लिए स्थानांतरित कर खेलने के लिए?

Question

मैं एक sql डेटाबेस अर्थात पर ऑडियो के "chunks" है (mp3 प्रारूप में), आप एक mp3 फ़ाइल कल्पना, मात्रा के बराबर आकार के लिए विभाजित है और प्रत्येक टुकड़ा एक sql सर्वर डाटाबेस पर एक रिकॉर्ड पर सहेजा गया है सकते हैं। इन chunks एक WCF सेवा के माध्यम से डेस्कटॉप क्लाइंट (रों) के लिए वापस आ रहे हैं। निश्चित रूप से ग्राहक जब यह एक प्राप्त करता है अगले हिस्सा के लिए पूछता है। (वे क्रम में प्राप्त किया जाएगा, ताकि हेडर पहले आता है!) यहाँ सवाल, कैसे मैं इस में मेरे डेस्कटॉप अनुप्रयोग में chunks प्राप्त एक करके निभा सकते है सिलसिलेवार? क्या मैं खिलाड़ी को बफर करने के लिए प्रत्येक खंड का उपयोग करके उन्हें वापस वापस चला सकता हूं?

कृपया ध्यान दें: -इस डेस्कटॉप क्लाइंट -इस खिलाड़ी wmp हो सकता है अगर यह इस उद्देश्य के लिए काम करता है सी # में है! -chunks बाइट्स कुछ कारणों -किसी "एसक्यूएल पर हिस्सा" सिस्टम पहले से ही किसी के द्वारा कार्यान्वित किया जाता है सिर्फ एक रास्ता डेस्कटॉप पर एक धारा की तरह उन्हें खेलने के लिए

धन्यवाद खोजने की जरूरत है else..i में सहेजे जाते हैं!

Answer 1

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

1. उपयोगकर्ता एमपी 3 का अनुरोध करता है
2. कार्य करें: के लिए
3. जांच और ग्राहक के लिए भेज उपलब्ध मात्रा
4. अगर वहाँ खेलने के लिए हिस्सा हैं, उन्हें (उन्हें स्ट्रीम में) में खेलने परिभाषित क्रम
5. जबकि: पाद लेख उन मात्रा में सामना करना पड़ा नहीं किया गया है // अंत

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

Answer 2

अपने एमपी 3 प्लेयर मानते हुए, एक System.IO.Stream वस्तु से खेल सकते हैं निम्नलिखित

private byte[] GetDataBlock() 
    { 
     while (data.Count == 0) 
     { 
      //TODO: Read More Data from the database 
      index = 0; 
     } 
     return data.Peek(); 
    } 
    private void RemoveDataBlock() 
    { 
     data.Dequeue(); 
     index = 0; 
    } 

    Queue<byte[]> data = new Queue<byte[]>(); 
    int index = 0; 
    public override int Read(byte[] buffer, int offset, int count) 
    {    
     int left = count; 
     int dstIndex = 0; 

     while (left > 0) 
     { 
      byte[] front = GetDataBlock(); 

      int available = front.Length - index; 
      // how much from the current block can we copy? 
      int length = (available <= left) ? available : left; 
      Array.Copy(front, index, buffer, dstIndex, length); 
      dstIndex += length; 
      left -= length; 
      index += length; 
      // read all the bytes in the array? 
      if (length == available) 
      { 
       RemoveDataBlock(); 
      } 
     } 

     return count; 
    } 

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

यह कोड केवल एक समय में 1 खंड पढ़ेगा, लेकिन एक अलग धागे को पढ़ने और कई हिस्सों को बफर करने के लिए विस्तारित किया जा सकता है।