Optimización de código

A medida que as aplicacións de lenzo evolucionan para satisfacer as diferentes necesidades empresariais, manter o rendemento óptimo é fundamental. A xestión de datos, o deseño da interface de usuario e a funcionalidade da aplicación requiren unha coidadosa estratexia de optimización do código.

A medida que as aplicacións canvas se fan máis complexas, podes ter problemas coa recuperación de datos, a complexidade das fórmulas e a velocidade de renderizado. Para equilibrar unha funcionalidade sólida cunha interface de usuario responsiva, usa un enfoque sistemático na optimización do código.

Optimización da fórmula Power Fx

Esta sección ofrece boas prácticas para optimizar fórmulas de Power Fx.

Con función

A función With avalía unha fórmula para un único rexistro. A fórmula pode calcular un valor ou realizar accións, como modificar datos ou traballar cunha conexión. Usa With para facilitar a lectura de fórmulas complexas dividíndoas en subfórmulas máis pequenas con nome. Estes valores con nome actúan como simples variables locais limitadas ao ámbito de With. With é mellor que as variables de contexto ou globais porque é autosuficiente, fácil de entender e funciona en calquera contexto de fórmula declarativa. Aprende máis sobre a función With.

Captura de pantalla dunha fórmula de Power Fx que usa a función Con.

Función concorrente

A Concurrent función permite avaliar múltiples fórmulas na mesma propiedade ao mesmo tempo se teñen chamadas a conector ou Dataverse. Normalmente, varias fórmulas avalíanse ao mesmo tempo cando se encadean co operador ; (punto e coma). Con Concurrent, a aplicación avalía todas as fórmulas dunha propiedade ao mesmo tempo, mesmo despois de usar o operador ; . Esta concorrencia significa que os usuarios esperan menos tempo polos resultados. Cando as chamadas de datos non comezan ata que rematan as chamadas anteriores, a aplicación agarda a suma de todos os tempos de solicitude. Se as chamadas de datos comezan ao mesmo tempo, a aplicación só agarda o tempo de solicitude máis longo. Aprende máis sobre a función Concorrente.

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

Función de coalescia

A función Coalesce avalía os seus argumentos por orde e devolve o primeiro valor que non estea en branco ou sexa unha cadea de caracteres baleira. Use esta función para substituír un valor en branco ou unha cadea baleira por un valor diferente, pero deixando os valores das cadeas que non sexan en branco nin baleiras sen modificar. Se todos os argumentos son en branco ou cadeas baleiras, a función devolve un valor en branco. Coalesce é unha boa maneira de converter cadeas baleiras en valores en branco. Aprende máis sobre a función Coalesce.

Este exemplo require value1 e value2 debe ser avaliado dúas veces:

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

Esta función pódese reducir a:

Coalesce(value1, value2)

Función IsMatch

A función IsMatch comproba se unha cadea de texto coincide cun patrón composto por caracteres ordinarios, patróns predefinidos ou unha expresión regular. Aprende máis sobre a función IsMatch.

Por exemplo, esta fórmula coincide cun número da Seguridade Social dos Estados Unidos:

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

Explicación da expresión regular:

  • \\d Coincide con calquera díxito (0-9).

  • {3} Especifica que o patrón de díxitos precedente (\d) debe aparecer exactamente tres veces.

  • - Coincide co carácter de guión.

  • {2} Especifica que o patrón de díxitos precedente (\d) debe aparecer exactamente dúas veces.

  • {4} Especifica que o patrón de díxitos precedente (\d) debe aparecer exactamente catro veces.

Máis exemplos de IsMatch:

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

Optimizar a aplicación OnStart

A OnStart propiedade das aplicacións canvas xoga un papel crucial na definición das accións que se producen cando a aplicación se lanza. Esta propiedade permite aos desenvolvedores de aplicacións executar tarefas de inicialización global, configurar variables e realizar accións que só deberían ocorrer unha vez durante o proceso de inicio da aplicación. Comprende e usa eficazmente a OnStart propiedade para crear aplicacións de canvas eficientes e responsivas.

Simplifica a App.OnStart función migrando configuracións de variables a fórmulas nomeadas. As fórmulas nomeadas, especialmente as configuradas ao principio do ciclo de vida da aplicación, son vantaxosas. Estas fórmulas xestionan a inicialización de variables baseadas en chamadas de datos, proporcionando unha estrutura máis limpa e organizada para o teu código. Aprende máis en Construír aplicacións de canvas grandes e complexas.

Nota

A OnStart propiedade é imprescindible. É unha lista ordenada de traballos que hai que facer antes de que apareza a primeira pantalla. Como é tan específico non só sobre o que hai que facer, senón tamén sobre cando ese traballo debe facerse segundo a orde, limita as optimizacións de reordenación e adiamento que doutro xeito poderían facerse.

Pantalla de inicio

Se App.OnStart contén unha Navigate chamada a unha función, aínda que estea nunha If función e raramente se chame, a aplicación debe completar a execución antes App.OnStart de mostrar a primeira pantalla da aplicación.  App.StartScreen é unha forma declarativa de indicar que pantalla debe mostrarse primeiro, e non bloquea as optimizacións.

Ao definir a propiedade StartScreen , móstrase a primeira pantalla antes de que App.OnStart remate. App.StartScreen declara que obxecto de pantalla mostrar primeiro sen requirir ningún preprocesamento.

En lugar de escribir código como:

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

Cambia o código a:

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

Máis información: App.StartScreen: unha alternativa declarativa a Navegar en App.OnStart.

Aviso

Evitar dependencias entre StartScreen e OnStart. Referenciar unha fórmula nomeada que á súa vez referencia unha variable global pode causar unha condición de raza na que StartScreen non se aplica correctamente.

Non crees dependencias entre StartScreen e OnStart. Mentres a aplicación bloquea a referencia a variables globais en StartScreen, podes referenciar unha fórmula nomeada, que á súa vez referencia unha variable global. Este enfoque podería causar unha condición de carreira na que non se StartScreen aplica correctamente.

Fórmulas con nome

As fórmulas nomeadas son estáticas ou constantes que poden definirse en App.Formulas. Unha vez declarados en App.Formulas, poden usarse en calquera lugar da aplicación, e os seus valores sempre se manteñen actualizados. As fórmulas nomeadas en Power Apps permítenche definir valores ou conxuntos de valores que a plataforma xestiona e actualiza automaticamente. Esta funcionalidade traslada a responsabilidade do cálculo e mantemento do valor do desenvolvedor a Power Apps, simplificando o proceso de desenvolvemento. As fórmulas nomeadas en Power Apps son unha función poderosa que pode mellorar significativamente o rendemento e a mantebilidade das aplicacións.

As fórmulas nomeadas tamén axudan á hora de declarar temas de aplicacións. Cando construís aplicacións empresariais, a miúdo queres que a aplicación teña temas comúns que proporcionen unha aparencia e experiencia de usuario consistentes. Para crear un tema, necesitas declarar decenas a centos de variables en App.OnStart. Esta declaración aumenta a lonxitude do código e o tempo de inicialización da aplicación.

Os controis modernos tamén poden axudar significativamente coa creación de temas e axudar a reducir a lóxica escrita polo cliente para xestionala. Os controis modernos están actualmente en versión preliminar.

Por exemplo, podes mover o seguinte código App.OnStart a App.Formulas, o que reduce o tempo de inicio nas declaracións globais de variables.

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

Podes mover o código ao App.Formulas seguinte xeito:

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 é en establecer Lookups. Aquí, é necesario un cambio nunha fórmula Lookup para obter a información do usuario de Office 365 en lugar de Dataverse. Só tes que facer o cambio nun lugar, sen cambiar o código en todas partes.

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 encarnan a esencia do cálculo. Articulan o proceso para determinar UserEmail, UserInfo, UserTitle e UserPhone en función doutros valores. Esta lóxica está encapsulada, o que permite un uso xeneralizado en toda a aplicación e pódese modificar nunha única localización. A adaptabilidade esténdese a cambiar da táboa Dataverse Users ao conector Office 365 sen necesidade de modificar as fórmulas dispersas pola aplicación.

Outra estratexia é optimizar countRows.

varListItems = CountRows(SampleList)

Coa Set función, debes inicializar a variable varListItems co número inicial de filas na lista de exemplo e configurala de novo despois de engadir ou eliminar os elementos da lista. Coas fórmulas nomeadas, a medida que cambian os datos, a varListItems variable actualízase automaticamente.

As fórmulas nomeadas na App.Formulas propiedade proporcionan un enfoque máis flexible e declarativo para xestionar valores e cálculos ao longo da aplicación. Ofrecen vantaxes en termos de independencia temporal, actualizacións automáticas, mantenibilidade e definicións inmutables en comparación con confiar só en App.OnStart.

Aspecto Fórmulas nomeadas (App.Formulas) Aplicación.OnStart
Independencia temporal As fórmulas están dispoñibles instantaneamente e poden calcularse en calquera orde. As variables poden introducir dependencias temporales que afectan á dispoñibilidade.
Actualizacións automáticas As fórmulas actualízanse automaticamente cando cambian as dependencias. As variables configúranse unha vez durante o arranque; Poden ser necesarias actualizacións manuais.
Mantemento As fórmulas centralizadas nun só lugar melloran a mantenibilidade. As variables dispersas poden requirir atopar e actualizar en varios lugares.
Definicións inmutables As definicións de fórmulas en App.Formulas son inmutables. Os valores das variables poden ser susceptibles a cambios accidentais.

Funcións definidas polo usuario

Funcións definidas polo usuario en Power Apps Studio permítenche crear as túas propias funcións personalizadas.

Define unha fórmula baixo App.Formulas do seguinte xeito:

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

O código funciona do seguinte xeito:

  • FunctionName invoca a función.

  • Parameter é o nome da entrada. Podes incluír unha ou máis entradas.

  • DataType é o tipo de dato co que o argumento pasado á función debe coincidir. Os tipos de datos dispoñibles inclúen Booleano, Cor, Data, Data, Dinámico, GUID, Hipervínculo, Texto e Hora.

  • OutputDataType é o tipo de datos para a saída da función.

  • Formula é a saída da función.

Úsase IfError para implementar o manexo de erros dentro da función definida:

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

Chama á función definida desde un control de texto ou etiqueta.

calcAreaOfCircle(Int(*TextInput1*.Text))

Optimizar variables

As variables definen e establecen os valores locais e globais que usas en toda a aplicación. Aínda que son cómodas, usar demasiadas variables pode facer que a túa aplicación sexa menos eficiente.

O seguinte exemplo demostra como definir unha variable para cada atributo dun obxecto, o que require o uso de Set para cada propiedade.

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

Unha estratexia máis eficiente é usar a propiedade só cando a necesitas:

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

Emprega con sabedoría as variables de contexto e as variables globais. Se o ámbito dunha variable vai máis alá dunha única pantalla, use variables globais en lugar de variables de contexto.

Demasiadas variables sen usar aumentan o uso da memoria e poden ralentizar a inicialización da aplicación. Os recursos asígnanse para estas variables mesmo se non as usas. As variables non utilizadas tamén engaden complexidade á lóxica da túa aplicación. Mantén a túa Power App limpa e organizada para un mellor rendemento e un desenvolvemento máis sinxelo.

Optimizar coleccións

As coleccións son estruturas temporais de storage de datos que usas para gardar e manipular datos nunha aplicación Power Apps. Con todo, as coleccións poden causar sobrecarga de rendemento. Limita o uso das coleccións e úsaas só cando sexa necesario.

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

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

Para contar rexistros nunha colección local, use CountIf en lugar de Count(Filter()).

Considera este enfoque ao traballar con coleccións:

  • Limitar o tamaño e o número de coleccións. Dado que as coleccións son locais para a aplicación, almacénanse na memoria do dispositivo móbil. Cantas máis coleccións de datos conteñan ou cantas máis coleccións empregue, peor será o rendemento. Usa a función ShowColumns para obter só columnas específicas. Engade a función Filter para obter só os datos relevantes.

    A seguinte función de exemplo devolve todo o conxunto de datos:

    ClearCollect(colDemoAccount, Accounts);

    Compare esta función co seguinte código, que só devolve rexistros e columnas específicas:

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

    Este exemplo devolve o seguinte conxunto de datos:

    Captura de pantalla dun conxunto de datos cunha táboa chamada colAcc e dúas columnas, address1_city e nome.

  • Definir unha frecuencia de actualización da fonte de datos. Se engades novos rexistros á colección, actualízaa ou recompílaa para obter os rexistros novos ou modificados. Se varios usuarios actualizan a túa fonte de datos, actualiza a colección para obter os rexistros novos ou modificados. Máis chamadas de actualización significan máis interacción co servidor.

Almacenar datos na caché en coleccións e variables

Unha colección é unha variable de táboa que almacena filas e columnas de datos, non só un único elemento de datos. As coleccións son útiles por dúas razóns principais: agregar datos antes de envialos á fonte de datos e almacenar información na caché para evitar consultas frecuentes. Como as coleccións coinciden coa estrutura tabular da fonte de datos e Power Apps, permítenche interactuar cos datos de forma eficiente, mesmo cando estás fóra de liña.

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

Eliminar as variables e os medios non utilizados

Aínda que os medios e variables non usados poden non afectar significativamente ao rendemento da aplicación, é importante limpar a túa aplicación eliminando calquera medio ou variable non utilizada.

  • Os ficheiros multimedia non utilizados aumentan o tamaño da aplicación, o que pode ralentizar os tempos de carga das aplicacións.

  • As variables non utilizadas aumentan o uso da memoria e poden ralentizar lixeiramente a inicialización da aplicación. Os recursos asígnanse para estas variables mesmo se non se usan. Demasiadas variables sen usar tamén poden facer que a lóxica da aplicación sexa máis complexa.

  • Usa o Verificador de aplicacións para revisar os medios e as variables non utilizados.

Optimizar pantallas e controis

Para optimizar pantallas e controis en Power Apps, considera as seguintes boas prácticas.

Evitar controis de referencia cruzada

Os controis que fan referencia a controis doutras pantallas poden ralentizar a carga e a navegación das aplicacións. Este enfoque pode obrigar á aplicación a cargar as outras pantallas en lugar de esperar a que o usuario vaia a esa pantalla. Para resolver este problema, usa variables, coleccións e contexto de navegación para compartir estado entre pantallas.

O comprobador de aplicacións en Power Apps Studio mostra controis que están cruzados. Revisa o Verificador de aplicacións con regularidade para solucionar este problema.

Na imaxe seguinte, o control Galería 1 está referenciado cruzadamente na Pantalla 2, control Etiqueta 2.

Captura de pantalla de Power Apps Studio mostrando un control cruzado.

Se referencias un control desde a primeira pantalla da aplicación na segunda pantalla, non hai perda de rendemento porque a primeira pantalla xa está cargada. Este comportamento é en realidade beneficioso porque a aplicación é declarativa en lugar de usar variables.

Se referencias controis que aínda non están cargados, como a primeira pantalla que referencia un control nomeado Label 3 da pantalla 3, a aplicación carga esa pantalla na memoria.

Activar DelayOutput para controis de texto

A configuración DelayOutput , cando se configura en verdadeira, rexistra a entrada do usuario tras un atraso de medio segundo. Este atraso é útil para adiar operacións custosas ata que o usuario remate de introducir texto, como filtrar cando se usa entrada noutras fórmulas.

Por exemplo, considere unha galería cuxos Elementos se filtran segundo o que o usuario introduza no control TextInput:

  • Se configuras DelayOutput en falso, que é o predeterminado, a galería filtra tan pronto como se escribe calquera texto. Se tes unha galería con moitos obxectos, recargar a galería con cambios inmediatamente ralentiza o rendemento. É mellor esperar. Este comportamento é práctico cando usas para TextInput unha cadea de busca ou a StartsWith función.

  • Se configuras DelayOutput en verdadeiro, hai un pequeno atraso antes de que se detecten os cambios. Este atraso dá tempo para rematar de escribir. O atraso funciona ben coa TextInput.OnChange propiedade. Se tes accións ligadas a cambios, non queres que se activen ata que remates de escribir no campo.

Delegación e procesamento no lado do servidor

O uso de delegación e procesamento no lado do servidor permite que a túa aplicación manexe grandes conxuntos de datos de forma eficiente descargando operacións á fonte de datos.

Delegación

A delegación en Power Apps refírese á capacidade da aplicación para descargar certas operacións á fonte de datos subxacente en lugar de procesar as operacións dentro do propio Power Apps. Ao usar delegación en Power Apps, podes crear aplicacións máis eficientes e escalables que funcionan ben mesmo en escenarios que implican grandes conxuntos de datos. Sé consciente das limitacións de delegación para fontes de datos e operacións específicas, e deseña a túa aplicación en consecuencia para acadar un rendemento óptimo.

Nota

Non todas as funcións son delegables. Aprende máis sobre a delegación en Limitacións de consulta: Delegación e límites de consulta.

A delegación ten varias vantaxes, como a optimización de consultas e o soporte para grandes conxuntos de datos. Ademais, se os datos de orixe cambian con frecuencia, a delegación axuda a manter os datos actualizados.

Reducir as chamadas á API á fonte de datos

Ás veces, pode parecer cómodo crear coleccións realizando unións dentro da aplicación de lenzo. Teña en conta o seguinte exemplo. No exemplo, hai dúas táboas: Condutores e Camións. O código crea unha colección de detalles de condutores e camións e, para cada camión, chama ao condutor propietario do camión.

// 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 esta unión na aplicación de lenzo pode xerar moitas chamadas á orixe de datos, o que leva a tempos de carga lentos.

Unha mellor estratexia é:

// 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 escenario en tempo real, podes reducir os tempos de carga de cinco minutos a menos de 10 segundos fixando os datos na fonte.

Procesamento no lado do servidor

Diferentes fontes de datos, como SQL e Dataverse, permítenche delegar o procesamento de datos, como filtros e buscas, na fonte de datos. En SQL Server, podes crear vistas definidas por unha consulta. En Dataverse, podes crear complementos de código baixo para procesar datos no servidor e devolver só os resultados finais á túa aplicación de lenzo.

Delegar o procesamento de datos ao servidor pode mellorar o rendemento, reducir o código do lado do cliente e facilitar o mantemento da aplicación.

Máis información sobre complementos en Dataverse.

Optimizar os patróns de datos de consulta

Optimizar como a túa aplicación consulta os datos pode reducir significativamente os tempos de carga e mellorar a resposta xeral.

Usar selección explícita de columnas

A funcionalidade de selección explícita de columnas (ECS) está activada por defecto para todas as aplicacións novas. Se non está activada na túa aplicación, actívaa. ECS reduce automaticamente o número de columnas recuperadas só ás que se usan na aplicación. Se o ECS non está activado, é posible que recibas máis datos dos que necesitas, o que pode afectar ao rendemento. Ás veces, cando unha aplicación obtén datos a través de coleccións, pode perderse a fonte orixinal dunha columna. ECS elimina columnas se non pode determinar que se usan. Para forzar a ECS a manter unha columna ausente, usa a expresión ShowColumns Power Fx despois dunha referencia de colección ou nun control.

Evita chamar a Power Automate para poboar unha colección

Unha práctica común é usar Power Automate para obter e encher coleccións en Power Apps. Aínda que esta estratexia é válida, hai situacións nas que pode non ser a opción máis eficiente. Chamar a Power Automate engade latencia de rede e un custo de rendemento de 0,6 segundos para instanciar o fluxo de Power Automate.

O uso excesivo dos fluxos de Power Automate tamén pode levar a límites de execución e limitación. Avalía sempre os compromisos entre a latencia da rede e o custo de rendemento.

Eliminar o problema N+1

O problema N+1 é un problema común nas consultas de bases de datos onde, en lugar de obter todos os datos necesarios nunha única consulta, se realizan varias consultas adicionais para recuperar datos relacionados. Este problema pode levar a problemas de rendemento, xa que cada consulta extra implica sobrecarga.

Unha chamada sinxela como esta para cargar unha colección pode xerar N+1 chamadas á fonte de datos:

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

No contexto das aplicacións e galerías de canvas, o problema N+1 pode xurdir ao traballar con fontes de datos e galerías que mostran rexistros relacionados. O problema adoita producirse cando se realizan máis consultas para cada elemento que se mostra na galería, o que provoca un colo de botella no rendemento.

Usa obxectos Vista en SQL Server para evitar problemas de consulta N+1, ou cambia a interface de usuario para evitar activar o escenario N+1.

Dataverse obtén automaticamente os datos necesarios das táboas relacionadas e podes seleccionar as columnas das táboas relacionadas.

ThisItem.Account.'Account Name'

Se RelatedDataSource o tamaño é pequeno (menos de 500 rexistros), gárdao en caché nunha colección e usa a colección para impulsar o escenario de consulta de Consulta (N+1).

Limitar o tamaño do paquete

Aínda que Power Apps optimiza a carga das aplicacións, podes tomar medidas para reducir a pegada das túas aplicacións. Unha pegada reducida é especialmente importante para usuarios de dispositivos antigos ou en lugares onde hai maior latencia ou menor ancho de banda.

  • Avalía os medios integrados na túa aplicación. Se algo non se usa, elimínase.

    Por exemplo, as imaxes incrustadas poden ser demasiado grandes. En vez de ficheiros PNG, comproba se podes usar imaxes SVG. Ten coidado ao usar texto en imaxes SVG porque a fonte debe estar instalada no cliente. Unha solución temporal cando necesitas mostrar texto é superpoñer unha etiqueta de texto sobre unha imaxe.

  • Avaliar se a resolución é axeitada para o factor de forma. A resolución dunha aplicación móbil non ten por que ser tan alta como a dunha aplicación de escritorio. Experimenta para conseguir o equilibrio axeitado entre calidade e tamaño da imaxe.

  • Se tes pantallas que non usas, elimínaas. Ten coidado de non eliminar ningunha pantalla oculta que só usen os creadores ou administradores de aplicacións.

  • Avalía se estás a tentar encaixar demasiados fluxos de traballo nunha soa aplicación. Por exemplo, tes pantallas de administración e pantallas de cliente na mesma aplicación? Se é así, considera dividilos en aplicacións individuais. Este enfoque tamén facilita que varias persoas traballen nas aplicacións ao mesmo tempo, e limita o "radio de explosión" (cantidade de probas) cando os cambios na aplicación requiren un exame completo.

Optimizar para todo

A función ForAll en Power Apps úsase para iterar a través dunha táboa de rexistros e aplicar unha fórmula ou conxunto de fórmulas a cada rexistro. Aínda que a función en si é versátil, un uso ForAll inadecuado pode facer que a túa aplicación sexa menos eficiente.

A ForAll función é unha función secuencial singular en lugar dunha función concurrente. Por iso, só mira un rexistro á vez, obtén o resultado e logo continúa ao seguinte rexistro ata que pasa por todos os rexistros do seu alcance.

Evita anidar ForAll. Esta práctica pode levar a iteracións exponenciais e afectar significativamente o rendemento.

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

Actualización por lotes da base de datos

Podes usar ForAll e Patch actualizar en lote a base de datos. Con todo, ten coidado ao usar a orde de ForAll e Patch.

A seguinte función é o mellor enfoque, por exemplo:

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

Mentres que o seguinte enfoque é menos eficiente:

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

Seguinte paso

Manexo de erros

  • Last updated on