En mis programas, acostumbraba a utilizar variables de tipo String, en vez de declararlas del tipo string. Mi razonamiento era que si string, simplemente es un tipo que encapsula a la clase System.String, entonces, iba a ser algo más eficiente utilizar directamente el segundo.

Cabe decir, que el MSDN, secunda esta hipótesis con la frase: "El tipo string representa una secuencia de cero o más caracteres Unicode. string es un alias de String en .NET Framework". Esto quiere decir, que sobre el papel, la implementación de String, debe ser más eficiente que la de string, lo cual se aplicará a todos los lenguajes de la plataforma .NET (VB.NET, C#, J#, …).

Para comprobarlo, he creado un sencillo programita en Visual C# 2008, que se encarga de iterar durante 500.000 veces, haciendo las operaciones más habituales contra una cadena de caracteres (trim, convertir a mayúsculas, convertir a minúsculas, concatenar, asignar, obtener la longitud, …). Realiza este proceso, usando primeramente String, y luego lo hace con string, calculando en ambos casos el tiempo necesario para hacerlo.

El programa, lo he compilado y ejecutado en un T2330 a 1,6 Ghz, usando el .NET Framework 3.5 en su versión de 32 bits, los tiempos obtenidos, han sido más que reveladores.

Primero de todo, la ejecución ha resultado más veloz usando el tipo, que usando la clase. 42.100.000 contra 42.400.000 ticks, es decir, un 1% a su favor, que en determinados casos, puede ser una diferencia suficientemente significativa. Pero lo más importante, es que esto me lleva a pensar, que probablemente, la implementación sea inversa a lo que afirma la propia Microsoft, y que en realidad es System.String el alias de string.

He consultado las definiciones de la clase String en System.String.cs, y lo que he visto es que los métodos que operan con cadenas, están declarados para usar el tipo nativo string. De nuevo, los indicios indican que es String el alias de string y no a la inversa. Lo siguiente es un extracto de la declaración de una sobrecarga del método Trim en la clase String:

using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.Reflection;
using System.Runtime.ConstrainedExecution;
using System.Runtime.InteropServices;
using System.Text;
namespace System
{
[Serializable]
[ComVisible(true)]
public sealed class String : IComparable, ICloneable, IConvertible, IComparable<string>, IEnumerable<char>, IEnumerable, IEquatable<string>
{

public string Trim();
//
// Summary:
// Removes all leading and trailing occurrences of a set of characters specified
// in an array from the current System.String object.
//
// Parameters:
// trimChars:
// An array of Unicode characters to remove or null.
//
// Returns:
// The string that remains after all occurrences of the characters in the trimChars
// parameter are removed from the start and end of the current System.String
// object. If trimChars is null, white-space characters are removed instead.

}
}

En esta declaración, vemos que efectivamente, internamente se usa string. Así que para futuros desarrollos en C# ya sabéis, mejor usar string que String.

Como referencia, el código del programa completo, es el siguiente:

using System;
using System.Windows.Forms;
static class Program
{
static void Main()
{
int iCont;
String s1;
string s2;
long lInicio1, lFin1, lInicio2, lFin2;
lInicio1 = DateTime.Now.Ticks;
for (iCont = 500000; iCont > 0; iCont–)
{
s1 = "";
s1 = iCont + s1 + iCont;
s1 = s1 + (s1.Length);
s1 = s1.ToLower();
s1 = s1.ToUpper();
s1 = s1.Trim();
s1.Clone();
s1.LastIndexOf("1");
s1.IndexOf("1000");
s1.StartsWith("1000");
s1.EndsWith("1");
s1.Contains("1");
s1.Equals("1");
s1.Insert(0, "0");
s1.Remove(0);
}
lFin1 = DateTime.Now.Ticks;
lInicio2 = DateTime.Now.Ticks;
for (iCont = 500000; iCont > 0; iCont–)
{
s2 = "";
s2 = iCont + s2 + iCont;
s2 = s2 + (s2.Length);
s2 = s2.ToLower();
s2 = s2.ToUpper();
s2 = s2.Trim();
s2.Clone();
s2.LastIndexOf("1");
s2.IndexOf("1000");
s2.StartsWith("1000");
s2.EndsWith("1");
s2.Contains("1");
s2.Equals("1");
s2.Insert(0, "0");
s2.Remove(0);
}
lFin2 = DateTime.Now.Ticks;
MessageBox.Show("String: " + (lFin1 – lInicio1) + "\n" + "string: " + (lFin2 – lInicio2));
}
}

También podéis descargar el proyecto completo (incluyendo fuentes y binarios), aquí (4 Kb. en formato ZIP)