Israel Aéce

Microsoft MVP, MCP, MCAD, MCTS, MCPD e MCT

My Links

Blog Stats

Archives

Post Categories

Links

Login

Comparação de Strings

Como sabemos, o .NET Framework nos fornece várias formas de compararmos Strings. Pois bem, isso me deixou bastante curioso, visto que com estas opções, saber qual é a mais rápida. Não sei se o teste de performance que criei é lá o ideal, mas deu para ter uma idéia.

O teste consiste em um laço For ... Next de 0 até 1.000.000.000, onde dentro do laço eu utilizo as comparações de Strings. O teste foi realizado para quando as Strings são iguais e também quando são diferentes, e o resultado é interessante por causa que dependendo se as Strings forem iguais uma forma é mais rápida, ao contrário de elas forem diferentes, ou seja, um outro método é mais eficaz. Vamos então ver a estrutura do código que escrevi para o teste/comparação:

        Dim d1 As DateTime
        Dim d2 As DateTime
        Dim t As TimeSpan
        Dim s1 As String = "valor1"
        Dim s2 As String = "valor1"

        GC.Collect()

        d1 = DateTime.Now
        For i As Integer = 0 To 1000000000
                'Aqui a comparação (abaixo)
        Next
        d2 = DateTime.Now
        t = d2.Subtract(d1)
        Console.WriteLine(t.ToString())

Pois bem, com esta mesma estrutura utilizei as tres formas de comparação de Strings para testá-las. As condicionais são:

            [ Forma 1 ]
                        If String.Equals(s1, s2) Then
                        End If

            [ Forma 2 ]
                        If s1 = s2 Then
                        End If

            [ Forma 3 ]
                        If s1.Equals(s2) Then
                        End If

Os testes foram feitos para quando as Strings (s1, s2) foram iguais quanto diferentes. Para ser sincero, eu imaginei que poderia haver alguma diferença, mas que seria algo mínimo, questões de milisegundos, mas depois do teste, vi que se elas forem iguais, o custo é um pouco maior para alguns dos casos. Abaixo os resultados que obtive:

            [ Strings Iguais ]
                        Forma 1 - 00:00:07.7962762
                        Forma 2 - 00:00:35.2941642
                        Forma 3 - 00:00:25.6074082

            [ Strings Diferentes ]
                        Forma 1 - 00:00:28.8443038
                        Forma 2 - 00:00:30.4536014
                        Forma 3 - 00:00:24.3753120

Os testes foram feitos em um PC com a seguinte configuração: P4, 3Ghz, 512RAM, e monitor LCD :P

Bem, fica aí os testes. Ainda não consegui identificar o porque um é mais rápido que o outro. Se alguém souber, e quiser compartilhar, fique a vontade.

posted on Friday, January 14, 2005 12:28 PM

Feedback

# re: Comparação de Strings 1/14/2005 5:12 PM NM

Minha tentativa de explicação para as string iguais.

A forma 2 é a mais lenta porque quando se usa o operador "=", este simplesmente chama o método Equals, ou seja são chamadas 2 métodos.

A forma 2 é mais mais lenta do que a 1.Porque como é uma função herdada e feito um overide demora muito mais tempo do que uma função static (caso 1). É que um para chamar um método que é virtual (caso 2), são precisos mais passos para realizar a chamada, porque é preciso primeiro ver onde se encontra numa tabela de funções virtuais.

Neste tipo de testes normalmente é corrido sempre 2 vezes, uma para "aquecer" o runtime e outro própriamente com os testes, assim evita-se desfasamentos com as optimizações em runtime do .net framework faz quando um método é chamado várias vezes.

# re: Comparação de Strings 1/14/2005 8:51 PM migas

A razão é simples, mas primeiro é preciso mostrar o código do String.Equals(s1, s2):

public static bool Equals(string a, string b)
{
if (a == b)
{
return true;
}
if ((a != null) && (b != null))
{
return a.Equals(b);
}
return false;
}

-no primeiro caso ([ Forma 1 ] com strings iguais) o JIT percebe que as strings são iguais e faz uma optimização e coloca-as no mesmo sitio da memória, logo se virmos o código do String.Equals(s1, s2) percebe-se pq é tão rápido, faz sempre retun true;

- no outros casos corre sempre este pedaço de código e dai o overhead e os valores serem semelhantes:

if ((a != null) && (b != null))
{
return a.Equals(b);
}
return false;



# re: Comparação de Strings 1/14/2005 9:00 PM migas

Aliás uma correcção no caso da Forma 2 o compilador gera a seguinte chamada:

if (StringType.StrCmp(text1, text2, false) == 0)
{
}
num1++;

Dai ser a forma mais lenta!!!

Title  
Name  
Url
Box Code
Protected by FormShield
Comments