El tipo System.String, que como todos sabemos representa una cadena,
es un tipo algo especial con el que hay que tener un poco de cuidado a
la hora de menejarlo. Veamos en primer lugar una definición más o menos
formal del tipo System.String:
"
El tipo System.String es un
tipo por referencia e inmutable (de solo lectura) que representa una
cadena de texto como una colección secuencial de caracteres Unicode
(objetos System.Char)".
Para este artículo nos centraremos
en la primera parte de la definición, es decir, en "El tipo
System.String es un tipo por referencia e inmutable (de solo lectura)
...".
¿Que quiere decir que es inmutable?
Un
objeto inmutable es un objeto que no se puede modificar. Cuando creas, o
cargas en menoria un objeto de este tipo, permanece con el mismo valor
durente toda la vida del objeto. Veamos el siguiente fragmento de
código:
string miCadena = "Un saludo";
miCadena += " para el lector";
Quizás
pueda parecer que en la segunda linea de este fragmento estamos
modificando el literal "Un saludo" pero esto no es así. Como ya dijimos
antes, el objeto "Un saludo" es inmutable, por lo tanto, despúes de la
concatenación, lo que se devuelve es un nuevo objeto de tipo
System.String que contiene la modificación: "Un saludo para el lector".
Por
lo tanto, cuando concatenamos cadenas de esta forma, tenemos en la
memoria dos objetos, uno con el valor original y otro con la
modificación. Es evidente, que sí esta operación la realizamos miles de
veces, por ejemplo leyendo de una base de datos, el rendimiento de la
aplicación se verá gravemente afectado. Por otro lado, si la operación
solo se realiza una o dos veces (incluso tres o cuatro) no tiene tanta
importancia.
Supongamos que tenemos una base de datos con todos
los nombre de los lectores de este blog, y supongamos que son miles los
nombres guardados (¡ojalá!...jeje). Ahora queremos leer de la base de
datos todos los nombres y saludarles por pantalla. Creamos un método al
que le pasamos cada nombre leido en un bucle.
static void Saludar(string Nombre)
{
StringBuilder sb = new StringBuilder("Hola para ");
sb.Append(Nombre);
Console.WriteLine(sb.ToString());
}
Esta es la manera correcta de proceder, creando un objeto
System.Text.StringBuilder
y añadiendo cada nueva cadena por medio de su método Append(). Si
queréis podéis descargaros un pequeño programilla que calcula el tiempo
que se tarda en realizar concatenaciones con System.String y
System.Text.StringBuilder en función de un número de iteraciones
introducidas por el usuario.
String_vs_StringBuilder.rar (21,95 kb)
Más cosas a tener en cuenta.
¿Más cosas a tener en cuenta?. Ya dijimos que eran...¡unos tipos de cuidado!.
Cuando
inicializamos variables de tipo Sytem.String y queremos darles un valor
por defecto de cadena vacia es muy frecuente hacerlo con las comillas
"".
class Lector
{
public string Nombre;
public string Apellidos;
public string Direccion;
public string Telefono;
public string Comentario;
public string FechaComentario;
public Lector()
{
Nombre = "";
Apellidos = "";
Direccion = "";
Telefono = "";
Comentario = "";
FechaComentario = "";
}
//...............
//Aquí el resto de mienbros de la clase.
//...............
}
No
es recomendable hacerlo de esta forma. En este caso hemos creado
(cargado en la menoria) 6 objetos diferentes de tipo cadena. Y
seguramente luego "intentaremos" modificarlos al asignarles un valor
determinado. Lo correcto, o por lo menos más recomendable, es hacerlo
así:
public Lector()
{
Nombre = String.Empty;
Apellidos = String.Empty;
Direccion = String.Empty;
Telefono = String.Empty;
Comentario = String.Empty;
FechaComentario = String.Empty;
}
Al utilizar el campo
String.Empty que
representa una cadena vacía, estamos apuntando todas las variables a un
mismo objeto. De esta forma solo reservamos memoria para un único
objeto gracias a que los tipos System.String son tipos por refencia.
Bueno...ya saben...¡cuidado con estos "tipos"!.
Espero que lo disfruten, compartan y comenten. ;)
Visita: http://rubitcorp.co/
"Si se puede imaginar... se puede programar."
