{"id":358,"date":"2022-11-02T15:10:44","date_gmt":"2022-11-02T14:10:44","guid":{"rendered":"https:\/\/blog.adameczek.pl\/?p=358"},"modified":"2026-01-07T11:46:25","modified_gmt":"2026-01-07T10:46:25","slug":"342","status":"publish","type":"post","link":"https:\/\/blog.adameczek.pl\/index.php\/2022\/11\/02\/342\/","title":{"rendered":"Kopiowanie jest OK, ale r\u00f3b to asynchronicznie"},"content":{"rendered":"\n

Dzi\u015b o kopiowaniu. Tyle, \u017ce nie o kopiowaniu czyjego\u015b kodu, czego nie zalecam robi\u0107 bez zrozumienia, bo mo\u017cna sobie\/klientowi\/pracodawcy zrobi\u0107 krzywd\u0119. B\u0119dzie o kopiowaniu plik\u00f3w. Kopiowanie plik\u00f3w jak wiadomo nie jest operacj\u0105, przez kt\u00f3r\u0105 mieliby\u015bmy nie spa\u0107. NET zapewnia zgrabne metody w statycznych klasach File<\/code> czy Directory<\/code>. Dodajemy sobie przestrze\u0144 System.IO<\/code> i ju\u017c mo\u017cemy kopiowa\u0107 do woli.<\/p>\n\n\n\n

File.Copy("st\u0105d", "tam")<\/code><\/pre><\/div>\n\n\n\n
Je\u015bli chcemy by\u0107 bardziej profi, a na naszym pliku wykonujemy wi\u0119cej ni\u017c jedn\u0105 operacj\u0119, na przyk\u0142ad chcemy do jakiego\u015b pliku dopisywa\u0107 now\u0105 linijk\u0119 upami\u0119tniaj\u0105c\u0105 nowego SMSa, kt\u00f3rego Romek napisa\u0142 do Ali, to mo\u017cemy utworzy\u0107 obiekt  new FileInfo(\"smsy-romka.txt\")<\/code> i u\u017cywa\u0107 go do tego celu. B\u0119dzie si\u0119 to odbywa\u0142o nieco szybciej i fajniej (czyt. profesjonalnie).<\/p>\n\n\n\n
Schody zaczn\u0105 si\u0119, kiedy zamiast tekstowych SMS\u00f3w b\u0119dziemy chcieli skopiowa\u0107 zdj\u0119cia wa\u017c\u0105ce po kilka MB jedno, kt\u00f3re Romek zrobi\u0142 na spacerze, a mia\u0142 Romek du\u017c\u0105 kart\u0119 pami\u0119ci i troch\u0119 czasu. Wtedy mo\u017ce to potrwa\u0107 d\u0142u\u017cej. Ca\u0142kiem nam si\u0119 humor popsuje, je\u015bli pliki trzeba b\u0119dzie przesy\u0142a\u0107 przez sie\u0107, nie w obr\u0119bie jednej maszyny. Wtedy najwolniejszym ogniwem nie b\u0119dzie nasz dysk, tylko wydajno\u015b\u0107 sieci, a z t\u0105 bywa r\u00f3\u017cnie.<\/p>\n\n\n\n
Takim kopiowaniem, jak pokaza\u0142em powy\u017cej zablokujesz w\u0105tek. Je\u015bli jest to w\u0105tek UI, to aplikacja stanie si\u0119 \u201etrudna w kontakcie\u201d lub inaczej m\u00f3wi\u0105c nie responsywna i mo\u017ce si\u0119 okaza\u0107, \u017ce nawet nie da si\u0119 jej zamkn\u0105\u0107 (WinForms). Sprytnie mo\u017cesz przekaza\u0107 taki przyd\u0142ugi proces do wykonania w tle w w\u0105tku pobranym z puli, a w\u0105tek g\u0142\u00f3wny mo\u017ce w tym czasie wykonywa\u0107 inne zadania, jakie dla niego wymy\u015blimy, albo obs\u0142ugiwa\u0107 interfejs u\u017cytkownika.<\/p>\n\n\n\n
var copyTask = Task.Run(() => File.Copy("st\u0105d", "tam"));<\/code><\/pre><\/div>\n\n\n\n
\n
Kopiowanie plik\u00f3w wykonywane przez OS \u201epod spodem\u201d .NET jest asynchroniczne. Dlatego zatrudnienie nowego w\u0105tku niczego nie polepszy, je\u015bli Task.RunI() zastosujemy w kodzie asynchronicznym. Taki trik ma sens tylko, je\u015bli znajdzie si\u0119 w kodzie wykonywanym przez g\u0142\u00f3wny w\u0105tek aplikacji.<\/p>\n<\/blockquote>\n\n\n\n
Trzeba poczeka\u0107 na zako\u0144czenie tego Tasku wydaj\u0105c komend\u0119: await copyTask<\/code>. Po doj\u015bciu do await<\/code>, w\u0105tek g\u0142\u00f3wny przejdzie do innych zada\u0144. I je\u015bli jest to aplikacja webowa lub okienkowa, to natychmiast docenimy zalety naszego posuni\u0119cia, bo aplikacja przestanie \u201elagowa\u0107\u201d. W wypasionej wersji mo\u017cna nawet przekaza\u0107 CancellationToken<\/code>, aby sko\u0144czy\u0107 z takim Taskiem, gdyby oczekiwanie znudzi\u0142o usera i postanowi\u0142 zamkn\u0105\u0107 aplikacj\u0119.<\/p>\n\n\n\n
Jest jednak jeden problem. Po zamkni\u0119ciu aplikacji przed zako\u0144czeniem kopiowania system plik\u00f3w zostawi nam w docelowej lokalizacji plik z przypadkow\u0105 zawarto\u015bci\u0105. Na dodatek zaalokuje miejsce na dysku. Romek nawet nie b\u0119dzie wiedzia\u0142, \u017ce straci\u0142 swoje zdj\u0119cie!<\/p>\n\n\n\n
Aby temat ogarn\u0105\u0107 tak, \u017ceby wstydu nie by\u0142o, wypada\u0142o by zrobi\u0107 dwie rzeczy:<\/p>\n\n\n\n
    \n
  1. Zadanie kopiowania wykona\u0107 asynchronicznie, ale tak, \u017ceby ewentualny shut down aplikcji da\u0142 nam czas na zwolnienie zasob\u00f3w i posprz\u0105tanie, zanim ostatecznie aplikacja zostanie zamkni\u0119ta.<\/li>\n\n\n\n
  2. Posprz\u0105tanie pozosta\u0142o\u015bci po przerwanym zadaniu.\n\n\n\n\n\n\n\n<\/li>\n<\/ol>\n\n\n\n
    Do pierwszego punktu u\u017cyjemy klasy FileStream<\/code>, kt\u00f3ra zawiera asynchroniczn\u0105 metod\u0119 CopyToAsync<\/code>. Nie b\u0119dziemy oryginalni i u\u017cyjemy tej metody. Czyli kopiujemy tak:<\/p>\n\n\n\n
    async Task CopyFileAsync(string sourcePath, string destinationPath)\n{\n    var sourceStream = new FileStream(sourcePath, FileMode.Open, FileAccess.Read);\n    var destinationStream = new FileStream(destinationPath, FileMode.CreateNew, FileAccess.Write);\n    await sourceStream.CopyToAsync(destinationStream);\n}<\/code><\/pre><\/div>\n\n\n\n
    \n
    Kod jest uproszczony, aby by\u0142 przejrzysty. Pe\u0142ny dzia\u0142aj\u0105cy kod mo\u017cna znale\u017a\u0107 na Githubie. Link znajduje si\u0119 pod artyku\u0142em.<\/p>\n<\/blockquote>\n\n\n\n
    Jest prawie super, ale musimy rozwi\u0105za\u0107 temat sprz\u0105tania po ewentualnym przerwaniu kopiowania. Poprawiona wersja wygl\u0105da tak:<\/p>\n\n\n\n
    async Task CopyFileAsync(string sourcePath, string destinationPath, CancellationToken cancellationToken)\n{\n    try\n    {\n        var sourceStream = new FileStream(sourcePath, FileMode.Open, FileAccess.Read);\n        var destinationStream = new FileStream(destinationPath, FileMode.CreateNew, FileAccess.Write);\n        await sourceStream.CopyToAsync(destinationStream, cancellationToken);\n    }\n    catch (OperationCanceledException)\n    {\n        var cts = new CancellationTokenSource();\n        cts.CancelAfter(TimeSpan.FromSeconds(3));\n        await Delete(destinationPath, cts.Token);\n    }\n    catch (Exception)\n    {\n        using var cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);\n        cts.CancelAfter(TimeSpan.FromSeconds(10));\n        await Delete(destinationPath, cts.Token);\n        throw;\n    }\n}<\/code><\/pre><\/div>\n\n\n\n
    Po pierwsze, asynchroniczna metoda CopyToAsync<\/code> przyjmuje CancellationToken<\/code>, wi\u0119c korzystamy z tego natychmiast i przekazujemy do niej token (linia 7).<\/p>\n\n\n\n
    Po drugie, w linii 9 przechwytujemy OperationCanceledException<\/code> i czas jaki mamy na zamkmi\u0119cie procesu wykorzystujemy na skasowanie pliku, kt\u00f3ry zosta\u0142 utworzony w docelowej lokalizacji, ale na pewno b\u0119dzie uszkodzony, bo przecie\u017c kopiowanie zosta\u0142o przerwane. W tym celu tworzymy nowy token, kt\u00f3ry daje metodzie Delete<\/code>() trzy d\u0142ugie sekundy z pi\u0119ciu jakie defaultowo dostaje aplikacja na zamkni\u0119cie (linia 12).<\/p>\n\n\n\n
    Po trzecie, w przypadku innego b\u0142\u0119du tak\u017ce kasujemy plik, kt\u00f3ry najprawdopodobniej b\u0119dzie uszkodzony, ale dodatkowo rzucamy wyj\u0105tek do kodu wywo\u0142uj\u0105cego kopiowanie. Niech go sobie obs\u0142u\u017cy (linia 20).<\/p>\n\n\n\n
    W ten spos\u00f3b kopiowanie nawet du\u017cych plik\u00f3w mo\u017ce odbywa\u0107 si\u0119 bez utraty responsywno\u015bci aplikacji, a ewentualne b\u0142\u0119dy nie powoduj\u0105 \u015bmietnika w systemie plik\u00f3w. Kod, kt\u00f3ry jest na Githubie <\/a>dodatkowo pilnuje cyklu \u017cycia egzemplarzy FileStream<\/code>. Ma te\u017c zaimplementowan\u0105 flag\u0119 overvrite i ma dodatkow\u0105 metod\u0119 MoveFileAsync<\/code>.<\/p>\n\n\n\n
    W ka\u017cdym kodzie znajdzie si\u0119 co\u015b do poprawienia. Nie inaczej jest w tym przypadku. Plik po zapisaniu w nowej lokalizacji powinien by\u0107 zweryfikowany na okoliczno\u015b\u0107 zgodno\u015bci z orygina\u0142em. Mo\u017cna to zaimplementowa\u0107 przez obliczenie skr\u00f3t\u00f3w orygina\u0142u i kopii i por\u00f3wnaniu ich warto\u015bci. Je\u015bli nie s\u0105 zgodne, to co\u015b posz\u0142o nie tak i nale\u017cy taki przypadek obs\u0142u\u017cy\u0107.<\/p>\n\n\n\n
    Uwaga na koniec<\/h2>\n\n\n\n
    Z punktu widzenia aplikacji .net metoda File.Copy<\/code> wykona si\u0119 synchronicznie i kod wywo\u0142uj\u0105cy File.Copy<\/code> rzeczywi\u015bcie na chwil\u0119 spauzuje. Jednak operacje I\/O s\u0105 asynchroniczne na poziomie systemu operacyjnego. Co wi\u0119cej, aplikacja wykonuj\u0105ca si\u0119 pod kontrol\u0105 Windows nawet nie otrzymuje danych do kopiowania. .net przesy\u0142a do systemu informacje o pliku i reszta odbywa si\u0119 ju\u017c bardzo szybko na poziomie systemu. Zatem mo\u017cesz spokojnie stosowa\u0107 synchroniczne komendy np. File.Copy<\/code> w swoim kodzie.<\/p>\n\n\n\n
    Kiedy wobec tego stosowa\u0107 kopiowanie asynchroniczne? <\/h2>\n\n\n\n
    Rowa\u017c to rozwi\u0105zanie kiedy<\/p>\n\n\n\n