जोड़ तोड़ लाइनों

Question

मैं जो इस तरह दिखेगा हर दूसरे अद्यतन डेटा से उत्पन्न लाइनों के लाखों लोगों की है:

104500 4783 
104501 8930 
104502 21794 
104503 21927 
104505 5746 
104506 9968 
104509 5867 
104510 46353 
104511 7767 
104512 4903 

दाईं ओर कॉलम समय (hhmmss प्रारूप) का प्रतिनिधित्व करता है, और दाईं ओर स्तंभ डेटा है जिसे सेकेंड-सेकेंड अपडेट किया जाता है। जैसा कि आप देख सकते हैं, यह वास्तव में दूसरे-सेकेंड नहीं है, और कुछ गुम समय हैं (10:45:04, 10:45:07, 10:45:08 इस उदाहरण में गायब हैं)। "-" परिणाम में, मैं सिर्फ

104500 4783 
104501 8930 
104502 21794 
104503 21927 
104504 21927 -- 
104505 5746 
104506 9968 
104507 9968 -- 
104508 9968 -- 
104509 5867 
104510 46353 
104511 7767 
104512 4903 

मैं नहीं करना चाहता: मेरा लक्ष्य लापता सेकंड में जोड़ने के लिए, और कहा कि दूसरा याद आ रही है, इस तरह के लिए पिछले दूसरी से डेटा का उपयोग करने के लिए है अतिरिक्त लाइनों को चिह्नित करने के लिए वहां रखो। अब तक मैंने StreamReader और StreamWriter का उपयोग करके इसे पूरा करने का प्रयास किया है, लेकिन ऐसा प्रतीत नहीं होता है कि वे मुझे जो चाहते हैं उसे पाने जा रहे हैं। मैं एक नौसिखिया प्रोग्रामर हूं और सी # के लिए नौसिखिया हूं, इसलिए यदि आप मुझे सही दिशा में इंगित कर सकते हैं, तो यह बहुत अच्छा होगा। मैं वास्तव में सोच रहा हूं कि सी # में ऐसा करना भी संभव है ... मैंने एमएसडीएन पर बहुत समय बिताया है और यहां एसओ पर इसका समाधान ढूंढ रहा है, लेकिन अब तक कोई भी नहीं मिला है।

संपादित करें: रेखाएं एक टेक्स्ट फ़ाइल में हैं, और मैं नव निर्मित डेटा को एक नई टेक्स्ट फ़ाइल में संग्रहीत करना चाहता हूं।

Answer 1

ठीक है, यहाँ है पूरी शूटिंग मैच, परीक्षण किया है और अपने परीक्षण डाटा के खिलाफ काम कर: कुछ लोगों को हो जाता है, मैं अलग लाइनों में पाठ फ़ाइल में पढ़ने की सलाह देंगे के बीच नई प्रविष्टियां डालने के रूप में अब तक

public void InjectMissingData() 
{ 
    DataLine lastDataLine = null; 
    using (var writer = new StreamWriter(File.Create("c:\\temp\\out.txt"))) 
    { 
     using (var reader = new StreamReader("c:\\temp\\in.txt")) 
     { 
      while (!reader.EndOfStream) 
      { 
       var dataLine = DataLine.Parse(reader.ReadLine()); 

       while (lastDataLine != null && dataLine.Occurence - lastDataLine.Occurence > TimeSpan.FromSeconds(1)) 
       { 
        lastDataLine = new DataLine(lastDataLine.Occurence + TimeSpan.FromSeconds(1), lastDataLine.Data); 
        writer.WriteLine(lastDataLine.Line); 
       } 

       writer.WriteLine(dataLine.Line); 

       lastDataLine = dataLine; 
      } 
     } 
    } 
} 

public class DataLine 
{ 
    public static DataLine Parse(string line) 
    { 
     var timeString = string.Format("{0}:{1}:{2}", line.Substring(0, 2), line.Substring(2, 2), 
             line.Substring(4, 2)); 

     return new DataLine(TimeSpan.Parse(timeString), long.Parse(line.Substring(7, line.Length - 7).Trim())); 
    } 

    public DataLine(TimeSpan occurence, long data) 
    { 
     Occurence = occurence; 
     Data = data; 
    } 

    public TimeSpan Occurence { get; private set; } 
    public long Data { get; private set; } 

    public string Line 
    { 
     get { return string.Format("{0}{1}{2} {3}", 
      Occurence.Hours.ToString().PadLeft(2, Char.Parse("0")), 
      Occurence.Minutes.ToString().PadLeft(2, Char.Parse("0")), 
      Occurence.Seconds.ToString().PadLeft(2, Char.Parse("0")), 
      Data); } 
    } 
} 

Answer 2

, और उसके बाद उन्हें List में संग्रहीत किया जाता है। इस तरह, आप अपनी नई लाइनों को सम्मिलित करने के लिए Insert(...) विधि का उपयोग कर सकते हैं। वहां से, आप लाइनों को वापस फाइल में लिख सकते हैं।

लाइनों को पढ़ने के दौरान, आप System.IO.File कक्षा: ReadAllText और ReadAllLines में स्थिर हेल्पर विधियों का उपयोग कर सकते हैं।

नोट: मैं, तरीके और वर्गों मैं उल्लेख किया है में से प्रत्येक के लिए MSDN प्रलेखन के लिंक जोड़ दिया है जब से तुम ने कहा कि आप सामान्य रूप में सी # और प्रोग्रामिंग के लिए नए हैं।

Answer 3

String prevTime; 
String prevData; 

while(String line = myStreamReader.ReadLine()) 
{ 
    String[] parts = line.Split(new Char[] { ' ' }); 
    String time = parts[0]; 
    String data = parts[1]; 

    Int32 iPrevTime = Int32.Parse(prevTime); 
    Int32 iCurrentTime = Int32.Parse(time); 

    // May need to loop here if you're missing more than one second 
    if(iCurrentTime > iPrevTime + 1) 
      AddData((iPrevTime + 1).ToString(), prevData); 

    AddData(time, data); 
    prevTime = time; 
    prevData = data; 
} 

यहां शुरू करने के लिए कुछ छद्म कोड है। मुझे लगता है कि आप इस प्रकार के एल्गोरिदम चाहते हैं।

Answer 4

कुछ चीजें आप को एक साथ रखा करने की जरूरत है।

1. पढ़ें एक फ़ाइल पंक्ति-दर-पंक्ति: यहाँ देखें: Reading a Text File One Line at a Time
2. एक फ़ाइल पंक्ति-दर-पंक्ति लेखन: StreamWriter.WriteLine
3. पिछले पढ़ने लाइन का ट्रैक रखें। (बस अपने जबकि पाश में एक चर का उपयोग जहां लाइनों पढ़ें)
4. चेक अंतराल है कि क्या वहाँ। हो सकता है कि पहले कॉलम (string.Split) TimeSpan.Parse का उपयोग कर पार्स करने से। यदि कोई अंतर है तो टाइम्स पैन बढ़ाने, अंतिम पठन रेखा लिखें।

Answer 5

सभी प्रश्नों के उत्तर के लिए adition में, यह देखते हुए कि आप एक विशाल फ़ाइलों के बारे में बात कर रहे हैं,, MemoryMappedFiles के उपयोग पर विचार here पढ़ कैसे सी # से उन्हें इस्तेमाल करने को देखने के लिए कर सकते हैं।

यह प्रदर्शन प्रदर्शन नहीं है, लेकिन स्मृति सुधार निश्चित रूप से है।

Answer 6

यह मानता है कि समय एक सेकंड से अधिक कभी नहीं होता है। यदि वह धारणा गलत है, तो नीचे संशोधित करना काफी आसान है, इसलिए यह प्रत्येक दूसरे गायब होने के लिए लूप में अंतिम वैल्यू लिखता है। अद्यतन मुझे आपके उदाहरण में याद आया कि वास्तव में यह कई सेकंड याद कर सकता है। मैंने इसे संबोधित करने के लिए नीचे दिया गया उदाहरण बदल दिया।

using (StreamReader reader = OpenYourInputFile()) 
using (StreamWriter writer = OpenYourOutputFile()) 
{ 
    TimeSpan? lastTime; 
    TimeSpan currentTime, maxDiff = TimeSpan.FromSeconds(1); 
    string lastValue, currentline, currentValue, format = "{0:hhmmss} {1}"; 

    while((currentLine = reader.ReadLine()) != null) 
    { 
     string[] s = currentLine.Split(' '); 
     currentTime = DateTime.ParseExact("hhmmss", s[0] CultureInfo.InvariantCulture).TimeOfDay; 
     currentValue = s[1]; 

     if (lastTime.HasValue && currentTime - lastTime.Value > maxDiff) 
     { 
     for(int x = 1; x <= (currentTime - lastTime).Seconds; x++) writer.WriteLine(string.Format(format, DateTime.Today.Add(lastTime).AddSeconds(x), lastValue); 
     } 

     writer.WriteLine(string.Format(format, DateTime.Today.Add(currentTime), currentValue); 

     lastTime = currentTime; 
     lastValue = currentValue; 
    } 

} 

Answer 7

यहां आपके लिए कुछ मोटा कोड है। मैं सब ठीक से निपटान नहीं कर रहा हूं, यह सिर्फ आपको शुरू करने के लिए है।

 DateTime lastTime; 
     string lastValue = null; 
     StreamReader reader = File.OpenText("path"); 
     StreamWriter writer = new StreamWriter(File.OpenWrite("newPath")); 

     while (!reader.EndOfStream) 
     { 
      string[] lineData = reader.ReadLine().Split(' '); 
      DateTime currentTime = DateTime.Parse(lineData[0]); 
      string value = lineData[1]; 

      if (lastValue != null) 
      { 
       while (lastTime < currentTime.AddSeconds(-1)) 
       { 
        lastTime = lastTime.AddSeconds(1); 
        writer.WriteLine("{0} {1}", lastTime, lastValue); 
       } 
      } 
      writer.WriteLine("{0} {1}", currentTime, value); 
      lastTime = currentTime; 
      lastValue = value; 
     } 

Answer 8

 string line;//The line that is read. 
     string previousLine = "0 0"; 
     int prevTime = 0; 

     //These "using"'s are so that the resources they use will be freed when the block (i.e. {}) is finished. 
     using (System.IO.StreamReader originalFile = new System.IO.StreamReader("c:\\users\\Me\\t.txt")) 
     using (System.IO.StreamWriter newFile = new System.IO.StreamWriter("c:\\users\\Me\\t2.txt")) 
     { 
      while ((line = originalFile.ReadLine()) != null) 
      { 
       //"Split" changes the words in "line" (- that are separated by a space) to an array. 
       //"Parse" takes the first in that array (by using "[0]") and changes it into an integer. 
       int time = int.Parse(line.Split(' ')[0]); 
       while (prevTime != 0 && time > ++prevTime) newFile.WriteLine(prevTime.ToString() + " " + previousLine.Split(' ')[1]); 

       previousLine = line; 
       prevTime = time; 
       newFile.WriteLine(line); 
      } 
     }