Foutafhandeling

Het gedrag dat in dit artikel wordt beschreven, is alleen beschikbaar wanneer de functie foutbeheer op formuleniveau is ingeschakeld.

Power Fx biedt ondersteuning voor foutafhandeling op formuleniveau. Deze functie is standaard ingeschakeld voor alle nieuwe apps. Voor sommige oudere apps is het echter mogelijk uitgeschakeld in app-instellingen. Houd deze functie ingeschakeld.

1. Open de canvas-app in de bewerkingsmodus.
2. Ga naar het tabbladInstellingenupdates>>buiten gebruik gesteld.
3. Zorg ervoor dat uitschakelen van beheer op formuleniveau is uitgeschakeld.

Zie Beheren welke functies zijn ingeschakeld voor meer informatie.

Fouten vinden plaats. Netwerken vallen uit, opslagruimtes raken vol, onverwachte waarden stromen binnen. Het is belangrijk dat uw logica goed blijft werken ondanks mogelijke problemen.

Standaard stromen fouten door de formules van een app en worden ze gerapporteerd aan de eindgebruiker van de app. Op deze manier weet de eindgebruiker dat er iets onverwachts is gebeurd. Ze kunnen het probleem mogelijk zelf oplossen met een andere invoer, of ze kunnen het probleem rapporteren aan de eigenaar van de app.

Als app-maker kunt u de controle over fouten in uw app overnemen:

• Een fout detecteren en afhandelen. Als er een fout kan optreden, schrijft u de formules van de app om de foutvoorwaarde te detecteren en voert u de bewerking opnieuw uit. De eindgebruiker hoeft zich geen zorgen te maken dat er een fout is opgetreden omdat de maker rekening heeft gehouden met de mogelijkheid. Leg de fout vast met behulp van de functies IfError, IsError en IsErrorOrBlank in een formule.
• Een fout melden. Als er geen fout wordt verwerkt in de formule waarin u deze hebt aangetroffen, wordt de fout doorgegeven naar de App.OnError handler. U kunt de fout niet vervangen omdat deze al is opgetreden en deel uitmaakt van formuleberekeningen. Maar u kunt App.OnError gebruiken om te bepalen hoe de fout wordt gerapporteerd aan de eindgebruiker, ook kan de foutrapportage helemaal worden onderdrukt. App.OnError biedt ook een gemeenschappelijk knelpunt voor foutrapportage in de gehele app.
• Maak en gooi een foutmelding opnieuw. Ten slotte kunt u een foutvoorwaarde detecteren met uw eigen logica, een voorwaarde die specifiek is voor uw app. Gebruik de functie Error om aangepaste fouten te maken. Gebruik de functie Fout om een fout opnieuw te werpen na ondervraagd te zijn in IfError of App.OnError.

Aan de slag

We beginnen met een eenvoudig voorbeeld.

1. Maak een nieuw scherm in een Power Apps Canvas-app.
2. Voeg een TextInput controle in. Deze wordt standaard ingesteld op de naam TextInput1.
3. Voeg een Label-controle toe.
4. Stel de eigenschap Text van het besturingselement Label in op de formule

1/Value( TextInput1.Text )

Er wordt een fout weergegeven omdat de standaardtekst van een TextInput-besturingselement is "Text input", dat niet kan worden geconverteerd naar een getal. Dit is standaard een goede zaak: de eindgebruiker krijgt een melding dat iets niet werkt zoals verwacht in de app.

Uiteraard wilt u niet dat de gebruiker elke keer dat deze app wordt gestart, een foutmelding krijgt. Waarschijnlijk is "Text input" toch niet de juiste standaardinstelling voor het tekstinvoervak. U kunt dit probleem oplossen door de standaardeigenschap van het besturingselement TextInput te wijzigen in:

Blank()

Hmm, nu ziet u een andere fout. Wiskundige bewerkingen met lege waarden, zoals delen, dwingen de lege waarde tot een nul. Deze waarde veroorzaakt een deling door nulfout. U kunt dit probleem oplossen door te bepalen wat het juiste gedrag is voor deze situatie in deze app. Het antwoord kan zijn om leeg te tonen wanneer de tekstinvoer leeg is. U kunt dit doel bereiken door de formule te verpakken met de functie IfError :

IfError( 1/Value( TextInput1.Text ), Blank() )

Nu wordt de fout vervangen door een geldige waarde en gaat de foutbanner weg. Maar misschien hebt u overschreden, de IfError functie die u hebt gebruikt behandelt alle fouten, inclusief het typen van een ongeldige waarde, zoals "hello". U kunt dit probleem oplossen door uw IfError af te stemmen om alleen gevallen van deling door nul af te handelen en alle andere fouten opnieuw op te werpen.

IfError( 1/Value( TextInput1.Text ), 
         If( FirstError.Kind = ErrorKind.Div0, Blank(), Error( FirstError ) ) )

Voer uw app uit en probeer een aantal verschillende waarden.

Zonder een waarde, zoals wanneer de app start, wordt er geen antwoord weergegeven omdat de standaardwaarde leeg is, maar er wordt ook geen fout weergegeven als IfError de deling door nul-fout vervangt.

Als u een 4 typt, krijgt u het verwachte resultaat van 0,25:

En als u iets illegaals typt, zoals hello, ontvangt u een foutmeldingbanner:

Dit is een eenvoudig inleidend voorbeeld. U kunt fouten op veel verschillende manieren afhandelen, afhankelijk van de behoeften van de app:

1. In plaats van een foutbanner kunt u '#Error' weergeven in het etiketbesturingselement met de formule. Als u de typen vervangingen compatibel wilt houden met het eerste argument in IfError, moet u het numerieke resultaat expliciet converteren naar een tekenreeks met behulp van de functie Tekst .

   IfError( Text( 1/Value( TextInput1.Text ) ), 
            If( FirstError.Kind = ErrorKind.Div0, Blank(), "#Error" )
   

   
2. In plaats van deze specifieke instantie te verpakken met IfError, kunt u een gecentraliseerde App.OnError-handler schrijven. U kunt de tekenreeks die wordt weergegeven, niet vervangen door '#Error' omdat de fout al is opgetreden en App.OnError alleen is opgegeven voor het beheren van rapportage.

   If( FirstError.Kind <> ErrorKind.Div0, Error( FirstError ) )
   

Foutvoortplanting

Fouten stromen door formules net zoals in Excel. Als de cel A1 bijvoorbeeld de formule =1/0bevat, wordt in A1 de foutwaarde #DIV0!weergegeven:

Als de cel A2 verwijst naar A1 met een formule zoals =A1*2, wordt de fout ook voortgezet via die formule.

De fout vervangt de waarde die de formule anders zou berekenen. Er is geen resultaat voor de vermenigvuldiging in cel A2, alleen de fout van de deling in A1.

Power Fx werkt op dezelfde manier. Als u in het algemeen een fout opgeeft als argument voor een functie of operator, vindt de bewerking niet plaats. De invoerfout vloeit voort uit de operatie. Bijvoorbeeld, retourneert Mid( Text( 1/0 ), 1, 1 ) een deling door nul-fout, omdat de binnenste fout door de functie Tekst en de functie Mid gaat:

Over het algemeen is er geen doorstroom van fouten door besturingseigenschappen van Power Apps. Laten we het vorige voorbeeld uitbreiden met een ander besturingselement dat aangeeft of de eigenschap van het eerste label Text een foutstatus heeft.

Het is prima dat fouten niet worden doorgegeven via een besturingselement, omdat het systeem fouten op de invoer in alle eigenschappen van het besturingselement ziet. De fout is niet verloren gegaan.

De meeste functies en operators volgen de regel 'fout in, fout uit', maar er zijn enkele uitzonderingen. De functies IsError, IsErrorOrBlank en IfError zijn ontworpen voor het werken met fouten, zodat ze mogelijk geen fout retourneren, zelfs niet als er een wordt doorgegeven.

Fouten waarnemen

Power Fx ziet geen fouten totdat de formule de foutwaarde gebruikt.

Als gevolg hiervan retourneren de functies If en Select mogelijk geen fout als er een wordt doorgegeven. Bekijk de formule If( false, 1/0, 3 ). Deze formule bevat een deling door nul, maar omdat de functie If die vertakking niet gebruikt vanwege de false voorwaarde, melden Power Fx en Power Apps geen fout.

Als u de functie Set met een fout gebruikt, wordt er geen fout gerapporteerd op het moment dat de fout in de variabele wordt geplaatst. In Power Apps ziet u bijvoorbeeld een formule in App.OnStart die een deling-door-nul-fout veroorzaakt in de variabele x.

Er wordt geen fout gerapporteerd, omdat er niet naar x wordt verwezen. Het moment waarop u echter een labelbesturingselement toevoegt en de eigenschap x instelt op, wordt de fout weergegeven:

U kunt fouten in een formule bekijken met behulp van de functies IfError, IsError en IsErrorOrBlank . Met deze functies kunt u een alternatieve waarde retourneren, alternatieve actie ondernemen of de fout wijzigen voordat deze wordt waargenomen en gerapporteerd.

Fouten rapporteren

Nadat Power Fx een fout heeft waargenomen, is de volgende stap het rapporteren van de fout aan de eindgebruiker.

In tegenstelling tot Excel is er niet altijd een handige plaats om een foutresultaat weer te geven, omdat het resultaat van een formule een eigenschap zoals X- en Y-coördinaten van een besturingselement kan aandrijven waarvoor geen handige plaats is om tekst weer te geven. Elke Power Fx-host bepaalt hoe fouten uiteindelijk worden weergegeven aan de eindgebruiker en hoeveel controle de maker heeft over dit proces. In Power Apps wordt een foutbanner weergegeven en wordt App.OnError gebruikt om te bepalen hoe de fout wordt gerapporteerd.

Het is belangrijk op te merken dat App.OnError de fout niet op dezelfde manier kan vervangen als IfError. Op het moment dat App.OnError wordt uitgevoerd, is de fout al opgetreden en wordt het resultaat doorgegeven via andere formules. App.OnError regelt alleen hoe de fout aan de eindgebruiker wordt gerapporteerd en biedt de maker een haak om de fout indien gewenst te loggen.

De bereikvariabelen FirstError en AllErrors geven contextinformatie over de fout of fouten. Deze context bevat informatie over het soort fout, waar de fout afkomstig is en waar deze is waargenomen.

Stoppen na een fout

Gedragsformules ondersteunen het ondernemen van actie, het aanpassen van databases en het veranderen van status. Met deze formules kan meer dan één actie in een reeks worden uitgevoerd met behulp van de ; ketenoperator (of ;; afhankelijk van de landinstelling).

In dit geval toont de gridcontrole bijvoorbeeld de inhoud van de T tabel. Elke geselecteerde knop verandert de status in deze tabel met twee Patch-aanroepen:

In een keten met gedragsformules stoppen acties niet na de eerste fout. Laten we ons voorbeeld aanpassen om een ongeldig indexnummer door te geven in de eerste Patch-aanroep. De tweede Patch gaat door ondanks deze eerdere fout. De eerste fout wordt gerapporteerd aan de eindgebruiker en weergegeven als een fout in Studio op het besturingselement:

Gebruik IfError om de uitvoering te stoppen na een fout. Net als bij de If-functie biedt het derde argument van deze functie een plaats om acties neer te zetten die alleen moeten worden uitgevoerd als er geen fout is:

Als er een fout optreedt tijdens een van de iteraties van ForAll, stopt de rest van de iteraties niet. ForAll is ontworpen om elke iteratie onafhankelijk uit te voeren, waardoor parallelle uitvoering mogelijk is. Wanneer de ForAll is voltooid, wordt er een fout geretourneerd die alle fouten bevat die zijn opgetreden (door AllErrors in IfError of App.OnError te onderzoeken).

De volgende formule resulteert bijvoorbeeld in ForAll in twee fouten (voor de deling door nul van Value 0, twee keer) en Collection heeft drie records (voor wanneer Value niet gelijk aan 0): [1, 2, 3].

Clear( Collection ); 
ForAll( [1,0,2,0,3], If( 1/Value > 0, Collect( Collection, Value ) ) );

Werken met meerdere fouten

Aangezien een gedragsformule meer dan één actie kan uitvoeren, kunnen er ook meerdere fouten optreden.

De app rapporteert standaard de eerste fout aan de eindgebruiker. In dit voorbeeld mislukken beide Patch-aanroepen, maar de tweede aanroep mislukt met een deling door nul. De gebruiker ziet alleen de eerste fout over de index:

De functie IfError en App.OnError hebben toegang tot alle fouten die zijn opgetreden met behulp van de bereikvariabele AllErrors . In dit geval kunt u deze variabele instellen op een globale variabele en kijken naar beide fouten die zijn opgetreden. Ze verschijnen in de tabel in dezelfde volgorde waarin ze zijn aangetroffen:

Nonbehavior-formules kunnen ook meerdere fouten opleveren. Als u bijvoorbeeld de Patch-functie gebruikt met een batch met records die moeten worden bijgewerkt, kunnen meerdere fouten worden geretourneerd, één voor elke record die mislukt.

Fouten in tabellen

Zoals u eerder hebt gezien, kunt u fouten opslaan in variabelen. U kunt ook fouten opnemen in gegevensstructuren, zoals tabellen. Deze methode is belangrijk omdat een fout in een record de hele tabel niet ongeldig kan maken.

Denk bijvoorbeeld aan dit besturingselement voor gegevenstabellen in Power Apps:

Tijdens de berekening in AddColumns is een deling met nulfout opgetreden voor een van de waarden. Voor die ene record heeft de kolom Reciprocal een foutwaarde (deling door nul), maar de andere records zijn in orde. IsError( Index( output, 2 ) ) retourneert onwaar en IsError( Index( output, 2 ).Value ) retourneert waar.

Als er een fout optreedt bij het filteren van een tabel, is de hele record een fout. De bewerking retourneert nog steeds het record in het resultaat, zodat de eindgebruiker weet dat er iets was en dat er een probleem is.

Kijk naar dit voorbeeld. Hier bevat de oorspronkelijke tabel geen fouten, maar bij het filteren wordt een fout veroorzaakt wanneer Waarde gelijk is aan 0:

De waarden -5 en -3 worden correct uitgefilterd. De waarden 0 resulteren in een fout bij het verwerken van het filter, waardoor het onduidelijk is of de record al dan niet in het resultaat moet worden opgenomen. Om de transparantie voor eindgebruikers te maximaliseren en makers te helpen fouten op te sporen, bevat de bewerking een foutrecord in plaats van het origineel. In dit geval geeft IsError( Index( output, 2 ) ) waar als resultaat.

Gegevensbronfouten

De functies die gegevens in gegevensbronnen wijzigen, zoals Patch, Collect, Remove, RemoveIf, Update, UpdateIf en SubmitForm rapporteren fouten op twee manieren:

• Elk van deze functies retourneert een foutwaarde als resultaat van de bewerking. U kunt fouten detecteren met behulp van IsError en fouten vervangen of onderdrukken door IfError en App.OnError zoals gebruikelijk te gebruiken.
• Na de bewerking retourneert de functie Fouten ook de fouten voor eerdere bewerkingen. Dit gedrag kan handig zijn voor het weergeven van het foutbericht op een formulierscherm zonder dat u de fout in een statusvariabele hoeft vast te leggen.

Met deze formule wordt bijvoorbeeld gecontroleerd op een fout in Collect en wordt een aangepast foutbericht weergegeven:

IfError( Collect( Names, { Name: "duplicate" } ),
         Notify( $"OOPS: { FirstError.Message }", NotificationType.Warning ) )

De functie Errors retourneert ook informatie over eerdere fouten tijdens runtime-bewerkingen. Dit kan handig zijn om een fout op een formulierscherm weer te geven zonder de fout in een statusvariabele te hoeven vastleggen.

Fouten heropwerpen

Soms verwacht u potentiële fouten en kunt u ze veilig negeren. In IfError en App.OnError, als er een fout wordt gedetecteerd die moet worden doorgegeven aan de volgende hogere handler, voert u deze opnieuw door met behulp van Error( AllErrors ).

Uw eigen fouten maken

U kunt ook uw eigen fouten maken met behulp van de functie Fout .

Als u uw eigen fouten maakt, gebruikt u waarden die groter zijn dan 1000 om mogelijke conflicten met toekomstige systeemfoutwaarden te voorkomen.

Waarden van de ErrorKind-enumeratie