Program-objekt i Power Apps

Gäller: Arbetsyteappar

Hämta information om appen som körs och kontrollera appens beteende.

Description

Precis som en kontroll har appobjektet egenskaper som identifierar vilken skärm som visas och uppmanar dig att spara ändringar så att du inte förlorar dem. Varje program har ett program-objekt.

Skriv formler för vissa egenskaper för appobjektet . Längst upp i fönstret Trädvy, välj Program-objekt som med någon annan kontroll eller skärm. Om du vill visa eller redigera en av objektets egenskaper markerar du den i listrutan till vänster om formelfältet.

Den här artikeln beskriver följande egenskaper för appobjekt :

• ActiveScreen – den skärm som visas för närvarande.
• BackEnabled – hur appen svarar på tillbaka-gesten för enheten.
• ConfirmExit och ConfirmExitMessage – varna användaren innan du stänger appen.
• Anslutningssträng – konfigurera Application Insights-loggning.
• Formler – definiera namngivna formler, användardefinierade funktioner och användardefinierade typer.
• OnError – hantera fel globalt.
• OnStart – kör logik när appen startar.
• StartScreen – ange den skärm som visas först när appen läses in.
• StudioVersion – returnerar Power Apps Studio-versionen som publicerade appen.

Egenskapen ActiveScreen

Egenskapen ActiveScreen identifierar den skärm som visas för närvarande.

Egenskapen returnerar ett skärmobjekt. Använd den för att referera till egenskaperna för den aktuella skärmen, till exempel namnet med formeln App.ActiveScreen.Name. Du kan också jämföra den här egenskapen med ett annat skärmobjekt, till exempel med jämförelseformeln App.ActiveScreen = Screen2 för att kontrollera om Screen2 är den aktuella skärmen.

Använd funktionen Bakåt eller Navigera för att växla den skärm som visas.

Egenskapen BackEnabled

Egenskapen BackEnabled ändrar hur appen svarar på bakåtgesten för enheten (svep eller använd bakåtknappen för maskinvara på Android-enheter eller svep från vänster på iOS-enheter) när den körs i Power Apps Mobile. När den är aktiverad går tillbaka-gesten tillbaka till den skärm som senast visades, vilket liknar back-formeln. När den är inaktiverad tar tillbaka enheten användaren till applistan.

Egenskaper för ConfirmExit

Ingen vill förlora ändringar som inte har sparats. Använd egenskaperna ConfirmExit och ConfirmExitMessage för att varna användaren innan du stänger appen.

ConfirmExit

ConfirmExit är en boolesk egenskap som när den är sann öppnar en bekräftelsedialogruta innan appen stängs. Som standard är den här egenskapen false och ingen dialogruta visas.

När användaren kan ha ändringar som inte har sparats i appen använder du den här egenskapen för att visa en bekräftelsedialogruta innan du avslutar appen. Använd en formel som kontrollerar variabler och kontrollegenskaper (till exempel egenskapen Unsaved för kontrollen Redigera formulär ).

Bekräftelsedialogrutan visas i alla situationer där data kan gå förlorade, till exempel:

• Kör funktionen Avsluta .
• Om appen körs i en webbläsare:
  • Stäng webbläsaren eller webbläsarfliken där appen körs.
  • Välj webbläsarens bakåtknapp.
  • Kör funktionen Starta med en LaunchTarget of Self.
• Om appen körs i Power Apps Mobile (iOS eller Android):
  • Svep för att växla till en annan app i Power Apps Mobile.
  • Välj bakåtknappen på en Android-enhet.
  • Kör funktionen Starta för att starta en annan app för arbetsytor.

Det exakta utseendet på bekräftelsedialogrutan kan variera mellan enheter och versioner av Power Apps.

Bekräftelsedialogrutan visas inte i Power Apps Studio.

ConfirmExitMessage

Som standard visas ett allmänt meddelande i bekräftelse dialogrutan, till exempel "Du kanske har osparade ändringar". på användarens språk.

Använd ConfirmExitMessage för att ange ett anpassat meddelande i bekräftelse dialogrutan. Om den här egenskapen är blank används standardvärdet. Anpassade meddelanden trunkeras efter behov för att passa in i bekräftelsedialogrutan, så håll meddelandet till högst några rader.

I en webbläsare kan bekräftelsedialogrutan visa ett allmänt meddelande från webbläsaren.

Example

1. Ange Program objekt egenskap ConfirmExit till följande uttryck:

   AccountForm.Unsaved Or ContactForm.Unsaved
   

   Dialogrutan visas om användaren ändrar data i något av formulären och sedan försöker stänga appen utan att spara ändringarna.

   

2. Ange App objekt egenskap ConfirmExitMessage till följande formel:

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

   Dialogrutan visar ett formulärspecifikt meddelande när användaren ändrar data i något av formulären och sedan försöker stänga appen utan att spara ändringarna.

   

Egenskapen Anslutningssträng

Använd egenskapen Anslutningssträng för att exportera systemgenererade programloggar till Application Insights.

Så här anger du reťazec pripojenia:

1. Öppna appen för redigering i Power Apps Studio.
2. Välj objektet App i trädvyn i det vänstra navigeringsfönstret.
3. Ange anslutningssträngen i egenskapsfönstret.

Om data inte skickas till Application Insights kontaktar du power platform-administratören och kontrollerar om Application Insights är inaktiverat på klientorganisationsnivå.

Egenskapen Formel

Använd egenskapen Formler för att definiera återanvändbar logik i din app. Egenskapen Formler stöder tre konstruktioner:

• Namngivna formler – tilldela ett namn till en formel och återanvänd värdet i hela appen.
• Användardefinierade funktioner – namngivna formler som tar parametrar och returnerar ett värde.
• Användardefinierade typer – namngivna typer som du kan återanvända i formler och funktionssignaturer.

Namngivna formler

Använd namngivna formler i egenskapen Formler för att definiera en formel som du kan återanvända i hela appen.

I Power Apps bestämmer formler värdet för kontrollegenskaper. Om du till exempel vill ange bakgrundsfärgen konsekvent i en app anger du egenskapen Fyll för varje kontroll till en vanlig formel:

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

Med så många platser där den här formeln visas blir det omständligt och felbenäget att uppdatera dem alla om en ändring behövs. Skapa i stället en global variabel i OnStart för att ange färgen en gång och återanvänd sedan värdet i hela appen:

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

Även om den här metoden är bättre beror den också på OnStart som körs innan värdet för BGColor upprättas. BGColor kan också manipuleras i ett hörn av appen som tillverkaren förser med, en förändring som någon annan har gjort och som kan vara svårt att hålla reda på.

Namngivna formeln utgör ett alternativ. Precis som du ofta skriver control-property = expression kan du i stället skriva namn = uttryck och sedan återanvända namn i hela appen för att ersätta uttrycket. Definiera dessa formler i egenskapen Formler :

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

Fördelarna med att använda namngivna formeln är:

• Formelns värde är alltid tillgängligt. Det finns inget tidsberoende, ingen OnStart som måste köras först innan värdet har angetts, ingen tid då formelns värde är felaktigt. Namngivna formeln kan referera till varandra i vilken ordning som helst, så länge de inte skapar en cirkelreferens. De kan beräknas samtidigt.
• Formelns värde är alltid uppdaterat. Formeln kan göra en beräkning som är beroende av kontrollegenskaper eller databasposter och när de ändras uppdateras formelns värde automatiskt. Du behöver inte uppdatera värdet manuellt på samma sätt som med en variabel. Och formeln beräknas bara om när det behövs.
• Formelns definition är oföränderlig. Definitionen i Formler är den enda sanningens källa och värdet kan inte ändras i programmet. Med variabler kan viss kod oväntat ändra ett värde, men den här svåra felsökningssituationen är inte möjlig med namngivna formler.
• Formelns beräkning kan skjutas upp. Eftersom värdet är oföränderligt kan det alltid beräknas när det behövs, vilket innebär att det inte behöver beräknas förrän det behövs. Formelvärden som inte används förrän skärm2 i ett program visas behöver inte beräknas förrän skärm2 visas. Om du avser detta arbete kan tiden för appbelastningen förbättras. Namngivna formeln är deklarativa och tillhandahåller möjligheter för systemet att optimera hur och när de beräknas.
• Namngivna formeln är ett Excel-koncept. Power Fx används Excel-begrepp när det är möjligt eftersom så många känner till Excel. Namngivna formeln motsvarar namngivna celler och namngivna formeln i Excel, hanterade med namnhanteraren. De räknar om automatiskt på samma sätt som celler i ett kalkylblad och det gör även kontrollegenskaper.

Definiera namngivna formler en efter en i egenskapen Formler , var och en slutar med ett semikolon. Typen av formel härleds från typerna av element i formeln och hur de används tillsammans. Dessa namngivna formeln hämtar till exempel användbar information om den aktuella användaren från 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' );

Om formeln för UserTitle behöver uppdateras kan du enkelt uppdatera den på den här platsen. Om UserPhone inte behövs i programmet görs inte samtalen till tabellen Användare i Dataverse. Ingen anledning att ta med en formeldefinition som inte används.

Vissa begränsningar för namngivna formeln:

• De kan inte använda beteendefunktioner eller på annat sätt orsaka biverkningar i programmet.
• De kan inte skapa en cirkelreferens. Att ha a = b; och b = a; i samma program är inte tillåtet.

Användardefinierade funktioner

Power Fx innehåller en lång lista med inbyggda funktioner, till exempel If, Text och Set. Genom att använda användardefinierade funktioner kan du skriva egna funktioner som tar parametrar och returnerar ett värde, precis som de inbyggda funktionerna. Tänk på användardefinierade funktioner som ett tillägg till namngivna formler som lägger till parametrar och stöder beteendeformler.

Du kan till exempel definiera en namngiven formel som returnerar skönlitterära böcker från ett bibliotek:

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

Utan parametrar måste du definiera separata namngivna formler för varje genre. Men i stället kan du parametrisera din namngivna formel:

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

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

Nu kan du anropa LibraryGenre( "Fiction" ), LibraryGenre( "Reference" )eller filtrera på andra genrer med hjälp av en enda användardefinierad funktion.

Syntaxen är:

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

• FunctionName – Krävs. Namnet på den användardefinierade funktionen.
• ParameterNames – Valfritt. Namnet på en funktionsparameter.
• ParameterType(s) – Valfritt. Namnet på en typ, antingen ett inbyggt datatypnamn, ett datakällans namn eller en typ som definieras med hjälp av funktionen Typ .
• ReturnType – Krävs. Typen av returvärde från funktionen.
• Formel – obligatoriskt. Formeln som beräknar funktionens värde baserat på parametrarna.

Du måste ange varje parameter och utdata från den användardefinierade funktionen. I det här exemplet SelectedGenre: Text definierar den första parametern för funktionen att vara av typen Text och SelectedGenre är namnet på parametern som används i brödtexten för filteråtgärden. Se Datatyper för de typnamn som stöds. Funktionen Typ används för att skapa en aggregeringstyp för biblioteket, så att du kan returnera en tabell med böcker från funktionen.

Du definierar LibraryType som en pluraltabell med posttyp. Om du vill skicka en enda bok till en funktion kan du extrahera typen av post för den här tabellen med hjälp av funktionen RecordOf:

BookType := Type( RecordOf( LibraryType ) );

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

Matchning av poster för funktionsparametrar är striktare än i andra delar av Power Fx. Fälten i ett postvärde måste vara en korrekt delmängd av typdefinitionen och får inte innehålla extra fält. Till exempel IsGenre( { Title: "My Book", Published: 2001 }, "Fiction" ) resulterar det i ett fel.

Rekursion stöds ännu inte av användardefinierade funktioner.

Användardefinierade funktioners beteende

Namngivna formler och de flesta användardefinierade funktioner stöder inte beteendefunktioner med sidoeffekter, till exempel Ange eller Meddela. I allmänhet bör du undvika att uppdatera tillståndet om du kan. Förlita dig i stället på funktionella programmeringsmönster och låt Power Fx beräkna om formler efter behov automatiskt. Men det finns fall där det är oundvikligt. Om du vill inkludera beteendelogik i en användardefinierad funktion omsluter du brödtexten inom klammerparenteser:

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

Nu kan du anropa Spend( 12 ) för att kontrollera om du har 12 i ditt sparande och i så fall debitera det med 12 och lägga till 12 i variabeln Spenderad. Returtypen för den här funktionen är Annullera eftersom den inte returnerar något värde.

Syntaxen för en beteendeanvändardefinierad funktion är:

FunctionName( [ ParameterName1: ParameterType1 [ , ParameterName2: ParameterType2 ... ] ] ) : ReturnType = { Formula1 [ ; Formel 2 ... ] };

• FunctionName – Krävs. Namnet på den användardefinierade funktionen.
• ParameterNames – Valfritt. Namnet på en funktionsparameter.
• ParameterType(s) – Valfritt. Namnet på en typ, antingen ett inbyggt datatypsnamn, ett namn på en datakälla eller en typ som definierats med funktionen Typ.
• ReturnType – Krävs. Typen av returvärde från funktionen. Använd Annullera om funktionen inte returnerar något värde.
• Formler – obligatoriskt. Formeln som beräknar funktionens värde baserat på parametrarna.

Precis som med alla Power Fx-formler avslutas inte körningen när ett fel påträffas. När funktionen Fel har anropats förhindrar funktionen If att ändringar i Sparande och Spenderad sker. Funktionen IfError kan också användas för att förhindra ytterligare körning efter ett fel. Även om den returnerar Annullera kan formeln fortfarande returnera ett fel om det uppstår ett problem.

Användardefinierade typer

Använd namngivna formler med funktionen Typ för att skapa användardefinierade typer. Använd := i stället för = för att definiera en användardefinierad typ, till exempel Book := Type( { Title: Text, Author: Text } ). Mer information och exempel finns i funktionen Typ.

Egenskapen OnError

Använd OnError för att vidta åtgärder när ett fel inträffar var som helst i appen. Det ger en global möjlighet att fånga upp en felbanderoll innan den visas för slutanvändaren. Du kan också använda det för att logga ett fel med hjälp av funktionen Trace eller skriva till en databas eller webbtjänst.

I arbetsyteappen kontrolleras resultatet av varje formelutvärdering för att ett fel uppstår. Om ett fel uppstår utvärderas OnError med samma FirstError- och AllErrors-omfångsvariabler som appen använder om hela formeln omsluts i en IfError-funktion.

Om OnError är tomt visas felet FirstError.Message i en standardfelbanderoll. Om du definierar en OnError-formel åsidosätts det här beteendet, så att tillverkaren kan hantera felrapportering efter behov. Du kan begära standardbeteendet i OnError genom att återväxa felet med hjälp av funktionen Fel. Använd återväxtmetoden om du vill filtrera bort eller hantera vissa fel på ett annat sätt, men låta andra passera.

OnError kan inte ersätta ett fel i beräkningar som IfError kan. Om OnError anropas har felet redan inträffat och bearbetas redan via formelberäkningar som IfError. OnError styr endast felrapportering.

OnError-formler utvärderas samtidigt och det är möjligt att deras utvärdering kan överlappa bearbetningen av andra fel. Om du till exempel anger en global variabel överst i en OnError och läser den senare i samma formel kan värdet ha ändrats. Använd funktionen With vill skapa ett namngivet värde som är lokalt i formeln.

Även om OnError bearbetar varje fel individuellt kanske standardfelbanderollen inte visas för varje fel individuellt. För att undvika att för många felbanderoller visas samtidigt visas inte samma felbanderoll igen om den nyligen visades.

Example

Överväg en Label kontroll och Slider som är bundna samman med formeln:

Label1.Text = 1/Slider1.Value

Reglaget har som standard 50. Om du flyttar skjutreglaget till 0 visar Label1 inget värde och en felbanderoll visas:

Låt oss titta på vad som händer i detalj:

1. Du flyttar skjutreglaget till vänster och egenskapen Slider1.Value ändras till 0.
2. Label1.Text omvärderas automatiskt. Division med noll inträffar, vilket genererar ett fel.
3. Det finns ingen IfError i den här formeln. Divisionsfelet med noll returneras av formelutvärderingen.
4. Label1.Text kan inte visa någonting för felet, så ett tomt tillstånd visas.
5. OnError anropas. Eftersom det inte finns någon hanterare visas standardfelbanderollen med felinformation.

Om det behövs kan du också ändra formeln till Label1.Text = IfError( 1/Slider1.Value, 0 ). Att använda IfError innebär att det inte finns något fel eller någon felbanderoll. Du kan inte ändra värdet för ett fel från OnError eftersom felet redan har inträffat – OnError styr bara hur det rapporteras.

Om du lägger till en OnError-hanterare påverkar det inte stegen före steg 5, men det ändrar hur felet rapporteras:

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

Med den här OnError-hanteraren ser appanvändaren inga fel. Men felet läggs till i övervakarens spårning, inklusive källan till felinformationen från FirstError:

Om du också vill visa standardfelbanderollen tillsammans med spårningen ska du återskapa felet med hjälp av funktionen Fel efter spårningsanropet , som om spårningen inte fanns där:

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

OnStart egenskap

Egenskapen OnStart körs när användaren startar programmet. Använd den här egenskapen för att:

• Hämta och cachelagra data i samlingar med hjälp av funktionen Collect .
• Ange globala variabler med hjälp av funktionen Set.

Den här formeln körs innan den första skärmen visas. Ingen skärm visas och du kan inte ange processvariabler med funktionen UpdateContext. Men du kan skicka kontextvariabler med funktionen Navigate .

När du har ändrat egenskapen OnStart testar du den genom att hovra över appobjektet i fönstret Trädvy , välja ellipsen (...) och sedan välja Kör påstart. Till skillnad från när appen läses in för första gången har befintliga samlingar och variabler redan angetts. Om du vill börja med tomma samlingar använder du funktionen ClearCollect i stället för funktionen Collect.

Egenskapen StartScreen

Egenskapen StartScreen anger vilken skärm som visas först. Power Apps utvärderar den här egenskapen en gång när appen läses in och returnerar skärmobjektet som ska visas. Som standard är den här egenskapen tom och den första skärmen i Studio Tree-vyn visas först.

StartScreen är en dataflödesegenskap som inte kan innehålla beteendefunktioner. Alla dataflödesfunktioner är tillgängliga. Använd dessa funktioner och signaler för att bestämma vilken skärm som ska visas först:

• Funktionen Param för att läsa parametrar som används för att starta appen.
• Funktionen User för att läsa information om den aktuella användaren.
• LookUp, Filter, CountRows, Max och andra funktioner som läser från en datakälla.
• API-anrop via en anslutningsapp. Kontrollera att anropet returnerar snabbt.
• Signaler som till exempel Anslutning, Kompass och Program.

Om StartScreen returnerar ett fel visas den första skärmen i Studio Tree-vyn som om StartScreen inte har angetts. Använd funktionen IfError för att fånga upp eventuella fel och omdirigera till en felskärm.

När du har ändrat StartScreen i Studio testar du det genom att hovra över appobjektet i fönstret Trädvy , välja ellipsen (...) och sedan välja Navigera till StartScreen. Skärmen ändras som om appen precis har lästs in.

Exempel

Screen9

Screen9 visas först när appen startar.

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

Kontrollerar om Param "admin-mode" har angetts och använder det för att avgöra om HomeScreen eller AdminScreen visas först.

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

Kontrollerar om en deltagare är anställd och dirigerar dem till rätt skärm vid start.

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

Dirigerar programmet baserat på ett API-anrop till antingen ForestScreen eller OceanScreen. Om API:et misslyckas använder ErrorScreen appen i stället.

StudioVersion-egenskap

Använd egenskapen StudioVersion för att visa eller logga den version av Power Apps Studio som används för att publicera en app. Den här egenskapen hjälper dig när du felsöker och kontrollerar att din app publiceras på nytt med en ny version av Power Apps Studio.

StudioVersion returnerar text. Formatet för den här texten kan ändras med tiden, så behandla den som en helhet och extrahera inte enskilda delar.