Contiene es más rápido que StartsWith?

Question

Un consultor vino ayer y de alguna manera surgió el tema de las cadenas. Mencionó que había notado que para cadenas de menos de cierta longitud, Contains es en realidad más rápido que StartsWith. Tenía que verlo con mis propios ojos, así que escribí una pequeña aplicación y, efectivamente, ¡Contains es más rápido!

¿Cómo es esto posible?

DateTime start = DateTime.MinValue; 
DateTime end = DateTime.MinValue; 
string str = "Hello there"; 

start = DateTime.Now; 
for (int i = 0; i < 10000000; i++) 
{ 
    str.Contains("H"); 
} 
end = DateTime.Now; 
Console.WriteLine("{0}ms using Contains", end.Subtract(start).Milliseconds); 

start = DateTime.Now; 
for (int i = 0; i < 10000000; i++) 
{ 
    str.StartsWith("H"); 
} 
end = DateTime.Now; 
Console.WriteLine("{0}ms using StartsWith", end.Subtract(start).Milliseconds); 

Salidas:

726ms using Contains 
865ms using StartsWith 

Yo lo he probado con cadenas más largas también!

Answer 1

Intente utilizar StopWatch para medir la velocidad en lugar de DateTime comprobación.

Stopwatch vs. using System.DateTime.Now for timing events

Creo que la clave es la siguiente las partes importantes en negrita:

Contains:

Este método realiza una cultura-ordinal (mayúsculas y minúsculas y comparación insensible).

StartsWith:

Este método realiza una palabra (mayúsculas y minúsculas y cultura sensible) comparación usando la cultura actual.

Creo que la clave es la comparación ordinal lo que equivale a:

Un tipo ordinal compara los cordajes de en el valor numérico de cada Char objeto en la cadena. Una comparación ordinal es automáticamente sensible a mayúsculas y minúsculas porque las minúsculas y las versiones en mayúsculas de un carácter tienen diferentes puntos de código. Sin embargo, si el caso no es importante en su aplicación , puede especificar una comparación ordinal que ignore el caso. Esto equivale a convertir la cadena en mayúsculas utilizando el cultivo invariante y luego realizar una comparación ordinal del resultado.

Referencias:

http://msdn.microsoft.com/en-us/library/system.string.aspx

http://msdn.microsoft.com/en-us/library/dy85x1sa.aspx

http://msdn.microsoft.com/en-us/library/baketfxw.aspx

El uso del reflector se puede ver el código para los dos:

public bool Contains(string value) 
{ 
    return (this.IndexOf(value, StringComparison.Ordinal) >= 0); 
} 

public bool StartsWith(string value, bool ignoreCase, CultureInfo culture) 
{ 
    if (value == null) 
    { 
     throw new ArgumentNullException("value"); 
    } 
    if (this == value) 
    { 
     return true; 
    } 
    CultureInfo info = (culture == null) ? CultureInfo.CurrentCulture : culture; 
    return info.CompareInfo.IsPrefix(this, value, 
     ignoreCase ? CompareOptions.IgnoreCase : CompareOptions.None); 
} 

Answer 2

Lo descubrí. Es porque StartsWith es culturalmente sensible, mientras que Contains no lo es. Eso significa intrínsecamente que StartsWith tiene que hacer más trabajo.

Fwiw, aquí están mis resultados en Mono con el punto de referencia más abajo (corregido):

1988.7906ms using Contains 
10174.1019ms using StartsWith 

Estaría contento de ver los resultados de las personas sobre la EM, pero mi punto principal es que correctamente hecho (y suponiendo optimizaciones similares), creo StartsWith tiene que ser más lenta:

using System; 
using System.Diagnostics; 

public class ContainsStartsWith 
{ 
    public static void Main() 
    { 
     string str = "Hello there"; 

     Stopwatch s = new Stopwatch(); 
     s.Start(); 
     for (int i = 0; i < 10000000; i++) 
     { 
      str.Contains("H"); 
     } 
     s.Stop(); 
     Console.WriteLine("{0}ms using Contains", s.Elapsed.TotalMilliseconds); 

     s.Reset(); 
     s.Start(); 
     for (int i = 0; i < 10000000; i++) 
     { 
      str.StartsWith("H"); 
     } 
     s.Stop(); 
     Console.WriteLine("{0}ms using StartsWith", s.Elapsed.TotalMilliseconds); 

    } 
} 

Answer 3

me hizo girar alrededor de reflector y encontré una posible respuesta:

Contiene:

return (this.IndexOf(value, StringComparison.Ordinal) >= 0); 

StartsWith:

... 
    switch (comparisonType) 
    { 
     case StringComparison.CurrentCulture: 
      return CultureInfo.CurrentCulture.CompareInfo.IsPrefix(this, value, CompareOptions.None); 

     case StringComparison.CurrentCultureIgnoreCase: 
      return CultureInfo.CurrentCulture.CompareInfo.IsPrefix(this, value, CompareOptions.IgnoreCase); 

     case StringComparison.InvariantCulture: 
      return CultureInfo.InvariantCulture.CompareInfo.IsPrefix(this, value, CompareOptions.None); 

     case StringComparison.InvariantCultureIgnoreCase: 
      return CultureInfo.InvariantCulture.CompareInfo.IsPrefix(this, value, CompareOptions.IgnoreCase); 

     case StringComparison.Ordinal: 
      return ((this.Length >= value.Length) && (nativeCompareOrdinalEx(this, 0, value, 0, value.Length) == 0)); 

     case StringComparison.OrdinalIgnoreCase: 
      return ((this.Length >= value.Length) && (TextInfo.CompareOrdinalIgnoreCaseEx(this, 0, value, 0, value.Length, value.Length) == 0)); 
    } 
    throw new ArgumentException(Environment.GetResourceString("NotSupported_StringComparison"), "comparisonType"); 

Y hay algunas sobrecargas para que la cultura por defecto es CurrentCulture.

En primer lugar, ordinal será más rápido (si la cadena está cerca del principio) de todos modos, ¿verdad? Y en segundo lugar, hay más lógica aquí que podría desacelerar las cosas (aunque es muy trivial)

Answer 4

StartsWith y Contains se comportan de forma completamente diferente cuando se trata de cuestiones relacionadas con la cultura.

En particular, StartsWith que devuelve NO implica Contains que devuelve true. Deberías reemplazar uno de ellos con el otro solo si realmente sabes lo que estás haciendo.

using System; 

class Program 
{ 
    static void Main() 
    { 
     var x = "A"; 
     var y = "A\u0640"; 

     Console.WriteLine(x.StartsWith(y)); // True 
     Console.WriteLine(x.Contains(y)); // False 
    } 
} 

Answer 5

Vamos a examinar lo que dice acerca de estos dos ILSpy ...

public virtual int IndexOf(string source, string value, int startIndex, int count, CompareOptions options) 
{ 
    if (source == null) 
    { 
     throw new ArgumentNullException("source"); 
    } 
    if (value == null) 
    { 
     throw new ArgumentNullException("value"); 
    } 
    if (startIndex > source.Length) 
    { 
     throw new ArgumentOutOfRangeException("startIndex", Environment.GetResourceString("ArgumentOutOfRange_Index")); 
    } 
    if (source.Length == 0) 
    { 
     if (value.Length == 0) 
     { 
      return 0; 
     } 
     return -1; 
    } 
    else 
    { 
     if (startIndex < 0) 
     { 
      throw new ArgumentOutOfRangeException("startIndex", Environment.GetResourceString("ArgumentOutOfRange_Index")); 
     } 
     if (count < 0 || startIndex > source.Length - count) 
     { 
      throw new ArgumentOutOfRangeException("count", Environment.GetResourceString("ArgumentOutOfRange_Count")); 
     } 
     if (options == CompareOptions.OrdinalIgnoreCase) 
     { 
      return source.IndexOf(value, startIndex, count, StringComparison.OrdinalIgnoreCase); 
     } 
     if ((options & ~(CompareOptions.IgnoreCase | CompareOptions.IgnoreNonSpace | CompareOptions.IgnoreSymbols | CompareOptions.IgnoreKanaType | CompareOptions.IgnoreWidth)) != CompareOptions.None && options != CompareOptions.Ordinal) 
     { 
      throw new ArgumentException(Environment.GetResourceString("Argument_InvalidFlag"), "options"); 
     } 
     return CompareInfo.InternalFindNLSStringEx(this.m_dataHandle, this.m_handleOrigin, this.m_sortName, CompareInfo.GetNativeCompareFlags(options) | 4194304 | ((source.IsAscii() && value.IsAscii()) ? 536870912 : 0), source, count, startIndex, value, value.Length); 
    } 
} 

parece que considera la cultura como bien, pero es por defecto.

public bool StartsWith(string value, StringComparison comparisonType) 
{ 
    if (value == null) 
    { 
     throw new ArgumentNullException("value"); 
    } 
    if (comparisonType < StringComparison.CurrentCulture || comparisonType > StringComparison.OrdinalIgnoreCase) 
    { 
     throw new ArgumentException(Environment.GetResourceString("NotSupported_StringComparison"), "comparisonType"); 
    } 
    if (this == value) 
    { 
     return true; 
    } 
    if (value.Length == 0) 
    { 
     return true; 
    } 
    switch (comparisonType) 
    { 
    case StringComparison.CurrentCulture: 
     return CultureInfo.CurrentCulture.CompareInfo.IsPrefix(this, value, CompareOptions.None); 
    case StringComparison.CurrentCultureIgnoreCase: 
     return CultureInfo.CurrentCulture.CompareInfo.IsPrefix(this, value, CompareOptions.IgnoreCase); 
    case StringComparison.InvariantCulture: 
     return CultureInfo.InvariantCulture.CompareInfo.IsPrefix(this, value, CompareOptions.None); 
    case StringComparison.InvariantCultureIgnoreCase: 
     return CultureInfo.InvariantCulture.CompareInfo.IsPrefix(this, value, CompareOptions.IgnoreCase); 
    case StringComparison.Ordinal: 
     return this.Length >= value.Length && string.nativeCompareOrdinalEx(this, 0, value, 0, value.Length) == 0; 
    case StringComparison.OrdinalIgnoreCase: 
     return this.Length >= value.Length && TextInfo.CompareOrdinalIgnoreCaseEx(this, 0, value, 0, value.Length, value.Length) == 0; 
    default: 
     throw new ArgumentException(Environment.GetResourceString("NotSupported_StringComparison"), "comparisonType"); 
    } 

Por el contrario, la única diferencia que veo que parece relevante es una verificación de longitud extra.