void worker_DoWork(object sender, DoWorkEventArgs e)
{
var rootDir = (string)e.Argument;
try
{
var dir = new DirectoryInfo(rootDir);
var re = new Regex(@"^[a-zA-Z]:\$", RegexOptions.IgnoreCase);
FileSizeContext context;
if (re.Match(rootDir).Success)
{
context = new FileSizeContext(new DriveInfo(rootDir).TotalFreeSpace);
}
else
{
context = new FileSizeContext(0);
}
// TODO: progress.IsIndeterminate = (context.DiskSize == 0);
DirectorySizeItem dsi = LoadDirectoryRecursive(context, dir);
ResolveSizeRecursive(dsi);
_worker.ReportProgress(0, dsi);
}
catch (Exception exp)
{
((App)Application.Current).LogException(exp);
}
}
public override void Interpret(FileSizeContext value)
{
foreach (FileSizeExpression exp in expressionTree)
{
exp.Interpret(value);
}
}
public override void Interpret(FileSizeContext value)
{
if (value.Input.EndsWith(this.ThisPattern()))
{
double amount = double.Parse(value.Input.Replace(this.ThisPattern(), String.Empty));
var fileSize = (int)(amount * 1024);
value.Input = String.Format("{0}{1}", fileSize, this.NextPattern());
value.Output = fileSize;
}
}
/// <summary>
/// Input unparsed string (such as "100Kb") and
/// output number in bytes as string ("102400 bytes")
/// </summary>
/// <param name="value"></param>
/// <param name="targetType"></param>
/// <param name="parameter">Can contain an array of 2 UInt64 numbers
/// which are interpreted as Min Max values for resulting number of bytes</param>
/// <param name="culture"></param>
/// <returns></returns>
public object Convert(object value,
Type targetType, object parameter, System.Globalization.CultureInfo culture)
{
if (value == null)
{
return(Binding.DoNothing);
}
string stringInput = value as string;
if (stringInput != null)
{
if (!string.IsNullOrEmpty(value.ToString()))
{
ulong numberOfBytes;
string[] inputComponents;
if (FileSizeContext.ConvertUnparsedSizeToBytesInt(value, out numberOfBytes, out inputComponents) == true)
{
ulong[] iMinMax = parameter as ulong[];
if (iMinMax != null)
{
if (iMinMax.Length == 2)
{
ulong iMin = iMinMax[0];
ulong iMax = iMinMax[1];
if (numberOfBytes < iMin || numberOfBytes > iMax)
{
string sMin, sMax;
MemUnit sizeUnit;
double d = NumberToBestSizeConverter.GetHumanReadableSize(iMin, out sizeUnit);
sMin = string.Format("{0} {1}", Math.Round(d, 2).ToString(), sizeUnit);
d = NumberToBestSizeConverter.GetHumanReadableSize(iMax, out sizeUnit);
sMax = string.Format("{0} {1}", Math.Round(d, 2).ToString(), sizeUnit);
return(string.Format("(Out of range [{0}, {1}])", sMin, sMax));
}
}
}
return(string.Format("{0} bytes", numberOfBytes));
}
else
{
return(string.Format("Syntax Error: '{0}'", stringInput));
}
}
}
return(Binding.DoNothing);
}
/// <summary>
/// Input unparsed string (such as "100Kb") plus an array of MinManx values
/// of type ulong in parameter object and output whether the input can be
/// converted OK and is within the MinMax range (true) or not (false).
/// </summary>
/// <param name="value"></param>
/// <param name="targetType"></param>
/// <param name="parameter">Can contain an array of 2 UInt64 numbers
/// which are interpreted as Min Max values for resulting number of bytes</param>
/// <param name="culture"></param>
/// <returns></returns>
public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
{
if (value == null)
{
return(false);
}
string stringInput = value as string;
if (stringInput != null)
{
if (!string.IsNullOrEmpty(value.ToString()))
{
ulong numberOfBytes;
string[] inputComponents;
if (FileSizeContext.ConvertUnparsedSizeToBytesInt(value, out numberOfBytes, out inputComponents) == true)
{
ulong[] iMinMax = parameter as ulong[];
if (iMinMax != null)
{
if (iMinMax.Length == 2)
{
ulong iMin = iMinMax[0];
ulong iMax = iMinMax[1];
if (numberOfBytes < iMin || numberOfBytes > iMax)
{
// Number is out of bounds (false == Visible error message)
return(System.Windows.Visibility.Visible);
}
}
}
// Number should be OK (true == Invisible error message)
return(System.Windows.Visibility.Collapsed);
}
}
}
// Syntax error - (false == Visible error message)
return(System.Windows.Visibility.Visible);
}
private DirectorySizeItem LoadDirectoryRecursive(FileSizeContext context, DirectoryInfo di)
{
var dsi = new DirectorySizeItem(context);
dsi.Load(di);
if (di.FullName.Length >= 230) // 再向下查找超过260个字符有可能引起异常，略过
{
return(dsi);
}
try
{
foreach (var fi in di.GetFiles())
{
var fsi = new FileSizeItem(context);
fsi.Load(fi);
dsi.Files.Add(fsi);
context.ReadedSize += fsi.Size;
}
}
catch (UnauthorizedAccessException)
{
}
_worker.ReportProgress(context.ReadedPercentage, string.Format("正在读取目录: {0}", di.FullName));
try
{
foreach (var subDi in di.GetDirectories())
{
var subDsi = LoadDirectoryRecursive(context, subDi);
dsi.SubDirectories.Add(subDsi);
}
}
catch (UnauthorizedAccessException)
{
}
return(dsi);
}
/// <summary>
/// Input unparsed string (such as "100Kb") and
/// output number in bytes as string ("102400 bytes")
/// </summary>
/// <param name="value"></param>
/// <param name="targetType"></param>
/// <param name="parameter">Can contain an array of 2 UInt64 numbers
/// which are interpreted as Min Max values for resulting number of bytes</param>
/// <param name="culture"></param>
/// <returns></returns>
public object Convert(object[] values, Type targetType, object parameter, System.Globalization.CultureInfo culture)
{
if (values == null)
{
return(Binding.DoNothing);
}
string stringInput = string.Empty;
if (values.Length == 1)
{
if (values[0] != null)
{
stringInput = string.Format("{0}", values[0]);
}
}
else
{
if (values.Length == 2)
{
if (values[0] != null && values[1] != null)
{
stringInput = string.Format("{0} {1}", values[0], values[1]);
}
}
}
if (stringInput.Length == 0)
{
return(Binding.DoNothing);
////throw new NotImplementedException(string.Format("One or Two input values are required for conversion, but there are; {0}", values.Length));
}
ulong numberOfBytes;
string[] inputComponents;
if (FileSizeContext.ConvertUnparsedSizeToBytesInt(stringInput, out numberOfBytes, out inputComponents) == true)
{
ulong[] iMinMax = parameter as ulong[];
if (iMinMax != null)
{
if (iMinMax.Length == 2)
{
ulong iMin = iMinMax[0];
ulong iMax = iMinMax[1];
if (numberOfBytes < iMin || numberOfBytes > iMax)
{
return(System.Windows.Visibility.Visible); // Number is out of bounds (false == Visible error message)
}
}
}
// Number should be OK (true == Invisible error message)
return(System.Windows.Visibility.Collapsed);
}
// Syntax error (false == Visible error message)
return(System.Windows.Visibility.Visible);
}
public abstract void Interpret(FileSizeContext value);
/// <summary>
/// Input unparsed string (such as "100Kb") and
/// output number in bytes as string ("102400 bytes")
/// </summary>
/// <param name="value"></param>
/// <param name="targetType"></param>
/// <param name="parameter">Can contain an array of 2 UInt64 numbers
/// which are interpreted as Min Max values for resulting number of bytes</param>
/// <param name="culture"></param>
/// <returns></returns>
public object Convert(object[] values, Type targetType, object parameter, System.Globalization.CultureInfo culture)
{
if (values == null)
{
return(Binding.DoNothing);
}
string stringInput = string.Empty;
if (values.Length == 1)
{
if (values[0] != null)
{
stringInput = string.Format("{0}", values[0]);
}
}
else
{
if (values.Length == 2)
{
if (values[0] != null && values[1] != null)
{
stringInput = string.Format("{0} {1}", values[0], values[1]);
}
}
}
if (stringInput.Length == 0)
{
return(Binding.DoNothing);
////throw new NotImplementedException(string.Format("One or Two input values are required for conversion, but there are; {0}", values.Length));
}
// Convert an iinput string such as, "100 Mb" into a byte string represantation, such as, "1000 bytes"
ulong numberOfBytes;
string[] inputComponents;
if (FileSizeContext.ConvertUnparsedSizeToBytesInt(stringInput, out numberOfBytes, out inputComponents) == true)
{
ulong[] iMinMax = parameter as ulong[];
if (iMinMax != null)
{
if (iMinMax.Length == 2)
{
ulong iMin = iMinMax[0];
ulong iMax = iMinMax[1];
if (numberOfBytes < iMin || numberOfBytes > iMax)
{
string sMin, sMax;
MemUnit sizeUnit;
double d = NumberToBestSizeConverter.GetHumanReadableSize(iMin, out sizeUnit);
sMin = string.Format("{0} {1}", Math.Round(d, 2).ToString(), sizeUnit);
d = NumberToBestSizeConverter.GetHumanReadableSize(iMax, out sizeUnit);
sMax = string.Format("{0} {1}", Math.Round(d, 2).ToString(), sizeUnit);
return(string.Format("(Out of range [{0}, {1}])", sMin, sMax));
}
}
}
return(string.Format("{0} bytes", numberOfBytes));
}
return(string.Format("Syntax Error: '{0}'", stringInput));
}
