¿Cuál es la principal diferencia entre Convert.ChangeType o Convert.ToInt32?

Question

¿Hay alguna ventajas de rendimiento de una sobre otra entre Convert.ChangeType o Convert.ToInt32 o int.Parse

Answer 1

Si sabe que va a ser la conversión de un string a Int32, utilizando Convert.ChangeType parece una manera oscura de hacer ese. Definitivamente preferiría cualquiera de las otras llamadas a eso.

La principal diferencia entre int.Parse y Convert.ToInt32(x) es que Convert.ToInt32(null) devuelve 0 en tanto que int.Parse(null) se producirá una excepción. Por supuesto, int.Parse también le da más control en términos de qué cultura se utiliza.

dudo mucho que haya ninguna ventaja de rendimiento de una sobre la otra: Me esperarConvert.ToInt32 para llamar int.Parse en lugar de a la inversa - pero no es documentado a trabajar de esa manera, y el golpe de es poco probable que una llamada a un solo método sea significativa. (De todos modos, puede estar subrayado.)

Answer 2

Sí.

Convert.ToInt32 es mejor que usar Convert.ChangeType para el mismo propósito.

ChangeType es un método de conversión de propósito general que convierte el objeto especificado por valor en conversionType. Mientras que ToInt32 es específico para tipo int32.

Answer 3

private const int maxValue = 1000000; 
    static void Main(string[] args) 
    { 
     string[] strArray = new string[maxValue]; 
     for (int i = 0; i < maxValue; i++) 
     { 
      strArray[i] = i.ToString(); 
     } 
     int[] parsedNums = new int[maxValue]; 
     CalcChangeTypePerf(strArray,parsedNums); 
     CalcToInt32Perf(strArray, parsedNums); 
     CalcIntParse(strArray, parsedNums); 
    } 
    public static void CalcChangeTypePerf(string[] strArray,int[] parsedArray) 
    { 
     Stopwatch stopwatch = new Stopwatch(); 
     stopwatch.Start(); 
     for (int i = 0; i < maxValue; i++) 
     { 
      parsedArray[i] = (int)Convert.ChangeType(strArray[i], typeof(int)); 
     } 
     stopwatch.Stop(); 
     Console.WriteLine("{0} on CalcChangeTypePerf", stopwatch.ElapsedMilliseconds); 
    } 
    public static void CalcToInt32Perf(string[] strArray, int[] parsedArray) 
    { 
     Stopwatch stopwatch = new Stopwatch(); 
     stopwatch.Start(); 
     for (int i = 0; i < maxValue; i++) 
     { 
      parsedArray[i] = Convert.ToInt32(strArray[i]); 
     } 
     stopwatch.Stop(); 
     Console.WriteLine("{0} on CalcToInt32Perf", stopwatch.ElapsedMilliseconds); 
    } 
    public static void CalcIntParse(string[] strArray, int[] parsedArray) 
    { 
     Stopwatch stopwatch = new Stopwatch(); 
     stopwatch.Start(); 
     for (int i = 0; i < maxValue; i++) 
     { 
      parsedArray[i] = int.Parse(strArray[i]); 
     } 
     stopwatch.Stop(); 
     Console.WriteLine("{0} on CalcIntParse", stopwatch.ElapsedMilliseconds); 
    } 

Este sencillo resultados de las pruebas de este

266 on CalcChangeTypePerf 
167 on CalcToInt32Perf 
165 on CalcIntParse 

Answer 4

prueba simple muestra es Parse() método más rápido, la próxima y última Convert.ToInt32()Convert.ChangeType():

static void Main(string[] args) 
{ 
    string s = "104563"; 
    int a = 1; 

    for (int k = 0; k < 4; k++) 
    { 
     Stopwatch w = Stopwatch.StartNew(); 
     for (int i = 0; i < 10000000; i++) 
      a = (int)Convert.ChangeType(s, typeof(int)); 
     w.Stop(); 

     Console.WriteLine("ChangeType={0}", w.ElapsedMilliseconds); 

     Stopwatch w1 = Stopwatch.StartNew(); 
     for (int i = 0; i < 10000000; i++) 
      a = Convert.ToInt32(s); 
     w1.Stop(); 

     Console.WriteLine("ToInt32={0}", w1.ElapsedMilliseconds); 

     Stopwatch w2 = Stopwatch.StartNew(); 
     for (int i = 0; i < 10000000; i++) 
      a = Int32.Parse(s); 
     w2.Stop(); 
     Console.WriteLine("Parse={0}", w2.ElapsedMilliseconds); 
    } 

    Console.ReadLine(); 
} 

El resultado es:

ChangeType=2422 
ToInt32=1859 
Parse=1760 
ChangeType=2374 
ToInt32=1857 
Parse=1762 
ChangeType=2378 
ToInt32=1860 
Parse=1763 
ChangeType=2375 
ToInt32=1855 
Parse=1759