C# का उपयोग करके टेक्स्ट फाइल को लाइन दर लाइन पढ़ने के सबसे तेज़ तरीके क्या हैं?

टेक्स्ट फाइल को लाइन दर लाइन पढ़ने के कई तरीके हैं। इनमें StreamReader.ReadLine, File.ReadLines आदि शामिल हैं। आइए एक टेक्स्ट फाइल पर विचार करें जिसमें निम्न लाइन्स हैं।

विधि 1: StreamReader.ReadLine का उपयोग करना

C# StreamReader का उपयोग निर्दिष्ट एन्कोडिंग में स्ट्रीम से कैरेक्टर्स पढ़ने के लिए किया जाता है। StreamReader.ReadLine मेथड इनपुट स्ट्रीम से अगली लाइन पढ़ता है।

using System;
using System.IO;
using System.Text;

namespace DemoApplication
{
    public class Program
    {
        static void Main(string[] args)
        {
            string filePath = @"D:\Demo\Demo.txt";
            
            // using स्टेटमेंट सुनिश्चित करता है कि संसाधन सही से डिस्पोज हों
            using (var fileStream = File.OpenRead(filePath))
            using (var streamReader = new StreamReader(fileStream, Encoding.UTF8))
            {
                string line;
                while ((line = streamReader.ReadLine()) != null)
                {
                    Console.WriteLine(line);
                }
            }
            
            Console.ReadLine();
        }
    }
}

विधि 2: File.ReadLines का उपयोग करना (मेमोरी-कुशल)

File.ReadLines() एक IEnumerable<string> लौटाता है जो लेज़ीली लाइन्स पढ़ता है - पूरी फाइल को एक बार में मेमोरी में लोड नहीं करता। बड़ी फाइलों के लिए आदर्श।

using System;
using System.IO;

namespace DemoApplication
{
    public class Program
    {
        static void Main(string[] args)
        {
            string filePath = @"D:\Demo\Demo.txt";
            
            // लेज़ी एन्यूमरेशन - एक समय में एक लाइन
            var lines = File.ReadLines(filePath);
            
            foreach (var line in lines)
            {
                Console.WriteLine(line);
            }
            
            Console.ReadLine();
        }
    }
}

विधि 3: File.ReadAllLines का उपयोग करना (पूरी फाइल मेमोरी में)

File.ReadAllLines() पूरी फाइल पढ़कर string[] लौटाता है। रैंडम एक्सेस की अनुमति देता है लेकिन पूरी फाइल मेमोरी में लोड करता है। छोटी फाइलों के लिए उपयुक्त।

using System;
using System.IO;

namespace DemoApplication
{
    public class Program
    {
        static void Main(string[] args)
        {
            string filePath = @"D:\Demo\Demo.txt";
            
            // पूरी फाइल मेमोरी में लोड होती है
            string[] lines = File.ReadAllLines(filePath);
            
            for (int i = 0; i < lines.Length; i++)
            {
                Console.WriteLine($"Line {i + 1}: {lines[i]}");
            }
            
            // रैंडम एक्सेस संभव
            Console.WriteLine($"पहली लाइन: {lines[0]}");
            Console.WriteLine($"अंतिम लाइन: {lines[lines.Length - 1]}");
            
            Console.ReadLine();
        }
    }
}

आउटपुट (सभी विधियों के लिए)

Hi All!!
Hello Everyone!!
How are you?

तुलना: कौन सी विधि कब उपयोग करें?

एडवांस्ड: एन्कोडिंग के साथ File.ReadLines

// विशिष्ट एन्कोडिंग के साथ (डिफ़ॉल्ट UTF-8)
var lines = File.ReadLines(filePath, Encoding.GetEncoding("windows-1252"));

// .NET 6+ में
var lines = File.ReadLines(filePath, Encoding.UTF8);

एडवांस्ड: StreamReader के साथ Async पढ़ना

using System;
using System.IO;
using System.Text;
using System.Threading.Tasks;

public async Task ReadFileAsync(string filePath)
{
    using (var reader = new StreamReader(filePath, Encoding.UTF8))
    {
        string line;
        while ((line = await reader.ReadLineAsync()) != null)
        {
            Console.WriteLine(line);
            // Async प्रोसेसिंग यहां करें
        }
    }
}

एडवांस्ड: LINQ के साथ प्रोसेसिंग

using System.Linq;

// File.ReadLines के साथ LINQ (लेज़ी इवैल्यूएशन)
var longLines = File.ReadLines(filePath)
    .Where(line => line.Length > 80)
    .Select(line => line.Trim())
    .Take(100); // केवल पहली 100 लंबी लाइन्स

foreach (var line in longLines)
{
    Console.WriteLine(line);
}

// काउंट पाने के लिए (पूरी सीक्वेंस एन्यूमरेट करता है)
int totalLines = File.ReadLines(filePath).Count();

बेंचमार्क सारांश (सामान्य)

• सबसे तेज़ कच्ची गति: File.ReadAllLines (छोटी फाइलों के लिए, अनुकूलित नेटिव कोड)
• सबसे अच्छा मेमोरी: File.ReadLines या StreamReader (स्ट्रीमिंग)
• सबसे लचीला: StreamReader (एन्कोडिंग, बफर साइज, Async नियंत्रण)
• LINQ के लिए सर्वश्रेष्ठ: File.ReadLines (कंपोज़ेबल, लेज़ी)

सिफारिश: अधिकांश मामलों में File.ReadLines डिफ़ॉल्ट विकल्प होना चाहिए - यह मेमोरी-कुशल, LINQ-अनुकूल और उपयोग में सरल है।