Praktik terbaik untuk performa startup aplikasi Anda

  • Artikel

Buat aplikasi Platform Windows Universal (UWP) dengan waktu mulai yang optimal dengan meningkatkan cara Anda menangani peluncuran dan aktivasi.

Praktik terbaik untuk performa startup aplikasi Anda

Sebagian, pengguna melihat apakah aplikasi Anda cepat atau lambat berdasarkan berapa lama waktu yang dibutuhkan untuk memulai. Untuk tujuan topik ini, waktu mulai aplikasi dimulai saat pengguna memulai aplikasi, dan berakhir ketika pengguna dapat berinteraksi dengan aplikasi dengan beberapa cara yang bermakna. Bagian ini memberikan saran tentang cara mendapatkan performa yang lebih baik dari aplikasi Anda saat dimulai.

Mengukur waktu mulai aplikasi Anda

Pastikan untuk memulai aplikasi beberapa kali sebelum Anda benar-benar mengukur waktu mulainya. Ini memberi Anda garis besar untuk pengukuran Anda dan memastikan bahwa Anda mengukur sesingkat mungkin waktu startup.

Pada saat aplikasi UWP Anda tiba di komputer pelanggan Anda, aplikasi Anda telah dikompilasi dengan toolchain .NET Native. .NET Native adalah teknologi kompilasi sebelumnya yang mengonversi MSIL menjadi kode mesin yang dapat dijalankan secara asli. Aplikasi .NET Native dimulai lebih cepat, gunakan lebih sedikit memori, dan gunakan lebih sedikit baterai daripada rekan-rekan MSIL mereka. Aplikasi yang dibangun dengan tautan statis .NET Native dalam runtime kustom dan .NET Core baru yang terkonvergensi yang dapat berjalan di semua perangkat, sehingga tidak bergantung pada implementasi .NET dalam kotak. Pada komputer pengembangan Anda, secara default aplikasi Anda menggunakan .NET Native jika Anda membuatnya dalam mode "Rilis", dan menggunakan CoreCLR jika Anda membangunnya dalam mode "Debug". Anda dapat mengonfigurasi ini di Visual Studio dari halaman Build di "Properti" (C#) atau Compile-Advanced> di "Proyek Saya" (VB). Cari kotak centang yang mengatakan "Kompilasi dengan .NET Native Toolchain".

Tentu saja, Anda harus mengambil pengukuran yang mewakili apa yang akan dialami pengguna akhir. Jadi, jika Anda tidak yakin mengkompilasi aplikasi ke kode asli di komputer pengembangan, Anda dapat menjalankan alat Native Image Generator (Ngen.exe) untuk melakukan prakompilasi aplikasi sebelum mengukur waktu mulainya.

Prosedur berikut menjelaskan cara menjalankan Ngen.exe untuk melakukan prakompeksi aplikasi Anda.

Untuk menjalankan Ngen.exe

  1. Jalankan aplikasi Anda setidaknya satu kali untuk memastikan bahwa Ngen.exe mendeteksinya.

  2. Buka Penjadwal Tugas dengan melakukan salah satu hal berikut ini:

    • Cari "Penjadwal Tugas" dari layar mulai.
    • Jalankan "taskschd.msc."

  3. Di panel sebelah kiri Penjadwal Tugas, perluas Pustaka Penjadwal Tugas.

  4. Perluas Microsoft.

  5. Perluas Windows.

  6. Pilih .NET Framework.

  7. Pilih .NET Framework NGEN 4.x dari daftar tugas.

    Jika Anda menggunakan komputer 64-bit, ada juga .NET Framework NGEN v4.x 64. Jika Anda membangun aplikasi 64-bit, pilih .NET Framework NGEN v4.x 64.

  8. Dari menu Tindakan , klik Jalankan.

Ngen.exe melakukan prakompeksi semua aplikasi pada komputer yang telah digunakan dan tidak memiliki gambar asli. Jika ada banyak aplikasi yang perlu dikomprelasi sebelumnya, ini bisa memakan waktu lama, tetapi eksekusi berikutnya jauh lebih cepat.

Saat Anda mengkombinasikan ulang aplikasi, gambar asli tidak lagi digunakan. Sebaliknya, aplikasi ini dikompilasi tepat waktu, yang berarti bahwa aplikasi dikompilasi saat aplikasi berjalan. Anda harus menjalankan ulang Ngen.exe untuk mendapatkan gambar asli baru.

Tangguhkan pekerjaan selama mungkin

Untuk meningkatkan waktu mulai aplikasi Anda, lakukan hanya pekerjaan yang benar-benar perlu dilakukan untuk memungkinkan pengguna mulai berinteraksi dengan aplikasi. Ini bisa sangat bermanfaat jika Anda dapat menunda pemuatan rakitan tambahan. Runtime bahasa umum memuat rakitan saat pertama kali digunakan. Jika Anda dapat meminimalkan jumlah rakitan yang dimuat, Anda mungkin dapat meningkatkan waktu mulai aplikasi dan konsumsi memorinya.

Lakukan pekerjaan jangka panjang secara independen

Aplikasi Anda dapat interaktif meskipun ada bagian aplikasi yang tidak berfungsi penuh. Misalnya, jika aplikasi Anda menampilkan data yang membutuhkan waktu cukup lama untuk diambil, Anda dapat membuat kode tersebut dijalankan secara independen dari kode startup aplikasi dengan mengambil data secara asinkron. Saat data tersedia, isi antarmuka pengguna aplikasi dengan data.

Banyak API Platform Windows Universal (UWP) yang mengambil data tidak sinkron, jadi Anda mungkin akan mengambil data secara asinkron. Untuk informasi selengkapnya tentang API asinkron, lihat Memanggil API asinkron di C# atau Visual Basic. Jika Anda melakukan pekerjaan yang tidak menggunakan API asinkron, Anda dapat menggunakan kelas Tugas untuk melakukan pekerjaan jangka panjang sehingga Anda tidak memblokir pengguna agar tidak berinteraksi dengan aplikasi. Ini akan membuat aplikasi Anda tetap responsif terhadap pengguna saat data dimuat.

Jika aplikasi Anda membutuhkan waktu yang sangat lama untuk memuat bagian dari UI-nya, pertimbangkan untuk menambahkan string di area tersebut yang mengatakan sesuatu seperti, "Mendapatkan data terbaru," sehingga pengguna Anda tahu bahwa aplikasi masih diproses.

Meminimalkan waktu mulai

Semua kecuali aplikasi paling sederhana memerlukan jumlah waktu yang dapat dirasakan untuk memuat sumber daya, mengurai XAML, menyiapkan struktur data, dan menjalankan logika saat aktivasi. Di sini, kami menganalisis proses aktivasi dengan memecahnya menjadi tiga fase. Kami juga memberikan tips untuk mengurangi waktu yang dihabiskan di setiap fase, dan teknik untuk membuat setiap fase startup aplikasi Anda lebih cocok untuk pengguna.

Periode aktivasi adalah waktu antara saat pengguna memulai aplikasi dan saat aplikasi berfungsi. Ini adalah waktu penting karena ini adalah kesan pertama pengguna tentang aplikasi Anda. Mereka mengharapkan umpan balik instan dan berkelanjutan dari sistem dan aplikasi. Sistem dan aplikasi dianggap rusak atau dirancang dengan buruk saat aplikasi tidak dimulai dengan cepat. Lebih buruk lagi, jika aplikasi membutuhkan waktu terlalu lama untuk diaktifkan, Process Lifetime Manager (PLM) mungkin mematikannya, atau pengguna mungkin menghapus instalannya.

Pengantar tahapan startup

Startup melibatkan sejumlah bagian yang bergerak, dan semuanya perlu dikoordinasikan dengan benar untuk pengalaman pengguna terbaik. Langkah-langkah berikut terjadi antara pengguna Anda mengklik petak peta aplikasi Anda dan konten aplikasi yang ditampilkan.

  • Shell Windows memulai proses dan Main dipanggil.
  • Objek Aplikasi dibuat.
    • (Templat proyek) Konstruktor memanggil InitializeComponent, yang menyebabkan App.xaml diurai dan objek dibuat.
  • Peristiwa Application.OnLaunched dinaikkan.
    • (ProjectTemplate) Kode aplikasi membuat Bingkai dan menavigasi ke MainPage.
    • (ProjectTemplate) Konstruktor halaman utama memanggil InitializeComponent yang menyebabkan MainPage.xaml diurai dan objek dibuat.
    • ProjectTemplate) Window.Current.Activate() dipanggil.
  • Platform XAML menjalankan kode Tata Letak termasuk Pengukuran &Atur.
    • ApplyTemplate akan menyebabkan konten templat kontrol dibuat untuk setiap kontrol, yang biasanya merupakan sebagian besar waktu Tata Letak untuk startup.
  • Render dipanggil untuk membuat visual untuk semua konten jendela.
  • Bingkai disajikan ke Desktop Windows Manager (DWM).

Lakukan lebih sedikit di jalur Startup Anda

Biarkan jalur kode startup Anda bebas dari apa pun yang tidak diperlukan untuk bingkai pertama Anda.

  • Jika Anda memiliki dll pengguna yang berisi kontrol yang tidak diperlukan selama bingkai pertama, pertimbangkan untuk menunda pemuatannya.
  • Jika Anda memiliki sebagian UI bergantung pada data dari cloud, pisahkan antarmuka pengguna tersebut. Pertama, munculkan UI yang tidak bergantung pada data cloud dan secara asinkron memunculkan UI yang bergantung pada cloud. Anda juga harus mempertimbangkan penembolokan data secara lokal sehingga aplikasi akan bekerja offline atau tidak terpengaruh oleh konektivitas jaringan yang lambat.
  • Tampilkan UI kemajuan jika UI Anda sedang menunggu data.
  • Berhati-hatilah dengan desain aplikasi yang melibatkan banyak penguraian file konfigurasi, atau UI yang dihasilkan secara dinamis oleh kode.

Kurangi jumlah elemen

Performa startup di aplikasi XAML berkorelasi langsung dengan jumlah elemen yang Anda buat selama startup. Semakin sedikit elemen yang Anda buat, semakin sedikit waktu yang diperlukan aplikasi Anda untuk memulai. Sebagai tolok ukur kasar, pertimbangkan setiap elemen untuk mengambil 1ms untuk dibuat.

  • Templat yang digunakan dalam kontrol item dapat memiliki dampak terbesar, karena diulang beberapa kali. Lihat Pengoptimalan UI ListView dan GridView.
  • UserControls dan templat kontrol akan diperluas, sehingga templat tersebut juga harus diperhitungkan.
  • Jika Anda membuat XAML apa pun yang tidak muncul di layar, maka Anda harus membenarkan apakah potongan XAML tersebut harus dibuat selama startup Anda.

Jendela Visual Tree Langsung Visual Studio menampilkan jumlah elemen anak untuk setiap simpul di pohon.

Live visual tree.

Gunakan deferral. Menciutkan elemen, atau mengatur opasitasnya ke 0, tidak akan mencegah elemen dibuat. Dengan menggunakan x:Load atau x:DeferLoadStrategy, Anda dapat menunda pemuatan sepotong UI, dan memuatnya saat diperlukan. Ini adalah cara yang baik untuk menunda pemrosesan UI yang tidak terlihat selama layar startup, sehingga Anda dapat memuatnya saat diperlukan, atau sebagai bagian dari serangkaian logika yang tertunda. Untuk memicu pemuatan, Anda hanya perlu memanggil FindName untuk elemen . Untuk contoh dan informasi selengkapnya, lihat atribut x:Load dan atribut x:DeferLoadStrategy.

Virtualisasi. Jika Anda memiliki konten daftar atau pengulang di UI Anda, sangat disarankan agar Anda menggunakan virtualisasi UI. Jika UI daftar tidak divirtualisasi maka Anda membayar biaya pembuatan semua elemen di muka, dan yang dapat memperlambat startup Anda. Lihat Pengoptimalan UI ListView dan GridView.

Performa aplikasi tidak hanya tentang performa mentah, ini juga tentang persepsi. Mengubah urutan operasi sehingga aspek visual terjadi terlebih dahulu biasanya akan membuat pengguna merasa seperti aplikasi lebih cepat. Pengguna akan mempertimbangkan aplikasi yang dimuat ketika konten ada di layar. Umumnya, aplikasi perlu melakukan beberapa hal sebagai bagian dari startup, dan tidak semua itu diperlukan untuk memunculkan UI, sehingga aplikasi tersebut harus ditunda atau diprioritaskan lebih rendah dari UI.

Topik ini berbicara tentang "bingkai pertama" yang berasal dari animasi/TV, dan merupakan ukuran berapa lama hingga konten dilihat oleh pengguna akhir.

Meningkatkan persepsi startup

Mari kita gunakan contoh game online sederhana untuk mengidentifikasi setiap fase startup dan teknik yang berbeda untuk memberikan umpan balik pengguna sepanjang proses. Untuk contoh ini, fase pertama aktivasi adalah waktu antara pengguna yang mengetuk petak peta game dan permainan mulai menjalankan kodenya. Selama waktu ini, sistem tidak memiliki konten apa pun untuk ditampilkan kepada pengguna untuk bahkan menunjukkan bahwa permainan yang benar telah dimulai. Tetapi menyediakan layar splash memberikan konten tersebut ke sistem. Game kemudian memberi tahu pengguna bahwa fase pertama aktivasi telah selesai dengan mengganti layar splash statis dengan UI-nya sendiri ketika mulai menjalankan kode.

Fase kedua aktivasi mencakup pembuatan dan inisialisasi struktur yang penting untuk game. Jika aplikasi dapat dengan cepat membuat UI awalnya dengan data yang tersedia setelah fase pertama aktivasi, maka fase kedua sepele dan Anda dapat segera menampilkan UI. Jika tidak, sebaiknya aplikasi menampilkan halaman pemuatan saat diinisialisasi.

Seperti apa halaman pemuatan terserah Anda dan itu bisa sesederhana menampilkan bilah kemajuan atau cincin kemajuan. Poin utamanya adalah bahwa aplikasi menunjukkan bahwa aplikasi melakukan tugas sebelum menjadi responsif. Dalam kasus permainan, ia ingin menampilkan layar awalnya tetapi UI mengharuskan beberapa gambar dan suara dimuat dari disk ke dalam memori. Tugas-tugas ini memakan waktu beberapa detik, sehingga aplikasi membuat pengguna mendapatkan informasi dengan mengganti layar splash dengan halaman pemuatan, yang menunjukkan animasi sederhana yang terkait dengan tema permainan.

Tahap ketiga dimulai setelah game memiliki sekumpulan info minimal untuk membuat antarmuka pengguna interaktif, yang menggantikan halaman pemuatan. Pada titik ini satu-satunya info yang tersedia untuk game online adalah konten yang dimuat aplikasi dari disk. Gim ini dapat mengirimkan konten yang cukup untuk membuat UI interaktif; tetapi karena ini adalah permainan online itu tidak akan berfungsi sampai terhubung ke internet dan mengunduh beberapa info tambahan. Sampai memiliki semua info yang perlu difungsikan, pengguna dapat berinteraksi dengan UI, tetapi fitur yang membutuhkan data tambahan dari web harus memberikan umpan balik bahwa konten masih dimuat. Mungkin perlu waktu agar aplikasi berfungsi penuh, jadi penting agar fungsionalitas tersedia sesegera mungkin.

Sekarang setelah kita mengidentifikasi tiga tahap aktivasi dalam game online, mari kita ikatkan ke kode aktual.

Fase 1

Sebelum aplikasi dimulai, aplikasi perlu memberi tahu sistem apa yang ingin ditampilkan sebagai layar percikan. Ini melakukannya dengan memberikan warna gambar dan latar belakang ke elemen SplashScreen dalam manifes aplikasi, seperti dalam contoh. Windows menampilkan ini setelah aplikasi memulai aktivasi.

<Package ...>
  ...
  <Applications>
    <Application ...>
      <VisualElements ...>
        ...
        <SplashScreen Image="Images\splashscreen.png" BackgroundColor="#000000" />
        ...
      </VisualElements>
    </Application>
  </Applications>
</Package>

Untuk informasi selengkapnya, lihat Menambahkan layar percikan.

Gunakan konstruktor aplikasi hanya untuk menginisialisasi struktur data yang penting bagi aplikasi. Konstruktor hanya dipanggil saat pertama kali aplikasi dijalankan dan belum tentu setiap kali aplikasi diaktifkan. Misalnya, konstruktor tidak dipanggil untuk aplikasi yang telah dijalankan, ditempatkan di latar belakang, lalu diaktifkan melalui kontrak pencarian.

Fase 2

Ada sejumlah alasan aplikasi diaktifkan, yang masing-masing mungkin ingin Anda tangani secara berbeda. Anda dapat menimpa metode OnActivated, OnCachedFileUpdaterActivated, OnFileActivated, OnFileOpenPickerActivated, OnFileSavePickerActivated, OnLaunched, OnSearchActivated, dan OnShareTargetActivated untuk menangani setiap alasan aktivasi. Salah satu hal yang harus dilakukan aplikasi dalam metode ini adalah membuat UI, menetapkannya ke Window.Content, lalu memanggil Window.Activate. Pada titik ini layar percikan digantikan oleh UI yang dibuat aplikasi. Visual ini dapat memuat layar atau UI aktual aplikasi jika info yang cukup tersedia saat aktivasi untuk membuatnya.

public partial class App : Application
{
    // A handler for regular activation.
    async protected override void OnLaunched(LaunchActivatedEventArgs args)
    {
        base.OnLaunched(args);

        // Asynchronously restore state based on generic launch.

        // Create the ExtendedSplash screen which serves as a loading page while the
        // reader downloads the section information.
        ExtendedSplash eSplash = new ExtendedSplash();

        // Set the content of the window to the extended splash screen.
        Window.Current.Content = eSplash;

        // Notify the Window that the process of activation is completed
        Window.Current.Activate();
    }

    // a different handler for activation via the search contract
    async protected override void OnSearchActivated(SearchActivatedEventArgs args)
    {
        base.OnSearchActivated(args);

        // Do an asynchronous restore based on Search activation

        // the rest of the code is the same as the OnLaunched method
    }
}

partial class ExtendedSplash : Page
{
    // This is the UIELement that's the game's home page.
    private GameHomePage homePage;

    public ExtendedSplash()
    {
        InitializeComponent();
        homePage = new GameHomePage();
    }

    // Shown for demonstration purposes only.
    // This is typically autogenerated by Visual Studio.
    private void InitializeComponent()
    {
    }
}

    Partial Public Class App
    Inherits Application

    ' A handler for regular activation.
    Protected Overrides Async Sub OnLaunched(ByVal args As LaunchActivatedEventArgs)
        MyBase.OnLaunched(args)

        ' Asynchronously restore state based on generic launch.

        ' Create the ExtendedSplash screen which serves as a loading page while the
        ' reader downloads the section information.
        Dim eSplash As New ExtendedSplash()

        ' Set the content of the window to the extended splash screen.
        Window.Current.Content = eSplash

        ' Notify the Window that the process of activation is completed
        Window.Current.Activate()
    End Sub

    ' a different handler for activation via the search contract
    Protected Overrides Async Sub OnSearchActivated(ByVal args As SearchActivatedEventArgs)
        MyBase.OnSearchActivated(args)

        ' Do an asynchronous restore based on Search activation

        ' the rest of the code is the same as the OnLaunched method
    End Sub
End Class

Partial Friend Class ExtendedSplash
    Inherits Page

    Public Sub New()
        InitializeComponent()

        ' Downloading the data necessary for
        ' initial UI on a background thread.
        Task.Run(Sub() DownloadData())
    End Sub

    Private Sub DownloadData()
        ' Download data to populate the initial UI.

        ' Create the first page.
        Dim firstPage As New MainPage()

        ' Add the data just downloaded to the first page

        ' Replace the loading page, which is currently
        ' set as the window's content, with the initial UI for the app
        Window.Current.Content = firstPage
    End Sub

    ' Shown for demonstration purposes only.
    ' This is typically autogenerated by Visual Studio.
    Private Sub InitializeComponent()
    End Sub
End Class

Aplikasi yang menampilkan halaman pemuatan di handler aktivasi mulai berfungsi untuk membuat UI di latar belakang. Setelah elemen tersebut dibuat, peristiwa FrameworkElement.Loaded terjadi. Di penanganan aktivitas, Anda mengganti konten jendela, yang saat ini merupakan layar pemuatan, dengan halaman beranda yang baru dibuat.

Sangat penting bahwa aplikasi dengan periode inisialisasi yang diperpanjang menampilkan halaman pemuatan. Selain memberikan umpan balik pengguna tentang proses aktivasi, proses akan dihentikan jika Window.Activate tidak dipanggil dalam waktu 15 detik sejak awal proses aktivasi.

partial class GameHomePage : Page
{
    public GameHomePage()
    {
        InitializeComponent();

        // add a handler to be called when the home page has been loaded
        this.Loaded += ReaderHomePageLoaded;

        // load the minimal amount of image and sound data from disk necessary to create the home page.
    }

    void ReaderHomePageLoaded(object sender, RoutedEventArgs e)
    {
        // set the content of the window to the home page now that it's ready to be displayed.
        Window.Current.Content = this;
    }

    // Shown for demonstration purposes only.
    // This is typically autogenerated by Visual Studio.
    private void InitializeComponent()
    {
    }
}

    Partial Friend Class GameHomePage
    Inherits Page

    Public Sub New()
        InitializeComponent()

        ' add a handler to be called when the home page has been loaded
        AddHandler Me.Loaded, AddressOf ReaderHomePageLoaded

        ' load the minimal amount of image and sound data from disk necessary to create the home page.
    End Sub

    Private Sub ReaderHomePageLoaded(ByVal sender As Object, ByVal e As RoutedEventArgs)
        ' set the content of the window to the home page now that it's ready to be displayed.
        Window.Current.Content = Me
    End Sub

    ' Shown for demonstration purposes only.
    ' This is typically autogenerated by Visual Studio.
    Private Sub InitializeComponent()
    End Sub
End Class

Untuk contoh penggunaan layar splash yang diperluas, lihat Sampel layar Splash.

Fase 3

Hanya karena aplikasi yang ditampilkan UI tidak berarti sepenuhnya siap digunakan. Dalam kasus permainan kami, UI ditampilkan dengan tempat penampung untuk fitur yang memerlukan data dari internet. Pada titik ini game mengunduh data tambahan yang diperlukan untuk membuat aplikasi berfungsi penuh dan secara progresif mengaktifkan fitur saat data diperoleh.

Terkadang banyak konten yang diperlukan untuk aktivasi dapat dipaketkan dengan aplikasi. Demikianlah halnya dengan permainan sederhana. Ini membuat proses aktivasi cukup sederhana. Tetapi banyak program (seperti pembaca berita dan penampil foto) harus menarik informasi dari web agar berfungsi. Data ini bisa besar dan membutuhkan waktu yang cukup lama untuk diunduh. Bagaimana aplikasi mendapatkan data ini selama proses aktivasi dapat berdampak besar pada performa aplikasi yang dirasakan.

Anda dapat menampilkan halaman pemuatan, atau yang lebih buruk, layar percikan, selama beberapa menit jika aplikasi mencoba mengunduh seluruh himpunan data yang dibutuhkan untuk fungsionalitas dalam fase satu atau dua aktivasi. Ini membuat aplikasi terlihat seperti digantung atau menyebabkannya dihentikan oleh sistem. Kami menyarankan agar aplikasi mengunduh jumlah data minimal untuk menampilkan UI interaktif dengan elemen tempat penampung di fase 2 dan kemudian secara progresif memuat data, yang menggantikan elemen tempat penampung, pada fase 3. Untuk informasi selengkapnya tentang menangani data, lihat Mengoptimalkan ListView dan GridView.

Bagaimana tepatnya aplikasi bereaksi terhadap setiap fase startup sepenuhnya terserah Anda, tetapi memberikan umpan balik sebanyak mungkin kepada pengguna (layar splash, layar pemuatan, UI saat pemuatan data) membuat pengguna merasa seolah-olah aplikasi, dan sistem secara keseluruhan, cepat.

Meminimalkan rakitan terkelola di jalur startup

Kode yang dapat digunakan kembali sering kali hadir dalam bentuk modul (DLL) yang disertakan dalam proyek. Memuat modul ini memerlukan akses disk, dan seperti yang dapat Anda bayangkan, biaya melakukannya dapat bertambah. Ini memiliki dampak terbesar pada startup dingin, tetapi juga dapat berdampak pada startup hangat. Dalam kasus C# dan Visual Basic, CLR mencoba menunda biaya sebanyak mungkin dengan memuat rakitan sesuai permintaan. Artinya, CLR tidak memuat modul sampai metode yang dijalankan mereferensikannya. Jadi, referensi hanya rakitan yang diperlukan untuk peluncuran aplikasi Anda dalam kode startup sehingga CLR tidak memuat modul yang tidak perlu. Jika Anda memiliki jalur kode yang tidak digunakan di jalur startup yang memiliki referensi yang tidak perlu, Anda dapat memindahkan jalur kode ini ke metode lain untuk menghindari beban yang tidak perlu.

Cara lain untuk mengurangi beban modul adalah dengan menggabungkan modul aplikasi Anda. Memuat satu rakitan besar biasanya membutuhkan waktu lebih sedikit daripada memuat dua yang kecil. Ini tidak selalu dimungkinkan, dan Anda harus menggabungkan modul hanya jika tidak membuat perbedaan material untuk produktivitas pengembang atau kegunaan kembali kode. Anda dapat menggunakan alat seperti PerfView atau Windows Penganalisis Kinerja (WPA) untuk mengetahui modul apa yang dimuat saat startup.

Membuat permintaan web pintar

Anda dapat secara dramatis meningkatkan waktu pemuatan aplikasi dengan mengemas kontennya secara lokal, termasuk XAML, gambar, dan file lain yang penting untuk aplikasi. Operasi disk lebih cepat daripada operasi jaringan. Jika aplikasi memerlukan file tertentu saat inisialisasi, Anda dapat mengurangi waktu mulai secara keseluruhan dengan memuatnya dari disk alih-alih mengambilnya dari server jarak jauh.

Halaman Jurnal dan Cache Secara Efisien

Kontrol Bingkai menyediakan fitur navigasi. Ini menawarkan navigasi ke Halaman (Metode navigasi), penjurnalan navigasi (properti BackStack/ForwardStack, metode GoForward/GoBack), Penembolokan halaman (Page.NavigationCacheMode), dan dukungan serialisasi (metode GetNavigationState).

Performa yang harus diperhatikan dengan Frame terutama di sekitar jurnal dan penembolokan halaman.

Bingkai jurnal. Saat Anda menavigasi ke halaman dengan Frame.Navigate(), PageStackEntry untuk halaman saat ini ditambahkan ke koleksi Frame.BackStack. PageStackEntry relatif kecil, tetapi tidak ada batas bawaan untuk ukuran koleksi BackStack. Berpotensi, pengguna dapat menavigasi dalam perulangan dan menumbuhkan koleksi ini tanpa batas waktu.

PageStackEntry juga menyertakan parameter yang diteruskan ke metode Frame.Navigate(). Disarankan agar parameter menjadi jenis serializable primitif (seperti int atau string), untuk memungkinkan metode Frame.GetNavigationState() berfungsi. Tetapi parameter itu berpotensi mereferensikan objek yang menyuntikkan jumlah set kerja yang lebih signifikan atau sumber daya lain, membuat setiap entri di BackStack jauh lebih mahal. Misalnya, Anda berpotensi menggunakan StorageFile sebagai parameter, dan akibatnya BackStack menjaga jumlah file yang tidak terbatas terbuka.

Oleh karena itu disarankan untuk menjaga parameter navigasi tetap kecil, dan untuk membatasi ukuran BackStack. BackStack adalah vektor standar (IList di C#, Platform::Vector di C++/CX), sehingga dapat dipangkas hanya dengan menghapus entri.

Penembolokan halaman. Secara default, saat Anda menavigasi ke halaman dengan metode Frame.Navigate, instans baru halaman akan dibuat. Demikian pula, jika Anda kemudian menavigasi kembali ke halaman sebelumnya dengan Frame.GoBack, instans baru halaman sebelumnya dialokasikan.

Namun, Frame menawarkan cache halaman opsional yang dapat menghindari instansiasi ini. Untuk mendapatkan halaman yang dimasukkan ke dalam cache, gunakan properti Page.NavigationCacheMode. Mengatur mode tersebut ke Diperlukan akan memaksa halaman untuk di-cache, mengaturnya ke Diaktifkan akan memungkinkannya untuk di-cache. Secara default ukuran cache adalah 10 halaman, tetapi ini dapat diganti dengan properti Frame.CacheSize. Semua halaman yang diperlukan akan di-cache, dan jika ada lebih sedikit dari halaman CacheSize Required, halaman yang diaktifkan juga dapat di-cache.

Penembolokan halaman dapat membantu performa dengan menghindari instansiasi, dan karenanya meningkatkan performa navigasi. Penembolokan halaman dapat merusak performa dengan penembolokan berlebihan dan karenanya berdampak pada set kerja.

Oleh karena itu, disarankan untuk menggunakan penembolokan halaman yang sesuai untuk aplikasi Anda. Misalnya, Anda memiliki aplikasi yang menampilkan daftar item dalam Bingkai, dan saat Anda mengetuk item, aplikasi tersebut menavigasi bingkai ke halaman detail untuk item tersebut. Halaman daftar mungkin harus diatur ke cache. Jika halaman detailnya sama untuk semua item, mungkin juga harus di-cache. Tetapi jika halaman detail lebih heterogen, mungkin lebih baik meninggalkan penembolokan.