🐱 🖤 🚦 Bencode से XML में अनुवाद करना 🙋🏾 ⏩ 👩🏻‍✈️

नमस्कार, हेब्र!
इस पोस्ट में मैं एक एप्लिकेशन बनाने की कोशिश करने का सुझाव देना चाहता हूं जो आपको एक फ़ाइल को एक बाइनरीकोड में एक XML फ़ाइल में बदलने की अनुमति देता है। चलो C # ले लो।
(हां, हम एक साइकिल बनाने की कोशिश करेंगे। यह आवश्यक क्यों है? यदि आप विशिष्ट समस्याओं को हल करने में सक्षम नहीं हैं, तो गैर-मानक लोग काम नहीं करेंगे)

Bencode। जैसा वह है

So. आइए नजर डालते हैं कि बेनकोड प्रारूप का क्या अर्थ है:
इसमें 4 डेटा प्रकार शामिल हैं (समर्थन करता है)

बाइट स्ट्रिंग
पूर्णांक
सूची
शब्दकोश

सीमांकक के रूप में, Bencode ASCII वर्णों और संख्याओं को स्वीकार करता है।
यह डेटा कैसे समाहित है?
मेरी राय में, सरल और जटिल डेटा प्रकारों को प्रतिष्ठित किया जा सकता है।
सरल प्रकार:
1) स्ट्रिंग बाइट्स - इससे पहले कि स्ट्रिंग में इसकी लंबाई (संख्या) हो, फिर कोलन साइन (":") और, वास्तव में, स्ट्रिंग। उदाहरण के लिए: 5: हैलो या 12: हैलो, हबल!
2) एक पूर्णांक - के रूप में लिखा है: प्रतीक "मैं" (पूर्णांक), संख्या, प्रतीक "ई" (अंत)। उदाहरण के लिए: i9e या i199e। इसके अलावा, यह प्रकार नकारात्मक संख्याओं का "समर्थन" करता है। आइए i-9e (-9) के उदाहरण पर एक नज़र डालें

जटिल डेटा प्रकार (सरल और जटिल प्रकार से मिलकर):
1) सूची - (उर्फ एक सरणी) - इसमें अन्य बेनकोड प्रकार होते हैं जो क्रमिक रूप से लिखे जाते हैं। रिकॉर्डिंग विधि प्रतीक "एल" (सूची), डेटा प्रकारों का विवरण, प्रतीक "ई" है। उदाहरण: l1: I3: You2: Wee ["I", "You", "We"]
2) शब्दकोश - (साहचर्य सरणी) - कुंजी-मूल्य डेटा शामिल हैं। और एक कुंजी के रूप में, हमेशा बाइट्स का एक स्ट्रिंग होता है, और डेटा को "कुंजी" फ़ील्ड द्वारा लेक्सोग्राफ़िक क्रम में सॉर्ट किया जाता है। शब्दकोश को इस प्रकार परिभाषित किया गया है - प्रतीक "डी" (शब्दकोश), कुंजी-मूल्य तत्व, प्रतीक "ई"। उदाहरण के लिए d5: Alpha4: Beta10: filesCounti9ee ["अल्फा" - "बीटा", "filesCount" - 9]

BEncode का उपयोग कहां किया जाता है?

बेनकोड का उपयोग हमारी सभी पसंदीदा .torrent फाइलों में किया जाता है। ये फाइलें एक सहयोगी सरणी (शब्दकोश) का प्रतिनिधित्व करती हैं।
हम उपकरण .torrent फ़ाइलों पर नहीं रुकेंगे।

हम डेटा संरचनाओं को व्यवस्थित करते हैं

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

फाइल एनकोडिंग पढ़ें

BItem वर्ग में है

पंक्ति
संख्या
किसी आइटम की सदस्यता का ध्वज
स्ट्रिंग और संख्या के लिए निर्माता
स्ट्रिंग अनुवाद विधि (ओवरलोडिंग ToString ())

/// <summary> /// integer value /// start - 'i' /// end - 'e' /// Example - i145e => 145 /// string value /// start - length /// end - /// Example 5:hello => "hello" /// </summary> public class BItem { protected string strValue = ""; protected int intValue = 0; protected bool IsInt = true; public bool isInt { get { return IsInt; } } public BItem(string A) { strValue = A; IsInt = false; } public BItem(int A) { IsInt = true; intValue = A; } public string ToString() { if (IsInt) return intValue.ToString(); return strValue; } }

BList वर्ग में है

तत्वों की प्रत्यक्ष सूची (BElement)
अनुक्रमण
संपत्ति की गणना करें
आइटम जोड़ने के लिए विधि (जोड़ें)

  /// <summary> /// List /// start - 'l' /// end - 'e' /// Example - l5:helloi145e => ("hello",145) /// </summary> public class BList { List<BElement> Items = null; public BList() { Items = new List<BElement>(); } public BElement this[int index] { get { if (Items.Count > index) { return Items[index]; } return new BElement(); } set { if (Items.Count > index) { Items[index] = value; } else { throw new Exception("   .   !"); } } } public int Count { get { return Items.Count; } } /// <summary> ///     /// </summary> public void Add(BElement inf) { Items.Add(inf); } }

BDEDIA वर्ग में शामिल है

तत्वों के साथ दो सूचियाँ (एक कुंजी-मूल्य संरचना के आयोजन के लिए)
संपत्ति की गणना करें
अनुक्रमण
आइटम जोड़ने के लिए विधि (जोड़ें)

  /// <summary> /// Dictionary /// start - 'd' /// end - 'e' /// Example - d2:hi7:goodbyee => ("hi" => "goodbye") /// </summary> public class BDictionary { protected List<BElement> FirstItem = null; protected List<BElement> SecondItem = null; public BDictionary() { FirstItem = new List<BElement>(); SecondItem = new List<BElement>(); } public int Count{ get { return FirstItem.Count; } } /// <summary> ///  /// </summary> /// <param name="index"></param> /// <returns></returns> public BElement[] this[int index] { get{ if (FirstItem.Count > index) { BElement[] Items = new BElement[2]; Items[0] = FirstItem[index]; Items[1] = SecondItem[index]; return Items; } return new BElement[2]; } set{ if (FirstItem.Count > index) { FirstItem[index] = value[0]; SecondItem[index] = value[1]; } else { //FirstItem.Add(value[0]); // SecondItem.Add(value[1]); -    , ..    !!!!!     throw new Exception("   .   "); } } } /// <summary> ///    /// </summary> /// <param name="First"></param> /// <param name="Second"></param> public void Add(BElement First, BElement Second) { FirstItem.Add(First); SecondItem.Add(Second); } }

अब हम "सार्वभौमिक" वर्ग बीईलमेंट पास करते हैं।
बीइलमेंट वर्ग में शामिल हैं

BItem प्रकार चर - string \ number कार्यान्वयन
BList प्रकार चर - सूची कार्यान्वयन
एक प्रकार का BDEDIA का एक चर - एक शब्दकोश का कार्यान्वयन
सरल डेटा प्रकार पढ़ने के लिए विधि
सूची पढ़ने की विधि
शब्दकोश पढ़ने की विधि
डेटा प्रकार परिभाषा (विधि)

  /// <summary> /// ""  /// </summary> public class BElement { public BItem STDItem = null; public BList LSTItem = null; public BDictionary DICItem = null; /// <summary> ///       string\integer /// </summary> /// <param name="Reader"> </param> /// <param name="CurrentCode">  </param> public void AddToBItem(StreamReader Reader, char CurrentCode) { char C; if (CurrentCode == 'i') {//  string Value= ""; C = (char)Reader.Read(); while (C != 'e') {// Value += C; C = (char)Reader.Read(); } try { int Res = Int32.Parse(Value); STDItem = new BItem(Res); } catch (Exception ex) { //   throw .     null' STDItem = null; } return; } int length = (int)CurrentCode - (int)'0'; C = (char)Reader.Read(); while (C != ':' && (C>='0' && C<='9')) { length = length * 10 + (int)C - (int)'0'; C = (char)Reader.Read(); } if (C!= ':') {//   (   ,   ,  throw new Exception("  "); //     throw     ...      =) STDItem = null; return; } string value = ""; for (int CurrentCount = 0; CurrentCount < length; CurrentCount++) { value += (char)Reader.Read(); } STDItem = new BItem(value); } /// <summary> /// . ,  l   /// </summary> /// <param name="Reader"> </param> public void AddToBList(StreamReader Reader) { LSTItem = new BList(); BElement Temp = GetNewBElement(Reader); while (Temp != null) { LSTItem.Add(Temp); Temp = GetNewBElement(Reader); } if (LSTItem.Count == 0) LSTItem = null;//  -        . } /// <summary> ///   /// </summary> /// <param name="Reader">  </param> public void AddToBDic(StreamReader Reader) { DICItem = new BDictionary(); BElement FirstTemp = GetNewBElement(Reader); BElement SecondTemp = GetNewBElement(Reader); while (FirstTemp != null || SecondTemp != null) { DICItem.Add(FirstTemp, SecondTemp); FirstTemp = GetNewBElement(Reader); SecondTemp = GetNewBElement(Reader); } if (DICItem.Count == 0) DICItem = null;//       } /// <summary> ///    .   /// </summary> /// <param name="Reader"> </param> /// <returns> </returns> public static BElement GetNewBElement(StreamReader Reader) { char C = (char)Reader.Read(); switch (C) { case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': case 'i': {//   BElement STDElement = new BElement(); STDElement.AddToBItem(Reader, C); return STDElement; } case 'l': {// BElement LSTElement = new BElement(); LSTElement.AddToBList(Reader); return LSTElement; } case 'd': {// BElement DICElement = new BElement(); DICElement.AddToBDic(Reader); return DICElement; } default://("e") return null; } } }

अंतिम वर्ग, हमारी संरचना का "दिल" - फाइलबैकनकोडिंग
यह BEncode \ XML लेखक एल्गोरिथ्म को लागू करेगा।

शुरू करने के लिए, हम पढ़ने को लागू करते हैं।
इस वर्ग को शामिल करें:

BElement की सूची (क्योंकि .torrent फ़ाइलों में आमतौर पर केवल एक तत्व होता है, आप बस BElement का एक चर सेट कर सकते हैं)
अनुक्रमण (सूची विकल्प)
फ़ाइल पथ का वर्णन करने वाले स्ट्रिंग के साथ कंस्ट्रक्टर

  public class FileBEncoding { List<BElement> BenItems;//      ,   BElement BenItem BElement this[int index] { get { if (BenItems.Count > index) return BenItems[index]; return null; } set { if (BenItems.Count > index) { BenItems[index] = value; } else throw new Exception("  .   "); } } public FileBEncoding(string Path) { if (!File.Exists(Path)) return; BenItems = new List<BElement>(); StreamReader Reader = new StreamReader(Path, Encoding.ASCII); while (!Reader.EndOfStream) { BElement temp = BElement.GetNewBElement(Reader); if (temp != null) BenItems.Add(temp); } Reader.Close(); }

अधिक स्पष्ट रेखा आउटपुट

यदि आप xml में आउटपुट पहले से ही देखना चाहते हैं, तो इस भाग को छोड़ दिया जा सकता है।
यहाँ मैं एक "संरचित" जानकारी के आउटपुट को फ़ाइल \ कंसोल में पेश करना चाहूंगा।
इसके लिए हमें क्या चाहिए?
C # की सभी कक्षाएं क्लास ऑब्जेक्ट से ली गई हैं। इस वर्ग में एक ToString () विधि है। डिफ़ॉल्ट रूप से, यह विधि प्रकार नाम प्रदर्शित करती है। इसे फिर से परिभाषित करें।

  private string BElementToSTR(BElement CurrentElement, int TabCount, bool Ignore = true) { //     if (CurrentElement == null) return "";//    ,       . string Result = "";//  if (Ignore)//      PasteTab(ref Result, TabCount); if (CurrentElement.STDItem != null) { Result += CurrentElement.STDItem.ToString(); return Result; } if (CurrentElement.LSTItem != null) {//  Result += "List{\n"; for (int i = 0; i < CurrentElement.LSTItem.Count; i++) Result += BElementToSTR(CurrentElement.LSTItem[i], TabCount + 1) + '\n'; PasteTab(ref Result, TabCount); Result += "}List\n"; return Result; } if (CurrentElement.DICItem != null) {//  Result += "Dict{\n"; for (int i = 0; i < CurrentElement.DICItem.Count; i++) { Result += BElementToSTR(CurrentElement.DICItem[i][0], TabCount + 1) +" => "+ BElementToSTR(CurrentElement.DICItem[i][1], TabCount+1,false) + '\n'; } PasteTab(ref Result, TabCount); Result += "}Dict\n"; return Result; } return "";//   null,     } private string PasteTab(ref string STR,int count) {// for (int i = 0; i < count; i++) STR += '\t'; return STR; } public string ToString() { string Result = ""; for (int i = 0; i < BenItems.Count; i++) { Result += BElementToSTR(BenItems[i], 0) + "\n\n"; } return Result; }

यहां हमने अतिरिक्त 2 फ़ंक्शन का उपयोग किया है। पहला एक एकल BElement की प्रक्रिया करता है (आप देख सकते हैं कि यह पुनरावर्ती है), दूसरा - इंडेंट बनाने के लिए।

एक XML फ़ाइल बनाएँ

इससे पहले कि हम कोडिंग शुरू करें, मैं XML भाषा के बारे में कुछ शब्द कहना चाहूंगा।
इस भाषा का व्यापक रूप से सूचना-विनिमय की एकल भाषा के रूप में उपयोग किया जाता है। C # (या बल्कि, .NET प्लेटफ़ॉर्म) उत्कृष्ट XML समर्थन को लागू करता है। सुविधाजनक काम के लिए, हम System.XML नेमस्पेस को जोड़कर अंतर्निहित उपकरणों का उपयोग करते हैं।

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

एक दस्तावेज़ बनाने के लिए, हम दो तरीकों को परिभाषित करते हैं
शून्य ToXMLFile (स्ट्रिंग पथ) और शून्य BElementToXML (BElement करंट, XmlWriter लेखक, इंट ऑर्डर = 0)
पहली विधि आवश्यक XmlWriter वर्ग का एक ऑब्जेक्ट बनाएगी और सूची से प्रत्येक तत्व के लिए BElementToXML को कॉल करेगी।
दूसरी विधि "अनुपचारित" BElement में लगी हुई है (यदि यह एक सूची \ डिक्शनरी है) और, वास्तव में, एक फ़ाइल का निर्माण।

  private void BElementToXML(BElement Current, XmlWriter Writer, int order = 0) { if (Current == null) return;//    if (Current.STDItem != null) {//     Writer.WriteAttributeString("STDType"+'_'+order.ToString(), Current.STDItem.ToString()); return; } if (Current.LSTItem != null) {// Writer.WriteStartElement("List");//    <List> for (int i = 0; i < Current.LSTItem.Count; i++) BElementToXML(Current.LSTItem[i],Writer,order);//  Writer.WriteEndElement();//  </List> return; } if (Current.DICItem != null) {// ( ) Writer.WriteStartElement("Dictionary"); for (int i = 0; i < Current.DICItem.Count; i++) { Writer.WriteStartElement("Dictionary_Items"); BElementToXML(Current.DICItem[i][0], Writer,order); BElementToXML(Current.DICItem[i][1], Writer,order+1); Writer.WriteEndElement(); } Writer.WriteEndElement(); return; } return; } public void ToXMLFile(string path) { using (XmlTextWriter XMLwr = new XmlTextWriter(path, System.Text.Encoding.Unicode)) { XMLwr.Formatting = Formatting.Indented; XMLwr.WriteStartElement("Bencode_to_XML"); foreach (BElement X in BenItems) { XMLwr.WriteStartElement("BenItem"); BElementToXML(X, XMLwr); XMLwr.WriteEndElement(); } XMLwr.WriteEndElement(); } }

परिणामस्वरूप, हमें BEncode फाइल को देखने के लिए और अधिक सुविधाजनक तरीके मिलते हैं:
(उदाहरण के लिए, मैंने ubuntu टोरेंट फ़ाइल का उपयोग किया। SHA ने चाबियाँ हटा दीं।)

कंसोल: (ToString)

एक्सेल: (xml)

निष्कर्ष

इस छोटे लेख में, हमने एक सबक सीखा: बीएनकोड फ़ाइलों को संसाधित करें, एक XML फ़ाइल उत्पन्न करें।
और BEncode से XML फ़ाइल बनाना उपयोगी हो सकता है, उदाहरण के लिए, BEncode फ़ाइलों के लिए एक संपादक लिखने के लिए। यहाँ कोड एक साथ रखा गया है

साहित्य

विकिपीडिया - बेनकोड फ़ाइलें
बेन वाटसन - सी # 4.0

Bencode से XML में अनुवाद करना