/// <summary>
/// Compares two file with a byte-by-byte sequence strategy.
/// Either based on a:
/// 1) byte size comparison and byte-by-byte comparison or
/// 2) byte-by-byte comparison ignoring different line feed styles on text files.
/// </summary>
/// <param name="ifo1"></param>
/// <param name="ifo2"></param>
/// <param name="diffMode"></param>
/// <returns>false if both files are equal and true if they differ</returns>
public bool AreBinaryFilesDifferent(IFileInfo ifo1, IFileInfo ifo2, DiffDirFileMode diffMode)
{
// Should we ignore different linefeeds on text files and is this type of matching applicable here?
if (diffMode == DiffDirFileMode.ByteLength_AllBytes_IgnoreLf)
{
bool IsIfo1Text = ifo1.Is == FileType.Text | ifo1.Is == FileType.Xml;
bool IsIfo2Text = ifo2.Is == FileType.Text | ifo2.Is == FileType.Xml;
if (IsIfo1Text && IsIfo2Text)
{
return(AreTextFiles_IgnoringLF_Different(ifo1, ifo2));
}
}
else if (diffMode == DiffDirFileMode.ByteLength_AllBytes_IgnoreLf_WSP)
{
bool IsIfo1Text = ifo1.Is == FileType.Text | ifo1.Is == FileType.Xml;
bool IsIfo2Text = ifo2.Is == FileType.Text | ifo2.Is == FileType.Xml;
if (IsIfo1Text && IsIfo2Text)
{
return(AreTextFiles_IgnoringLF_WSP_Different(ifo1, ifo2));
}
}
// Before we open the files, compare the sizes. If they are different,
// then the files are certainly different.
if (ifo1.Length != ifo2.Length)
{
return(true);
}
var info1 = new FileInfo(ifo1.FullName);
var info2 = new FileInfo(ifo2.FullName);
using (FileStream stream1 = info1.OpenRead())
using (FileStream stream2 = info2.OpenRead())
{
// The previous length check should ensure these are equal.
Debug.Assert(stream1.Length == stream2.Length, "The streams' lengths must be the same.");
// They have the same lengths, so we have to check byte-by-byte. As soon as we find a difference, we can quit.
int byte1, byte2;
do
{
byte1 = stream1.ReadByte();
byte2 = stream2.ReadByte();
Debug.Assert(byte1 <= 255, "Byte1 size is larger than 8 bit.");
Debug.Assert(byte2 <= 255, "Byte2 size is larger than 8 bit.");
if (byte1 != byte2)
{
return(true); // The files are different
}
}while (byte1 >= 0 && byte2 >= 0);
return(false); // The files are byte-by-byte equal.
}
}
/// <summary>
/// Class constructor
/// </summary>
/// <param name="name"></param>
/// <param name="description"></param>
/// <param name="modeKey"></param>
public DiffFileModeItemViewModel(string name,
string description,
DiffDirFileMode modeKey)
: this()
{
this.Name = name;
this.Description = description;
this.ModeKey = modeKey;
}
/// <summary>
/// Class constructor
/// </summary>
/// <param name="args">Determines the options that control the way in which
/// the diff is computed (eg.: whether sub-directories should be considered or not).</param>
public DirectoryDiff(DirDiffArgs args)
{
_ShowOnlyInA = args.ShowOnlyInA;
_ShowOnlyInB = args.ShowOnlyInB;
_ShowDifferent = args.ShowDifferent;
_ShowSame = args.ShowSame;
_Recursive = args.Recursive;
_IgnoreDirectoryComparison = args.IgnoreDirectoryComparison;
_Filter = args.FileFilter;
_DiffMode = args.CompareDirFileMode;
_LastUpDatePrecision = args.LastUpDateFilePrecision;
}
/// <summary>
/// Class constructor
/// </summary>
/// <param name="filter"></param>
/// <param name="recursive"></param>
/// <param name="rootPathA"></param>
/// <param name="rootPathB"></param>
/// <param name="diffMode">
/// Determines the modus operandi per <see cref="DiffDirFileMode"/> that is used to
/// compare two files and pronounce them as different or equal.
/// </param>
public DirectoryDiffRoot(string rootPathA, string rootPathB,
bool recursive,
DirectoryDiffFileFilter filter,
DiffDirFileMode diffMode)
: this()
{
this.RootPathA = rootPathA;
this.RootPathB = rootPathB;
_Recursive = recursive;
_Filter = filter;
_DiffMode = diffMode;
}
/// <summary>
/// Compares two file on a byte-by-byte sequence strategy.
/// Either based on a:
/// 1) byte size comparison and byte-by-byte comparison or
/// 2) byte-by-byte comparison ignoring different line feed styles on text files.
/// </summary>
/// <param name="info1"></param>
/// <param name="info2"></param>
/// <param name="diffMode"></param>
/// <returns>false if both files are equal and true if they differ</returns>
public bool AreBinaryFilesDifferent(string fileName1, string fileName2, DiffDirFileMode diffMode)
{
return(AreBinaryFilesDifferent(new FileInfoImpl(fileName1), new FileInfoImpl(fileName2), diffMode));
}
private void CompareFilesCommand_Executed(string leftDir,
string rightDir,
DiffDirFileMode dirFileMode)
{
if (_cancelTokenSource.IsCancellationRequested == true)
{
return;
}
DirDiffArgs args = _Args;
_Args.CompareDirFileMode = dirFileMode;
// Construct deffault options if there are no others
if (_Args == null)
{
args = new DirDiffArgs(leftDir, rightDir);
}
else
{
_Args.LeftDir = leftDir;
_Args.RightDir = rightDir;
}
var diff = new DirectoryDiff(args);
try
{
_DiffProgress.ResetProgressValues(_cancelTokenSource.Token);
Task.Factory.StartNew <IDiffProgress>(
(p) => diff.Execute(args.LeftDir, args.RightDir, _DiffProgress, _DataSource)
, TaskCreationOptions.LongRunning, _cancelTokenSource.Token)
.ContinueWith((r) =>
{
bool onError = false;
bool taskCancelled = false;
if (_cancelTokenSource != null)
{
// Re-create cancellation token if this task was cancelled
// to support cancelable tasks in the future
if (_cancelTokenSource.IsCancellationRequested)
{
taskCancelled = true;
_cancelTokenSource.Dispose();
_cancelTokenSource = new CancellationTokenSource();
}
}
if (taskCancelled == false)
{
if (r.Result == null)
{
onError = true;
}
else
{
if (r.Result.ResultData == null)
{
onError = true;
}
}
}
if (onError == false && taskCancelled == false)
{
var diffResults = r.Result.ResultData as IDirectoryDiffRoot;
_DirDiffDoc.ShowDifferences(args, diffResults);
}
else
{
// Display Error
}
});
}
catch
{
// Handle task based error and display error
}
}
