Oggetto App in Power Apps

Si applica a: App Canvas

Ottenere informazioni sull'app attualmente in esecuzione e controllare il comportamento dell'app.

Descrizione

Analogamente a un controllo, l'oggetto App ha proprietà che identificano la schermata visualizzata e richiedono di salvare le modifiche in modo da non perderle. Ogni app ha un oggetto App.

Scrivere formule per alcune proprietà dell'oggetto App . Nella parte superiore del riquadro Visualizzazione ad albero, seleziona l'oggetto App come qualsiasi altro controllo o schermo. Per visualizzare o modificare una delle proprietà dell'oggetto, selezionarla nell'elenco a discesa a sinistra della barra della formula.

Questo articolo illustra le proprietà dell'oggetto App seguenti:

• ActiveScreen : schermata attualmente visualizzata.
• BackEnabled : modalità di risposta dell'app al movimento indietro del dispositivo.
• ConfirmExit e ConfirmExitMessage : avvisano l'utente prima di chiudere l'app.
• Stringa di connessione : configurare la registrazione di Application Insights.
• Formule: definire formule denominate, funzioni definite dall'utente e tipi definiti dall'utente.
• OnError : gestire gli errori a livello globale.
• OnStart : eseguire la logica all'avvio dell'app.
• StartScreen : impostare la schermata visualizzata per prima quando l'app viene caricata.
• StudioVersion: restituisce la versione di Power Apps Studio che ha pubblicato l'app.

Proprietà ActiveScreen

La proprietà ActiveScreen identifica la schermata attualmente visualizzata.

Questa proprietà restituisce un oggetto schermo. Usarlo per fare riferimento alle proprietà della schermata corrente, ad esempio il nome con la formula App.ActiveScreen.Name. È anche possibile confrontare questa proprietà con un altro oggetto schermo, ad esempio con la formula di confronto App.ActiveScreen = Screen2 per verificare se Screen2 è la schermata corrente.

Usare la funzione Back o Navigate per cambiare la schermata visualizzata.

Proprietà BackEnabled

La proprietà BackEnabled modifica il modo in cui l'app risponde al movimento indietro del dispositivo (scorrimento rapido o uso del pulsante Indietro hardware nei dispositivi Android o scorrimento rapido a sinistra nei dispositivi iOS) quando viene eseguito in Power Apps per dispositivi mobili. Se abilitata, il movimento indietro del dispositivo torna allo schermo visualizzato più di recente, simile alla formula Indietro . Se disabilitato, il movimento indietro del dispositivo porta l'utente all'elenco di app.

Proprietà ConfirmExit

Nessuno vuole perdere le modifiche non salvate. Usa le proprietà ConfirmExit e ConfirmExitMessage per avvisare l'utente prima di chiudere l'app.

ConfirmExit

ConfirmExit è una proprietà booleana che, se true, apre una finestra di dialogo di conferma prima della chiusura dell'app. Per impostazione predefinita, questa proprietà è false e non viene visualizzata alcuna finestra di dialogo.

Quando l'utente potrebbe avere modifiche non salvate nell'app, usa questa proprietà per visualizzare una finestra di dialogo di conferma prima di uscire dall'app. Utilizzare una formula che controlla le variabili e le proprietà del controllo, ad esempio la proprietà Unsaved del controllo Modulo di modifica .

La finestra di dialogo di conferma viene visualizzata in qualsiasi situazione in cui i dati possono essere persi, ad esempio:

• Eseguire la funzione Exit .
• Se l'app viene eseguita in un browser:
  • Chiudere il browser o la scheda del browser in cui viene eseguita l'app.
  • Selezionare il pulsante Indietro del browser.
  • Eseguire la funzione Launch con LaunchTarget of Self.
• Se l'app viene eseguita in Power Apps Mobile (iOS o Android):
  • Scorrere rapidamente per passare a un'app diversa in Power Apps Mobile.
  • Selezionare il pulsante Indietro in un dispositivo Android.
  • Eseguire la funzione Launch per avviare un'altra app canvas.

L'aspetto esatto della finestra di dialogo di conferma può variare tra dispositivi e versioni di Power Apps.

La finestra di dialogo di conferma non viene visualizzata in Power Apps Studio.

ConfirmExitMessage

Per impostazione predefinita, la finestra di dialogo di conferma mostra un messaggio generico, ad esempio "Potresti avere modifiche non salvate". nella lingua dell'utente.

Usa ConfirmExitMessage per fornire un messaggio personalizzato nella finestra di dialogo di conferma. Se questa proprietà è vuota, viene utilizzato il valore predefinito. I messaggi personalizzati vengono troncati in base alle esigenze per rientrare nella finestra di dialogo di conferma, quindi mantenere al massimo il messaggio a poche righe.

In un browser la finestra di dialogo di conferma può visualizzare un messaggio generico dal browser.

Esempio

1. Imposta la proprietà ConfirmExit dell'oggetto App su questa espressione:

   AccountForm.Unsaved Or ContactForm.Unsaved
   

   La finestra di dialogo viene visualizzata se l'utente modifica i dati in entrambi i moduli e quindi tenta di chiudere l'app senza salvare tali modifiche.

   

2. Imposta la proprietà ConfirmExitMessage dell'oggetto App su questa formula:

   If( AccountForm.Unsaved,
       "Accounts form has unsaved changes.",
       "Contacts form has unsaved changes."
   )
   

   La finestra di dialogo mostra un messaggio specifico del modulo quando l'utente modifica i dati in entrambi i moduli e quindi tenta di chiudere l'app senza salvare tali modifiche.

   

Proprietà della stringa di connessione

Usare la proprietà Stringa di connessione per esportare i log applicazioni generati dal sistema in Application Insights.

Per impostare il stringa di connessione:

1. Apri l'app per la modifica in Power Apps Studio.
2. Selezionare l'oggetto App nella visualizzazione ad albero del riquadro di spostamento.
3. Immettere la stringa di connessione nel riquadro delle proprietà.

Se i dati non vengono inviati ad Application Insights, contattare l'amministratore di Power Platform e verificare se Application Insights è disabilitato a livello di tenant.

Proprietà Formulas

Usare la proprietà Formule per definire la logica riutilizzabile nell'app. La proprietà Formulas supporta tre costrutti:

• Formule denominate : assegnare un nome a una formula e riutilizzare il valore in tutta l'app.
• Funzioni definite dall'utente : formule denominate che accettano parametri e restituiscono un valore.
• Tipi definiti dall'utente : tipi denominati che è possibile riutilizzare nelle formule e nelle firme di funzione.

Formule con nome

Usa formule denominate nella proprietà Formule per definire una formula che puoi riutilizzare in tutta l'app.

In Power Apps, le formule determinano il valore delle proprietà del controllo. Ad esempio, per impostare il colore di sfondo in modo coerente in un'app, impostare la proprietà Fill per ogni controllo su una formula comune:

Label1.Fill: ColorValue( Param( "BackgroundColor" ) )
Label2.Fill: ColorValue( Param( "BackgroundColor" ) )
Label3.Fill: ColorValue( Param( "BackgroundColor" ) )

Con così tante posizioni in cui viene visualizzata questa formula, diventa noioso ed è soggetto a errori ad aggiornarli tutti se è necessaria una modifica. Creare invece una variabile globale in OnStart per impostare il colore una sola volta e quindi riutilizzare il valore in tutta l'app:

App.OnStart: Set( BGColor, ColorValue( Param( "BackgroundColor" ) ) )
Label1.Fill: BGColor
Label2.Fill: BGColor
Label3.Fill: BGColor

Questo metodo è migliore, ma è necessario eseguire prima OnStart per poter impostare il valore di BGColor. BGColor potrebbe anche essere modificato da qualcun altro e se l'autore non è a conoscenza di tale modifica, può risultare difficile identificarla.

Le formule con nome forniscono un'alternativa. Proprio come in genere si scrive control-property = expression, è possibile scrivere invece name = expression e quindi riutilizzare il nome in tutta l'app per sostituire l'espressione. Definire queste formule nella proprietà Formule :

App.Formulas: BGColor = ColorValue( Param( "BackgroundColor" ) );
Label1.Fill: BGColor
Label2.Fill: BGColor
Label3.Fill: BGColor

I vantaggi derivanti dall'utilizzo di formule con nome sono:

• Il valore della formula è sempre disponibile. Non c'è dipendenza temporale, nessuna proprietà OnStart che deve essere eseguita prima affinché il valore venga impostato, nessun momento in cui il valore della formula non è corretto. Le formule con nome possono farsi riferimento a vicenda in qualsiasi ordine, purché non creino un riferimento circolare. Possono essere calcolate in parallelo.
• Il valore della formula è sempre aggiornato. La formula può eseguire un calcolo che dipende dalle proprietà di controllo o dai record del database e quando questi cambiano, il valore della formula si aggiorna automaticamente. Non devi aggiornare manualmente il valore come avviene con una variabile. Inoltre, le formule vengono ricalcolate solo quando necessario.
• La definizione della formula è immutabile. La definizione in Formulas è l'unica origine di riferimento e il valore non può essere modificato altrove nell'app. Con le variabili, il codice potrebbe modificare in modo imprevisto un valore, ma questa situazione difficile da eseguire con le formule denominate non è possibile.
• Il calcolo della formula può essere differito. Poiché il relativo valore è immutabile, può sempre essere calcolato al momento opportuno, il che significa che non serve calcolarlo finché non sarà necessario. I valori della formula che non vengono utilizzati fino a che non viene visualizzato screen2 di un'app, non devono essere calcolati fino a che screen2 non è visibile. Il rinvio può migliorare il tempo di caricamento dell'app. Le formule con nome sono dichiarative e offrono al sistema opportunità di ottimizzare come e quando vengono calcolate.
• Le formule con nome sono un concetto di Excel. Power Fx utilizza i concetti di Excel quando possibile poiché tante persone conoscono Excel. Le formule con nome sono l'equivalente delle celle con nome e delle formule con nome in Excel, gestite con Gestione nomi. Vengono ricalcolate automaticamente come celle di un foglio di calcolo e proprietà di controllo.

Definire formule denominate una dopo l'altra nella proprietà Formule , ognuna che termina con un punto e virgola. Il tipo della formula viene dedotto dai tipi degli elementi all'interno della formula e dal modo in cui vengono utilizzati insieme. Ad esempio, queste formule con nome recuperano informazioni utili sull'utente corrente da Dataverse:

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

Se la formula per UserTitle deve essere aggiornata, è possibile aggiornarla facilmente in questo percorso. Se UserPhone non è necessario nell'app, le chiamate alla tabella Utenti in Dataverse non vengono eseguite. Non è prevista alcuna penalità per l'inclusione di una definizione di formula che non viene utilizzata.

Alcune limitazioni delle formule con nome:

• Non possono utilizzare funzioni di comportamento in quanto possono causare effetti collaterali nell'app.
• Non possono creare un riferimento circolare. Avere a = b; e b = a; nella stessa app non è consentito.

Funzioni definite dall'utente

Power Fx include un lungo elenco di funzioni predefinite, ad esempio If, Testo e Imposta. Usando le funzioni definite dall'utente, è possibile scrivere funzioni personalizzate che accettano parametri e restituiscono un valore, proprio come le funzioni predefinite. Si considerino funzioni definite dall'utente come estensione per formule denominate che aggiungono parametri e supportano formule di comportamento.

Ad esempio, è possibile definire una formula con nome che restituisce libri di narrativa da una libreria:

Library = [ { Title: "The Hobbit", Author: "J. R. R. Tolkien", Genre: "Fiction" },
            { Title: "Oxford English Dictionary", Author: "Oxford University", Genre: "Reference" } ];

LibraryFiction = Filter( Library, Genre = "Fiction" );

Senza parametri, è necessario definire formule denominate separate per ogni genere. Ma in alternativa, parametrizzare la formula denominata:

LibraryType := Type( [ { Title: Text, Author: Text, Genre: Text } ] );

LibraryGenre( SelectedGenre: Text ): LibraryType = Filter( Library, Genre = SelectedGenre );

È ora possibile chiamare LibraryGenre( "Fiction" ), LibraryGenre( "Reference" )o filtrare in base ad altri generi usando una singola funzione definita dall'utente.

La sintassi è:

FunctionName( [ ParameterName1: ParameterType1 [ , ParameterName2: ParameterType2 ... ] ] ) : Formula ReturnType = ;

• FunctionName: obbligatorio. Nome della funzione definita dall'utente.
• ParameterNames – Facoltativo. Il nome di un parametro di funzione.
• ParameterType(s): facoltativo. Nome di un tipo, nome del tipo di dati predefinito, nome di origine dati o tipo definito tramite la funzione Type .
• ReturnType: obbligatorio. Il tipo del valore restituito dalla funzione.
• Formula – Obbligatorio. La formula che calcola il valore della funzione in base ai parametri.

È necessario digitare ogni parametro e l'output della funzione definita dall'utente. In questo esempio, SelectedGenre: Text definisce il primo parametro per la funzione di tipo Text e SelectedGenre è il nome del parametro utilizzato nel corpo dell'operazione Filter. Vedi Tipi di dati per i nomi dei tipi supportati. La funzione Type viene usata per creare un tipo di aggregazione per la libreria, in modo da poter restituire una tabella di libri dalla funzione .

Si definisce LibraryType come tabella plurale di tipi di record. Se si desidera passare un singolo libro a una funzione, è possibile estrarre il tipo di record per questa tabella usando la funzione RecordOf:

BookType := Type( RecordOf( LibraryType ) );

IsGenre( Book: BookType, SelectedGenre: Text ): Boolean = (Book.Genre = SelectedGenre);

La corrispondenza dei record per i parametri della funzione è più stretta rispetto ad altre parti di Power Fx. I campi di un valore di record devono essere un subset appropriato della definizione del tipo e non possono includere campi aggiuntivi. Ad esempio, IsGenre( { Title: "My Book", Published: 2001 }, "Fiction" ) restituisce un errore.

La ricorsione non è ancora supportata dalle funzioni definite dall'utente.

Comportamento delle funzioni definite dall'utente

Le formule con nome e la maggior parte delle funzioni definite dall'utente non supportano le funzioni di comportamento con effetti collaterali, ad esempio Set o Notify. In generale, evitare di aggiornare lo stato, se possibile. In alternativa, basarsi su modelli di programmazione funzionale e consentire a Power Fx di ricalcolare le formule in base alle esigenze automaticamente. Ma ci sono casi in cui è inevitabile. Per includere la logica del comportamento in una funzione definita dall'utente, racchiudi il corpo tra parentesi graffe:

Spend( Amount: Number ) : Void = {
    If( Amount > Savings, 
        Error( $"{Amount} is more than available savings" ),
        Set( Savings, Savings - Amount );
        Set( Spent, Spent + Amount) 
    );
}

A questo punto è possibile chiamare Spend( 12 ) per verificare se si dispone di 12 nel risparmio e, in tal caso, addebitarlo di 12 e aggiungere 12 alla variabile Spesa. Il tipo restituito di questa funzione è Void perché non restituisce un valore.

La sintassi di una funzione di comportamento definita dall'utente è:

NomeFunzione( [ NomeParametro1: TipoParametro1 [ , NomeParametro2: TipoParametro2 ... ] ] ) : RitornoTipo = { Formula1 [ ; Formula2 ... ] };

• FunctionName: obbligatorio. Nome della funzione definita dall'utente.
• ParameterNames – Facoltativo. Il nome di un parametro di funzione.
• ParameterType(s): facoltativo. Il nome di un tipo, un nome del tipo di dato predefinito, un nome di origine dati o un tipo definito con la funzione Type.
• ReturnType: obbligatorio. Il tipo del valore restituito dalla funzione. Usa Void se la funzione non restituisce un valore.
• Formule – Obbligatorio. La formula che calcola il valore della funzione in base ai parametri.

Come per tutte le formule Power Fx, l'esecuzione non termina quando viene rilevato un errore. Dopo aver chiamato la funzione Error, la funzione If impedisce le modifiche apportate a Risparmi e Spese. La funzione IfError può essere utilizzata anche per impedire l'ulteriore esecuzione dopo un errore. Anche se restituisce Void, la formula può comunque restituire un errore in caso di problemi.

Tipi definiti dall'utente

Usare formule denominate con la funzione Type per creare tipi definiti dall'utente. Utilizza := invece di = per definire un tipo definito dall'utente, ad esempio Book := Type( { Title: Text, Author: Text } ). Vedi la funzione Tipo per ulteriori informazioni ed esempi.

Proprietà OnError

Usa OnError per intervenire quando si verifica un errore in un punto qualsiasi dell'app. Offre un'opportunità globale per intercettare un banner di errore prima che venga visualizzato all'utente finale. È anche possibile usarlo per registrare un errore usando la funzione Trace o scrivere in un database o in un servizio Web.

Nelle app canvas, il risultato di ogni valutazione della formula viene controllato per verificare la presenza di un errore. Se viene rilevato un errore, OnError viene valutato con le stesse variabili di ambito FirstError e AllErrors usate dall'app se l'intera formula viene sottoposta a wrapping in una funzione IfError.

Se OnError è vuoto, viene visualizzato un banner di errore predefinito in FirstError.Message dell'errore. La definizione di una formula OnError esegue l'override di questo comportamento, in modo che l'autore possa gestire la segnalazione degli errori in base alle esigenze. È possibile richiedere il comportamento predefinito in OnError rigenerando l'errore usando la funzione Error. Usare l'approccio di rethrowing se si desidera escludere o gestire alcuni errori in modo diverso, ma consentire ad altri di passare attraverso.

OnError non può sostituire un errore nei calcoli come fa IfError. Se viene richiamato OnError , l'errore si è già verificato ed è già elaborato tramite calcoli di formule come IfError; OnError controlla solo la segnalazione errori.

Le formule OnError vengono valutate simultaneamente ed è possibile che la valutazione si sovrapponga all'elaborazione di altri errori. Ad esempio, se si imposta una variabile globale all'inizio di un OnError e la si legge più avanti nella stessa formula, il valore potrebbe essere stato modificato. Usa la funzione With per creare un valore denominato che sia locale nella formula.

Anche se OnError elabora ogni errore singolarmente, il banner di errore predefinito potrebbe non essere visualizzato singolarmente per ogni errore. Per evitare di dover visualizzare contemporaneamente troppi banner di errore, lo stesso banner di errore non viene visualizzato di nuovo se è stato visualizzato di recente.

Esempio

Considera un controllo Label e un controllo Slider che sono legati tra loro attraverso la formula:

Label1.Text = 1/Slider1.Value

Per impostazione predefinita, il controllo slider è impostato su 50. Se si sposta il dispositivo di scorrimento su 0, Label1 non visualizza alcun valore e viene visualizzato un banner di errore:

Esaminiamo in dettaglio cosa accade:

1. Il dispositivo di scorrimento viene spostato a sinistra e la proprietà Slider1.Value viene modificata in 0.
2. Label1.Text rivaluta automaticamente. La divisione per zero si verifica generando un errore.
3. Non c'è IfError in questa formula. L'errore di divisione per zero viene restituito dalla formula di valutazione.
4. Label1.Text non può mostrare nulla per questo errore, quindi mostra uno stato vuoto.
5. OnError viene richiamato. Poiché non esiste un gestore, viene visualizzato il banner di errore standard con le informazioni sull'errore.

Se necessario, è anche possibile modificare la formula in Label1.Text = IfError( 1/Slider1.Value, 0 ). L'uso di IfError indica che non è presente alcun banner di errore o errore. Non è possibile modificare il valore di un errore da OnError perché l'errore si è già verificato: OnError controlla solo il modo in cui viene segnalato.

Se si aggiunge un gestore OnError , non influisce sui passaggi precedenti al passaggio 5, ma cambia il modo in cui viene segnalato l'errore:

Trace( $"Error {FirstError.Message} in {FirstError.Source}" )

Con questo gestore OnError , l'utente dell'app non visualizza alcun errore. L'errore viene tuttavia aggiunto alla traccia di Monitoraggio, inclusa l'origine delle informazioni sull'errore da FirstError:

Se si vuole anche visualizzare il banner di errore predefinito insieme alla traccia, generare nuovamente l'errore usando la funzione Error dopo la chiamata di traccia , come se la traccia non fosse presente:

Trace( $"Error {FirstError.Message} in {FirstError.Source}" );
Error( FirstError )

Proprietà OnStart

La proprietà OnStart viene eseguita quando l'utente avvia l'app. Utilizzare questa proprietà per:

• Recuperare e memorizzare nella cache i dati nelle raccolte usando la funzione Collect .
• Imposta le variabili globali usando la funzione Set.

Questa formula viene eseguita prima che venga visualizzata la prima schermata. Non viene caricata alcuna schermata, quindi non è possibile impostare variabili di contesto con la funzione UpdateContext. È tuttavia possibile passare variabili di contesto con la funzione Navigate .

Dopo aver modificato la proprietà OnStart , testarla passando il puntatore del mouse sull'oggetto App nel riquadro Visualizzazione albero , selezionando i puntini di sospensione (...), quindi selezionando Esegui OnStart. A differenza di quando l'app viene caricata per la prima volta, le raccolte e le variabili esistenti sono già impostate. Per iniziare con raccolte vuote, utilizza la funzione ClearCollect invece di Collect.

Proprietà StartScreen

La proprietà StartScreen imposta la schermata visualizzata per prima. Power Apps valuta questa proprietà una volta quando l'app viene caricata e restituisce l'oggetto schermo da visualizzare. Per impostazione predefinita, questa proprietà è vuota e la prima schermata della visualizzazione Albero di Studio viene visualizzata per prima.

StartScreen è una proprietà del flusso di dati che non può contenere funzioni di comportamento. Sono disponibili tutte le funzioni del flusso di dati. Usare queste funzioni e segnali per decidere quale schermata visualizzare per prima:

• Funzione Param per leggere i parametri utilizzati per avviare l'app.
• Funzione User per leggere le informazioni sull'utente corrente.
• Funzione LookUp, Filtro, CountRows, Max e altre funzioni che leggono da un origine dati.
• Chiamate API tramite un connettore. Assicurarsi che la chiamata venga restituita rapidamente.
• Segnali come Connessione, Bussola, e App.

Se StartScreen restituisce un errore, la prima schermata della visualizzazione Albero di Studio viene visualizzata come se StartScreen non sia impostato. Usare la funzione IfError per rilevare eventuali errori e reindirizzare a una schermata di errore.

Dopo aver modificato StartScreen in Studio, testarlo passando il puntatore del mouse sull'oggetto App nel riquadro Visualizzazione albero , selezionando i puntini di sospensione (...), quindi selezionando Passa a StartScreen. La schermata cambia come se l'app fosse stata appena caricata.

Examples

Screen9

Screen9 viene visualizzato per primo ogni volta che viene avviata l'app.

If( Param( "admin-mode" ) = 1, HomeScreen, AdminScreen )

Controlla se il parametro "admin-mode" è impostato e lo usa per decidere se HomeScreen o AdminScreen viene visualizzato per primo.

If( LookUp( Attendees, User = User().Email ).Staff, StaffPortal, HomeScreen )

Controlla se un partecipante è un membro del personale e li indirizza alla schermata corretta all'avvio.

IfError( If( CustomConnector.APICall() = "Forest", 
             ForestScreen, 
             OceanScreen 
         ), 
         ErrorScreen 
)

Indirizza l'app in base a una chiamata API a ForestScreen o OceanScreen. Se l'API ha esito negativo, l'app usa ErrorScreen invece.

Proprietà StudioVersion

Usare la proprietà StudioVersion per visualizzare o registrare la versione di Power Apps Studio usata per pubblicare un'app. Questa proprietà consente di eseguire il debug e verificare che l'app venga ripubblicata con una versione recente di Power Apps Studio.

StudioVersion restituisce testo. Il formato di questo testo può cambiare nel tempo, quindi considerarlo nel suo complesso e non estrarre singole parti.