Ottimizzazione del codice

Man mano che le app canvas si evolvono per soddisfare le diverse esigenze aziendali, è fondamentale mantenere prestazioni ottimali. La gestione dei dati, la progettazione dell'interfaccia utente e le funzionalità dell'app richiedono un approccio attento all'ottimizzazione del codice.

Man mano che le app canvas diventano più complesse, è possibile verificarsi problemi con il recupero dei dati, la complessità delle formule e la velocità di rendering. Per bilanciare le funzionalità avanzate con un'interfaccia utente reattiva, usare un approccio sistematico all'ottimizzazione del codice.

Ottimizzazione della formula Power Fx

Questa sezione illustra le procedure consigliate per l'ottimizzazione delle formule di Power Fx.

Con la funzione

La funzione With valuta una formula per un singolo record. La formula può calcolare un valore o eseguire azioni, ad esempio la modifica di dati o l'uso di una connessione. Usa With per semplificare la leggibilità di formule complesse suddividendole in formule secondarie denominate più piccole. Questi valori denominati agiscono come semplici variabili locali limitate nell'ambito di With. With è migliore rispetto al contesto o alle variabili globali perché è indipendente, facile da comprendere e funziona in qualsiasi contesto di formula dichiarativa. Altre informazioni sulla funzione With.

Funzione Concorrente

La funzione Concurrent consente la valutazione di più formule nella stessa proprietà contemporaneamente se dispongono di chiamate ai connettori o Dataverse. In genere, più formule vengono valutate contemporaneamente quando le si concatena con l'operatore ; (punto e virgola). Con Concurrent, l'app valuta tutte le formule di una proprietà contemporaneamente, anche dopo aver usato l'operatore ;. Questa concorrenza significa che gli utenti attendono meno tempo per i risultati. Quando le chiamate di dati non vengono avviate prima del completamento delle chiamate precedenti, l'app deve attendere per il tempo totale di tutte le richieste. Se le chiamate di dati iniziano contemporaneamente, l'app attenderà solo il tempo della richiesta più lunga. Altre informazioni sulla funzione concurrent.

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

Funzione Coalesce

La funzione Coalesce valuta i rispettivi argomenti nell'ordine specificato e restituisce il primo valore non vuoto o una stringa vuota. Usa questa funzione per sostituire un valore blank o una stringa vuota con un valore diverso, senza modificare i valori non blank e le stringhe non vuote. Se tutti gli argomenti sono vuoti o stringhe vuote, la funzione restituisce vuoto. Coalesce è un buon modo per convertire le stringhe vuote in valori nulli. Altre informazioni sulla funzione Coalesce.

Questo esempio richiede value1 e value2 deve essere valutato due volte:

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

Questa funzione può essere ridotta a:

Coalesce(value1, value2)

Funzione IsMatch

La funzione IsMatch verifica se una stringa di testo corrisponde a un modello di caratteri ordinari, modelli predefiniti o un'espressione regolare. Altre informazioni sulla funzione IsMatch.

Ad esempio, questa formula corrisponde a un codice fiscale degli Stati Uniti:

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

Spiegazione dell'espressione regolare:

• \\d Corrisponde a qualsiasi cifra (0-9).

• {3} Specifica che il modello di cifra precedente (\d) dovrebbe verificarsi esattamente tre volte.

• - Corrisponde al carattere trattino.

• {2} Specifica che il modello di cifra precedente (\d) dovrebbe verificarsi esattamente due volte.

• {4} Specifica che il modello di cifra precedente (\d) dovrebbe verificarsi esattamente quattro volte.

Altri esempi di IsMatch:

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

Ottimizzazione dell'app OnStart

La OnStart proprietà per le app canvas svolge un ruolo fondamentale nella definizione di azioni che si verificano all'avvio dell'app. Questa proprietà consente agli sviluppatori di app di eseguire attività di inizializzazione globale, impostare variabili ed eseguire azioni che dovrebbero verificarsi una sola volta durante il processo di avvio dell'app. Comprendere ed usare efficacemente la OnStart proprietà per creare app canvas reattive ed efficienti.

Semplificare la funzione App.OnStart spostando le impostazioni delle variabili alle formule denominate. Le formule denominate, in particolare quelle configurate all'inizio del ciclo di vita dell'app, sono vantaggiose. Queste formule gestiscono l'inizializzazione delle variabili in base alle chiamate dati, fornendo una struttura più pulita e organizzata per il codice. Per altre informazioni, vedere Creare app canvas di grandi dimensioni e complesse.

Schermata Start

Se App.OnStart contiene una Navigate chiamata di funzione, anche se si trova in una If funzione e raramente chiamata, l'app deve completare l'esecuzione di App.OnStart prima di visualizzare la prima schermata dell'app.  App.StartScreen è un modo dichiarativo per indicare quale schermata deve essere visualizzata per prima e non blocca le ottimizzazioni.

L'impostazione della proprietà StartScreen mostra la prima schermata prima che App.OnStart venga completata. App.StartScreen dichiara l'oggetto schermo da visualizzare per primo senza richiedere alcuna pre-elaborazione.

Invece di scrivere codice come:

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

Cambiare il codice in:

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

Altre informazioni: App.StartScreen: un'alternativa dichiarativa a Navigate in App.OnStart.

Formule con nome

Le formule denominate sono costanti o statiche che possono essere definite in App.Formulas. Una volta dichiarato in App.Formulas, possono essere usati ovunque nell'app e i relativi valori rimangano sempre aggiornati. Le formule denominate in Power Apps consentono di definire valori o set di valori gestiti e aggiornati automaticamente dalla piattaforma. Questa funzionalità sposta la responsabilità del calcolo del valore e del backup dallo sviluppatore a Power Apps, semplificando il processo di sviluppo. Le formule denominate in Power Apps sono una funzionalità potente che può migliorare significativamente le prestazioni e la gestibilità delle app.

Le formule denominate consentono anche di dichiarare i temi dell'app. Quando crei app aziendali, spesso vuoi che l'app abbia temi comuni che offrono un aspetto coerente e un'esperienza utente. Per creare un tema, è necessario dichiarare decine a centinaia di variabili in App.OnStart. Questa dichiarazione aumenta la lunghezza del codice e il tempo di inizializzazione dell'app.

I controlli moderni possono anche aiutare in modo significativo con la tematizzazione e contribuire a ridurre la logica sviluppata dai clienti per gestire la tematizzazione. I controlli moderni sono attualmente in versione di anteprima.

Ad esempio, è possibile spostare il codice seguente in App.OnStartApp.Formulas, riducendo il tempo di avvio nelle dichiarazioni di variabili globali.

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

È possibile spostare il codice in App.Formulas come indicato di seguito:

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

Un altro esempio consiste nell'impostazione di Lookups. In questo caso, è necessaria una modifica in una Lookup formula per ottenere le informazioni utente da Office 365 invece di Dataverse. È sufficiente apportare la modifica in un'unica posizione, senza modificare il codice ovunque.

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

Queste formule incarnano l'essenza del calcolo. Articolano il processo per determinare UserEmail, UserInfo, UserTitle e UserPhone in base ad altri valori. Questa logica è incapsulata, consentendo un utilizzo diffuso in tutta l'app e può essere modificata in una singola posizione. L'adattabilità si estende al passaggio dalla tabella Utenti Dataverse al connettore Office 365 senza richiedere modifiche alle formule sparse nell'app.

Un altro approccio è ottimizzare countRows.

varListItems = CountRows(SampleList)

Con la Set funzione è necessario inizializzare la variabile varListItems con il conteggio iniziale delle righe nell'elenco di esempio e impostarla di nuovo dopo l'aggiunta o la rimozione degli elementi dell'elenco. Con le formule denominate, man mano che i dati cambiano, la varListItems variabile viene aggiornata automaticamente.

Le formule denominate nella App.Formulas proprietà offrono un approccio più flessibile e dichiarativo per la gestione di valori e calcoli in tutta l'app. Offrono vantaggi in termini di indipendenza temporale, aggiornamenti automatici, manutenibilità e definizioni non modificabili rispetto a basarsi esclusivamente su App.OnStart.

Funzioni definite dall'utente

Le funzioni definite dall'utente in Power Apps Studio consentono di creare funzioni personalizzate.

Definire una formula in App.Formulas come segue:

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

Il codice funziona nel modo seguente:

• FunctionName richiama la funzione .

• Parameter è il nome dell'input. È possibile includere uno o più input.

• DataType è il tipo di dati che l'argomento passato nella funzione deve corrispondere. I tipi di dati disponibili includono Boolean, Color, Date, Datetime, Dynamic, GUID, Hyperlink, Text e Time.

• OutputDataType è il tipo di dati per l'output della funzione.

• Formula è l'output della funzione.

Usare IfError per implementare la gestione degli errori all'interno della funzione definita:

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

Avvia la funzione definita da un controllo di testo o etichetta.

calcAreaOfCircle(Int(*TextInput1*.Text))

Ottimizzare le variabili

Le variabili definiscono e impostano i valori locali e globali utilizzati in tutta l'app. Sebbene siano convenienti, l'uso di troppe variabili può rendere l'app meno efficiente.

Nell'esempio seguente viene illustrato come impostare una variabile per ogni attributo di un oggetto, operazione che richiede l'utilizzo di Set per ogni proprietà.

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

Un approccio più efficiente consiste nell'usare la proprietà solo quando ne hai bisogno:

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

Utilizza saggiamente le variabili di contesto e le variabili globali. Se l'ambito di una variabile va oltre una singola schermata, usa le variabili globali anziché le variabili di contesto.

Troppe variabili inutilizzate aumentano l'utilizzo della memoria e possono rallentare l'inizializzazione dell'app. Le risorse vengono allocate per queste variabili anche se non vengono utilizzate. Anche le variabili inutilizzate aggiungono complessità alla logica dell'app. Mantenere pulita e organizzata l'app Power Per migliorare le prestazioni e semplificare lo sviluppo.

Ottimizzare le raccolte

Le raccolte sono strutture di archiviazione dati temporanee che usi per archiviare e manipolare i dati in un'app Power Apps . Tuttavia, le raccolte possono causare un sovraccarico delle prestazioni. Limitare l'uso delle raccolte e usarle solo quando necessario.

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

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

Per contare i record in una raccolta locale, utilizza CountIf invece di Count(Filter()).

Si consideri questo approccio quando si lavora con le raccolte:

• Limita le dimensioni e il numero delle raccolte. Poiché le raccolte sono locali per l'app, vengono archiviate nella memoria del dispositivo mobile. Maggiore è il numero di raccolte di dati conservate o più raccolte vengono utilizzate, peggiori sono le prestazioni. Usa la funzione ShowColumns per ottenere solo colonne specifiche. Aggiungi la funzione Filter per ottenere solo i dati rilevanti.

  La funzione di esempio seguente restituisce l'intero set di dati:

  ClearCollect(colDemoAccount, Accounts);
  

  Confrontare questa funzione con il codice seguente, che restituisce solo record e colonne specifici:

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

  Questo esempio restituisce il seguente set di dati:

  

• Imposta una frequenza di aggiornamento per l'origine dati. Se aggiungi nuovi record alla raccolta, aggiornala o raccoglila per ottenere i record nuovi o modificati. Se più utenti aggiornano la tua origine dati, aggiorna la raccolta per ottenere i record nuovi o modificati. Più chiamate di aggiornamento significano più interazione con il server.

Memorizza i dati nella cache in raccolte e variabili

Una raccolta è una variabile di tabella in cui sono archiviate righe e colonne di dati, non solo un singolo elemento di dati. Le raccolte sono utili per due motivi principali: aggregare i dati prima di inviarli all'origine dati e memorizzare le informazioni nella cache per evitare query frequenti. Poiché le raccolte corrispondono alla struttura tabellare sia dell'origine dati sia di Power Apps, ti consentono di interagire con i dati in modo efficiente, anche quando sei offline.

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

Rimuovere le variabili e i media non utilizzati

Anche se i supporti e le variabili inutilizzati potrebbero non influire in modo significativo sulle prestazioni dell'app, è importante pulire l'app rimuovendo eventuali supporti o variabili inutilizzati.

• I file multimediali inutilizzati aumentano le dimensioni dell'app, il che può rallentare i tempi di caricamento dell'app.

• Le variabili inutilizzate aumentano l'utilizzo della memoria e possono rallentare leggermente l'inizializzazione dell'app. Le risorse vengono allocate per queste variabili anche se non vengono utilizzate. Un numero eccessivo di variabili inutilizzate può anche rendere più complessa la logica dell'app.

• Utilizza Controllo app per esaminare i supporti di memorizzazione e le variabili non utilizzati.

Ottimizza schermate e controlli

Per ottimizzare le schermate e i controlli in Power Apps, prendere in considerazione le procedure consigliate seguenti.

Evita controlli di riferimenti incrociati

I controlli che fanno riferimento a controlli su altre schermate possono rallentare il caricamento e la navigazione delle app. Questo approccio può forzare l'app a caricare le altre schermate invece di attendere fino a quando l'utente non passa a tale schermata. Per risolvere questo problema, usare variabili, raccolte e contesto di spostamento per condividere lo stato tra le schermate.

Il verificatore di app in Power Apps Studio mostra i controlli che sono stati incrociati. Controlla regolarmente la funzione di verifica dell'app per risolvere questo problema.

Nell'immagine seguente il controllo Gallery 1 fa riferimento incrociato nel controllo Screen 2, Label 2.

Se si fa riferimento a un controllo dalla prima schermata dell'app nella seconda schermata, non ci sono impatti sulle prestazioni perché la prima schermata è già caricata. Questo comportamento è effettivamente utile perché l'app è dichiarativa anziché usare variabili.

Se fai riferimento a controlli non ancora caricati, ad esempio la prima schermata che fa riferimento a un controllo denominato Label 3 dalla schermata 3, l'app carica tale schermata in memoria.

Abilitare DelayOutput per i controlli di testo

L'impostazione DelayOutput , se impostata su true, registra l'input dell'utente dopo un ritardo di mezzo secondo. Questo ritardo è utile per rinviare operazioni costose fino a quando l'utente non termina l'immissione di testo, ad esempio il filtro quando viene usato l'input in altre formule.

Si consideri, ad esempio, una raccolta i cui elementi vengono filtrati a seconda di ciò che l'utente immette nel controllo TextInput:

• Se si imposta DelayOutput su false, ovvero l'impostazione predefinita, la raccolta filtra non appena viene digitato testo. Se si dispone di una raccolta con molti elementi, ricaricare la raccolta con le modifiche subito rallenta le prestazioni. È meglio aspettare. Questo comportamento è pratico quando si usa TextInput per una stringa di ricerca o per la StartsWith funzione .

• Se si imposta DelayOutput su true, si verifica un breve ritardo prima che vengano rilevate le modifiche. Questo ritardo consente di completare la digitazione. Il ritardo funziona bene con la proprietà TextInput.OnChange. Se si dispone di azioni associate alle modifiche, non si desidera che vengano attivate fino a quando non si termina la digitazione nel campo.

Delegazione ed elaborazione lato server

L'uso della delega e dell'elaborazione lato server consente all'app di gestire in modo efficiente set di dati di grandi dimensioni eseguendo l'offload delle operazioni nell'origine dati.

Delega

La delega in Power Apps si riferisce alla capacità dell'app di delegare determinate operazioni all'origine dati sottostante, invece di elaborare le operazioni all'interno di Power Apps stesse. Usando la delega in Power Apps, è possibile creare applicazioni più efficienti e scalabili che funzionano correttamente anche in scenari che coinvolgono set di dati di grandi dimensioni. Tenere presente le limitazioni di delega per origini dati e operazioni specifiche e progettare l'app di conseguenza per ottenere prestazioni ottimali.

La delega presenta diversi vantaggi, ad esempio l'ottimizzazione delle query e il supporto per set di dati di grandi dimensioni. Inoltre, se i dati dell'origine cambiano frequentemente, la delega aiuta a mantenere aggiornati i dati.

Riduci le chiamate API all'origine dati

A volte, può sembrare conveniente creare raccolte eseguendo operazioni di join all'interno dell'app Canvas. Si consideri l'esempio seguente. Nell'esempio sono presenti due tabelle: Driver e Truck. Il codice crea una raccolta di driver e dettagli del camion e, per ogni camion, chiama l'autista proprietario del camion.

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

L'esecuzione di tale join nell'app canvas può generare molte chiamate all'origine dati, il che porta a tempi di caricamento lenti.

Un approccio migliore è:

// 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'
    )
)

Nello scenario in tempo reale è possibile ridurre i tempi di caricamento da cinque minuti a meno di 10 secondi correggendo i dati nell'origine.

Elaborazione sul lato server

Origini dati diverse, ad esempio SQL e Dataverse, consentono di delegare l'elaborazione dei dati, ad esempio filtri e ricerche, all'origine dati. In SQL Server è possibile creare viste definite da una query. In Dataverse, puoi creare plug-in con poco codice per elaborare i dati sul server e restituire solo i risultati finali alla tua app canvas.

Delegare l'elaborazione dei dati al server può migliorare le prestazioni, ridurre il codice lato client e semplificare la manutenzione dell'app.

Altre informazioni su plug-in in Dataverse.

Ottimizzare i modelli di dati delle query

L'ottimizzazione del modo in cui l'app esegue query su dati può ridurre significativamente i tempi di caricamento e migliorare la velocità di risposta complessiva.

Usa selezione esplicita delle colonne

La funzionalità ECS (Explicit Column Selection) è attiva per impostazione predefinita per tutte le nuove app. Se non è attivo per la tua app, attivalo. ECS riduce automaticamente il numero di colonne recuperate alle sole colonne utilizzate nell'app. Se ECS non è attivo, potresti ottenere più dati del necessario, il che può influire sulle prestazioni. A volte, quando un'app recupera i dati tramite raccolte, l'origine originale di una colonna può andare persa. ECS elimina le colonne se non riesce a determinare se vengono utilizzate. Per obbligare ECS a mantenere una colonna mancante, utilizzare l'espressione Power Fx ShowColumns dopo un riferimento a una collezione o in un controllo.

Evita di chiamare Power Automate per popolare una raccolta

Una prassi comune è utilizzare Power Automate per recuperare e popolare raccolte in Power Apps. Sebbene questo approccio sia valido, ci sono situazioni in cui potrebbe non essere la scelta più efficiente. La chiamata a Power Automate comporta una latenza di rete e un impatto sulle prestazioni di 0,6 secondi per l'instanziazione del flusso di Power Automate.

L'uso eccessivo dei flussi Power Automate può anche portare a limiti di esecuzione e limitazione delle prestazioni. Valutare sempre i compromessi tra latenza di rete e i costi delle prestazioni.

Elimina il problema N+1

Il problema N+1 è un problema comune nelle query del database in cui, invece di recuperare tutti i dati richiesti in un'unica query, vengono eseguite più query aggiuntive per recuperare i dati correlati. Questo problema può causare problemi di prestazioni, perché ogni query aggiuntiva comporta un sovraccarico.

Una semplice chiamata simile alla seguente per caricare una raccolta può generare chiamate N+1 all'origine dati:

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

Nel contesto delle app Canvas e delle raccolte, il problema N+1 può verificarsi quando si utilizzano origini dati e raccolte che visualizzano record correlati. Il problema si verifica in genere quando vengono effettuate più query per ciascun elemento visualizzato nella galleria, determinando un collo di bottiglia delle prestazioni.

Utilizzare oggetti View in SQL Server per evitare il problema di query N+1 oppure modificare l'interfaccia utente per evitare di attivare lo scenario N+1.

Dataverse recupera automaticamente i dati richiesti dalle tabelle correlate ed è possibile selezionare le colonne dalle tabelle correlate.

ThisItem.Account.'Account Name'

Se le dimensioni sono ridotte (meno di 500 record), memorizzarle nella cache all'interno di una raccolta e usare la raccolta per gestire lo scenario di query Lookup (N+1).

Limitare le dimensioni del pacchetto

Anche se Power Apps ottimizza il caricamento delle app, è possibile adottare misure per ridurre il footprint delle app. Un footprint ridotto è particolarmente importante per gli utenti di dispositivi meno recenti o gli utenti in aree geografiche dove c'è una latenza più elevata o una banda ridotta.

• Valuta i contenuti multimediali incorporati nella tua app. Se qualcosa non viene utilizzato, eliminalo.

  Ad esempio, le immagini incorporate potrebbero essere troppo grandi. Invece dei file PNG, verifica se puoi utilizzare immagini SVG. Prestare attenzione all'uso del testo nelle immagini SVG perché il tipo di carattere deve essere installato nel client. Una soluzione alternativa quando è necessario visualizzare il testo consiste nell'sovrapporre un'etichetta di testo su un'immagine.

• Valuta se la risoluzione è appropriata per il formato. Non è necessario che la risoluzione di un'app mobile sia elevata quanto quella di un'app desktop. Sperimenta per ottenere il giusto equilibrio tra qualità e dimensioni dell'immagine.

• Se hai schermate inutilizzate, eliminale. Fai attenzione a non eliminare le schermate nascoste utilizzate solo dai creatori di app o dagli amministratori.

• Valuta se stai cercando di inserire troppi flussi di lavoro in un'unica app. Ad esempio, hai sia schermate di amministrazione che schermate client nella stessa app? In tal caso, valuta la possibilità di suddividerli in singole app. Questo approccio rende inoltre più semplice per più persone lavorare contemporaneamente sulle app e limita il "raggio di esplosione" (quantità di test) quando le modifiche dell'app richiedono un superamento completo del test.

Ottimizza ForAll

La funzione ForAll in Power Apps viene utilizzata per interagire con una tabella di record e applicare una formula o un insieme di formule a ciascun record. Anche se la funzione stessa è versatile, l'uso improprio della ForAll funzione può rendere l'app meno efficiente.

La ForAll funzione è una funzione sequenziale singolare anziché una funzione simultanea. Pertanto, esamina un solo record alla volta, ottiene il risultato e quindi continua fino al record successivo fino a quando non passa attraverso tutti i record nel relativo ambito.

Evitare di annidare ForAll. Questa procedura può causare iterazioni esponenziali e influire in modo significativo sulle prestazioni.

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

Aggiornare il database in batch

È possibile usare ForAll e Patch per aggiornare in batch il database. Tuttavia, prestare attenzione quando si usa l'ordine di ForAll e Patch.

La funzione seguente è l'approccio migliore, ad esempio:

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

Mentre l'approccio seguente è meno efficiente:

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

Passaggio successivo