Bina aplikasi kanvas yang besar dan kompleks

Artikel
08/05/2024

Kebanyakan artikel dalam bahagian dokumentasi ini merangkumi prestasi masa jalan apl seperti yang dialami oleh orang yang menggunakannya. Artikel ini merangkumi prestasi apl seperti yang dialami oleh orang yang membuatnya.

Apabila apl menjadi lebih besar dan lebih kompleks, Power Apps Studio perlu memuatkan dan mengurus bilangan kawalan, formula dan sumber data yang lebih besar, semuanya dengan saling bergantung yang berkembang secara eksponen. Power Apps Studio boleh mengambil masa yang lebih lama untuk dimuatkan, dan ciri seperti IntelliSense dan pengekodan warna boleh ketinggalan. Gunakan pengesyoran yang berikut untuk berfungsi dengan lebih baik dengan apl yang besar dan kompleks Power Apps Studio. Ia juga boleh membantu meningkatkan prestasi masa jalan apl anda.

Contoh dalam artikel ini menggunakan penyelesaian sampel Respons Kecemasan Hospital.

Gunakan App.Formulas dan bukannya App.OnStart

Petua

Anda boleh menggunakan Dengan fungsi dan sifat output tersuai komponen kanvas sebagai alternatif kepada formula yang dinamakan.

Cara terbaik untuk mengurangkan masa memuatkan kedua-duanya Power Apps Studio dan apl anda ialah menggantikan pembolehubah dan permulaan koleksi dalam App.OnStart dengan formula yang dinamakan dalam App.Formulas.

Mari lihat contoh berikut, yang menggunakan App.OnStart.

// Get the color of text on a dark background.
Set(varColorOnDark,RGBA(0, 0, 0, 1));

// Get the color of the menu icons.
Set(varColorMenuIcon,"#0070a9");

// Get the styles for a form.
Set(varFormStyle,
    {
        DataCard: { Height: 50 },
        Title: { Height: 50, Size: 21, Color: varColorOnDark },
        Control: { Height: 50, Size: 18 },
        Label: { Size: 18, Color: varColorOnDark }
    }
);

ClearCollect(
    FacilitiesList,
    ForAll(
        Facilities,
        { Name: 'Facility Name', Id: Facility }
    )
);
If(
    Not IsBlank(Param("FacilityID")),
    Set(ParamFacility,
        LookUp(
            FacilitiesList,
            Id = GUID(Param("FacilityID"))
        ).Name
    );
);

Oleh kerana ia adalah urutan pernyataan, apl anda mesti menilai panggilan Tetapkan dan Kumpul ini mengikut tertib sebelum ia boleh memaparkan skrin pertama, yang menjadikan apl dimuatkan dengan lebih perlahan. Dan kerana keseluruhan App.OnStart mesti dipertimbangkan secara keseluruhan, pesanan dipelihara dan ralat diagregatkan sebelum mengembalikan hasil akhir, formula adalah rumit untuk Power Apps Studio dianalisis.

Ada cara yang lebih baik. Gunakan App.Formulas sebaliknya dan takrifkan pembolehubah dan koleksi ini sebagai formula yang dinamakan, seperti dalam contoh berikut.

// Get the color of text on a dark background.
varColorOnDark = RGBA(0, 0, 0, 1);

// Get the color of the menu icons.
varColorMenuIcon = "#0070a9";

// Get the styles for a form.
varFormStyle = 
    {
        DataCard: { Height: 50 },
        Title: { Height: 50, Size: 21, Color: varColorOnDark },
        Control: { Height: 50, Size: 18 },
        Label: { Size: 18, Color: varColorOnDark }
    };

FacilitiesList =
    ForAll(
        Facilities,
        { Name: 'Facility Name', Id: Facility }
    );

ParamFacility = 
    If( Not IsBlank(Param("FacilityID")),
        LookUp(
            FacilitiesList,
            Id = GUID(Param("FacilityID"))
        ).Name,
        Blank()
    );

Perubahan ini mungkin kelihatan kecil, tetapi ia boleh memberi kesan yang besar. Oleh kerana setiap formula yang dinamakan adalah bebas daripada yang lain, Power Apps Studio boleh menganalisisnya secara bebas, dengan berkesan membahagikan App.OnStart yang besar kepada kepingan yang lebih kecil. Kami telah melihat Power Apps Studio masa muat menurun sebanyak 80% dengan perubahan ini sahaja.

Apl anda juga dimuatkan dengan lebih pantas kerana ia tidak perlu menilai formula ini sehingga memerlukan hasilnya. Skrin pertama apl dipaparkan serta-merta.

Formula bernama tidak boleh digunakan dalam semua situasi kerana anda tidak boleh mengubah suainya atau menggunakannya dengan Set. Sesetengah situasi memerlukan penggunaan pembolehubah keadaan yang boleh diubah suai. Set sesuai untuk situasi ini dan anda harus terus menggunakannya. Tetapi, lebih kerap daripada tidak, anda menggunakan pembolehubah global dalam OnStart untuk menyediakan nilai statik yang tidak berubah. Dalam kes tersebut, formula yang dinamakan adalah pilihan yang lebih baik.

Oleh kerana formula yang dinamakan tidak boleh diubah, awalan var (singkatan untuk "pembolehubah") sebagai konvensyen penamaan tidak lagi sesuai. Kami tidak menukar nama dalam contoh ini kerana ia memerlukan perubahan pada apl yang lain untuk dipadankan.

Sangat menggoda untuk meletakkan formula yang dinamakan dalam App.OnStart, tetapi jangan. Mereka tidak tergolong di sana. Sebagai sifat On tingkah laku, App.OnStart menilai setiap penyataannya mengikut urutan, mencipta pembolehubah global dan bercakap dengan pangkalan data sekali sahaja, apabila apl dimuatkan. Formula yang dinamakan ialah formula yang mentakrifkan cara mengira sesuatu apabila diperlukan dan sentiasa benar. Sifat formula inilah yang membolehkan mereka berdikari dan membolehkan apl selesai dimuatkan sebelum ia dinilai.

Pisahkan formula panjang

App.OnStart ialah salah satu pesalah terburuk untuk formula panjang dan pastinya di mana anda harus bermula, tetapi ia bukan satu-satunya kes.

Kajian kami telah menunjukkan bahawa hampir semua apl dengan masa muat yang lama mempunyai Power Apps Studio sekurang-kurangnya satu formula lebih daripada 256,000 aksara. Sesetengah apl dengan masa muat terlama mempunyai formula lebih daripada 1 juta aksara. Formula yang telah lama memberi tekanan Power Apps Studio yang ketara.

Lebih memburukkan keadaan, menyalin dan menampal kawalan dengan formula panjang menduplikasi formula dalam sifat kawalan tanpa disedari. Power Apps dimodelkan selepas Excel, di mana berbilang salinan formula adalah biasa. Walau bagaimanapun, dalam Excel formula terhad kepada satu ungkapan dan dihadkan pada 8,000 aksara. Power Apps Formula boleh berkembang lebih lama dengan pengenalan logik imperatif dan pengendali rantaian (; atau ;;, bergantung pada tempat).

Penyelesaian umum ialah membahagikan formula panjang kepada bahagian yang lebih kecil dan menggunakan semula bahagian, seperti yang kami lakukan dalam bahagian sebelumnya apabila kami menukar pernyataan Set/Collect dalam App.OnStart kepada formula yang dinamakan dalam App.Formulas. Dalam bahasa pengaturcaraan lain, bahagian boleh guna semula sering dirujuk sebagai subrutin atau fungsi yang ditentukan pengguna. Anda boleh menganggap formula bernama sebagai bentuk mudah fungsi yang ditentukan pengguna tanpa parameter atau kesan sampingan.

Gunakan formula bernama di mana-mana sahaja

Dalam contoh terdahulu, kami menggunakan formula bernama sebagai pengganti App.OnStart ·. Walau bagaimanapun, anda boleh menggunakannya untuk menggantikan pengiraan di mana-mana sahaja dalam apl.

Sebagai contoh, salah satu skrin dalam penyelesaian sampel Respons Kecemasan Hospital termasuk logik ini dalam Screen.OnVisible:

ClearCollect(
    MySplashSelectionsCollection,
    {
        MySystemCol: First(
            Filter(
                Regions,
                Region = MyParamRegion
            )
        ).System.'System Name',
        MyRegionCol: First(
            Filter(
                Regions,
                Region = MyParamRegion
            )
        ).'Region Name',
        MyFacilityCol: ParamFacility,
          MyFacilityColID:  LookUp(
            FacilitiesList,
            Id = GUID(Param("FacilityID"))
        ).Id
    }
);

Formula ini boleh dibahagikan kepada satu set formula yang dinamakan. Ia juga menjadikan formula lebih mudah dibaca.

MyRegion = LookUp(
                    Regions,
                    Region = MyParamRegion
           );

MyFacility = LookUp(
                    FacilitiesList,
                    Id = GUID(Param("FacilityID")
            );

MySplashSelectionsCollection = 
    {
        MySystemCol: MyRegion.System.'System Name',
        MyRegionCol: MyRegion.'Region Name',
        MyFacilityCol: ParamFacility,
        MyFacilityColID:  MyFacility.Id
    };

Kami mengekstrak ParamFacility sebagai formula yang dinamakan sebelum ini apabila kami mengalihkan kebanyakan panggilan Set daripada App.OnStart kepada formula yang dinamakan dalam App.Formulas.

Formula yang dinamakan dinilai hanya apabila nilainya diperlukan. Jika niat asal menggunakan Screen.OnVisible adalah untuk menangguhkan kerja sehingga skrin ditunjukkan, maka kerja masih ditangguhkan sebagai formula bernama global dalam App.Formulas.

Gunakan fungsi Dengan

Anda juga boleh menggunakan fungsi Dengan dalam formula untuk membahagikan logik. Cipta rekod dalam parameter pertama dengan nilai yang anda mahu gunakan sebagai medan dan kemudian gunakan medan tersebut dalam parameter kedua untuk mengira nilai pulangan daripada With. Sebagai contoh, contoh sebelumnya boleh ditulis sebagai hanya satu formula yang dinamakan:

MySplashSelectionsCollection = 
    With( { MyRegion: LookUp(
                            Regions,
                            Region = MyParamRegion
                      ),
            MyFacility: LookUp(
                            FacilitiesList,
                            Id = GUID(Param("FacilityID")
                      ) 
           },
           {
                MySystemCol: MyRegion.System.'System Name',
                MyRegionCol: MyRegion.'Region Name',
                MyFacilityCol: ParamFacility,
                MyFacilityColID:  MyFacility.Id
           }
    )

Satu kelemahan menggunakan Dengan cara ini ialah tidak MyFacility boleh digunakan MyRegion kerana ia ditakrifkan dalam fungsi With yang sama, masalah yang tidak terdapat dengan formula yang dinamakan. Satu penyelesaian ialah bersarang Fungsi With dan menggunakan kata kunci As untuk menamakan rekod bagi setiap satu untuk memberikan akses mudah kepada semua pembolehubah With .

Gunakan komponen kanvas

Komponen kanvas paling kerap digunakan untuk mencipta kawalan UI yang boleh diletakkan pada kanvas sama seperti kawalan. Anda juga boleh menggunakannya tanpa meletakkannya dalam UI untuk melaksanakan pengiraan dengan sifat output tersuai sebagai alternatif kepada formula yang dinamakan. Komponen kanvas mudah dikongsi merentas apl dengan pustaka komponen dan, tidak seperti formula yang dinamakan, disokong sepenuhnya. Walau bagaimanapun, ia lebih sukar untuk dikonfigurasikan dan digunakan daripada formula yang dinamakan.

Untuk membahagikan logik:

Dalam Power Apps Studio, tukar ke tab Komponen dalam paparan Pokok.
Cipta komponen baharu.
Dalam anak tetingkap Sifat, hidupkan Skop aplikasi akses.
Tambah sifat tersuai.
Tetapkan Jenis Sifat kepada Output dan Jenis Data mengikut kesesuaian.
Pilih Cipta.
Dalam pemilih sifat di sebelah bar formula di bahagian atas skrin, pilih sifat baharu.
Tulis formula untuk logik untuk berpecah dan digunakan semula.

Untuk menggunakan logik:

Tukar ke tab Skrin dalam paparan Pokok.
Dalam anak tetingkap Sisipkan, kembangkan Tersuai dan masukkan komponen anda.
Untuk mengira nilai dengan sifat, gunakan ComponentName.PropertyName.

Gunakan Pilih dengan kawalan tersembunyi untuk logik imperatif

Logik imperatif digunakan untuk mengubah suai keadaan dengan Set and Collect, memberitahu pengguna dengan Notify, navigasi ke skrin atau apl lain dengan Navigate and Launch, dan menulis nilai pada pangkalan data dengan Patch, SubmitForm atau RemoveIf.

Formula bernama dan sifat output tersuai komponen kanvas tidak menyokong logik imperatif. Cara biasa untuk membahagikan logik imperatif ialah menggunakan sifat OnSelect bagi kawalan tersembunyi.

Tambah kawalan Butang pada skrin.
Tetapkan sifat OnSelect kepada logik imperatif yang anda mahu laksanakan.
Tetapkan sifat Visible kepada false, kerana pengguna tidak perlu melihat atau berinteraksi dengannya.
Hubungi Select( Button ) apabila anda ingin melaksanakan logik imperatif.

Contohnya, salah satu skrin dalam sampel kami mempunyai sifat OnSelect berikut pada kawalan Button . (Contoh mudah ini adalah untuk tujuan ilustrasi sahaja. Biasanya, anda hanya akan menggunakan teknik ini untuk formula yang lebih panjang.)

btnAction_17.OnSelect = 
    Trace("Feedback Screen: Submit Button",TraceSeverity.Information);
    If(
        // Proceed if all forms are validated.
        And(
            FormFeedback.Valid
        ),
    
        // Set the updates to static variables.
        Set(updatesFeedback,Patch(Defaults('App Feedbacks'), FormFeedback.Updates));
        // Submit the first form. Subsequent actions can be found in the OnSuccess.
        SubmitForm(FormFeedback);
        ,
    
        Notify("Please complete all fields before proceeding",
               NotificationType.Warning,2000)
    );

Untuk membahagikan logik ini kepada beberapa bahagian, kita boleh meletakkan bahagian pada kawalan Butang yang berasingan dan Pilihnya daripada yang asal:

btnTrace.OnSelect = 
    Trace("Feedback Screen: Submit Button",TraceSeverity.Information);

btnSubmit.OnSelect = 
    If(
        // Proceed if all forms are validated.
        And(
            FormFeedback.Valid
        ),
    
        // Set the updates to static variables.
        Set(updatesFeedback,Patch(Defaults('App Feedbacks'), FormFeedback.Updates));
        // Submit the first form. Subsequent actions can be found in OnSuccess.
        SubmitForm(FormFeedback);
        ,
    
        Notify("Please complete all fields before proceeding",
               NotificationType.Warning,2000)
    );

btnAction_17.OnSelect = 
    Select( btnTrace );
    Select( btnSubmit );

Teknik ini hanya berfungsi pada skrin yang sama. Teknik lain yang sedikit lebih rumit berfungsi merentasi skrin, seperti menggunakan kawalan Togol, menetapkan OnCheck kepada logik yang anda mahu jalankan dan menetapkan Lalai kepada pemboleh ubah global dan kemudian menogol pemboleh ubah global dengan Set( global, true ); Set( global, false ) pada titik anda mahu menjalankan logik.

Dalam contoh ini, beberapa pemisahan logik telah pun dilakukan. Komen itu menyebut bahawa "Tindakan seterusnya boleh didapati dalam OnSuccess." Acara ini menjalankan logik imperatif selepas rekod berjaya diserahkan, penyelesaian khusus untuk fungsi SubmitForm .

Bahagikan apl

Sesetengah apl berkembang kepada beribu-ribu kawalan dan beratus-ratus sumber data, yang menjadi Power Apps Studio perlahan. Seperti formula panjang, apl besar boleh dibahagikan kepada bahagian yang lebih kecil yang berfungsi bersama untuk mencipta satu pengalaman pengguna.

Bebaskan aplikasi kanvas

Satu pendekatan ialah melaksanakan bahagian dalam apl kanvas berasingan dan menggunakan fungsi Pelancaran untuk menavigasi antara apl berasingan dan menghantar konteks yang diperlukan.

Pendekatan ini digunakan dalam penyelesaian sampel Respons Kecemasan Hospital. App berasingan mengurus setiap kawasan utama keseluruhan app. Apl berkongsi komponen papan suis biasa melalui pustaka komponen yang ditunjukkan oleh setiap apl pada skrin permulaannya:

Tangkapan skrin aplikasi kanvas penyelesaian sampel respons kecemasan hospital yang berjalan pada telefon, menunjukkan komponen kanvas papan suis.

Apabila pengguna memilih kawasan, komponen menggunakan metadata tentang aplikasi yang tersedia dan aplikasi yang mengehoskan komponen tersebut. Jika skrin yang dikehendaki berada dalam apl ini (iaitu,ThisItem.Screen · tidak kosong), maka panggilan Navigasi dibuat. Tetapi jika skrin yang dikehendaki berada dalam apl yang berbeza (iaitu,ThisItem.PowerAppID · tidak kosong), maka fungsi Pelancaran digunakan dengan ID Apl sasaran dan konteks FacilityID:

If(
    IsBlank(ThisItem.Screen),
    If(IsBlank(ThisItem.PowerAppID), 
        Launch(ThisItem.URL),           
        Launch("/providers/Microsoft.PowerApps/apps/" & ThisItem.PowerAppID, 
               "FacilityID", Home_Facility_DD.Selected.Id)
    ),
    Navigate(
        ThisItem.Screen,
        Fade
    )
);

Keadaan dalam apl asal hilang apabila apl lain dilancarkan. Pastikan anda menyimpan sebarang keadaan sebelum anda memanggil fungsi Pelancaran . Tulis pada pangkalan data, panggil SaveData atau hantar keadaan kepada apl sasaran dengan parameter yang dibaca dengan fungsi Param .

Aplikasi dipacu model dengan halaman tersuai

Bahagian juga boleh dilaksanakan sebagai halaman tersuai. Halaman tersuai bertindak sebagai aplikasi kanvas mini dengan bekas aplikasi dipacu model untuk navigasi.

Nota

Adakah anda boleh memberitahu kami tentang keutamaan bahasa dokumentasi anda? Jawab tinjauan pendek. (harap maklum bahawa tinjauan ini dalam bahasa Inggeris)

Tinjauan akan mengambil masa lebih kurang tujuh minit. Tiada data peribadi akan dikumpulkan (pernyataan privasi).

Kongsi melalui