Manejo de Cadenas en C#

Utilizar cadenas (Guía de programación de C#)

Una cadena de C# es una matriz de caracteres que se declara utilizando la palabra clave string. Un literal de cadena se declara utilizando las comillas, como se muestra en el siguiente ejemplo:

string s = "Hello, World!";

Puede extraer subcadenas y concatenar cadenas de la siguiente manera:

string s1 = "orange";
string s2 = "red";

s1 += s2;
System.Console.WriteLine(s1);  // outputs "orangered"

s1 = s1.Substring(2, 5);
System.Console.WriteLine(s1);  // outputs "anger"

Los objetos de cadena son inmutables, lo que significa que no se pueden cambiar una vez creados. Los métodos que actúan sobre las cadenas, devuelven los nuevos objetos de cadena. En el ejemplo anterior, cuando el contenido de s1 y s2 se concatenan para formar una sola cadena, las dos cadenas que contienen "orange" y "red" no se modifican. El operador += crea una nueva cadena que contiene el contenido combinado. Como resultado, s1 ahora hace referencia a una cadena totalmente diferente. Todavía existe una cadena que sólo contiene "orange" , pero deja de hacerse referencia a ella cuando se concatena s1.

Nota
Tenga cuidado cuando cree referencias a cadenas. Si crea una referencia a una cadena y después "modifica" la cadena, la referencia seguirá señalando al objeto original y no al nuevo objeto que se creó cuando se modificó la cadena. Esta situación peligrosa se ilustra en el código siguiente:

string s1 = "Hello";
string s2 = s1;
s1 += " and goodbye.";
Console.WriteLine(s2); //outputs "Hello"

Dado que las modificaciones en las cadenas implican la creación de nuevos objetos de tipo string, por motivos de rendimiento, la concatenación de un gran número de cadenas u otro tipo de manipulación de las cadenas debe realizarse con la clase StringBuilder, como se muestra a continuación:

System.Text.StringBuilder sb = new System.Text.StringBuilder();
sb.Append("one ");
sb.Append("two ");
sb.Append("three");
string str = sb.ToString();

La clase StringBuilder se describe con mayor detalle en la sección "Utilizar Stringbuilder".

Trabajar con cadenas

Carácter de escape
Los caracteres de escape como "\n" y (nueva línea) y "\t" (tabulador) se pueden incluir en cadenas. La línea:

string hello = "Hello\nWorld!";

equivale a:
Hello
World!
Si desea incluir una barra diagonal inversa, ésta debe estar precedida de otra barra diagonal inversa. La cadena siguiente:

string filePath = "\\\\My Documents\\";

equivale a:
\\My Documents\

El símbolo @
El símbolo @ indica al constructor de cadena que debe omitir caracteres de escape y saltos de línea. Las dos cadenas siguientes son, por consiguiente, idénticas:

string p1 = "\\\\My Documents\\My Files\\";
string p2 = @"\\My Documents\My Files\";

ToString()
Al igual que todos los objetos derivados de Object, las cadenas proporcionan el método ToString, que convierte un valor en una cadena. Este método se puede utilizar para convertir valores numéricos en cadenas de la siguiente manera:

int year = 1999;
string msg = "Eve was born in " + year.ToString();
System.Console.WriteLine(msg);  // outputs "Eve was born in 1999"

Tener acceso a los caracteres individuales
Se obtiene acceso a los caracteres individuales contenidos en una cadena utilizando métodos como SubString(), Replace(),, Split() y Trim().

string s3 = "Visual C# Express";

System.Console.WriteLine(s3.Substring(7, 2));         // outputs "C#"
System.Console.WriteLine(s3.Replace("C#", "Basic"));  // outputs "Visual Basic Express"

También es posible copiar los caracteres en una matriz de caracteres, tal como se muestra a continuación:

string s4 = "Hello, World";
char[] arr = s4.ToCharArray(0, s4.Length);

foreach (char c in arr)
{
    System.Console.Write(c);  // outputs "Hello, World"
}

Puede obtener acceso a los caracteres individuales de una cadena con un índice:

string s5 = "Printing backwards";

for (int i = 0; i < s5.Length; i++)
{
    System.Console.Write(s5[s5.Length - i - 1]);  // outputs "sdrawkcab gnitnirP"
}

Cambiar mayúsculas y minúsculas
Para cambiar las letras en una cadena a mayúsculas o minúsculas, se utiliza ToUpper() o ToLower(), de la siguiente forma:

string s6 = "Battle of Hastings, 1066";

System.Console.WriteLine(s6.ToUpper());  // outputs "BATTLE OF HASTINGS 1066"
System.Console.WriteLine(s6.ToLower());  // outputs "battle of hastings 1066"

Comparaciones
La manera más simple de comparar dos cadenas es utilizar los operadores == y !=, que realizan una comparación con distinción entre mayúsculas y minúsculas.

string color1 = "red";
string color2 = "green";
string color3 = "red";

if (color1 == color3)
{
    System.Console.WriteLine("Equal");
}
if (color1 != color2)
{
    System.Console.WriteLine("Not equal");
}

Los objetos String también tienen un método CompareTo() que devuelve un valor entero, basado en si una cadena es menor que (<) o mayor que (>) otra. Al comparar las cadenas, se utiliza el valor Unicode, y las minúsculas tienen un valor menor que las mayúsculas.

string s7 = "ABC";
string s8 = "abc";

if (s7.CompareTo(s8) > 0)
{
    System.Console.WriteLine("Greater-than");
}
else
{
    System.Console.WriteLine("Less-than");
}

Para buscar una cadena dentro de otra, utilice IndexOf(). IndexOf() devuelve -1 si la cadena de búsqueda no se encuentra; en caso contrario devuelve el índice de la primera posición de la cadena, con base cero.

string s9 = "Battle of Hastings, 1066";

System.Console.WriteLine(s9.IndexOf("Hastings"));  // outputs 10
System.Console.WriteLine(s9.IndexOf("1967"));      // outputs -1

Dividir una cadena en subcadenas
Dividir una cadena en subcadenas (al igual que dividir una frase en palabras) es una tarea común de programación. El método Split() toma una matriz de char de delimitadores (por ejemplo, un carácter de espacio) y devuelve una matriz de subcadenas. Para obtener acceso a esta matriz con foreach:

char[] delimit = new char[] { ' ' };
string s10 = "The cat sat on the mat.";
foreach (string substr in s10.Split(delimit))
{
    System.Console.WriteLine(substr);
}

Este código genera cada palabra en una línea separada de la siguiente forma:
The
cat
sat
on
the
mat.

Cadenas nulas y cadenas vacías
Una cadena vacía es una instancia de un objeto System.String que contiene cero caracteres. Las cadenas vacías se utilizan habitualmente en distintos escenarios de programación para representar un campo de texto en blanco. Puede realizar llamadas a métodos en cadenas vacías porque son objetos System.String válidos. Las cadenas vacías se inicializan del modo siguiente:

string s = "";

Por el contrario, una cadena nula no hace referencia a una instancia de un objeto System.String y cualquier intento de llamar a un método en una cadena nula produce una excepción NullReferenceException. Sin embargo, puede utilizar cadenas nulas en operaciones de concatenación y comparación con otras cadenas. Los ejemplos siguientes muestran algunos casos en los que se hace referencia a una cadena nula y no se produce una excepción:

string str = "hello";
string nullStr = null;
string emptyStr = "";

string tempStr  = str + nullStr; // tempStr = "hello"
bool b = (emptyStr == nullStr);// b = false;
emptyStr + nullStr = ""; // creates a new empty string
int I  = nullStr.Length; // throws NullReferenceException

Utilizar StringBuilder

La clase StringBuilder crea un búfer de cadena que proporciona el mejor rendimiento si el programa realiza una gran manipulación de cadenas. La cadena StringBuilder también permite reasignar los caracteres individuales, algo que el tipo de datos de cadena integrado no admite. Por ejemplo, este código cambia el contenido de una cadena sin crear una nueva cadena:

System.Text.StringBuilder sb = new System.Text.StringBuilder("Rat: the ideal pet");
sb[0] = 'C';
System.Console.WriteLine(sb.ToString());
System.Console.ReadLine();

En este ejemplo, se utiliza un objeto StringBuilder para crear una cadena a partir de un conjunto de tipos numéricos:

class TestStringBuilder
{
    static void Main()
    {
        System.Text.StringBuilder sb = new System.Text.StringBuilder();

        // Create a string composed of numbers 0 - 9
        for (int i = 0; i < 10; i++)
        {
            sb.Append(i.ToString());
        }
        System.Console.WriteLine(sb);  // displays 0123456789

        // Copy one character of the string (not possible with a System.String)
        sb[0] = sb[9];

        System.Console.WriteLine(sb);  // displays 9123456789
    }
}