Otimização do código

À medida que as aplicações de tela evoluem para satisfazer diferentes necessidades de negócio, manter o desempenho ótimo é crítico. O processamento de dados, o design da interface de utilizador e a funcionalidade da aplicação exigem uma abordagem cuidadosa à otimização de código.

À medida que as aplicações canvas se tornam mais complexas, pode surgir problemas com a recuperação de dados, a complexidade das fórmulas e a velocidade de renderização. Para equilibrar uma funcionalidade forte com uma interface de utilizador responsiva, utilize uma abordagem sistemática à otimização do código.

Otimização da fórmula Power Fx

Esta secção apresenta as melhores práticas para otimizar fórmulas de Power Fx.

Com função

A função With avalia uma fórmula para um único registo. A fórmula pode calcular um valor ou realizar ações, como modificar os dados ou trabalhar com uma ligação. Utilize With para facilitar a leitura de fórmulas complexas adividindo-as em subfórmulas com nomes mais pequenos. Estes valores nomeados funcionam como variáveis locais simples limitadas ao âmbito do With. With é melhor do que o contexto ou variáveis globais porque é autocontido, fácil de entender e opera bem em qualquer contexto de fórmula declarativa. Saiba mais sobre a função With.

Função Concorrente

A Concurrent função permite que múltiplas fórmulas da mesma propriedade sejam avaliadas ao mesmo tempo, caso tenham chamadas connector ou Dataverse. Normalmente, são avaliadas várias fórmulas ao mesmo tempo quando as encadeia com o operador ; (ponto e vírgula). Com Concurrent, a aplicação avalia todas as fórmulas numa propriedade ao mesmo tempo, mesmo depois de usar o operador ;. Esta concorrência significa que os utilizadores esperam menos tempo pelos resultados. Quando as chamadas de dados não são iniciadas até as chamadas anteriores serem concluídas, a aplicação espera pela soma do tempo de execução de todos os pedidos. Se as chamadas de dados começarem ao mesmo tempo, a aplicação só espera pelo tempo da solicitação mais longa. Saiba mais sobre a função Concorrente.

Concurrent(
    ClearCollect(colAccounts1, Accounts),
    ClearCollect(colUsers1, Users),
    ClearCollect(colEnvDef1, 'Environment Variable Definitions'),
    ClearCollect(colEnvVal1, 'Environment Variable Values')
);

Função de coalesce

A função Coalesce avalia os argumentos por ordem e devolve o primeiro valor que não esteja em branco ou uma cadeia vazia. Utilize esta função para substituir um valor em branco ou uma cadeia vazia por um valor diferente, mas deixe os valores de cadeia não em branco e não vazios inalterados. Se todos os argumentos estão em branco ou cadeias vazias, a função devolve blank. Coalesce é uma boa forma de converter cadeias vazias para valores em branco. Saiba mais sobre a função Coalesce.

Este exemplo requer value1 e value2 deve ser avaliado duas vezes:

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

Esta função pode ser reduzida a:

Coalesce(value1, value2)

Função IsMatch

A função IsMatch testa se uma cadeia de texto corresponde a um padrão composto por carateres comuns, padrões predefinidos ou uma expressão regular. Saiba mais sobre a função IsMatch.

Por exemplo, esta fórmula corresponde a um número de Segurança Social dos Estados Unidos:

IsMatch(TextInput1.Text, "\d{3}-\d{2}-\d{4}")

Explicação da expressão regular:

• \\d Corresponde a qualquer dígito (0-9).

• {3} Especifica que o padrão de dígitos anterior (\d) deve ocorrer exatamente três vezes.

• - Corresponde ao carácter de hífen.

• {2} Especifica que o padrão de dígitos anterior (\d) deve ocorrer exatamente duas vezes.

• {4} Especifica que o padrão de dígitos anterior (\d) deve ocorrer exatamente quatro vezes.

Mais exemplos de IsMatch:

IsMatch(TextInput1.Text, "Hello World")
IsMatch(TextInput1\_2.Text, "(?!^\[0-9\]\\\*$)(?!^\[a-zA-Z\]\\\*$)(\[a-zA-Z0-9\]{8,10})")

Otimizar a função OnStart da aplicação

A OnStart propriedade das aplicações canvas desempenha um papel crucial na definição das ações que ocorrem quando a aplicação é lançada. Esta propriedade permite que os programadores de aplicações executem tarefas de inicialização global, configurem variáveis e executem ações que só devem acontecer uma vez durante o processo de arranque da aplicação. Compreender e usar eficazmente a OnStart propriedade para criar aplicações de canvas responsivas e eficientes.

Simplifice a App.OnStart função migrando configurações de variáveis para fórmulas nomeadas. Fórmulas nomeadas, especialmente aquelas configuradas no início do ciclo de vida da aplicação, são vantajosas. Estas fórmulas lidam com a inicialização de variáveis com base em chamadas de dados, fornecendo uma estrutura mais limpa e organizada para o seu código. Saiba mais em Construir aplicações canvas grandes e complexas.

Nota

A OnStart propriedade é imperativa. É uma lista ordenada de trabalhos que precisam de ser feitos antes de aparecer o primeiro ecrã. Como é tão específico não só sobre o que precisa ser feito, mas também sobre quando esse trabalho tem de ser feito baseado na ordem, limita as otimizações de reordenação e adiamento que poderiam ser de outra forma feitas.

Ecrã inicial

Se App.OnStart contiver uma Navigate chamada de uma função, mesmo que esteja numa If função e raramente seja chamada, a aplicação deve concluir a execução de App.OnStart antes de mostrar o primeiro ecrã da aplicação.  App.StartScreen é uma forma declarativa de indicar qual ecrã deve ser mostrado primeiro, e não bloqueia as otimizações.

A definição da propriedade StartScreen mostra o primeiro ecrã antes de App.OnStart estar concluído. App.StartScreen declara qual o objeto de ecrã a mostrar primeiro sem necessidade de pré-processamento.

Em vez de escrever código como:

App.OnStart = Collect(OrdersCache, Orders);
If(Param("AdminMode") = "1", Navigate(AdminScreen), Navigate(HomeScreen))

Alterar o código para:

App.OnStart = Collect(OrdersCache, Orders);
App.StartScreen = If(Param("AdminMode") = "1", AdminScreen, HomeScreen)

Mais informações: App.StartScreen: uma alternativa declarativa ao Navigate no App.OnStart.

Aviso

Evite dependências entre StartScreen e OnStart. Referenciar uma fórmula nomeada que, por sua vez, faz referência a uma variável global pode causar uma condição de corrida em que StartScreen não é aplicado corretamente.

Não crie dependências entre StartScreen e OnStart. Enquanto a aplicação bloqueia a referência a variáveis globais em StartScreen, podes referenciar uma fórmula nomeada, que por sua vez faz referência a uma variável global. Esta abordagem pode causar uma condição de corrida em que o StartScreen não é aplicado corretamente.

Fórmulas nomeadas

Fórmulas nomeadas são estáticas ou constantes que podem ser definidas em App.Formulas. Uma vez declarados em App.Formulas, podem ser usados em qualquer lugar da aplicação, e os seus valores mantêm-se sempre atualizados. Fórmulas nomeadas no Power Apps permitem-lhe definir valores ou conjuntos de valores que a plataforma gere e atualiza automaticamente. Esta funcionalidade transfere a responsabilidade pelo cálculo e manutenção do valor do programador para o Power Apps, simplificando o processo de desenvolvimento. As fórmulas nomeadas no Power Apps são uma funcionalidade poderosa que pode melhorar significativamente o desempenho e a manutenção das aplicações.

Fórmulas nomeadas também ajudam ao declarar temas de app. Quando constrói aplicações empresariais, muitas vezes quer que a aplicação tenha temas comuns que proporcionem uma aparência e experiência de utilizador consistentes. Para criar um tema, é necessário declarar dezenas a centenas de variáveis em App.OnStart. Esta declaração aumenta o comprimento do código e o tempo de inicialização da aplicação.

Os controlos modernos também podem ajudar significativamente com a tematização e a reduzir a lógica escrita pelo cliente para processar tematizações. Os controlos modernos estão atualmente em fase de teste.

Por exemplo, pode mover o código App.OnStart seguinte para App.Formulas, o que reduz o tempo de arranque nas declarações globais de variáveis.

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

Pode mover o código para App.Formulas a seguinte forma:

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

Outro exemplo é na configuração Lookups. Aqui, é necessária uma alteração numa fórmula Lookup para obter a informação do utilizador do Office 365 em vez do Dataverse. Só precisas de fazer a alteração num só local, sem alterar o código em todo o lado.

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

Estas fórmulas incorporam a essência do cálculo. Articulam o processo para determinar UserEmail, UserInfo, UserTitle e UserPhone com base noutros valores. Esta lógica é encapsulada, permitindo uma utilização generalizada em toda a aplicação, e pode ser modificada numa localização singular. A adaptabilidade estende-se à mudança da tabela Dataverse Users para o conector Office 365 sem necessidade de alterações às fórmulas espalhadas pela aplicação.

Outra abordagem é otimizar countRows.

varListItems = CountRows(SampleList)

Com a Set função, deve inicializar a variável varListItems com a contagem inicial de linhas na lista de exemplo e voltar a defini-la depois de os itens da lista serem adicionados ou removidos. Com fórmulas nomeadas, à medida que os dados mudam, a varListItems variável é atualizada automaticamente.

As fórmulas nomeadas na App.Formulas propriedade proporcionam uma abordagem mais flexível e declarativa para gerir valores e cálculos ao longo da aplicação. Oferecem vantagens em termos de independência temporal, atualizações automáticas, manutenibilidade e definições imutáveis em comparação com depender apenas de App.OnStart.

Aspecto	Fórmulas nomeadas (Formulas do Aplicativo)	App.OnStart
Independência do tempo	As fórmulas estão disponíveis instantaneamente e podem ser calculadas em qualquer ordem.	As variáveis podem introduzir dependências temporárias que afetam a disponibilidade.
Atualizações automáticas	As fórmulas atualizam-se automaticamente quando as dependências mudam.	As variáveis são definidas uma vez durante o arranque; Podem ser necessárias atualizações manuais.
Capacidade de Manutenção	Fórmulas centralizadas em um único local melhoram a capacidade de manutenção.	Variáveis dispersas podem exigir encontrar e atualizar em vários locais.
Definições imutáveis	As definições de fórmulas em App.Formulas são imutáveis.	Os valores das variáveis podem ser suscetíveis a alterações acidentais.

Funções definidas pelo utilizador

funções definidas pelo utilizador no Power Apps Studio permitem-lhe criar as suas próprias funções personalizadas.

Defina uma fórmula em App.Formulas da seguinte forma:

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

O código funciona da seguinte forma:

• FunctionName invoca a função.

• Parameter é o nome da entrada. Pode-se incluir uma ou mais entradas.

• DataType é o tipo de dado que o argumento passado para a função deve corresponder. Os tipos de dados disponíveis incluem Booleano, Cor, Data, Data-Hora, Dinâmico, GUID, Hiperligação, Texto e Hora.

• OutputDataType é o tipo de dado para a saída da função.

• Formula é a saída da função.

Use IfError para implementar o tratamento de erros dentro da função definida:

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

Chame a função definida a partir de um controlo de texto ou etiqueta.

calcAreaOfCircle(Int(*TextInput1*.Text))

Otimizar variáveis

As variáveis definem e estabelecem os valores local e global que usa em toda a aplicação. Embora sejam convenientes, a utilização de demasiadas variáveis pode tornar a sua aplicação menos eficiente.

O exemplo a seguir demonstra como definir uma variável para cada atributo de um objeto, o que requer a utilização de Set para cada propriedade.

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

A abordagem mais eficiente é usar a propriedade apenas quando precisar dela:

Set(varEmployee, Office365Users.MyProfile())
"Welcome " & varEmployee.DisplayName

Utilize as variáveis de contexto e as variáveis globais de forma sensata. Se o âmbito de uma variável for além de um único ecrã, use variáveis globais em vez de variáveis de contexto.

Demasiadas variáveis não utilizadas aumentam a utilização da memória e podem abrandar a inicialização da aplicação. Os recursos são alocados para estas variáveis, mesmo que não as use. As variáveis não utilizadas também adicionam complexidade à lógica da sua aplicação. Mantenha a sua Power App limpa e organizada para melhor desempenho e desenvolvimento mais fácil.

Otimizar coleções

As coleções são estruturas temporárias de storage de dados que usas para armazenar e manipular dados numa aplicação Power Apps. No entanto, as coleções podem causar sobrecarga de desempenho. Limite a utilização de coleções e use-as apenas quando necessário.

// Use this pattern
ClearCollect(colErrors, {Text: gblErrorText, Code: gblErrorCode});

// Do not use this pattern
Clear(colErrors);
Collect(colErrors, {Text: gblErrorText, Code: gblErrorCode});

Para contar registos numa coleção local, use CountIf em vez de Count(Filter()).

Considere esta abordagem ao trabalhar com coleções:

• Limite o tamanho e o número de coleções. Como as coleções são locais à aplicação, são armazenadas na memória do dispositivo móvel. Quanto mais dados as coleções armazenarem, ou quanto mais coleções usar, pior será o desempenho. Use a função ShowColumns para obter apenas colunas específicas. Adicione a função Filter para obter apenas os dados relevantes.

  A seguinte função de exemplo devolve todo o conjunto de dados:

  ClearCollect(colDemoAccount, Accounts);
  

  Compare esta função com o seguinte código, que retorna apenas registos e colunas específicas:

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

  Este exemplo devolve o seguinte conjunto de dados:

  

• Defina uma frequência de atualização da origem de dados. Se adicionar novos registos à coleção, atualize-a ou colecione-a para obter os registos novos ou alterados. Se vários utilizadores atualizarem a sua origem de dados, atualize a coleção para obter os registos novos ou alterados. Mais chamadas de atualização significam mais interação com o servidor.

Armazenar dados em cache em coleções e variáveis

A coleção é uma variável de tabela que armazena linhas e colunas de dados, não apenas um único item de dados. As coleções são úteis por dois motivos principais: agregar dados antes de enviá-los para a origem de dados e colocar em cache as informações para evitar consultas frequentes. Como as coleções correspondem à estrutura tabular da fonte de dados e do Power Apps, permitem-lhe interagir com os dados de forma eficiente, mesmo quando está offline.

// Clear the contents of EmployeeCollection, it already contains data
ClearCollect(
    colEmployee,
    {
        Id: "1",
        Name: "John",
        Department: "IT"
    },
    {
        Id: "2",
        Name: "Nestor",
        Department: "IT"
    }
)

Remover variáveis e suportes de dados não utilizados

Embora os media e variáveis não utilizados possam não afetar significativamente o desempenho da aplicação, é importante limpar a sua aplicação removendo qualquer média ou variável não utilizada.

• Os ficheiros multimédia não utilizados aumentam o tamanho da aplicação, o que pode abrandar os tempos de carregamento da aplicação.

• As variáveis não utilizadas aumentam a utilização da memória e podem abrandar ligeiramente a inicialização da aplicação. Os recursos são alocados para estas variáveis, mesmo que não sejam utilizadas. Demasiadas variáveis não utilizadas também podem tornar a lógica da aplicação mais complexa.

• Utilize o Verificador de Aplicações para rever multimédia e variáveis não utilizadas.

Otimizar ecrãs e controlos

Para otimizar ecrãs e controlos no Power Apps, considere as seguintes melhores práticas.

Evitar referências cruzadas entre controlos

Os controlos que referenciam controlos noutros ecrãs podem abrandar o carregamento e a navegação da aplicação. Esta abordagem pode obrigar a aplicação a carregar os outros ecrãs em vez de esperar que o utilizador vá para esse ecrã. Para resolver este problema, use variáveis, coleções e contexto de navegação para partilhar o estado entre ecrãs.

O verificador de aplicações no Power Apps Studio mostra controlos que são referenciados. Reveja o Verificador de Aplicações regularmente para corrigir este problema.

Na imagem seguinte, o controlo Galeria 1 é referenciado no Ecrã 2, Controlo Rótulo 2.

Se consultares um controlo do primeiro ecrã da aplicação no segundo ecrã, não há perda de desempenho porque o primeiro ecrã já está carregado. Este comportamento é na verdade benéfico porque a aplicação é declarativa em vez de usar variáveis.

Se consultares controlos que ainda não foram carregados, como o primeiro ecrã que faz referência a um controlo nomeado Label 3 do ecrã 3, a aplicação carrega esse ecrã na memória.

Ativar DelayOutput para controlos de texto

A definição DelayOutput , quando definida como verdadeira, regista a entrada do utilizador após um atraso de meio segundo. Este atraso é útil para adiar operações dispendiosas até que o utilizador termine de introduzir texto, como filtrar quando a entrada é usada noutras fórmulas.

Por exemplo, considere uma galeria cujos Itens são filtrados dependendo do que o utilizador insere no controlo TextInput:

• Se definir DelayOutput como "falso", que é o padrão, a galeria filtra logo que qualquer texto é introduzido. Se tiveres uma galeria com muitos itens, recarregar a galeria com alterações imediatamente abranda o desempenho. É melhor esperar. Este comportamento é prático quando se usa TextInput para uma cadeia de pesquisa ou a StartsWith função.

• Se definires o DelayOutput como verdadeiro, há um pequeno atraso antes de as alterações serem detetadas. Este atraso dá tempo para terminar a escrita. O atraso funciona bem com a propriedade TextInput.OnChange. Se tiveres ações ligadas a mudanças, não queres que sejam ativadas até terminares de escrever no campo.

Delegação e processamento do lado do servidor

A utilização de delegação e processamento do lado do servidor permite que a sua aplicação gere grandes conjuntos de dados de forma eficiente, descarregando operações para a fonte de dados.

Delegação

Delegação no Power Apps refere-se à capacidade da aplicação de transferir certas operações para a fonte de dados subjacente, em vez de processar as operações dentro do próprio Power Apps. Ao usar delegação no Power Apps, pode criar aplicações mais eficientes e escaláveis que têm bom desempenho mesmo em cenários envolvendo grandes conjuntos de dados. Esteja atento às limitações de delegação para fontes de dados e operações específicas, e desenhe a sua aplicação em conformidade para alcançar um desempenho ótimo.

Nota

Nem todas as funções são delegáveis. Saiba mais sobre delegação em Limitações de Consulta: Delegação e limites de consulta.

A delegação tem várias vantagens, como otimização de consultas e suporte para grandes conjuntos de dados. Além disso, se os dados de origem mudarem frequentemente, a delegação ajuda a manter os dados atualizados.

Reduzir chamadas à API para a fonte de dados

Por vezes, pode parecer conveniente criar coleções ao realizar junções na sua aplicação canvas. Considere o exemplo a seguir. No exemplo, existem duas tabelas: Motoristas e Camiões. O código cria uma coleção de motoristas e informações do camião, e para cada camião, chama o motorista que possui o camião.

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

Realizar tal junção na aplicação Canvas pode gerar muitas chamadas para a origem de dados, o que leva a tempos de carregamento lentos.

Uma abordagem melhor é:

// 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'
    )
)

No cenário em tempo real, pode reduzir os tempos de carregamento de cinco minutos para menos de 10 segundos corrigindo os dados na fonte.

Processamento do lado do servidor

Diferentes origens de dados, como SQL e Dataverse, permitem delegar o processamento de dados, como filtros e procuras, para a origem de dados. No SQL Server, pode criar vistas definidas por uma consulta. No Dataverse, pode criar plug-ins com pouco código para processar dados no lado do servidor e devolver apenas os resultados finais para a sua aplicação canvas.

Delegar o processamento de dados para o servidor pode melhorar o desempenho, reduzir o código do lado do cliente e tornar a sua aplicação mais fácil de manter.

Mais informações sobre plug-ins no Dataverse.

Otimizar padrões de dados de consulta

Otimizar a forma como a sua aplicação consulta os dados pode reduzir significativamente os tempos de carregamento e melhorar a capacidade de resposta geral.

Utilizar seleção de colunas explícita

A caraterística de Seleção Explícita de Colunas (ECS) está ativada por predefinição para todas as novas aplicações. Se não estiver ativado na tua aplicação, liga-a. O ECS reduz automaticamente o número de colunas recuperadas apenas para aquelas utilizadas na aplicação. Se a ECS não estiver ativada, pode obter mais dados do que precisa, o que pode afetar o desempenho. Por vezes, quando uma aplicação recebe dados através de coleções, a origem original de uma coluna pode ser perdida. O ECS elimina colunas se não conseguir determinar quais são usadas. Para forçar o ECS a manter uma coluna em falta, use a expressão ShowColumns Power Fx após uma referência de coleção ou num controlo.

Evite chamar o Power Automate para preencher uma coleção

Uma prática comum é usar o Power Automate para buscar e preencher coleções no Power Apps. Embora esta abordagem seja válida, existem situações em que poderá não ser a escolha mais eficiente. Chamar o Power Automate adiciona latência de rede e um custo de desempenho de 0,6 segundos para instanciar o fluxo do Power Automate.

O uso excessivo dos fluxos do Power Automate pode também levar a limites de execução e limitação. Avalie sempre as compensações entre latência de rede e custo de performance.

Eliminar o problema N+1

O problema N+1 é um problema comum em consultas de base de dados onde, em vez de obter todos os dados necessários numa única consulta, são feitas várias consultas adicionais para obter dados relacionados. Este problema pode levar a problemas de desempenho, pois cada consulta extra gera sobrecarga.

Uma chamada simples como esta para carregar uma coleção pode gerar N+1 chamadas para a fonte de dados:

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

No contexto das aplicações e galerias do tipo canvas, o problema N+1 pode surgir ao trabalhar com fontes de dados e galerias que exibem registos relacionados. O problema ocorre normalmente quando são feitas mais consultas para cada item apresentado na galeria, levando a um estrangulamento de desempenho.

Use objetos View no SQL Server para evitar problemas de consulta N+1, ou altere a interface de utilizador para evitar desencadear o cenário N+1.

Dataverse obtém automaticamente os dados necessários de tabelas relacionadas e pode selecionar as colunas a partir de tabelas relacionadas.

ThisItem.Account.'Account Name'

Se RelatedDataSource o tamanho for pequeno (menos de 500 registos), armazene-o numa coleção e use a coleção para conduzir o cenário de consulta Lookup (N+1).

Limite o tamanho da embalagem

Embora o Power Apps otimize o carregamento das aplicações, pode tomar medidas para reduzir a presença das suas aplicações. Uma pegada reduzida é especialmente importante para utilizadores de dispositivos antigos ou em locais onde há maior latência ou largura de banda reduzida.

• Avalie os conteúdos multimédia incorporados na sua aplicação. Se algo não for utilizado, elimine-o.

  Por exemplo, imagens embutidas podem ser demasiado grandes. Em vez de ficheiros PNG, veja se pode utilizar imagens SVG. Tem cuidado ao usar texto em imagens SVG porque a fonte tem de estar instalada no cliente. Uma solução alternativa quando precisa de mostrar texto é sobrepor uma etiqueta de texto sobre uma imagem.

• Avalie se a resolução é adequada para o fator de forma. A resolução para uma aplicação móvel não precisa de ser tão alta como a resolução para uma aplicação de ambiente de trabalho. Experimente para obter o equilíbrio certo entre qualidade e tamanho da imagem.

• Se tiver ecrãs não utilizados, elimine-os. Tenha cuidado para não eliminar quaisquer ecrãs ocultos que só os criadores de aplicações ou administradores utilizam.

• Avalie se está a tentar encaixar demasiados fluxos de trabalho numa única aplicação. Por exemplo, tem ecrãs de administração e de cliente na mesma aplicação? Em caso afirmativo, considere dividi-las em aplicações individuais. Esta abordagem também facilita que várias pessoas trabalhem nas aplicações ao mesmo tempo e limita o "raio de explosão" (quantidade de testes) quando as alterações de aplicação exigem uma passagem completa no teste.

Otimizar ForAll

A função ForAll em Power Apps é usada para iterar por uma tabela de registos e aplicar uma fórmula ou conjunto de fórmulas a cada registo. Embora a função em si seja versátil, o uso incorreto da função ForAll pode tornar rapidamente o seu app menos eficiente.

A ForAll função é uma função sequencial singular em vez de uma função concorrente. Assim, analisa apenas um registo de cada vez, obtém o resultado e depois continua para o registo seguinte até passar por todos os registos do seu âmbito.

Evita fazer ninhos ForAll. Esta prática pode levar a iterações exponenciais e afetar significativamente o desempenho.

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

Atualização em lote da base de dados

Pode usar o ForAll e o Patch para atualizar a base de dados em lote. No entanto, tenha cuidado ao usar a ordem de ForAll e Patch.

A seguinte função é a melhor abordagem, por exemplo:

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

Enquanto que a seguinte abordagem é menos eficiente:

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

Próximo passo

Tratamento de erros