.NET에서 fileInfo.copyto ()를 사용하여 파일 복사 진행 상황을 표시 할 수 있습니까?
https://stackoverflow.com/questions/187768
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
Russian문제
C# (.NET 2.0 프레임 워크)에서 파일, 디렉토리 및 재귀 하위 디렉토리를 복사하는 복사 유틸리티를 만들었습니다. 복사 할 파일 및 사본 작업의 경우 완료된 백분율. 현재 파일 / 총 파일을 기반으로하는 진행률 표시 줄도 있습니다.
내 문제는 큰 파일 복사와 관련이 있습니다. 큰 파일의 총 사본 진행 상황을 나타내는 방법을 찾을 수 없었습니다 (FileInfo.copyto 메소드를 사용하는 현재 클래스 구조를 사용하여). 해결 방법으로 파일 복사 작업 및 GUI 디스플레이를 자신의 스레드로 분리하고 작업이 수행되고 있음을 보여주기 위해 시각적 신호를 설정했습니다. 적어도 사용자는 프로그램이 동결되지 않았으며 여전히 파일을 복사하고 있음을 알고 있습니다.
총 바이트 수를 기준으로 진행 상황을 보여줄 수 있거나 현재 파일에서 복사 된 총 바이트 수를 나타내는 FileInfo.copyto 메소드에서 발사되는 일부 유형의 이벤트가있는 것이 좋습니다.
FileInfo.length 속성을 알고 있으므로 MacGuyver 가이 이벤트를 기반으로하고 업데이트를 읽는 것의 GUI 측에 핸들러가있는 방법이 있다고 확신합니다 (파일 인포 확인을 기반으로 할 수 있습니다. 일부 유형의 타이머를 사용하여 대상 객체의 길이 속성?).
내가 간과하는 방법을 아는 사람이 있습니까? 내가 그것을 피할 수 있다면, 나는 스트림을 통해 바이트를 복사하고 그런 식으로 추적하기 위해 내 클래스를 다시 작성하지 않을 것입니다 (나는 그 경로로가는 데 붙어있을 것이라고 생각하지만).
미리 감사드립니다
추신 - 지금은 .NET 2.0 프레임 워크에 갇혀 있으므로> = 3.0으로 제공되는 기능이 필요한 모든 솔루션은 옵션이 아닙니다.
PPS- 저는 C#뿐만 아니라 .NET 언어 품종의 솔루션에 열려 있습니다.
해결책
FileInfo.copyto는 기본적으로 Kernel32.dll에서 Win32 API 호출 "CopyFile"주변의 래퍼입니다. 이 방법은 진행 콜백을 지원하지 않습니다.
그러나 CopyFileEx 메소드는 여기에 설명 된 것처럼 몇 분 안에 자체 .NET 래퍼를 쓸 수 있습니다.http://www.pinvoke.net/default.aspx/kernel32.copyfileex
다른 팁
또한 제공된 구현도 사용했습니다 표시된 대답. 그러나 .NET에서 사용할 수있는 더 좋은 ™ API를 제공하기 위해 래퍼를 만들었습니다.
용법:
XCopy.Copy(networkFile.FullPath, temporaryFilename, true, true, (o, pce) =>
{
worker.ReportProgress(pce.ProgressPercentage, networkFile);
});
구현
/// <summary>
/// PInvoke wrapper for CopyEx
/// http://msdn.microsoft.com/en-us/library/windows/desktop/aa363852.aspx
/// </summary>
public class XCopy
{
public static void Copy(string source, string destination, bool overwrite, bool nobuffering)
{
new XCopy().CopyInternal(source, destination, overwrite, nobuffering, null);
}
public static void Copy(string source, string destination, bool overwrite, bool nobuffering, EventHandler<ProgressChangedEventArgs> handler)
{
new XCopy().CopyInternal(source, destination, overwrite, nobuffering, handler);
}
private event EventHandler Completed;
private event EventHandler<ProgressChangedEventArgs> ProgressChanged;
private int IsCancelled;
private int FilePercentCompleted;
private string Source;
private string Destination;
private XCopy()
{
IsCancelled = 0;
}
private void CopyInternal(string source, string destination, bool overwrite, bool nobuffering, EventHandler<ProgressChangedEventArgs> handler)
{
try
{
CopyFileFlags copyFileFlags = CopyFileFlags.COPY_FILE_RESTARTABLE;
if (!overwrite)
copyFileFlags |= CopyFileFlags.COPY_FILE_FAIL_IF_EXISTS;
if (nobuffering)
copyFileFlags |= CopyFileFlags.COPY_FILE_NO_BUFFERING;
Source = source;
Destination = destination;
if (handler != null)
ProgressChanged += handler;
bool result = CopyFileEx(Source, Destination, new CopyProgressRoutine(CopyProgressHandler), IntPtr.Zero, ref IsCancelled, copyFileFlags);
if (!result)
throw new Win32Exception(Marshal.GetLastWin32Error());
}
catch (Exception)
{
if (handler != null)
ProgressChanged -= handler;
throw;
}
}
private void OnProgressChanged(double percent)
{
// only raise an event when progress has changed
if ((int)percent > FilePercentCompleted)
{
FilePercentCompleted = (int)percent;
var handler = ProgressChanged;
if (handler != null)
handler(this, new ProgressChangedEventArgs((int)FilePercentCompleted, null));
}
}
private void OnCompleted()
{
var handler = Completed;
if (handler != null)
handler(this, EventArgs.Empty);
}
#region PInvoke
[DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Auto)]
[return: MarshalAs(UnmanagedType.Bool)]
private static extern bool CopyFileEx(string lpExistingFileName, string lpNewFileName, CopyProgressRoutine lpProgressRoutine, IntPtr lpData, ref Int32 pbCancel, CopyFileFlags dwCopyFlags);
private delegate CopyProgressResult CopyProgressRoutine(long TotalFileSize, long TotalBytesTransferred, long StreamSize, long StreamBytesTransferred, uint dwStreamNumber, CopyProgressCallbackReason dwCallbackReason,
IntPtr hSourceFile, IntPtr hDestinationFile, IntPtr lpData);
private enum CopyProgressResult : uint
{
PROGRESS_CONTINUE = 0,
PROGRESS_CANCEL = 1,
PROGRESS_STOP = 2,
PROGRESS_QUIET = 3
}
private enum CopyProgressCallbackReason : uint
{
CALLBACK_CHUNK_FINISHED = 0x00000000,
CALLBACK_STREAM_SWITCH = 0x00000001
}
[Flags]
private enum CopyFileFlags : uint
{
COPY_FILE_FAIL_IF_EXISTS = 0x00000001,
COPY_FILE_NO_BUFFERING = 0x00001000,
COPY_FILE_RESTARTABLE = 0x00000002,
COPY_FILE_OPEN_SOURCE_FOR_WRITE = 0x00000004,
COPY_FILE_ALLOW_DECRYPTED_DESTINATION = 0x00000008
}
private CopyProgressResult CopyProgressHandler(long total, long transferred, long streamSize, long streamByteTrans, uint dwStreamNumber,
CopyProgressCallbackReason reason, IntPtr hSourceFile, IntPtr hDestinationFile, IntPtr lpData)
{
if (reason == CopyProgressCallbackReason.CALLBACK_CHUNK_FINISHED)
OnProgressChanged((transferred / (double)total) * 100.0);
if (transferred >= total)
OnCompleted();
return CopyProgressResult.PROGRESS_CONTINUE;
}
#endregion
}
파티에 조금 늦었다는 걸 알아요.하지만 래퍼를 만들었습니다. CopyFileEx a Task 그리고 수락 a CancellationToken 그리고 IProgress<double>. 불행히도 .NET 2.0 프레임 워크에서는 작동하지 않지만 4.5를 사용하는 사람은 누구나 사용할 수 있습니다. await 예어.
public static class FileEx
{
public static Task CopyAsync(string sourceFileName, string destFileName)
{
return CopyAsync(sourceFileName, destFileName, CancellationToken.None);
}
public static Task CopyAsync(string sourceFileName, string destFileName, CancellationToken token)
{
return CopyAsync(sourceFileName, destFileName, token, null);
}
public static Task CopyAsync(string sourceFileName, string destFileName, IProgress<double> progress)
{
return CopyAsync(sourceFileName, destFileName, CancellationToken.None, progress);
}
public static Task CopyAsync(string sourceFileName, string destFileName, CancellationToken token, IProgress<double> progress)
{
int pbCancel = 0;
CopyProgressRoutine copyProgressHandler;
if (progress != null)
{
copyProgressHandler = (total, transferred, streamSize, streamByteTrans, dwStreamNumber, reason, hSourceFile, hDestinationFile, lpData) =>
{
progress.Report((double)transferred / total * 100);
return CopyProgressResult.PROGRESS_CONTINUE;
};
}
else
{
copyProgressHandler = EmptyCopyProgressHandler;
}
token.ThrowIfCancellationRequested();
var ctr = token.Register(() => pbCancel = 1);
var copyTask = Task.Run(() =>
{
try
{
CopyFileEx(sourceFileName, destFileName, copyProgressHandler, IntPtr.Zero, ref pbCancel, CopyFileFlags.COPY_FILE_RESTARTABLE);
token.ThrowIfCancellationRequested();
}
finally
{
ctr.Dispose();
}
}, token);
return copyTask;
}
private static CopyProgressResult EmptyCopyProgressHandler(long total, long transferred, long streamSize, long streamByteTrans, uint dwStreamNumber, CopyProgressCallbackReason reason, IntPtr hSourceFile, IntPtr hDestinationFile, IntPtr lpData)
{
return CopyProgressResult.PROGRESS_CONTINUE;
}
#region DLL Import
[DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Auto)]
[return: MarshalAs(UnmanagedType.Bool)]
private static extern bool CopyFileEx(string lpExistingFileName, string lpNewFileName,
CopyProgressRoutine lpProgressRoutine, IntPtr lpData, ref Int32 pbCancel,
CopyFileFlags dwCopyFlags);
delegate CopyProgressResult CopyProgressRoutine(
long totalFileSize,
long totalBytesTransferred,
long streamSize,
long streamBytesTransferred,
uint dwStreamNumber,
CopyProgressCallbackReason dwCallbackReason,
IntPtr hSourceFile,
IntPtr hDestinationFile,
IntPtr lpData);
enum CopyProgressResult : uint
{
PROGRESS_CONTINUE = 0,
PROGRESS_CANCEL = 1,
PROGRESS_STOP = 2,
PROGRESS_QUIET = 3
}
enum CopyProgressCallbackReason : uint
{
CALLBACK_CHUNK_FINISHED = 0x00000000,
CALLBACK_STREAM_SWITCH = 0x00000001
}
[Flags]
enum CopyFileFlags : uint
{
COPY_FILE_FAIL_IF_EXISTS = 0x00000001,
COPY_FILE_RESTARTABLE = 0x00000002,
COPY_FILE_OPEN_SOURCE_FOR_WRITE = 0x00000004,
COPY_FILE_ALLOW_DECRYPTED_DESTINATION = 0x00000008
}
#endregion
}
하나님의 사랑은 스트림을 사용하여 자신의 파일 사본을 구현하지 않습니다! Win32 Copyfile API는 Gaspar가 EG DMA를 활용할 수 있다고 호출하는 반면, 코드가 작성할 도넛에 달러를 내기로서 그렇게 할 수있을 정도로 "스마트"할 수는 없습니다.
CopyFileEx는 귀하를 올바르게 처리하거나 대상 파일의 증가하는 크기를보고 해당 정보를 사용하여 진행률 표시 줄을 업데이트하는 배경 작업자를 구현할 수 있습니다. 후자의 방법은 당신에게 pinvoke를 절약하지만, 전자는 아마도 장기적으로 약간 깨끗할 것입니다.
이런 종류의 것들에 대해 나는 Shell32로 돌아 왔습니다 (또는 Shellui입니까? 더 이상 모릅니다). 이를 통해 사용자가 작업 복사에 사용되는 기본 Windows 대화 상자가 제공됩니다. 이미 기존의 대화 상자를 대체 할 것이므로 정답이 아닐 수도 있지만 "핀치"시나리오를 기억하는 것이 유용합니다.
Microsoft.VisualBasic.FileIO.FileSystem.CopyFile(
srcPath,
dstPath,
Microsoft.VisualBasic.FileIO.UIOption.AllDialogs,
Microsoft.VisualBasic.FileIO.UICancelOption.ThrowException
);
예, Microsoft.visualbasic Assembly를 참조해야합니다. 나는 성장했다 사랑 이 어셈블리.
CopyFileEx 메소드를 지적한 @Gasper 및 @Dennis에게 감사드립니다. Abort Copy로 Dennis 답변을 확장했습니다
/// <summary>
/// Type indicates how the copy gets completed.
/// </summary>
internal enum CopyCompletedType
{
Succeeded,
Aborted,
Exception
}
/// <summary>
/// Event arguments for file copy
/// </summary>
internal class FileCopyEventArgs : EventArgs
{
/// <summary>
/// Constructor
/// </summary>
/// <param name="type">type of the copy completed type enum</param>
/// <param name="exception">exception if any</param>
public FileCopyEventArgs(CopyCompletedType type, Exception exception)
{
Type = type;
Exception = exception;
}
/// <summary>
/// Type of the copy completed type
/// </summary>
public CopyCompletedType Type
{
get;
private set;
}
/// <summary>
/// Exception if any happend during copy.
/// </summary>
public Exception Exception
{
get;
private set;
}
}
/// <summary>
/// PInvoke wrapper for CopyEx
/// http://msdn.microsoft.com/en-us/library/windows/desktop/aa363852.aspx
/// </summary>
internal class XCopy
{
private int IsCancelled;
private int FilePercentCompleted;
public XCopy()
{
IsCancelled = 0;
}
/// <summary>
/// Copies the file asynchronously
/// </summary>
/// <param name="source">the source path</param>
/// <param name="destination">the destination path</param>
/// <param name="nobuffering">Bufferig status</param>
/// <param name="handler">Event handler to do file copy.</param>
public void CopyAsync(string source, string destination, bool nobuffering)
{
try
{
//since we needed an async copy ..
Action action = new Action(
() => CopyInternal(source, destination, nobuffering)
);
Task task = new Task(action);
task.Start();
}
catch (AggregateException ex)
{
//handle the inner exception since exception thrown from task are wrapped in
//aggreate exception.
OnCompleted(CopyCompletedType.Exception, ex.InnerException);
}
catch (Exception ex)
{
OnCompleted(CopyCompletedType.Exception, ex);
}
}
/// <summary>
/// Event which will notify the subscribers if the copy gets completed
/// There are three scenarios in which completed event will be thrown when
/// 1.Copy succeeded
/// 2.Copy aborted.
/// 3.Any exception occured.
/// These information can be obtained from the Event args.
/// </summary>
public event EventHandler<FileCopyEventArgs> Completed;
/// <summary>
/// Event which will notify the subscribers if there is any progress change while copying.
/// This will indicate the progress percentage in its event args.
/// </summary>
public event EventHandler<ProgressChangedEventArgs> ProgressChanged;
/// <summary>
/// Aborts the copy asynchronously and throws Completed event when done.
/// User may not want to wait for completed event in case of Abort since
/// the event will tell that copy has been aborted.
/// </summary>
public void AbortCopyAsync()
{
Trace.WriteLine("Aborting the copy");
//setting this will cancel an operation since we pass the
//reference to copyfileex and it will periodically check for this.
//otherwise also We can check for iscancelled on onprogresschanged and return
//Progress_cancelled .
IsCancelled = 1;
Action completedEvent = new Action(() =>
{
//wait for some time because we ll not know when IsCancelled is set , at what time windows stops copying.
//so after sometime this may become valid .
Thread.Sleep(500);
//do we need to wait for some time and send completed event.
OnCompleted(CopyCompletedType.Aborted);
//reset the value , otherwise if we try to copy again since value is 1 ,
//it thinks that its aborted and wont allow to copy.
IsCancelled = 0;
});
Task completedTask = new Task(completedEvent);
completedTask.Start();
}
/// <summary>
/// Copies the file using asynchronos task
/// </summary>
/// <param name="source">the source path</param>
/// <param name="destination">the destination path</param>
/// <param name="nobuffering">Buffering status</param>
/// <param name="handler">Delegate to handle Progress changed</param>
private void CopyInternal(string source, string destination, bool nobuffering)
{
CopyFileFlags copyFileFlags = CopyFileFlags.COPY_FILE_RESTARTABLE;
if (nobuffering)
{
copyFileFlags |= CopyFileFlags.COPY_FILE_NO_BUFFERING;
}
try
{
Trace.WriteLine("File copy started with Source: " + source + " and destination: " + destination);
//call win32 api.
bool result = CopyFileEx(source, destination, new CopyProgressRoutine(CopyProgressHandler), IntPtr.Zero, ref IsCancelled, copyFileFlags);
if (!result)
{
//when ever we get the result as false it means some error occured so get the last win 32 error.
throw new Win32Exception(Marshal.GetLastWin32Error());
}
}
catch (Exception ex)
{
//the mesage will contain the requested operation was aborted when the file copy
//was cancelled. so we explicitly check for that and do a graceful exit
if (ex.Message.Contains("aborted"))
{
Trace.WriteLine("Copy aborted.");
}
else
{
OnCompleted(CopyCompletedType.Exception, ex.InnerException);
}
}
}
private void OnProgressChanged(double percent)
{
// only raise an event when progress has changed
if ((int)percent > FilePercentCompleted)
{
FilePercentCompleted = (int)percent;
var handler = ProgressChanged;
if (handler != null)
{
handler(this, new ProgressChangedEventArgs((int)FilePercentCompleted, null));
}
}
}
private void OnCompleted(CopyCompletedType type, Exception exception = null)
{
var handler = Completed;
if (handler != null)
{
handler(this, new FileCopyEventArgs(type, exception));
}
}
#region PInvoke
/// <summary>
/// Delegate which will be called by Win32 API for progress change
/// </summary>
/// <param name="total">the total size</param>
/// <param name="transferred">the transferrred size</param>
/// <param name="streamSize">size of the stream</param>
/// <param name="streamByteTrans"></param>
/// <param name="dwStreamNumber">stream number</param>
/// <param name="reason">reason for callback</param>
/// <param name="hSourceFile">the source file handle</param>
/// <param name="hDestinationFile">the destination file handle</param>
/// <param name="lpData">data passed by users</param>
/// <returns>indicating whether to continue or do somthing else.</returns>
private CopyProgressResult CopyProgressHandler(long total, long transferred, long streamSize, long streamByteTrans, uint dwStreamNumber,
CopyProgressCallbackReason reason, IntPtr hSourceFile, IntPtr hDestinationFile, IntPtr lpData)
{
//when a chunk is finished call the progress changed.
if (reason == CopyProgressCallbackReason.CALLBACK_CHUNK_FINISHED)
{
OnProgressChanged((transferred / (double)total) * 100.0);
}
//transfer completed
if (transferred >= total)
{
if (CloseHandle(hDestinationFile))
{
OnCompleted(CopyCompletedType.Succeeded, null);
}
else
{
OnCompleted(CopyCompletedType.Exception,
new System.IO.IOException("Unable to close the file handle"));
}
}
return CopyProgressResult.PROGRESS_CONTINUE;
}
[System.Runtime.InteropServices.DllImport("Kernel32")]
private extern static Boolean CloseHandle(IntPtr handle);
[DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Auto)]
[return: MarshalAs(UnmanagedType.Bool)]
private static extern bool CopyFileEx(string lpExistingFileName, string lpNewFileName, CopyProgressRoutine lpProgressRoutine, IntPtr lpData, ref Int32 pbCancel, CopyFileFlags dwCopyFlags);
private delegate CopyProgressResult CopyProgressRoutine(long TotalFileSize, long TotalBytesTransferred, long StreamSize, long StreamBytesTransferred, uint dwStreamNumber, CopyProgressCallbackReason dwCallbackReason,
IntPtr hSourceFile, IntPtr hDestinationFile, IntPtr lpData);
private enum CopyProgressResult : uint
{
PROGRESS_CONTINUE = 0,
PROGRESS_CANCEL = 1,
PROGRESS_STOP = 2,
PROGRESS_QUIET = 3
}
private enum CopyProgressCallbackReason : uint
{
CALLBACK_CHUNK_FINISHED = 0x00000000,
CALLBACK_STREAM_SWITCH = 0x00000001
}
[Flags]
private enum CopyFileFlags : uint
{
COPY_FILE_FAIL_IF_EXISTS = 0x00000001,
COPY_FILE_NO_BUFFERING = 0x00001000,
COPY_FILE_RESTARTABLE = 0x00000002,
COPY_FILE_OPEN_SOURCE_FOR_WRITE = 0x00000004,
COPY_FILE_ALLOW_DECRYPTED_DESTINATION = 0x00000008
}
#endregion
}
클라이언트는 Xcopy 클래스의 객체를 생성하고 COPY/ABORT 메소드를 호출 할 수 있습니다.
제휴하지 않습니다 StackOverflow
