¿Qué es mejor usar: Convert.ToX o X.Parse (...)?

Question

Estoy usando la reflexión para crear algunos objetos. Los valores que estoy configurando se leen desde un archivo, por lo que están nativamente en formato de cadena y debo convertirlos al tipo de datos de la propiedad.

Mi pregunta es, ¿cuál es más rápido/mejor de usar: los métodos Convert.ToX(...) o los métodos X.Parse(...)?

Answer 1

Todas las funciones Convert.ToX que aceptan un argumento de tipo string finalmente llaman al método Parse del tipo de datos apropiado de todos modos.

Por ejemplo, Convert.ToInt32(string) se ve algo como esto:

public static int ToInt32(string value) 
{ 
    if (value == null) 
    { 
     return 0; 
    } 
    return int.Parse(value, CultureInfo.CurrentCulture); 
} 

Lo mismo para todos los demás métodos de conversión numéricas, incluyendo Decimal y DateTime. Así que es bastante irrelevante cuál usas; el resultado (y la velocidad) serán los mismos en ambos casos.

Realmente, la única diferencia es la cláusula de guardia if (value == null) al principio. Si eso es conveniente o no depende del caso de uso específico. Generalmente, si sabe que tiene un objeto no nulo string, también podría usar Parse. Si no está seguro, ConvertToX es una apuesta más segura, ya que requiere menos código de verificación nula en línea.

Answer 2

¡Son exactamente lo mismo! Los métodos Convert.ToX(String) realmente llaman a los métodos X.Parse(String).

Answer 3

De acuerdo con lo que veo en Reflector, Convertir cadena de formulario es un envoltorio alrededor de Parse. por lo tanto, es razonable razonar que el análisis es marginalmente mejor en el rendimiento.

EDIT: después de Cody señaló que la optimización hará la diferencia casi nada, he probado en mi máquina, y de hecho los tiempos de ejecución para Parse y Convert salió el mismo al analizar 1 millón de inetgers en un bucle.

EDIT2: aquí tienes yas4891, en realidad es el código que usaste con cambios muy pequeños.

public static void Main() 
     { 
      int tRuns = 1000000; 
      List<String> tList = new List<string>(); 
      for (int i = 0; i < tRuns; i++) tList.Add(i.ToString()); 
      Stopwatch s = new Stopwatch(); 
      s.Start(); 
      int tSum = 0; 
      for (int i = tRuns - 1; i >= 0; i--) 
      { 
       tSum += Convert.ToInt32(tList[i]); 
      } 
      s.Stop(); 
      Console.WriteLine("convert: " + s.ElapsedMilliseconds); 

      Console.WriteLine("tSum:" + tSum); 

      s.Reset(); 
      s.Start(); 
      tSum = 0; 
      for (int i = tRuns - 1; i >= 0; i--) 
      { 
       tSum += Int32.Parse(tList[i]); 
      } 
      s.Stop(); 
      Console.WriteLine("parse: " + s.ElapsedMilliseconds); 
      Console.WriteLine("tSum:" + tSum); 
      Console.ReadKey(); 
     } 

Answer 4

usando el siguiente código

int tRuns = 1000000; 
List<String> tList = new List<string>(); 

for (int i = 0; i < tRuns; i++) 
    tList.Add(i.ToString()); 


PerformanceMeter.Start(); 
int tSum = 0; 
for (int i = tRuns-1; i >= 0; i--) 
{ 
    tSum += Convert.ToInt32(tList[i]); 
} 

PerformanceMeter.LogAndStop("using Convert.ToInt32:"); 

cLogger.Info("tSum:" + tSum); 
PerformanceMeter.Start(); 

tSum = 0; 
for (int i = tRuns-1; i >= 0; i--) 
{ 
    tSum += Int32.Parse(tList[i]); 
} 

PerformanceMeter.LogAndStop("using Int32.Parse:"); 
cLogger.Info("tSum:" + tSum); 

me da el siguiente resultado:

{} PerformanceMeter: 178 INFORMACIÓN: - utilizando Convert.ToInt32 :: 233,0133 ms
{Programa}: 92 INFO: - tSum: 1783293664
{PerformanceMeter}: 178 INFO: - usando Int32.Parse :: 179,0103 ms
{Programa}: 102 INFORMACIÓN: - tSUM: 1783293664

Así al menos para Int32 parece ser más eficaz utilizar Int32.Parse. Sin embargo, esto puede ser diferente en su escenario y supongo que debe hacer una prueba similar.

Answer 5

Otra posibilidad es los métodos TryParse. Estos son particularmente útiles si existe la posibilidad de que el valor no se pueda analizar con éxito.En lugar de lanzar una excepción, la llamada devolverá un bool indicando si la operación fue exitosa. Esto se ejecuta mucho más rápido y es una implementación más limpia en comparación con tratar con la excepción.