private static OperationResult CopyFileWithProgress(
string sourceFile,
string newFile,
Action <Progress> progress,
CancellationToken cancellationToken)
{
int pbCancel = 0;
DateTime startTimestamp = DateTime.Now;
NativeMethods.CopyProgressRoutine lpProgressRoutine = (NativeMethods.CopyProgressRoutine)((size, transferred, streamSize, bytesTransferred, number, reason, file, destinationFile, data) =>
{
Progress progress1 = new Progress(startTimestamp, bytesTransferred, size);
try
{
lock (progress)
{
progress(progress1);
return(NativeMethods.CopyProgressResult.PROGRESS_CONTINUE);
}
}
catch (Exception ex)
{
return(NativeMethods.CopyProgressResult.PROGRESS_STOP);
}
});
if (cancellationToken.IsCancellationRequested)
{
return(OperationResult.Cancelled);
}
cancellationToken.Register((Action)(() => pbCancel = 1));
bool flag = NativeMethods.CopyFileEx(sourceFile, newFile, lpProgressRoutine, IntPtr.Zero, ref pbCancel, NativeMethods.CopyFileFlags.COPY_FILE_RESTARTABLE);
return(cancellationToken.IsCancellationRequested ? OperationResult.Cancelled : (flag ? OperationResult.Success : OperationResult.Failed));
}
public static bool MoveWithProgress(string source, string destination, Action <TransferProgress> progress)
{
var startTimestamp = DateTime.Now;
NativeMethods.CopyProgressRoutine lpProgressRoutine = (size, transferred, streamSize, bytesTransferred, number, reason, file, destinationFile, data) =>
{
TransferProgress fileProgress = new TransferProgress(startTimestamp, bytesTransferred)
{
Total = size,
Transferred = transferred,
StreamSize = streamSize,
BytesTransferred = bytesTransferred,
ProcessedFile = source
};
try
{
progress(fileProgress);
return(NativeMethods.CopyProgressResult.PROGRESS_CONTINUE);
}
catch (Exception ex)
{
return(NativeMethods.CopyProgressResult.PROGRESS_STOP);
}
};
if (!NativeMethods.MoveFileWithProgress(source, destination, lpProgressRoutine, IntPtr.Zero, NativeMethods.MoveFileFlags.MOVE_FILE_REPLACE_EXISTSING | NativeMethods.MoveFileFlags.MOVE_FILE_COPY_ALLOWED | NativeMethods.MoveFileFlags.MOVE_FILE_WRITE_THROUGH))
{
return(false);
}
return(true);
}
public static extern bool CopyFileEx(
string lpExistingFileName,
string lpNewFileName,
NativeMethods.CopyProgressRoutine lpProgressRoutine,
IntPtr lpData,
ref int pbCancel,
NativeMethods.CopyFileFlags dwCopyFlags);
private static TransferResult CopyFileWithProgress(string sourceFile, string newFile, Action <TransferProgress> progress, CancellationToken cancellationToken)
{
int pbCancel = 0;
var startTimestamp = DateTime.Now;
NativeMethods.CopyProgressRoutine lpProgressRoutine = (size, transferred, streamSize, bytesTransferred, number, reason, file, destinationFile, data) =>
{
TransferProgress fileProgress = new TransferProgress(startTimestamp, bytesTransferred)
{
Total = size,
Transferred = transferred,
StreamSize = streamSize,
ProcessedFile = sourceFile
};
try
{
if (cancellationToken.IsCancellationRequested)
{
return(NativeMethods.CopyProgressResult.PROGRESS_CANCEL);
}
progress(fileProgress);
return(NativeMethods.CopyProgressResult.PROGRESS_CONTINUE);
}
catch (Exception)
{
return(NativeMethods.CopyProgressResult.PROGRESS_STOP);
}
};
if (cancellationToken.IsCancellationRequested)
{
return(TransferResult.Cancelled);
}
var ctr = cancellationToken.Register(() => pbCancel = 1);
var result = NativeMethods.CopyFileEx(sourceFile, newFile, lpProgressRoutine, IntPtr.Zero, ref pbCancel, NativeMethods.CopyFileFlags.COPY_FILE_FAIL_IF_EXISTS);
if (cancellationToken.IsCancellationRequested)
{
return(TransferResult.Cancelled);
}
return(result ? TransferResult.Success : TransferResult.Failed);
}
public static bool MoveWithProgress(
string source,
string destination,
Action <Progress> progress)
{
DateTime startTimestamp = DateTime.Now;
NativeMethods.CopyProgressRoutine lpProgressRoutine = (size, transferred, streamSize, bytesTransferred, number, reason, file, destinationFile, data) =>
{
Progress progress1 = new Progress(startTimestamp, bytesTransferred, size);
try
{
progress(progress1);
return(NativeMethods.CopyProgressResult.PROGRESS_CONTINUE);
}
catch (Exception ex)
{
return(NativeMethods.CopyProgressResult.PROGRESS_STOP);
}
};
return(NativeMethods.MoveFileWithProgress(source, destination, lpProgressRoutine, IntPtr.Zero, NativeMethods.MoveFileFlags.MOVE_FILE_REPLACE_EXISTSING | NativeMethods.MoveFileFlags.MOVE_FILE_COPY_ALLOWED | NativeMethods.MoveFileFlags.MOVE_FILE_WRITE_THROUGH));
}
public static extern bool MoveFileWithProgress(
string lpExistingFileName,
string lpNewFileName,
NativeMethods.CopyProgressRoutine lpProgressRoutine,
IntPtr lpData,
NativeMethods.MoveFileFlags dwCopyFlags);
/// <summary>
/// Copy or move file from source to destination with progress callback
/// </summary>
/// <param name="source">source file</param>
/// <param name="destination">destination file</param>
/// <param name="overwrite">true if destination must be overwritten if exists</param>
/// <param name="move">true if move, false=copy</param>
/// <param name="callback">progress callback method to be called</param>
public static void CopyOrMoveFile(string source, string destination, bool overwrite, bool move, CopyFileCallback callback)
{
if (source == null)
{
throw new ArgumentNullException("source");
}
if (destination == null)
{
throw new ArgumentNullException("destination");
}
new FileIOPermission(FileIOPermissionAccess.Read, source).Demand();
new FileIOPermission(FileIOPermissionAccess.Write, destination).Demand();
CopyProgressData progData = null;
NativeMethods.CopyProgressRoutine cpr = null;
if (callback != null)
{
progData = new CopyProgressData(source, destination, callback);
cpr = progData.CallbackHandler;
}
bool cancel = false;
if (Environment.OSVersion.Platform == PlatformID.Win32NT)
{
try
{
bool ret = true;
if (move)
{
NativeMethods.MoveFileExFlags fm = NativeMethods.MoveFileExFlags.MOVEFILE_COPY_ALLOWED;
if (overwrite)
{
fm |= NativeMethods.MoveFileExFlags.MOVEFILE_REPLACE_EXISTING;
}
ret = NativeMethods.MoveFileWithProgress(source, destination, cpr, IntPtr.Zero, (int)fm);
}
else
{
NativeMethods.CopyFileExFlags f = NativeMethods.CopyFileExFlags.COPY_FILE_ALLOW_DECRYPTED_DESTINATION;
if (!overwrite)
{
f |= NativeMethods.CopyFileExFlags.COPY_FILE_FAIL_IF_EXISTS;
}
ret = NativeMethods.CopyFileEx(source, destination, cpr, IntPtr.Zero, ref cancel, (int)f);
}
if (progData != null && progData.Exception != null)
{
Utils.Rethrow(progData.Exception);
}
if (!ret)
{
var w = new Win32Exception();
if (w.NativeErrorCode == 2)
{
throw new FileNotFoundException(w.Message, source);
}
throw new IOException(w.Message, w);
}
return;
}
catch (MissingMethodException) { }
catch (SecurityException) { }
}
// The old fashioned way
if (source != destination)
{
if (overwrite)
{
var fi = new FileInfo(destination);
if (fi.Exists && (fi.Attributes & (FileAttributes.Hidden | FileAttributes.ReadOnly | FileAttributes.System)) != 0)
{
fi.Attributes &= ~(FileAttributes.Hidden | FileAttributes.ReadOnly | FileAttributes.System);
}
fi.Delete();
}
if (move)
{
File.Move(source, destination);
}
else
{
File.Copy(source, destination, overwrite);
}
return;
}
}
