बड़े और जटिल कैनवास अनुप्रयोग बनाएँ

दस्तावेज़ीकरण के इस खंड के अधिकांश लेख ऐप्स के रनटाइम प्रदर्शन को कवर करते हैं जैसा कि उनका उपयोग करने वाले लोगों द्वारा अनुभव किया जाता है। इस लेख में ऐप के प्रदर्शन को उन लोगों द्वारा अनुभव किया गया है जो उन्हें बनाते हैं।

जैसे-जैसे ऐप्स बड़े और अधिक जटिल होते जाते हैं, Power Apps Studio बड़ी संख्या में नियंत्रण, सूत्र और डेटा स्रोतों को लोड और प्रबंधित करने की आवश्यकता होती है, सभी परस्पर निर्भरता के साथ जो तेजी से बढ़ते हैं। Power Apps Studio लोड होने में अधिक समय लग सकता है, और IntelliSense और कलर कोडिंग जैसी सुविधाएँ पिछड़ सकती हैं। उन अनुशंसाओं का उपयोग करें जो बड़े और जटिल ऐप्स के साथ बेहतर काम करने के लिए अनुसरण करती हैं। Power Apps Studio वे आपके ऐप्स के रनटाइम प्रदर्शन को बेहतर बनाने में भी मदद कर सकते हैं।

इस आलेख में दिए गए उदाहरण अस्पताल आपातकालीन प्रतिक्रिया नमूना समाधान का उपयोग करते हैं ।

App.OnStart के बजाय App.Formulas का उपयोग करें

युक्ति

आप नामित सूत्रों के विकल्प के रूप में फ़ंक्शन और कैनवास घटक कस्टम आउटपुट गुणों के साथ उपयोग कर सकते हैं.

दोनों Power Apps Studio और आपके ऐप के लिए लोडिंग समय को कम करने का सबसे अच्छा तरीका App.OnStart में चर और संग्रह आरंभीकरण को App.Formula में नामित सूत्रों से बदलना है।

आइए निम्नलिखित उदाहरण देखें, जो 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
    );
);

क्योंकि वे कथनों का अनुक्रम हैं, इसलिए आपके ऐप को पहली स्क्रीन प्रदर्शित करने से पहले इन सेट और कलेक्ट कॉल का मूल्यांकन करना होगा, जिससे ऐप अधिक धीमा हो जाता है। और क्योंकि संपूर्ण App.OnStart को संपूर्ण माना जाना चाहिए, अंतिम परिणाम देने से पहले एकत्रित आदेश, और त्रुटियां, विश्लेषण करने के लिए Power Apps Studio सूत्र जटिल है।

एक बेहतर तरीका है। इसके बजाय App.Formula का उपयोग करें और इन चरों और संग्रहों को नामित सूत्रों के रूप में परिभाषित करें, जैसा कि निम्न उदाहरण में है।

// 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 को छोटे टुकड़ों में विभाजित कर सकते हैं। हमने अकेले इस परिवर्तन के साथ लोड समय में 80% तक की गिरावट देखी Power Apps Studio है।

आपका ऐप भी तेजी से लोड होता है क्योंकि इसे परिणाम की आवश्यकता होने तक इन सूत्रों का मूल्यांकन करने की आवश्यकता नहीं होती है। ऐप की पहली स्क्रीन तुरंत प्रदर्शित होती है।

नामित सूत्रों का उपयोग सभी स्थितियों में नहीं किया जा सकता क्योंकि आप उन्हें संशोधित नहीं कर सकते हैं या सेट के साथ उनका उपयोग नहीं कर सकते हैं. कुछ स्थितियों में एक राज्य चर के उपयोग की आवश्यकता होती है जिसे संशोधित किया जा सकता है। सेट इन स्थितियों के लिए एकदम सही है और आपको इसका उपयोग जारी रखना चाहिए। लेकिन, अधिक बार नहीं, आप स्थिर मान सेट करने के लिए ऑनस्टार्ट में वैश्विक चर का उपयोग कर रहे हैं जो बदलते नहीं हैं। उन मामलों में, एक नामित सूत्र बेहतर विकल्प है।

चूंकि नामित सूत्र अपरिवर्तनीय हैं, इसलिए नामकरण सम्मेलन के रूप में उपसर्ग var ("चर" के लिए छोटा) अब उपयुक्त नहीं है। हमने इस उदाहरण में नाम नहीं बदले क्योंकि इससे मिलान करने के लिए शेष ऐप में परिवर्तन की आवश्यकता होगी।

App.OnStart में एक नामित सूत्र रखना आकर्षक है, लेकिन नहीं। वे वहां के नहीं हैं। व्यवहार संपत्ति पर, App.OnStart अपने प्रत्येक कथन का मूल्यांकन क्रम में करता है, वैश्विक चर बनाता है, और केवल एक बार डेटाबेस से बात करता है, जब ऐप लोड होता है। नामित सूत्र वे सूत्र हैं जो परिभाषित करते हैं कि जब भी आवश्यकता हो तो किसी चीज़ की गणना कैसे करें और हमेशा सत्य होते हैं। यह सूत्र प्रकृति है जो उन्हें स्वतंत्र होने की अनुमति देती है और ऐप को मूल्यांकन करने से पहले लोडिंग समाप्त करने की अनुमति देती है।

लंबे सूत्रों को विभाजित करें

App.OnStart लंबे फ़ार्मुलों के लिए सबसे खराब अपराधियों में से एक है और निश्चित रूप से आपको कहाँ से शुरू करना चाहिए, लेकिन यह एकमात्र मामला नहीं है।

हमारे अध्ययनों से पता चला है कि लंबे लोड समय वाले Power Apps Studio लगभग सभी ऐप्स में 256,000 से अधिक वर्णों का कम से कम एक सूत्र है। सबसे लंबे लोड समय वाले कुछ ऐप्स में 1 मिलियन से अधिक वर्णों के सूत्र होते हैं। सूत्र जो लंबे समय तक एक महत्वपूर्ण दबाव डालते हैं Power Apps Studio।

मामलों को बदतर बनाने के लिए, किसी लंबे सूत्र के साथ नियंत्रण की प्रतिलिपि बनाना और चिपकाना नियंत्रण के गुणों में सूत्र को बिना साकार किए डुप्लिकेट करता है. Power Apps Excel के बाद मॉडलिंग की जाती है, जहाँ किसी सूत्र की एकाधिक प्रतिलिपियाँ सामान्य होती हैं. हालाँकि, Excel में सूत्र एक व्यंजक तक सीमित होते हैं और 8,000 वर्णों पर कैप किए जाते हैं. Power Apps सूत्र अनिवार्य तर्क और चेनिंग ऑपरेटर (; या ;;, लोकेल के आधार पर) की शुरूआत के साथ बहुत लंबे समय तक बढ़ सकते हैं।

सामान्य समाधान लंबे फ़ार्मुलों को छोटे भागों में विभाजित करना और भागों का पुन: उपयोग करना है, जैसा कि हमने पिछले अनुभाग में किया था जब हमने App.OnStart में Set Collect स्टेटमेंट को App.Formula में नामित सूत्रों में बदल दिया/था। · · अन्य प्रोग्रामिंग भाषाओं में, पुन: प्रयोज्य भागों को अक्सर सबरूटीन या उपयोगकर्ता-परिभाषित कार्यों के रूप में संदर्भित किया जाता है। आप नामित सूत्रों को उपयोगकर्ता-परिभाषित फ़ंक्शन के एक सरल रूप के रूप में सोच सकते हैं जिसमें कोई पैरामीटर या साइड-इफेक्ट नहीं है।

हर जगह नामित सूत्रों का उपयोग करें

पिछले उदाहरण में, हमने App.OnStart के प्रतिस्थापन के रूप में नामित सूत्रों का उपयोग किया था। हालाँकि, आप उनका उपयोग किसी ऐप में कहीं भी गणना को बदलने के लिए कर सकते हैं।

उदाहरण के लिए, अस्पताल आपातकालीन प्रतिक्रिया नमूना समाधान में स्क्रीन में से एक में 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 को पहले एक नामित सूत्र के रूप में निकाला था जब हमने App.OnStart से App.Formula में नामित सूत्रों में अधिकांश सेट कॉल स्थानांतरित किए थे ।

नामित सूत्रों का मूल्यांकन केवल तभी किया जाता है जब उनके मानों की आवश्यकता होती है. यदि Screen.OnVisible का उपयोग करने का मूल उद्देश्य स्क्रीन दिखाए जाने तक काम को स्थगित करना था, तो कार्य अभी भी App.Formulas में वैश्विक नामित सूत्रों के रूप में स्थगित है।

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

इस तरह से उपयोग करने का एक नकारात्मक पक्ष यह है कि इसका उपयोग MyFacility नहीं किया जा सकता है MyRegion क्योंकि वे फ़ंक्शन के साथ एक ही में परिभाषित हैं, एक समस्या जो नामित सूत्रों के साथ मौजूद नहीं है। एक समाधान कार्यों के साथ घोंसला बनाना है और सभी विथ चर तक आसान पहुंच देने के लिए प्रत्येक के लिए रिकॉर्ड को नाम देने के लिए कीवर्ड के रूप में उपयोग करना है।

कैनवास घटकों का उपयोग करें

कैनवास घटकों का उपयोग अक्सर UI नियंत्रण बनाने के लिए किया जाता है जिसे नियंत्रण की तरह कैनवास पर रखा जा सकता है। आप नामित सूत्रों के विकल्प के रूप में कस्टम आउटपुट गुणों के साथ गणना करने के लिए उन्हें UI में रखे बिना भी उनका उपयोग कर सकते हैं। कैनवास घटकों को घटक लाइब्रेरी वाले अनुप्रयोगों में साझा करना आसान होता है और नामित सूत्रों के विपरीत, वे पूरी तरह से समर्थित होते हैं. हालाँकि, वे नामित सूत्रों की तुलना में कॉन्फ़िगर और उपयोग करने में कठिन हैं।

तर्क को विभाजित करने के लिए:

1. में Power Apps Studio, ट्री दृश्य में घटक टैब पर स्विच करें।
2. एक नया घटक बनाएँ.
3. गुण फलक में, Access अनुप्रयोग क्षेत्र चालू करें.
4. कस्टम प्रॉपर्टी जोड़ें.
5. गुण प्रकार को आउटपुट और डेटा प्रकार को उपयुक्त के रूप में सेट करें । · ·
6. बनाएँ चुनें.
7. स्क्रीन के शीर्ष पर सूत्र पट्टी के आगे गुण पिकर में, नए गुण का चयन करें.
8. तर्क को विभाजित करने और पुन: उपयोग करने के लिए सूत्र लिखें।

तर्क का उपयोग करने के लिए:

1. ट्री दृश्य में स्क्रीन टैब पर स्विच करें।
2. सम्मिलित करें फलक में, कस्टम विस्तृत करें और अपना घटक सम्मिलित करें.
3. गुण के साथ मान की गणना करने के लिए, ComponentName.PropertyName का उपयोग करें.

अनिवार्य तर्क के लिए छुपे हुए नियंत्रण के साथ चयन करें का उपयोग करें

Imperative logic का उपयोग Set and Collect के साथ स्थिति को संशोधित करने के लिए किया जाता है, उपयोगकर्ता को Notify के साथ सूचित करें , नेविगेट करें और लॉन्च के साथ किसी अन्य स्क्रीन या ऐप पर नेविगेट करें, और 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 );

यह तकनीक केवल एक ही स्क्रीन पर काम करती है। अन्य तकनीकें जो थोड़ी अधिक जटिल हैं, वे सभी स्क्रीन पर काम करती हैं, जैसे टॉगल नियंत्रण का उपयोग करना, ऑनचेक को उस तर्क पर सेट करना जिसे आप चलाना चाहते हैं, और डिफ़ॉल्ट को एक वैश्विक चर पर सेट करना और फिर Set( global, true ); Set( global, false ) उस बिंदु पर वैश्विक चर को टॉगल करना जिसे आप तर्क चलाना चाहते हैं।

इस उदाहरण में, कुछ तर्क विभाजन पहले ही किया जा चुका था। टिप्पणी में उल्लेख किया गया है कि "आगामी क्रियाएं OnSuccess में पाई जा सकती हैं।" यह इवेंट रिकॉर्ड सफलतापूर्वक सबमिट होने के बाद अनिवार्य तर्क चलाता है, जो SubmitForm फ़ंक्शन के लिए विशिष्ट समाधान है।

ऐप का विभाजन करें

कुछ ऐप्स हज़ारों नियंत्रणों और सैकड़ों डेटा स्रोतों तक बढ़ जाते हैं, जिससे काम धीमा हो जाता है। Power Apps Studio लंबे सूत्रों की तरह, बड़े ऐप्स को छोटे-छोटे खंडों में विभाजित किया जा सकता है जो एक साथ मिलकर एक उपयोगकर्ता अनुभव बनाते हैं।

अलग कैनवास ऐप्स

एक दृष्टिकोण अलग-अलग कैनवास ऐप्स में अनुभागों को लागू करना और अलग-अलग ऐप्स के बीच नेविगेट करने और आवश्यक संदर्भ पास करने के लिए Launch फ़ंक्शन का उपयोग करना है.

इस दृष्टिकोण का उपयोग अस्पताल आपातकालीन प्रतिक्रिया नमूना समाधान में किया गया था। ... अलग-अलग ऐप्स समग्र ऐप के प्रत्येक प्रमुख क्षेत्र का प्रबंधन करते हैं। ऐप्स एक घटक लाइब्रेरी के माध्यम से एक सामान्य स्विचबोर्ड घटक साझा करते हैं, जिसे प्रत्येक ऐप अपनी स्टार्टअप स्क्रीन पर दिखाता है:

जब उपयोगकर्ता कोई क्षेत्र चुनता है, तो घटक उपलब्ध ऐप्स के बारे में मेटाडेटा का उपयोग करता है और यह भी कि कौन सा ऐप घटक को होस्ट कर रहा है। यदि वांछित स्क्रीन इस ऐप में है (अर्थात, ThisItem.Screen रिक्त नहीं है), तो Navigate कॉल किया जाता है। लेकिन यदि वांछित स्क्रीन किसी भिन्न ऐप में है (अर्थात, ThisItem.PowerAppID रिक्त नहीं है), तो लक्ष्य के ऐप ID और FacilityID संदर्भ के साथ Launch फ़ंक्शन का उपयोग किया जाता है:

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 फ़ंक्शन के साथ पढ़ा जाता है।

कस्टम पेजों के साथ मॉडल-संचालित ऐप

अनुभागों को कस्टम पेज के रूप में भी क्रियान्वित किया जा सकता है। कस्टम पृष्ठ नेविगेशन के लिए मॉडल-संचालित ऐप कंटेनर के साथ एक मिनी कैनवास ऐप के रूप में कार्य करते हैं.

नोट

क्या आप हमें अपनी दस्तावेज़ीकरण भाषा वरीयताओं के बारे में बता सकते हैं? एक छोटा सर्वेक्षण पूरा करें. (कृपया ध्यान दें कि यह सर्वेक्षण अंग्रेज़ी में है)

सर्वेक्षण में लगभग सात मिनट लगेंगे. कोई भी व्यक्तिगत डेटा एकत्र नहीं किया जाता है (गोपनीयता कथन).