Tüm dosyayı C # kullanarak bir dizeye okumak nasıl?

Bir metin dosyasını dize değişkenine okumanın en hızlı yolu nedir?

Ben bireysel bayt okumak ve daha sonra bu dizeye dönüştürmek gibi çeşitli şekillerde yapılabilir anlıyorum. Minimum kodlama ile bir yöntem arıyordum.

Nasıl olur File.ReadAllText:

string contents = File.ReadAllText(@"C:\temp\test.txt");

Bir kriter karşılaştırılması File.ReadAllLinesvs StreamReader ReadLineden C # dosya işleme

Sonuçlar. StreamReader, 10.000'den fazla satır içeren büyük dosyalar için çok daha hızlıdır, ancak daha küçük dosyalar için fark göz ardı edilebilir. Her zaman olduğu gibi, farklı boyutlardaki dosyaları planlayın ve File.ReadAllLines'i yalnızca performans kritik olmadığında kullanın.

StreamReader yaklaşımı

Gibi File.ReadAllTextyaklaşım başkaları tarafından ileri sürülmüştür, ayrıca deneyebilirsiniz hızlı (ı test etmedim nicel performans etkisini, ancak daha hızlı gibi görünüyor File.ReadAllText(bkz karşılaştırma ) aşağıda). Fark performansında olsa sadece büyük dosyalar halinde görünür olacaktır.

string readContents;
using (StreamReader streamReader = new StreamReader(path, Encoding.UTF8))
{
     readContents = streamReader.ReadToEnd();
}

File.Readxxx () ile StreamReader.Readxxx () karşılaştırması

Aracılığıyla gösterge kod görüntüleniyor ILSpy ben hakkında aşağıdaki bulduk File.ReadAllLines, File.ReadAllText.

• File.ReadAllText - StreamReader.ReadToEndDahili olarak kullanır
• File.ReadAllLines - Ayrıca StreamReader.ReadLinedahili List<string>olarak kullanarak okuma satırları olarak dönmek ve dosya sonuna kadar döngü ek yükü ile kullanır .

Yani her iki yöntem de üzerine inşa edilmiş ek bir rahatlık katmanıdırStreamReader . Bu, yöntemin gösterge organı tarafından belirgindir.

File.ReadAllText() ILSpy tarafından ayrıştırıldığı şekliyle uygulama

public static string ReadAllText(string path)
{
    if (path == null)
    {
        throw new ArgumentNullException("path");
    }
    if (path.Length == 0)
    {
        throw new ArgumentException(Environment.GetResourceString("Argument_EmptyPath"));
    }
    return File.InternalReadAllText(path, Encoding.UTF8);
}   

private static string InternalReadAllText(string path, Encoding encoding)
{
    string result;
    using (StreamReader streamReader = new StreamReader(path, encoding))
    {
        result = streamReader.ReadToEnd();
    }
    return result;
}

string contents = System.IO.File.ReadAllText(path)

İşte MSDN belgeleri

File.ReadAllText () yöntemine göz atın

Bazı önemli açıklamalar:

Bu yöntem bir dosyayı açar, dosyanın her satırını okur ve ardından her satırı bir dizenin öğesi olarak ekler. Daha sonra dosyayı kapatır. Satır, bir satır sırası ('\ r'), satır beslemesi ('\ n') veya hemen satır satırından sonra gelen satır beslemesi gelen bir karakter dizisi olarak tanımlanır. Sonuçta elde edilen dize, sonlandırıcı satır başı ve / veya satır beslemesi içermez.

Bu yöntem, bayt sırası işaretlerinin varlığına bağlı olarak bir dosyanın kodlamasını otomatik olarak algılamaya çalışır. UTF-8 ve UTF-32 kodlama formatları (hem büyük endian hem de küçük endian) tespit edilebilir.

Tanınmayan karakterler doğru okunamayabileceğinden, içe aktarılan metin içerebilecek dosyaları okurken ReadAllText (String, Encoding) yönteminin aşırı yüklenmesini kullanın.

İstisnalar artırılsa bile dosya tanıtıcısının bu yöntemle kapatılması garanti edilir

string text = File.ReadAllText("Path");tüm metni tek bir dize değişkeninde bulabilirsiniz. Her satıra ayrı ayrı ihtiyacınız varsa bunu kullanabilirsiniz:

string[] lines = File.ReadAllLines("Path");

System.IO.StreamReader myFile =
   new System.IO.StreamReader("c:\\test.txt");
string myString = myFile.ReadToEnd();

@Cris özür dilerim. MSDN Microsoft

metodoloji

Bu deneyde iki sınıf karşılaştırılacaktır. StreamReaderVe FileStreamsınıf uygulaması dizinden bütünüyle 10K ve 200K iki dosya okumak için yönlendirilecektir.

StreamReader (VB.NET)

sr = New StreamReader(strFileName)
Do
  line = sr.ReadLine()
Loop Until line Is Nothing
sr.Close()

FileStream (VB.NET)

Dim fs As FileStream
Dim temp As UTF8Encoding = New UTF8Encoding(True)
Dim b(1024) As Byte
fs = File.OpenRead(strFileName)
Do While fs.Read(b, 0, b.Length) > 0
    temp.GetString(b, 0, b.Length)
Loop
fs.Close()

Sonuç

FileStreamBu testte açıkça daha hızlı. StreamReaderKüçük dosyayı okumak % 50 daha fazla zaman alır . Büyük dosya için% 27 daha fazla zaman aldı.

StreamReaderözellikle satır sonları arıyor FileStream, değil. Bu, ekstra sürenin bir kısmını açıklayacaktır.

öneriler

Uygulamanın bir veri bölümü ile ne yapması gerektiğine bağlı olarak, ek işlem süresi gerektiren ek ayrıştırmalar olabilir. Bir dosyanın veri sütunlarına sahip olduğu ve satırların CR/LFsınırlandığı bir senaryo düşünün . Bu StreamReader, metni arayan metin satırında çalışacak CR/LFve daha sonra uygulama, belirli bir veri konumu arayan ek ayrıştırma yapacaktır. (String'i düşündün mü? SubString bedelsiz geliyor mu?)

Öte yandan, FileStreamparçalardaki verileri okur ve proaktif bir geliştirici, akışı yararına kullanmak için biraz daha mantık yazabilir. Gerekli veriler dosyada belirli konumlarda bulunuyorsa, bu kesinlikle bellek kullanımını azalttığı için gitmenin yoludur.

FileStream hız için daha iyi bir mekanizmadır, ancak daha fazla mantık gerektirir.

iyi mümkün olan en az C # kodu ile hızlı yolu muhtemelen bu:

string readText = System.IO.File.ReadAllText(path);

Uygulamanın Bin klasöründen dosya almak istiyorsanız, takip etmeyi deneyebilir ve istisna işleme yapmayı unutmayın.

string content = File.ReadAllText(Path.Combine(System.IO.Directory.GetCurrentDirectory(), @"FilesFolder\Sample.txt"));

kullanabilirsiniz :

 public static void ReadFileToEnd()
{
    try
    {
    //provide to reader your complete text file
        using (StreamReader sr = new StreamReader("TestFile.txt"))
        {
            String line = sr.ReadToEnd();
            Console.WriteLine(line);
        }
    }
    catch (Exception e)
    {
        Console.WriteLine("The file could not be read:");
        Console.WriteLine(e.Message);
    }
}

string content = System.IO.File.ReadAllText( @"C:\file.txt" );

Bu şeyleri eğlenceli ve ilginç bulan noobs için, bir dosyayı tüm durumlarda bir dizeye okumanın en hızlı yolu ( bu kriterlere göre ) aşağıdaki gibidir:

using (StreamReader sr = File.OpenText(fileName))
{
        string s = sr.ReadToEnd();
}
//you then have to process the string

Ancak, genel olarak bir metin dosyasını okumak için en hızlı olanı aşağıdaki gibi görünür:

using (StreamReader sr = File.OpenText(fileName))
{
        string s = String.Empty;
        while ((s = sr.ReadLine()) != null)
        {
               //do what you have to here
        }
}

Diğer bazı tekniklere karşı koymak , BufferedReader da dahil olmak üzere çoğu zaman kazandı.

Bu şekilde kullanabilirsiniz

public static string ReadFileAndFetchStringInSingleLine(string file)
    {
        StringBuilder sb;
        try
        {
            sb = new StringBuilder();
            using (FileStream fs = File.Open(file, FileMode.Open))
            {
                using (BufferedStream bs = new BufferedStream(fs))
                {
                    using (StreamReader sr = new StreamReader(bs))
                    {
                        string str;
                        while ((str = sr.ReadLine()) != null)
                        {
                            sb.Append(str);
                        }
                    }
                }
            }
            return sb.ToString();
        }
        catch (Exception ex)
        {
            return "";
        }
    }

Umarım bu size yardımcı olacaktır.

bir metin dosyasından dizeye bir metni aşağıdaki gibi de okuyabilirsiniz

string str = "";
StreamReader sr = new StreamReader(Application.StartupPath + "\\Sample.txt");
while(sr.Peek() != -1)
{
  str = str + sr.ReadLine();
}

public partial class Testfile : System.Web.UI.Page
{
    public delegate void DelegateWriteToDB(string Inputstring);
    protected void Page_Load(object sender, EventArgs e)
    {
        getcontent(@"C:\Working\Teradata\New folder");
    }

      private void SendDataToDB(string data)
    {
        //InsertIntoData
          //Provider=SQLNCLI10.1;Integrated Security=SSPI;Persist Security Info=False;User ID="";Initial Catalog=kannan;Data Source=jaya;
        SqlConnection Conn = new SqlConnection("Data Source=aras;Initial Catalog=kannan;Integrated Security=true;");
        SqlCommand cmd = new SqlCommand();
        cmd.Connection = Conn;
        cmd.CommandType = CommandType.Text;
        cmd.CommandText = "insert into test_file values('"+data+"')";
        cmd.Connection.Open();
        cmd.ExecuteNonQuery();
        cmd.Connection.Close();
    }

      private void getcontent(string path)
      {
          string[] files;
          files = Directory.GetFiles(path, "*.txt");
          StringBuilder sbData = new StringBuilder();
          StringBuilder sbErrorData = new StringBuilder();
          Testfile df = new Testfile();
          DelegateWriteToDB objDelegate = new DelegateWriteToDB(df.SendDataToDB);
          //dt.Columns.Add("Data",Type.GetType("System.String"));


          foreach (string file in files)
          {
              using (StreamReader sr = new StreamReader(file))
              {
                  String line;
                  int linelength;
                  string space = string.Empty;

                  // Read and display lines from the file until the end of 
                  // the file is reached.
                  while ((line = sr.ReadLine()) != null)
                  {
                      linelength = line.Length;
                      switch (linelength)
                      {
                          case 5:
                              space = "     ";
                              break;

                      }
                      if (linelength == 5)
                      {
                          IAsyncResult ObjAsynch = objDelegate.BeginInvoke(line + space, null, null);
                      }
                      else if (linelength == 10)
                      {
                          IAsyncResult ObjAsynch = objDelegate.BeginInvoke(line , null, null);
                      }

                  }
              }
          }
      }
    }

Ben 2Mb csv için bir ReadAllText ve StreamBuffer arasında bir karşılaştırma yaptım ve fark oldukça küçük görünüyordu ama ReadAllText fonksiyonları tamamlamak için alınan sürelerden üst el almak gibi görünüyordu.