Asynchrones Kopieren von Dateien und Ordnern

    • VB.NET

    Es gibt 1 Antwort in diesem Thema. Der letzte Beitrag () ist von ~blaze~.

      Asynchrones Kopieren von Dateien und Ordnern

      Hi
      habe soeben eine Klasse geschrieben, die das asynchrone Kopieren von Dateien und Ordnern ermöglicht:

      VB.NET-Quellcode

      1. ''' <summary>
      2. ''' Ermöglicht das asynchrone Kopieren mit Fortschrittsüberwachung von Dateien, Verzeichnissen und Datenströmen.
      3. ''' </summary>
      4. Public Class FileCopy
      5. ''' <summary>
      6. ''' Stellt eine Instanz bereit, die für Standardkopiervorgänge von Dateien verwendet werden kann.
      7. ''' </summary>
      8. Public Shared ReadOnly General As FileCopy = New FileCopy()
      10. Private ReadOnly _bufferSize As Integer
      12. ''' <summary>
      13. ''' Initialisiert eine neue Instanz der FileCopy-Klasse unter Verwendung der Standardpuffergröße von 4096.
      14. ''' </summary>
      15. Protected Sub New()
      16. Me.New(4096)
      17. End Sub
      19. ''' <summary>
      20. ''' Initialisiert eine neue Instanz der FileCopy-Klasse unter Verwendung der angegebenen Puffergröße.
      21. ''' </summary>
      22. ''' <param name="bufferSize">Die Größe der Puffer, die zum Kopieren verwendet werden soll.</param>
      23. Public Sub New(ByVal bufferSize As Integer)
      24. _bufferSize = bufferSize
      25. End Sub
      27. ''' <summary>
      28. ''' Kopiert die angegebene Datei an die Zieldatei.
      29. ''' </summary>
      30. ''' <param name="sourceFile">Der Pfad zur Quelldatei.</param>
      31. ''' <param name="destinationFile">Der Pfad mit Dateinamen zur Zieldatei.</param>
      32. ''' <returns>Ein Objekt, das zum Überwachen des Fortschritts verwendet werden kann.</returns>
      33. Public Function CopyFile(ByVal sourceFile As String, ByVal destinationFile As String) As CopyProgress
      34. Dim sf As IO.Stream = IO.File.OpenRead(sourceFile), df = IO.File.OpenWrite(destinationFile)
      36. Dim progress As CopyProgress = CreateProgress(sf.Length, 1)
      38. AddHandler progress.Finished, Sub(sender, e)
      39. sf.Close()
      40. df.Close()
      41. End Sub
      42. CopyAsync(progress, New KeyValuePair(Of IO.Stream, IO.Stream)(sf, df))
      43. Return progress
      44. End Function
      46. ''' <summary>
      47. ''' Kopiert das angegebene Verzeichnis in das Zielverzeichnis.
      48. ''' </summary>
      49. ''' <param name="sourceDirectory">Das Quellverzeichnis.</param>
      50. ''' <param name="destinationDirectory">Das Zielverzeichnis.</param>
      51. ''' <param name="searchOption">Gibt an, ob nur das angegebene Verzeichnis oder alle Unterverzeichnisse kopiert werden sollen.</param>
      52. ''' <returns>Ein Objekt, das zum Überwachen des Fortschritts verwendet werden kann.</returns>
      53. Public Function CopyDirectory(ByVal sourceDirectory As String, ByVal destinationDirectory As String, ByVal searchPattern As String, ByVal searchOption As IO.SearchOption) As CopyProgress
      54. Dim files() As String = System.IO.Directory.GetFiles(sourceDirectory, searchPattern, searchOption)
      55. Dim pl(files.Length - 1) As KeyValuePair(Of System.IO.Stream, System.IO.Stream)
      56. Dim len As Long = 0
      57. Dim progress As CopyProgress
      58. For i As Integer = 0 To files.Length - 1
      59. Dim target As String = IO.Path.Combine(destinationDirectory, files(i).Substring(sourceDirectory.Length + 1))
      60. IO.Directory.CreateDirectory(IO.Path.GetDirectoryName(target))
      61. Dim sf As IO.Stream = IO.File.OpenRead(files(i)), df = System.IO.File.OpenWrite(target)
      62. len += sf.Length
      63. pl(i) = New KeyValuePair(Of System.IO.Stream, System.IO.Stream)(sf, df)
      64. Next
      65. progress = CreateProgress(len, files.Length)
      66. AddHandler progress.Finished, Sub()
      67. For Each cp As KeyValuePair(Of System.IO.Stream, System.IO.Stream) In pl
      68. cp.Key.Close()
      69. cp.Value.Close()
      70. Next
      71. End Sub
      72. CopyAsync(pl, progress)
      73. Return progress
      74. End Function
      76. ''' <summary>
      77. ''' Kopiert die Daten des <see cref="System.IO.Stream"/> an das Ziel.
      78. ''' </summary>
      79. ''' <param name="source">Die Datenquelle.</param>
      80. ''' <param name="destination">Das Datenziel.</param>
      81. ''' <returns>Ein Objekt, das zum Überwachen des Fortschritts verwendet werden kann.</returns>
      82. Public Function CopyStream(ByVal source As IO.Stream, ByVal destination As IO.Stream) As CopyProgress
      83. Dim cp As CopyProgress = CreateProgress(-1, source.Length - source.Position, 0)
      84. CopyAsync(cp, New KeyValuePair(Of IO.Stream, IO.Stream)(source, destination))
      85. Return cp
      86. End Function
      88. ''' <summary>
      89. ''' Erzeugt eine neue Fortschritts-Überwachung.
      90. ''' </summary>
      91. ''' <param name="amount">Die Gesamtzahl der gelesenen Bytes.</param>
      92. ''' <param name="fileCount">Die Anzahl der gelesenen Dateien.</param>
      93. ''' <returns>Das Überwachungsobjekt.</returns>
      94. Protected Function CreateProgress(ByVal amount As Long, ByVal fileCount As Integer) As CopyProgress
      95. Return CreateProgress(amount, amount, fileCount)
      96. End Function
      98. ''' <summary>
      99. ''' Erzeugt eine neue Fortschritts-Überwachung.
      100. ''' </summary>
      101. ''' <param name="amount">Die Gesamtzahl der gelesenen Bytes.</param>
      102. ''' <param name="estimatedAmount">Die geschätzte Anzahl an Bytes, die gelesen wird.
      103. ''' Dieser Wert wird verwendet, wenn die Quelle die ermittelten Werte verändern kann.</param>
      104. ''' <param name="fileCount">Die Anzahl der gelesenen Dateien.</param>
      105. ''' <returns>Das Überwachungsobjekt.</returns>
      106. Protected Overridable Function CreateProgress(ByVal amount As Long, ByVal estimatedAmount As Long, ByVal fileCount As Integer) As CopyProgress
      107. Return New CopyProgress(amount, estimatedAmount)
      108. End Function
      110. Private Shared Sub CopyAsync(ByVal progress As CopyProgress, ByVal ParamArray streams() As KeyValuePair(Of IO.Stream, IO.Stream))
      111. CopyAsync(streams, progress)
      112. End Sub
      114. Private Shared Sub CopyAsync(ByVal streams As IEnumerable(Of KeyValuePair(Of IO.Stream, IO.Stream)), ByVal progress As CopyProgress)
      115. System.Threading.ThreadPool.QueueUserWorkItem(Sub(o)
      116. Copy(streams, progress, CInt(Math.Min(progress.Amount, 4096)))
      117. End Sub)
      118. End Sub
      120. Private Shared Sub Copy(ByVal streams As IEnumerable(Of KeyValuePair(Of IO.Stream, IO.Stream)), ByVal progress As CopyProgress, ByVal bufferSize As Integer)
      121. Dim buffer(bufferSize - 1) As Byte
      122. Dim len As Integer
      123. Dim canceled As Boolean
      124. For Each strm As KeyValuePair(Of IO.Stream, IO.Stream) In streams
      125. Do
      126. If progress.Canceled Then
      127. canceled = True
      128. Exit For
      129. End If
      130. len = strm.Key.Read(buffer, 0, buffer.Length)
      131. If progress.Canceled Then
      132. canceled = True
      133. Exit For
      134. End If
      135. strm.Value.Write(buffer, 0, len)
      136. If progress.Canceled Then
      137. canceled = True
      138. Exit For
      139. End If
      140. progress.AdvanceProgress(len)
      141. Loop While len <> 0
      142. progress.StreamCompleted()
      143. Next
      144. progress.SetFinished(canceled)
      145. End Sub
      147. Private Shared Sub CreateDirectories(ByVal src As String, ByVal dest As String)
      148. CreateDirectories(New IO.DirectoryInfo(src), System.IO.Directory.CreateDirectory(dest))
      149. End Sub
      151. Private Shared Sub CreateDirectories(ByVal src As IO.DirectoryInfo, ByVal dest As IO.DirectoryInfo)
      152. For Each di As System.IO.DirectoryInfo In src.GetDirectories()
      153. CreateDirectories(di, dest.CreateSubdirectory(di.Name))
      154. Next
      155. End Sub
      156. End Class
      158. ''' <summary>
      159. ''' Stellt eine Möglichkeit zur Überwachung von Kopiervorgängen bereit.
      160. ''' </summary>
      161. Public Class CopyProgress
      162. ''' <summary>
      163. ''' Tritt ein, sobald ein weiterer Datenblock kopiert wurde.
      164. ''' </summary>
      165. ''' <remarks></remarks>
      166. Public Event ProgressChanged As EventHandler
      167. ''' <summary>
      168. ''' Tritt ein, sobald der Kopiervorgang abgeschlossen wird.
      169. ''' </summary>
      170. ''' <remarks></remarks>
      171. Public Event Finished As EventHandler
      172. ''' <summary>
      173. ''' Tritt ein, sobald sich der Fortschritt zum ersten mal ändert.
      174. ''' </summary>
      175. ''' <remarks></remarks>
      176. Public Event Started As EventHandler
      178. Private _amount, _estimatedAmount As Long
      179. Private _progress As Long
      180. Private _canceled, _started As Boolean
      181. Private _cancelSyncObj As System.Threading.ManualResetEventSlim
      183. ''' <summary>
      184. ''' Bricht den Kopiervorgang ab.
      185. ''' </summary>
      186. ''' <remarks></remarks>
      187. Public Sub Cancel()
      188. If Not _canceled Then
      189. _cancelSyncObj = New System.Threading.ManualResetEventSlim()
      190. _canceled = True
      191. End If
      192. _cancelSyncObj.Wait()
      193. End Sub
      195. Friend ReadOnly Property CancelSyncObj As System.Threading.ManualResetEventSlim
      196. Get
      197. Return _cancelSyncObj
      198. End Get
      199. End Property
      201. ''' <summary>
      202. ''' Gibt an, ob der Vorgang abgebrochen wurde.
      203. ''' </summary>
      204. Public ReadOnly Property Canceled As Boolean
      205. Get
      206. Return _canceled
      207. End Get
      208. End Property
      210. ''' <summary>
      211. ''' Gibt die Gesamtzahl der geschätzten Bytes an, die gelesen wird oder -1, sofern die Gesamtzahl unbekannt ist.
      212. ''' </summary>
      213. Public ReadOnly Property EstimatedAmount As Long
      214. Get
      215. Return _amount
      216. End Get
      217. End Property
      219. ''' <summary>
      220. ''' Gibt die Gesamtzahl der Bytes an, die gelesen wird oder -1, sofern die Gesamtzahl unbekannt ist.
      221. ''' </summary>
      222. Public ReadOnly Property Amount As Long
      223. Get
      224. Return _amount
      225. End Get
      226. End Property
      228. ''' <summary>
      229. ''' Gibt die aktuelle Anzahl der gelesenen Bytes an.
      230. ''' </summary>
      231. Public ReadOnly Property Progress As Long
      232. Get
      233. Return _progress
      234. End Get
      235. End Property
      237. ''' <summary>
      238. ''' Gibt den Fortschritt in Prozent an. Sofern die Anzahl geschätzt wird, wird die geschätzte Zahl als Referenzwert verwendet.
      239. ''' </summary>
      240. Public Function GetPercentage() As Double
      241. Return If(Amount = 0, 1.0, Progress / GetAmount())
      242. End Function
      244. ''' <summary>
      245. ''' Gibt den Fortschritt relativ zur angegebenen Zahl an. Sofern die Anzahl geschätzt wird, wird die geschätzte Zahl als Referenzwert verwendet.
      246. ''' </summary>
      247. Public Function GetPerValue(ByVal value As Integer) As Integer
      248. Return If(Amount = 0, value, CInt(Progress * value \ GetAmount()))
      249. End Function
      251. Private Function GetAmount() As Long
      252. Return If(Amount = -1, EstimatedAmount, Amount)
      253. End Function
      255. Friend Sub AdvanceProgress(ByVal delta As Long)
      256. SyncLock Me
      257. Dim progress As Long = progress + delta
      258. If progress < 0 OrElse progress > Amount Then
      259. Throw New ArgumentOutOfRangeException("progress")
      260. End If
      261. If Not _started Then
      262. _started = True
      263. RaiseEvent Started(Me, EventArgs.Empty)
      264. End If
      265. _progress = progress
      266. End SyncLock
      267. OnProgressChanged(EventArgs.Empty)
      268. End Sub
      270. ''' <summary>
      271. ''' Erhöht den Fortschritt manuell um den angegebenen Wert.
      272. ''' </summary>
      273. ''' <param name="delta">Die Zahl der Bytes, um die der Fortschritt erhöht werden soll.</param>
      274. Protected Sub Advance(ByVal delta As Long)
      275. AdvanceProgress(delta)
      276. End Sub
      278. Friend Sub SetFinished(ByVal canceled As Boolean)
      279. _amount = Progress
      280. RaiseEvent Finished(Me, EventArgs.Empty)
      281. If canceled Then
      282. CancelSyncObj.Set()
      283. OnCanceled()
      284. End If
      285. End Sub
      287. Friend Sub StreamCompleted()
      288. OnStreamCompleted()
      289. End Sub
      291. ''' <summary>
      292. ''' Setzt den Vorgang manuell auf abgeschlossen.
      293. ''' </summary>
      294. Protected Sub SetFinished()
      295. SetFinished(False)
      296. End Sub
      298. ''' <summary>
      299. ''' Initialisiert eine neue Instanz der CopyProgress-Klasse unter Angabe der Gesamtzahl der zu lesenden Bytes.
      300. ''' </summary>
      301. ''' <param name="amount">Die Anzahl der zu lesenden Bytes.</param>
      302. Public Sub New(ByVal amount As Long)
      303. Me.New(amount, amount)
      304. End Sub
      306. ''' <summary>
      307. ''' Initialisiert eine neue Instanz der CopyProgress-Klasse unter Angabe der Gesamtzahl der zu lesenden Bytes.
      308. ''' </summary>
      309. ''' <param name="amount">Die Anzahl der zu lesenden Bytes.</param>
      310. ''' <param name="estimatedAmount">Die geschätzte Anzahl der zu lesenden Bytes.
      311. ''' Dieser Wert wird verwendet, sofern die Gesamtzahl der zu lesenden Bytes unbekannt und somit -1 ist.</param>
      312. Public Sub New(ByVal amount As Long, ByVal estimatedAmount As Long)
      313. _amount = amount
      314. _estimatedAmount = estimatedAmount
      315. End Sub
      317. ''' <summary>
      318. ''' Wird aufgerufen, um den Fortschritt an Ereignisabonnenten weiterzugeben.
      319. ''' </summary>
      320. ''' <param name="e">Enthält nähere Informationen zum Fortschritt.</param>
      321. Protected Overridable Sub OnProgressChanged(ByVal e As EventArgs)
      322. RaiseEvent ProgressChanged(Me, e)
      323. End Sub
      325. ''' <summary>
      326. ''' Wird aufgerufen, sobald ein abgebrochener Vorgang abgeschlossen wurde.
      327. ''' </summary>
      328. Protected Overridable Sub OnCanceled()
      329. End Sub
      331. ''' <summary>
      332. ''' Wird aufgerufen, sobald ein einzelner Stream vollständig kopiert wurde.
      333. ''' </summary>
      334. Protected Overridable Sub OnStreamCompleted()
      335. End Sub
      336. End Class

      Um weitere Informationen, wie z.B. das Startdatum des Kopiervorgangs weiterzugeben, kann man eine Klasse von CopyProgress erben lassen und diese Information manuell setzen. Dazu sollte man dann eben FileCopy.CreateProgress überschreiben. Für allgemeine Kopiervorgänge, für die das nicht benötigt wird, genügt eine FileCopy-Instanz; wenn man die Standardpuffergröße von 4096 Bytes verwenden will, sollte man einfach auf die Instanz FileCopy.General zugreifen, sonst kann man eine neue Instanz erzeugen mit der Puffergröße erzeugen.
      Für frühere Frameworks kann statt des System.Threading.ManualResetEventSlims in CopyProgress auch einfach die System.Threading.ManualResetEvent-Klasse verwendet werden.
      Es handelt sich leider nur um einen Auszug aus der Datei, da sonst die max. Anzahl an Zeichen überschritten wird. Die vollständige Datei befindet sich im Anhang. Ein Beispiel folgt im nächsten Posting.

      Gruß
      ~blaze~
      Dateien

      • FileCopy.vb

        (15,33 kB, 280 mal heruntergeladen, zuletzt: )

      Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „Marcus Gräfe“ ()

      Im folgendem Beispiel wird das Kopieren von einem Ordner aus einer Form heraus gezeigt:
      Benötigt wird eine ProgressBar _progressBar, die den Fortschritt darstellt und ein Button _startCopyButton, der den Kopiervorgang ausführt.

      VB.NET-Quellcode

      1. Private _progress As CopyProgress
      3. Private Sub _startCopyButton(ByVal sender As Object, ByVal e As EventArgs) Handles _startCopyButton.Click
      5. 'Fortschrittsueberwachung in _progress behalten, einen 32 KiB Puffer verwenden
      6. _progress = New FileCopy(32768).CopyDirectory("quellverzeichnis", "zielverzeichnis", IO.SearchOption.AllDirectories)
      8. AddHandler _progress.ProgressChanged, Sub(s, ev)
      9. 'Fortschritt an den Thread fuer ProgressBar _progressBar weiterleiten
      10. BeginInvoke(Sub()
      11. If Not _progress.Canceled Then
      12. 'Fortschritt in der ProgressBar anzeigen
      13. _progressBar.Value = _progressBar.Minimum + _progress.GetPerValue(_progressBar.Maximum - _progressBar.Minimum)
      14. End If
      15. End Sub)
      16. End Sub
      17. End Sub
      19. Protected Overrides Sub OnFormClosing(ByVal e As System.Windows.Forms.FormClosingEventArgs)
      20. _progress.Cancel() 'beim Schliessen der Form abbrechen. Der Vorgang wird nur unterbrochen, das Rueckgaengigmachen muss der Benutzer selbst uebernehmen!
      21. MyBase.OnFormClosing(e)
      22. End Sub


      Gruß
      ~blaze~

    Facebook
    Telefonspende