PONTIFICIA UNIVERSIDAD CATÓLICA DE CHILE

ESCUELA DE INGENIERÍA
DEPARTAMENTO DE CIENCIA DE LA COMPUTACIÓN
IIC 1102 INTRODUCCIÓN A LA PROGRAMACIÓN
Profesor: Rodrigo Sandoval U.

Capítulo VIII – Strings en C#

1 CADENAS DE TEXTO..............................................................................................................................................1
1.1 LA CLASE SYSTEM.STRING ....................................................................................................................................1
1.1.1 Declaración de un string...............................................................................................................................1
1.1.2 Operadores básicos sobre un string..............................................................................................................1
1.1.3 Revisando los caracteres individuales de un string ......................................................................................2
1.1.4 Métodos de la clase String ............................................................................................................................2
1.1.5 Ejemplo: Validación de formato de un e-mail ..............................................................................................3
1.1.6 Ejemplo: Manejo de un Diccionario, incluyendo la búsqueda de palabras..................................................4
1.1.7 Ejemplo: Búsqueda y Reemplazo de Texto....................................................................................................7
1.2 TRANSFORMACIÓN DE OTROS TIPOS A STRING ......................................................................................................9
1.2.1 Transformación con Formato .......................................................................................................................9

Material preparado por Rodrigo Sandoval U en Abril 2004

Intro. Prog. Orientada a Objeto – Strings en C# Rodrigo Sandoval U.

1 Cadenas de Texto
Los strings esencialmente son cadenas de texto, compuestas por uno o más caracteres. Si bien no se
incluyen dentro de los tipos básicos de C#, como son el int, el double, el char, efectivamente se reconoció su
enorme importancia al haberse incluido una clase String y su alias string en la base del lenguaje C#.
Internamente, un string, al ser una lista de caracteres, se puede equiparar con un arreglo de char, sin
embargo, dada su propia necesidad funcional, se han agregado diversos atributos y métodos a la clase
String, para simplificar y potenciar su utilización, hasta cierto punto ocultando su real implementación de
arreglo interna.

1.1 La clase System.String

La clase System.String, o simplemente String (cuando se incluyó “using System;” en la primera línea del
programa) es una clase especialmente diseñada para almacenar cadenas de texto, en forma de una
secuencia de caracteres. Dada su importancia, una palabra reservada de C# corresponde a un alias para
esta clase, al igual que en el caso de in (Int), y otros. Esta palabra clave es simplemente string.

1.1.1 Declaración de un string

string <identificador>;

string <identificador> = “valor inicial”;

Algunos ejemplos:

string nombre;
nombre = “Juan Pérez”;

string nombre = “Juan Pérez”;

1.1.2 Operadores básicos sobre un string

Adicionalmente, algunos de los operadores más recurridos dentro de las expresiones del lenguaje C#
también son válidos para trabajar con strings, tal es el caso de la asignación (=), la igualdad (==), y la suma
(+).
Ejemplos:
string nombre;
nombre = “Juan”;

nombre = nombre + “ Pérez”;

Console.WriteLine(nombre);

if( nombre == “Juan Pérez”) Console.WriteLine(“Es igual”);

IIC 1102 Página: 1

Intro. Prog. Orientada a Objeto – Strings en C# Rodrigo Sandoval U.

1.1.3 Revisando los caracteres individuales de un string

Considerando que los strings siguen siendo arreglos, es aún factible utilizar la misma sintaxis para revisar los
caracteres (elementos) según su indexación. Esto se hace mediante la declaración:
<identificador>[indice]
Ejemplo:
string nombre;
nombre = “Juan”;

nombre = nombre + “ Pérez”;

Console.WriteLine(“Iniciales: {0}{1}”, nombre[0],nombre[6]);

1.1.4 Métodos de la clase String

Siendo String una clase derivada de Array, los mismos atributos y métodos de ésta (descritos en el capítulo
anterior), son totalmente válidos. Tal es el caso de Length (atributo), por ejemplo.
Específicamente, los métodos principales de la clase String son los siguientes:

EndsWith Determina si el final de la instancia de String coincide con un substring dado.

Equals Determina si dos strings dados tienen el mismo valor.

Format Formatea un string conteniendo varios valores y especificadores acerca de cómo cada
valor debe ser formateado.

IndexOf Ubica la primera ocurrencia de un substring dado, en el string.

IndexOfAny Ubica la primera ocurrencia de cualquier carácter de un substring dado, en el string.

Insert Inserta un substring en una posición específico dentro del string.

LastIndexOf Igual que IndexOf, pero comenzando desde el final del string.

LastIndexOfAny Igual que IndexOfAny, pero comenzando desde el final del string.

Replace Reemplaza todos los caracter4es de un substring indicado, por otro también indicado.

Split Identifica los substrings en la instancia y los ordena por separado en un arreglo de
strings.

StartsWith Como EndsWith, pero revisando el comienzo del string.

Substring Entrega un substring de la instancia, comenzando en un índice dado.

ToLower Convierte el string as minúsculas.

ToUpper Convierte el string a mayúsculas.

IIC 1102 Página: 2

Intro. Prog. Orientada a Objeto – Strings en C# Rodrigo Sandoval U.

Trim Elimina todos los espacios al comienzo y al final del string.

TrimEnd Elimina todos los espacios al final del string.

TrimStart Elimina todos los espacios al comienzo del string.

1.1.5 Ejemplo: Validación de formato de un e-mail

/////////////////////////////////////////////////////////////////////////////////
// Validación de direcciones e-mail. Las reglas de validación son:
// - Que todos los caracteres sean válidos.
// Sólo letras, dígitos y los símbolos: _ - @ y el punto
// - Que tengan un único símbolo @, ni más ni menos
// - Que tengan al menos un punto a la derecha del @, pero pueden ser más de uno
// - Que el lado izquierdo sea más largo que 0.
// - Por ende, el largo mínimo de un e-mail es 6: x@x.xx
//
// En este ejemplo se ilustra el uso de los siguientes métodos de la clase String:
// IndexOf(), LastIndexOf(), Substring(), ToLower(), Trim()
/////////////////////////////////////////////////////////////////////////////////

using System;

class Email {

public static bool Validar(string email) {

// string que contiene caracteres válidos dentro de un e-mail
string caracteresvalidos = "abcdefghijklmnopqrstuvwxyz1234567890_-.@";

if(email.Length<6) return (false);

// Se valida sobre e-mail en minúsculas y sin espacios antes y después

email = email.ToLower().Trim();

// Verifica todos los caracteres

for (int i=0; i<email.Length; i++)
// ¿Es un caracter no-válido?
if( caracteresvalidos.IndexOf(email[i]) < 0 ) return(false);

// Cantidad de @
if( email.IndexOf('@') < 0 ) return (false); // No había @
if( email.IndexOf('@') != email.LastIndexOf('@') )
return (false); // Hay más de 1 @

// Cantidad de . a la derecha de @.
// Se busca un . sólo en el substring a la derecha del @
if( email.Substring(email.IndexOf('@'),
email.Length-email.IndexOf('@')-1).IndexOf('.') < 0)
return(false);

// Que el @ no sea el primer símbolo

if( email.IndexOf('@') == 0 ) return (false);

return (true);
}
}

IIC 1102 Página: 3

Intro. Prog. Orientada a Objeto – Strings en C# Rodrigo Sandoval U.

class MainApp {
static void Main() {
string email;

do {
Console.Write("Ingrese su e-mail: ");
email = Console.ReadLine();
} while( !Email.Validar(email) );

Console.Write("Gracias. Presione ENTER para terminar ...");

Console.ReadLine();
}
}

1.1.6 Ejemplo: Manejo de un Diccionario, incluyendo la búsqueda de palabras

/////////////////////////////////////////////////////////////////////////////////
// Ejemplo de manejo de un diccionario de palabras
// ===============================================
// Este ejemplo declara una clase Diccionario que maneja una lista de palabras
// (en este caso, nombres de animales). Luego, permitiéndole al usuario ingresar
// nombres o subpalabras a buscar, se filtran y se revisan las palabras del
// diccionario que comienzan con la palabra indicada, o terminan, o la contienen.
//
// En este ejemplo se ilustra el uso de los siguientes métodos de la clase String:
// IndexOf(), StartsWith(), EndsWith(), Trim(), ToUpper(),
/////////////////////////////////////////////////////////////////////////////////

using System;

class Diccionario {

// Lista (arreglo): nombres de animales, ordenados alfabéticamente.

string[] diccionario = {
"AGUILA", "ALBATROS", "ALCE", "ANACONDA", "ANGUILA", "ANTILOPE", "ARAÑA",
"BALLENA", "BISONTE", "BUFALO", "BUITRE",
"CABRA", "CABALLO", "CANGREJO", "CEBRA", "CIERVO", "CISNE", "COBRA",
"CONDOR", "CORMORAN",
"DELFIN", "DINGO",
"ELEFANTE", "EMU", "EQUIDNA", "ESCORPION", "ESTRELLA DE MAR", "ERIZO",
"FAISAN", "FLAMENCO", "FOCA",
"GACELA", "GARZA", "GATO", "GAVILAN", "GAVIOTA", "GORRION", "GOLONDRINA",
"GUEPARDO",
"HALCON", "HIENA", "HIPOPOTAMO", "HORMIGA", "HURON",
"IBIS", "IGUANA",
"JABALI", "JAGUAR", "JAIBA", "JIRAFA", "JOTE",
"LANGOSTA", "LEOPARDO", "LEON", "LEON MARINO", "LOBO", "LOCO",
"LUCIERNAGA",
"MANATI", "MERLUZA", "MONO", "MORSA", "MURCIELAGO",
"NARVAL", "NUTRIA",
"OSO", "OSO HORMIGUERO",
"PANTERA", "PATO", "PAVO", "PERRO", "PERDIZ", "PEREZOSO", "PINGUINO",
"PULPO",
"RATON", "RENO", "RINOCERONTE",
"SALTAMONTES", "SERPIENTE", "SIMIO",
"TAPIR", "TIBURON", "TIGRE", "TUCAN",
"VACA", "VENADO",

IIC 1102 Página: 4

Intro. Prog. Orientada a Objeto – Strings en C# Rodrigo Sandoval U.

"ZORRO", "ZORRILLO" };

// BuscarInicio(palabra): Busca la palabra dada en todos los strings del diccionario

// viendo en cuáles de ellos se encuentra al comienzo
// Retorna: un arreglo de strings con las palabras del diccionario que coincidieron
public string[] BuscarInicio(string palabra) {
string[] resultado;
int cantidad = 0;
int[] posiciones = new int[diccionario.Length];
// Registrar posiciones que empiezan con el string indicado (palabra)
for(int i=0; i<diccionario.Length; i++)
if( diccionario[i].StartsWith(palabra) ) {
posiciones[cantidad] = i;
cantidad++;
}

// Se copian los strings correspondientes

resultado = new string[cantidad];
for(int i=0; i<cantidad; i++)
resultado[i] = diccionario[posiciones[i]];

return(resultado);
}

// BuscarFinal(palabra): Busca la palabra dada en todos los strings del diccionario

// viendo en cuáles de ellos se encuentra al final
// Retorna: un arreglo de strings con las palabras del diccionario que coincidieron
public string[] BuscarFinal(string palabra) {
string[] resultado;
int cantidad = 0;
int[] posiciones = new int[diccionario.Length];
// Registrar posiciones que terminan con el string indicado (palabra)
for(int i=0; i<diccionario.Length; i++)
if( diccionario[i].EndsWith(palabra) ) {
posiciones[cantidad] = i;
cantidad++;
}

// Se copian los strings correspondientes

resultado = new string[cantidad];
for(int i=0; i<cantidad; i++)
resultado[i] = diccionario[posiciones[i]];

return(resultado);
}

// BuscarInicio(palabra): Busca la palabra dada en todos los strings del diccionario

// viendo en cuáles de ellos se encuentra en cualquier parte
// Retorna: un arreglo de strings con las palabras del diccionario que coincidieron
public string[] Buscar(string palabra) {
string[] resultado;
int cantidad = 0;
int[] posiciones = new int[diccionario.Length];
// Registrar las posiciones que contienen el string indicado (palabra)
for(int i=0; i<diccionario.Length; i++)
if( diccionario[i].IndexOf(palabra)>=0 ) {
posiciones[cantidad] = i;
cantidad++;
}

// Se copian los strings correspondientes

resultado = new string[cantidad];
for(int i=0; i<cantidad; i++)

IIC 1102 Página: 5

Intro. Prog. Orientada a Objeto – Strings en C# Rodrigo Sandoval U.

resultado[i] = diccionario[posiciones[i]];

return(resultado);
}
}

class MainApp {
static void Main() {
Diccionario d = new Diccionario();
string palabra;
string[] resultado;

Console.Write("Indique la palabra a buscar: ");

palabra = Console.ReadLine();
// El string ingresado por el usuario debe ser filtrado:
// Primero, eliminar todos los espacios blancos, al comienzo y al final
palabra = palabra.Trim();
Console.WriteLine("Buscando: \"{0}\"", palabra);
// Segundo, la palabra debe venir en mayúsculas
palabra = palabra.ToUpper();
Console.WriteLine("Buscando: \"{0}\"", palabra);

// Primero, los strings que comienzan con la palabra

Console.WriteLine("Los sig. strings comienzan con \"{0}\":",palabra);
resultado = d.BuscarInicio(palabra);
foreach(string s in resultado)
Console.WriteLine(s);

// Segundo, los strings que terminan con la palabra

Console.WriteLine("Los sig. strings terminan con \"{0}\":",palabra);
resultado = d.BuscarFinal(palabra);
foreach(string s in resultado)
Console.WriteLine(s);

// Tercero, los strings que contienen la palabra

Console.WriteLine("Los siguientes strings contienen \"{0}\":",palabra);
resultado = d.Buscar(palabra);
foreach(string s in resultado)
Console.WriteLine(s);

Console.ReadLine();
}
}

Ejemplos de Ejecución
Indique la palabra a buscar: oso
Buscando: "oso"
Buscando: "OSO"
Los siguientes strings comienzan con "OSO":
OSO
OSO HORMIGUERO
Los siguientes strings terminan con "OSO":
OSO
PEREZOSO
Los siguientes strings contienen "OSO":
OSO
OSO HORMIGUERO
PEREZOSO

IIC 1102 Página: 6

Intro. Prog. Orientada a Objeto – Strings en C# Rodrigo Sandoval U.

Indique la palabra a buscar: mo

Buscando: "mo"
Buscando: "MO"
Los siguientes strings comienzan con "MO":
MONO
MORSA
Los siguientes strings terminan con "MO":
HIPOPOTAMO
Los siguientes strings contienen "MO":
CORMORAN
HIPOPOTAMO
MONO
MORSA
SALTAMONTES

1.1.7 Ejemplo: Búsqueda y Reemplazo de Texto

/////////////////////////////////////////////////////////////////////////////////
// Implementación de Find-Replace de los Editores de Texto
// =======================================================
// Entre las funcionalidades que ofrecen los editores de texto hoy en día se encuentra
// la búsqueda y reemplazo de una palabra por otra, todas las veces que ésta aparezca
// en el texto.
// El siguiente programa implementa la búsqueda y reemplazo utilizando las funciones
// y conceptos de string, con las siguientes condiciones:
// * El contenido del texto se almacena en la clase Texto
// * Se incluye el método BuscarReemplazar(str1,str2)
// donde el primer parámetro (str1) es el string a buscar y el segundo (str2)
// es el string por el cual reemplazar el string encontrado.
// * En la búsqueda se consideran idénticas las mayúsculas de las minúsculas, es decir,
// "CASA" es totalmente equivalente a "Casa".
// * La búsqueda no considera palabras acotadas, es decir, al buscar "el",
// se considera que se encontró en "el", "ellos", "aquel".
// * Al encontrar la palabra buscada, se reemplaza el texto de ella por el texto indicado.
// Si el texto encontrado es parte de otra palabra, sólo se reemplaza la porción corresp.
// al texto encontrado. Es decir, si se busca "casa" y se reemplaza por "hogar",
// entonces la frase
// "El casamiento fue en la tarde", quedará como "El hogarmiento fue en la tarde".
// * Se considera ajustar el texto restante: si la palabra buscada tiene distinto
// largo que su reemplazo.
//
// En este ejemplo se ilustra el uso de los siguientes métodos de la clase String:
// IndexOf(), Substring(), ToLower(), Insert(), Remove()
/////////////////////////////////////////////////////////////////////////////////

using System;

class Reemplazo {
public string texto = "En la casa del explorador, se encuentra todo tipo de cosas, " +
"incluyendo fotografías de recuerdo. " +
"Estos objetos son parte de la historia de este explorador, " +
"a través de los años y kilómetros que ha recorrido";

public void BuscarReemplazar(string str1, string str2) {

int posicion = 0; // Se comienza desde el primer caracter (-1+1 = 0)
int indice = 0;
string copiatexto;

IIC 1102 Página: 7

Intro. Prog. Orientada a Objeto – Strings en C# Rodrigo Sandoval U.

do {
// Se busca la sig. posición en que str1 está en el texto
indice = texto.Substring(posicion,texto.Length-posicion).IndexOf(str1);

// Si la posición es válida, se procesa el reemplazo

if ( indice >= 0 ) {
// Se eliminan los caracteres del str1
// de la posición encontrada (pero en la original)
texto = texto.Remove(posicion+indice,str1.Length);
// Se inserta el nuevo string (str2) en la misma posición
texto = texto.Insert(posicion+indice,str2);
posicion += indice;
}
} while(indice>=0);
}

public void BuscarReemplazarDirecto(string str1, string str2) {

str1 = str1.ToLower(); // El texto a buscar también se deja en minúsculas.

texto = texto.Replace(str1,str2);
}

class MainApp {
static void Main() {
Reemplazo r = new Reemplazo();
string str1;
string str2;

Console.WriteLine("** Búsqueda-Reemplazo de texto **");

Console.WriteLine("\nTexto: \"{0}\"\n", r.texto);
Console.Write("Texto a buscar: "); str1 = Console.ReadLine().Trim();
Console.Write("Texto de reemplazo: "); str2 = Console.ReadLine().Trim();

// Se efectúa el reemplazo y se muestra el resultado

r.BuscarReemplazar(str1,str2);
Console.WriteLine("\nTexto modificado: \"{0}\"\n", r.texto);

Console.ReadLine();
}
}

Ejemplos de Ejecución
** Búsqueda-Reemplazo de texto **

Texto: "En la casa del explorador, se encuentra todo tipo de cosas, incluyendo
fotografías de recuerdo. Estos objetos son parte de la historia de este
explorador, a través de los años y kilómetros que ha recorrido"

Texto a buscar: la
Texto de reemplazo: lo

Texto modificado: "En lo casa del explorador, se encuentra todo tipo de cosas,
incluyendo fotografías de recuerdo. Estos objetos son parte de lo historia de
este explorador, a través de los años y kilómetros que ha recorrido"

IIC 1102 Página: 8

Intro. Prog. Orientada a Objeto – Strings en C# Rodrigo Sandoval U.

1.2 Transformación de otros Tipos a String

Es común requerir que datos, que se almacenan en otro tipo de dato de origen, como podría ser un int, char,
float, double, quieran ser transformados a string. Las clases en C#, proveen naturalmente el método
ToString(), que efectivamente transforma el dato correspondiente a un string, incluyendo funcionalidad de
formato.
Ejemplo:
// Transformación básica
int numero = 10;
string num = “El número es “ + numero.ToString();

1.2.1 Transformación con Formato

Al igual que al imprimir texto en pantalla (por medio de Console.Write() y WriteLine()), es posible transformar
tipos básicos a strings, con un formato numérico predefinido. Para ello, el método ToString() en los tipos
numéricos básicos (int, float, double, etc.), permite agregar como parámetro la cadena que indica el formato.
El parámetro es de la forma:
“{formato}”
Formato puede ser uno de los siguientes:
• C o c, para formato monetario (tomado de la configuración de Windows)
• D o d, para números enteros (decimales).
• E o e, para números en formato de exponente (ej: 1.234E+005)
• F o f, para números reales, con parte decimal
• G o g, para formato general.
• N o n, similar a F, pero con la separación de miles.
• P o p, porcentaje.
• R o r, round-trip o viaje redondo, que se usa en números reales. Garantiza que un valor numérico
convertido a string será re-transformado de vuelta sin perder información.
• X o x, número en formato hexadecimal (ej: 1A24C)

Ejemplo:
////////////////////////////////////////////////////////////////////////////////
// Transformación de tipos básicos a strings con formato. Uso de ToString()
/////////////////////////////////////////////////////////////////////////////////

using System;

class ValoresNumericos {

static void Main() {

int[] valores = new int[4];

Console.WriteLine("Proceso de cantidades monetarias");

for(int i=0; i<valores.Length; i++) {

IIC 1102 Página: 9

Intro. Prog. Orientada a Objeto – Strings en C# Rodrigo Sandoval U.

Console.Write("Ingrese el monto {0}: ",i+1);

valores[i] = int.Parse(Console.ReadLine());
}

// Nótese que el formato moneda viene de la configuración de Windows

Console.WriteLine("Los montos son: ");
foreach(int n in valores)
Console.Write("{0}, ", n.ToString("C")); // C: currency (moneda)

int contador=0;
foreach(int n in valores) // Cuenta montos sobre $100
if(n>100) contador++;

Console.WriteLine("De ellos, el {0} es mayor que {1:C}",

((float)contador/ valores.Length).ToString("P"),100);

Console.Write("Presione ENTER para terminar ..."); Console.ReadLine();

}
}

Ejemplos de Ejecución
Proceso de cantidades monetarias
Ingrese el monto 1: 150
Ingrese el monto 2: 1200
Ingrese el monto 3: 23
Ingrese el monto 4: 33
Los montos son:
$ 150, $ 1.200, $ 23, $ 33, De ellos, el 50,00 % es mayor que $ 100
Presione ENTER para terminar ...

IIC 1102 Página: 10