Neste terceiro artigo da nossa série sobre a melhoria do desempenho do aplicativo. NET, nós iremos discutir várias técnicas para otimizar e melhorar o desempenho do seu código gerenciado. Mais importante: design de classe, gerenciamento de memória e coletor de lixo, multithreading eficiente, execução assíncrona eficaz, boxe e tratamento de exceção.
Como você bem sabe, a forma como você escreve seu código gerenciado pode tirar o máximo de proveito das funções de alto desempenho Common Language Runtime (CLR), ou pode impedi-las. Vamos indicar os problemas relacionados ao desempenho que ajudam a evitar os erros mais comuns e esperamos ajudá-lo a melhorar o desempenho do seu código. Neste artigo vamos nos concentrar nas considerações de design de classe. Eu listei os mais importantes abaixo.
- Evite fazer classes thread salvas por padrão ? Leve em consideração se é necessário fazer a sua classe thread salva, ou se é necessário apenas em uma camada superior e não um nível de classe individual.
- Use uma palavra-chave secreta - Se você não precisa ou deseja estender sua base de classes, considere marcá-las com uma palavra-chave "secreta". Caso derive uma classe de uma classe base com membros virtuais e quiser impedir ainda mais a extensibilidade da classe derivada, use a palavra-chave "secreta" com os membros virtuais da sua classe derivada. Seler os métodos virtuais permite otimizações alinhadas do compilador.
public class MyClass{
protected virtual void SomeMethod() { ... }
}
Overdiding and seal a method in a derived class.
public class DerivedClass : MyClass {
protected override sealed void SomeMethod () { ... }
}
- Evite membros virtuais desnecessários - Os membros virtuais são mais custosos para chamar por causa da tabela de pesquisa virtual e não funciona para certas otimizações de tempo de execução.
- Usar métodos sobrecarregados - Ao invés de usar um método com um número variável de parâmetros, use métodos sobrecarregados. Esteja ciente de que os clientes COM não podem trabalhar com métodos sobrecarregados. Nesse caso, usar métodos com nomes diferentes.
//method taking variable number of arguments
void GetCustomers (params object [] filterCriteria)
//overloaded methods
void GetCustomers (int countryId, int regionId)
void GetCustomers (int countryId, int regionId, int CustomerType)
- Substituindo o método Equals - Substituir o método Equals, que é fornecido pelo System.Object, pode melhorar ainda mais o desempenho. Um método Equals específico pode fazer uma comparação muito mais fácil e, em seguida, usar a implementação padrão, que usa Reflection, para executar a comparação.
public struct Rectangle{
public double Length;
public double Breadth;
public override bool Equals (object ob) {
if(ob is Rectangle)
return Equals((Rectangle)ob);
else
return false;
}
private bool Equals(Rectangle rect) {
return this.Length == rect.Length && this.Breadth==rect.Breadth;
}
}
- Acessando uma propriedade de classe - Propriedades parecem campos, mas não são e elas têm um custo escondido. Esteja ciente de que se você acessar uma propriedade, o código adicional pode ser executado; e acessar uma propriedade pode ser mais lento do que acessar um campo diretamente. Claro que o código adicional por trás de uma propriedade, geralmente, está lá por uma boa razão - por exemplo, para validar os dados.
Se o objeto foi projetado para o acesso remoto, use métodos com vários parâmetros, ao invés de exigir que o cliente defina várias propriedades ou campos, reduzindo idas e vindas. Além disso, é considerado uma má prática usar propriedades que escondem as regras de negócio complexos ou outras operações custosas; requisitadores de propriedades em geral esperam que o custo seja baixo.
- Variáveis de membro privado versus membro público - Evite membros públicos desnecessários para evitar qualquer sobrecarga de serialização quando você usar a classe XmlSerializer. Como você bem sabe, esta classe serializa todos os membros públicos por padrão.
- Limite o uso de campos voláteis - Limite o uso da palavra-chave volátil, porque os campos voláteis restringem a forma como o compilador lê e escreve o conteúdo do campo. O compilador gera o código que lê sempre a partir da localização do campo de memória, ao invés de ler a partir de um registo que pode ter carregado o valor do campo. Isto significa que o acesso a campos voláteis é mais lento do que os não-voláteis porque o sistema é forçado a usar endereços de memória, em vez de registros.
Estas são as considerações de classe de design mais importantes e que podem ajudar você a otimizar seu código gerenciado. Em nosso próximo artigo vamos nos concentrar na coletor de lixo.
*****
*Texto original da equipe Monitis, liderada por Hovhannes Avoyan, disponível em:*** http://blog.monitis.com/index.php/2012/03/27/improving-net-application-performance-part-3-class-design-considerations/
http://imasters.com.br/artigo/24543/dotnet/melhorando-o-desempenho-do-aplicativo-net-parte-03
