दिलचस्प पोस्ट
आउटपुट छवि का उपयोग कैसे करें com.android.camera.action.CROP सेट करें आवेदन बनाम सत्र बनाम कैश jqgrid + ईएफ + एमवीसी: एक्सेल में कैसे निर्यात करें? आप किस विधि का सुझाव देते हैं? आईओएस के लिए एनईटी यूनिट टेस्ट रनर UIWebView: कब पृष्ठ वास्तव में लोड हो रहा है? एडी के खुलासे के मॉड्यूल पैटर्न के विवरण में "पैच की आवश्यकता है, तो" सार्वजनिक फ़ंक्शन द्वारा क्या मतलब है ओवरराइड नहीं किया जा सकता है? फ़ाइल सामग्री सी + + में एक स्ट्रिंग में पढ़ें रूबी में === बनाम == अग्रभूमि आईओएस में ऐप करते समय पुश सूचना प्राप्त करें एक वस्तु के क्षेत्रों से अजगर शब्दकोश $ http.get को एक्सेस-कंट्रोल-अनुमति-मूल द्वारा अनुमति नहीं है लेकिन $। एजेक्स है एंड्रॉइड स्टूडियो प्रोजेक्ट का निर्माण करते समय स्टैकट्र्रेस या डीबग विकल्प कैसे जोड़ें सी # सभी फाइलों और उपनिर्देशिका FTP के माध्यम से डाउनलोड करें वसंत MVC नियंत्रक में JSON पैरामीटर टीएसक्यूएल का उपयोग कर डेटाबेस में सभी तालिकाओं को कैसे छांटते हैं?

बहुत बड़ी टेक्स्ट फ़ाइल की अंतिम 10 लाइनें प्राप्त करें> 10 जीबी

बहुत बड़ी टेक्स्ट फ़ाइल की आखिरी 10 लाइनों को प्रदर्शित करने का सबसे कारगर तरीका क्या है (यह विशेष रूप से फ़ाइल 10 जीबी से अधिक है) मैं बस एक साधारण सी # ऐप लिखने की सोच रहा था लेकिन मुझे यकीन नहीं है कि यह कैसे प्रभावी ढंग से करना है

वेब के समाधान से एकत्रित समाधान "बहुत बड़ी टेक्स्ट फ़ाइल की अंतिम 10 लाइनें प्राप्त करें> 10 जीबी"

फ़ाइल के अंत में पढ़ें, फिर जब तक आप दस नई लाइनें नहीं मिलते हैं, तब तक पीछे की तलाश करें, और फिर अंत में आगे पढ़ें, विभिन्न एन्कोडिंग को ध्यान में रखते हुए। ऐसे मामलों को संभालना सुनिश्चित करें जहां फाइल में पंक्तियों की संख्या दस से कम है। नीचे एक कार्यान्वयन है (सी # के रूप में आपने इसे टैग किया है), encoding में एन्कोडेड path पर स्थित फ़ाइल में अंतिम संख्या numberOfTokens ढूंढने के लिए सामान्यीकृत है, जहां टोकन सेपरेटर का प्रतिनिधित्व टोकन सेपरेटर द्वारा किया tokenSeparator ; नतीजा एक string रूप में लौटाया जाता है (यह एक IEnumerable<string> लौटकर सुधार किया जा सकता है जो टोकन की गणना करता है)।

 public static string ReadEndTokens(string path, Int64 numberOfTokens, Encoding encoding, string tokenSeparator) { int sizeOfChar = encoding.GetByteCount("\n"); byte[] buffer = encoding.GetBytes(tokenSeparator); using (FileStream fs = new FileStream(path, FileMode.Open)) { Int64 tokenCount = 0; Int64 endPosition = fs.Length / sizeOfChar; for (Int64 position = sizeOfChar; position < endPosition; position += sizeOfChar) { fs.Seek(-position, SeekOrigin.End); fs.Read(buffer, 0, buffer.Length); if (encoding.GetString(buffer) == tokenSeparator) { tokenCount++; if (tokenCount == numberOfTokens) { byte[] returnBuffer = new byte[fs.Length - fs.Position]; fs.Read(returnBuffer, 0, returnBuffer.Length); return encoding.GetString(returnBuffer); } } } // handle case where number of tokens in file is less than numberOfTokens fs.Seek(0, SeekOrigin.Begin); buffer = new byte[fs.Length]; fs.Read(buffer, 0, buffer.Length); return encoding.GetString(buffer); } } 

मुझे संभावना है कि इसे एक बाइनरी स्ट्रीम के रूप में खोलें, अंत की तलाश करें, फिर वापस लाइन ब्रेक की तलाश करें। अपनी 10 लाइनें ढूंढने के लिए 10 (या 11 को पिछली पंक्ति के आधार पर) वापस लें, फिर अंत में पढ़िए और एन्कोडिंग का उपयोग करें। आप जिस स्ट्रिंग फ़ॉर्मेट में प्राप्त करने के लिए पढ़ते हैं, उसके बारे में गेटस्ट्रिंग का उपयोग करें। वांछित के रूप में विभाजित

पूंछ? टेल एक यूनिक्स कमांड है जो एक फ़ाइल की अंतिम कुछ पंक्तियां प्रदर्शित करेगा। Windows 2003 सर्वर संसाधन किट में एक विंडोज संस्करण है

जैसा कि दूसरों ने सुझाव दिया है, आप फ़ाइल के अंत में जा सकते हैं और पीछे की ओर प्रभावी ढंग से पढ़ सकते हैं। हालांकि, यह थोड़ा मुश्किल है – खासकर इसलिए कि यदि आपके पास एक चर-लंबाई एन्कोडिंग (जैसे कि यूटीएफ -8) है तो आपको यह सुनिश्चित करने के लिए चालाक होना चाहिए कि आप "पूरे" वर्ण प्राप्त करें

आप फ़ाइल के अंत में स्थानांतरित करने के लिए FileStream.Seek () का उपयोग करने में सक्षम होना चाहिए, फिर अपने पीछे की तरफ काम करें, \ n जब तक आपके पास पर्याप्त पंक्तियाँ न हों

मुझे यकीन नहीं है कि यह कैसे कुशल होगा, लेकिन Windows PowerShell में फ़ाइल की अंतिम दस पंक्तियां मिलती-जुलती हैं

 Get-Content file.txt | Select-Object -last 10 

यही यूनिक्स पूल कमांड करता है http://en.wikipedia.org/wiki/Tail_(Unix देखें )

इंटरनेट पर बहुत सारे ओपन सोर्स लागूकरण हैं और यहां Win32: Tail WIn32 के लिए है

मुझे लगता है कि निम्नलिखित कोड प्रिबिल को सूक्ष्म परिवर्तनों के साथ एन्कोडिंग को फिर से सुलझाएगा

 StreamReader reader = new StreamReader(@"c:\test.txt"); //pick appropriate Encoding reader.BaseStream.Seek(0, SeekOrigin.End); int count = 0; while ((count < 10) && (reader.BaseStream.Position > 0)) { reader.BaseStream.Position--; int c = reader.BaseStream.ReadByte(); if (reader.BaseStream.Position > 0) reader.BaseStream.Position--; if (c == Convert.ToInt32('\n')) { ++count; } } string str = reader.ReadToEnd(); string[] arr = str.Replace("\r", "").Split('\n'); reader.Close(); 

आप पूंछ कमांड के विंडोज संस्करण का इस्तेमाल कर सकते हैं और इसे सिर्फ एक प्रतीक के साथ एक टेक्स्ट फाइल में आउटपुट के रूप में दिखाएं या स्क्रीन पर उसे देखिए कि आपकी ज़रूरतें क्या हैं

यहाँ मेरा का संस्करण है HTH

 using (StreamReader sr = new StreamReader(path)) { sr.BaseStream.Seek(0, SeekOrigin.End); int c; int count = 0; long pos = -1; while(count < 10) { sr.BaseStream.Seek(pos, SeekOrigin.End); c = sr.Read(); sr.DiscardBufferedData(); if(c == Convert.ToInt32('\n')) ++count; --pos; } sr.BaseStream.Seek(pos, SeekOrigin.End); string str = sr.ReadToEnd(); string[] arr = str.Split('\n'); } 

अगर आप फाइल को फाइलमैड के साथ खोलते हैं। ऐपेंड यह आपके लिए फ़ाइल के अंत की तलाश करेगा। फिर आप चाहते हैं कि आप जितनी बाइट्स की संख्या वापस कर लेंगे और उन्हें पढ़ें। यह तेजी से नहीं हो सकता है, हालांकि आप जो भी करते हैं उसके बावजूद यह बहुत बड़ी फ़ाइल है

एक उपयोगी तरीका FileInfo.Length । यह बाइट्स में फ़ाइल का आकार देता है।

आपकी फ़ाइल संरचना क्या है? क्या आपको यकीन है कि पिछले 10 लाइनें फ़ाइल के अंत के पास होगी? यदि आपके पास 12 लाइनों की पाठ्य और 10 जीबी 0 एस के साथ एक फाइल है, तो अंत में देखना वास्तव में तेज़ नहीं होगा फिर से, आपको पूरी फाइल देखने की ज़रूरत है

यदि आपको यकीन है कि फ़ाइल में प्रत्येक एक नई पंक्ति में कई लघु स्ट्रिंग हैं, तो अंत की तलाश करें, फिर जांचें, जब तक कि आप लाइनों के 11 छोरों की गणना नहीं करेंगे फिर आप अगले 10 लाइनों के लिए आगे पढ़ सकते हैं

मुझे लगता है कि अन्य पोस्टर्स ने यह दिखाया है कि कोई वास्तविक शॉर्टकट नहीं है

आप या तो पूंछ (या पावरशेल्ड) जैसे किसी उपकरण का उपयोग कर सकते हैं या आप कुछ गूंगा कोड लिख सकते हैं जो फ़ाइल के अंत की तलाश करता है और फिर एन न्यूलाइनों के लिए पीछे दिखता है

वेब पर वहाँ पूंछ के बहुत सारे लागू होते हैं – स्रोत कोड पर एक नज़र डालें यह देखने के लिए कि वे यह कैसे करते हैं। टेल बहुत कुशल है (बहुत बहुत बड़ी फाइलों पर भी) और इसलिए उन्होंने इसे लिखा है, जब उन्हें सही हो गया होगा!

फ़ाइल खोलें और लाइनें पढ़ने शुरू करें आपके द्वारा पढ़े जाने के बाद 10 लाइनें एक और पॉइंटर को खोलती हैं, जो फ़ाइल के सामने से शुरू होती हैं, इसलिए दूसरा सूचक पहले 10 लाइनों के द्वारा लांग करता है पढ़ने के बाद, दो बिंदुओं को एकजुट में ले जाने तक, पहले तक फ़ाइल के अंत तक पहुंचने तक। फिर परिणाम को पढ़ने के लिए दूसरे सूचक का उपयोग करें। यह पूंछ लंबाई से खाली और कम सहित किसी भी आकार फ़ाइल के साथ काम करता है और पूंछ की किसी भी लम्बाई के लिए समायोजित करना आसान है। दोष, निश्चित रूप से, यह है कि आप पूरी फाइल को पढ़ना बंद कर देते हैं और ऐसा हो सकता है कि आप जो बचने का प्रयास कर रहे हैं

यदि आपके पास एक फाइल है जिसमें प्रति पंक्ति एक प्रारूप है (जैसे एक daq प्रणाली), तो आप फ़ाइल की लंबाई प्राप्त करने के लिए सिर्फ स्ट्रीमरीडर का उपयोग करें, फिर एक पंक्तियां लें, ( readline() )।

तार की लंबाई से कुल लंबाई को विभाजित करें। अब फाइल में लाइनों की संख्या का प्रतिनिधित्व करने के लिए आपके पास एक सामान्य लंबी संख्या है।

कुंजी यह है कि आप अपने डेटा को अपने सरणी के लिए या जो कुछ भी प्राप्त करने से पहले readline() उपयोग करते हैं यह सुनिश्चित करेगा कि आप एक नई लाइन की शुरुआत में शुरू हो जाएंगे, और पिछले एक से किसी भी बचे हुए डेटा को नहीं प्राप्त करेंगे।

 StreamReader leader = new StreamReader(GetReadFile); leader.BaseStream.Position = 0; StreamReader follower = new StreamReader(GetReadFile); int count = 0; string tmper = null; while (count <= 12) { tmper = leader.ReadLine(); count++; } long total = follower.BaseStream.Length; // get total length of file long step = tmper.Length; // get length of 1 line long size = total / step; // divide to get number of lines long go = step * (size - 12); // get the bit location long cut = follower.BaseStream.Seek(go, SeekOrigin.Begin); // Go to that location follower.BaseStream.Position = go; string led = null; string[] lead = null ; List<string[]> samples = new List<string[]>(); follower.ReadLine(); while (!follower.EndOfStream) { led = follower.ReadLine(); lead = Tokenize(led); samples.Add(lead); } 

प्रारंभिक बिंदु के रूप में Sisutil के जवाब का उपयोग करके, आप फ़ाइल लाइन को लाइन से पढ़ सकते हैं और उन्हें एक Queue<String> में लोड कर सकते हैं यह फ़ाइल को शुरू से ही पढ़ा है, लेकिन इसके पीछे फाइल को पढ़ने की कोशिश नहीं करने का गुण है यह वास्तव में मुश्किल हो सकता है अगर आपके पास यूटीएफ -8 जैसी एक चर वर्ण चौड़ाई एन्कोडिंग के साथ एक फाइल है जो जॉन स्कीट ने बताया है। यह लाइन की लंबाई के बारे में किसी भी धारणा नहीं करता है।

मैंने इसे 1.7 जीबी फ़ाइल के खिलाफ परीक्षण किया था (इसमें 10 जीबी एक काम नहीं था) और इसमें लगभग 14 सेकंड लग गए। बेशक, कंप्यूटर की तुलना में लोड की तुलना करते समय और पढ़ने के दौरान सामान्य आश्वासन लागू होते हैं।

 int numberOfLines = 10; string fullFilePath = @"C:\Your\Large\File\BigFile.txt"; var queue = new Queue<string>(numberOfLines); using (FileStream fs = File.Open(fullFilePath, FileMode.Open, FileAccess.Read, FileShare.Read)) using (BufferedStream bs = new BufferedStream(fs)) // May not make much difference. using (StreamReader sr = new StreamReader(bs)) { while (!sr.EndOfStream) { if (queue.Count == numberOfLines) { queue.Dequeue(); } queue.Enqueue(sr.ReadLine()); } } // The queue now has our set of lines. So print to console, save to another file, etc. do { Console.WriteLine(queue.Dequeue()); } while (queue.Count > 0); 

मेरे पास एक ही समस्या थी, एक विशाल लॉग फाइल जो कि एक आराम अंतरफलक के माध्यम से पहुंचा है बेशक यह जो भी स्मृति में लोड हो रहा है और इसे http के माध्यम से पूरा करने का कोई समाधान नहीं था।

जैसा कि जॉन ने बताया, यह समाधान एक बहुत विशिष्ट उपयोग के लिए है। मेरे मामले में, मुझे यकीन है कि (और जांच) पता है, कि एन्कोडिंग यूटीएफ -8 (बीओएम!) के साथ है और यूटीएफ के सभी आशीषों से लाभ ले सकता है। यह निश्चित रूप से सामान्य प्रयोजन समाधान नहीं है

यह मेरे लिए बेहद अच्छी और तेजी से काम करने वाला है (मैं स्ट्रीम को बंद करना भूल गया – अब तय किया गया):

  private string tail(StreamReader streamReader, long numberOfBytesFromEnd) { Stream stream = streamReader.BaseStream; long length = streamReader.BaseStream.Length; if (length < numberOfBytesFromEnd) numberOfBytesFromEnd = length; stream.Seek(numberOfBytesFromEnd * -1, SeekOrigin.End); int LF = '\n'; int CR = '\r'; bool found = false; while (!found) { int c = stream.ReadByte(); if (c == LF) found = true; } string readToEnd = streamReader.ReadToEnd(); streamReader.Close(); return readToEnd; } 

हम पहले बेसस्ट्रीम के साथ अंत में कहीं और की तलाश करते हैं, और जब हमारे पास सही स्ट्रीम पॉइटॉन होता है, तो सामान्य स्ट्रीमरेडर के साथ अंत में पढ़ें।

यह सचमुच लाइनों की मात्रा को निर्दिष्ट करने की अनुमति नहीं देता, जो अंत के रूप में तैयार होती है, जो कि एक अच्छा विचार नहीं है, क्योंकि लाइनें मनमाने ढंग से लंबी हो सकती हैं और इस प्रकार, प्रदर्शन को फिर से मार दिया जाता है इसलिए मैं बाइट्स की मात्रा निर्दिष्ट करता हूं, जब तक कि हम पहली बार न्यूलाइन तक पहुंचते हैं और अंत तक आराम से पढ़ते हैं। सैद्धांतिक रूप से, आप कैरिएज रिटरन भी देख सकते थे, लेकिन मेरे मामले में, यह आवश्यक नहीं था।

यदि हम इस कोड का उपयोग करते हैं, तो यह लेखक थ्रेड को परेशान नहीं करेगा:

  FileStream fileStream = new FileStream( filename, FileMode.Open, FileAccess.Read, FileShare.ReadWrite); StreamReader streamReader = new StreamReader(fileStream); 

यदि आपको किसी पाठ फ़ाइल से किसी भी संख्या में उल्लिखित लाइनों को पढ़ने की आवश्यकता है, तो यहां एक LINQ- संगत वर्ग है जिसे आप उपयोग कर सकते हैं। यह बड़ी फ़ाइलों के लिए प्रदर्शन और समर्थन पर केंद्रित है आप कई लाइनों को पढ़ सकते हैं और पीछे की ओर पिछले कई लाइनों को प्राप्त करने के लिए रिवर्स () पर कॉल कर सकते हैं:

उपयोग :

 var reader = new ReverseTextReader(@"C:\Temp\ReverseTest.txt"); while (!reader.EndOfStream) Console.WriteLine(reader.ReadLine()); 

रिवर्सटेस्टरेडर क्लास :

 /// <summary> /// Reads a text file backwards, line-by-line. /// </summary> /// <remarks>This class uses file seeking to read a text file of any size in reverse order. This /// is useful for needs such as reading a log file newest-entries first.</remarks> public sealed class ReverseTextReader : IEnumerable<string> { private const int BufferSize = 16384; // The number of bytes read from the uderlying stream. private readonly Stream _stream; // Stores the stream feeding data into this reader private readonly Encoding _encoding; // Stores the encoding used to process the file private byte[] _leftoverBuffer; // Stores the leftover partial line after processing a buffer private readonly Queue<string> _lines; // Stores the lines parsed from the buffer #region Constructors /// <summary> /// Creates a reader for the specified file. /// </summary> /// <param name="filePath"></param> public ReverseTextReader(string filePath) : this(new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read), Encoding.Default) { } /// <summary> /// Creates a reader using the specified stream. /// </summary> /// <param name="stream"></param> public ReverseTextReader(Stream stream) : this(stream, Encoding.Default) { } /// <summary> /// Creates a reader using the specified path and encoding. /// </summary> /// <param name="filePath"></param> /// <param name="encoding"></param> public ReverseTextReader(string filePath, Encoding encoding) : this(new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read), encoding) { } /// <summary> /// Creates a reader using the specified stream and encoding. /// </summary> /// <param name="stream"></param> /// <param name="encoding"></param> public ReverseTextReader(Stream stream, Encoding encoding) { _stream = stream; _encoding = encoding; _lines = new Queue<string>(128); // The stream needs to support seeking for this to work if(!_stream.CanSeek) throw new InvalidOperationException("The specified stream needs to support seeking to be read backwards."); if (!_stream.CanRead) throw new InvalidOperationException("The specified stream needs to support reading to be read backwards."); // Set the current position to the end of the file _stream.Position = _stream.Length; _leftoverBuffer = new byte[0]; } #endregion #region Overrides /// <summary> /// Reads the next previous line from the underlying stream. /// </summary> /// <returns></returns> public string ReadLine() { // Are there lines left to read? If so, return the next one if (_lines.Count != 0) return _lines.Dequeue(); // Are we at the beginning of the stream? If so, we're done if (_stream.Position == 0) return null; #region Read and Process the Next Chunk // Remember the current position var currentPosition = _stream.Position; var newPosition = currentPosition - BufferSize; // Are we before the beginning of the stream? if (newPosition < 0) newPosition = 0; // Calculate the buffer size to read var count = (int)(currentPosition - newPosition); // Set the new position _stream.Position = newPosition; // Make a new buffer but append the previous leftovers var buffer = new byte[count + _leftoverBuffer.Length]; // Read the next buffer _stream.Read(buffer, 0, count); // Move the position of the stream back _stream.Position = newPosition; // And copy in the leftovers from the last buffer if (_leftoverBuffer.Length != 0) Array.Copy(_leftoverBuffer, 0, buffer, count, _leftoverBuffer.Length); // Look for CrLf delimiters var end = buffer.Length - 1; var start = buffer.Length - 2; // Search backwards for a line feed while (start >= 0) { // Is it a line feed? if (buffer[start] == 10) { // Yes. Extract a line and queue it (but exclude the \r\n) _lines.Enqueue(_encoding.GetString(buffer, start + 1, end - start - 2)); // And reset the end end = start; } // Move to the previous character start--; } // What's left over is a portion of a line. Save it for later. _leftoverBuffer = new byte[end + 1]; Array.Copy(buffer, 0, _leftoverBuffer, 0, end + 1); // Are we at the beginning of the stream? if (_stream.Position == 0) // Yes. Add the last line. _lines.Enqueue(_encoding.GetString(_leftoverBuffer, 0, end - 1)); #endregion // If we have something in the queue, return it return _lines.Count == 0 ? null : _lines.Dequeue(); } #endregion #region IEnumerator<string> Interface public IEnumerator<string> GetEnumerator() { string line; // So long as the next line isn't null... while ((line = ReadLine()) != null) // Read and return it. yield return line; } IEnumerator IEnumerable.GetEnumerator() { throw new NotImplementedException(); } #endregion } 

फ़ाइल का उपयोग क्यों नहीं करें। रोल्डलाइन जो स्ट्रिंग देता है []?

फिर आप पिछले 10 लाइनें (या सरणी के सदस्यों) को प्राप्त कर सकते हैं जो एक तुच्छ कार्य होगा।

यह दृष्टिकोण किसी भी एन्कोडिंग मुद्दों को ध्यान में नहीं ले रहा है और मुझे इस दृष्टिकोण की सटीक क्षमता (विधि, आदि को पूरा करने के लिए समय लिया गया) पर निश्चित नहीं है।