En supposant que vous lisez à partir d'un flux ici est un exemple (non parfait) de la façon de le faire ... Fondamentalement, le ProgressStreamWrapper encapsule le flux de fichier et déclenche un événement chaque fois que la position est modifiée.
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Reading big file...");
FileStream fileStream = File.OpenRead("c:\\temp\\bigfile.xml");
ProgressStreamWrapper progressStreamWrapper = new ProgressStreamWrapper(fileStream);
progressStreamWrapper.PositionChanged += (o, ea) => Console.WriteLine((double) progressStreamWrapper.Position/progressStreamWrapper.Length * 100 + "% complete");
XmlReader xmlReader = XmlReader.Create(progressStreamWrapper);
while (xmlReader.Read())
{
//read the xml document
}
Console.WriteLine("DONE");
Console.ReadLine();
}
}
public class ProgressStreamWrapper : Stream, IDisposable
{
public ProgressStreamWrapper(Stream innerStream)
{
InnerStream = innerStream;
}
public Stream InnerStream { get; private set; }
public override void Close()
{
InnerStream.Close();
}
void IDisposable.Dispose()
{
base.Dispose();
InnerStream.Dispose();
}
public override void Flush()
{
InnerStream.Flush();
}
public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
{
return InnerStream.BeginRead(buffer, offset, count, callback, state);
}
public override int EndRead(IAsyncResult asyncResult)
{
int endRead = InnerStream.EndRead(asyncResult);
OnPositionChanged();
return endRead;
}
public override IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
{
return InnerStream.BeginWrite(buffer, offset, count, callback, state);
}
public override void EndWrite(IAsyncResult asyncResult)
{
InnerStream.EndWrite(asyncResult);
OnPositionChanged(); ;
}
public override long Seek(long offset, SeekOrigin origin)
{
long seek = InnerStream.Seek(offset, origin);
OnPositionChanged();
return seek;
}
public override void SetLength(long value)
{
InnerStream.SetLength(value);
}
public override int Read(byte[] buffer, int offset, int count)
{
int read = InnerStream.Read(buffer, offset, count);
OnPositionChanged();
return read;
}
public override int ReadByte()
{
int readByte = InnerStream.ReadByte();
OnPositionChanged();
return readByte;
}
public override void Write(byte[] buffer, int offset, int count)
{
InnerStream.Write(buffer, offset, count);
OnPositionChanged();
}
public override void WriteByte(byte value)
{
InnerStream.WriteByte(value);
OnPositionChanged();
}
public override bool CanRead
{
get { return InnerStream.CanRead; }
}
public override bool CanSeek
{
get { return InnerStream.CanSeek; }
}
public override bool CanTimeout
{
get { return InnerStream.CanTimeout; }
}
public override bool CanWrite
{
get { return InnerStream.CanWrite; }
}
public override long Length
{
get { return InnerStream.Length; }
}
public override long Position
{
get { return InnerStream.Position; }
set
{
InnerStream.Position = value;
OnPositionChanged();
}
}
public event EventHandler PositionChanged;
protected virtual void OnPositionChanged()
{
if (PositionChanged != null)
{
PositionChanged(this, EventArgs.Empty);
}
}
public override int ReadTimeout
{
get { return InnerStream.ReadTimeout; }
set { InnerStream.ReadTimeout = value; }
}
public override int WriteTimeout
{
get { return InnerStream.WriteTimeout; }
set { InnerStream.WriteTimeout = value; }
}
}
Où chargez-vous ces fichiers, dans un DOM/Database ou autre chose? Êtes-vous en train de les lire et de les traiter nœud par nœud ou en les mettant en mémoire? – A9S6
Je suppose que j'oublie de mettre quelques informations: Je charge ces fichiers XML pour une API (j'ai source, mais je préfère ne pas éditer la logique/analyse) qui analysent le fichier (principalement avec Xpath). Cette API accepte dans XML param un chemin vers un fichier XML (et utilise XmlReader) ou un Stream. Je ne m'intéresse pas vraiment au processus d'analyse qui est rapide, en me concentrant uniquement sur le chargement en mémoire. – camous
XmlReader ne prend pas en charge XPath, et fournit uniquement un accès série ... si vous avez besoin d'un traitement plus sophistiqué, vous pouvez utiliser XPathNaviator, ou si l'utilisation de la mémoire est importante, essayez vtd-xml –