[Resolvido] Melhorando desempenho de aplicativos .NET - Parte 12

Em nosso artigo anterior, nós discutimos sobre ?Iteração e Looping?. Hoje iremos nos concentrar na otimização de operações de string.

O Framework .NET fornece o tipo de dado System.String para representar uma string. A manipulação intensiva de strings pode degradar o desempenho. Toda vez que você executar uma operação para mudar os dados da strings, a string original na memória é descartada para um coletor de lixo posterior e uma nova é criada para armazenar os dados de sequência de novos caracteres. Observe também que o tipo String é um tipo de referência, por isso os conteúdos dela são armazenados em um heap gerenciado. Como resultado, as strings devem ser coletadas para serem limpas.

Esta seção resume as recomendações que você deve levar em conta quando se trabalha com strings.

Evite concatenação de string ineficiente
A concatenação excessiva de strings resulta em muitas operações de alocação e desalocação, pois cada vez que você realiza uma operação para alterar a string, uma nova é criada e a antiga é posteriormente coletada pelo coletor de lixo.

Se você concatenar strings literais, o compilador irá concatená-las no tempo de compilação.

//?Hello? and ?world? are string literals
String str = ?Hello? + ?world?;

Se você concatenar as sequências não-literais, faça uma concatenação neles em tempo de execução. Então, usar o operador + cria vários objetos strings no heap gerenciado.

Use o StringBuilder para manipulações de strings complexas e também quando precisar concatenar strings várias vezes.

// using String and ?+? to append

String str = ?Some Text?;

for ( ? loop several times to build the string ?) {

 str = str + ? additional text ?;

}

// using String and .Append method to append

StringBuilder strBuilder = new StringBuilder(?Some Text ?);

for ( ? loop several times to build the string ?) {

 strBuilder.Append(? additional text ?);

}

Use + quando o número de Appends for conhecido
Se você souba o número de appends a ser feito e você está concatenando as strings de uma vez só, prefira o operador + para a concatenação.

String str = str1+str2+str3;
Caso você concatene as strings em uma única expressão, então será preciso fazer apenas uma chamada para String.Concat. Isso não resulta em nenhuma string temporária (para combinações parciais das strings a serem concatenadas).

Evite usar + em strings dentro de um loop ou de múltiplas iterações. Use StringBuilder no lugar.

Use StringBuilder quando o número de Appends for desconhecido
Se você não souber o número de appends que precisa ser feito, o que poderia ser o caso quando iterar por um loop ou a construção de pesquisas dinâmicas de SQL, use a classe StringBuilder, como mostrado no exemplo seguinte:

for (int i=0; i< Results.Count; i++)
{

StringBuilder.Append (Results);

}

A classe StringBuilder começa com uma capacidade inicial padrão de 16. Strings inferiores a capacidade inicial são armazenadas no objeto StringBuilder. A capacidade inicial do buffer pode ser definida usando o seguinte construtor sobrecarregado.

public StringBuilder (int capacidade);
Você pode continuar a concatenar sem alocações adicionais até você consumir o buffer alocado préviamente. Como resultado, usar um objeto StringBuilder é muitas vezes mais eficiente do que usar objetos string para concatenação. Se você concatenar mais ainda, a classe StringBuilder vai gerar um novo buffer com o dobro da da capacidade atual.

Então, se você começar com um StringBuilder de tamanho 16 e exceder o limite, o StringBuilder vai aloca um novo buffer de tamanho 32 e copiar a sequência antiga para o novo buffer. O antigo será inacessível e se tornará elegível para garbage collection.

Você deve tentar configurar a capacidade inicial do StringBuilder a um valor ideal para reduzir o custo de novas atribuições. A melhor maneira para controlar o consumo de memória usando o CLR Profiler é determinar o valor ideal para o seu caso.

 

Trate StringBuilder como um acumulador
Você pode tratar o StringBuilder como um acumulador ou buffer reutilizável. Isso ajuda a evitar as alocações de sequências temporárias durante as múltiplas iterações append. Aqui estão algumas das situações onde isso pode ajudar:

• Concatenando strings: você deve preferir sempre a seguinte abordagem para a concatenação ao usar StringBuilder.

StringBuilder sb;
sb.Append(str1);

sb.Append(str2);

Use the preceding code rather than the following.

sb.Append(str1+str2);

Isso é porque você não precisa fazer a str1 + str2 temporária para anexar str1 e str2.

• Concatenando as strings de várias funções

O seguinte código mostra um exemplo disso:

StringBuilder sb;
sb.Append(f1());

sb.Append(f2());

sb.Append(f3());

O fragmento de código anterior resulta em alocações de string temporários para os valores de retorno por parte das funções f1 (...), f2 (), f3 (). Você pode evitar essas alocações temporárias usando o seguinte padrão:

void f1( sb,);
void f2( sb,);

void f3( sb,);

 

Neste caso, a instância StringBuilder é diretamente passada como um parâmetro de entrada para os métodos. O sb.Append é chamado diretamente no corpo da função, o que evita a atribuição de strings temporárias.

Use o método sobrecarregado de comparação para comparações de strings Case-Insensitive
Considere cuidadosamente como você executa as comparações entre strings case-insensitive. Evite usar o ToLower, como mostrado no código a seguir, porque você acaba criando objetos string temporários.

// Bad way for insensitive operations because ToLower creates temporary
strings

String str=?New York?;

String str2 = ?New york?;

if (str.ToLower()==str2.ToLower())

// do something

The more efficient way to perform case-insensitive string comparisons is to use the Compare method.

str.Compare(str,str2,false);

O método String.Compare utiliza a informação na propriedade CultureInfo.CompareInfo para comparar as strings culture-sensitives.

 

*****

*Artigo original disponível em:** *http://blog.monitis.com/index.php/2012/05/04/improving-net-application-performance-part-12-string-operations/

* ** *

http://imasters.com.br/artigo/25300/dotnet/melhorando-desempenho-de-aplicativos-net-parte-12