สร้างแอปพื้นที่ทำงานขนาดใหญ่และซับซ้อน

บทความส่วนใหญ่ในส่วนนี้ของเอกสารครอบคลุมถึงประสิทธิภาพรันไทม์ของแอปตามประสบการณ์ของผู้ที่ผู้ใช้แอปเหล่านี้ บทความนี้ครอบคลุมประสิทธิภาพของแอปตามประสบการณ์ของผู้ที่สร้างแอป

เมื่อแอปมีขนาดใหญ่และซับซ้อนมากกว่า Power Apps Studio จำเป็นต้องโหลดและจัดการตัวควบคุม สูตร และแหล่งข้อมูลจำนวนมากขึ้น พร้อมการพึ่งพาระหว่างกันทั้งหมดซึ่งเพิ่มขึ้นอย่างทวีคูณ อาจใช้เวลาในการโหลด Power Apps Studio มากขึ้น และคุณลักษณะต่างๆ เช่น IntelliSense และการกำหนดรหัสสีอาจล่าช้า ใช้คำแนะนำที่ทำให้ทำงานกับแอปขนาดใหญ่และซับซ้อนได้ดียิ่งขึ้นใน Power Apps Studio นอกจากนี้ยังช่วยปรับปรุงประสิทธิภาพรันไทม์ของแอปได้อีกด้วย

ตัวอย่างในหัวบทความนี้ใช้ การรับมือสภาวะฉุกเฉินของโรงพยาบาล - โซลูชันตัวอย่าง

ใช้ App.Formulas แทน App.OnStart

เคล็ดลับ

คุณสามารถใช้ฟังก์ชั่น กับ และคุณสมบัติเอาต์พุตแบบกำหนดเองของคอมโพเนนต์ canvas เป็นทางเลือกแทนสูตรที่กำหนดชื่อ

วิธีที่ดีที่สุดในการลดเวลาการโหลดสำหรับทั้ง Power Apps Studio และแอปของคุณคือการแทนที่การกำหนดค่าเริ่มต้นตัวแปรและคอลเลกชันใน App.OnStart ด้วย สูตรที่มีชื่อใน App.Formulas

ลองดูตัวอย่างต่อไปนี้ ซึ่งใช้ 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
    );
);

เนื่องจากถูกเรียงลำดับตามคำสั่ง แอปของคุณจะต้องประเมินการเรียก Set และ Collect เหล่านี้ตามลำดับ ก่อนที่หน้าจหน้าอแรกจะแสดงขึ้น ซึ่งทำให้เวลาในการโหลดแอปช้าลงอีก และเนื่องจาก App.OnStart ทั้งหมดต้องได้รับการพิจารณาโดยรวม รักษาลำดับ และรวมข้อผิดพลาด ก่อนการส่งคืนผลลัพธ์สุดท้าย สูตรนี้จึงซับซ้อนสำหรับ Power Apps Studio ในการวิเคราะห์

มีวิธีที่ดีกว่านี้ ใช้ App.Formulas แทนและกำหนดตัวแปรและคอลเลกชันเหล่านี้เป็นสูตรที่มีชื่อ ดังตัวอย่างต่อไปนี้

// 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()
    );

การเปลี่ยนแปลงนี้อาจดูเล็กน้อย แต่อาจมีผลกระทบอย่างมาก เนื่องจากแต่ละสูตรที่มีชื่อไม่ขึ้นกับสูตรอื่น Power Apps Studio สามารถวิเคราะห์ได้อย่างอิสระ แยก App.OnStart ขนาดใหญ่ให้เป็นชิ้นเล็กๆ ได้อย่างมีประสิทธิภาพ เราเคยเห็นเวลาในการโหลด Power Apps Studio ลดลงมากถึง 80% ด้วยการเปลี่ยนแปลงนี้เพียงอย่างเดียว

แอปของคุณยังโหลดได้เร็วขึ้น เนื่องจากไม่ต้องประเมินสูตรเหล่านี้จนกว่าจะต้องการผลลัพธ์ หน้าจอแรกของแอปจะแสดงทันที

ไม่สามารถใช้สูตรที่มีชื่อได้ในทุกสถานการณ์ เนื่องจากคุณไม่สามารถแก้ไขหรือใช้กับ Set บางสถานการณ์จำเป็นต้องใช้ตัวแปรสถานะที่สามารถแก้ไขได้ Set เหมาะสำหรับสถานการณ์เหล่านี้ และคุณควรใช้ต่อไป แต่บ่อยครั้งกว่านั้น คุณกำลังใช้ตัวแปรส่วนกลางใน OnStart เพื่อตั้งค่าคงที่ซึ่งไม่มีการเปลี่ยนแปลง ในกรณีดังกล่าว สูตรที่มีชื่อจะเป็นตัวเลือกที่ดีกว่า

เนื่องจากสูตรที่มีชื่อไม่สามารถเปลี่ยนรูปได้ คำนำหน้า var (ย่อมาจาก "ตัวแปร") เป็นหลักการตั้งชื่อจึงไม่เหมาะสมอีกต่อไป เราไม่ได้เปลี่ยนชื่อในตัวอย่างนี้ เนื่องจากจำเป็นต้องเปลี่ยนแปลงส่วนที่เหลือของแอปเพื่อให้ตรงกัน

ซึ่งอาจวางสูตรที่มีชื่อใน App.OnStart แต่ไม่ พวกเขาไม่ได้อยู่ที่นั่น ในฐานะคุณสมบัติ Behavior เปิด App.OnStart ประเมินแต่ละคำสั่งตามลำดับ สร้างตัวแปรส่วนกลาง และ พูดคุยกับฐานข้อมูล เพียงครั้งเดียว เมื่อโหลดแอป สูตรที่มีชื่อจะเป็นสูตรที่กำหนดวิธีคำนวณบางสิ่ง เมื่อต้องการ และเป็นจริงเสมอแทน ซึ่งเป็นธรรมชาติของสูตรนี้ที่ช่วยให้เป็นอิสระและอนุญาตให้แอปโหลดเสร็จก่อนที่จะได้รับการประเมิน

แยกสูตรที่ยาว

App.OnStart เป็นหนึ่งในตัวละเมิดที่เลวร้ายที่สุดสำหรับสูตรที่ยาว และแน่นอนว่าเป็นจุดมี่คุณควรเริ่ม แต่ไม่ใช่เพียงกรณีเดียว

การศึกษาของเราแสดงให้เห็นว่าแอปเกือบทั้งหมดที่มีเวลาในการโหลด Power Apps Studio นาน มีอย่างน้อยหนึ่งสูตรที่มีอักขระมากกว่า 256,000 ตัว บางแอปที่มีเวลาโหลดนานที่สุดจะมีสูตรที่มีความยาวมากกว่า 1 ล้านอักขระ สูตรที่ทำให้เกิดการตอบสนองเวลานานใน Power Apps Studio

ที่แย่กว่านั้น การคัดลอกและการวางตัวควบคุมที่มีสูตรที่ยาวซ้ำกันในคุณสมบัติของตัวควบคุมโดยไม่รู้ตัว Power Apps ถูกจำลองแบบมาจาก Excel ซึ่งมีสูตรหลายชุดอยู่ทั่วไป อย่างไรก็ตาม ในสูตร Excel จะจำกัดไว้ที่หนึ่งนิพจน์ และจำกัดไว้ที่ 8,000 อักขระ สูตร Power Apps สามารถยาวได้มากขึ้นด้วยการแนะนำตรรกะที่จำเป็นและตัวดำเนินการเชื่อมโยง (; หรือ ;; ขึ้นอยู่กับตำแหน่งที่ตั้ง)

วิธีแก้ไขทั่วไปคือการแบ่งสูตรยาวๆ ออกเป็นส่วนเล็กๆ และนำส่วนเหล่านั้นกลับมาใช้ใหม่ เช่นเดียวกับที่เราทำในส่วนก่อนหน้าเมื่อเราเปลี่ยนคำสั่ง Set/Collect ใน App.OnStart เป็นสูตรที่มีชื่อใน App.Formulas ในภาษาการเขียนโปรแกรมอื่นๆ ส่วนที่นำมาใช้ใหม่ได้มักจะเรียกว่า Subroutine หรือฟังก์ชันที่ผู้ใช้กำหนด คุณสามารถคิดได้ว่าสูตรที่มีชื่อเป็นฟอร์มง่ายๆ ของฟังก์ชันที่ผู้ใช้กำหนด โดยไม่มีพารามิเตอร์และไม่มีผลข้างเคียง

ใช้สูตรที่มีชื่อทุกที่

ในตัวอย่างก่อนหน้านี้ เราใช้สูตรที่มีชื่อแทน App.OnStart อย่างไรก็ตาม คุณสามารถใช้แทนการคำนวณได้ทุกที่ในแอป

ตัวอย่างเช่น หนึ่งในหน้าจอในโซลูชันตัวอย่าง Hospital Emergency Response มีตรรกะนี้ใน 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
    }
); 

สูตรนี้สามารถแบ่งออกเป็นชุดของสูตรที่มีชื่อ นอกจากนี้ยังทำให้อ่านสูตรได้ง่ายขึ้น

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
    };

เราแตก ParamFacility เป็นสูตรที่มีชื่อก่อนหน้านี้เมื่อเราย้ายการเรียกใช้ Set ส่วนใหญ่จาก App.OnStart เป็นสูตรที่มีชื่อใน App.Formulas

สูตรที่มีชื่อจะได้รับการประเมินเมื่อจำเป็นต้องใช้ค่าเท่านั้น หากความตั้งใจดั้งเดิมของการใช้ Screen.OnVisible คือการเลื่อนการทำงานออกไปจนกว่าจะแสดงหน้าจอ งานนั้นจะยังคงถูกเลื่อนออกไปเป็นสูตรที่มีชื่อส่วนกลางใน App.Formulas

ใช้ฟังก์ชัน With

คุณยังสามารถใช้ฟังก์ชัน With ในสูตรเพื่อแยกลอจิก สร้างเรกคอร์ดในพารามิเตอร์แรกด้วยค่าที่คุณต้องการใช้เป็นฟิลด์ จากนั้นใช้ฟิลด์เหล่านั้นในพารามิเตอร์ที่สองเพื่อคำนวณค่าส่งคืนจาก With ตัวอย่างเช่น ตัวอย่างข้างต้นสามารถเขียนเป็นสูตรที่มีชื่อเดียว:

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
           }
    )

ข้อเสียประการหนึ่งของการใช้ With คือวิธีนี้ MyFacility ใช้ MyRegion ไม่ได้เนื่องจากมีการกำหนดไว้ในฟังก์ช้น With เดียวกัน จึงไม่มีปัญหาที่มีสูตรที่มีชื่อ การแก้ไขปัญหาวิธีหนึ่งคือซ้อนฟังก์ชัน With และใช้คำสำคัญ As เพื่อตั้งชื่อเรกคอร์ดสำหรับแต่ละรายการเพื่อให้เข้าถึงได้ง่ายไปยังตัวแปร With ทั้งหมด

ใช้ส่วนประกอบพื้นที่ทำงาน

ส่วนประกอบพื้นที่ทำงานมักใช้เพื่อสร้างตัวควบคุม UI ที่สามารถวางบนพื้นที่ทำงานได้เช่นเดียวกับตัวควบคุม นอกจากนี้คุณยังสามารถใช้ได้โดยไม่มีการวางใน UI เพื่อทำการคำนวณด้วยคุณสมบัติผลลัพธ์แบบกำหนดเอง ซึ่งเป็นทางเลือกแทนสูตรที่มีชื่อ ส่วนประกอบพื้นที่ทำงานนั้นง่ายต่อการแชร์ข้ามแอปด้วยไลบรารีส่วนประกอบ และได้รับการสนับสนุนอย่างสมบูรณ์ ไม่เหมือนกับสูตรที่มีชื่อ อย่างไรก็ตาม การกำหนดค่าและใช้งานทำได้ยากกว่าสูตรที่มีชื่อ

เพื่อแยกตรรกะ:

1. ใน Power Apps Studio ให้สลับแท็บ ส่วนประกอบ ใน มุมมองทรี
2. สร้างส่วนประกอบใหม่
3. ในบานหน้าต่าง คุณสมบัติ ให้เปิด เข้าถึงขอบเขตแอป
4. เพื่อคุณสมบัติที่กำหนดเอง
5. เลือก ชนิดคุณสมบัติ เป็น ผลลัพธ์ และ ชนิดข้อมูล ตามเหมาะสม
6. เลือก สร้าง
7. ในตัวเลือกคุณสมบัติถัดจากแถบสูตรที่ด้านบนของหน้าจอ ให้เลือกคุณสมบัติใหม่
8. เขียนสูตรสำหรับตรรกะที่จะแยกและนำกลับมาใช้ใหม่

ในการใช้ตรรกะ:

1. สลับแท็บ หน้าจอ ใน มุมมองลำดับชั้น
2. ในบานหน้าต่าง แทรก ให้ขยาย กำหนดเอง และแทรกส่วนประกอบของคุณ
3. ในการคำนวณค่าที่มีคุณสมบัติ ให้ใช้ ComponentName.PropertyName

ใช้ Select กับตัวควบคุมที่ซ่อนอยู่สำหรับตรรกะที่จำเป็น

ตรรกะที่จำเป็นใช้เพื่อแก้ไขสถานะด้วย Set และ Collect แจ้งเตือนผู้ใช้ด้วย Notify นำทางไปยังหน้าจอหรือแอปอื่นด้วย Navigate และ Launch และเขียนค่ากลับลงในฐานข้อมูลด้วย Patch, SubmitForm หรือ RemoveIf

สูตรที่มีชื่อ และคุณสมบัติผลลัพธ์ที่กำหนดเองของส่วนประกอบพื้นที่ทำงานไม่สนับสนุนตรรกะที่จำเป็น วิธีทั่วไปในการแยกตรรกะที่จำเป็นคือการใช้คุณสมบัติ OnSelect ของตัวควบคุมที่ซ่อนอยู่

1. เพิ่มตัวควบคุม ปุ่ม ให้กับหน้าจอ
2. ตั้งค่าคุณสมบัติ OnSelect เป็นตรรกะที่จำเป็นที่คุณต้องการดำเนินการ
3. ตั้งค่าคุณสมบัติ มองเห็นได้ เป็นเท็จ เนื่องจากผู้ใช้ไม่จำเป็นต้องเห็นหรือโต้ตอบกับคุณสมบัตินี้
4. เรียกใช้ Select( Button ) เมื่อคุณต้องการดำเนินการตามตรรกะที่จำเป็น

ตัวอย่างเช่น หน้าจอหนึ่งในตัวอย่างของเรามีคุณสมบัติ OnSelect ต่อไปนี้บนตัวควบคุม ปุ่ม (ตัวอย่างง่ายๆ นี้ใช้เพื่อจุดประสงค์ในการอธิบายเท่านั้น โดยปกติ คุณจะใช้เทคนิคนี้สำหรับสูตรที่ยาวขึ้นเท่านั้น)

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)
    );

หากต้องการแยกตรรกะนี้ออกเป็นส่วนๆ เราสามารถใส่ส่วนต่างๆ ลงในตัวควบคุม ปุ่ม และ เลือก จากต้นฉบับ:

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 );

เทคนิคนี้ใช้งานได้บนหน้าจอเดียวกันเท่านั้น เทคนิคอื่นๆ ที่ซับซ้อนกว่าเล็กน้อยจะทำงานบนหน้าจอต่างๆ เช่น การใช้ปุ่มควบคุม สลับ การตั้งค่า OnCheck คุณต้องการเรียกใช้ และตั้งค่า ค่าเริ่มต้น เป็นตัวแปรส่วนกลาง จากนั้นสลับตัวแปรส่วนกลางด้วย Set( global, true ); Set( global, false ) ที่จุดที่คุณต้องการเรียกใช้ตรรกะ

ในตัวอย่างนี้ ได้ทำการแยกตรรกะบางส่วนแล้ว ข้อคิดเห็นระบุว่า "การดำเนินการที่ตามมาสามารถพบได้ใน OnSuccess" เหตุการณ์นี้เรียกใช้ตรรกะที่จำเป็นหลังจากส่งบันทึกเรียบร้อยแล้ว ซึ่งเป็นโซลูชันเฉพาะสำหรับฟังก์ชัน SubmitForm

พาร์ติชันแอป

แอปบางแอปขยายการควบคุมเป็นพันรายการและแหล่งข้อมูลหลายร้อยรายการ ซึ่งทำให้ Power Apps Studio ช้าลง เช่นเดียวกับสูตรที่ยาว แอปขนาดใหญ่สามารถแบ่งออกเป็นส่วนย่อยๆ ที่ทำงานร่วมกันเพื่อสร้างประสบการณ์ผู้ใช้เดียว

แยกแอปพื้นที่ทำงาน

วิธีหนึ่งคือการนำส่วนต่างๆ ไปใช้ในแอปพื้นที่ทำงานแยกต่างหาก และใช้ฟังก์ชัน Launch เพื่อนำทางระหว่างแอปที่แยกกันและส่งบริบทที่จำเป็น

วิธีการนี้ใช้ใน การรับมือสภาวะฉุกเฉินของโรงพยาบาล - โซลูชันตัวอย่าง แอปที่แยกจากกันจะจัดการแต่ละส่วนหลักๆ ของแอปโดยรวม แอปแชร์คอมโพเนนต์สวิตช์บอร์ดทั่วไปผ่านไลบรารีคอมโพเนนต์ที่แต่ละแอปแสดงบนหน้าจอเริ่มต้น:

เมื่อผู้ใช้เลือกพื้นที่ ส่วนประกอบจะใช้ข้อมูลเมตาเกี่ยวกับแอปที่มีและแอปใดที่โฮสต์ส่วนประกอบ หากหน้าจอที่ต้องการอยู่ในแอปนี้ (นั่นคือ ThisItem.Screen ไม่เว้นว่างไว้) ซึ่งจะมีการเรียกใช้ Navigate แต่ถ้าหน้าจอที่ต้องการอยู่ในแอปอื่น (นั่นคือ ThisItem.PowerAppID ไม่เว้นว่างไว้) ซึ่งฟังก์ชัน Launch จะใช้กับรหัสแอปของเป้าหมายและบริบท 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
    )
);

สถานะในแอปดั้งเดิมจะหายไปเมื่อแอปอื่นเปิดใช้งาน อย่าลืมบันทึกสถานะใดๆ ก่อนเรียกฟังก์ชัน Launch เขียนลงในฐานข้อมูล เรียก SaveData หรือส่งสถานะไปยังแอปเป้าหมายด้วยพารามิเตอร์ที่อ่านด้วยฟังก์ชัน Param

แอปแบบจำลองกับหน้าแบบกำหนดเอง

ส่วนต่างๆ สามารถนำไปใช้เป็น หน้าแบบกำหนดเอง หน้าแบบกำหนดเองทำหน้าที่เป็นแอปพื้นที่ทำงานขนาดเล็ก โดยมีคอนเทนเนอร์แอปแบบจำลองสำหรับการนำทาง

หมายเหตุ

บอกให้เราทราบเกี่ยวกับภาษาที่คุณต้องการในคู่มือ ทำแบบสำรวจสั้นๆ (โปรดทราบว่าแบบสำรวจนี้เป็นภาษาอังกฤษ)

แบบสำรวจนี้ใช้เวลาทำประมาณเจ็ดนาที ไม่มีการเก็บข้อมูลส่วนบุคคล (คำชี้แจงสิทธิ์ส่วนบุคคล)