การเพิ่มประสิทธิภาพโค้ด

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

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

การเพิ่มประสิทธิภาพสูตร Power Fx

ฟังก์ชัน With

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

ฟังก์ชัน Concurrent

ฟังก์ชัน Concurrent ช่วยให้หลายสูตรในคุณสมบัติเดียวกันสามารถประเมินพร้อมกันได้หากมีการเรียกใช้ตัวเชื่อมต่อหรือ Dataverse โดยปกติ หลายสูตรจะได้รับการประเมินพร้อมกันเมื่อคุณเชื่อมโยงสูตรเหล่านั้นด้วยตัวดำเนินการ ; (เครื่องหมายอัฒภาค) ด้วย Concurrent แอปจะประเมินสูตรทั้งหมดในคุณสมบัติพร้อมกัน แม้ว่าจะใช้ตัวดำเนินการ ; แล้วก็ตาม การทำงานพร้อมกันนี้หมายความว่าผู้ใช้รอผลลัพธ์น้อยลง เมื่อการเรียกข้อมูลไม่เริ่มต้นจนกว่าการเรียกก่อนหน้าจะเสร็จสิ้น แอปจะรอผลรวมของเวลาการร้องขอทั้งหมด ถ้าการเรียกข้อมูลเริ่มต้นในเวลาเดียวกัน แอปจะรอเวลาร้องขอที่นานที่สุดเท่านั้น เรียนรู้เพิ่มเติม เกี่ยวกับฟังก์ชัน Concurrent

Concurrent(
    ClearCollect(colAccounts1, Accounts),
    ClearCollect(colUsers1, Users),
    ClearCollect(colEnvDef1, 'Environment Variable Definitions'),
    ClearCollect(colEnvVal1, 'Environment Variable Values')
);

ฟังก์ชัน Coalesce

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

ตัวอย่าง

If(Not IsBlank(value1), value1, Not IsBlank(value2), value2)

ต้องมีการประเมินค่า 1 และค่า 2 สองครั้ง ฟังก์ชันนี้สามารถลดลงเป็น:

Coalesce(value1, value2)

ฟังก์ชัน IsMatch

ฟังก์ชัน IsMatch จะทดสอบว่าสตริงข้อความตรงกับรูปแบบที่อาจประกอบด้วยอักขระทั่วไป รูปแบบที่กำหนดไว้ล่วงหน้าหรือนิพจน์ปกติ เรียนรู้เพิ่มเติม เกี่ยวกับฟังก์ชัน IsMatch

ตัวอย่างเช่น สูตรนี้จับคู่หมายเลขประกันสังคมของสหรัฐอเมริกา:

IsMatch(TextInput1.Text, "\d{3}-\d{2}-\d{4}")

คำอธิบายของนิพจน์ปกติ:

\\d จับคู่ตัวเลขใดๆ (0-9)

{3} ระบุว่ารูปแบบหลักก่อนหน้า (\d) ควรเกิดขึ้นสามครั้งพอดี

- จับคู่อักขระยัติภังค์

{2} ระบุว่ารูปแบบหลักก่อนหน้า (\d) ควรเกิดขึ้นสองครั้งพอดี

{4} ระบุว่ารูปแบบหลักก่อนหน้า (\d) ควรเกิดขึ้นสี่ครั้งพอดี

ตัวอย่างเพิ่มเติมของ IsMatch:

IsMatch(TextInput1.Text, "Hello World")
IsMatch(TextInput1\_2.Text, "(?!^\[0-9\]\\\*$)(?!^\[a-zA-Z\]\\\*$)(\[a-zA-Z0-9\]{8,10})")

เพิ่มประสิทธิภาพ OnStart ของแอป

คุณสมบัติ OnStart สำหรับแอปพื้นที่ทำงานมีบทบาทสำคัญในการกำหนดการดำเนินการที่เกิดขึ้นเมื่อเปิดใช้แอป คุณสมบัตินี้ช่วยให้นักพัฒนาแอปสามารถดำเนินงานการเริ่มต้นทั้งหมด ตั้งค่าตัวแปร และดำเนินการที่ควรจะเกิดขึ้นเพียงครั้งเดียวในระหว่างกระบวนการเริ่มต้นของแอป การทำความเข้าใจและการใช้คุณสมบัติ OnStart อย่างมีประสิทธิภาพเป็นสิ่งสำคัญสำหรับการสร้างแอปพื้นที่ทำงานที่ตอบสนองและมีประสิทธิภาพ

แนวทางที่แนะนำคือการปรับปรุงประสิทธิภาพฟังก์ชัน App.OnStart โดยการย้ายการตั้งค่าตัวแปรไปยังสูตรที่มีชื่อ สูตรที่มีชื่อ โดยเฉพาะอย่างยิ่งที่กำหนดค่าไว้ในช่วงต้นของวงจรการใช้งานแอป พิสูจน์แล้วว่ามีข้อได้เปรียบ สูตรเหล่านี้จัดการการเริ่มต้นตัวแปรตามการเรียกข้อมูล ทำให้โค้ดของคุณมีโครงสร้างที่สะอาดตาและเป็นระเบียบมากขึ้น รายละเอียดเพิ่มเติม สร้างแอปพื้นที่ทำงานขนาดใหญ่และซับซ้อน - Power Apps | Microsoft Learn

หมายเหตุ

คุณสมบัติ OnStart เป็นสิ่งสำคัญ เป็นรายการงานที่ต้องทำตามลำดับก่อนที่จะแสดงหน้าจอแรก เพราะไม่แค่มีความเฉพาะเจาะจงว่าอะไร จำเป็นต้องทำ แต่ยังรวมถึงเมื่อใดงานนั้นต้องทำตามลำดับ ซึ่งจะจำกัดการเพิ่มประสิทธิภาพการเรียงลำดับใหม่และการเลื่อนเวลาที่อาจทำได้

เริ่มหน้าจอ

หาก App.OnStart มีการเรียกฟังก์ชัน Navigate แม้ว่าจะอยู่ในฟังก์ชัน If และไม่ค่อยถูกเรียก เราจะต้องดำเนินการเรียกใช้แอป OnStart ก่อนที่เราจะแสดงหน้าจอแรกของแอป  App.StartScreen เป็นวิธีการประกาศแบบใหม่ในการระบุว่าควรแสดงหน้าจอใดก่อน ซึ่งจะไม่บล็อกการปรับให้เหมาะสม

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

แทนที่จะเขียนโค้ด เช่น:

App.OnStart = Collect(OrdersCache, Orders);
If(Param("AdminMode") = "1", Navigate(AdminScreen), Navigate(HomeScreen))

ให้เปลี่ยนโค้ดเป็น:

App.OnStart = Collect(OrdersCache, Orders);
App.StartScreen = If(Param("AdminMode") = "1", AdminScreen, HomeScreen)

โปรดดู <https://Power Apps.microsoft.com/en-us/blog/app-startscreen-a-new-declarative-alternative-to-navigate-in-app-onstart/> สำหรับรายละเอียดเพิ่มเติม

คำเตือน

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

สูตรที่มีชื่อ

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

สูตรที่มีชื่อยังสามารถระบุถึงการประกาศธีมของแอปได้ด้วย ในหลายกรณีที่มีการสร้างแอประดับองค์กร เราต้องการให้แอปมีธีมทั่วไปเพื่อให้รูปลักษณ์และประสบการณ์ผู้ใช้ที่สอดคล้องกัน ในการสร้างธีม มีตัวแปร 10 ถึง 100 ตัวที่ต้องประกาศบน App OnStart ความยาวโค้ดและเวลาเริ่มต้นของแอปเพิ่มขึ้น

ตัวควบคุมสมัยใหม่ยังช่วยได้มากในการกำหนดธีม และช่วยลดตรรกะในการเขียนของลูกค้าในการจัดการธีม ตัวควบคุมสมัยใหม่ยังอยู่ในรุ่นพรีวิว

ตัวอย่างเช่น โค้ดต่อไปนี้บน App.OnStart สามารถย้ายไปที่ App.Formulas ซึ่งจะช่วยลดเวลาเริ่มต้นในการประกาศตัวแปรส่วนกลาง

Set(BoardDark, RGBA(181,136,99, 1));
Set(BoardSelect, RGBA(34,177,76,1));
Set(BoardRowWidth, 10);                      // expected 8 plus two guard characters for regular expressions.
Set(BoardMetadata, 8 \* BoardRowWidth + 1);   // which player is next, have pieces moved for castling rules, etc.
Set(BoardBlank, "----------------------------------------------------------------\_00000000000000");
Set(BoardClassic, "RNBQKBNR\_\_PPPPPPPP------------------------\_--------\_\_pppppppp\_\_rnbqkbnr\_\_0000000000");

โดยสามารถย้ายโค้ดไปที่ App.Formulas ได้ดังนี้:

BoardSize = 70;
BoardLight = RGBA(240,217,181, 1);
BoardDark = RGBA(181,136,99, 1);
BoardSelect = RGBA(34,177,76,1);
BoardRowWidth = 10;                      // expected 8 plus two guard characters for regular expressions
BoardMetadata = 8 \* BoardRowWidth + 1;   // which player is next, have pieces moved for castling rules, etc.
BoardBlank = "----------------------------------------------------------------\_00000000000000";
BoardClassic = "RNBQKBNR\_\_PPPPPPPP------------------------\_--------\_\_pppppppp\_\_rnbqkbnr\_\_0000000000";

อีกตัวอย่างหนึ่งคือ การตั้งค่า Lookups ในที่นี้ จำเป็นต้องเปลี่ยนแปลงในสูตรการค้นหาเพื่อรับข้อมูลผู้ใช้จาก Office 365 แทน Dataverse มีเพียงที่เดียวเท่านั้นที่ต้องเปลี่ยนแปลงโดยไม่ต้องเปลี่ยนโค้ดทุกที่

UserEmail = User().Email;
UserInfo = LookUp(Users, 'Primary Email' = User().Email);
UserTitle = UserInfo.Title;
UserPhone = Switch(UserInfo.'Preferred Phone', 'Preferred Phone (Users)'.'Mobile Phone', UserInfo.'Mobile Phone',
UserInfo.'Main Phone');

สูตรเหล่านี้เป็นส่วนสำคัญของการคำนวณ โดยจะกล่าวถึงกระบวนการกำหนด UserEmail, UserInfo, UserTitle และ UserPhone ตามค่าอื่นๆ ตรรกะนี้ถูกห่อหุ้มไว้ ช่วยให้สามารถใช้งานได้อย่างแพร่หลายทั่วทั้งแอป และสามารถแก้ไขได้ในตำแหน่งเดียว ความสามารถในการปรับเปลี่ยนขยายไปสู่การสลับจากตารางผู้ใช้ Dataverse ไปเป็นตัวเชื่อมต่อ Office 365 โดยไม่จำเป็นต้องแก้ไขสูตรที่กระจายอยู่ทั่วทั้งแอป

อีกวิธีหนึ่งคือ การเพิ่มประสิทธิภาพ countRows

varListItems = CountRows(SampleList)

ด้วยฟังก์ชัน Set ตัวแปร varListItems จะต้องเริ่มต้นด้วยจำนวนแถวเริ่มต้นในรายการตัวอย่าง และตั้งค่าอีกครั้งหลังจากเพิ่มหรือลบรายการแล้ว เมื่อใช้สูตรที่มีชื่อ เมื่อข้อมูลเปลี่ยนแปลง ตัวแปร varListitems จะได้รับการอัปเดตโดยอัตโนมัติ

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

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

ฟังก์ชันที่ผู้ใช้กำหนดเอง

ฟังก์ชันที่ผู้ใช้กำหนดใน Power Apps Authoring Studio ช่วยให้ผู้ใช้สามารถสร้างฟังก์ชันที่กำหนดเองได้

หากต้องการใช้คุณลักษณะนี้ ภายใต้การตั้งค่ารุ่นพรีวิว ให้เปิดฟังก์ชันที่ผู้ใช้กำหนด (UDF) ไม่ควรใช้ฟังก์ชันการแสดงตัวอย่างในการผลิต ซึ่งเป็นสาเหตุที่ปิดใช้งานโดยค่าเริ่มต้น แต่จะพร้อมใช้งานโดยทั่วไปในไม่ช้า

กำหนดสูตรภายใต้ App.Formulas ดังต่อไปนี้:

FunctionName(Parameter1:DataType1, Parameter2:DataType2):OutputDataType = Formula

โค้ดจะทำงานดังนี้:

• FunctionName ใช้เพื่อเรียกใช้ฟังก์ชัน

• Parameter เป็นชื่อของอินพุต อนุญาตอินพุตอย่างน้อยหนึ่งรายการ

• DataType เป็นอาร์กิวเมนต์ที่ส่งผ่านไปยังฟังก์ชันซึ่งจะต้องตรงกับชนิดข้อมูลนี้ ชนิดข้อมูลที่สามารถใช้ได้ ได้แก่ แบบบูลีน สี วันที่ วันที่เวลา ไดนามิก GUID ไฮเปอร์ลิงก์ ข้อความ และเวลา

• OutputDataType เป็นชนิดข้อมูลที่จะเป็นเอาต์พุตของฟังก์ชัน

• Formula เป็นเอาต์พุตของฟังก์ชัน

// Function to calculate the area of a circle based on the radius
calcAreaOfCircle(radius: Number): Number = 
    IfError(Pi() * radius * radius, 0);

ใช้ IfError เพื่อทำการจัดการข้อผิดพลาดภายในฟังก์ชันที่กำหนด

เรียกฟังก์ชันที่กำหนดจากตัวควบคุมข้อความ/ป้ายชื่อ

calcAreaOfCircle(Int(*TextInput1*.Text))

หมายเหตุ

คุณลักษณะทดลองและอาจเปลี่ยนแปลงได้ ยังไม่รองรับข้อมูลบางชนิด เช่น เรกคอร์ดและตัวกรอง

เพิ่มประสิทธิภาพตัวแปร

ตัวแปรจะกำหนดและตั้งค่าท้องถิ่นและส่วนกลางที่คุณใช้ทั่วทั้งแอป แม้ว่าจะสะดวก แต่การใช้ตัวแปรมากเกินไปอาจทำให้แอปของคุณมีประสิทธิภาพน้อยลง

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

Set(varEmpName, Office365Users.MyProfile().DisplayName);
Set(varEmpCity, Office365Users.MyProfile().City);
Set(varEmpPhone, Office365Users.MyProfile().BusinessPhones);
Set(varEmpUPN, Office365Users.MyProfile().UserPrincipalName);
Set(varEmpMgrName, Office365Users.ManagerV2(varEmpUPN).DisplayName);

วิธีที่มีประสิทธิภาพมากขึ้นคือการใช้คุณสมบัติเมื่อคุณต้องการเท่านั้น:

Set(varEmployee, Office365Users.MyProfile())
"Welcome " & varEmployee.DisplayName

ใช้ตัวแปรบริบทและตัวแปรส่วนกลางอย่างชาญฉลาด หากขอบเขตของตัวแปรเกินกว่าหน้าจอเดียว ให้ใช้ตัวแปรส่วนกลางแทนตัวแปรบริบท

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

เพิ่มประสิทธิภาพคอลเลกชัน

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

// Use this pattern
ClearCollect(colErrors, {Text: gblErrorText, Code: gblErrorCode});

// Do not use this pattern
Clear(colErrors);
Collect(colErrors, {Text: gblErrorText, Code: gblErrorCode});

เมื่อต้องการนับเรกคอร์ดในคอลเลกชันภายในเครื่อง ให้ใช้ CountIf แทน Count(Filter())

พิจารณาคำแนะนำนี้เมื่อทำงานกับคอลเลกชัน:

จำกัดขนาดและจำนวนคอลเลกชัน เนื่องจากคอลเลกชันอยู่ในแอป จึงจัดเก็บไว้ในหน่วยความจำของอุปกรณ์เคลื่อนที่ ยิ่งมีการรวบรวมข้อมูลมากเท่าใด หรือคุณใช้คอลเล็กชันมากเท่าใด ประสิทธิภาพก็จะยิ่งแย่ลงเท่านั้น ใช้ฟังก์ชัน ShowColumns เพื่อรับเฉพาะคอลัมน์ที่ระบุ เพิ่มฟังก์ชัน Filter เพื่อรับเฉพาะข้อมูลที่เกี่ยวข้อง

ฟังก์ชันตัวอย่างต่อไปนี้จะส่งคืนชุดข้อมูลทั้งหมด

ClearCollect(colDemoAccount, Accounts);

เปรียบเทียบข้อมูลนี้กับโค้ดต่อไปนี้ ซึ่งส่งคืนเฉพาะเรกคอร์ดและคอลัมน์ที่ระบุเท่านั้น:

ClearCollect(colAcc,
              ShowColumns(
                Filter(Accounts, !IsBlank('Address 1: City')),
                "name","address1_city"))

ตัวอย่างนี้ส่งคืนชุดข้อมูลต่อไปนี้:

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

ข้อมูลแคชในคอลเลกชันและตัวแปร

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

// Clear the contents of EmployeeCollection, it already contains data
ClearCollect(
    colEmployee,
    {
        Id: "1",
        Name: "John",
        Department: "IT"
    },
    {
        Id: "2",
        Name: "Nestor",
        Department: "IT"
    }
)

ลบตัวแปรและสื่อที่ไม่ได้ใช้

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

• ไฟล์สื่อที่ไม่ได้ใช้จะเพิ่มขนาดแอป ซึ่งอาจทำให้เวลาในการโหลดแอปช้าลง

• ตัวแปรที่ไม่ได้ใช้จะเพิ่มการใช้หน่วยความจำและอาจทำให้การเริ่มต้นแอปช้าลงเล็กน้อย มีการจัดสรรทรัพยากรสำหรับตัวแปรเหล่านี้แม้ว่าจะไม่ได้ใช้ก็ตาม ตัวแปรที่ไม่ได้ใช้มากเกินไปอาจทำให้ตรรกะของแอปซับซ้อนขึ้นได้

• ใช้ตัวตรวจสอบแอปเพื่อตรวจสอบสื่อและตัวแปรที่ไม่ได้ใช้

เพิ่มประสิทธิภาพหน้าจอและตัวควบคุม

หลีกเลี่ยงตัวควบคุมการอ้างอิงโยง

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

ตัวตรวจสอบแอปใน Power Apps Studio แสดงตัวควบคุมที่มีการอ้างอิงโยง ตรวจสอบตัวตรวจสอบแอปเป็นประจำเพื่อแก้ไขปัญหานี้

นี่คือตัวอย่างของตัวควบคุมที่มีการอ้างอิงโยง ในรูปด้านล่าง ตัวควบคุมแกลเลอรี 1 มีการอ้างอิงโยงในตัวควบคุม Screen 2, Label 2

หากคุณอ้างอิงตัวควบคุมจากหน้าจอแรกในแอปในหน้าจอที่สอง จะไม่มีการกระทบต่อประสิทธิภาพการทำงานเนื่องจากโหลดหน้าจอแรกแล้ว นี่อาจเป็นสิ่งที่ดีเพราะแอปมีการประกาศแทนที่จะใช้ตัวแปร

หากคุณอ้างอิงตัวควบคุมที่ยังไม่ได้โหลด เช่น หน้าจอแรกที่อ้างอิงตัวควบคุมที่ชื่อ Label 3 จากหน้าจอ 3 แอปจะโหลดหน้าจอนั้นลงในหน่วยความจำ

เปิดใช้งาน DelayOutput สำหรับตัวควบคุมข้อความ

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

ตัวอย่างเช่น สำหรับแกลเลอรีที่มีรายการถูกกรองโดยขึ้นอยู่กับสิ่งที่ผู้ใช้ป้อนในตัวควบคุม TextInput:

• เมื่อตั้งค่า DelayOutput เป็น false ซึ่งเป็นค่าเริ่มต้น แกลเลอรีจะถูกกรองทันทีที่พิมพ์ข้อความใดๆ หากคุณมีแกลเลอรีที่มีรายการจำนวนมาก การโหลดแกลเลอรีซ้ำพร้อมการเปลี่ยนแปลงจะทำให้ประสิทธิภาพการทำงานช้าลง รอสักหน่อยดีกว่า ซึ่งมีประโยชน์เมื่อคุณใช้ TextInput สำหรับสตริงการค้นหา (ดูที่ ค้นหา หรือฟังก์ชัน StartsWith ใหม่)

• เมื่อตั้งค่า DelayOutput เป็น true จะมีการหน่วงเวลาสั้นๆ ก่อนที่จะตรวจพบการเปลี่ยนแปลง วิธีนี้จะช่วยให้คุณมีเวลาพิมพ์ให้เสร็จ ความล่าช้าทำงานได้ดีกับคุณสมบัติ TextInput.OnChange ถ้าคุณมีการดำเนินการที่เชื่อมโยงกับการเปลี่ยนแปลง คุณไม่ต้องการให้มีการทริกเกอร์จนกว่าคุณจะพิมพ์ลงในฟิลด์เสร็จแล้ว

การมอบสิทธิ์และการประมวลผลฝั่งเซิร์ฟเวอร์

การมอบหมาย

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

![หมายเหตุ] ไม่ใช่ทุกฟังก์ชันที่สามารถมอบสิทธิ์ได้ โปรดดูที่ การทำความเข้าใจการมอบสิทธิ์ เพื่อเรียนรู้เพิ่มเติมเกี่ยวกับการมอบสิทธิ์

การมอบสิทธิ์มีข้อดีหลายประการ เช่น การเพิ่มประสิทธิภาพการสอบถามและเพิ่มการสนับสนุนสำหรับชุดข้อมูลขนาดใหญ่ นอกจากนี้ หากข้อมูลต้นฉบับเปลี่ยนแปลงบ่อยครั้ง การมอบสิทธิ์จะช่วยให้ข้อมูลอัปเดตอยู่เสมอ

ลดการเรียก API ไปยังแหล่งข้อมูล

บางครั้งอาจดูสะดวกในการสร้างคอลเลกชันโดยการรวมภายในแอปพื้นที่ทำงานของคุณ ตัวอย่างมีดังนี้:

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

// Bad code
ClearCollect(vartruckdata, AddColumns('Truck Details',
    "CITY",LookUp(Drivers, 'Truck Details'\[@'Dummy ID'\] = Drivers\[@'Truck Details'\],City),
        "FIRSTNAME",LookUp(Drivers, 'Truck Details'\[@'Dummy ID'\] = Drivers\[@'Truck Details'\],'Driver First Name'),
    "LASTNAME",LookUp(Drivers, 'Truck Details'\[@'Dummy ID'\] = Drivers\[@'Truck Details'\],'Driver Last Name'),
        "STATE",LookUp(Drivers, 'Truck Details'\[@'Dummy ID'\] = Drivers\[@'Truck Details'\],State)));

การดำเนินการรวมข้อมูลดังกล่าวในแอปพื้นที่ทำงานสามารถสร้างการเรียกจำนวนมากไปยังแหล่งข้อมูล ซึ่งนำไปเวลาในการโหลดที่ช้า

แนวทางที่ดีกว่าคือ:

// Good code
Set(
    varTruckData,
    LookUp(
        Drivers,
        'Dummy ID' = ThisRecord.'Dummy ID',
        'Driver First Name'
    ) & LookUp(
        Drivers,
        'Dummy ID' = ThisRecord.'Dummy ID',
        'Driver Last Name'
        )
);

Set(
    varTruckData,
    With(
        {
            vDriver: LookUp(
                Drivers,
                'Dummy ID' = ThisRecord.'Dummy ID'
            )
        },
        vDriver.'Driver First Name' & vDriver.'Driver Last Name'
    )
)

ในสถานการณ์แบบเรียลไทม์ คุณสามารถลดเวลาในการโหลดจากห้านาทีเหลือต่ำกว่า 10 วินาทีโดยแก้ไขข้อมูลในแหล่งที่มา

การประมวลผลฝั่งเซิร์ฟเวอร์

แหล่งข้อมูลต่างๆ เช่น SQL และ Dataverse ให้คุณสามารถมอบหมายการประมวลผลข้อมูล เช่น ตัวกรองและการค้นหาให้กับแหล่งข้อมูล ใน SQL Server คุณสามารถสร้างมุมมองที่กำหนดโดยการสอบถามได้ ใน Dataverse คุณสามารถสร้างปลั๊กอินแบบ low-code เพื่อประมวลผลข้อมูลบนเซิร์ฟเวอร์และส่งคืนเฉพาะผลลัพธ์สุดท้ายไปยังแอปพื้นที่ทำงานของคุณ

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

เรียนรู้เพิ่มเติมเกี่ยวกับ ปลั๊กอินใน Dataverse

ปรับรูปแบบข้อมูลการสอบถามให้เหมาะสม

ใช้การเลือกคอลัมน์ที่ชัดเจน

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

หลีกเลี่ยงการเรียก Power Automate เพื่อเติมคอลเลกชัน

แนวทางปฏิบัติทั่วไปคือการใช้ Power Automate เพื่อดึงข้อมูลและเติมข้อมูลคอลเลกชันใน Power Apps แม้ว่าวิธีนี้จะใช้ได้ แต่ก็มีบางสถานการณ์ที่อาจไม่ใช่ตัวเลือกที่มีประสิทธิภาพมากที่สุด การเรียก Power Automate มาพร้อมกับเวลาแฝงของเครือข่าย และเพิ่มต้นทุนด้านประสิทธิภาพ 0.6 วินาทีเพื่อสร้างโฟลว์ Power Automate

การใช้โฟลว์ Power Automate มากเกินไปอาจทำให้เกิดขีดจำกัดในการดำเนินการและการควบคุมปริมาณ ดังนั้นควรประเมินข้อดีข้อเสียระหว่างเวลาแฝงของเครือข่ายและต้นทุนด้านประสิทธิภาพเสมอ

ขจัดปัญหา N+1

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

การเรียกง่ายๆ เช่นนี้เพื่อโหลดคอลเลกชันสามารถสร้างการเรียก N+1 ไปที่แหล่งข้อมูล

ClearCollect(MyCollection, OrdersList,
    {
        LookUp(CustomersList,CustomerID = OrdersList[@CustomerID])
    }
)

ในบริบทของแอปพื้นที่ทำงานและแกลเลอรี ปัญหา N+1 อาจเกิดขึ้นเมื่อทำงานกับแหล่งข้อมูลและแกลเลอรีที่แสดงเรกคอร์ดที่เกี่ยวข้อง โดยทั่วไป ปัญหาจะเกิดขึ้นเมื่อมีการสืบค้นเพิ่มเติมสำหรับแต่ละรายการที่แสดงในแกลเลอรี ซึ่งนำไปสู่ปัญหาคอขวดด้านประสิทธิภาพ

ใช้ออบเจ็กต์มุมมองใน SQL Server เพื่อหลีกเลี่ยงปัญหาการสืบค้น N+1 หรือเปลี่ยนส่วนติดต่อผู้ใช้เพื่อหลีกเลี่ยงการทริกเกอร์สถานการณ์ N+1

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

ThisItem.Account.'Account Name'

หาก RelatedDataSource มีขนาดเล็ก (<500 เรกคอร์ด) คุณสามารถแคชไว้ในคอลเลกชันและใช้คอลเลกชันดังกล่าวเพื่อขับเคลื่อนสถานการณ์การสืบค้น (N+1)

การจำกัดขนาดแพคเกจ

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

• ประเมินสื่อที่ฝังอยู่ในแอปของคุณ หากไม่ได้ใช้สิ่งใด ให้ลบออก

• รูปภาพที่ฝังอาจมีขนาดใหญ่เกินไป แทนที่จะใช้ไฟล์ PNG ให้ดูว่าคุณสามารถใช้รูปภาพ SVG ได้หรือไม่ อย่างไรก็ตาม โปรดใช้ความระมัดระวังเกี่ยวกับการใช้ข้อความในภาพ SVG เนื่องจากจะต้องติดตั้งแบบอักษรที่ใช้บนไคลเอ็นต์ วิธีแก้ปัญหาที่ดีเมื่อคุณต้องการแสดงข้อความคือการวางป้ายชื่อข้อความไว้เหนือรูปภาพ

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

• หากคุณมีหน้าจอที่ไม่ได้ใช้ ให้ลบออก ระวังอย่าลบหน้าจอที่ซ่อนอยู่ ซึ่งมีเพียงผู้สร้างแอปหรือผู้ดูแลระบบเท่านั้นที่ใช้

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

เพิ่มประสิทธิภาพ ForAll

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

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

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

ClearCollect(FollowUpMeetingAttendees.ForAll(ForAll(Distinct(AttendeesList.EmailAddress.Address).Lookup(Attendees))))

การอัปเดตเป็นชุดงานไปยังฐานข้อมูล

ForAll + Patch สามารถเป็นวิธีหนึ่งในการอัปเดตฐานข้อมูลเป็นชุดงาน อย่างไรก็ตาม ควรระมัดระวังในการใช้ลำดับของ For All และ Patch

ฟังก์ชันต่อไปนี้:

Patch(SampleFoodSalesData, ForAll(colSampleFoodSales,
    {
        demoName:"fromCanvas2"
    })
);

ทำงานได้ดีกว่า:

ForAll(colSampleFoodSales, Patch(SampleFoodSalesData,
    {
        demoName:"test"
    })
);

ขั้นตอนถัดไป

แนวทางการจัดการข้อผิดพลาด