Как прочитать весь файл в строку, используя C#?

эталонное сравнение File.ReadAllLines vs StreamReader ReadLine С обработка файлов C#

результаты. StreamReader намного быстрее для больших файлов с 10,000+ строки, но разница для небольших файлов незначительна. Как всегда, планируйте различные размеры файлов и используйте файл.ReadAllLines только когда производительность не критична.

StreamReader подход

As the File.ReadAllText подход был предложен другими, вы также можете попробовать быстрее (я не тестировал количественно влияние производительности, но, похоже, это быстрее, чем File.ReadAllText (см. сравнение ниже)). The разница в производительности будет видно только в случае больших файлов, хотя.

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

сравнение файлов.Readxxx () против StreamReader.Readxxx()

просмотр примерного код через помощью ILSpy я нашел следующее о File.ReadAllLines, File.ReadAllText.

• File.ReadAllText - использует StreamReader.ReadToEnd внутри
• File.ReadAllLines - тоже использует StreamReader.ReadLine внутренне с дополнительными накладными расходами на создание List<string> для возврата в виде прочитанных строк и зацикливания до конца файла.

Таким образом, оба метода являются дополнительный уровень удобства. построен на верх StreamReader. Это видно по показательной части метода.

File.ReadAllText() реализация как декомпилированная ILSpy

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)

здесь документация MSDN

посмотри .ReadAllText() метод

некоторые важные замечания:

этот метод открывает файл, считывает каждую строку файла, а затем добавляет каждая строка как элемент строки. Затем он закрывает файл. Линия определяется как последовательность символов возврата каретки ('\r'), подача строки ('\n') или возврат каретки сразу после этого по линии подачи. Результирующая строка не содержит завершающий возврата каретки и/или перевода строки.

этот метод пытается автоматически определить кодировку файла на основании наличия меток порядка байтов. Форматы кодирования UTF-8 и UTF-32 (и big-endian и little-endian) можно обнаружить.

используйте перегрузку метода ReadAllText(String, Encoding) при чтении файлы, которые могут содержать импортированный текст, поскольку не распознаны символы могут быть прочитаны неправильно.

дескриптор файла гарантированный быть закрытым этим методом, даже если возникают исключения

string text = File.ReadAllText("Path"); у вас есть весь текст в одну строковую переменную. Если вам нужна каждая строка отдельно, вы можете использовать это:

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

@Cris извините .Это цитата MSDN Microsoft

методология

в этом эксперименте будут сравниваться два класса. The StreamReader и FileStream класс будет направлен на чтение двух файлов 10K и 200K в полном объеме из каталога приложений.

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()

результат

FileStream - это очевидно быстрее в этом тесте. Это занимает еще 50% больше времени для StreamReader читать мелкий файл. Для большой файл, это заняло еще 27% времени.

StreamReader специально искал разрывы строк в то время как FileStream нет. Это объясняет часть дополнительного времени.

рекомендации

в зависимости от того, что приложение должно делать с разделом данных, может быть дополнительный синтаксический анализ, который потребует дополнительного времени обработки. Рассмотрим сценарий, в котором файл имеет столбцы данных, а строки -CR/LF запятыми. The StreamReader будет работать по строке текста, ища CR/LF, а затем приложение будет выполнять дополнительный синтаксический анализ, ища конкретное местоположение данных. (Вы подумали о струне. Субстрат приходит без цены?)

С другой стороны,FileStream читает данные порциями и активный разработчик мог бы написать немного больше логики, чтобы использовать поток в свою пользу. Если необходимые данные находятся в определенных позициях в файле, это, безусловно, путь, поскольку он сохраняет использование памяти вниз.

FileStream является лучшим механизмом для скорости, но займет больше логики.

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

ну самый быстрый способ, означающий с наименьшим возможным кодом C#, вероятно, это:

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

Если вы хотите выбрать файл из папки bin приложения, то вы можете попробовать следующее и не забудьте сделать обработку исключений.

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

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

для нубов, которые находят этот материал забавным и интересным, самый быстрый способ прочитать весь файл в строку в большинстве случаев (согласно этим критериям) является следующим:

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

тем не менее, абсолютный самый быстрый для чтения текстового файла в целом выглядит следующим образом:

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

противопоставить несколько других методов, он выиграл большую часть времени, в том числе против BufferedReader.

вы можете использовать :

 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);
    }
}

вы можете использовать такой

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 "";
        }
    }

надеюсь, это поможет вам.

вы можете прочитать текст из текстового файла в строку следующим образом также

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);
                      }

                  }
              }
          }
      }
    }

Я сделал сравнение между ReadAllText и StreamBuffer для csv 2 мб, и казалось, что разница была довольно небольшой, но ReadAllText, казалось, взял верх от времени, взятого для завершения функций.