Cadenas (Guía de programación de C#)Strings (C# Programming Guide)

Una cadena es un objeto de tipo String cuyo valor es texto.A string is an object of type String whose value is text. Internamente, el texto se almacena como una colección secuencial de solo lectura de objetos Char.Internally, the text is stored as a sequential read-only collection of Char objects. No hay ningún carácter que finaliza en null al final de una cadena de C#; por lo tanto, la cadena de C# puede contener cualquier número de caracteres nulos insertados ('\0').There is no null-terminating character at the end of a C# string; therefore a C# string can contain any number of embedded null characters ('\0'). La propiedad Length de una cadena representa el número de objetos Char que contiene, no el número de caracteres Unicode.The Length property of a string represents the number of Char objects it contains, not the number of Unicode characters. Para obtener acceso a los puntos de código Unicode individuales de una cadena, use el objeto StringInfo.To access the individual Unicode code points in a string, use the StringInfo object.

cadena frente System.Stringstring vs. System.String

En C#, la palabra clave string es un alias de String.In C#, the string keyword is an alias for String. Por lo tanto, String y string son equivalentes y se puede utilizar la convención de nomenclatura que prefiera.Therefore, String and string are equivalent, and you can use whichever naming convention you prefer. La clase String proporciona muchos métodos para crear, manipular y comparar cadenas de forma segura.The String class provides many methods for safely creating, manipulating, and comparing strings. Además, el lenguaje C# sobrecarga algunos operadores para simplificar las operaciones de cadena comunes.In addition, the C# language overloads some operators to simplify common string operations. Para más información sobre la palabra clave, consulte string.For more information about the keyword, see string. Para obtener más información sobre el tipo y sus métodos, vea String.For more information about the type and its methods, see String.

Declaración e inicialización de cadenasDeclaring and Initializing Strings

Puede declarar e inicializar cadenas de varias maneras, tal como se muestra en el ejemplo siguiente:You can declare and initialize strings in various ways, as shown in the following example:

// Declare without initializing.
string message1;

// Initialize to null.
string message2 = null;

// Initialize as an empty string.
// Use the Empty constant instead of the literal "".
string message3 = System.String.Empty;

// Initialize with a regular string literal.
string oldPath = "c:\\Program Files\\Microsoft Visual Studio 8.0";

// Initialize with a verbatim string literal.
string newPath = @"c:\Program Files\Microsoft Visual Studio 9.0";

// Use System.String if you prefer.
System.String greeting = "Hello World!";

// In local variables (i.e. within a method body)
// you can use implicit typing.
var temp = "I'm still a strongly-typed System.String!";

// Use a const string to prevent 'message4' from
// being used to store another string value.
const string message4 = "You can't get rid of me!";

// Use the String constructor only when creating
// a string from a char*, char[], or sbyte*. See
// System.String documentation for details.
char[] letters = { 'A', 'B', 'C' };
string alphabet = new string(letters);

Tenga en cuenta que no se usa el operador new para crear un objeto de cadena, salvo cuando se inicialice la cadena con una matriz de caracteres.Note that you do not use the new operator to create a string object except when initializing the string with an array of chars.

Inicialice una cadena con el valor constante Empty para crear un objeto String cuya cadena tenga longitud cero.Initialize a string with the Empty constant value to create a new String object whose string is of zero length. La representación literal de la cadena de una cadena de longitud cero es "".The string literal representation of a zero-length string is "". Mediante la inicialización de las cadenas con el valor Empty en lugar de null, puede reducir las posibilidades de que se produzca una excepción NullReferenceException.By initializing strings with the Empty value instead of null, you can reduce the chances of a NullReferenceException occurring. Use el método estático IsNullOrEmpty(String) para comprobar el valor de una cadena antes de intentar obtener acceso a ella.Use the static IsNullOrEmpty(String) method to verify the value of a string before you try to access it.

Inmutabilidad de los objetos de cadenaImmutability of String Objects

Los objetos de cadena son inmutables: no se pueden cambiar después de haberse creado.String objects are immutable: they cannot be changed after they have been created. Todos los métodos String y operadores de C# que parecen modificar una cadena en realidad devuelven los resultados en un nuevo objeto de cadena.All of the String methods and C# operators that appear to modify a string actually return the results in a new string object. En el siguiente ejemplo, cuando el contenido de s1 y s2 se concatena para formar una sola cadena, las dos cadenas originales no se modifican.In the following example, when the contents of s1 and s2 are concatenated to form a single string, the two original strings are unmodified. El operador += crea una nueva cadena que contiene el contenido combinado.The += operator creates a new string that contains the combined contents. Este nuevo objeto se asigna a la variable s1 y el objeto original que se asignó a s1 se libera para la recolección de elementos no utilizados porque ninguna otra variable contiene una referencia a él.That new object is assigned to the variable s1, and the original object that was assigned to s1 is released for garbage collection because no other variable holds a reference to it.

string s1 = "A string is more ";
string s2 = "than the sum of its chars.";

// Concatenate s1 and s2. This actually creates a new
// string object and stores it in s1, releasing the
// reference to the original object.
s1 += s2;

System.Console.WriteLine(s1);
// Output: A string is more than the sum of its chars.

Dado que una "modificación" de cadena es en realidad una creación de cadena, debe tener cuidado al crear referencias a las cadenas.Because a string "modification" is actually a new string creation, you must use caution when you create references to strings. Si crea una referencia a una cadena y después "modifica" la cadena original, la referencia seguirá apuntando al objeto original en lugar de al objeto nuevo creado al modificarse la cadena.If you create a reference to a string, and then "modify" the original string, the reference will continue to point to the original object instead of the new object that was created when the string was modified. El código siguiente muestra este comportamiento:The following code illustrates this behavior:

string s1 = "Hello ";
string s2 = s1;
s1 += "World";

System.Console.WriteLine(s2);
//Output: Hello

Para más información acerca de cómo crear cadenas basadas en modificaciones como las operaciones de buscar y reemplazar en la cadena original, consulte Cómo: Modificar el contenido de cadenasFor more information about how to create new strings that are based on modifications such as search and replace operations on the original string, see How to: Modify String Contents.

Literales de cadena regulares y textualesRegular and Verbatim String Literals

Utilice literales de cadena regulares cuando tenga que insertar caracteres de escape proporcionados por C#, tal como se muestra en el ejemplo siguiente:Use regular string literals when you must embed escape characters provided by C#, as shown in the following example:

string columns = "Column 1\tColumn 2\tColumn 3";
//Output: Column 1        Column 2        Column 3

string rows = "Row 1\r\nRow 2\r\nRow 3";
/* Output:
  Row 1
  Row 2
  Row 3
*/

string title = "\"The \u00C6olean Harp\", by Samuel Taylor Coleridge";
//Output: "The Æolean Harp", by Samuel Taylor Coleridge

Utilice cadenas textuales para mayor comodidad y mejor legibilidad cuando el texto de la cadena contenga caracteres de barra diagonal inversa, por ejemplo, en rutas de acceso de archivo.Use verbatim strings for convenience and better readability when the string text contains backslash characters, for example in file paths. Como las cadenas textuales conservan los caracteres de nueva línea como parte del texto de la cadena, pueden utilizarse para inicializar cadenas multilíneas.Because verbatim strings preserve new line characters as part of the string text, they can be used to initialize multiline strings. Utilice comillas dobles para insertar una comilla simple dentro de una cadena textual.Use double quotation marks to embed a quotation mark inside a verbatim string. En el ejemplo siguiente se muestran algunos usos habituales de las cadenas textuales:The following example shows some common uses for verbatim strings:

string filePath = @"C:\Users\scoleridge\Documents\";
//Output: C:\Users\scoleridge\Documents\

string text = @"My pensive SARA ! thy soft cheek reclined
    Thus on mine arm, most soothing sweet it is
    To sit beside our Cot,...";
/* Output:
My pensive SARA ! thy soft cheek reclined
   Thus on mine arm, most soothing sweet it is
   To sit beside our Cot,... 
*/

string quote = @"Her name was ""Sara.""";
//Output: Her name was "Sara."

Secuencias de escape de cadenaString Escape Sequences

Secuencia de escapeEscape sequence Nombre de carácterCharacter name Codificación UnicodeUnicode encoding
\'\' Comilla simpleSingle quote 0x00270x0027
\"\" Comilla dobleDouble quote 0x00220x0022
\\ Barra diagonal inversaBackslash 0x005C0x005C
\0\0 NullNull 0x00000x0000
\a\a AlertaAlert 0x00070x0007
\b\b RetrocesoBackspace 0x00080x0008
\f\f Avance de páginaForm feed 0x000C0x000C
\n\n Nueva líneaNew line 0x000A0x000A
\r\r Retorno de carroCarriage return 0x000D0x000D
\t\t Tabulación horizontalHorizontal tab 0x00090x0009
\v\v Tabulación verticalVertical tab 0x000B0x000B
\u\u Secuencia de escape Unicode (UTF-16)Unicode escape sequence (UTF-16) \uHHHH (intervalo: 0000 - FFFF; ejemplo: \u00E7 = "ç")\uHHHH (range: 0000 - FFFF; example: \u00E7 = "ç")
\U\U Secuencia de escape Unicode (UTF-32)Unicode escape sequence (UTF-32) \U00HHHHHH (intervalo: 000000 - 10FFFF; ejemplo: \U0001F47D = "👽")\U00HHHHHH (range: 000000 - 10FFFF; example: \U0001F47D = "👽")
\x\x Secuencia de escape Unicode similar a "\u" excepto con longitud variableUnicode escape sequence similar to "\u" except with variable length \xH[H][H][H] (intervalo: 0 - FFFF; ejemplo: \x00E7 o \x0E7 o \xE7 = "ç")\xH[H][H][H] (range: 0 - FFFF; example: \x00E7 or \x0E7 or \xE7 = "ç")

Advertencia

Cuando se usa la secuencia de escape \x y se especifican menos de 4 dígitos hexadecimales, si los caracteres que van inmediatamente después de la secuencia de escape son dígitos hexadecimales válidos (es decir, 0-9, A-f y a-f), se interpretará que forman parte de la secuencia de escape.When using the \x escape sequence and specifying less than 4 hex digits, if the characters that immediately follow the escape sequence are valid hex digits (i.e. 0-9, A-F, and a-f), they will be interpreted as being part of the escape sequence. Por ejemplo, \xA1 genera "¡", que es el punto de código U+00A1.For example, \xA1 produces "¡", which is code point U+00A1. Sin embargo, si el carácter siguiente es "A" o "a", la secuencia de escape se interpretará como \xA1A y producirá "ਚ", que es el punto de código U+0A1A.However, if the next character is "A" or "a", then the escape sequence will instead be interpreted as being \xA1A and produce "ਚ", which is code point U+0A1A. En casos así, se pueden especificar los 4 dígitos hexadecimales (por ejemplo, \x00A1) para evitar posibles errores de interpretación.In such cases, specifying all 4 hex digits (e.g. \x00A1 ) will prevent any possible misinterpretation.

Nota

En tiempo de compilación, las cadenas textuales se convierten en cadenas normales con las mismas secuencias de escape.At compile time, verbatim strings are converted to ordinary strings with all the same escape sequences. Por lo tanto, si se muestra una cadena textual en la ventana Inspección del depurador, verá los caracteres de escape agregados por el compilador, no la versión textual del código fuente.Therefore, if you view a verbatim string in the debugger watch window, you will see the escape characters that were added by the compiler, not the verbatim version from your source code. Por ejemplo, la cadena textual @"C:\files.txt" aparecerá en la ventana Inspección, como "C:\\files.txt".For example, the verbatim string @"C:\files.txt" will appear in the watch window as "C:\\files.txt".

Cadenas de formatoFormat Strings

Una cadena de formato es una cadena cuyo contenido se determina de manera dinámica en tiempo de ejecución.A format string is a string whose contents are determined dynamically at runtime. Las cadenas de formato se crean mediante la inserción de expresiones interpoladas o marcadores de posición entre llaves dentro de una cadena.Format strings are created by embedding interpolated expressions or placeholders inside of braces within a string. Todo lo incluido entre llaves ({...}) se resolverá en un valor y se generará como una cadena con formato en tiempo de ejecución.Everything inside the braces ({...}) will be resolved to a value and output as a formatted string at runtime. Existen dos métodos para crear cadenas de formato: interpolación de cadenas y formato compuesto.There are two methods to create format strings: string interpolation and composite formatting.

Interpolación de cadenasString Interpolation

Disponible en C# 6.0 y versiones posteriores, las cadenas interpoladas se identifican por el carácter especial $ e incluyen expresiones interpoladas entre llaves.Available in C# 6.0 and later, interpolated strings are identified by the $ special character and include interpolated expressions in braces. Si no está familiarizado con la interpolación de cadenas, consulte el tutorial interactivo Interpolación de cadenas en C# para obtener información general rápidamente.If you are new to string interpolation, see the String interpolation - C# interactive tutorial for a quick overview.

Use la interpolación de cadenas para mejorar la legibilidad y el mantenimiento del código.Use string interpolation to improve the readability and maintainability of your code. Con la interpolación de cadenas se obtienen los mismos resultados que con el método String.Format, pero mejora la facilidad de uso y la claridad en línea.String interpolation achieves the same results as the String.Format method, but improves ease of use and inline clarity.

var jh = (firstName: "Jupiter", lastName: "Hammon", born: 1711, published: 1761);
Console.WriteLine($"{jh.firstName} {jh.lastName} was an African American poet born in {jh.born}.");
Console.WriteLine($"He was first published in {jh.published} at the age of {jh.published - jh.born}.");
Console.WriteLine($"He'd be over {Math.Round((2018d - jh.born) / 100d) * 100d} years old today.");

// Output:
// Jupiter Hammon was an African American poet born in 1711.
// He was first published in 1761 at the age of 50.
// He'd be over 300 years old today. 

Formatos compuestosComposite Formatting

String.Format emplea marcadores de posición entre llaves para crear una cadena de formato.The String.Format utilizes placeholders in braces to create a format string. Los resultados de este ejemplo son similares a la salida del método de interpolación de cadenas usado anteriormente.This example results in similar output to the string interpolation method used above.

var pw = (firstName: "Phillis", lastName: "Wheatley", born: 1753, published: 1773);
Console.WriteLine("{0} {1} was an African American poet born in {2}.", pw.firstName, pw.lastName, pw.born);
Console.WriteLine("She was first published in {0} at the age of {1}.", pw.published, pw.published - pw.born);
Console.WriteLine("She'd be over {0} years old today.", Math.Round((2018d - pw.born) / 100d) * 100d);

// Output:
// Phillis Wheatley was an African American poet born in 1753.
// She was first published in 1773 at the age of 20.
// She'd be over 300 years old today.

Para más información sobre cómo dar formato a los tipos .NET, consulte Aplicar formato a tipos en .NET.For more information on formatting .NET types see Formatting Types in .NET.

SubcadenasSubstrings

Una subcadena es cualquier secuencia de caracteres que se encuentra en una cadena.A substring is any sequence of characters that is contained in a string. Use el método Substring para crear una nueva cadena de una parte de la cadena original.Use the Substring method to create a new string from a part of the original string. Puede buscar una o más apariciones de una subcadena con el método IndexOf.You can search for one or more occurrences of a substring by using the IndexOf method. Use el método Replace para reemplazar todas las apariciones de una subcadena especificada por una nueva cadena.Use the Replace method to replace all occurrences of a specified substring with a new string. Al igual que el método Substring, Replace devuelve una cadena nueva y no modifica la cadena original.Like the Substring method, Replace actually returns a new string and does not modify the original string. Para más información, consulte Cómo: Buscar cadenas y Cómo: Modificar el contenido de cadenasFor more information, see How to: search strings and How to: Modify String Contents.

string s3 = "Visual C# Express";
System.Console.WriteLine(s3.Substring(7, 2));
// Output: "C#"

System.Console.WriteLine(s3.Replace("C#", "Basic"));
// Output: "Visual Basic Express"

// Index values are zero-based
int index = s3.IndexOf("C");
// index = 7

Acceso a caracteres individualesAccessing Individual Characters

Puede utilizar la notación de matriz con un valor de índice para adquirir acceso de solo lectura a caracteres individuales, como en el ejemplo siguiente:You can use array notation with an index value to acquire read-only access to individual characters, as in the following example:

string s5 = "Printing backwards";

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

Si el método String no proporciona la funcionalidad que debe tener para modificar los caracteres individuales de una cadena, puede usar un objeto StringBuilder para modificar los caracteres individuales "en contexto" y, después, crear una cadena para almacenar los resultados mediante el método StringBuilder.If the String methods do not provide the functionality that you must have to modify individual characters in a string, you can use a StringBuilder object to modify the individual chars "in-place", and then create a new string to store the results by using the StringBuilder methods. En el ejemplo siguiente, se supone que debe modificar la cadena original de una manera determinada y, después, almacenar los resultados para un uso futuro:In the following example, assume that you must modify the original string in a particular way and then store the results for future use:

string question = "hOW DOES mICROSOFT wORD DEAL WITH THE cAPS lOCK KEY?";
System.Text.StringBuilder sb = new System.Text.StringBuilder(question);

for (int j = 0; j < sb.Length; j++)
{
    if (System.Char.IsLower(sb[j]) == true)
        sb[j] = System.Char.ToUpper(sb[j]);
    else if (System.Char.IsUpper(sb[j]) == true)
        sb[j] = System.Char.ToLower(sb[j]);
}
// Store the new string.
string corrected = sb.ToString();
System.Console.WriteLine(corrected);
// Output: How does Microsoft Word deal with the Caps Lock key?            

Cadenas nulas y cadenas vacíasNull Strings and Empty Strings

Una cadena vacía es una instancia de un objeto System.String que contiene cero caracteres.An empty string is an instance of a System.String object that contains zero characters. Las cadenas vacías se utilizan a menudo en distintos escenarios de programación para representar un campo de texto en blanco.Empty strings are used often in various programming scenarios to represent a blank text field. Puede llamar a métodos en cadenas vacías porque son objetos System.String válidos.You can call methods on empty strings because they are valid System.String objects. Las cadenas vacías se inicializan como sigue:Empty strings are initialized as follows:

string s = String.Empty;  

En cambio, 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.By contrast, a null string does not refer to an instance of a System.String object and any attempt to call a method on a null string causes a NullReferenceException. Sin embargo, puede utilizar cadenas nulas en operaciones de comparación y concatenación con otras cadenas.However, you can use null strings in concatenation and comparison operations with other strings. Los ejemplos siguientes muestran algunos casos en que una referencia a una cadena nula provoca y no provoca una excepción:The following examples illustrate some cases in which a reference to a null string does and does not cause an exception to be thrown:

static void Main()
{
    string str = "hello";
    string nullStr = null;
    string emptyStr = String.Empty;

    string tempStr = str + nullStr;
    // Output of the following line: hello
    Console.WriteLine(tempStr);

    bool b = (emptyStr == nullStr);
    // Output of the following line: False
    Console.WriteLine(b);

    // The following line creates a new empty string.
    string newStr = emptyStr + nullStr;

    // Null strings and empty strings behave differently. The following
    // two lines display 0.
    Console.WriteLine(emptyStr.Length);
    Console.WriteLine(newStr.Length);
    // The following line raises a NullReferenceException.
    //Console.WriteLine(nullStr.Length);

    // The null character can be displayed and counted, like other chars.
    string s1 = "\x0" + "abc";
    string s2 = "abc" + "\x0";
    // Output of the following line: * abc*
    Console.WriteLine("*" + s1 + "*");
    // Output of the following line: *abc *
    Console.WriteLine("*" + s2 + "*");
    // Output of the following line: 4
    Console.WriteLine(s2.Length);
}

Uso de StringBuilder para la creación rápida de cadenasUsing StringBuilder for Fast String Creation

Las operaciones de cadena en .NET están muy optimizadas y en la mayoría de los casos no afectan significativamente al rendimiento.String operations in .NET are highly optimized and in most cases do not significantly impact performance. Sin embargo, en algunos escenarios, como los bucles de pequeñas dimensiones que se ejecutan cientos o miles de veces, las operaciones de cadena pueden afectar al rendimiento.However, in some scenarios such as tight loops that are executing many hundreds or thousands of times, string operations can affect performance. La clase StringBuilder crea un búfer de cadena que proporciona un mejor rendimiento si el programa realiza muchas manipulaciones de cadenas.The StringBuilder class creates a string buffer that offers better performance if your program performs many string manipulations. La cadena StringBuilder también permite reasignar caracteres individuales, algo que el tipo de datos de cadena integrado no admite.The StringBuilder string also enables you to reassign individual characters, something the built-in string data type does not support. Por ejemplo, este código cambia el contenido de una cadena sin crear una nueva:This code, for example, changes the content of a string without creating a new string:

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

//Outputs Cat: the ideal pet

En este ejemplo, se usa un objeto StringBuilder para crear una cadena a partir de un conjunto de tipos numéricos:In this example, a StringBuilder object is used to create a string from a set of numeric types:

using System;
using System.Text;

namespace CSRefStrings
{
    class TestStringBuilder
    {
        static void Main()
        {
            var sb = new StringBuilder();

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

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

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

Cadenas, métodos de extensión y LINQStrings, Extension Methods and LINQ

Dado que el tipo String implementa IEnumerable<T>, puede usar los métodos de extensión definidos en la clase Enumerable en cadenas.Because the String type implements IEnumerable<T>, you can use the extension methods defined in the Enumerable class on strings. Para evitar el desorden visual, estos métodos se excluyen de IntelliSense para el tipo String, pero aun así están disponibles.To avoid visual clutter, these methods are excluded from IntelliSense for the String type, but they are available nevertheless. También puede utilizar expresiones de consulta LINQLINQ en cadenas.You can also use LINQLINQ query expressions on strings. Para más información, consulte LINQ and Strings (LINQ y cadenas).For more information, see LINQ and Strings.

TemaTopic DESCRIPCIÓNDescription
Cómo: Modificar el contenido de cadenasHow to: Modify String Contents Muestra técnicas para transformar cadenas y modificar el contenido de estas.Illustrates techniques to transform strings and modify the contents of strings.
Cómo: Comparar cadenasHow to: Compare Strings Muestra cómo realizar comparaciones ordinales y culturales específicas de las cadenas.Shows how to perform ordinal and culture specific comparisons of strings.
Cómo: Concatenar varias cadenasHow to: Concatenate Multiple Strings Muestra diferentes maneras de combinar varias cadenas en una.Demonstrates various ways to join multiple strings into one.
Cómo: para analizar cadenas mediante String.Split (Guía de C#)How to: Parse Strings Using String.Split Contiene ejemplos de código que muestran cómo utilizar el método String.Split para analizar cadenas.Contains code examples that illustrate how to use the String.Split method to parse strings.
Cómo: Buscar cadenasHow to: Search Strings Explica cómo usar la búsqueda para especificar texto o patrones en cadenas.Explains how to use search for specific text or patterns in strings.
Cómo: Determinar si una cadena representa un valor numéricoHow to: Determine Whether a String Represents a Numeric Value Muestra cómo analizar de forma segura una cadena para ver si tiene un valor numérico válido.Shows how to safely parse a string to see whether it has a valid numeric value.
Interpolación de cadenasString interpolation Describe la característica de interpolación de cadena que proporciona una sintaxis adecuada para dar formato a las cadenas.Describes the string interpolation feature that provides a convenient syntax to format strings.
Operaciones básicas de cadenasBasic String Operations Proporciona vínculos a temas que usan los métodos System.String y System.Text.StringBuilder para realizar operaciones básicas de cadenas.Provides links to topics that use System.String and System.Text.StringBuilder methods to perform basic string operations.
Parsing StringsParsing Strings Describe cómo convertir las representaciones de cadena de los tipos base de .NET en las instancias de los tipos correspondientes.Describes how to convert string representations of .NET base types to instances of the corresponding types.
Analizar cadenas de fecha y hora en .NETParsing Date and Time Strings in .NET Muestra cómo convertir una cadena como "24/01/2008" en un objeto System.DateTime.Shows how to convert a string such as "01/24/2008" to a System.DateTime object.
Comparar cadenasComparing Strings Incluye información sobre cómo comparar cadenas y proporciona ejemplos de C# y Visual Basic.Includes information about how to compare strings and provides examples in C# and Visual Basic.
Utilizar la clase StringBuilderUsing the StringBuilder Class Describe cómo crear y modificar objetos de cadena dinámicos con la clase StringBuilder.Describes how to create and modify dynamic string objects by using the StringBuilder class.
LINQ y cadenasLINQ and Strings Proporciona información sobre cómo realizar varias operaciones de cadena utilizando consultas LINQ.Provides information about how to perform various string operations by using LINQ queries.
Guía de programación de C#C# Programming Guide Proporciona vínculos a temas que explican las construcciones de programación en C#.Provides links to topics that explain programming constructs in C#.