Xamarin Forms - Usando Fast Renderers

Xamarin Forms - Melhorando o desempenho

Neste artigo veremos como podemos melhorar o desempenho das nossas aplicações Xamarin Forms.

Quem não deseja melhorar o desempenho de sua aplicação, não é mesmo. Ainda mais quando estamos falando de aplicações mobile e para piorar usando aplicação que é renderizada para mais de uma plataforma.

Então a seguir vou apresentar cinco dicas que foram compiladas da web com objetivo de melhorar o desempenho da sua aplicação Xamarin Forms. Na última apresento sete dicas para otimização do layout.

Nota: Dependendo da versão atual do Xamarin.Forms pode ser que alguma técnica indicada já tenha sido incorporada ao projeto Xamarin.Forms.

1 - Habilitar o compilador XAML

O XAML pode opcionalmente ser compilado diretamente na linguagem intermediária (IL) com o compilador XAML (XAMLC). O XAMLC está desativado por padrão para garantir compatibilidade com versões anteriores. No entanto, ele pode ser ativado nos níveis de assembly e classe.

Segundo a documentação a ativação a nível de assembly pode ser feita com o código a seguir:

 using Xamarin.Forms.Xaml;
 ...
 [assembly: XamlCompilation (XamlCompilationOptions.Compile)]
 namespace PhotoApp
 {
   ...
 }

Para habilitar o compilador a nível de classe o código usado é visto abaixo:

 using Xamarin.Forms.Xaml;
 ...
 [XamlCompilation (XamlCompilationOptions.Compile)]
 public class HomePage : ContentPage
 {
     ...
 }

2 - Habilitar a compactação do Layout

A compactação de layout remove layouts especificados da árvore visual, na tentativa de melhorar o desempenho da renderização da página.

O benefício de desempenho que isso proporciona varia de acordo com a complexidade de uma página, a versão do sistema operacional em uso e o dispositivo no qual o aplicativo está sendo executado. No entanto, os ganhos de desempenho serão realmente visíveis em dispositivos mais antigos.

Para obter mais informações, consulte a documentação oficial de Compactação de layout.

3 - Usar Fast Renderers

Os Fast Renderers ou renderizadores rápidos reduzem os custos de inflação e renderização dos controles Xamarin.Forms no Android, nivelando a hierarquia de controles nativa resultante. Isso melhora ainda mais o desempenho, criando menos objetos, o que resulta em uma árvore visual menos complexa e menos uso de memória.

Os renderizadores rápidos estão disponíveis para os seguintes controles no Xamarin.Forms no Android: Button, Image, Label e Frame.

Funcionalmente, esses renderizadores rápidos não são diferentes dos renderizadores herdados. A partir do Xamarin.Forms 4.0, todos os aplicativos direcionados ao FormsAppCompatActivity usarão esses renderizadores rápidos por padrão.

Os renderizadores para todos os novos controles, incluindo ImageButton e CollectionView, usam a abordagem do renderizador rápido.

Para mais informações, consulte os documentos oficiais do Fast Renderers.

4 - Remover Bindings desnecessários

Não use Bindings ou associações para conteúdo que possa ser facilmente definido estaticamente. Não há vantagem em criar ligações para dados que não precisam ser vinculadas porque as ligações são uma sobrecarga adicional, especialmente em comparação com variáveis estáticas.

Por exemplo, a configuração de Button.Text = "Submit" tem menos sobrecarga do que vincular Button.Text a uma propriedade de string ViewModel com o valor "Submit".

5 - Otimizando o Layout

O aspecto mais importante da otimização no nível do layout é saber quando você deve usar qual layout. Como desenvolvedor de XAML, você deve estar ciente de como cada um desses layouts funciona e quais são as desvantagens de usar cada um deles.

Então vamos iniciar orientações de otimização de layout:

1 - Gerais:

Um layout que é capaz de exibir vários filhos, mas que tem apenas um filho, é um desperdício. Por exemplo, um StackLayout com um único filho não faz sentido, pois é apenas uma carga adicional sobre o XAMLC.
Planejando usar StaticResources para reduzir a redundância de código e os valores de código fixo ? Se sim, você pode economizar tempo usando estilos para aumentar o desempenho, não executando várias pesquisas ao mesmo tempo.
Não tente reproduzir a aparência de um layout específico usando uma combinação de outros layouts, pois isso resulta na execução de cálculos desnecessários de layout e, aginal isso não faz muito sentido. Por exemplo, não tente reproduzir um layout de grade usando uma combinação de StackLayouts.
Não defina as VerticalOptions e HorizontalOptions de um layout, a menos que seja necessário. Os valores padrão para ele, ou seja, LayoutOptions.Fill e LayoutOptions.FillAndExpand, permitem a melhor otimização de layout.
Alterar essas propriedades tem um custo e consome memória, mesmo ao defini-las com os valores padrão. Portanto, se o seu requisito for atendido usando Fill/FillAndExpand, não mencioná-lo durante a criação de visualizações é a melhor prática.
Evite usar um RelativeLayout, se possível. Tem uma sobrecarga significativa e nunca é recomendada.
Ao usar um AbsoluteLayout, evite usar a propriedade AbsoluteLayout.Autosize sempre que possível.
Envolva suas views no construtor, e não no OnAppearing.
Ignore a transparência - se você conseguir o mesmo efeito (ou próximo) com total opacidade, faça-o.
Use async/wait para evitar o bloqueio do thread principal. E, em seguida, mostre o resultado final usando o Device.BeginInvokeOnMainThread();

2 - Para o Grid

Reduza a profundidade das hierarquias de layout especificando os valores da propriedade Margin, permitindo a criação de layouts com menos visualizações de disposição.
Ao usar uma Grid, tente garantir que o menor número possível de linhas e colunas esteja definido como Automático, o que faz o mecanismo executar cálculos adicionais. Em vez disso, use linhas e colunas de tamanho fixo, se possível.
Defina linhas e colunas para ocupar uma quantidade proporcional de espaço com o GridUnitType.Star;

3 - Para o StackLayout

Ao usar um StackLayout, verifique se apenas um filho está definido como LayoutOptions.Expands. Essa propriedade garante que o filho especificado ocupe o maior espaço que o StackLayout pode fornecer a ele. Nota: É um desperdício realizar esses cálculos mais de uma vez.
Não chame nenhum dos métodos da classe Layout, pois eles resultam no desempenho de cálculos caros de layout. Em vez disso, é provável que o layout desejado possa ser obtido definindo as propriedades TranslationX e TranslationY. Como alternativa, você pode subclassificar a classe Layout<View> para obter o comportamento de layout desejado.
Evite chamar Layout() (e especialmente ForceLayout()).

4 - Para a Label

Atualize a Label apenas quando necessário, pois alterar o tamanho de uma Label pode resultar em que todo o layout da tela sendo recalculado.
Não defina a propriedade VerticalTextAlignment / HorizontalTextAlignment de uma Label, a menos que seja necessário.
Defina o LineBreakMode de qualquer Label como NoWrap sempre que viável.

5 - Para o ListView

Incluir um ListView dentro de um ScrollView é uma prática muito ruim. Sempre evite isso. Use as propriedades de cabeçalho e rodapé do ListView.
Não use a TableView onde você pode usar um ListView. Geralmente, os TableViews são recomendados para uma configuração como interface do usuário.
Use ListViewCachingStrategy.RecycleElement quando puder. Esta não é a estratégia de armazenamento em cache padrão.
Use os seletores DataTemplate para facilitar visualizações heterogêneas em um único ListView. Não substitua OnBindingContextChanged para atualizar e obter o mesmo efeito.
Evite passar IEnumerable<T> como uma fonte de dados para ListViews. Em vez disso, tente usar IList<T>, porque as coleções IEnumerable<T> não oferecem suporte ao acesso aleatório.
Aninhar ListViews é uma prática ruim. Em vez disso, use grupos em um único ListView. O aninhamento não é explicitamente suportado e interromperá seu aplicativo.
Use HasUnevenRows onde seu ListView possui linhas de tamanhos diferentes. Se o conteúdo da célula for modificado dinamicamente (talvez após carregá-lo no banco de dados), chame ForceUpdateSize() na célula.
Evite hierarquias de layout profundamente aninhadas. Use AbsoluteLayout ou Grid para ajudar a reduzir o aninhamento.
Evite opções de layout específicas que não sejam Fill (Fill é o mais barato para calcular).

6 - Para o Navigation

Sempre use await com os métodos PushAsync e PopAsync. Não fazer isso é prejudicial ao desempenho e à boas práticas;
Evite hiding/showing (ocultar/mostrar) a barra de navegação;
Use o AppCompat back-end para Android. Isso melhorará o desempenho e a aparência do aplicativo.

7 - Para a Image

As imagens no Android não apresentam down-sample, ou seja, reduzem a resolução espacial mantendo a mesma representação bidirecional. Lembre-se sempre disso, pois esse é um dos motivos pelos quais seu aplicativo atinge o Out Of Memory;
Defina Image.IsOpaque como true, se possível.
Carregue imagens de Content m vez de Resources;

Com essas orientações aplicadas ao seu projeto quando pertinentes sua aplicação vai com certeza ter um melhor desempenho.

"Bendito seja o Deus e Pai de nosso Senhor Jesus Cristo, o Pai das misericórdias e o Deus de toda a consolação;
Que nos consola em toda a nossa tribulação, para que também possamos consolar os que estiverem em alguma tribulação, com a consolação com que nós mesmos somos consolados por Deus."
2 Coríntios 1:3,4

Referências:

José Carlos Macoratti