public static extern bool CopyFileEx(
string lpExistingFileName,
string lpNewFileName,
APICopyProgressRoutine lpProgressRoutine,
IntPtr lpData,
ref Int32 lpCancel,
CopyFileOptions dwCopyFlags);
public override FileSystemExitCode PutFile(string localName, ref string remoteName, CopyFlags copyFlags)
{
bool overWrite = (CopyFlags.Overwrite & copyFlags) != 0;
string rmtName = remoteName.Substring(1);
if (File.Exists(rmtName) & !overWrite)
{
return(FileSystemExitCode.FileExists);
}
try {
if ((CopyFlags.Move & copyFlags) != 0)
{
MoveFileOptions options =
(overWrite) ? MoveFileOptions.ReplaceExisting : MoveFileOptions.None;
FileRoutines.MoveFile(new FileInfo(localName), new FileInfo(rmtName), options, OnCopyFile);
}
else
{
CopyFileOptions options =
(overWrite) ? CopyFileOptions.None : CopyFileOptions.FailIfDestinationExists;
FileRoutines.CopyFile(new FileInfo(localName), new FileInfo(rmtName), options, OnCopyFile);
}
TraceProc(TraceLevel.Warning, "Local file '" + localName + "' transferred!");
return(FileSystemExitCode.OK);
} catch (Exception ex) {
MessageBox.Show(
"File operation error:" + Environment.NewLine + ex.Message,
"LFS Plugin (PutFile)", MessageBoxButtons.OK, MessageBoxIcon.Error);
return(FileSystemExitCode.WriteError);
}
}
public override FileSystemExitCode GetFile(string remoteName, ref string localName, CopyFlags copyFlags,
RemoteInfo remoteInfo)
{
bool overWrite = (CopyFlags.Overwrite & copyFlags) != 0;
remoteName = remoteName.Substring(1);
if (File.Exists(localName) & !overWrite)
{
return(FileSystemExitCode.FileExists);
}
try {
if ((CopyFlags.Move & copyFlags) != 0)
{
MoveFileOptions options =
(overWrite) ? MoveFileOptions.ReplaceExisting : MoveFileOptions.None;
FileRoutines.MoveFile(new FileInfo(remoteName), new FileInfo(localName),
options, OnCopyFile);
}
else
{
CopyFileOptions options =
(overWrite) ? CopyFileOptions.None : CopyFileOptions.FailIfDestinationExists;
FileRoutines.CopyFile(new FileInfo(remoteName), new FileInfo(localName),
options, OnCopyFile);
}
return(FileSystemExitCode.OK);
} catch (Exception ex) {
MessageBox.Show(
"File operation error:" + Environment.NewLine + ex.Message,
"LFS Plugin (GetFile)", MessageBoxButtons.OK, MessageBoxIcon.Error);
return(FileSystemExitCode.ReadError);
}
}
/// <summary> </summary>
public static void copy_file_to(FileInfo source, FileInfo destination, CopyFileOptions options, CopyFileCallback callback, object state)
{
if (source == null)
{
throw new ArgumentNullException("source");
}
if (destination == null)
{
throw new ArgumentNullException("destination");
}
if ((options & ~CopyFileOptions.All) != 0)
{
throw new ArgumentOutOfRangeException("options");
}
new FileIOPermission(
FileIOPermissionAccess.Read, source.FullName).Demand();
new FileIOPermission(
FileIOPermissionAccess.Write, destination.FullName).Demand();
CopyProgressRoutine cpr = callback == null ?
null : new CopyProgressRoutine(new CopyProgressData(
source, destination, callback, state).CallbackHandler);
bool cancel = false;
if (!CopyFileEx(source.FullName, destination.FullName, cpr,
IntPtr.Zero, ref cancel, (int)options))
{
String custom_message = "\r\n source:" + source.FullName + "\r\n destination:" + destination.FullName;
logger.writelog("file handling failure:" + custom_message);
throw new IOException(new Win32Exception().Message.Insert(0, custom_message));
}
}
public static void CopyFile(string source, string destination, CopyFileOptions options, CopyFileCallback callback, object state)
{
if (source == null)
{
throw new ArgumentNullException("source");
}
if (destination == null)
{
throw new ArgumentNullException("destination");
}
if ((options & ~CopyFileOptions.All) != 0)
{
throw new ArgumentOutOfRangeException("options");
}
new FileIOPermission(FileIOPermissionAccess.Read, source).Demand();
new FileIOPermission(FileIOPermissionAccess.Write, destination).Demand();
CopyProgressRoutine cpr = callback == null ? null : new CopyProgressRoutine(new CopyProgressData(source, destination, callback, state).CallbackHandler);
bool cancel = false;
if (!CopyFileEx(source, destination, cpr, IntPtr.Zero, ref cancel, (int)options))
{
throw new IOException(new Win32Exception().Message);
}
}
public static bool CopyFile(string sourceFile, string destinationFile, CopyFileOptions options = CopyFileOptions.None)
{
if (!zFile.Exists(sourceFile))
return false;
if (zFile.Exists(destinationFile))
{
if ((options & CopyFileOptions.Overwrite) != CopyFileOptions.Overwrite)
return false;
if ((options & CopyFileOptions.CopyOnlyIfNewer) == CopyFileOptions.CopyOnlyIfNewer)
{
//FileInfo sourceFileInfo = new FileInfo(sourceFile);
var sourceFileInfo = zFile.CreateFileInfo(sourceFile);
//FileInfo destinationFileInfo = new FileInfo(destinationFile);
var destinationFileInfo = zFile.CreateFileInfo(destinationFile);
if (destinationFileInfo.LastWriteTimeUtc >= sourceFileInfo.LastWriteTimeUtc)
return false;
}
bool removeReadOnlyAttribute = false;
//if ((options & CopyFileOptions.CopyIfDestinationIsReadOnly) == CopyFileOptions.CopyIfDestinationIsReadOnly)
if ((options & CopyFileOptions.OverwriteReadOnly) == CopyFileOptions.OverwriteReadOnly)
removeReadOnlyAttribute = true;
DeleteFile(destinationFile, removeReadOnlyAttribute);
}
else
CreateFileDirectory(destinationFile);
zFile.Copy(sourceFile, destinationFile);
return true;
}
public static void CopyFile(FileInfo source, FileInfo destination,
CopyFileOptions options, CopyFileCallback callback, object state)
{
if (source == null)
{
throw new ArgumentNullException("source");
}
if (destination == null)
{
throw new ArgumentNullException("destination");
}
if ((options & ~CopyFileOptions.All) != 0)
{
throw new ArgumentOutOfRangeException("options");
}
new FileIOPermission(FileIOPermissionAccess.Read, source.FullName).Demand();
new FileIOPermission(FileIOPermissionAccess.Write, destination.FullName).Demand();
CopyProgressRoutine cpr = (callback == null ?
null : new CopyProgressRoutine(new CopyProgressData(
source, destination, callback, state).CallbackHandler));
bool cancel = false;
if (!CopyFileEx(source.FullName, destination.FullName, cpr,
IntPtr.Zero, ref cancel, (int)options))
{
throw new IOException(new Win32Exception().Message);
}
}
public async Task CopyFileAsync(FileInfo source, FileInfo destination, CopyFileOptions options, CancellationToken cancellationToken)
{
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
if (destination == null)
{
throw new ArgumentNullException(nameof(destination));
}
if ((options & ~CopyFileOptions.All) != 0) // if any bit in options is set which is not defined by CopyFileOptions
{
throw new ArgumentOutOfRangeException(nameof(options));
}
new FileIOPermission(FileIOPermissionAccess.Read, source.FullName).Demand();
new FileIOPermission(FileIOPermissionAccess.Write, destination.FullName).Demand();
CopyProgressRoutine cpr;
if (CopyFileProgressChanged != null)
{
var fileEventArgs = new CopyFileEventArgs(source, destination);
cpr = (totalFileSize, totalBytesTransferred,
streamSize, streamBytesTransferred, streamNumber, callbackReason, sourceFile, destinationFile, data) =>
{
try
{
cancellationToken.ThrowIfCancellationRequested();
var copyFileEventArgs = fileEventArgs;
copyFileEventArgs.TotalFileSize = totalFileSize;
copyFileEventArgs.TotalBytesTransferred = totalBytesTransferred;
OnCopyFileProgressChanged(copyFileEventArgs);
return((int)fileEventArgs.CallbackAction);
}
catch (OperationCanceledException)
{
return((int)CopyFileCallbackAction.Cancel);
}
};
}
else
{
cpr = null;
}
var cancel = false;
var copyFileExResult = await Task.Run(() =>
CopyFileEx(source.FullName, destination.FullName, cpr, IntPtr.Zero, ref cancel, (int)options), cancellationToken).ConfigureAwait(false);
if (!copyFileExResult)
{
throw new IOException(new Win32Exception().Message);
}
}
/// <summary>
/// Creates a new instance of <see cref="CopyFileExWrapperData"/>
/// </summary>
/// <param name="source">The source file</param>
/// <param name="destination">The destination file</param>
/// <param name="options">The options</param>
/// <param name="callback">The operation callback</param>
/// <param name="state">The operation state</param>
/// <param name="cancellationToken">The cancellation token</param>
public CopyFileExWrapperData(string source, string destination, CopyFileOptions options, CopyFileCallback callback, object state, CancellationToken cancellationToken)
{
Source = source;
Destination = destination;
Options = options;
Callback = callback;
State = state;
CancellationToken = cancellationToken;
}
static public void CopyFile(
string sourceFilename,
string destinationFilename,
CopyProgressDelegate progressHandler,
IntPtr userData,
CopyFileOptions copyOptions)
{
CopyFile(sourceFilename, destinationFilename, progressHandler, userData, copyOptions,
CancellationToken.None);
}
public static string CopyFileToDirectory(string sourceFile, string destinationDirectory, string destinationFilename = null, CopyFileOptions options = CopyFileOptions.None)
{
string destinationFile;
if (destinationFilename == null)
destinationFile = zpath.PathSetDirectory(sourceFile, destinationDirectory);
// vérifier si ce cas est utilisé
//else if (destinationFilename.EndsWith("\\"))
// destinationFile = zPath.Combine(destinationDirectory, destinationFilename + zPath.GetFileName(sourceFile));
else
destinationFile = zPath.Combine(destinationDirectory, destinationFilename);
if (CopyFile(sourceFile, destinationFile, options))
return destinationFile;
else
return null;
}
static private CopyFileResult CopyFileInternal(
string sourceFilename,
string destinationFilename,
CopyProgressDelegate progressHandler,
IntPtr userData,
CopyFileOptions copyOptions,
CancellationToken cancelToken)
{
// On error, throw IOException with the value from Marshal.GetLastWin32Error
CopyProgressDelegate handler = progressHandler;
int cancelFlag = 0;
APICopyProgressRoutine callback;
if (handler == null)
{
callback = null;
}
else
{
callback = new APICopyProgressRoutine((tfSize, xferBytes, strmSize, strmXferBytes,
strmNum, cbReason, srcHandle, dstHandle, udata) => {
var args = new CopyProgressArgs(tfSize, xferBytes, strmSize, strmXferBytes,
strmNum, cbReason, srcHandle, dstHandle, udata);
handler(args);
return((Int32)args.Result);
});
}
if (cancelToken.CanBeCanceled)
{
cancelToken.Register(() => { cancelFlag = 1; });
}
bool rslt = CopyFileEx(
sourceFilename,
destinationFilename,
callback,
userData,
ref cancelFlag,
copyOptions);
int err = 0;
if (!rslt)
{
err = Marshal.GetLastWin32Error();
}
return(new CopyFileResult(rslt, err));
}
public override FileSystemExitCode RenMovFile(string oldName, string newName, bool move, bool overwrite,
RemoteInfo remoteInfo)
{
oldName = oldName.Substring(1);
if (!File.Exists(oldName))
{
return(FileSystemExitCode.FileNotFound);
}
newName = newName.Substring(1);
if (File.Exists(newName) & !overwrite)
{
return(FileSystemExitCode.FileExists);
}
try {
if (move)
{
MoveFileOptions options =
(overwrite) ? MoveFileOptions.ReplaceExisting : MoveFileOptions.None;
FileRoutines.MoveFile(new FileInfo(oldName), new FileInfo(newName),
options, OnCopyFile);
}
else
{
CopyFileOptions options =
(overwrite) ? CopyFileOptions.None : CopyFileOptions.FailIfDestinationExists;
FileRoutines.CopyFile(new FileInfo(oldName), new FileInfo(newName),
options, OnCopyFile);
}
return(FileSystemExitCode.OK);
} catch (IOException ex) {
if (ex.Message.Equals(ErrorRequestAbortedMsg))
{
return(FileSystemExitCode.UserAbort);
}
if (ex.Message.Equals(ErrorFileNotFoundMsg))
{
return(FileSystemExitCode.FileNotFound);
}
MessageBox.Show(
"File operation error:" + Environment.NewLine + ex.Message,
"LFS Plugin (RenMovFile)", MessageBoxButtons.OK, MessageBoxIcon.Error);
return(FileSystemExitCode.ReadError);
}
}
static public IAsyncResult BeginCopyFile(
string sourceFilename,
string destinationFilename,
CopyProgressDelegate progressHandler,
IntPtr userData,
CopyFileOptions copyOptions,
CancellationToken cancelToken,
AsyncCallback callback = null)
{
var caller = new CopyFileInvoker(CopyFileInternal);
return(caller.BeginInvoke(
sourceFilename,
destinationFilename,
progressHandler,
userData,
copyOptions,
cancelToken,
callback,
null));
}
static public void CopyFile(
string sourceFilename,
string destinationFilename,
CopyProgressDelegate progressHandler,
IntPtr userData,
CopyFileOptions copyOptions,
CancellationToken cancelToken)
{
var rslt = CopyFileInternal(
sourceFilename,
destinationFilename,
progressHandler,
userData,
copyOptions,
cancelToken);
if (!rslt.ReturnValue)
{
throw new IOException(string.Format("Error copying file. GetLastError returns {0}.", rslt.LastError),
rslt.LastError);
}
}
public static bool CopyFile(string sourceFile, string destinationFile, CopyFileOptions options = CopyFileOptions.None)
{
if (!zFile.Exists(sourceFile))
{
return(false);
}
if (zFile.Exists(destinationFile))
{
if ((options & CopyFileOptions.Overwrite) != CopyFileOptions.Overwrite)
{
return(false);
}
if ((options & CopyFileOptions.CopyOnlyIfNewer) == CopyFileOptions.CopyOnlyIfNewer)
{
//FileInfo sourceFileInfo = new FileInfo(sourceFile);
var sourceFileInfo = zFile.CreateFileInfo(sourceFile);
//FileInfo destinationFileInfo = new FileInfo(destinationFile);
var destinationFileInfo = zFile.CreateFileInfo(destinationFile);
if (destinationFileInfo.LastWriteTimeUtc >= sourceFileInfo.LastWriteTimeUtc)
{
return(false);
}
}
bool removeReadOnlyAttribute = false;
//if ((options & CopyFileOptions.CopyIfDestinationIsReadOnly) == CopyFileOptions.CopyIfDestinationIsReadOnly)
if ((options & CopyFileOptions.OverwriteReadOnly) == CopyFileOptions.OverwriteReadOnly)
{
removeReadOnlyAttribute = true;
}
DeleteFile(destinationFile, removeReadOnlyAttribute);
}
else
{
CreateFileDirectory(destinationFile);
}
zFile.Copy(sourceFile, destinationFile);
return(true);
}
// ReSharper disable once FlagArgument
private static void CopyFile(FileInfo source, FileInfo destination, CopyFileOptions options, CopyFileCallback callback, object state)
{
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
if (destination == null)
{
throw new ArgumentNullException(nameof(destination));
}
if ((options & ~CopyFileOptions.ALL) != 0)
{
throw new ArgumentOutOfRangeException(nameof(options));
}
var copyProgressRoutine = callback == null ? null : new CopyProgressRoutine(new CopyProgressData(source, destination, callback, state).CallbackHandler);
bool cancel = false;
if (!CopyFileEx(source.FullName, destination.FullName, copyProgressRoutine, IntPtr.Zero, ref cancel, (int)options))
{
throw new IOException(new Win32Exception().Message);
}
}
public static void CopyFile(FileInfo source, FileInfo destination,
CopyFileOptions options, CopyFileCallback callback)
{
CopyFile(source, destination, options, callback, null);
}
public static void CopyFile(FileInfo source, FileInfo destination,
CopyFileOptions options)
{
CopyFile(source, destination, options, null);
}
public static void MoveFile(FileInfo source, FileInfo destination,
CopyFileOptions options)
{
CopyFile(source, destination, options, null);
source.Delete();
}
public static void MoveFile(FileInfo source, FileInfo destination,
CopyFileOptions options, CopyFileCallback callback, object state)
{
CopyFile(source, destination, options, callback, state);
source.Delete();
}
public static void CopyFile(FileInfo source, FileInfo destination,
CopyFileOptions options, CopyFileCallback callback)
{
CopyFile(source, destination, options, callback, null);
}
public static void CopyFile(FileInfo source, FileInfo destination,
CopyFileOptions options)
{
CopyFile(source, destination, options, null);
}
public static string CopyFileToDirectory(string sourceFile, string destinationDirectory, string destinationFilename = null, CopyFileOptions options = CopyFileOptions.None)
{
string destinationFile;
if (destinationFilename == null)
{
destinationFile = zpath.PathSetDirectory(sourceFile, destinationDirectory);
}
// vérifier si ce cas est utilisé
//else if (destinationFilename.EndsWith("\\"))
// destinationFile = zPath.Combine(destinationDirectory, destinationFilename + zPath.GetFileName(sourceFile));
else
{
destinationFile = zPath.Combine(destinationDirectory, destinationFilename);
}
if (CopyFile(sourceFile, destinationFile, options))
{
return(destinationFile);
}
else
{
return(null);
}
}
/// <summary> </summary>
public static void copy_file_to(FileInfo source, FileInfo destination, CopyFileOptions options)
{
copy_file_to(source, destination, options, null);
}
public static void MoveFile(FileInfo source, FileInfo destination,
CopyFileOptions options)
{
CopyFile(source, destination, options, null);
source.Delete();
}
public static void MoveFile(FileInfo source, FileInfo destination,
CopyFileOptions options, CopyFileCallback callback, object state)
{
CopyFile(source, destination, options, callback, state);
source.Delete();
}
public static void CopyFile(string source, string destination, CopyFileOptions options, CopyFileCallback callback)
{
CopyFile(source, destination, options, callback, null);
}
public static void CopyFile(string source, string destination, CopyFileOptions options)
{
CopyFile(source, destination, options, null);
}
public void CopyFile(
string existingFileName,
string newFileName,
IProgress <CopyFileProgress> progress = null,
CancellationToken ct = new CancellationToken(),
CopyFileOptions options = null)
{
Int32 pbCancel = 0;
if (options == null)
{
options = new CopyFileOptions();
}
var begin = DateTime.UtcNow;
var progressCallback = progress != null ? new NativeMethods.CopyProgressRoutine(
(
long TotalFileSize,
long TotalBytesTransferred,
long StreamSize,
long StreamBytesTransferred,
uint dwStreamNumber,
NativeMethods.CopyProgressCallbackReason dwCallbackReason,
IntPtr hSourceFile,
IntPtr hDestinationFile,
IntPtr lpData
) =>
{
progress.Report(new CopyFileProgress(
begin,
TotalFileSize,
TotalBytesTransferred,
StreamSize,
StreamBytesTransferred,
(int)dwStreamNumber));
if (ct.IsCancellationRequested)
{
return(NativeMethods.CopyProgressResult.PROGRESS_CANCEL);
}
else
{
return(NativeMethods.CopyProgressResult.PROGRESS_CONTINUE);
}
}) : null;
NativeMethods.CopyFileEx(
existingFileName,
newFileName,
progressCallback,
IntPtr.Zero,
ref pbCancel,
(options.AllowDecryptedDestination ? NativeMethods.CopyFileFlags.COPY_FILE_ALLOW_DECRYPTED_DESTINATION : 0) |
(options.CopySymlink ? NativeMethods.CopyFileFlags.COPY_FILE_COPY_SYMLINK : 0) |
(options.FailIfExists ? NativeMethods.CopyFileFlags.COPY_FILE_FAIL_IF_EXISTS : 0) |
(options.NoBuffering ? NativeMethods.CopyFileFlags.COPY_FILE_NO_BUFFERING : 0) |
(options.OpenSourceForWrite ? NativeMethods.CopyFileFlags.COPY_FILE_OPEN_SOURCE_FOR_WRITE : 0) |
(options.Restartable ? NativeMethods.CopyFileFlags.COPY_FILE_RESTARTABLE : 0))
.CheckApiCall(String.Format("copy from {0} to {1}", existingFileName, newFileName));
}
/// <summary> </summary>
public static void copy_file_to(FileInfo source, FileInfo destination, CopyFileOptions options, CopyFileCallback callback)
{
copy_file_to(source, destination, options, callback, null);
}
