Ottimizzazione del codice

Man mano che le app canvas si evolvono per soddisfare diversi requisiti aziendali, la sfida di mantenere prestazioni ottimali diventa una considerazione fondamentale. Le complessità della gestione dei dati, della progettazione dell'interfaccia utente e delle funzionalità all'interno delle app canvas richiedono un approccio articolato all'ottimizzazione del codice.

Man mano che le app canvas diventano più complesse, gli sviluppatori incontrano sfide legate al recupero dei dati, alla complessità delle formule e alle velocità di rendering. La necessità di trovare un equilibrio tra funzionalità robuste e interfacce utente reattive sottolinea l'importanza di adottare 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 e/o eseguire azioni, ad esempio la modifica di dati o l'uso di una connessione. Usa With per migliorare la leggibilità di formule complesse suddividendole in formule secondarie denominate più piccole. Questi valori denominati agiscono come semplici variabili locali confinate 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 la valutazione di più colonne viene eseguita concatenandole con l'operatore ; (punto e virgola) che valuta ogni colonna in ordine sequenziale. Con la funzione Concurrent, l'app valuterà tutte le formule all'interno di una proprietà contemporaneamente anche dopo aver usato l'operatore ;. Questa concorrenza aiuterà gli utenti ad aspettare meno per lo stesso risultato. 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 blank 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 blank o stringhe vuote, la funzione restituisce blank, rendendo Coalesce un modo efficiente per convertire le stringhe vuote in valori blank.

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 che può contenere 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. Fai riferimento a una formula denominata che a sua volta fa riferimento a una variabile globale può causare una condizione di competizione in cui StartScreen non viene applicato correttamente. Nota: non dovremmo avere 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 condizione di competizione 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 sono una funzionalità sperimentale in Power Apps Authoring Studio che consente agli utenti di creare la propria funzione personalizzata.

Per utilizzare questa funzionalità, nelle impostazioni sperimentali, seleziona Nuovo motore di analisi e Funzione definita dall'utente (UDF)

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, Datetime, GUID, Collegamento ipertestuale, Testo, Ora, Oggetto non tipizzato

• 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 vengono utilizzate per definire e impostare valori locali e globali da utilizzare ovunque nelle app. Sebbene siano convenienti, troppe possono rendere l'app meno ottimizzata.

L'esempio seguente dimostra l'impostazione di una variabile per ogni attributo di un oggetto, 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ù ottimizzato consiste nell'utilizzare la proprietà 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 si espande oltre una singola schermata, valuta la possibilità di utilizzare variabili globali anziché variabili di contesto.

Troppe variabili inutilizzate contribuiscono a un maggiore utilizzo della memoria e a un'inizializzazione dell'app leggermente più lenta. Questo perché le risorse vengono allocate per queste variabili anche se non vengono utilizzate attivamente. Troppe variabili inutilizzate possono anche portare a una complessità complessiva della logica dell'app. Anche se l'impatto delle variabili inutilizzate potrebbe non essere grave, è buona norma mantenere una Power App pulita e ben organizzata per garantire prestazioni ottimali e facilità di sviluppo.

Ottimizzare le raccolte

Le raccolte sono strutture di archiviazione dati temporanee che possono essere utilizzate per archiviare e manipolare i dati all'interno di un'app Power Apps. Tuttavia, esiste una linea sottile su quando le raccolte possono portare a un sovraccarico delle prestazioni. Pertanto, limita l'uso delle raccolte. Prova a usarle solo se sono necessarie.

// 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 nell'app, vengono archiviate nella memoria del dispositivo mobile. Maggiore è il numero di dati contenuti nelle raccolte o maggiore è il numero di raccolte, peggiore sarà la prestazione. Utilizza la funzione ShowColumns per ottenere solo le 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);

Confronta con il codice seguente che restituirà solo record e colonne specifici:

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

Il codice di esempio restituisce questo set di dati:

Imposta una frequenza di aggiornamento per l'origine dati. Se stai aggiungendo nuovi record alla raccolta, devi aggiornarla o effettuare una raccolta per inserire i record nuovi o modificati nella raccolta. Se la tua origine dati viene aggiornato da più utenti, devi aggiornare 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, essenzialmente una variabile di tabella, è distinta in quanto memorizza righe e colonne di dati anziché un singolo elemento di dati. La loro utilità risiede in due scopi principali: in primo luogo, per aggregare i dati prima di trasmetterli all'origine dati e, in secondo luogo, per memorizzare nella cache le informazioni, eliminando la necessità di query frequenti all'origine dati. Poiché le raccolte si allineano con la struttura tabulare sia dell'origine dati che di Power Apps, offrono un mezzo efficiente per interagire con i dati, anche in scenari 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 media e le variabili inutilizzati potrebbero non avere un impatto drastico sulle prestazioni dell'app, è importante ripulire l'app da eventuali media o variabili inutilizzati.

• I file multimediali inutilizzati contribuiscono all'aumento complessivo delle dimensioni dell'app. Ciò può portare a tempi di caricamento dell'app più lenti.

• Le variabili inutilizzate contribuiscono a un maggiore utilizzo della memoria e a un'inizializzazione dell'app leggermente più lenta. Questo perché le risorse vengono allocate per queste variabili anche se non vengono utilizzate attivamente. Inoltre, troppe variabili inutilizzate possono anche portare a una complessità complessiva della 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. Questa operazione potrebbe forzare l'app a caricare altre schermate immediatamente, anziché attendere che l'utente passi alla schermata. Per risolvere questo problema, utilizza invece variabili, raccolte e contesto di navigazione per condividere lo stato tra le schermate.

Controllo app di Power Apps all'interno di Studio di creazione mostra i controlli con riferimenti incrociati. Esamina regolarmente il controllo dell'app per risolvere questo problema.

Ecco un esempio di controlli con riferimenti incrociati. Nell'immagine sotto i controlli della Raccolta 1 hanno riferimenti incrociati nella Schermata 2, controllo Etichetta 2.

Se fai riferimento a un controllo dalla prima schermata dell'app nella seconda schermata, non si verificherà alcun calo delle prestazioni poiché la prima schermata è già stata caricata e questo potrebbe effettivamente essere una buona cosa poiché l'app dichiarativa invece di utilizzare variabili.

Se fai riferimento a controlli che devono ancora essere caricati, ad esempio la prima schermata che fa riferimento a un controllo denominato Label 3 dalla schermata 3, richiederà il caricamento della schermata in memoria.

Abilitare DelayOutput per i controlli di testo

Impostazione DelayOutput: se impostata su true, l'input dell'utente viene registrato con mezzo secondo di ritardo. Utile per ritardare le operazioni dispendiose finché l'utente non ha completato l'input 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 viene immesso nel controllo TextInput:

• Con DelayOutput impostato su false, che è l'impostazione predefinita, la Galleria 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; sarebbe più vantaggioso aspettare un po'. Ciò è pratico quando si utilizza TextInput per una stringa di ricerca (vedi Ricercao le nuove funzioni StartsWith).

• Con DelayOutput impostato su true, c'è un secondo ritardo prima che le modifiche vengano rilevate. Questo viene fatto per darti il ​​tempo di finire di digitare ciò che desideri. Il ritardo funziona bene se utilizzato per supportare la proprietà TextInput.OnChange. Se hai azioni legate alle modifiche, non vuoi che vengano attivate finché tutto ciò che desideri non viene digitato 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ò essere conveniente seguire semplicemente le pratiche di codifica come la creazione di raccolte eseguendo unioni all'interno dell'app canvas. Fare riferimento alla coda di seguito:

In questo esempio sono presenti due tabelle, Conducenti e Camion. Lo sviluppatore scrive il codice per creare una raccolta di conducenti e dettagli del camion e per ogni camion, richiama i conducenti che possiedono i 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 tali operazioni di unione dall'app canvas può generare numerose chiamate all'origine dati con conseguenti tempi di caricamento molto 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 5 minuti a meno di 10 secondi semplicemente correggendo i dati al livello dell'origine dati.

Elaborazione lato server

Diverse origini dati come SQL e Dataverse consentono di delegare l'elaborazione dei dati come filtri e ricerche all'origine dati. In SQL Server gli utenti possono creare visualizzazioni con contenuto definito da una query. Allo stesso modo, con Dataverse, gli utenti possono creare plugin con poco codice per scrivere la logica per l'elaborazione dei dati sul lato server e ottenere i risultati finali solo nelle app canvas.

Delegare l'elaborazione dei dati al server può migliorare le prestazioni generali, ridurre il codice sul lato client ed è facile da mantenere.

Altre informazioni su plug-in in Dataverse.

Ottimizzare modelli di dati di query

Usa selezione esplicita delle colonne

La funzionalità Selezione esplicita delle colonne (ECS) è abilitata per impostazione predefinita per tutte le nuove app. Se non è abilitata per la tua app, dovresti abilitarla. ECS riduce automaticamente il numero di colonne recuperate solo a quelle utilizzate nell'applicazione. Se ECS non è abilitato, potresti recuperare più dati del necessario, il che può influire sulle prestazioni. Occasionalmente, quando un'app inserisce dati tramite raccolte, la derivazione originale o l'origine di una colonna può andare persa. Non sappiamo se viene utilizzata e la eliminiama utilizzando ECS. Di solito è possibile forzare ECS a funzionare per una colonna mancante utilizzando l'espressione PowerFx ShowColumns dopo un riferimento alla raccolta o utilizzandola 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"
    })
);

Ha prestazioni migliori rispetto a:

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

Passaggio successivo

Errore nella gestione delle linee guida