Messenger/Versions/Less Closed Beta/v2.0/Post-Cleanup/MSGer.tk (C#)/ProgressStatistic.cs

358 lines
13 KiB
C#
Raw Normal View History

2014-07-12 08:53:00 +00:00
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace HdSystemLibrary.IO
{
public class ProgressEventArgs : EventArgs
{
public ProgressEventArgs(ProgressStatistic progressStatistic)
{
if (progressStatistic == null)
throw new ArgumentNullException("progressStatistic");
ProgressStatistic = progressStatistic;
}
public ProgressStatistic ProgressStatistic { get; private set; }
}
[Serializable]
public class OperationAlreadyStartedException : Exception
{
public OperationAlreadyStartedException() { }
public OperationAlreadyStartedException(string message) : base(message) { }
public OperationAlreadyStartedException(string message, Exception inner) : base(message, inner) { }
protected OperationAlreadyStartedException(
System.Runtime.Serialization.SerializationInfo info,
System.Runtime.Serialization.StreamingContext context)
: base(info, context) { }
}
/// <summary>
/// A class which calculates progress statistics like average bytes per second or estimated finishing time.
/// To use it, call the ProgressChange method in regular intervals with the actual progress.
/// </summary>
public class ProgressStatistic
{
public ProgressStatistic()
{
StartingTime = DateTime.MinValue;
FinishingTime = DateTime.MinValue;
progressChangedArgs = new ProgressEventArgs(this); //Event args can be cached
}
private bool hasStarted = false;
/// <summary>
/// Gets whether the operation has started
/// </summary>
public bool HasStarted { get { return hasStarted; } }
/// <summary>
/// Gets whether the operation has finished
/// </summary>
public bool HasFinished { get { return FinishingTime != DateTime.MinValue; } }
/// <summary>
/// Gets whether the operation is still running
/// </summary>
public bool IsRunning { get { return HasStarted && !HasFinished; } }
#region Time
/// <summary>
/// Gets the date time when the operation has started
/// </summary>
public DateTime StartingTime { get; private set; }
/// <summary>
/// Gets the date time when the operation has finished
/// </summary>
public DateTime FinishingTime { get; private set; }
/// <summary>
/// Gets the duration of the operation.
/// If the operation is still running, the time since starting is returned.
/// If the operation has not started, TimeSpan.Zero is returned.
/// If the operation has finished, the time between starting and finishing is returned.
/// </summary>
public TimeSpan Duration
{
get
{
if (!HasStarted)
return TimeSpan.Zero;
else if (!HasFinished)
return DateTime.Now - StartingTime;
else
return FinishingTime - StartingTime;
}
}
/// <summary>
/// The method which will be used for estimating duration and finishing time
/// </summary>
public enum EstimatingMethod
{
/// <summary>
/// Current bytes per second will be used for estimating.
/// </summary>
CurrentBytesPerSecond,
/// <summary>
/// Average bytes per second will be used for estimating
/// </summary>
AverageBytesPerSecond
}
private EstimatingMethod estimatingMethod = EstimatingMethod.CurrentBytesPerSecond;
/// <summary>
/// Gets or sets which method will be used for estimating.
/// Can only be set before the operation has started, otherwise an OperationAlreadyStartedException will be thrown.
/// </summary>
public EstimatingMethod UsedEstimatingMethod
{
get { return estimatingMethod; }
set
{
if (HasStarted)
throw new OperationAlreadyStartedException();
estimatingMethod = value;
}
}
/// <summary>
/// Gets the estimated duration. Use UsedEstimatingMethod to specify which method will be used for estimating.
/// If the operation will take more than 200 days, TimeSpan.MaxValue is returned.
/// </summary>
public TimeSpan EstimatedDuration
{
get
{
if (HasFinished)
return Duration;
if (TotalBytesToRead == -1)
return TimeSpan.MaxValue;
double bytesPerSecond = 1;
if (UsedEstimatingMethod == EstimatingMethod.AverageBytesPerSecond)
bytesPerSecond = AverageBytesPerSecond;
else if (UsedEstimatingMethod == EstimatingMethod.CurrentBytesPerSecond)
bytesPerSecond = CurrentBytesPerSecond;
double seconds = (TotalBytesToRead - BytesRead) / bytesPerSecond;
if (seconds > 60 * 60 * 24 * 200) //over 200 Days -> infinite
return TimeSpan.MaxValue;
else
return Duration + TimeSpan.FromSeconds(seconds);
}
}
/// <summary>
/// Gets the estimated finishing time based on EstimatedDuration.
/// If the operation will take more than 200 days, DateTime.MaxValue is returned.
/// If the operation has finished, the actual finishing time is returned.
/// </summary>
public DateTime EstimatedFinishingTime
{
get
{
if (EstimatedDuration == TimeSpan.MaxValue)
return DateTime.MaxValue;
return StartingTime + EstimatedDuration;
}
}
#endregion
/// <summary>
/// Gets the amount of bytes already read.
/// </summary>
public long BytesRead { get; private set; }
/// <summary>
/// Gets the amount of total bytes to read. Can be -1 if unknown.
/// </summary>
public long TotalBytesToRead { get; private set; }
/// <summary>
/// Gets the progress in percent between 0 and 1.
/// If the amount of total bytes to read is unknown, -1 is returned.
/// </summary>
public double Progress
{
get
{
if (TotalBytesToRead == -1)
return -1;
else
return (double)BytesRead / (double)TotalBytesToRead;
}
}
/// <summary>
/// Gets the average bytes per second.
/// </summary>
public double AverageBytesPerSecond { get { return (double)BytesRead / Duration.TotalSeconds; } }
#region CurrentBytesPerSecond
/// <summary>
/// Gets the approximated current count of bytes processed per second
/// </summary>
public double CurrentBytesPerSecond { get; private set; }
private TimeSpan currentBytesCalculationInterval = TimeSpan.FromSeconds(0.5);
/// <summary>
/// Gets or sets the interval used for the calculation of the current bytes per second. Default is 500 ms.
/// </summary>
/// <exception cref="OperationAlreadyStartedException">
/// Thrown when trying to set although the operation has already started.</exception>
public TimeSpan CurrentBytesCalculationInterval
{
get { return currentBytesCalculationInterval; }
set
{
if (HasStarted)
throw new InvalidOperationException("Task has already started!");
currentBytesCalculationInterval = value;
}
}
KeyValuePair<DateTime, long>[] currentBytesSamples = new KeyValuePair<DateTime, long>[6];
/// <summary>
/// Gets or sets the number of samples in CurrentBytesPerSecondInterval used for current bytes per second approximation
/// </summary>
/// <exception cref="OperationAlreadyStartedException">
/// Thrown when trying to set although the operation has already started.</exception>
public int CurrentBytesSampleCount
{
get { return currentBytesSamples.Length; }
set
{
if (HasStarted)
throw new InvalidOperationException("Task has already started!");
if (value != currentBytesSamples.Length)
{
currentBytesSamples = new KeyValuePair<DateTime, long>[value];
}
}
}
int currentSample = 0; //current sample index in currentBytesSamples
DateTime lastSample;
private void ProcessSample(long bytes)
{
if ((DateTime.Now - lastSample).Ticks > CurrentBytesCalculationInterval.Ticks / currentBytesSamples.Length)
{
lastSample = DateTime.Now;
KeyValuePair<DateTime, long> current = new KeyValuePair<DateTime, long>(DateTime.Now, bytes);
var old = currentBytesSamples[currentSample];
currentBytesSamples[currentSample] = current;
if (old.Key == DateTime.MinValue)
CurrentBytesPerSecond = AverageBytesPerSecond;
else
CurrentBytesPerSecond = (double)(current.Value - old.Value) / (current.Key - old.Key).TotalSeconds;
currentSample++;
if (currentSample >= currentBytesSamples.Length)
currentSample = 0;
}
}
#endregion
/// <summary>
/// This method can be called to report progress changes.
/// The signature of this method is compliant with the ProgressChange-delegate
/// </summary>
/// <param name="bytesRead">The amount of bytes already read</param>
/// <param name="totalBytesToRead">The amount of total bytes to read. Can be -1 if unknown.</param>
/// <exception cref="ArgumentException">Thrown if bytesRead has not changed or even shrunk.</exception>
/// <exception cref="InvalidOperationException">Thrown if the operation has finished already.</exception>
public virtual void ProgressChange(long bytesRead, long totalBytesToRead)
{
if (bytesRead <= BytesRead)
throw new ArgumentException("Operation cannot go backwards!", "bytesRead");
if (HasFinished)
throw new InvalidOperationException("Operation has finished already!");
if (!hasStarted)
{
StartingTime = DateTime.Now;
hasStarted = true;
OnStarted();
}
BytesRead = bytesRead;
TotalBytesToRead = totalBytesToRead;
ProcessSample(bytesRead);
OnProgressChanged();
if (bytesRead == TotalBytesToRead)
{
FinishingTime = DateTime.Now;
OnFinished();
}
}
/// <summary>
/// This method can be called to finish an aborted operation.
/// If the operation does not reach 100%, "Finished" will be never raised, so this method should be called.
/// </summary>
public virtual void Finish()
{
if (!HasFinished)
{
FinishingTime = DateTime.Now;
OnFinished();
}
}
#region Events
private readonly ProgressEventArgs progressChangedArgs;
protected virtual void OnStarted()
{
if (Started != null)
Started(this, progressChangedArgs);
}
protected virtual void OnProgressChanged()
{
if (ProgressChanged != null)
ProgressChanged(this, progressChangedArgs);
}
protected virtual void OnFinished()
{
if (Finished != null)
Finished(this, progressChangedArgs);
}
/// <summary>
/// Will be raised when the operation has started
/// </summary>
public event EventHandler<ProgressEventArgs> Started;
/// <summary>
/// Will be raised when the progress has changed
/// </summary>
public event EventHandler<ProgressEventArgs> ProgressChanged;
/// <summary>
/// Will be raised when the operation has finished
/// </summary>
public event EventHandler<ProgressEventArgs> Finished;
#endregion
}
}