Umumnya ada dua metode pembaruan aplikasi: satu adalah memberi tahu pengguna (seperti mengirim email) dan meminta pengguna untuk mengunduh program yang diperbarui dari alamat situs web yang ditentukan; yang lainnya adalah dengan mengalihkan tanggung jawab pembaruan dari pengguna ke aplikasi itu sendiri. Daripada pengguna mendapatkan dan menginstal pembaruan perangkat lunak, aplikasi klien itu sendiri bertanggung jawab untuk mengunduh dan menginstal pembaruan dari server yang dikenal. Satu-satunya intervensi yang perlu dilakukan pengguna adalah memutuskan apakah mereka ingin menginstal pembaruan baru sekarang atau Nanti. Tentu saja, yang terakhir ini lebih ramah daripada yang pertama. Anda sekarang dapat melihat produk sebenarnya yang menyerupai pendekatan terakhir, seperti Windows XP dan Microsoft Money. Komponen pembaruan aplikasi .NET yang diperkenalkan dalam artikel ini dapat menyediakan fungsionalitas serupa.
1. Pengenalan komponen pembaruan aplikasi .NET
Komponen pembaruan aplikasi .NET AppUpdater dikembangkan menggunakan kerangka .NET. Meskipun AppUpdater bukan produk Microsoft, selama Anda menambahkan komponen ke toolbar VS.NET, Anda dapat menarik dan melepas komponen dari toolbar ke dalam aplikasi Anda seperti menggunakan komponen lainnya setelah mengatur beberapa properti (seperti lokasi dan frekuensi memperoleh pembaruan, dll.), aplikasi klien Anda dapat memiliki fungsi pembaruan otomatis.
2. Prinsip Kerja
Untuk memahami secara mendalam prinsip kerja komponen pembaruan aplikasi klien .NET, Anda perlu mempelajari dengan cermat apa yang harus dilakukan untuk mengimplementasikan pembaruan aplikasi klien. Langkah pertama adalah memeriksa apakah ada pembaruan; ketika pembaruan ditemukan, mulai langkah kedua - unduh pembaruan, ketika unduhan pembaruan selesai, lanjutkan ke langkah terakhir - terapkan pembaruan;
(1) Periksa pembaruan.
Sebagai pengembang, Anda harus memberi tahu aplikasi terlebih dahulu di mana harus memeriksa pembaruan. Jika tidak, bukankah itu seperti mencari jarum di tumpukan jerami? Kedua, tentukan kapan harus memeriksa pembaruan. Tidak mungkin bagi pengguna untuk menjalankan program klien setiap saat dan program tersebut terus-menerus memeriksa pembaruan di latar belakang. Satu hal penting terakhir yang harus diatasi adalah cara memeriksa pembaruan. Komponen Pembaruan Aplikasi .NET menggunakan HTTP untuk komunikasi, yang memungkinkan aplikasi klien melakukan pembaruan melalui firewall. Dan alamat yang diperlukan untuk pemeriksaan pembaruan menjadi alamat URL server web yang dikenal, dan masalah pertama berhasil diselesaikan.
Komponen pembaruan aplikasi .NET menghasilkan thread berdasarkan pembuatan komponen, yang bertanggung jawab untuk pemeriksaan pembaruan. Thread ini sebagian besar tertidur, tetapi aktif pada interval yang ditentukan dan melakukan pemeriksaan pembaruan. Frekuensi aplikasi memeriksa pembaruan baru bergantung pada aplikasinya. Nilai umum untuk interval antara pemeriksaan pembaruan biasanya berkisar dari satu jam hingga beberapa hari. Pendekatan dasar dalam pemungutan suara ini tidak cocok untuk setiap situasi. Misalnya, Microsoft Money hanya memeriksa pembaruan saat pengguna memintanya. Dalam hal ini, thread polling pembaruan dapat dinonaktifkan.
Pemeriksaan pembaruan diimplementasikan dengan memanggil metode CheckForUpdate() komponen pembaruan dengan sebuah perintah.
Ada beberapa metode tentang cara melakukan pemeriksaan pembaruan:
Metode 1: Pemeriksaan file langsung - Gunakan HTTP untuk membandingkan stempel tanggal/waktu modifikasi terakhir dari aplikasi server dan klien untuk melihat apakah keduanya konsisten. Jika ada file yang diperbarui di server, klien mengetahui bahwa file tersebut dapat diperbarui sendiri. Hal yang sama berlaku untuk browser web, yang mengetahui apakah ia perlu mengunduh ulang halaman atau gambar html atau apakah ia dapat menggunakan kembali yang diunduh sebelumnya. Ketika versi baru aplikasi tersedia, administrator cukup menyalin versi yang lebih baru ke versi yang lebih lama di server Web. Masalah dengan pendekatan ini adalah pembaruan tidak otomatis sehingga ada potensi kegagalan. Misalnya, jika administrator memperbarui versi aplikasi di server Web, dan pelanggan mengunduh versi sebelum pembaruan, maka komputer pelanggan akan memiliki beberapa file dari sebelum pembaruan, serta beberapa file dari versi baru. versi setelah pembaruan dokumen. Karena alasan di atas, pemeriksaan pembaruan file secara langsung tidak disarankan untuk aplikasi penting.
Metode 2: Pemeriksaan eksplisit - gunakan file konfigurasi eksplisit di server. File eksplisit server yang valid untuk digunakan dengan komponen pembaruan aplikasi .NET terlihat seperti ini: ..
<VersionConfig>
＜Versi yang Tersedia＞1.0.0.0＜/Versi yang Tersedia＞
＜Url Aplikasi＞ http://localhost/demos/selfupdate/V1/ ＜/
Url Aplikasi＞
</VersionConfig>
AvailableVersion menentukan nomor versi perakitan terbaru yang tersedia. Atribut ApplicationURL menentukan alamat URL tempat versi aplikasi ini berada. Ketika administrator ingin memperbarui aplikasi klien, mereka menyalin versi baru aplikasi ke server Web dan memodifikasi file eksplisit server dengan tepat. Klien sendiri akan mendeteksi bahwa file eksplisit server telah diubah, dan kemudian mengunduh file eksplisit tersebut. Klien kemudian membandingkan nomor versi perakitan yang ditentukan dalam file eksplisit dengan nomor versi file EXE aplikasi. Jika nomor versi yang lebih baru tersedia di file eksplisit server, aplikasi mengetahui bahwa nomor tersebut perlu diperbarui. Metode ini direkomendasikan untuk sebagian besar aplikasi.
Metode tiga: Pemeriksaan Layanan Web XML-Layanan Web XML menyediakan metode pemeriksaan pembaruan yang lebih canggih. Misalnya, Anda ingin memperbarui sekumpulan pengguna awal sebelum memperbarui pengguna lain. Jika aplikasi klien memanggil Layanan Web XML untuk memeriksa apakah pembaruan tersedia, Layanan Web XML tersebut juga dapat menanyakan database untuk pengguna tersebut dan menentukan apakah pengguna tersebut adalah pengguna awal. Jika mereka adalah pengguna awal, Layanan Web XML mengembalikan nilai yang menunjukkan bahwa pembaruan tersedia. Jika tidak, Layanan Web mengembalikan nilai yang menunjukkan bahwa pembaruan tidak tersedia. Namun, komponen pembaruan aplikasi .NET yang diperkenalkan dalam artikel ini tidak menyediakan dukungan langsung Layanan Web XML.
Untuk menggunakan Layanan Web XML untuk melakukan pemeriksaan pembaruan, pertama-tama buat Layanan Web XML dan kaitkan peristiwa OnCheckForUpdate. Hal ini memungkinkan Anda untuk menulis pemeriksaan khusus Anda sendiri sebagai pengganti pemeriksaan pembaruan thread poller. Peristiwa OnCheckForUpdate memiliki nilai kembalian yang menunjukkan apakah pembaruan terdeteksi.
(2) Mengunduh pembaruan
Ketika komponen pembaruan aplikasi .NET mendeteksi bahwa pembaruan baru tersedia, maka secara otomatis akan memulai thread lain dan memulai pengunduhan pembaruan di latar belakang yang tidak sinkron.
Pengunduhan dilakukan menggunakan HTTP-DAV. DAV adalah versi HTTP yang diperluas, yang menyediakan fungsionalitas seperti enumerasi direktori dan file. Proses pengunduhan lengkap dimulai dengan menentukan URL. URL yang digunakan untuk mengunduh bergantung pada metode yang digunakan untuk menyelesaikan pemeriksaan pembaruan. Misalnya, jika Anda menggunakan file eksplisit server, URL yang digunakan untuk mengunduh pembaruan ditentukan melalui atribut ApplicationURL di file eksplisit server.
Pengunduhan pembaruan jelas memerlukan ketahanan. Tidak diperbolehkan meninggalkan aplikasi klien dalam keadaan tidak stabil setelah mengunduh dan memperbarui. Sejumlah masalah mungkin terjadi selama proses pengunduhan: server web tempat file pembaruan mungkin tidak aktif, mesin klien mungkin macet, atau pengguna mungkin menutup aplikasi karena alasan tertentu. Karena aplikasi sedang diunduh, jika ditutup, unduhan akan berhenti. Solusi desain alternatif adalah dengan menggunakan layanan sistem terpisah untuk pengunduhan dan pembaruan aplikasi. Dengan menggunakan layanan sistem, pengunduhan pembaruan terus berlanjut meskipun aplikasi itu sendiri tidak berjalan. Faktanya, Windows XP memiliki layanan pengunduhan bawaan yang disebut BITS, yang melayani tujuan ini. BITS digunakan oleh Windows XP untuk mengunduh dan memperbarui Windows itu sendiri. Untuk informasi lebih lanjut tentang BITS, lihat http://msdn.microsoft.com/library/en-us/dnwxp/html/WinXP_BITS.asp . Layanan ini tidak digunakan pada komponen .NET Application Update, sehingga dapat digunakan pada Windows 9x yang tidak mendukung layanan sistem.
(3) Menerapkan Pembaruan
Komponen pembaruan aplikasi .NET memperoleh ketahanan dengan membagi proses pengunduhan dan pembaruan menjadi dua fase terpisah. Ketika setiap tahap selesai, itu dicatat dalam file manifes yang diperbarui yang terletak di direktori aplikasi klien. Jika proses pengunduhan atau pembaruan terganggu pada tahap apa pun, maka pekerjaan asli akan dilanjutkan dari breakpoint terakhir yang diselesaikan pada saat aplikasi dimulai lagi. Setiap tahapan dapat dijalankan ulang, jadi jika terjadi kegagalan di tengah-tengah tahapan, menjalankan ulang tahapan tersebut akan berhasil. Jika terjadi kesalahan, seperti koneksi ke server terputus selama pengunduhan, komponen pembaruan .NET akan mencoba lagi nanti. Jika terlalu banyak kesalahan yang dilaporkan (misalnya, server web tidak pernah kembali online), pengunduhan dan pembaruan akan dibatalkan dan kesalahan dilaporkan.
Pendekatan pertama kami adalah memulai proses terpisah untuk mengimplementasikan pembaruan. Proses terpisah ini pertama-tama akan menghentikan proses aplikasi, mengimplementasikan pembaruan (karena sekarang tidak terkunci), memulai ulang proses aplikasi, dan kemudian mematikan sendiri setelah selesai. Oleh karena itu, ada tiga masalah mendasar dengan desain ini:
Dalam beberapa kasus, desain ini tidak berfungsi. Ketika suatu aplikasi diperbarui, proses pembaruan menutup proses aplikasi asli, dan proses pembaruan itu sendiri juga ditutup, sehingga pembaruan tidak akan dilaksanakan.
. Kami ingin dapat memperbarui semua kode yang perlu diperbarui secara otomatis. Kami ingin kemampuan untuk menginstal patch secara otomatis tidak hanya pada aplikasi, namun juga pada komponen Pembaruan Aplikasi .NET itu sendiri. Dengan menggunakan mode ini, kami tidak dapat memperbarui proses yang mengimplementasikan pembaruan.
. Tidak sopan memaksa pengguna menutup aplikasi dan menunggu saat menggunakannya.
Metode terakhir yang digunakan untuk mengimplementasikan pembaruan aplikasi adalah dengan menggunakan pola perakitan paralel .NET Framework. Sebagai alternatif untuk mencoba memperbarui aplikasi itu sendiri, buatlah versi aplikasi yang lebih baru dari versi yang ada saat ini.
Versi baru dapat dihasilkan dengan menggabungkan katalog aplikasi yang ada saat ini dengan versi terbaru yang diunduh. Ketika versi baru selesai, pengguna akan secara otomatis menggunakan versi baru saat mereka membuka kembali aplikasi di lain waktu. Salinan aplikasi asli kemudian dapat dihapus. Hal yang sulit adalah mencari tahu versi mana yang harus dimuat pada saat tertentu. Kami memperkenalkan aplikasi bernama Appstart. Appstart adalah titik masuk ke aplikasi Anda. Dengan menggunakan mode ini, direktori aplikasi Anda terlihat seperti ini: ..
--> Program Files
--> MyApp
--> Appstart.exe
--> Appstart.config
- -> V1 Folder
-- > MyApp.exe
--> Folder V1.1
--> MyApp.exe
Untuk menjalankan aplikasi Anda, biasanya Anda memulai Appstart.exe. Jika Anda ingin memiliki tombol pintas di desktop, tombol pintas tersebut harus mengarah ke Appstart dan tidak langsung ke aplikasi (perhatikan bahwa Anda dapat mengganti nama AppStart.exe menjadi apa pun yang Anda inginkan, seperti YourApp.exe) Appstart.exe Itu adalah sebuah program yang sangat sederhana yang membaca file Appstart.config dan memuat aplikasi yang ditentukan. File Appstart.config yang valid terlihat seperti ini:
<Config>
＜NamaFolder Aplikasi＞Folder V1＜/NamaFolder Aplikasi＞
＜AppExeName＞MyApp.exe＜/AppExeName＞
＜AppLaunchMode＞domain aplikasi＜/AppLaunchMode＞
＜/Konfigurasi＞
AppFolderName menentukan subfolder yang berisi versi aplikasi yang sedang dijalankan. AppExeName berisi nama file exe yang akan dimuat di folder tersebut. Ketika pembaruan aplikasi selesai, langkah terakhir adalah mengubah nilai AppFolderName agar mengarah ke versi aplikasi yang baru. Dengan cara ini, saat pengguna menjalankan aplikasi lagi, versi aplikasi terbaru yang diperbarui akan berjalan. AppLaunchMode menentukan bagaimana aplikasi dimuat. Ada dua cara untuk memuat aplikasi: Cara pertama adalah dengan menggunakan AppDomains. AppDomains adalah fitur runtime bahasa umum kerangka .NET dan juga merupakan unit logis independen dan objek manajemen. Runtime bahasa umum memungkinkan beberapa domain aplikasi per proses. Dengan cara ini Appstart.exe dapat memuat aplikasi Anda di AppDomain terpisah tetapi dalam proses AppStart.exe yang sama. Terlepas dari kenyataan bahwa ada dua program exe berbeda yang berjalan (yaitu Appstart.exe dan MyApp.exe), hanya satu proses yang digunakan. AppDomains akan berfungsi dengan baik untuk sebagian besar aplikasi, meskipun ada beberapa perbedaan kecil antara menjalankan AppDomain terpisah dan menjalankan dalam proses terpisah. Dalam hal ini, AppLaunchMode dapat diatur ke "proses", yang akan menyebabkan aplikasi dimuat dalam proses terpisah.
Setelah Appstart meluncurkan aplikasi, ia masuk ke mode tidur menunggu aplikasi dihentikan. Setelah aplikasi dihentikan, Appstart juga ditutup.
3. Panduan Contoh
Sebelumnya kita telah membahas cara kerja pembaruan aplikasi .NET, sekarang mari kita terapkan pada sebuah contoh.
Langkah 1: Buat aplikasi untuk diperbarui
1. Gunakan VS.NET untuk menghasilkan proyek aplikasi Windows baru, bernama "SampleApp".
2. Berikan warna latar belakang yang menarik sesuai pilihan Anda. Kami akan menggunakan warna latar belakang untuk membedakannya dari versi yang diperbarui nanti.
3. Sekarang mari tambahkan fitur halus ke aplikasi ini. Pertama, tambahkan tombol ke formulir Anda. File terkompresi berisi rakitan dengan Formulir Windows sederhana. Tambahkan referensi ke rakitan SamplesSampleAppSimpleForm di file terkompresi. Kemudian tambahkan dua baris kode ke event handler tombol Anda:
..
SimpleForm.Form1 F = baru SimpleForm.Form1();
F.Tampilkan();
4. Ubah flag build Anda dari debug menjadi RELEASE. Ini akan memungkinkan kita menghindari masalah penguncian file pdb di kemudian hari ketika kita membuat aplikasi versi baru saat salinan asli sedang berjalan. Bangun dan uji aplikasi Anda.
Langkah 2: Tambahkan komponen pembaruan aplikasi .NET
1. Pada tab Komponen pada toolbar VS.NET, klik kanan dan pilih "Sesuaikan Toolbar". Pilih tab "Komponen .NET Framework". Klik "Jelajahi" dan pilih AppUpdater.dll yang terletak di bawah proyek AppUpdater di file terkompresi, klik OK.
2. Ikon AppUpdater sekarang akan muncul di bagian bawah daftar komponen toolbar. Seret dan lepas komponen AppUpdater ke formulir SampleApp. Contoh komponen Pembaruan Aplikasi .NET bernama appUpdater1 muncul di bagian bawah formulir.
Langkah 3: Menyiapkan komponen pembaruan aplikasi .NET
Pada langkah ini kita akan menyiapkan komponen pembaruan aplikasi .NET. Perhatikan bahwa dalam contoh ini Anda hanya perlu mengubah empat properti pertama, membiarkan sisanya pada nilai defaultnya.
Atribut AppUpdater: Ini adalah inti dari pembaruan aplikasi Aplikasi .NET. Pengaturan berikut perlu dibuat untuk program ini:
(1) AutoFileLoad: Ini mengontrol karakteristik pengunduhan perintah yang akan dijelaskan nanti.
(2) ChangeDetectionMode: Pencacahan ini menentukan cara memeriksa pembaruan. Dalam contoh ini, kita akan menggunakan pemeriksaan eksplisit server, jadi setel nilainya ke "ServerManifestCheck".
(3) ShowDefaultUI: Komponen pembaruan aplikasi .NET memiliki serangkaian antarmuka pengguna untuk memberi tahu pengguna tentang beberapa peristiwa, seperti pembaruan baru yang tersedia atau kesalahan yang terjadi selama pembaruan. UI ini dapat dinonaktifkan dengan menyetel UI default ke tidak valid dan menggantinya dengan UI khusus aplikasi khusus, menghubungkan ke peristiwa yang sesuai (mis.
OnUpdateComplete) dan munculkan antarmuka pengguna khusus. Untuk contoh ini kita akan menggunakan antarmuka pengguna default, jadi atur nilainya menjadi true.
(4) UpdateUrl: UpdateUrl menentukan di mana program pembaruan akan mencari pembaruan. Dalam contoh ini kita menggunakan file eksplisit server untuk memeriksa pembaruan, jadi properti ini harus disetel ke URL file eksplisit server.
Dalam contoh ini setel ke: http://yourWebserver/SampleApp_ServerSetup/UpdateVersion.xml . Silakan ganti "server Web Anda" dengan nama server Web Anda.
Properti Pengunduh: Komponen AppUpdater memiliki dua subkomponen. Yang pertama disebut Downloader, yang mengontrol properti pengunduhan dan Poller komponen: Subkomponen kedua AppUpdater adalah Poller, yang mengontrol pemeriksaan pembaruan.
(1)Mulai Otomatis: Nilai Boolean yang mengontrol apakah Poller harus mulai melakukan polling saat aplikasi dimulai atau apakah harus menunggu hingga kueri pembaruan terencana dimulai.
(2) DownloadOnDetection: Nilai Boolean, mengontrol apakah Poller segera mulai mengunduh pembaruan ketika pembaruan baru ditemukan, atau apakah akan memulai pengunduhan eksplisit dengan memanggil metode DownloadUdpate().
(3)InitialPollInterval: Jumlah detik untuk menunggu sebelum melakukan pemeriksaan pembaruan pertama setelah aplikasi dimulai.
(4)PollInterval: Setelah pemeriksaan pembaruan pertama, PollInterval mengontrol jumlah detik antara setiap pemeriksaan pembaruan berikutnya. Catatan: Defaultnya adalah memeriksa setiap 30 detik, tentu saja Anda ingin aplikasi Anda mengurangi jumlah pemeriksaan pembaruan .
Setelah semua ini selesai, tabel properti Anda akan terlihat seperti ini:
Direktori SamplesSampleAppSampleApp_Complete berisi versi aplikasi yang diinstal dengan benar.
Instalasi:
(1)DownloadRetryAttempts: Jika terjadi kesalahan selama pengunduhan (seperti server Web sedang down) pengunduh akan mencoba lagi nanti. Properti ini mengontrol berapa kali pengunduh mencoba ulang permintaan jaringan sebelum menganggapnya sebagai kesalahan pembaruan aplikasi yang lengkap.
(2)SecondsBeteweenDownloadRety: Jumlah detik yang harus ditunggu sebelum mencoba kembali permintaan jaringan.
(3)UpdateRetryAttempts: Jika terjadi kesalahan serius selama pembaruan (misalnya, pengunduh melebihi jumlah percobaan ulang), kesalahan pembaruan aplikasi akan dihasilkan. Secara default, upaya pembaruan akan dihentikan. Namun ia akan mencoba memulihkan saat aplikasi dijalankan lagi (misalnya, pembaruan server web mungkin terhenti selama beberapa hari). Properti ini mengontrol berapa kali pembaruan dilakukan. Jika nilai ini terlampaui, pembaru akan membatalkan pembaruan, mengatur ulang statusnya, dan kembali memeriksa pembaruan.
(4)ValidateAssemblies: Atribut ini mengontrol tingkat penyelesaian rakitan yang diunduh secara efektif. Lihat bagian Keamanan artikel ini untuk informasi lebih lanjut.
Langkah 4: Hasilkan dan terapkan aplikasi versi V1 pada klien.
Dalam proyek SampleApp, buka file AssemblyInfo.cs. Ubah nilai AssemblyVersion dari "1.0" menjadi "1.0.0.0". Hal ini menyebabkan ketika membangun Majelis untuk mendapatkan tag dengan nilai "1.0.0.0".. alih-alih nilai yang biasanya ditentukan VS.NET sebagai kenaikan.
1. Bangun aplikasinya.
2. Salin direktori SamplesSampleAppSampleApp_ClientSetup dari file terkompresi ke mesin lokal Anda. Perhatikan bahwa direktori ini sudah berisi AppStart.exe. AppStart.config telah diatur untuk menunjuk ke direktori 1.0.0.0 dan memulai SampleApp.exe.
Salin SampleApp (Appupdater.dll, SimpleForm.dll dan SampleApp.exe) dari direktori rilis SampleApp
ke direktori klien SampleApp_ClientSetup1.0.0.0. Pada titik ini, versi aplikasi yang berfungsi penuh telah "diinstal" pada klien dan dapat dijalankan dengan menjalankan AppStart.exe.
Langkah 5: Instal Server Web
Pada langkah ini kita akan menginstal server Web untuk menyediakan fungsionalitas polling pembaruan. Komponen Pembaruan Aplikasi .NET menggunakan HTTP-DAV untuk mengunduh pembaruan aplikasi dan oleh karena itu memerlukan server web yang mendukung HTTP-DAV. IIS5.0 pada Windows 2000 dan sistem operasi yang lebih baru mendukung HTTP-DAV.
1. Salin direktori Samples/SampleApp_ServerSetup ke direktori wwwroot di server Web Anda.
2. Salin SampleApp versi V1 ke folder 1.0.0.0 di server web.
3. Aktifkan izin "Penjelajahan Direktori" IIS untuk direktori SampleApp_ServerSetup di server web.
Langkah Keenam: Update Aplikasi Secara Otomatis
Oke,... Sekarang saatnya melihat hasil dari semua kerja keras ini dengan menginstal versi baru secara otomatis.
1. Jika versi SampleApp yang Anda terapkan pada klien tidak berjalan, muat dan biarkan berjalan.
2. Kembali ke VS.NET dan buat beberapa perubahan nyata pada formulir SampleApp (seperti mengubah warna latar belakang).
3. Ubah informasi versi AssemblyInfo.cs menjadi 2.0.0.0.
4. Regenerasi.
5. Kembali ke server Web dan buat direktori 2.0.0.0 yang setara dengan direktori 1.0.0.0. Salin versi baru aplikasi dari direktori pembuatan rilis ke direktori 2.0.0.0 yang baru dibuat di server Web.
6. Buka UpdateVersion.xml dan ubah AvailableVersion menjadi 2.0.0.0. Ubah ApplicationURL agar mengarah ke jalur 2.0.0.0 yang baru.
7. Simpan perubahan yang dilakukan pada UpdateVersion.xml.
Setelah Anda menyimpan UpdateVersion.xml baru, dalam waktu 30 detik, salinan SampleApp yang berjalan akan mendeteksi versi baru yang tersedia.
4. Instalasi sesuai permintaan, keamanan, skalabilitas, dan debugging
(1) Instalasi sesuai permintaan
Yang disebut instalasi sesuai permintaan berarti bahwa hanya program utama yang dapat dieksekusi yang diinstal secara eksplisit di komputer klien. Aplikasi lainnya dapat diunduh dan diinstal secara otomatis berdasarkan kebutuhan dasar.
Memulai instalasi sesuai permintaan melalui properti AutoFileLoad komponen pembaruan aplikasi .NET. Anda harus hati-hati mempertimbangkan letak batasan rakitan dalam aplikasi Anda dan tindakan apa yang akan menyebabkan rakitan diunduh. Karena pengunduhan rakitan melibatkan input dan output jaringan, waktu yang diperlukan untuk mengunduh bervariasi. Selama pengunduhan rakitan, aplikasi dibekukan menunggu pengunduhan rakitan selesai.
(2) Penerapan
Kemampuan untuk menginstal pembaruan aplikasi secara otomatis dengan aman memiliki banyak manfaat, namun juga memiliki beberapa potensi bahaya. Saat Anda mempermudah penginstalan pembaruan, Anda juga dapat mempermudah penginstalan kode berbahaya jika Anda tidak hati-hati. Ada dua bahaya. Bahaya pertama adalah seseorang akan menggunakan server webnya sendiri untuk mengelabui server web yang digunakan untuk menyebarkan pembaruan. Mereka mungkin menggunakan server web tersebut untuk memasang virus di jalur aplikasi Anda. Cara paling sederhana untuk mencegah spoofing atau gangguan tidak patut lainnya melalui jaringan adalah dengan menggunakan HTTPS. Untuk menggunakan HTTPS dengan komponen Pembaruan Aplikasi .NET, cukup ganti URL HTTP dengan URL HTTPS. Tentu saja, HTTPS bukanlah obat mujarab. Ada dua masalah dalam penggunaan HTTPS. Yang pertama adalah skalabilitas. Menggunakan HTTPS mengharuskan server untuk mengenkripsi semua file yang diunduh dari server web. Jika file pembaruan aplikasi berukuran besar, biaya enkripsi file pembaruan dapat membebani server. Masalah lain dalam menggunakan HTTPS adalah ia tidak memberikan manfaat apa pun terhadap bahaya keamanan kedua. Bahaya kedua adalah hacker dapat menyerang server Anda dari dalam maupun dari luar. Jika serangan berhasil, ratusan atau ribuan klien juga terpengaruh oleh pembaruan otomatis, yang akan menjadi bencana besar.
Untuk mengatasi masalah ini, komponen Pembaruan Aplikasi .NET menggunakan fitur nama yang kuat untuk rakitan .NET untuk memverifikasi rakitan yang diunduh. Jika komponen Pembaruan Aplikasi .NET mendeteksi bahwa rakitan tidak ditandatangani dengan kunci Anda selama pengunduhan, pengunduhan akan dibatalkan. Artinya hanya seseorang yang memiliki kunci pribadi aplikasi Anda yang dapat membuat pembaruan yang dapat diterapkan secara otomatis.
Untuk memverifikasi bahwa rakitan valid, komponen Pembaruan Aplikasi .NET memverifikasi bahwa kunci publik dari aplikasi yang Anda instal saat ini dapat dieksekusi dan kunci publik dari pembaruan yang diunduh cocok. Jika dua majelis ditandatangani dengan kunci pribadi rahasia yang sama, maka kunci publik yang tertanam akan sama. Karena rakitan yang dimuat oleh CLR memverifikasi kunci publiknya, CLR menghitung pemeriksaan hash normal untuk memastikan bahwa rakitan tersebut sebenarnya adalah rakitan asli dan bukan rakitan yang dirusak. Untuk mengaktifkan validasi pada waktu pengunduhan, tambahkan nama yang kuat ke semua rakitan aplikasi Anda dan atur properti ValidateAssemblies dari komponen Pembaruan Aplikasi .NET ke true.
Verifikasi perakitan pada waktu pengunduhan sangat membantu, namun dalam praktiknya, aplikasi sering kali memiliki komponen yang ditandatangani dengan kunci pribadi yang berbeda. Misalnya, aplikasi Anda mungkin memiliki dua file: rakitan yang dapat dieksekusi yang ditandatangani dengan kunci pribadi Anda dan rakitan dll lainnya yang berisi kontrol bagan pihak ketiga yang Anda beli dan gunakan dalam aplikasi Anda. Majelis pihak ketiga dapat ditandatangani menggunakan kunci pribadi pihak ketiga, bukan milik Anda. Untuk lebih memperumit situasi, pengaturan kunci pribadi valid yang digunakan untuk menandatangani rakitan di aplikasi Anda dapat berubah dari nomor versi ke nomor versi. Bagaimana cara Anda memperbarui jenis aplikasi tersebut secara otomatis? Untuk mengatasi masalah ini, Anda bisa membuat rakitan di aplikasi Anda yang berisi daftar kunci publik yang valid. Tanda tangani rakitan dengan kunci pribadi master aplikasi (kunci yang digunakan untuk menandatangani file exe aplikasi) dan letakkan rakitan di direktori di server web dengan file pembaruan aplikasi. Sebelum proses pengunduhan pembaruan dimulai, komponen Pembaruan Aplikasi .NET akan memeriksa rakitan bernama "AppUpdaterKeys.dll" di direktori pembaruan aplikasi di server Web. Jika ada, perakitan diunduh. Majelis diverifikasi terhadap kunci publik aplikasi utama. Jika tanda tangan valid, daftar kunci diekstraksi. Mulai sekarang, kunci apa pun dalam daftar ini akan dianggap sebagai tanda tangan yang valid untuk file yang diperbarui.
Pendekatan keamanan yang disarankan adalah menggunakan URL HTTPS untuk pemeriksaan pembaruan. Ini memberikan perlindungan spoofing tingkat pertama. Untuk pengunduhan pembaruan, sebaiknya jangan gunakan HTTPS RL untuk menghindari membebani server web Anda secara berlebihan. Sebagai gantinya, tambahkan nama yang kuat ke rakitan aplikasi Anda dan gunakan fitur validasi rakitan.
(3) Skalabilitas
Dalam contoh yang disebutkan sebelumnya dalam artikel ini, kita cukup menarik dan melepas komponen ke dalam aplikasi dan mengatur beberapa properti untuk mencapai penerapan otomatis.
Meskipun ini berfungsi dengan baik di banyak aplikasi, beberapa aplikasi memerlukan kontrol tingkat tinggi yang hanya dapat diperoleh dengan menulis kode. Kita dapat menulis kode kita sendiri untuk menggantikan proses standar komponen pembaruan aplikasi .NET, menggunakan metode CheckForUpdate() dan ApplyUpdate() yang diganti untuk menyesuaikan perilaku pemeriksaan dan pembaruan.
(4) Debugging
Bagian ini akan menunjukkan beberapa opsi debugging yang disukai, serta menjelaskan masalah paling umum yang dihadapi oleh pengguna komponen ini.
Pembaruan Aplikasi .NET menghasilkan file log tersembunyi bernama AppUpdate.log di direktori yang sama dengan AppStart.exe.
Semua informasi keberhasilan dan kegagalan pembaruan dicatat dalam log ini. File log sangat berguna ketika klien tertentu gagal memperbarui dengan sukses.
Anda dapat menggunakan log untuk menentukan kapan dan bagaimana pembaruan gagal. Selain itu, komponen Pembaruan Aplikasi .NET menggunakan kelas Debug .NET Framework untuk menghasilkan banyak informasi berguna. Jika Anda menjalankan aplikasi di debugger, Anda akan melihat informasi ini di jendela keluaran. Anda dapat mengikuti log .NET Application Updater untuk menyorot dan menemukan area masalah.
Jika karena alasan tertentu Anda tidak dapat menjalankan .NET Application Updater, pastikan hal berikut sebelum Anda mempelajari debugging. Masalah yang Anda temui kemungkinan besar adalah salah satu dari berikut ini: ..
Apakah Anda menjelajah ke IIS direktori? Jika tidak, pembaru tidak akan mengunduh dan menginstal file apa pun.
. Apakah Anda menerapkan semuanya dengan benar dan menyetel URL dengan benar?
. Jika aplikasi Anda diinstal di direktori file program, apakah Anda yakin Anda adalah administrator super atau pengguna super mesin tersebut? Jika tidak, Anda tidak akan memiliki akses tulis untuk memperbarui aplikasi.
. Apakah Anda membuat objek AppUpdater di thread UI utama aplikasi? Jika tidak, pembaru tidak akan dapat menampilkan UI dan akan gagal saat mengaktifkan kembali peristiwa ke UI.
.Apakah pembaruan berhasil tetapi aplikasi gagal memulai ulang secara otomatis dengan pembaruan baru? Komponen Pembaruan Aplikasi .NET mencoba keluar dari aplikasi dengan memanggil metode Application.Exit. Namun cara ini tidak menjamin penutupan aplikasi. Jika Anda menelurkan dan membiarkan thread terpisah berjalan, metode ini tidak dapat menghentikan proses. Solusi untuk menjamin bahwa semua thread berakhir adalah dengan memanggil acara Application.OnExit, atau menghubungkan ke acara OnUpdateComplete pembaru aplikasi .NET dan menangani sendiri pematian tersebut.
5. Ringkasan
Penyebaran aplikasi klien yang nyaman merupakan tujuan penting dari versi pertama kerangka .NET. Menggunakan kerangka .NET adalah teknik hebat untuk membangun aplikasi klien yang memecahkan masalah penerapan. Kemudahan penerapan tetap menjadi tujuan penting untuk versi baru .NET Framework di masa depan. Sebagai solusinya, komponen pembaruan aplikasi .NET yang dijelaskan di sini mewakili beberapa ide kami yang dapat kami gunakan secara langsung di versi .NET Framework yang akan datang. Namun sebelum waktu itu tiba, komponen pembaruan aplikasi .NET dapat dianggap sebagai cara penting untuk mulai membangun aplikasi pembaruan otomatis.
Dari: csdn, saya melihatnya di Tianji, saya belum mempelajarinya dengan cermat, saya akan meninggalkannya untuk nanti