Comment lire un fichier entier dans une chaîne en utilisant C #?

Quelle est la façon la plus rapide de lire un fichier texte dans une variable chaîne?

Je comprends que cela peut être fait de plusieurs façons, telles que la lecture d'octets individuels, puis la conversion en chaîne. Je cherchais une méthode avec un codage minimal.

Que diriez-vous File.ReadAllText:

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

Une comparaison de référence de File.ReadAllLinesvs à StreamReader ReadLinepartir de la gestion des fichiers C #

Résultats. StreamReader est beaucoup plus rapide pour les fichiers volumineux de plus de 10 000 lignes, mais la différence pour les fichiers plus petits est négligeable. Comme toujours, planifiez différentes tailles de fichiers et utilisez File.ReadAllLines uniquement lorsque les performances ne sont pas critiques.

Approche StreamReader

Comme l' File.ReadAllTextapproche a été suggérée par d'autres, vous pouvez également essayer plus rapidement (je n'ai pas testé quantitativement l'impact sur les performances, mais il semble être plus rapide que File.ReadAllText(voir comparaison ci-dessous)). La différence de performances ne sera visible que dans le cas de fichiers plus volumineux.

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

Comparaison de File.Readxxx () et StreamReader.Readxxx ()

Affichage du code indicatif par ILSpy J'ai trouvé ce qui suit à propos File.ReadAllLines, File.ReadAllText.

• File.ReadAllText - Utilise en StreamReader.ReadToEndinterne
• File.ReadAllLines - Utilise également en StreamReader.ReadLineinterne avec la surcharge supplémentaire de créer le List<string>retour en tant que lignes de lecture et de boucler jusqu'à la fin du fichier.

Donc, les deux méthodes sont une couche supplémentaire de commodité construite sur StreamReader. Cela est évident par le corps indicatif de la méthode.

File.ReadAllText() implémentation décompilée par 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)

Voici la documentation MSDN

Jetez un œil à la méthode File.ReadAllText ()

Quelques remarques importantes:

Cette méthode ouvre un fichier, lit chaque ligne du fichier, puis ajoute chaque ligne en tant qu'élément d'une chaîne. Il ferme ensuite le fichier. Une ligne est définie comme une séquence de caractères suivie d'un retour chariot ('\ r'), d'un saut de ligne ('\ n') ou d'un retour chariot immédiatement suivi d'un saut de ligne. La chaîne résultante ne contient pas le retour chariot final et / ou le saut de ligne.

Cette méthode tente de détecter automatiquement l'encodage d'un fichier en fonction de la présence de marques d'ordre d'octets. Les formats d'encodage UTF-8 et UTF-32 (big-endian et little-endian) peuvent être détectés.

Utilisez la surcharge de la méthode ReadAllText (String, Encoding) lors de la lecture de fichiers pouvant contenir du texte importé, car les caractères non reconnus peuvent ne pas être lus correctement.

Le descripteur de fichier est garanti d'être fermé par cette méthode, même si des exceptions sont levées

string text = File.ReadAllText("Path");vous avez tout le texte dans une variable de chaîne. Si vous avez besoin de chaque ligne individuellement, vous pouvez utiliser ceci:

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

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

@Cris désolé .C'est une citation MSDN Microsoft

Méthodologie

Dans cette expérience, deux classes seront comparées. Le StreamReaderet la FileStreamclasse seront dirigés pour lire deux fichiers de 10K et 200K dans leur intégralité à partir du répertoire de l'application.

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

Résultat

FileStreamest évidemment plus rapide dans ce test. Il faut 50% de temps supplémentaire pour StreamReaderlire le petit fichier. Pour le gros fichier, cela a pris 27% de temps supplémentaire.

StreamReaderrecherche spécifiquement les sauts de ligne alors qu'il FileStreamn'en a pas Cela représentera une partie du temps supplémentaire.

Recommandations

Selon ce que l'application doit faire avec une section de données, une analyse supplémentaire peut nécessiter un temps de traitement supplémentaire. Considérez un scénario dans lequel un fichier a des colonnes de données et les lignes sont CR/LFdélimitées. Le StreamReadertravaillerait sur la ligne de texte à la recherche duCR/LF , puis l'application effectuerait une analyse supplémentaire à la recherche d'un emplacement spécifique des données. (Pensiez-vous que String. SubString est livré sans prix?)

D'un autre côté, le FileStreamlit les données en morceaux et un développeur proactif pourrait écrire un peu plus de logique pour utiliser le flux à son avantage. Si les données nécessaires se trouvent dans des positions spécifiques dans le fichier, c'est certainement la voie à suivre car cela réduit l'utilisation de la mémoire.

FileStream est le meilleur mécanisme de vitesse mais prendra plus de logique.

eh bien le moyen le plus rapide qui signifie avec le moins de code C # possible est probablement celui-ci:

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

si vous souhaitez choisir un fichier dans le dossier Bin de l'application, vous pouvez essayer de suivre et n'oubliez pas de gérer les exceptions.

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

vous pouvez utiliser :

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

Pour les noobs qui trouvent ce truc amusant et intéressant, le moyen le plus rapide de lire un fichier entier dans une chaîne dans la plupart des cas ( selon ces repères ) est le suivant:

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

Cependant, le plus rapide pour lire un fichier texte dans son ensemble semble être le suivant:

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

Confronté à plusieurs autres techniques , il l'emportait la plupart du temps, notamment contre le BufferedReader.

Vous pouvez utiliser comme ça

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

J'espère que ceci vous aidera.

vous pouvez lire un texte d'un fichier texte dans une chaîne comme suit également

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

                  }
              }
          }
      }
    }

J'ai fait une comparaison entre un ReadAllText et StreamBuffer pour un csv de 2 Mo et il semblait que la différence était assez petite mais ReadAllText semblait prendre le dessus sur le temps nécessaire pour terminer les fonctions.