¿Cómo leer un archivo completo en una cadena usando C #?

¿Cuál es la forma más rápida de leer un archivo de texto en una variable de cadena?

Entiendo que se puede hacer de varias maneras, como leer bytes individuales y luego convertirlos en cadenas. Estaba buscando un método con encoding mínima.

Qué tal si

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

Una comparación de referencia de File.ReadAllLines vs StreamReader ReadLine desde el manejo de archivos C #

Comparación de lectura de archivos

Resultados. StreamReader es mucho más rápido para archivos grandes con más de 10.000 líneas, pero la diferencia para archivos más pequeños es insignificante. Como siempre, planifique diferentes tamaños de archivos y use File.ReadAllLines solo cuando el rendimiento no sea crítico.

Enfoque de StreamReader

Como el enfoque File.ReadAllText ha sido sugerido por otros, también puede probarlo más rápido (no he probado cuantitativamente el impacto en el rendimiento, pero parece ser más rápido que File.ReadAllText (ver comparación a continuación)). La diferencia en el rendimiento será visible solo en el caso de archivos más grandes.

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

Comparación de File.Readxxx () vs StreamReader.Readxxx ()

Viendo el código indicativo a través de ILSpy , he encontrado lo siguiente sobre File.ReadAllLines , File.ReadAllText .

  • File.ReadAllText – Utiliza StreamReader.ReadToEnd internamente
  • File.ReadAllLines : también utiliza StreamReader.ReadLine internamente con la carga adicional de crear la List para devolver como líneas de lectura y bucles hasta el final del archivo.

Entonces ambos métodos son una capa adicional de conveniencia construida sobre StreamReader . Esto es evidente por el cuerpo indicativo del método.

File.ReadAllText() descomstackda por 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) 

Aquí está la documentación de MSDN

Eche un vistazo al método File.ReadAllText ()

Algunos comentarios importantes:

Este método abre un archivo, lee cada línea del archivo y luego agrega cada línea como un elemento de una cadena. Luego cierra el archivo. Una línea se define como una secuencia de caracteres seguida de un retorno de carro (‘\ r’), un avance de línea (‘\ n’) o un retorno de carro seguido inmediatamente de un avance de línea. La cadena resultante no contiene el retorno de carro de terminación y / o el avance de línea.

Este método intenta detectar automáticamente la encoding de un archivo en función de la presencia de marcas de orden de bytes. Se pueden detectar formatos de encoding UTF-8 y UTF-32 (tanto big-endian como little-endian).

Utilice la sobrecarga del método ReadAllText (String, Encoding) cuando lea archivos que puedan contener texto importado, ya que los caracteres no reconocidos pueden no leerse correctamente.

Se garantiza que el identificador de archivo se cerrará con este método, incluso si se generan excepciones

string text = File.ReadAllText("Path"); tienes todo el texto en una variable de cadena. Si necesita cada línea individualmente, puede usar esto:

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

@Cris lo siento. Esto es citar a MSDN Microsoft

Metodología

En este experimento, se compararán dos clases. El StreamReader y la clase FileStream serán dirigidos a leer dos archivos de 10K y 200K en su totalidad desde el directorio de la aplicación.

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

Resultado

enter image description here

FileStream es obviamente más rápido en esta prueba. Demora un 50% más de tiempo para que StreamReader lea el archivo pequeño. Para el archivo grande, tomó un 27% adicional del tiempo.

StreamReader está específicamente buscando saltos de línea mientras FileStream no lo hace. Esto explicará parte del tiempo extra.

Recomendaciones

Dependiendo de lo que la aplicación necesite hacer con una sección de datos, puede haber un análisis adicional que requerirá tiempo de procesamiento adicional. Considere un escenario donde un archivo tiene columnas de datos y las filas están delimitadas por CR/LF . StreamReader trabajaría en la línea de texto buscando el CR/LF , y luego la aplicación haría un análisis adicional en busca de una ubicación específica de datos. (¿Crees que String. SubString viene sin un precio?)

Por otro lado, FileStream lee los datos en fragmentos y un desarrollador proactivo podría escribir un poco más de lógica para usar la transmisión en su beneficio. Si los datos necesarios se encuentran en posiciones específicas en el archivo, este es sin duda el camino a seguir, ya que mantiene el uso de la memoria baja.

FileStream es el mejor mecanismo para la velocidad pero tendrá más lógica.

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

bueno, la manera más rápida de decir con el menor código posible de C # es probablemente esta:

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

si desea elegir el archivo de la carpeta Bin de la aplicación, puede intentar seguirlo y no olvide hacer un manejo de excepciones.

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

Para los noobs que encuentran esta cosa divertida e interesante, la manera más rápida de leer un archivo completo en una cadena en la mayoría de los casos (de acuerdo con estos puntos de referencia ) es la siguiente:

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

Sin embargo, el absoluto más rápido para leer un archivo de texto en general parece ser el siguiente:

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

En contraste con muchas otras técnicas , ganó la mayor parte del tiempo, incluso contra el BufferedReader.

puedes usar :

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

Puedes usar así

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

Espero que esto te ayudará.

puede leer un texto de un archivo de texto en una cadena de la siguiente manera también

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

Hice una comparación entre ReadAllText y StreamBuffer para una csv de 2Mb y parecía que la diferencia era bastante pequeña, pero ReadAllText parecía tomar ventaja de los tiempos necesarios para completar las funciones.