Compartilhar via

Otimização de código

À medida que os aplicativos de tela evoluem para atender a diversos requisitos de negócios, o desafio de manter o desempenho ideal torna-se uma consideração crítica. As complexidades do tratamento de dados, design de interface do usuário e funcionalidade em aplicativos de tela exigem uma abordagem diferenciada para otimização de código.

À medida que os aplicativos de tela se tornam mais complexos, os desenvolvedores encontram desafios relacionados à recuperação de dados, complexidade da fórmula e velocidades de renderização. A necessidade de encontrar um equilíbrio entre funcionalidade robusta e interfaces de usuário responsivas destaca a importância de adotar uma abordagem sistemática para a otimização de código.

Otimização de fórmulas do Power Fx

Função With

A função With avalia uma fórmula para um único registro. A fórmula pode calcular um valor e/ou realização ações, como modificar dados ou trabalhar com uma conexão. Use With para melhorar a legibilidade de fórmulas complexas dividindo-a em subfórmulas nomeadas menores. Esses valores nomeados atuam como variáveis locais simples confinadas ao escopo do With. Usar With é preferencial em relação ao contexto ou às variáveis globais, pois ela é autocontida, fácil de entender e pode ser usada em qualquer contexto de fórmula declarativa. Saiba mais sobre a função With.

Uma captura de tela de uma fórmula do Power Fx que usa a função With

Função Concurrent

A função Concurrent permite que várias fórmulas especificadas na mesma propriedade sejam avaliadas ao mesmo tempo se tiverem conector ou chamadas do Dataverse. Normalmente, várias fórmulas são avaliadas pelo encadeamento delas com o operador ; (ponto-e-vírgula), que avalia cada uma sequencialmente. Com a função Concurrent, o aplicativo avaliará todas as fórmulas dentro de uma propriedade simultaneamente, mesmo depois de usar o operador ;. Essa simultaneidade ajuda os usuários a esperar menos pelo mesmo resultado. Quando as chamadas de dados não forem iniciadas até que as chamadas anteriores sejam concluídas, o aplicativo precisará aguardar a soma de todos os tempos de solicitação. Se as chamadas de dados forem iniciadas ao mesmo tempo, o aplicativo precisará aguardar apenas pelo tempo de solicitação mais longo. Saiba mais sobre a função Concurrent.

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

Função Coalesce

A função Coalesce avalia seus argumentos na ordem e retorna o primeiro valor que não está em branco ou uma cadeia de caracteres vazia. Use esta função para substituir um valor em branco ou uma cadeia de caracteres vazia por um valor diferente, sem alterar os valores de cadeia de caracteres não em branco e não vazios. Se todos os argumentos forem em branco ou cadeias de caracteres vazias, então a função retornará em branco, tornando Coalesce uma boa maneira de converter cadeias de caracteres vazias em valores em branco.

Por exemplo: 

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

Requer que o valor 1 e o valor 2 sejam avaliados duas vezes. Essa função pode ser reduzida para:

Coalesce(value1, value2)

Função IsMatch

A função IsMatch testa se uma cadeia de caracteres de texto corresponde a um padrão que pode incluir caracteres 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 do Seguro 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 caractere 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 aplicativo OnStart

A propriedade OnStart para aplicativos cavas desempenha um papel crucial na definição de ações que ocorrem quando o aplicativo é iniciado. Essa propriedade permite que os desenvolvedores de aplicativos executem tarefas de inicialização globais, configurem variáveis e executem ações que devem acontecer apenas uma vez durante o processo de inicialização do aplicativo. Entender e utilizar efetivamente a propriedade OnStart é essencial para criar aplicativos de tela responsivos e eficientes.

Uma abordagem recomendada é simplificar a função App.OnStart migrando configurações de variáveis para fórmulas nomeadas. As fórmulas nomeadas, especialmente aquelas configuradas no início do ciclo de vida do aplicativo, mostram-se vantajosas. Essas fórmulas lidam com a inicialização de variáveis com base em chamadas de dados, fornecendo uma estrutura mais limpa e organizada para seu código. Mais detalhes Criar aplicativos de tela grandes e complexos - Power Apps | Microsoft Learn.

Observação

A propriedade OnStart é Imperativa. É uma lista ordenada de trabalho que precisa ser feito antes que a primeira tela seja mostrada. Por ser tão específico não apenas sobre o que precisa ser feito, mas também quando esse trabalho deve ser feito com base na ordem, ele limita o reordenamento e adiamento de otimizações que poderiam ser feitas de outra forma.

Tela inicial

Se App.OnStart contiver uma chamada de função Navigate, mesmo que esteja em uma função If e raramente chamada, devemos concluir a execução do Aplicativo OnStart antes de apresentarmos a primeira tela do aplicativo.  App.StartScreen é a nova maneira declarativa de indicar qual tela deve ser mostrada primeiro, que não bloqueia otimizações.

A configuração da propriedade StartScreen mostra a primeira tela antes da conclusão de App.OnStart. App.StartScreen declares qual objeto de tela deve ser mostrado primeiro sem exigir nenhum pré-processamento.

Então, em vez de escrever código como:

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

Altere o código para:

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

Consulte <https://Power Apps.microsoft.com/en-us/blog/app-startscreen-a-new-declarative-alternative-to-navigate-in-app-onstart/> para obter mais detalhes.

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 concorrência na qual StartScreen não é aplicada corretamente. Observação: não devemos ter dependências entre StartScreen e OnStart. Bloqueamos a referência a variáveis globais no StartScreen, mas podemos fazer referência a uma fórmula nomeada, que por sua vez faz referência a uma variável global e que pode causar uma condição de concorrência na qual StartScreen não é aplicada corretamente.

Fórmulas nomeadas

As fórmulas nomeadas são estáticas ou constantes que podem ser definidas na seção App.Formulas. Depois de declaradas em App.Formulas, elas podem ser usados em qualquer lugar no aplicativo e seu valor sempre permanece atualizado. As Fórmulas Nomeadas no Power Apps ativam a definição de valores ou conjuntos de valores que são gerenciados e atualizados automaticamente pela plataforma. Essa funcionalidade transfere a responsabilidade do cálculo de valor e manutenção do desenvolvedor para o Power Apps, agilizando o processo de desenvolvimento. As Fórmulas Nomeadas no Power Apps são uma funcionalidade avançada que pode melhorar significativamente o desempenho e a capacidade de manutenção do aplicativo.

As fórmulas nomeadas também podem abordar a declaração de temas de aplicativo. Em muitos casos em que aplicativos empresariais são criados, queremos que o aplicativo tenha temas comuns para dar aparência e experiência do usuário consistentes. Para criar um tema, existem 10s e 100s de variáveis que precisam ser declaradas no aplicativo OnStart. Isso aumentou o comprimento do código e o tempo de inicialização do aplicativo.

Os controles modernos também podem ajudar significativamente com a criação de temas e ajudar a reduzir a lógica escrita pelo cliente para lidar com os temas. Controles modernos estão em versão preliminar.

Por exemplo, o código a seguir no App.OnStart pode ser movido para App.Formulas, reduzindo assim o tempo de inicialização em declarações de variáveis globais.

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

O código pode ser movido para App.Formulas da seguinte maneira:

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 é a configuração interna Lookups. Aqui, é necessária uma alteração em uma fórmula de pesquisa para obter as informações do usuário, em vez de Office 365 Dataverse. Há apenas um lugar em que a alteração é necessária, sem alterar o código em todos os lugares.

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

Essas fórmulas incorporam a essência do cálculo. Elas articulam o processo para determinar UserEmail, UserInfo, UserTitle e UserPhone com base em outros valores. Essa lógica é encapsulada, permitindo ampla utilização em todo o aplicativo, e pode ser modificada em um único local. A adaptabilidade se estende à alternância da tabela Usuários do Dataverse para o conector do Office 365 sem necessidade de alterações em fórmulas espalhadas pelo aplicativo.

Outra abordagem é otimizar countRows.

varListItems = CountRows(SampleList)

Com a função Set, a variável varListItems terá que ser inicializada com a contagem inicial de linhas na lista de amostras e definida novamente depois que os itens da lista forem adicionados ou removidos. Com as fórmulas Nomeadas, à medida que os dados mudam, as variáveis varListitems são atualizadas automaticamente.

As Fórmulas Nomeadas na propriedade App.Formulas fornecem uma abordagem mais flexível e declarativa para gerenciar valores e cálculos em todo o aplicativo, oferecendo vantagens em termos de independência de tempo, atualizações automáticas, capacidade de manutenção e definições imutáveis em comparação com a dependência exclusiva App.OnStart.

Aspecto Fórmulas nomeadas (App.Formulas) App.OnStart
Independência de Tempo As fórmulas estão disponíveis instantaneamente, podem ser calculadas em qualquer ordem. As variáveis podem introduzir dependências de tempo, impactando a disponibilidade.
Atualizações Automáticas As fórmulas são atualizadas automaticamente quando as dependências mudam. As variáveis são definidas uma vez durante a inicialização; as atualizações manuais podem ser necessárias.
Capacidade de Manutenção Fórmulas centralizadas em um único local melhoram a capacidade de manutenção. Variáveis dispersas podem exigir localização e atualização em vários lugares.
Definições Imutáveis As definições de fórmula em App.Formulas são imutáveis. Os valores das variáveis podem ser suscetíveis a mudanças acidentais.

Funções definidas pelo usuário

Funções Definidas pelo Usuário é uma funcionalidade experimental do Power Apps Authoring Studio que permite aos usuários criar sua própria função personalizada.

Para usar esse recurso, em configurações experimentais, selecione Novo mecanismo de análise e Função definida pelo usuário (UDFs)

Defina uma fórmula de App.Formulas da seguinte maneira:

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

O código funciona assim:

  • FunctionName é usado para invocar a função

  • Parameteré o nome da entrada. Um ou mais entradas são permitidas

  • DataType é um argumento passado para a função e deve corresponder a este tipo de dados. Os tipos de dados disponíveis incluem Booliano, Cor, Data, Datetime, GUID, Hiperlink, Texto, Hora, Objeto sem Tipo

  • OutputDataType é o tipo de dados no qual a saída da função estará

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

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

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

Chame a função definida a partir do controle de texto/rótulo.

calcAreaOfCircle(Int(*TextInput1*.Text))

Observação

Este é um recurso experimental e está sujeito a alterações. Alguns tipos de dados, como registros e filtros, ainda não são compatíveis.

Otimizar variáveis

As variáveis são usadas para definir e configurar valores locais e globais a serem usados em qualquer lugar nos aplicativos. Embora sejam convenientes, muitas delas podem fazer com que o aplicativo seja menos otimizado.

O exemplo a seguir demonstra a configuração de uma variável para cada atributo de um objeto, que requer o uso 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);

Uma abordagem mais otimizada é usar a propriedade quando for necessário:

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

Use variáveis de contexto e variáveis globais com sabedoria. Se o escopo de uma variável se expandir além de uma única tela, considere o uso de variáveis globais, em vez de variáveis de contexto.

Muitas variáveis não utilizadas contribuem para o aumento do uso de memória e inicialização de aplicativos um pouco mais lenta. Isso ocorre porque os recursos são alocados para essas variáveis, mesmo que eles não sejam usados ativamente. Muitas variáveis não utilizadas também podem levar à complexidade geral da lógica do aplicativo. Embora o impacto de variáveis não utilizadas possa não ser grave, é uma boa prática manter um Power App limpo e bem organizado para garantir o desempenho ideal e a facilidade de desenvolvimento.

Otimizar coleções

As coleções são estruturas temporárias de armazenamento de dados que podem ser usadas para armazenar e manipular dados em um aplicativo Power Apps. No entanto, há uma linha tênue sobre quando as coleções podem levar à sobrecarga de desempenho. Portanto, limite o uso de coleções. Tente usá-las apenas quando forem necessárias.

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

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

Para contar os registros em uma coleção local, use CountIf, em vez de Count(Filter()).

Considere esta orientação ao trabalhar com coleções:

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

A função de exemplo a seguir retorna o conjunto de dados inteiro.

ClearCollect(colDemoAccount, Accounts);

Compare com o código abaixo que retornará apenas os registros e colunas específicos:

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

O código de exemplo retorna este conjunto de dados:

Uma captura de tela de um conjunto de dados com uma tabela chamada colAcc e duas colunas com dados, cidade_endereço1 e nome

Definir uma frequência de atualização da fonte de dados. Se você estiver adicionando novos registros à coleção, precisará atualizá-la ou coletá-la para obter os registros novos ou alterados na coleção. Se a sua fonte de dados for atualizada por vários usuários, você precisará atualizar a coleção para obter os registros 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

Uma coleção, essencialmente uma variável de tabela, é distinta, pois armazena linhas e colunas de dados em vez de um único item de dados. Sua utilidade reside em duas finalidades principais: em primeiro lugar, para agregar dados antes de transmiti-los para a fonte de dados e, em segundo lugar, para armazenar informações em cache, eliminando a necessidade de consultas frequentes à fonte de dados. À medida que as coleções se alinham com a estrutura tabular da fonte de dados e do Power Apps, elas oferecem um meio eficiente de interagir com os dados, mesmo em cenários 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 mídia não utilizadas

Embora a mídia e as variáveis não utilizadas não possam criar um impacto drástico no desempenho do aplicativo, é importante limpar seu aplicativo de qualquer mídia ou variável não utilizada.

  • Arquivos de mídia não utilizados contribuem para o aumento geral no tamanho do aplicativo. Isso pode levar a tempos de carregamento do aplicativo mais lentos.

  • Variáveis não utilizadas contribuem para o aumento do uso de memória e inicialização de aplicativos um pouco mais lenta. Isso ocorre porque os recursos são alocados para essas variáveis, mesmo que eles não sejam usados ativamente. Além disso, muitas variáveis ​​não utilizadas podem levar à complexidade geral da lógica do aplicativo.

  • Use o Verificador de Aplicativo para analisar mídias e variáveis não utilizadas.

Otimizar telas e controles

Evitar controles de referência cruzada

Os controles que fazem referência a controles em outras telas podem tornar o carregamento e a navegação do aplicativo mais lentos. Isso pode forçar o aplicativo a carregar as outras telas imediatamente, em vez de esperar até que o usuário navegue até essa tela. Para resolver esse problema, use variáveis, coleções e contexto de navegação para compartilhar o estado entre telas.

O verificador de aplicativo do Power Apps no estúdio de criação mostra os controles que fazem referências cruzadas. Revise o Verificador de aplicativo regularmente para resolver esse problema.

Veja um exemplo de controles com referências cruzadas. Na imagem abaixo os controles da Galeria 1 têm referência cruzada na Tela 2, controle de Rótulo 2.

Uma captura de tela do Power Apps Studio mostrando um controle com referência cruzada

Se você referenciar um controle desde a primeira tela no aplicativo na segunda tela, não haverá impacto no desempenho, pois a primeira tela já foi carregada e isso pode realmente ser uma coisa boa como o aplicativo declarativo, em vez de usar variáveis.

Se você fizer referência a controles que ainda precisam ser carregados, como a primeira tela que faz referência a um controle nomeado Label 3 na tela 3, será necessário carregar a tela na memória.

Habilitar DelayOutput para controles de texto

Configuração de saída de atraso – quando definida como verdadeira, a entrada do usuário é registrada após um atraso de meio segundo. É útil para atrasar operações caras até que o usuário preencha o texto de entrada, como filtragem de entrada quando é usado em outras fórmulas.

Por exemplo, para uma Galeria cujos Itens são Filtrados dependendo do que é inserido no controle TextInput:

  • Com DelayOutput definido como falso, que é o padrão, a Galeria é filtrada assim que qualquer texto é digitado. Se você tiver uma galeria com muitos itens, recarregar a Galeria com alterações imediatamente diminui o desempenho; seria mais vantajoso esperar um pouco. Isso é prático quando você está usando o TextInput para uma cadeia de caracteres de pesquisa (Consulte Pesquisar ou as novas funções StartsWith).

  • Com DelayOutput definido como verdadeiro, há um segundo atraso antes que as alterações sejam detectadas. Isso é feito para dar tempo de você terminar de digitar o que você quer. O atraso funciona bem quando usado para auxiliar a propriedade TextInput.OnChange. Se você tiver ações vinculadas a alterações, não deseja que elas sejam acionadas até que tudo o que deseja seja digitado no campo.

Delegação e processamento do servidor

Delegação

A delegação no Power Apps é um conceito que se refere à capacidade do aplicativo de descarregar determinadas operações para a fonte de dados subjacente, em vez de processar as operações dentro do próprio Power Apps. Usando a delegação no Power Apps, os desenvolvedores podem criar aplicativos mais eficientes e escalonáveis com bom desempenho, mesmo em cenários que envolvem grandes conjuntos de dados. É importante estar ciente das limitações de delegação para fontes de dados e operações específicas e projetar os aplicativos adequadamente para atingir o desempenho ideal.

![OBSERVAÇÃO] Nem todas as funções são delegáveis. Consulte Noções básicas sobre Delegação para saber mais sobre delegação.

A delegação tem várias vantagens, como Otimização de consulta, e adiciona suporte para grandes conjuntos de dados. Além disso, se os dados de origem forem alterados com frequência, a delegação ajudará a manter os dados atualizados.

Reduza as chamadas de API para fonte de dados

Às vezes, pode ser conveniente seguir práticas de codificação, como a criação de coleções realizando junções no aplicativo de tela. Consulte o código abaixo:

Neste exemplo, existem duas tabelas, Motoristas e Caminhões. O desenvolvedor escreve o código para criar uma coleção de detalhes de motoristas e caminhões e, para cada caminhão, ele chama os motoristas proprietários dos caminhões.

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

A execução dessas operações de junção de dentro do aplicativo de tela pode gerar várias chamadas para fonte de dados levando a tempos de carregamento muito 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 de tempo real, é possível reduzir os tempos de carregamento de 5 minutos para menos de 10 segundos apenas corrigindo os dados no nível fonte de dados.

Processamento do servidor

Fontes de dados diferentes, como SQL Dataverse permitem delegar o processamento de dados, como Filtro e Pesquisas, à fonte de dados. No SQL Server, os usuários podem criar modos de exibição, que têm conteúdo definido por uma consulta. Da mesma forma, com o Dataverse os usuários podem criar plug-ins low-code para escrever lógica para processamento de dados no servidor e só obter os resultados finais em aplicativos de tela.

Delegar o processamento de dados ao servidor pode melhorar o desempenho geral, reduzir o código no lado do cliente e ser fácil de manter.

Saiba mais sobre plug-ins no Dataverse.

Otimizar padrões de dados de consulta

Usar seleção de coluna explícita

O recurso Seleção de Coluna Explícita (ECS) permanece habilitado por padrão para todos os novos aplicativos. Se ele não estiver habilitado para o aplicativo, você deverá fazer isso. O ECS reduz automaticamente o número de colunas recuperadas apenas àquelas usadas no aplicativo. Se o ECS não estiver habilitado, você poderá recuperar mais dados do que precisa, o que pode afetar o desempenho. Às vezes, quando um aplicativo extrai dados por meio de coleções, a linhagem original ou a fonte de uma coluna pode ser perdida. Não sabemos se ele está sendo usado e o descartamos usando ECS. Você normalmente pode forçar o ECS a trabalhar para uma coluna ausente usando a expressão ShowColumns após uma referência de coleção ou usando-a em um controle.

Evitar 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 essa abordagem seja válida, há situações em que ela pode não ser a escolha mais eficiente. A chamada do Power Automate vem com uma sobrecarga de latência de rede e adiciona um custo de desempenho de 0,6 segundo para instanciar o fluxo do Power Automate.

O uso excessivo de fluxos do Power Automate também pode conduzir a limites de execução e limitação. Portanto, sempre avalie os trade-offs entre latência de rede e custo de desempenho.

Elimine o problema N+1

O problema N+1 é um problema comum em consultas de banco de dados em que, em vez de buscar todos os dados necessários em uma única consulta, várias consultas extras são feitas para recuperar dados relacionados. Isso pode levar a problemas de desempenho, pois cada consulta extra gera sobrecarga.

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

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

No contexto de aplicativos de tela e galerias, o problema N+1 pode surgir ao trabalhar com fontes de dados e galerias que exibem registros relacionados. O problema geralmente ocorre quando mais consultas são feitas para cada item exibido na galeria, levando a um gargalo de desempenho.

Use Exibir objetos no SQL Server para evitar o problema de consulta N+1 ou altere a interface do usuário para evitar o acionamento do cenário N+1.

O Dataverse busca automaticamente os dados necessários das tabelas relacionadas e você pode selecionar as colunas das tabelas relacionadas.

ThisItem.Account.'Account Name'

Se o tamanho de RelatedDataSourcfor pequeno (<500 registros), você poderá armazená-lo em cache em uma coleção e usar a coleção para conduzir o cenário de consulta Pesquisa (N+1).

Limitando o tamanho do pacote

Embora o Power Apps faça muito para otimizar o carregamento do aplicativo, você pode tomar medidas para reduzir o volume de seus aplicativos. Um volume ocupado reduzido é especialmente importante para usuários de dispositivos mais antigos ou usuários em localidades onde há maior latência ou largura de banda reduzida.

  • Avalie as mídias incorporadas em seu aplicativo. Se algo não for usado, exclua-o.

  • As imagens incorporadas podem ser muito grandes. Em vez de arquivos PNG, veja se você pode usar imagens SVG. No entanto, tenha cuidado ao usar texto em imagens SVG, porque a fonte usada precisará ser instalada no cliente. Uma ótima solução alternativa quando você precisa mostrar texto é sobrepor um rótulo de texto sobre uma imagem.

  • Avalie se a resolução é apropriada para o fator forma. A resolução de um aplicativo móvel não precisa ser tão alta quanto a resolução de um aplicativo de desktop. Experimente obter o equilíbrio certo entre qualidade e tamanho da imagem.

  • Se você tiver telas não utilizadas, exclua-as. Tenha cuidado para não excluir nenhuma tela oculta que só os criadores de aplicativos ou administradores usam.

  • Avalie se você está tentando encaixar muitos fluxos de trabalho em um aplicativo. Por exemplo, você tem telas de administrador e telas de cliente no mesmo aplicativo? Em caso afirmativo, divida-as em aplicativos individuais. Essa abordagem também facilitará o trabalho de várias pessoas nos aplicativos ao mesmo tempo e limitará o "raio de explosão" (quantidade de testes) quando as alterações no aplicativo exigirem uma aprovação completa no teste.

Otimizar ForAll

A função ForAll no Power Apps é usada para percorrer uma tabela de registros e aplicar uma fórmula ou conjunto de fórmulas a cada registro. Embora a função em si seja versátil, o uso indevido da função ForAll pode rapidamente tornar seu aplicativo menos eficiente.

A função ForAll é uma função sequencial singular, em vez de uma função simultânea. Portanto, ela examina apenas um registro por vez, obtém o resultado e continua para o próximo, até que tenha passado por todos os registros em seu escopo.

Evite o Aninhamento de ForAll a todo custo. Isso pode levar a iterações exponenciais e afetar significativamente o desempenho.

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

Atualizações em lote para o Banco de dados

ForAll + Patch pode ser uma abordagem para atualizar em lote o banco de dados. No entanto, tenha cuidado ao usar a ordem de For All e Patch.

Seguinte função:

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

Tem melhor desempenho que:

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

Próxima etapa

Diretrizes para tratamento de erros