Comment lire un fichier entier sur une chaîne en utilisant C #?
Quel est le moyen le plus rapide de lire un fichier texte dans une variable chaîne?
Je comprends que cela peut être fait de plusieurs manières, telles que lire des octets individuels puis les convertir en chaîne. Je cherchais une méthode avec un codage minimal.
Que diriez-vous
string contents = File.ReadAllText(@"C:\temp\test.txt");
Une comparaison de référence de _File.ReadAllLines_ et _StreamReader ReadLine_ à partir de Traitement de fichier C #
Résultats. StreamReader est beaucoup plus rapide pour les fichiers volumineux de 10 000 lignes ou plus, mais la différence pour les fichiers plus petits est négligeable. Comme toujours, prévoyez des tailles de fichiers variables et utilisez File.ReadAllLines uniquement lorsque les performances ne sont pas critiques.
Approche StreamReader
Comme l’approche _File.ReadAllText_ 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 in performance 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 ()
Visualisation du code indicatif via ILSpy J'ai trouvé ce qui suit concernant _File.ReadAllLines_, _File.ReadAllText_.
File.ReadAllText- Utilise _StreamReader.ReadToEnd_ en interneFile.ReadAllLines- Utilise également _StreamReader.ReadLine_ en interne avec la surcharge supplémentaire liée à la création de _List<string>_ à retourner en tant que lignes de lecture. et en boucle jusqu'à la fin du fichier.
Les deux méthodes sont donc une couche de commodité supplémentaire construite sur StreamReader. Ceci est évident dans 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 le documentation MSDN
Regardez 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 suivi immédiatement d'un saut de ligne. La chaîne résultante ne contient pas le retour chariot et/ou le saut de ligne.
Cette méthode tente de détecter automatiquement le codage d'un fichier en fonction de la présence de marques d'ordre des octets. Les formats de codage 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 risquent de 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 chaîne. Si vous avez besoin de chaque ligne individuellement, vous pouvez utiliser ceci:
string[] lines = File.ReadAllLines("Path");
@Cris désolé. Ceci est la citation MSDN Microsoft
Méthodologie
Dans cette expérience, deux classes seront comparées. Les classes StreamReader et FileStream seront dirigées de manière à 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
FileStream est évidemment plus rapide dans ce test. Il faut 50% de plus de temps pour que StreamReader lise le petit fichier. Pour le fichier volumineux, cela a pris 27% de temps supplémentaire.
StreamReader recherche spécifiquement des sauts de ligne alors que FileStream ne le fait pas. Cela représentera une partie du temps supplémentaire.
Recommandations
En fonction de ce que l'application doit faire avec une section de données, des analyses supplémentaires peuvent nécessiter un temps de traitement supplémentaire. Envisagez un scénario dans lequel un fichier contient des colonnes de données et où les lignes sont délimitées CR/LF. La StreamReader travaillera sur la ligne de texte à la recherche du CR/LF, puis l'application effectuera une analyse complémentaire pour rechercher un emplacement spécifique de données. (Avez-vous pensé à String. SubString est livré sans prix?)
D'autre part, le FileStream lit 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 à des positions spécifiques dans le fichier, il s'agit certainement de la meilleure solution car elle réduit l'utilisation de la mémoire.
FileStream est le meilleur mécanisme pour la vitesse mais prendra plus de logique.
System.IO.StreamReader myFile =
new System.IO.StreamReader("c:\\test.txt");
string myString = myFile.ReadToEnd();
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);
}
}
si vous voulez choisir un fichier dans le dossier Bin de l'application, essayez de suivre et n'oubliez pas de gérer les exceptions.
string content = File.ReadAllText(Path.Combine(System.IO.Directory.GetCurrentDirectory(), @"FilesFolder\Sample.txt"));
eh bien, le moyen le plus rapide de dire avec le moins de code C # possible est probablement celui-ci:
string readText = System.IO.File.ReadAllText(path);
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 cela vous aidera.
Pour les noobs qui trouvent ce contenu 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 critères ) est le suivant:
using (StreamReader sr = File.OpenText(fileName))
{
string s = sr.ReadToEnd();
}
//you then have to process the string
Cependant, dans l’ensemble, le plus rapide à lire un fichier texte 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
}
}
mis en place avec plusieurs autres techniques , il a gagné la plupart du temps, y compris contre BufferedReader.
string content = System.IO.File.ReadAllText( @"C:\file.txt" );
vous pouvez lire un texte d'un fichier texte en chaîne comme suit
string str = "";
StreamReader sr = new StreamReader(Application.StartupPath + "\\Sample.txt");
while(sr.Peek() != -1)
{
str = str + sr.ReadLine();
}
J'ai fait une comparaison entre ReadAllText et StreamBuffer pour un fichier csv de 2 Mo. Il semblait que la différence était assez petite, mais ReadAllText semblait prendre le dessus sur le temps pris pour compléter des fonctions.
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);
}
}
}
}
}
}