Bagikan melalui

Mulai menggunakan Kerangka Kerja Dukungan Paket

Package Support Framework adalah kit sumber terbuka yang membantu Anda menerapkan perbaikan ke aplikasi desktop yang ada (tanpa memodifikasi kode) sehingga dapat berjalan dalam kontainer MSIX. Package Support Framework membantu aplikasi Anda mengikuti praktik terbaik dari lingkungan runtime modern.

Artikel ini menyediakan tampilan indepth pada setiap komponen Kerangka Kerja Dukungan Paket dan panduan langkah demi langkah untuk menggunakannya.

Memahami apa yang ada di dalam Kerangka Kerja Dukungan Paket

Kerangka Kerja Dukungan Paket berisi executable, DLL manajer runtime, dan serangkaian perbaikan runtime.

Kerangka Kerja Dukungan Paket

Berikut adalah prosesnya:

  1. Buat file konfigurasi yang menentukan perbaikan yang ingin Anda terapkan ke aplikasi Anda.
  2. Ubah paket Anda untuk menunjuk ke file executable peluncur Package Support Framework (PSF).

Saat pengguna memulai aplikasi Anda, peluncur Package Support Framework adalah executable pertama yang berjalan. Ini membaca file konfigurasi Anda dan menyuntikkan perbaikan saat runtime serta DLL manajer runtime ke dalam proses aplikasi. Manajer runtime menerapkan perbaikan ketika diperlukan oleh aplikasi untuk berjalan di dalam kontainer MSIX.

Injeksi DLL Kerangka Kerja Dukungan Paket

Langkah 1: Identifikasi masalah kompatibilitas aplikasi paket

Pertama, buat paket untuk aplikasi Anda. Kemudian, instal, jalankan, dan amati perilakunya. Anda mungkin menerima pesan kesalahan yang dapat membantu Anda mengidentifikasi masalah kompatibilitas. Anda juga dapat menggunakan Monitor Proses untuk mengidentifikasi masalah. Masalah umum berkaitan dengan asumsi aplikasi mengenai izin direktori kerja dan jalur program.

Menggunakan Monitor Proses untuk mengidentifikasi masalah

Monitor Proses adalah utilitas yang kuat untuk mengamati operasi file dan registri aplikasi, dan hasilnya. Ini dapat membantu Anda memahami masalah kompatibilitas aplikasi. Setelah membuka Monitor Proses, tambahkan filter (Filter Filter > ...) untuk menyertakan hanya peristiwa dari aplikasi yang dapat dieksekusi.

Filter Aplikasi ProcMon

Daftar peristiwa akan muncul. Untuk banyak dari peristiwa ini, kata SUCCESS akan muncul di kolom Hasil .

Acara ProcMon

Secara opsional, Anda dapat memfilter peristiwa untuk hanya menampilkan kegagalan.

ProcMon Mengecualikan Keberhasilan

Jika Anda mencurigai kegagalan akses sistem file, cari peristiwa gagal yang berada di bawah jalur berkas System32/SysWOW64 atau jalur berkas paket. Filter juga dapat membantu di sini. Mulai di bagian bawah daftar ini dan gulir ke atas. Kegagalan yang muncul di bagian bawah daftar ini telah terjadi baru-baru ini. Perhatikan sebagian besar kesalahan yang berisi string seperti "akses ditolak," dan "jalur/nama tidak ditemukan", dan abaikan hal-hal yang tidak terlihat mencurigakan. PSFSample memiliki dua masalah. Anda dapat melihat masalah tersebut dalam daftar yang muncul di gambar berikut.

ProcMon Config.txt

Dalam masalah pertama yang muncul dalam gambar ini, aplikasi gagal membaca dari file "Config.txt" yang terletak di jalur "C:\Windows\SysWOW64". Tidak mungkin aplikasi mencoba mereferensikan jalur tersebut secara langsung. Kemungkinan besar, ia mencoba membaca dari file tersebut dengan menggunakan jalur relatif, dan secara default, "System32/SysWOW64" adalah direktori kerja aplikasi. Ini menunjukkan bahwa aplikasi mengharapkan direktori kerjanya saat ini ditetapkan pada suatu lokasi di dalam paket. Melihat ke dalam appx, kita melihat file tersebut berada di direktori yang sama dengan file executable.

Aplikasi Config.txt

Masalah kedua muncul pada gambar berikut.

ProcMon Logfile

Dalam masalah ini, aplikasi gagal menulis file .log ke jalur paketnya. Hal ini menyarankan bahwa perbaikan masalah pengalihan file mungkin membantu.

Langkah 2: Temukan perbaikan runtime

PSF berisi perbaikan runtime yang dapat Anda gunakan saat ini, seperti perbaikan pengalihan file.

Perbaikan Pengalihan File

Anda dapat menggunakan Perbaikan Pengalihan File untuk mengalihkan upaya untuk menulis atau membaca data di direktori yang tidak dapat diakses dari aplikasi yang berjalan dalam kontainer MSIX.

Misalnya, jika aplikasi Anda menulis ke file log yang berada di direktori yang sama dengan aplikasi Anda yang dapat dieksekusi, maka Anda dapat menggunakan Perbaikan Pengalihan File untuk membuat file log tersebut di lokasi lain, seperti penyimpanan data aplikasi lokal.

Perbaikan runtime dari komunitas

Pastikan untuk meninjau kontribusi komunitas ke halaman GitHub kami. Ada kemungkinan bahwa pengembang lain telah menyelesaikan masalah yang mirip dengan Anda dan telah berbagi perbaikan runtime.

Langkah 3: Menerapkan perbaikan runtime

Anda dapat menerapkan perbaikan runtime yang ada dengan beberapa alat sederhana dari Windows SDK, dan dengan mengikuti langkah-langkah ini.

  • Membuat folder tata letak paket
  • Dapatkan file Kerangka Kerja Dukungan Paket
  • Menambahkannya ke paket Anda
  • Mengubah manifes paket
  • Membuat file konfigurasi

Mari kita melalui setiap tugas.

Membuat folder tata letak paket

Jika Anda sudah memiliki file .msix (atau .appx), Anda dapat membuka kemasan kontennya ke dalam folder tata letak yang akan berfungsi sebagai area penahapan untuk paket Anda. Anda dapat melakukan ini dari prompt perintah menggunakan alat MakeAppx, berdasarkan jalur penginstalan SDK Anda, di sinilah Anda akan menemukan alat makeappx.exe pada PC Windows 10 Anda: x86: C:\Program Files (x86)\Windows Kits\10\bin\x86\makeappx.exe x64: C:\Program Files (x86)\Windows Kits\10\bin\x64\makeappx.exe

makeappx unpack /p PSFSamplePackage_1.0.60.0_AnyCPU_Debug.msix /d PackageContents

Ini akan memberi Anda sesuatu yang terlihat seperti berikut ini.

Tata Letak Paket

Jika Anda tidak memiliki file .msix (atau .appx) untuk memulai, Anda dapat membuat folder paket dan file dari awal.

Dapatkan file Kerangka Kerja Dukungan Paket

Anda bisa mendapatkan paket PSF Nuget dengan menggunakan alat baris perintah Nuget mandiri atau melalui Visual Studio.

Dapatkan paket dengan menggunakan alat baris perintah

Instal alat baris perintah Nuget dari lokasi ini: https://www.nuget.org/downloads. Kemudian, dari baris perintah Nuget, jalankan perintah ini:

nuget install Microsoft.PackageSupportFramework

Atau, Anda dapat mengganti nama ekstensi paket menjadi .zip dan membuka zipnya. Semua file yang Anda butuhkan akan berada di bawah folder /bin.

Dapatkan paket dengan menggunakan Visual Studio

Di Visual Studio, klik kanan solusi atau simpul proyek Anda dan pilih salah satu perintah Kelola Paket Nuget. Cari Microsoft.PackageSupportFramework atau PSF untuk menemukan paket di Nuget.org. Kemudian, instal.

Menambahkan file Kerangka Kerja Dukungan Paket ke paket Anda

Tambahkan DLL PSF 32-bit dan 64-bit yang diperlukan dan file yang dapat dieksekusi ke direktori paket. Gunakan tabel berikut sebagai panduan. Anda juga perlu menyertakan perbaikan sistem yang dibutuhkan saat program berjalan. Dalam contoh kami, kita memerlukan perbaikan runtime pengalihan file.

Aplikasi yang dapat dieksekusi adalah x64 Aplikasi yang dapat dieksekusi adalah x86
PSFLauncher64.exe PSFLauncher32.exe
PSFRuntime64.dll PSFRuntime32.dll
PSFRunDll64.exe PSFRunDll32.exe

Konten paket Anda sekarang akan terlihat seperti ini.

Paket Biner

Mengubah manifes paket

Buka manifes paket Anda di editor teks, lalu atur atribut Executable elemen Application menjadi nama file yang dapat dieksekusi PSF Launcher. Jika Anda mengetahui arsitektur aplikasi target Anda, pilih versi yang sesuai, PSFLauncher32.exe atau PSFLauncher64.exe. Jika tidak, PSFLauncher32.exe akan berfungsi di semua situasi. Berikut adalah contohnya.

<Package ...>
  ...
  <Applications>
    <Application Id="PSFSample"
                 Executable="PSFLauncher32.exe"
                 EntryPoint="Windows.FullTrustApplication">
      ...
    </Application>
  </Applications>
</Package>

Membuat file konfigurasi

Buat nama config.jsonfile , dan simpan file tersebut ke folder akar paket Anda. Ubah ID aplikasi yang dideklarasikan dari file config.json untuk menunjuk ke executable yang baru saja Anda ganti. Dengan menggunakan pengetahuan yang Anda peroleh dari menggunakan Process Monitor, Anda juga dapat mengatur direktori kerja serta menggunakan pengaturan pengalihan file untuk mengalihkan operasi baca dan tulis ke file .log di bawah direktori "PSFSampleApp" yang relatif terhadap paket.

{
    "applications": [
        {
            "id": "PSFSample",
            "executable": "PSFSampleApp/PSFSample.exe",
            "workingDirectory": "PSFSampleApp/"
        }
    ],
    "processes": [
        {
            "executable": "PSFSample",
            "fixups": [
                {
                    "dll": "FileRedirectionFixup.dll",
                    "config": {
                        "redirectedPaths": {
                            "packageRelative": [
                                {
                                    "base": "PSFSampleApp/",
                                    "patterns": [
                                        ".*\\.log"
                                    ]
                                }
                            ]
                        }
                    }
                }
            ]
        }
    ]
}

Berikut ini adalah panduan untuk skema config.json:

Array kunci Nilai
Aplikasi Id Gunakan nilai atribut Id dari elemen Application dalam manifes paket.
Aplikasi berkas yang dapat dieksekusi Jalur yang relatif terhadap paket menuju executable yang ingin Anda mulai. Dalam kebanyakan kasus, Anda bisa mendapatkan nilai ini dari file manifes paket anda sebelum memodifikasinya. Ini adalah nilai atribut Executable dari elemen Application.
Aplikasi workingDirectory (direktori kerja) (Opsional) Jalur relatif paket untuk digunakan sebagai direktori kerja aplikasi yang dimulai. Jika Anda tidak menetapkan nilai ini, sistem operasi menggunakan System32 direktori sebagai direktori kerja aplikasi.
Proses berkas yang dapat dieksekusi Dalam kebanyakan kasus, ini akan menjadi nama executable yang dikonfigurasi di atas, dengan jalur dan ekstensi file yang telah dihapus.
perbaikan dll Jalur relatif paket ke fixup, .msix/.appx untuk dimuat.
perbaikan konfig (Opsional) Mengontrol perilaku dll perbaikan. Format yang tepat dari nilai ini bervariasi berdasarkan perbaikan demi perbaikan karena setiap perbaikan dapat menafsirkan "blob" ini seperti yang diinginkan.

Kunci applications, processes, dan fixups adalah array. Itu berarti Anda dapat menggunakan file config.json untuk menentukan lebih dari satu aplikasi, proses, dan DLL perbaikan.

Mengemas dan menguji aplikasi

Selanjutnya, buat paket.

makeappx pack /d PackageContents /p PSFSamplePackageFixup.msix

Kemudian, tanda tangani.

signtool sign /a /v /fd sha256 /f ExportedSigningCertificate.pfx PSFSamplePackageFixup.msix

Untuk informasi selengkapnya, lihat cara membuat sertifikat penandatanganan paket dan cara menandatangani paket menggunakan signtool

Menggunakan PowerShell, instal paket.

Nota

Ingatlah untuk menghapus instalan paket terlebih dahulu.

powershell Add-AppPackage .\PSFSamplePackageFixup.msix

Jalankan aplikasi dan amati perilaku dengan perbaikan runtime yang diterapkan. Ulangi langkah-langkah diagnostik dan pengemasan seperlunya.

Periksa apakah Kerangka Kerja Dukungan Paket sedang berjalan

Anda dapat memeriksa apakah perbaikan runtime Anda berjalan. Cara untuk melakukan ini adalah dengan membuka Task Manager dan klik Detail selengkapnya. Temukan aplikasi tempat kerangka kerja dukungan paket diterapkan dan perluas detail aplikasi untuk menampilkan detail selengkapnya. Anda akan dapat melihat bahwa Kerangka Kerja Dukungan Paket sedang berjalan.

Gunakan Perbaikan Penelusuran

Teknik alternatif untuk mendiagnosis masalah kompatibilitas aplikasi yang telah dikemas adalah dengan menggunakan Trace Fixup. DLL ini disertakan dengan PSF dan menyediakan tampilan diagnostik terperinci tentang perilaku aplikasi, mirip dengan Monitor Proses. Ini dirancang khusus untuk mengungkapkan masalah kompatibilitas aplikasi. Untuk menggunakan Trace Fixup, tambahkan DLL ke paket, tambahkan potongan kode berikut ke config.jsonAnda, lalu paketkan dan instal aplikasi Anda.

{
    "dll": "TraceFixup.dll",
    "config": {
        "traceLevels": {
            "filesystem": "allFailures"
        }
    }
}

Secara bawaan, Trace Fixup memfilter kegagalan yang mungkin dianggap sebagai "yang diharapkan". Misalnya, aplikasi mungkin mencoba menghapus file tanpa syarat tanpa memeriksa untuk melihat apakah sudah ada, mengabaikan hasilnya. Ini memiliki konsekuensi yang tidak menguntungkan bahwa beberapa kegagalan tak terduga mungkin difilter, jadi dalam contoh di atas, kami memilih untuk menerima semua kegagalan dari fungsi sistem file. Kami melakukan ini karena kami tahu dari sebelumnya bahwa upaya untuk membaca dari file Config.txt gagal dengan pesan "file tidak ditemukan". Ini adalah kegagalan yang sering diamati dan umumnya tidak diasumsikan tidak terduga. Dalam praktiknya, kemungkinan yang terbaik adalah memulai pemfilteran hanya untuk kegagalan tak terduga, dan kemudian kembali ke semua kegagalan jika ada masalah yang masih tidak dapat diidentifikasi.

Secara default, output dari Trace Fixup akan dikirim ke debugger terlampir. Untuk contoh ini, kita tidak akan melampirkan debugger, dan sebaliknya akan menggunakan program DebugView dari SysInternals untuk melihat outputnya. Setelah menjalankan aplikasi, kita dapat melihat kegagalan yang sama seperti sebelumnya, yang akan mengarahkan kita ke perbaikan runtime yang sama.

File TraceShim Tidak Ditemukan

TraceShim Ditolak Akses

Men-debug, memperluas, atau membuat perbaikan runtime

Anda dapat menggunakan Visual Studio untuk men-debug perbaikan runtime, memperluas perbaikan runtime, atau membuatnya dari awal. Anda harus melakukan hal-hal ini agar berhasil.

  • Menambahkan proyek pengemasan
  • Tambahkan proyek untuk memperbaiki runtime
  • Tambahkan proyek yang memulai executable PSF Launcher
  • Mengonfigurasi proyek pengemasan

Setelah selesai, solusi Anda akan terlihat seperti ini.

Solusi yang telah selesai

Mari kita lihat setiap proyek dalam contoh ini.

Proyek Tujuan
Paket Aplikasi Desktop Proyek ini didasarkan pada proyek Windows Application Packaging dan menghasilkan paket MSIX.
Runtimefix Ini adalah proyek Pustaka Dynamic-Linked C++ yang berisi satu atau beberapa fungsi penggantian yang berfungsi sebagai perbaikan runtime.
PSFLauncher Ini adalah Proyek Kosong C++. Proyek ini adalah tempat untuk mengumpulkan file runtime yang dapat didistribusikan dari Kerangka Kerja Dukungan Paket. Ini menghasilkan file yang dapat dieksekusi. Executable itu adalah hal pertama yang berjalan ketika Anda memulai solusi.
WinFormsDesktopApplication Proyek ini berisi kode sumber aplikasi desktop.

Untuk melihat sampel lengkap yang berisi semua jenis proyek ini, lihat PSFSample.

Mari kita telusuri langkah-langkah untuk membuat dan mengonfigurasi setiap proyek ini dalam solusi Anda.

Membuat solusi paket

Jika Anda belum memiliki solusi untuk aplikasi desktop Anda, buat Solusi Kosong baru di Visual Studio.

Solusi kosong

Anda mungkin juga ingin menambahkan proyek aplikasi apa pun yang Anda miliki.

Menambahkan proyek pengemasan

Jika Anda belum memiliki Proyek Kemasan Aplikasi Windows, buat dan tambahkan ke solusi Anda.

Templat proyek kemasan

Untuk informasi selengkapnya tentang proyek Windows Application Packaging, lihat Mengemas aplikasi Anda dengan menggunakan Visual Studio.

Di Penjelajah Solusi, klik kanan proyek pengemasan, pilih Edit, lalu tambahkan ini ke bagian bawah file proyek:

<Target Name="PSFRemoveSourceProject" AfterTargets="ExpandProjectReferences" BeforeTargets="_ConvertItems">
<ItemGroup>
  <FilteredNonWapProjProjectOutput Include="@(_FilteredNonWapProjProjectOutput)">
  <SourceProject Condition="'%(_FilteredNonWapProjProjectOutput.SourceProject)'=='<your runtime fix project name goes here>'" />
  </FilteredNonWapProjProjectOutput>
  <_FilteredNonWapProjProjectOutput Remove="@(_FilteredNonWapProjProjectOutput)" />
  <_FilteredNonWapProjProjectOutput Include="@(FilteredNonWapProjProjectOutput)" />
</ItemGroup>
</Target>

Tambahkan proyek untuk memperbaiki runtime

Tambahkan proyek C++ Dynamic-Link Library (DLL) ke solusi.

Perpustakaan perbaikan runtime

Klik kanan proyek tersebut, lalu pilih Properti.

Di halaman properti, temukan bidang Standar Bahasa C++, lalu di daftar drop-down di samping bidang tersebut, pilih opsi ISO C++17 Standard (/std:c++17).

Opsi ISO 17

Klik kanan proyek tersebut, lalu di menu konteks, pilih opsi Kelola Paket Nuget . Pastikan bahwa opsi Sumber paket diatur ke Semua atau nuget.org.

Klik ikon pengaturan di samping bidang tersebut.

Cari paket PSF* Nuget, lalu instal untuk proyek ini.

paket nuget

Jika Anda ingin men-debug atau memperluas perbaikan runtime yang ada, tambahkan file perbaikan runtime yang Anda peroleh dengan menggunakan panduan yang dijelaskan di bagian Temukan perbaikan runtime dari panduan ini.

Jika Anda ingin membuat perbaikan baru, jangan tambahkan apa pun ke proyek ini. Kami akan membantu Anda menambahkan file yang tepat ke proyek ini nanti dalam panduan ini. Untuk saat ini, kami akan terus menyiapkan solusi Anda.

Tambahkan proyek yang memulai executable PSF Launcher

Tambahkan proyek Proyek Kosong C++ ke solusi.

Proyek kosong

Tambahkan paket PSF Nuget ke proyek ini dengan menggunakan panduan yang sama yang dijelaskan di bagian sebelumnya.

Buka halaman properti untuk proyek, dan di halaman Pengaturan umum , atur properti Nama Target ke PSFLauncher32 atau PSFLauncher64 bergantung pada arsitektur aplikasi Anda.

Referensi Peluncur PSF

Tambahkan referensi proyek ke proyek perbaikan runtime dalam solusi Anda.

referensi perbaikan waktu proses

Klik kanan referensi, lalu di jendela Properti , terapkan nilai-nilai ini.

Harta benda Nilai
Salin lokal Benar
Salin Rakitan Satelit Lokal Benar
Output Komponen Rujukan Benar
Menghubungkan Ketergantungan Pustaka Tidak benar
Menautkan Input Dependensi Pustaka Tidak benar

Mengonfigurasi proyek pengemasan

Dalam proyek pengemasan, klik kanan folder Aplikasi , lalu pilih Tambahkan Referensi.

Tambahkan Referensi Proyek

Pilih proyek Peluncur PSF dan proyek aplikasi desktop Anda, lalu pilih tombol OK .

Proyek desktop

Nota

Jika Anda tidak memiliki kode sumber ke aplikasi Anda, cukup pilih proyek Peluncur PSF. Kami akan menunjukkan kepada Anda cara mereferensikan executable anda saat membuat file konfigurasi.

Di simpul Aplikasi , klik kanan aplikasi Peluncur PSF, lalu pilih Atur sebagai Titik Masuk.

Atur titik masuk

Tambahkan file bernama config.json ke proyek kemasan Anda, lalu salin dan tempel teks json berikut ke dalam file. Atur properti Tindakan Paket ke Konten.

{
    "applications": [
        {
            "id": "",
            "executable": "",
            "workingDirectory": ""
        }
    ],
    "processes": [
        {
            "executable": "",
            "fixups": [
                {
                    "dll": "",
                    "config": {
                    }
                }
            ]
        }
    ]
}

Berikan nilai untuk setiap kunci. Gunakan tabel ini sebagai panduan.

Array kunci Nilai
Aplikasi Id Gunakan nilai atribut Id dari elemen Application dalam manifes paket.
Aplikasi berkas yang dapat dieksekusi Jalur yang relatif terhadap paket menuju executable yang ingin Anda mulai. Dalam kebanyakan kasus, Anda bisa mendapatkan nilai ini dari file manifes paket anda sebelum memodifikasinya. Ini adalah nilai atribut Executable dari elemen Application.
Aplikasi workingDirectory (direktori kerja) (Opsional) Jalur relatif paket untuk digunakan sebagai direktori kerja aplikasi yang dimulai. Jika Anda tidak menetapkan nilai ini, sistem operasi menggunakan System32 direktori sebagai direktori kerja aplikasi.
Proses berkas yang dapat dieksekusi Dalam kebanyakan kasus, ini akan menjadi nama executable yang dikonfigurasi di atas, dengan jalur dan ekstensi file yang telah dihapus.
perbaikan dll Jalur relatif paket ke DLL perbaikan untuk dimuat.
perbaikan konfig (Opsional) Mengontrol perilaku DLL perbaikan. Format yang tepat dari nilai ini bervariasi berdasarkan perbaikan demi perbaikan karena setiap perbaikan dapat menafsirkan "blob" ini seperti yang diinginkan.

Setelah selesai, file Anda config.json akan terlihat seperti ini.

{
  "applications": [
    {
      "id": "DesktopApplication",
      "executable": "DesktopApplication/WinFormsDesktopApplication.exe",
      "workingDirectory": "WinFormsDesktopApplication"
    }
  ],
  "processes": [
    {
      "executable": ".*App.*",
      "fixups": [ { "dll": "RuntimeFix.dll" } ]
    }
  ]
}

Nota

Kunci applications, processes, dan fixups adalah array. Itu berarti Anda dapat menggunakan file config.json untuk menentukan lebih dari satu aplikasi, proses, dan DLL perbaikan.

Memperbaiki kesalahan saat runtime

Di Visual Studio, tekan F5 untuk memulai debugger. Hal pertama yang dimulai adalah aplikasi Peluncur PSF, yang pada gilirannya, memulai aplikasi desktop target Anda. Untuk men-debug aplikasi desktop target, Anda harus melampirkan secara manual ke proses aplikasi desktop dengan memilih Debug-Lampirkan> ke Proses, lalu memilih proses aplikasi. Untuk memperbolehkan debugging aplikasi .NET dengan DLL perbaikan runtime native, pilih jenis kode terkelola dan native (debugging mode campuran).

Setelah menyiapkannya, Anda dapat mengatur titik henti di samping baris kode dalam kode aplikasi desktop dan proyek perbaikan runtime. Jika Anda tidak memiliki kode sumber ke aplikasi, Anda akan dapat mengatur titik henti hanya di samping baris kode dalam proyek perbaikan runtime Anda.

Karena penelusuran kesalahan F5 menjalankan aplikasi dengan menyebarkan file longgar dari jalur folder tata letak paket, daripada menginstal dari paket .msix/.appx, folder tata letak biasanya tidak memiliki batasan keamanan yang sama dengan folder paket yang diinstal. Akibatnya, mungkin tidak mungkin untuk mereproduksi kesalahan penolakan akses jalur paket sebelum menerapkan perbaikan runtime.

Untuk mengatasi masalah ini, gunakan penyebaran paket .msix / .appx daripada penyebaran file F5 yang tidak terikat. Untuk membuat file paket .msix / .appx, gunakan utilitas MakeAppx dari Windows SDK, seperti yang dijelaskan di atas. Atau, dari dalam Visual Studio, klik kanan simpul proyek aplikasi Anda dan pilih Simpan -> Buat Paket Aplikasi.

Masalah lain dengan Visual Studio adalah tidak memiliki dukungan bawaan untuk melampirkan ke proses turunan apa pun yang diluncurkan oleh debugger. Ini membuatnya sulit untuk men-debug logika di jalur startup aplikasi target, yang harus dilampirkan secara manual oleh Visual Studio setelah diluncurkan.

Untuk mengatasi masalah ini, gunakan debugger yang mendukung lampiran proses anak. Perhatikan bahwa umumnya tidak mungkin untuk melampirkan debugger just-in-time (JIT) ke aplikasi target. Ini karena sebagian besar teknik JIT melibatkan peluncuran debugger sebagai pengganti aplikasi target, melalui kunci registri ImageFileExecutionOptions. Ini mengatasi mekanisme pengalihan yang digunakan oleh PSFLauncher.exe untuk menyuntikkan FixupRuntime.dll ke dalam aplikasi target. WinDbg, termasuk dalam Alat Debugging untuk Windows, dan diperoleh dari Windows SDK, mendukung lampiran proses anak. Sekarang juga mendukung peluncuran dan debugging aplikasi UWP secara langsung.

Untuk memperbaiki kesalahan saat memulai aplikasi target sebagai proses turunan, mulai WinDbg.

windbg.exe -plmPackage PSFSampleWithFixup_1.0.59.0_x86__7s220nvg1hg3m -plmApp PSFSample

Pada petunjuk WinDbg, aktifkan debugging anak dan setel breakpoint yang sesuai.

.childdbg 1
g

(jalankan hingga aplikasi target dimulai dan masuk ke debugger)

sxe ld fixup.dll
g

(jalankan hingga DLL perbaikan dimuat)

bp ...

Nota

PLMDebug juga dapat digunakan untuk melampirkan debugger ke aplikasi saat diluncurkan, dan juga disertakan dalam Alat Debugging untuk Windows. Namun, lebih kompleks untuk digunakan daripada dukungan langsung yang sekarang disediakan oleh WinDbg.

Dukungan

Punya pertanyaan? Tanyakan kami di ruang percakapan Kerangka Kerja Dukungan Paket di situs komunitas teknologi MSIX.

  • Last updated on