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.

Quando le app canvas diventano più complesse, è possibile che si verifichino problemi con il recupero dei dati, la complessità delle formule e la velocità di rendering. Bilanciare funzionalità avanzate e un'interfaccia utente reattiva significa che è necessario un approccio sistematico all'ottimizzazione del codice.

Ottimizzazione delle formule di Power Fx

Funzione With

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. L'uso di With è preferito al contesto o alle variabili globali in quanto è autonomo, facile da capire e può essere utilizzato in qualsiasi contesto di formula dichiarativa. Altre informazioni sulla funzione With.

Funzione Concurrent

La funzione Concurrent consente di valutare più formule specificate all'interno della stessa proprietà contemporaneamente se hanno chiamate connettore 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 aspettano meno 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 vengono avviate contemporaneamente, l'app dovrà attendere 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.

Ad esempio:

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

Richiede che il valore 1 e il valore 2 vengano valutati due volte. 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 proprietà OnStart per le app cavas svolge un ruolo cruciale nella definizione delle 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 e utilizzare efficacemente la proprietà OnStart è essenziale per creare app canvas reattive ed efficienti.

Un approccio consigliato è quello di semplificare la funzione App.OnStart migrando le impostazioni delle variabili in formule denominate. Le formule con nome, soprattutto quelle configurate nelle prime fasi del ciclo di vita dell'app, si rivelano vantaggiose. Queste formule gestiscono l'inizializzazione delle variabili in base alle chiamate dati, fornendo una struttura più pulita e organizzata per il codice. Più dettagli Crea app canvas grandi e complesse: Power Apps | Microsoft Learn.

Nota

La proprietà OnStart è imperativa. Si tratta di un elenco ordinato di attività che devono essere eseguite prima che venga visualizzata la prima schermata. Perché è così specifico non solo cosadeve essere fatto, ma anche quando il lavoro debba essere svolto in base all'ordine, limita il riordino e il differimento delle ottimizzazioni che potrebbero altrimenti essere eseguite.

Schermata Start

Se App.OnStart contiene una chiamata della funzione Navigate, anche se è in una funzione If e chiamata raramente, dobbiamo completare l'esecuzione dell'app. OnStart prima di mostrare la prima schermata dell'app.  App.StartScreen è il nuovo modo dichiarativo per indicare quale schermata deve essere mostrata per prima, che non blocca le ottimizzazioni.

L'impostazione della proprietà StartScreen mostra la prima schermata prima che App.OnStart venga completata. App.StartScreen declares quale oggetto sullo schermo mostrare per primo senza richiedere alcuna preelaborazione.

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)

Fai riferimento a <https://Power Apps.microsoft.com/en-us/blog/app-startscreen-a-new-declarative-alternative-to-navigate-in-app-onstart/> per ulteriori dettagli.

Avviso

Evitare le dipendenze tra StartScreen e OnStart. Se si fa riferimento a una formula con nome che a sua volta fa riferimento a una variabile globale, è possibile che si verifichi una race condition in cui StartScreen potrebbe non essere applicato correttamente. Nota: non dovrebbero esistere dipendenze tra StartScreen e OnStart. Blocchiamo il riferimento alle variabili globali in StartScreen, ma possiamo fare riferimento a una formula denominata, che a sua volta fa riferimento a una variabile globale e che potrebbe causare una race condition in cui StartScreen non viene applicato correttamente.

Formule con nome

Le formule denominate sono statiche o costanti e possono essere definite nella sezione App.Formulas. Una volta dichiarate in App.Formulas, possono essere utilizzate ovunque nell'app e il loro valore rimane sempre aggiornato. Le formule con nome in Power Apps abilita la definizione di valori o insiemi di valori che vengono gestiti e aggiornati automaticamente dalla piattaforma. Questa funzionalità trasferisce la responsabilità del calcolo del valore e della manutenzione dallo sviluppatore a Power Apps, semplificando il processo di sviluppo. Le formule con nome in Power Apps sono una funzionalità potente che può migliorare significativamente le prestazioni e la manutenibilità dell'app.

Le formule denominate possono anche risolvere la dichiarazione dei temi dell'app. In molti casi in cui vengono create app aziendali, vogliamo che l'app abbia temi comuni per offrire aspetto ed esperienza utente coerenti. Per creare un tema, ci sono decine e centinaia di variabili che devono essere dichiarate sull'app OnStart. Ciò ha aumentato la lunghezza del codice e il tempo di inizializzazione dell'app.

I controlli moderni possono anche aiutare in modo significativo con il tema e contribuire a ridurre la logica scritta dal cliente per gestire il tema. I controlli moderni sono attualmente in anteprima.

Ad esempio, il seguente codice in App.OnStart può essere spostato in App.Formulas, riducendo così il tempo di avvio sulle 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");

Il codice può essere spostato in App.Formulas come segue:

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 è l'impostazione inn Lookups. In questo caso, è richiesta una modifica in una formula di ricerca per ottenere le informazioni sull'utente da Office 365, anziché da Dataverse. C'è solo un posto in cui è richiesta la modifica 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 funzione Set, la variabile varListItems dovrà essere inizializzata con il conteggio iniziale delle righe nell'elenco dei campioni e impostata nuovamente dopo che gli elementi dell'elenco sono stati aggiunti o rimossi. Con le formule denominate, quando i dati cambiano, le variabili varListitems vengono aggiornate automaticamente.

Le formule con nome nella proprietà App.Formulas forniscono un approccio più flessibile e dichiarativo per la gestione di valori e calcoli in tutta l'app, offrendo vantaggi in termini di indipendenza temporale, aggiornamenti automatici, manutenibilità e definizioni immutabili rispetto al fare affidamento esclusivamente su App.OnStart.

Aspetto	Formule con nome (App.Formulas)	App.OnStart
Indipendenza tempi	Le formule sono disponibili immediatamente e possono essere calcolate in qualsiasi ordine.	Le variabili possono introdurre dipendenze temporali, influenzando la disponibilità.
Aggiornamenti automatici	Le formule si aggiornano automaticamente quando le dipendenze cambiano.	Le variabili vengono impostate una volta durante l'avvio; potrebbero essere necessari aggiornamenti manuali.
Manutenibilità	Le formule centralizzate in un'unica posizione migliorano la manutenibilità.	Le variabili sparse potrebbero richiedere la ricerca e l'aggiornamento in più punti.
Definizioni immutabili	Le definizioni delle formule in App.Formulas sono immutabili.	I valori variabili possono essere suscettibili di modifiche accidentali.

Funzioni definite dall'utente

Le funzioni definite dall'utente in Power Apps Authoring Studio consentono agli utenti di creare la propria funzione personalizzata.

Per utilizzare questa funzionalità, nelle impostazioni di anteprima attiva Funzioni definite dall'utente (FDU). La funzionalità di anteprima non deve essere usata nell'ambiente di produzione, motivo per cui è disabilitata per impostazione predefinita, ma diventerà presto disponibile a livello generale.

Definire una formula in App.Formulas come segue:

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

Il codice funziona in questo modo:

• FunctionName viene utilizzato per richiamare la funzione

• Parameter è il nome dell'input. Uno o più input sono consentiti

• DataType è un argomento passato alla funzione deve corrispondere a questo tipo di dati. I tipi di dati disponibili includono Booleano, Colore, Data, Data e ora, Dinamico, GUID, Collegamento ipertestuale, Testo e Ora

• OutputDataType è il tipo di dati in cui sarà l'output della funzione

• Formula è l'output della funzione

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

Utilizzare IfError per implementare la gestione degli errori all'interno della funzione definita.

Chiama la funzione definita dal controllo testo o dall'etichetta.

calcAreaOfCircle(Int(*TextInput1*.Text))

Nota

Questa è una funzionalità sperimentale ed è soggetta a modifiche. Alcuni tipi di dati, come record e filtri, non sono ancora supportati.

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. Anche se l'impatto potrebbe non essere grave, è buona norma mantenere il Power App pulito e organizzato per ottenere prestazioni migliori e uno sviluppo più semplice.

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 se utilizzate eccessivamente. 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()).

Considera queste linee guida quando lavori 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 seguente funzione di esempio restituisce l'intero set di dati.

ClearCollect(colDemoAccount, Accounts);

Confrontalo 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 tabulare dell'origine dati 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 file multimediali e le variabili inutilizzati potrebbero non avere un impatto significativo sulle prestazioni dell'app, è importante ripulire l'app rimuovendo eventuali file multimediali 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

Evita controlli di riferimenti incrociati

I controlli che fanno riferimento a controlli su altre schermate possono rallentare il caricamento e la navigazione delle app. In questo modo puoi forzare l'app a caricare immediatamente le altre schermate, anziché attendere che l'utente acceda a quella schermata. Per risolvere questo problema, usa variabili, raccolte e contesto di spostamento per condividere lo stato tra le schermate.

Verifica app in Power Apps Studio mostra i controlli a cui è stato fatto riferimento incrociato. Rivedi regolarmente Verifica app per risolvere questo problema.

Ecco un esempio di controlli con riferimenti incrociati. Nell'immagine seguente, viene fatto riferimento incrociato al controllo Gallery 1 nel controllo Screen 2, Label 2.

Se fai riferimento a un controllo dalla prima schermata dell'app nella seconda schermata, non c'è un calo delle prestazioni perché la prima schermata è già caricata. Questa può effettivamente essere una buona cosa perché l'app è dichiarativa invece di usare variabili.

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

Abilitare DelayOutput per i controlli di testo

L'impostazione DelayOutput, se impostata su true, registra l'input dell'utente con mezzo secondo di ritardo. Utile per ritardare le operazioni dispendiose finché l'utente non ha completato l'immissione di testo, ad esempio nel caso del filtro se l'input viene usato in altre formule.

Ad esempio, per una raccolta i cui elementi vengono filtrati in base a ciò che l'utente immette nel controllo TextInput:

• Con DelayOutput impostato su false, che è l'impostazione predefinita, la raccolta viene filtrata non appena viene digitato del testo. Se hai una raccolta con molti elementi, ricaricare subito la raccolta con le modifiche rallenta le prestazioni. Meglio aspettare un po'. Ciò è pratico quando si utilizza TextInput per una stringa di ricerca (vedi Ricercao le nuove funzioni StartsWith).

• Se DelayOutput è impostato su true, si verifica un breve ritardo prima che le modifiche vengano rilevate. Questo ti dà il tempo di finire di digitare. Il ritardo funziona bene con la proprietà TextInput.OnChange. Se sono presenti azioni legate alle modifiche, non vuoi che vengano attivate fino a quando non hai finito di digitare nel campo.

Delega ed elaborazione lato server

Delega

Il concetto di delega in Power Apps è un concetto che si riferisce alla capacità dell'app di scaricare determinate operazioni sull'origine dati sottostante anziché elaborare le operazioni all'interno Power Apps. Utilizzando la delega in Power Apps, gli sviluppatori possono creare applicazioni più efficienti e scalabili che funzionano bene anche in scenari che coinvolgono set di dati di grandi dimensioni. È importante essere consapevoli delle limitazioni della delega per origini dati e operazioni specifiche e progettare le app di conseguenza per ottenere prestazioni ottimali.

![NOTA] Non tutte le funzioni sono delegabili. Fai riferimento a Comprendere il concetto di delega per ulteriori informazioni sulla delega.

La delega presenta numerosi vantaggi come l'ottimizzazione delle query e aggiunge 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 join all'interno dell'app canvas. Ecco un esempio:

In questo esempio sono presenti due tabelle: Conducenti e Camion. 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 all'origine.

Elaborazione 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 modelli di dati di query

Usa selezione esplicita delle colonne

La funzionalità ECS (Explicit Column Selection) è attiva per impostazione predefinita per tutte le nuove app. Se non è attiva per la tua app, attivala. 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 è in grado di stabilire se sono utilizzate. Per forzare ECS a mantenere una colonna mancante, utilizza l'espressione ShowColumns di PowerFx dopo un riferimento alla raccolta o in un controllo.

Evita di chiamare Power Automate per popolare una raccolta

Una prassi comune è utilizzare Power Automate per recuperare e popolare raccolte Power Apps. Sebbene questo approccio sia valido, ci sono situazioni in cui potrebbe non essere la scelta più efficiente. La chiamata Power Automate implica un sovraccarico di latenza di rete e aggiunge un costo prestazionale di 0,6 secondi per creare istanze del flusso Power Automate.

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

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. Ciò può portare a problemi di prestazioni, poiché ogni query aggiuntiva comporta un sovraccarico.

Una semplice chiamata come questa per caricare una raccolta può generare N+1 chiamate all'origine dati.

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

Nel contesto delle app canvas e delle raccolte, il problema N+1 può sorgere quando si lavora con origini dati e gallerie che visualizzano record correlati. Il problema si verifica in genere quando vengono effettuate più query per ciascun elemento visualizzato nella raccolta, determinando un collo di bottiglia nelle prestazioni.

Utilizzare Visualizza oggetti in SQL Server per evitare problemi di query N+1 oppure modifica 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 di RelatedDataSource` sono piccole (<500 record), puoi memorizzarli nella cache di una raccolta e utilizzare la raccolta per gestire lo scenario di query di ricerca (N+1).

Limitare le dimensioni del pacchetto

Sebbene Power Apps fa molto per ottimizzare il caricamento delle app, puoi adottare misure per ridurre l'ingombro delle tue app. Un ingombro ridotto è particolarmente importante per gli utenti di dispositivi meno recenti o per gli utenti in luoghi in cui è presente una latenza più elevata o una larghezza di banda ridotta.

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

• Le immagini incorporate potrebbero essere troppo grandi. Invece dei file PNG, verifica se puoi utilizzare immagini SVG. Tuttavia, fai attenzione all'utilizzo del testo nelle immagini SVG, perché il carattere utilizzato dovrà essere installato sul client. Un'ottima soluzione quando è necessario mostrare il testo è sovrapporre un'etichetta di testo a un'immagine.

• Valuta se la risoluzione è appropriata per fattore di forma. 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 renderà inoltre più semplice per più persone lavorare sulle app contemporaneamente e limiterà il "raggio di esplosione" (quantità di test) quando le modifiche alle 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. Sebbene la funzione stessa sia versatile, l'uso improprio della funzione ForAll può rendere rapidamente la tua app meno performante.

La funzione ForAll è una funzione sequenziale singolare anziché una funzione simultanea. Pertanto esamina un solo record alla volta, ottiene il risultato, quindi continua con quello successivo finché non ha esaminato tutti i record nel suo ambito.

Evita l'annidamento ForAll a tutti i costi. Ciò può portare a iterazioni esponenziali e avere un impatto significativo sulle prestazioni.

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

Aggiornamenti in batch al database

ForAll + Patch può essere un approccio per aggiornare in batch il database. Tuttavia, fai attenzione nell'usare l'ordine di For All e Patch.

Funzione seguente:

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

Si comporta meglio di:

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

Passaggio successivo

Errore nella gestione delle linee guida