बिना किसी उपभोग के स्ट्रीमर से एक लाइन पढ़ना?

Question

क्या अगली पंक्ति में विशिष्ट टैग डेटा है या नहीं, यह जांचने के लिए एक पंक्ति आगे पढ़ने का कोई तरीका है?

मैं ऐसे प्रारूप से निपट रहा हूं जिसमें एक प्रारंभ टैग है लेकिन कोई अंत टैग नहीं है।

मैं एक रेखा को एक संरचना में जोड़ना चाहता हूं, फिर यह सुनिश्चित करने के लिए नीचे दी गई रेखा का परीक्षण करें कि यह एक नया "नोड" नहीं है और यदि यह उस संरचना को बंद कर देता है और नया बनाता है तो यह जोड़ना नहीं है एक

एकमात्र समाधान मैं के बारे में सोच सकते हैं दो धारा पाठकों को एक ही समय थोड़े ताला कदम के साथ वहाँ रास्ता suffling पर जा रहा है लेकिन यह है कि wastefull लगती है (अगर यह और भी काम करेंगे)

मैं झांकना की तरह कुछ की जरूरत है लेकिन peekline

Answer 1

समस्या है अंतर्निहित धारा भी तलाश योग्य नहीं हो सकती है। यदि आप स्ट्रीम रीडर कार्यान्वयन पर एक नज़र डालते हैं तो यह एक बफर का उपयोग करता है ताकि यह TextReader.Peek() को कार्यान्वित कर सके, भले ही स्ट्रीम खोजने योग्य न हो।

public class PeekableStreamReaderAdapter 
    { 
     private StreamReader Underlying; 
     private Queue<string> BufferedLines; 

     public PeekableStreamReaderAdapter(StreamReader underlying) 
     { 
      Underlying = underlying; 
      BufferedLines = new Queue<string>(); 
     } 

     public string PeekLine() 
     { 
      string line = Underlying.ReadLine(); 
      if (line == null) 
       return null; 
      BufferedLines.Enqueue(line); 
      return line; 
     } 


     public string ReadLine() 
     { 
      if (BufferedLines.Count > 0) 
       return BufferedLines.Dequeue(); 
      return Underlying.ReadLine(); 
     } 
    } 

Answer 2

आप StreamReader.BaseStream.Position तक पहुंचने की स्थिति को स्टोर कर सकते हैं, फिर अगली पंक्ति रेखा को पढ़ें, अपना परीक्षण करें , फिर लाइन पढ़ने से पहले स्थिति की तलाश करें:

  // Peek at the next line 
      long peekPos = reader.BaseStream.Position; 
      string line = reader.ReadLine(); 

      if (line.StartsWith("<tag start>")) 
      { 
       // This is a new tag, so we reset the position 
       reader.BaseStream.Seek(pos);  

      } 
      else 
      { 
       // This is part of the same node. 
      } 

यह वही लाइनों की तलाश और पुनः पढ़ने के लिए बहुत कुछ है। कुछ तर्क का उपयोग, तो आप इस पूरी तरह से बचने के लिए सक्षम हो सकता है - उदाहरण के लिए, जब आप एक नया टैग शुरू देखते हैं, बाहर मौजूदा संरचना एक नया एक को बंद करने और शुरू - यहाँ एक बुनियादी एल्गोरिथ्म है:

 SomeStructure myStructure = null; 
     while (!reader.EndOfStream) 
     { 
      string currentLine = reader.ReadLine(); 
      if (currentLine.StartsWith("<tag start>")) 
      { 
       // Close out existing structure. 
       if (myStructure != null) 
       { 
        // Close out the existing structure. 
       } 

       // Create a new structure and add this line. 
       myStructure = new Structure();     
       // Append to myStructure. 
      } 
      else 
      { 
       // Add to the existing structure. 
       if (myStructure != null) 
       { 
        // Append to existing myStructure 
       } 
       else 
       { 
        // This means the first line was not part of a structure. 
        // Either handle this case, or throw an exception. 
       } 
      } 
     } 

Answer 3

क्यों कठिनाई:

आप एक सरल एडाप्टर अगली पंक्ति और वह आंतरिक बफ़र्स, कुछ इस तरह पढ़ता लिख ​​सकता है? परवाह किए बिना, अगली पंक्ति वापस लौटें। जांचें कि यह एक नया नोड है, यदि नहीं, तो इसे संरचना में जोड़ें। यदि यह है, तो एक नई संरचना बनाएँ।

// Not exactly C# but close enough 
Collection structs = new Collection(); 
Struct struct; 
while ((line = readline()) != null)) { 
    if (IsNode(line)) { 
     if (struct != null) structs.add(struct); 
     struct = new Struct(); 
     continue; 
    } 
    // Whatever processing you need to do 
    struct.addLine(line); 
} 
structs.add(struct); // Add the last one to the collection 

// Use your structures here 
foreach s in structs { 

} 

Answer 4

यहां तक ​​कि मैं अब तक क्या जाता हूं। मैं लाइन मार्ग से स्ट्रीमreader लाइन की तुलना में अधिक विभाजित मार्ग चला गया।

मुझे यकीन है कि कुछ ऐसे स्थान हैं जो अधिक सुरुचिपूर्ण होने के लिए मर रहे हैं लेकिन अभी यह काम कर रहा है।

कृपया मुझे पता आप क्या सोचते हैं

struct INDI 
    { 
     public string ID; 
     public string Name; 
     public string Sex; 
     public string BirthDay; 
     public bool Dead; 


    } 
    struct FAM 
    { 
     public string FamID; 
     public string type; 
     public string IndiID; 
    } 
    List<INDI> Individuals = new List<INDI>(); 
    List<FAM> Family = new List<FAM>(); 
    private void button1_Click(object sender, EventArgs e) 
    { 
     string path = @"C:\mostrecent.ged"; 
     ParseGedcom(path); 
    } 

    private void ParseGedcom(string path) 
    { 
     //Open path to GED file 
     StreamReader SR = new StreamReader(path); 

     //Read entire block and then plit on 0 @ for individuals and familys (no other info is needed for this instance) 
     string[] Holder = SR.ReadToEnd().Replace("0 @", "\u0646").Split('\u0646'); 

     //For each new cell in the holder array look for Individuals and familys 
     foreach (string Node in Holder) 
     { 

      //Sub Split the string on the returns to get a true block of info 
      string[] SubNode = Node.Replace("\r\n", "\r").Split('\r'); 
      //If a individual is found 
      if (SubNode[0].Contains("INDI")) 
      { 
       //Create new Structure 
       INDI I = new INDI(); 
       //Add the ID number and remove extra formating 
       I.ID = SubNode[0].Replace("@", "").Replace(" INDI", "").Trim(); 
       //Find the name remove extra formating for last name 
       I.Name = SubNode[FindIndexinArray(SubNode, "NAME")].Replace("1 NAME", "").Replace("/", "").Trim(); 
       //Find Sex and remove extra formating 
       I.Sex = SubNode[FindIndexinArray(SubNode, "SEX")].Replace("1 SEX ", "").Trim(); 

       //Deterine if there is a brithday -1 means no 
       if (FindIndexinArray(SubNode, "1 BIRT ") != -1) 
       { 
        // add birthday to Struct 
        I.BirthDay = SubNode[FindIndexinArray(SubNode, "1 BIRT ") + 1].Replace("2 DATE ", "").Trim(); 
       } 

       // deterimin if there is a death tag will return -1 if not found 
       if (FindIndexinArray(SubNode, "1 DEAT ") != -1) 
       { 
        //convert Y or N to true or false (defaults to False so no need to change unless Y is found. 
        if (SubNode[FindIndexinArray(SubNode, "1 DEAT ")].Replace("1 DEAT ", "").Trim() == "Y") 
        { 
         //set death 
         I.Dead = true; 
        } 
       } 
       //add the Struct to the list for later use 
       Individuals.Add(I); 
      } 

      // Start Family section 
      else if (SubNode[0].Contains("FAM")) 
      { 
       //grab Fam id from node early on to keep from doing it over and over 
       string FamID = SubNode[0].Replace("@ FAM", ""); 

       // Multiple children can exist for each family so this section had to be a bit more dynaimic 

       // Look at each line of node 
       foreach (string Line in SubNode) 
       { 
        // If node is HUSB 
        if (Line.Contains("1 HUSB ")) 
        { 

         FAM F = new FAM(); 
         F.FamID = FamID; 
         F.type = "PAR"; 
         F.IndiID = Line.Replace("1 HUSB ", "").Replace("@","").Trim(); 
         Family.Add(F); 
        } 
         //If node for Wife 
        else if (Line.Contains("1 WIFE ")) 
        { 
         FAM F = new FAM(); 
         F.FamID = FamID; 
         F.type = "PAR"; 
         F.IndiID = Line.Replace("1 WIFE ", "").Replace("@", "").Trim(); 
         Family.Add(F); 
        } 
         //if node for multi children 
        else if (Line.Contains("1 CHIL ")) 
        { 
         FAM F = new FAM(); 
         F.FamID = FamID; 
         F.type = "CHIL"; 
         F.IndiID = Line.Replace("1 CHIL ", "").Replace("@", ""); 
         Family.Add(F); 
        } 
       } 
      } 
     } 
    } 

    private int FindIndexinArray(string[] Arr, string search) 
    { 
     int Val = -1; 
     for (int i = 0; i < Arr.Length; i++) 
     { 
      if (Arr[i].Contains(search)) 
      { 
       Val = i; 
      } 
     } 
     return Val; 
    }