Comment lire les dernières lignes "n" du fichier journal

besoin d'un extrait de code qui permettrait de lire le dernier "n" premières lignes d'un fichier journal. Je suis venu avec le code suivant à partir du net.Je suis un peu nouveau pour C sharp. Depuis le fichier journal peut être
assez grand, je veux éviter la surcharge de la lecture de la totalité du fichier.Quelqu'un peut-il suggérer toute amélioration de la performance. Je n'ont pas vraiment envie de lire chaque caractère et de changer de position.

   var reader = new StreamReader(filePath, Encoding.ASCII);
            reader.BaseStream.Seek(0, SeekOrigin.End);
            var count = 0;
            while (count <= tailCount)
            {
                if (reader.BaseStream.Position <= 0) break;
                reader.BaseStream.Position--;
                int c = reader.Read();
                if (reader.BaseStream.Position <= 0) break;
                reader.BaseStream.Position--;
                if (c == '\n')
                {
                    ++count;
                }
            }

            var str = reader.ReadToEnd();

source d'informationauteur frictionlesspulley

.net c#file-io performance

Votre code s'effectuer très mal, puisque vous n'êtes pas permettant à toute mise en cache à arriver.

En outre, il ne fonctionnera pas à tous les pour Unicode.

J'ai écrit la suite de la mise en œuvre:

///<summary>Returns the end of a text reader.</summary>
///<param name="reader">The reader to read from.</param>
///<param name="lineCount">The number of lines to return.</param>
///<returns>The last lneCount lines from the reader.</returns>
public static string[] Tail(this TextReader reader, int lineCount) {
    var buffer = new List<string>(lineCount);
    string line;
    for (int i = 0; i < lineCount; i++) {
        line = reader.ReadLine();
        if (line == null) return buffer.ToArray();
        buffer.Add(line);
    }

    int lastLine = lineCount - 1;           //The index of the last line read from the buffer.  Everything > this index was read earlier than everything <= this indes

    while (null != (line = reader.ReadLine())) {
        lastLine++;
        if (lastLine == lineCount) lastLine = 0;
        buffer[lastLine] = line;
    }

    if (lastLine == lineCount - 1) return buffer.ToArray();
    var retVal = new string[lineCount];
    buffer.CopyTo(lastLine + 1, retVal, 0, lineCount - lastLine - 1);
    buffer.CopyTo(0, retVal, lineCount - lastLine - 1, lastLine + 1);
    return retVal;
}

Un de mes amis utilise cette méthode (BackwardReader peut être trouvé ici):

public static IList<string> GetLogTail(string logname, string numrows)
{
    int lineCnt = 1;
    List<string> lines = new List<string>();
    int maxLines;

    if (!int.TryParse(numrows, out maxLines))
    {
        maxLines = 100;
    }

    string logFile = HttpContext.Current.Server.MapPath("~/" + logname);

    BackwardReader br = new BackwardReader(logFile);
    while (!br.SOF)
    {
        string line = br.Readline();
        lines.Add(line + System.Environment.NewLine);
        if (lineCnt == maxLines) break;
        lineCnt++;
    }
    lines.Reverse();
    return lines;
}

Voici ma réponse:-

    private string StatisticsFile = @"c:\yourfilename.txt";
//Read last lines of a file....
public IList<string> ReadLastLines(int nFromLine, int nNoLines, out bool bMore)
{
//Initialise more
bMore = false;
try
{
char[] buffer = null;
//lock (strMessages)  Lock something if you need to....
{
if (File.Exists(StatisticsFile))
{
//Open file
using (StreamReader sr = new StreamReader(StatisticsFile))
{
long FileLength = sr.BaseStream.Length;
int c, linescount = 0;
long pos = FileLength - 1;
long PreviousReturn = FileLength;
//Process file
while (pos >= 0 && linescount < nFromLine + nNoLines) //Until found correct place
{
//Read a character from the end
c = BufferedGetCharBackwards(sr, pos);
if (c == Convert.ToInt32('\n'))
{
//Found return character
if (++linescount == nFromLine)
//Found last place
PreviousReturn = pos + 1; //Read to here
}
//Previous char
pos--;
}
pos++;
//Create buffer
buffer = new char[PreviousReturn - pos];
sr.DiscardBufferedData();
//Read all our chars
sr.BaseStream.Seek(pos, SeekOrigin.Begin);
sr.Read(buffer, (int)0, (int)(PreviousReturn - pos));
sr.Close();
//Store if more lines available
if (pos > 0)
//Is there more?
bMore = true;
}
if (buffer != null)
{
//Get data
string strResult = new string(buffer);
strResult = strResult.Replace("\r", "");
//Store in List
List<string> strSort = new List<string>(strResult.Split('\n'));
//Reverse order
strSort.Reverse();
return strSort;
}
}
}
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine("ReadLastLines Exception:" + ex.ToString());
}
//Lets return a list with no entries
return new List<string>();
}
const int CACHE_BUFFER_SIZE = 1024;
private long ncachestartbuffer = -1;
private char[] cachebuffer = null;
//Cache the file....
private int BufferedGetCharBackwards(StreamReader sr, long iPosFromBegin)
{
//Check for error
if (iPosFromBegin < 0 || iPosFromBegin >= sr.BaseStream.Length)
return -1;
//See if we have the character already
if (ncachestartbuffer >= 0 && ncachestartbuffer <= iPosFromBegin && ncachestartbuffer + cachebuffer.Length > iPosFromBegin)
{
return cachebuffer[iPosFromBegin - ncachestartbuffer];
}
//Load into cache
ncachestartbuffer = (int)Math.Max(0, iPosFromBegin - CACHE_BUFFER_SIZE + 1);
int nLength = (int)Math.Min(CACHE_BUFFER_SIZE, sr.BaseStream.Length - ncachestartbuffer);
cachebuffer = new char[nLength];
sr.DiscardBufferedData();
sr.BaseStream.Seek(ncachestartbuffer, SeekOrigin.Begin);
sr.Read(cachebuffer, (int)0, (int)nLength);
return BufferedGetCharBackwards(sr, iPosFromBegin);
}

Remarque:-

Appel ReadLastLines avec nLineFrom en commençant à 0 pour la dernière ligne et nNoLines que le nombre de lignes à lire.
Il renverse la liste si le 1er est la dernière ligne dans le fichier.
bMore retourne true si il y a plus de lignes à lire.
Il met en cache les données en 1024 char morceaux - de sorte qu'il est rapide, vous souhaiterez peut-être augmenter cette taille pour les très gros fichiers.

Profitez-en!

Avait des problèmes avec votre code. C'est ma version. Depuis sa un fichier journal, quelque chose pourrait être écrit pour elle, il est donc préférable de s'assurer que vous n'êtes pas de la fermeture.

Vous allez à la fin. Démarrer la lecture vers l'arrière jusqu'à ce que vous atteignez n lignes. Puis tout lire à partir de là.

        int n = 5; //or any arbitrary number
int count = 0;
string content;
byte[] buffer = new byte[1];
using (FileStream fs = new FileStream("text.txt", FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
{
//read to the end.
fs.Seek(0, SeekOrigin.End);
//read backwards 'n' lines
while (count < n)
{
fs.Seek(-1, SeekOrigin.Current);
fs.Read(buffer, 0, 1);
if (buffer[0] == '\n')
{
count++;
}
fs.Seek(-1, SeekOrigin.Current); //fs.Read(...) advances the position, so we need to go back again
}
fs.Seek(1, SeekOrigin.Current); //go past the last '\n'
//read the last n lines
using (StreamReader sr = new StreamReader(fs))
{
content = sr.ReadToEnd();
}
}

0

Quelque chose que vous pouvez faire très facilement en C# 4.0 (et avec juste un tout petit peu d'effort dans les versions antérieures) est d'utiliser les fichiers mappés en mémoire pour ce type d'opération. Idéal pour les gros fichiers que vous pouvez associer à seulement une partie du fichier, puis accéder à la mémoire virtuelle.

Il y a un un bon exemple ici.
0

Votre journal ont des lignes de longueur similaire? Si oui, alors vous pouvez calculer la moyenne de la longueur de la ligne, puis effectuez les opérations suivantes:
1. chercher à end_of_file - lines_needed*avg_line_length (previous_point)
2. tout lire jusqu'à la fin
3. si vous attrapé assez de lignes, c'est très bien. Si non, chercher à previous_point - lines_needed*avg_line_length
4. tout lire jusqu'à previous_point
5. goto 3
fichier mappé en mémoire est aussi une bonne méthode -- carte de la queue de fichier, de calculer des lignes, la carte du volume précédent, calculer les lignes etc. jusqu'à ce que vous obtenir le nombre de lignes nécessaires
0

Ce n'est en aucune façon optimale, mais rapide et sale vérifie avec de petits fichiers de log, j'ai été en utilisant quelque chose comme ceci:
```
List<string> mostRecentLines = File.ReadLines(filePath)
//.Where(....)
//.Distinct()
.Reverse()
.Take(10)
.ToList()
```

Vous devez vous connecter pour publier un commentaire.