String String String String Class

Definition

Representa texto como una secuencia de unidades de código UTF-16. Represents text as a sequence of UTF-16 code units.

public ref class String sealed : ICloneable, IComparable, IComparable<System::String ^>, IConvertible, IEquatable<System::String ^>, System::Collections::Generic::IEnumerable<char>
[System.Runtime.InteropServices.ComVisible(true)]
[Serializable]
public sealed class String : ICloneable, IComparable, IComparable<string>, IConvertible, IEquatable<string>, System.Collections.Generic.IEnumerable<char>
type string = class
    interface IComparable
    interface ICloneable
    interface IConvertible
    interface IEnumerable
    interface IComparable<string>
    interface seq<char>
    interface IEquatable<string>
Public NotInheritable Class String
Implements ICloneable, IComparable, IComparable(Of String), IConvertible, IEnumerable(Of Char), IEquatable(Of String)
Inheritance
StringStringStringString
Attributes
ComVisibleAttribute SerializableAttribute
Implements

Remarks

Una cadena es una colección secuencial de caracteres que se utiliza para representar texto.A string is a sequential collection of characters that is used to represent text. Un String objeto es una colección secuencial de System.Char objetos que representan una cadena; un System.Char objeto corresponde a una unidad de código UTF-16.A String object is a sequential collection of System.Char objects that represent a string; a System.Char object corresponds to a UTF-16 code unit. El valor de la String objeto es el contenido de la colección secuencial de System.Char objetos, y que el valor es inmutable (es decir, es de solo lectura).The value of the String object is the content of the sequential collection of System.Char objects, and that value is immutable (that is, it is read-only). Para obtener más información acerca de la inmutabilidad de cadenas, vea el inmutabilidad y la clase StringBuilder sección más adelante en este tema.For more information about the immutability of strings, see the Immutability and the StringBuilder class section later in this topic. El tamaño máximo de un String objeto en memoria es 2 GB, o aproximadamente 1 millones de caracteres.The maximum size of a String object in memory is 2GB, or about 1 billion characters.

En esta sección:In this section:

Instancias de un objeto de cadena Instantiating a String object
Los caracteres Unicode y objetos Char Char objects and Unicode characters
Las cadenas y el estándar Unicode Strings and The Unicode Standard
Las cadenas y caracteres nulos incrustados Strings and embedded null characters
Las cadenas e índices Strings and indexes
Cadenas nulas y cadenas vacías Null strings and empty strings
La inmutabilidad y la clase StringBuilder Immutability and the StringBuilder class
Ordinal frente a operaciones sensibles a la referencia cultural Ordinal vs. culture-sensitive operations
Normalización Normalization
Operaciones de cadenas por categoríaString operations by category

Instancias de un objeto de cadenaInstantiating a String object

Puede crear instancias de un String objeto de las maneras siguientes:You can instantiate a String object in the following ways:

  • Mediante la asignación de un literal de cadena a un String variable.By assigning a string literal to a String variable. Este es el método más usado para crear una cadena.This is the most commonly used method for creating a string. El ejemplo siguiente utiliza la asignación para crear varias cadenas.The following example uses assignment to create several strings. Tenga en cuenta que en C#, ya que la barra diagonal inversa (\) es un carácter de escape, se debe escapar barra diagonal literal en una cadena o la cadena completa debe ser @-quoted.Note that in C#, because the backslash (\) is an escape character, literal backslashes in a string must be escaped or the entire string must be @-quoted.

    using namespace System;
    
    void main()
    {
       String^ string1 = "This is a string created by assignment.";
       Console::WriteLine(string1);
       String^ string2a = "The path is C:\\PublicDocuments\\Report1.doc";
       Console::WriteLine(string2a);
    }
    // The example displays the following output: 
    //       This is a string created by assignment. 
    //       The path is C:\PublicDocuments\Report1.doc 
    
    string string1 = "This is a string created by assignment.";
    Console.WriteLine(string1);
    string string2a = "The path is C:\\PublicDocuments\\Report1.doc";
    Console.WriteLine(string2a);
    string string2b = @"The path is C:\PublicDocuments\Report1.doc";
    Console.WriteLine(string2b);
    // The example displays the following output:
    //       This is a string created by assignment.
    //       The path is C:\PublicDocuments\Report1.doc
    //       The path is C:\PublicDocuments\Report1.doc      
    
    Dim string1 As String = "This is a string created by assignment."
    Console.WriteLine(string1)
    Dim string2 As String = "The path is C:\PublicDocuments\Report1.doc"
    Console.WriteLine(string2)
    ' The example displays the following output:
    '       This is a string created by assignment.
    '       The path is C:\PublicDocuments\Report1.doc      
    
  • Mediante una llamada a un String constructor de clase.By calling a String class constructor. El ejemplo siguiente se crea una instancia de cadenas mediante una llamada a varios constructores de clase.The following example instantiates strings by calling several class constructors. Tenga en cuenta que algunos de los constructores son punteros a matrices de caracteres o matrices de bytes con signo como parámetros.Note that some of the constructors include pointers to character arrays or signed byte arrays as parameters. Visual Basic no admite llamadas a estos constructores.Visual Basic does not support calls to these constructors. Para obtener información detallada sobre String constructores, vea el String resumen del constructor.For detailed information about String constructors, see the String constructor summary.

    using namespace System;
    
    void main()
    {
       wchar_t chars[5] = L"word";
       char bytes[6] = { 0x41, 0x42, 0x43, 0x44, 0x45, 0x00 };
    
       // Create a string from a character array. 
       String^ string1 = gcnew String(chars);
       Console::WriteLine(string1);
    
       // Create a string that consists of a character repeated 20 times. 
       String^ string2 = gcnew String('c', 20);
       Console::WriteLine(string2);
    
       String^ stringFromBytes = nullptr;
       String^ stringFromChars = nullptr;
    
       char * pbytes = &bytes[0];
       // Create a string from a pointer to a signed byte array.
       stringFromBytes = gcnew String(pbytes);
    
       wchar_t* pchars =  &chars[0];
       // Create a string from a pointer to a character array.
       stringFromChars = gcnew String(pchars);
    
       Console::WriteLine(stringFromBytes);
       Console::WriteLine(stringFromChars);
       Console::ReadLine();
    }
    // The example displays the following output: 
    //       word 
    //       cccccccccccccccccccc 
    //       ABCDE 
    //       word  
    
    char[] chars = { 'w', 'o', 'r', 'd' };
    sbyte[] bytes = { 0x41, 0x42, 0x43, 0x44, 0x45, 0x00 };
    
    // Create a string from a character array.
    string string1 = new string(chars);
    Console.WriteLine(string1);
    
    // Create a string that consists of a character repeated 20 times.
    string string2 = new string('c', 20);
    Console.WriteLine(string2);
    
    string stringFromBytes = null;
    string stringFromChars = null;
    unsafe
    {
       fixed (sbyte* pbytes = bytes)
       {
          // Create a string from a pointer to a signed byte array.
          stringFromBytes = new string(pbytes);
       }
       fixed (char* pchars = chars)
       {
          // Create a string from a pointer to a character array.
          stringFromChars = new string(pchars);
       }
    }
    Console.WriteLine(stringFromBytes);
    Console.WriteLine(stringFromChars);
    // The example displays the following output:
    //       word
    //       cccccccccccccccccccc
    //       ABCDE
    //       word  
    
    Dim chars() As Char = { "w"c, "o"c, "r"c, "d"c }
    
    ' Create a string from a character array.
    Dim string1 As New String(chars)
    Console.WriteLine(string1)
    
    ' Create a string that consists of a character repeated 20 times.
    Dim string2 As New String("c"c, 20)
    Console.WriteLine(string2)
    ' The example displays the following output:
    '       word
    '       cccccccccccccccccccc      
    
  • Utilizando el operador de concatenación (+ en C# y & o + en Visual Basic) para crear una sola cadena de cualquier combinación de String instancias y literales de cadena.By using the string concatenation operator (+ in C# and & or + in Visual Basic) to create a single string from any combination of String instances and string literals. El ejemplo siguiente muestra el uso del operador de concatenación de cadena.The following example illustrates the use of the string concatenation operator.

    String^ string1 = "Today is " + DateTime::Now.ToString("D") + ".";
    Console::WriteLine(string1);
    
    String^ string2 = "This is one sentence. " + "This is a second. ";
    string2 += "This is a third sentence.";
    Console::WriteLine(string2);
    // The example displays output like the following: 
    //    Today is Tuesday, July 06, 2011. 
    //    This is one sentence. This is a second. This is a third sentence.
    
    string string1 = "Today is " + DateTime.Now.ToString("D") + ".";
    Console.WriteLine(string1);
    
    string string2 = "This is one sentence. " + "This is a second. ";
    string2 += "This is a third sentence.";
    Console.WriteLine(string2);
    // The example displays output like the following:
    //    Today is Tuesday, July 06, 2011.
    //    This is one sentence. This is a second. This is a third sentence.
    
    Dim string1 As String = "Today is " + Date.Now.ToString("D") + "."  
    Console.WriteLine(string1)
    Dim string2 As String = "This is one sentence. " + "This is a second. "
    string2 += "This is a third sentence."
    Console.WriteLine(string2)      
    ' The example displays output like the following:
    '    Today is Tuesday, July 06, 2011.
    '    This is one sentence. This is a second. This is a third sentence.
    
  • Recuperar una propiedad o llamar a un método que devuelve una cadena.By retrieving a property or calling a method that returns a string. El ejemplo siguiente utiliza los métodos de la String clase para extraer una subcadena de una cadena mayor.The following example uses the methods of the String class to extract a substring from a larger string.

    String^ sentence = "This sentence has five words.";
    // Extract the second word.
    int startPosition = sentence->IndexOf(" ") + 1;
    String^ word2 = sentence->Substring(startPosition, 
                                        sentence->IndexOf(" ", startPosition) - startPosition);
    Console::WriteLine("Second word: " + word2);
    
    string sentence = "This sentence has five words.";
    // Extract the second word.
    int startPosition = sentence.IndexOf(" ") + 1;
    string word2 = sentence.Substring(startPosition,
                                      sentence.IndexOf(" ", startPosition) - startPosition);
    Console.WriteLine("Second word: " + word2);
    // The example displays the following output:
    //       Second word: sentence
    
    Dim sentence As String = "This sentence has five words."
    ' Extract the second word.
    Dim startPosition As Integer = sentence.IndexOf(" ") + 1
    Dim word2 As String = sentence.Substring(startPosition, 
                                             sentence.IndexOf(" ", startPosition) - startPosition) 
    Console.WriteLine("Second word: " + word2)
    ' The example displays the following output:
    '       Second word: sentence
    
  • Mediante una llamada a un método para convertir un valor u objeto en su representación de cadena de formato.By calling a formatting method to convert a value or object to its string representation. En el ejemplo siguiente se usa el formatos compuestos característica para incrustar la representación de cadena de dos objetos en una cadena.The following example uses the composite formatting feature to embed the string representation of two objects into a string.

    DateTime^ dateAndTime = gcnew DateTime(2011, 7, 6, 7, 32, 0);
    Double temperature = 68.3;
    String^ result = String::Format("At {0:t} on {0:D}, the temperature was {1:F1} degrees Fahrenheit.",
                                   dateAndTime, temperature);
    Console::WriteLine(result);
    // The example displays the following output: 
    //       At 7:32 AM on Wednesday, July 06, 2011, the temperature was 68.3 degrees Fahrenheit.      
    
    DateTime dateAndTime = new DateTime(2011, 7, 6, 7, 32, 0);
    double temperature = 68.3;
    string result = String.Format("At {0:t} on {0:D}, the temperature was {1:F1} degrees Fahrenheit.",
                                  dateAndTime, temperature);
    Console.WriteLine(result);
    // The example displays the following output:
    //       At 7:32 AM on Wednesday, July 06, 2011, the temperature was 68.3 degrees Fahrenheit.      
    
    Dim dateAndTime As DateTime = #07/06/2011 7:32:00AM#
    Dim temperature As Double = 68.3
    Dim result As String = String.Format("At {0:t} on {0:D}, the temperature was {1:F1} degrees Fahrenheit.",
                                         dateAndTime, temperature)
    Console.WriteLine(result)
    ' The example displays the following output:
    '       At 7:32 AM on Wednesday, July 06, 2011, the temperature was 68.3 degrees Fahrenheit.      
    

Los caracteres Unicode y objetos CharChar objects and Unicode characters

Cada carácter de una cadena se define mediante un valor escalar Unicode, también denominado punto de código Unicode o el valor ordinal (numérico) del carácter Unicode.Each character in a string is defined by a Unicode scalar value, also called a Unicode code point or the ordinal (numeric) value of the Unicode character. Cada punto de código se codifica utilizando la codificación UTF-16, y el valor numérico de cada elemento de la codificación se representa mediante un Char objeto.Each code point is encoded by using UTF-16 encoding, and the numeric value of each element of the encoding is represented by a Char object.

Nota

Tenga en cuenta que, dado un String instancia se compone de una colección secuencial de unidades de código UTF-16, es posible crear un String objeto que no es una cadena Unicode con formato correcto.Note that, because a String instance consists of a sequential collection of UTF-16 code units, it is possible to create a String object that is not a well-formed Unicode string. Por ejemplo, es posible crear una cadena que tenga un suplente bajo sin un suplente alto correspondiente.For example, it is possible to create a string that has a low surrogate without a corresponding high surrogate. Aunque algunos métodos, como los métodos de codificación y descodificación de objetos en el System.Text espacio de nombres, es posible que realiza comprobaciones para asegurarse de que las cadenas están bien formadas, String los miembros de clase no garantizan que una cadena es correcta.Although some methods, such as the methods of encoding and decoding objects in the System.Text namespace, may performs checks to ensure that strings are well-formed, String class members don't ensure that a string is well-formed.

Una sola Char objeto normalmente representa un único punto de código; es decir, el valor numérico de la Char es igual al punto de código.A single Char object usually represents a single code point; that is, the numeric value of the Char equals the code point. Por ejemplo, el punto de código para el carácter "a" es u+0061.For example, the code point for the character "a" is U+0061. Sin embargo, un punto de código podría requerir más de un elemento codificado (más de un Char objeto).However, a code point might require more than one encoded element (more than one Char object). El estándar Unicode define dos tipos de caracteres que corresponden a varios Char objetos: graphemes y puntos de código adicionales que se corresponden con los caracteres de los aviones con Unicode.The Unicode standard defines two types of characters that correspond to multiple Char objects: graphemes, and Unicode supplementary code points that correspond to characters in the Unicode supplementary planes.

  • Un grafemas está representado por un carácter base seguido de uno o más caracteres de combinación.A grapheme is represented by a base character followed by one or more combining characters. Por ejemplo, el carácter Unicote se representa mediante un Char objeto cuyo punto de código está seguido por un u+0061 Char objeto cuyo punto de código es + u+0308.For example, the character ä is represented by a Char object whose code point is U+0061 followed by a Char object whose code point is U+0308. Este carácter también puede definirse mediante una sola Char objeto que tiene un punto de código de 00E4 U +.This character can also be defined by a single Char object that has a code point of U+00E4. Como se muestra en el ejemplo siguiente, una comparación de referencias culturales de igualdad indica que estas dos representaciones son iguales, aunque no lo hace una comparación ordinal normal.As the following example shows, a culture-sensitive comparison for equality indicates that these two representations are equal, although an ordinary ordinal comparison does not. Sin embargo, si se normalizan las dos cadenas, una comparación ordinal también indica si son iguales.However, if the two strings are normalized, an ordinal comparison also indicates that they are equal. (Para obtener más información sobre la normalización de cadenas, vea el normalización sección.)(For more information on normalizing strings, see the Normalization section.)

    using namespace System;
    using namespace System::Globalization;
    using namespace System::IO;
    
    void main()
    {
       StreamWriter^ sw = gcnew StreamWriter(".\\graphemes.txt");
       String^ grapheme = L"a" + L"\u0308";
       sw->WriteLine(grapheme);
    
       String^ singleChar = "\u00e4";
       sw->WriteLine(singleChar);
    
       sw->WriteLine("{0} = {1} (Culture-sensitive): {2}", grapheme, singleChar, 
                      String::Equals(grapheme, singleChar, 
                                  StringComparison::CurrentCulture));
       sw->WriteLine("{0} = {1} (Ordinal): {2}", grapheme, singleChar, 
                      String::Equals(grapheme, singleChar, 
                                  StringComparison::Ordinal));
       sw->WriteLine("{0} = {1} (Normalized Ordinal): {2}", grapheme, singleChar, 
                      String::Equals(grapheme->Normalize(), 
                                  singleChar->Normalize(), 
                                  StringComparison::Ordinal));
       sw->Close(); 
    }
    // The example produces the following output: 
    //       ä 
    //       ä 
    //       ä = ä (Culture-sensitive): True 
    //       ä = ä (Ordinal): False 
    //       ä = ä (Normalized Ordinal): True
    
    using System;
    using System.Globalization;
    using System.IO;
    
    public class Example
    {
       public static void Main()
       {
          StreamWriter sw = new StreamWriter(@".\graphemes.txt");
          string grapheme = "\u0061\u0308";
          sw.WriteLine(grapheme);
          
          string singleChar = "\u00e4";
          sw.WriteLine(singleChar);
                
          sw.WriteLine("{0} = {1} (Culture-sensitive): {2}", grapheme, singleChar, 
                       String.Equals(grapheme, singleChar, 
                                     StringComparison.CurrentCulture));
          sw.WriteLine("{0} = {1} (Ordinal): {2}", grapheme, singleChar, 
                       String.Equals(grapheme, singleChar, 
                                     StringComparison.Ordinal));
          sw.WriteLine("{0} = {1} (Normalized Ordinal): {2}", grapheme, singleChar, 
                       String.Equals(grapheme.Normalize(), 
                                     singleChar.Normalize(), 
                                     StringComparison.Ordinal));
          sw.Close(); 
       }
    }
    // The example produces the following output:
    //       ä
    //       ä
    //       ä = ä (Culture-sensitive): True
    //       ä = ä (Ordinal): False
    //       ä = ä (Normalized Ordinal): True
    
    Imports System.Globalization
    Imports System.IO
    
    Module Example
       Public Sub Main()
          Dim sw As New StreamWriter(".\graphemes.txt")
          Dim grapheme As String = ChrW(&H0061) + ChrW(&h0308)
          sw.WriteLine(grapheme)
          
          Dim singleChar As String = ChrW(&h00e4)
          sw.WriteLine(singleChar)
                
          sw.WriteLine("{0} = {1} (Culture-sensitive): {2}", grapheme, singleChar, 
                       String.Equals(grapheme, singleChar, 
                                     StringComparison.CurrentCulture))
          sw.WriteLine("{0} = {1} (Ordinal): {2}", grapheme, singleChar, 
                       String.Equals(grapheme, singleChar, 
                                     StringComparison.Ordinal))
          sw.WriteLine("{0} = {1} (Normalized Ordinal): {2}", grapheme, singleChar, 
                       String.Equals(grapheme.Normalize(), 
                                     singleChar.Normalize(), 
                                     StringComparison.Ordinal))
          sw.Close() 
       End Sub
    End Module
    ' The example produces the following output:
    '       ä
    '       ä
    '       ä = ä (Culture-sensitive): True
    '       ä = ä (Ordinal): False
    '       ä = ä (Normalized Ordinal): True
    
  • Unicode (un par suplente) del punto de código adicional se representa mediante un Char objeto cuyo punto de código es un suplente alto seguido por un Char objeto cuyo punto de código es un suplente bajo.A Unicode supplementary code point (a surrogate pair) is represented by a Char object whose code point is a high surrogate followed by a Char object whose code point is a low surrogate. Las unidades de código suplentes altos del intervalo de u+D800 a U+DBFF.The code units of high surrogates range from U+D800 to U+DBFF. Las unidades de código suplentes bajo del intervalo de u+DC00 a U+DFFF.The code units of low surrogates range from U+DC00 to U+DFFF. Los pares suplentes se utilizan para representar los caracteres de los aviones con 16 de Unicode.Surrogate pairs are used to represent characters in the 16 Unicode supplementary planes. El ejemplo siguiente se crea un carácter suplente y lo pasa a la Char.IsSurrogatePair(Char, Char) método para determinar si se trata de un par suplente.The following example creates a surrogate character and passes it to the Char.IsSurrogatePair(Char, Char) method to determine whether it is a surrogate pair.

    using namespace System;
    
    void main()
    {
       String^ surrogate =  L"\xD800\xDC03" ;
       for (int ctr = 0; ctr < surrogate->Length; ctr++)
          Console::Write("U+{0:X4} ", Convert::ToUInt16(surrogate[ctr]));
    
       Console::WriteLine();
       Console::WriteLine("   Is Surrogate Pair: {0}", 
                          Char::IsSurrogatePair(surrogate[0], surrogate[1]));
       Console::ReadLine();
    }
    // The example displays the following output: 
    //       U+D800 U+DC03 
    //          Is Surrogate Pair: True
    
    using System;
    
    public class Example
    {
       public static void Main()
       {
          string surrogate = "\uD800\uDC03";
          for (int ctr = 0; ctr < surrogate.Length; ctr++) 
             Console.Write("U+{0:X2} ", Convert.ToUInt16(surrogate[ctr]));
    
          Console.WriteLine();
          Console.WriteLine("   Is Surrogate Pair: {0}", 
                            Char.IsSurrogatePair(surrogate[0], surrogate[1]));
       }
    }
    // The example displays the following output:
    //       U+D800 U+DC03
    //          Is Surrogate Pair: True
    
    Module Example
       Public Sub Main()
          Dim surrogate As String = ChrW(&hD800) + ChrW(&hDC03)
          For ctr As Integer = 0 To surrogate.Length - 1
             Console.Write("U+{0:X2} ", Convert.ToUInt16(surrogate(ctr)))
          Next   
          Console.WriteLine()
          Console.WriteLine("   Is Surrogate Pair: {0}", 
                            Char.IsSurrogatePair(surrogate(0), surrogate(1)))
       End Sub
    End Module
    
    ' The example displays the following output:
    '       U+D800 U+DC03
    '          Is Surrogate Pair: True
    

Las cadenas y el estándar UnicodeStrings and the Unicode Standard

Caracteres de una cadena se representan mediante unidades de código con codificación UTF-16, que corresponden a Char valores.Characters in a string are represented by UTF-16 encoded code units, which correspond to Char values.

Cada carácter de una cadena tiene una categoría de caracteres Unicode asociada, que se representa en .NET mediante el UnicodeCategory enumeración.Each character in a string has an associated Unicode character category, which is represented in .NET by the UnicodeCategory enumeration. La categoría de un carácter o un par suplente se puede determinar mediante una llamada a la CharUnicodeInfo.GetUnicodeCategory método.The category of a character or a surrogate pair can be determined by calling the CharUnicodeInfo.GetUnicodeCategory method.

.NET dispone de una tabla propia de caracteres y de sus categorías correspondientes, cosa que permite garantizar que una versión específica de una implementación de .NET ejecutada en distintas plataformas devuelve la misma información sobre las categorías de caracteres..NET maintains its own table of characters and their corresponding categories, which ensures that a specific version of a .NET implementation running on different platforms returns identical character category information. En el caso de .NET Core, al ejecutarlo en Linux y macOS, la información sobre categorías de caracteres se proporciona mediante las bibliotecas de International Components for Unicode (Componentes internacionales de Unicode).On .NET Core running on Linux and macOS, character category information is provided by International Components for Unicode libraries.

En la tabla siguiente se enumeran las versiones de .NET y del estándar Unicode en las que se basan sus categorías de caracteres.The following table lists .NET versions and the versions of the Unicode Standard on which their character categories are based.

Versión de .NET.NET version Versión del estándar UnicodeVersion of the Unicode Standard
.NET Framework 1.1.NET Framework 1.1 Estándar Unicode, versión 4.0.0The Unicode Standard, Version 4.0.0
.NET Framework 2.0.NET Framework 2.0 Estándar Unicode, versión 5.0.0The Unicode Standard, Version 5.0.0
.NET Framework 3,5.NET Framework 3.5 Estándar Unicode, versión 5.0.0The Unicode Standard, Version 5.0.0
.NET Framework 4.NET Framework 4 Estándar Unicode, versión 5.0.0The Unicode Standard, Version 5.0.0
.NET Framework 4.5.NET Framework 4.5 Estándar Unicode, versión 6.3.0The Unicode Standard, Version 6.3.0
.NET Framework 4.51.NET Framework 4.51 Estándar Unicode, versión 6.3.0The Unicode Standard, Version 6.3.0
.NET Framework 4.52.NET Framework 4.52 Estándar Unicode, versión 6.3.0The Unicode Standard, Version 6.3.0
.NET Framework 4.6.NET Framework 4.6 Estándar Unicode, versión 6.3.0The Unicode Standard, Version 6.3.0
.NET Framework 4.61.NET Framework 4.61 Estándar Unicode, versión 6.3.0The Unicode Standard, Version 6.3.0
.NET Framework 4.6.2 y versiones posteriores.NET Framework 4.6.2 and later versions Estándar Unicode, versión 8.0.0The Unicode Standard, Version 8.0.0
.NET Core (todas las versiones).NET Core (all versions) Estándar Unicode, versión 8.0.0The Unicode Standard, Version 8.0.0

Además, .NET admite la comparación de cadenas y ordenar según el estándar Unicode.In addition, .NET supports string comparison and sorting based on the Unicode standard. En las versiones de .NET Framework a través de la .NET Framework 4.NET Framework 4, .NET Framework mantiene su propia tabla de datos de cadena.In versions of the .NET Framework through the .NET Framework 4.NET Framework 4, the .NET Framework maintains its own table of string data. También es el caso de las versiones de .NET Framework a partir de la .NET Framework 4.5.NET Framework 4.5 que se ejecutan en Windows 7.This is also true of versions of the .NET Framework starting with the .NET Framework 4.5.NET Framework 4.5 running on Windows 7. A partir de la .NET Framework 4.5.NET Framework 4.5 que se ejecutan en Windows 8 y versiones posteriores del sistema operativo Windows, la cadena de los delegados en tiempo de ejecución de comparaciones y ordenaciones de las operaciones en el sistema operativo.Starting with the .NET Framework 4.5.NET Framework 4.5 running on Window 8 and later versions of the Windows operating system, the runtime delegates string comparison and sorting operations to the operating system. Comparación de cadenas en .NET Core, y ordenar la información proporcionada por International Components for Unicode bibliotecas. En la tabla siguiente se enumera las versiones de .NET y las versiones del estándar Unicode en caracteres que se basan las comparaciones y ordenaciones.On .NET Core, string comparison and sorting information is provided by International Components for Unicode libraries.The following table lists the versions of .NET and the versions of the Unicode Standard on which character comparison and sorting are based.

Versión de .NET.NET version Versión del estándar UnicodeVersion of the Unicode Standard
.NET Framework 1.1.NET Framework 1.1 Estándar Unicode, versión 4.0.0The Unicode Standard, Version 4.0.0
.NET Framework 2.0The .NET Framework 2.0 Estándar Unicode, versión 5.0.0The Unicode Standard, Version 5.0.0
.NET Framework 3,5.NET Framework 3.5 Estándar Unicode, versión 5.0.0The Unicode Standard, Version 5.0.0
.NET Framework 4.NET Framework 4 Estándar Unicode, versión 5.0.0The Unicode Standard, Version 5.0.0
.NET Framework 4.5.NET Framework 4.5 y versiones posteriores en Windows 7and later on Windows 7 Estándar Unicode, versión 5.0.0The Unicode Standard, Version 5.0.0
.NET Framework 4.5.NET Framework 4.5 y versiones posteriores en Windows 8 y los sistemas operativos de Windows posterioresand later on Windows 8 and later Windows operating systems Estándar Unicode, versión 6.3.0The Unicode Standard, Version 6.3.0
.NET Core (todas las versiones).NET Core (all versions) Depende de la versión del estándar Unicode compatibles con el sistema operativo subyacente.Depends on the version of the Unicode Standard supported by the underlying operating system.

Las cadenas y caracteres nulos incrustadosStrings and embedded null characters

En. NET, un String objeto puede incluir caracteres nulos incrustados, que cuentan como parte de la longitud de cadena.In .NET, a String object can include embedded null characters, which count as a part of the string's length. Sin embargo, en algunos lenguajes como C y C++, un carácter null indica el final de una cadena; no se considera parte de la cadena y no se cuentan como parte de la longitud de cadena.However, in some languages such as C and C++, a null character indicates the end of a string; it is not considered a part of the string and is not counted as part of the string's length. Esto significa que las suposiciones siguientes comunes que podrían hacer que los programadores de C y C++ o bibliotecas escritas en C o C++ acerca de las cadenas no son necesariamente válidas cuando se aplica a String objetos:This means that the following common assumptions that C and C++ programmers or libraries written in C or C++ might make about strings are not necessarily valid when applied to String objects:

  • El valor devuelto por la strlen o wcslen funciones no es necesariamente igual String.Length.The value returned by the strlen or wcslen functions does not necessarily equal String.Length.

  • La cadena creada por el strcpy_s o wcscpy_s funciones no es necesariamente idéntica a la cadena creada por el String.Copy método.The string created by the strcpy_s or wcscpy_s functions is not necessarily identical to the string created by the String.Copy method.

Debe asegurarse de ese código de C y C++ nativo que crea una instancia de String objetos y el código que se pasa String objetos a través de la plataforma de invocación, no suponga que un carácter nulo incrustado marca el final de la cadena.You should ensure that native C and C++ code that instantiates String objects, and code that is passed String objects through platform invoke, don't assume that an embedded null character marks the end of the string.

Caracteres nulos incrustados en una cadena también se tratan de forma diferente cuando una cadena se ordenan (o en comparación con) y cuando se busca una cadena.Embedded null characters in a string are also treated differently when a string is sorted (or compared) and when a string is searched. Caracteres null se omiten al realizar comparaciones entre dos cadenas, incluyendo las comparaciones con la referencia cultural invariable.Null characters are ignored when performing culture-sensitive comparisons between two strings, including comparisons using the invariant culture. Se consideran sólo para las comparaciones ordinales ordinales o mayúsculas y minúsculas.They are considered only for ordinal or case-insensitive ordinal comparisons. Por otro lado, siempre se consideran caracteres nulos incrustados al buscar una cadena con métodos como Contains, StartsWith, y IndexOf.On the other hand, embedded null characters are always considered when searching a string with methods such as Contains, StartsWith, and IndexOf.

Las cadenas e índicesStrings and indexes

Un índice es la posición de un Char objeto (no un carácter Unicode) en un String.An index is the position of a Char object (not a Unicode character) in a String. Un índice es un número no negativo de base cero que se inicia desde la primera posición en la cadena, que es la posición de índice cero.An index is a zero-based, nonnegative number that starts from the first position in the string, which is index position zero. Un número de métodos de búsqueda, como IndexOf y LastIndexOf, devolver el índice de un carácter o subcadena en la instancia de cadena.A number of search methods, such as IndexOf and LastIndexOf, return the index of a character or substring in the string instance.

El Chars[Int32] propiedad le permite tener acceso a individuales Char objetos por su posición de índice en la cadena.The Chars[Int32] property lets you access individual Char objects by their index position in the string. Dado que el Chars[Int32] propiedad es la propiedad predeterminada (en Visual Basic) o el indizador (en C#), puede tener acceso a la persona Char objetos en una cadena mediante código como el siguiente.Because the Chars[Int32] property is the default property (in Visual Basic) or the indexer (in C#), you can access the individual Char objects in a string by using code such as the following. Este código busca un espacio en blanco o caracteres de puntuación en una cadena para determinar el número de palabras contiene la cadena.This code looks for white space or punctuation characters in a string to determine how many words the string contains.

using namespace System;

void main()
{
   String^ s1 = "This string consists of a single short sentence.";
   int nWords = 0;

   s1 = s1->Trim();      
   for (int ctr = 0; ctr < s1->Length; ctr++) {
         if (Char::IsPunctuation(s1[ctr]) | Char::IsWhiteSpace(s1[ctr]))
            nWords++;              
   }
   Console::WriteLine("The sentence\n   {0}\nhas {1} words.",
                     s1, nWords);           
}
// The example displays the following output: 
//       The sentence 
//          This string consists of a single short sentence. 
//       has 8 words.
using System;

public class Example
{
   public static void Main()
   {
      string s1 = "This string consists of a single short sentence.";
      int nWords = 0;

      s1 = s1.Trim();      
      for (int ctr = 0; ctr < s1.Length; ctr++) {
         if (Char.IsPunctuation(s1[ctr]) | Char.IsWhiteSpace(s1[ctr]))
            nWords++;              
      }
      Console.WriteLine("The sentence\n   {0}\nhas {1} words.",
                        s1, nWords);                                                                     
   }
}
// The example displays the following output:
//       The sentence
//          This string consists of a single short sentence.
//       has 8 words.
Module Example
   Public Sub Main()
      Dim s1 As String = "This string consists of a single short sentence."
      Dim nWords As Integer = 0

      s1 = s1.Trim()      
      For ctr As Integer = 0 To s1.Length - 1
         If Char.IsPunctuation(s1(ctr)) Or Char.IsWhiteSpace(s1(ctr)) 
            nWords += 1              
         End If   
      Next
      Console.WriteLine("The sentence{2}   {0}{2}has {1} words.",
                        s1, nWords, vbCrLf)                                                                     
   End Sub
End Module
' The example displays the following output:
'       The sentence
'          This string consists of a single short sentence.
'       has 8 words.

Porque el String la clase implementa la IEnumerable interfaz, también puede iterar por la Char objetos en una cadena mediante un foreach construcción, como se muestra en el ejemplo siguiente.Because the String class implements the IEnumerable interface, you can also iterate through the Char objects in a string by using a foreach construct, as the following example shows.

using namespace System;

void main()
{
   String^ s1 = "This string consists of a single short sentence.";
   int nWords = 0;

   s1 = s1->Trim();      
   for each (Char ch in s1)
   {
      if (Char::IsPunctuation(ch) | Char::IsWhiteSpace(ch))
         nWords++;              
   }
   Console::WriteLine("The sentence\n   {0}\nhas {1} words.",
                      s1, nWords);  
   Console::ReadLine();
}
// The example displays the following output: 
//       The sentence 
//          This string consists of a single short sentence. 
//       has 8 words.
using System;

public class Example
{
   public static void Main()
   {
      string s1 = "This string consists of a single short sentence.";
      int nWords = 0;

      s1 = s1.Trim();      
      foreach (var ch in s1) {
         if (Char.IsPunctuation(ch) | Char.IsWhiteSpace(ch))
            nWords++;              
      }
      Console.WriteLine("The sentence\n   {0}\nhas {1} words.",
                        s1, nWords);                                                                     
   }
}
// The example displays the following output:
//       The sentence
//          This string consists of a single short sentence.
//       has 8 words.
Module Example
   Public Sub Main()
      Dim s1 As String = "This string consists of a single short sentence."
      Dim nWords As Integer = 0

      s1 = s1.Trim()      
      For Each ch In s1
         If Char.IsPunctuation(ch) Or Char.IsWhiteSpace(ch) Then 
            nWords += 1              
         End If   
      Next
      Console.WriteLine("The sentence{2}   {0}{2}has {1} words.",
                        s1, nWords, vbCrLf)                                                                     
   End Sub
End Module
' The example displays the following output:
'       The sentence
'          This string consists of a single short sentence.
'       has 8 words.

Valores de índice consecutivos no pueden corresponderse con caracteres Unicode consecutivos, porque podría ser el carácter Unicode codificado como más de un Char objeto.Consecutive index values might not correspond to consecutive Unicode characters, because a Unicode character might be encoded as more than one Char object. En concreto, una cadena puede contener varios caracteres unidades de texto que están formadas por un carácter base seguido por uno o más caracteres de combinación o por pares suplentes.In particular, a string may contain multi-character units of text that are formed by a base character followed by one or more combining characters or by surrogate pairs. Para trabajar con caracteres Unicode en lugar de Char objetos, utilice el System.Globalization.StringInfo y TextElementEnumerator clases.To work with Unicode characters instead of Char objects, use the System.Globalization.StringInfo and TextElementEnumerator classes. El ejemplo siguiente muestra la diferencia entre el código que funciona con Char objetos y el código que funciona con los caracteres Unicode.The following example illustrates the difference between code that works with Char objects and code that works with Unicode characters. Compara el número de caracteres o elementos de texto de cada palabra de una frase.It compares the number of characters or text elements in each word of a sentence. La cadena incluye dos secuencias de un carácter base seguido por un carácter de combinación.The string includes two sequences of a base character followed by a combining character.

using namespace System;
using namespace System::Collections::Generic;
using namespace System::Globalization;

void main()
{
   // First sentence of The Mystery of the Yellow Room, by Leroux. 
   String^ opening = L"Ce n'est pas sans une certaine émotion que "+
                     L"je commence à raconter ici les aventures " +
                     L"extraordinaires de Joseph Rouletabille."; 
  
   // Character counters. 
   int nChars = 0;
   // Objects to store word count.
   List<int>^ chars = gcnew List<int>();
   List<int>^ elements = gcnew List<int>();

   for each (Char ch in opening) {
      // Skip the ' character. 
      if (ch == '\x0027') continue;

      if (Char::IsWhiteSpace(ch) | (Char::IsPunctuation(ch))) {
         chars->Add(nChars);
         nChars = 0;
      }
      else {
         nChars++;
      }
   }

   TextElementEnumerator^ te = StringInfo::GetTextElementEnumerator(opening);
   while (te->MoveNext()) {
      String^ s = te->GetTextElement();   
      // Skip the ' character. 
      if (s == "\x0027") continue;
      if ( String::IsNullOrEmpty(s->Trim()) | (s->Length == 1 && Char::IsPunctuation(Convert::ToChar(s)))) {
         elements->Add(nChars);         
         nChars = 0;
      }
      else {
         nChars++;
      }
   }

   // Display character counts.
   Console::WriteLine("{0,6} {1,20} {2,20}",
                      "Word #", "Char Objects", "Characters"); 
   for (int ctr = 0; ctr < chars->Count; ctr++) 
      Console::WriteLine("{0,6} {1,20} {2,20}",
                         ctr, chars[ctr], elements[ctr]); 
   Console::ReadLine();
}
// The example displays the following output:
//      Word #         Char Objects           Characters
//           0                    2                    2
//           1                    4                    4
//           2                    3                    3
//           3                    4                    4
//           4                    3                    3
//           5                    8                    8
//           6                    8                    7
//           7                    3                    3
//           8                    2                    2
//           9                    8                    8
//          10                    2                    1
//          11                    8                    8
//          12                    3                    3
//          13                    3                    3
//          14                    9                    9
//          15                   15                   15
//          16                    2                    2
//          17                    6                    6
//          18                   12                   12
using System;
using System.Collections.Generic;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      // First sentence of The Mystery of the Yellow Room, by Leroux.
      string opening = "Ce n'est pas sans une certaine émotion que "+
                       "je commence à raconter ici les aventures " +
                       "extraordinaires de Joseph Rouletabille."; 
      // Character counters.
      int nChars = 0;
      // Objects to store word count.
      List<int> chars = new List<int>();
      List<int> elements = new List<int>();
      
      foreach (var ch in opening) {
         // Skip the ' character.
         if (ch == '\u0027') continue;
              
         if (Char.IsWhiteSpace(ch) | (Char.IsPunctuation(ch))) {
            chars.Add(nChars);
            nChars = 0;
         }
         else {
            nChars++;
         }
      }

      TextElementEnumerator te = StringInfo.GetTextElementEnumerator(opening);
      while (te.MoveNext()) {
         string s = te.GetTextElement();   
         // Skip the ' character.
         if (s == "\u0027") continue;
         if ( String.IsNullOrEmpty(s.Trim()) | (s.Length == 1 && Char.IsPunctuation(Convert.ToChar(s)))) {
            elements.Add(nChars);         
            nChars = 0;
         }
         else {
            nChars++;
         }
      }

      // Display character counts.
      Console.WriteLine("{0,6} {1,20} {2,20}",
                        "Word #", "Char Objects", "Characters"); 
      for (int ctr = 0; ctr < chars.Count; ctr++) 
         Console.WriteLine("{0,6} {1,20} {2,20}",
                           ctr, chars[ctr], elements[ctr]); 
   }
}
// The example displays the following output:
//       Word #         Char Objects           Characters
//            0                    2                    2
//            1                    4                    4
//            2                    3                    3
//            3                    4                    4
//            4                    3                    3
//            5                    8                    8
//            6                    8                    7
//            7                    3                    3
//            8                    2                    2
//            9                    8                    8
//           10                    2                    1
//           11                    8                    8
//           12                    3                    3
//           13                    3                    3
//           14                    9                    9
//           15                   15                   15
//           16                    2                    2
//           17                    6                    6
//           18                   12                   12
Imports System.Collections.Generic
Imports System.Globalization

Module Example
   Public Sub Main()
      ' First sentence of The Mystery of the Yellow Room, by Leroux.
      Dim opening As String = "Ce n'est pas sans une certaine émotion que "+
                              "je commence à raconter ici les aventures " +
                              "extraordinaires de Joseph Rouletabille." 
      ' Character counters.
      Dim nChars As Integer = 0
      ' Objects to store word count.
      Dim chars As New List(Of Integer)()
      Dim elements As New List(Of Integer)()
      
      For Each ch In opening
         ' Skip the ' character.
         If ch = ChrW(&h0027) Then Continue For
              
         If Char.IsWhiteSpace(ch) Or Char.IsPunctuation(ch) Then
            chars.Add(nChars)
            nChars = 0
         Else 
            nChars += 1
         End If
      Next

      Dim te As TextElementEnumerator = StringInfo.GetTextElementEnumerator(opening)
      Do While te.MoveNext()
         Dim s As String = te.GetTextElement()   
         ' Skip the ' character.
         If s = ChrW(&h0027) Then Continue Do
         If String.IsNullOrEmpty(s.Trim()) Or (s.Length = 1 AndAlso Char.IsPunctuation(Convert.ToChar(s))) 
            elements.Add(nChars)         
            nChars = 0
         Else 
            nChars += 1
         End If
      Loop

      ' Display character counts.
      Console.WriteLine("{0,6} {1,20} {2,20}",
                        "Word #", "Char Objects", "Characters") 
      For ctr As Integer = 0 To chars.Count - 1 
         Console.WriteLine("{0,6} {1,20} {2,20}",
                           ctr, chars(ctr), elements(ctr)) 
      Next                        
   End Sub
End Module
' The example displays the following output:
'    Word #         Char Objects           Characters
'         0                    2                    2
'         1                    4                    4
'         2                    3                    3
'         3                    4                    4
'         4                    3                    3
'         5                    8                    8
'         6                    8                    7
'         7                    3                    3
'         8                    2                    2
'         9                    8                    8
'        10                    2                    1
'        11                    8                    8
'        12                    3                    3
'        13                    3                    3
'        14                    9                    9
'        15                   15                   15
'        16                    2                    2
'        17                    6                    6
'        18                   12                   12

En este ejemplo funciona con elementos de texto mediante el StringInfo.GetTextElementEnumerator método y el TextElementEnumerator clase para enumerar todos los elementos de texto en una cadena.This example works with text elements by using the StringInfo.GetTextElementEnumerator method and the TextElementEnumerator class to enumerate all the text elements in a string. También puede recuperar una matriz que contiene el índice inicial de cada elemento de texto mediante una llamada a la StringInfo.ParseCombiningCharacters método.You can also retrieve an array that contains the starting index of each text element by calling the StringInfo.ParseCombiningCharacters method.

Para obtener más información sobre cómo trabajar con unidades de texto en lugar de persona Char valores, vea el StringInfo clase.For more information about working with units of text rather than individual Char values, see the StringInfo class.

Cadenas nulas y cadenas vacíasNull strings and empty strings

Es una cadena que se ha declarado pero no se ha asignado un valor null.A string that has been declared but has not been assigned a value is null. Al intentar llamar a métodos en esa cadena produce una NullReferenceException.Attempting to call methods on that string throws a NullReferenceException. Una cadena null es diferente de una cadena vacía, que es una cadena cuyo valor es "" o String.Empty.A null string is different from an empty string, which is a string whose value is "" or String.Empty. En algunos casos, pasando una cadena nula o una cadena vacía como argumento en una llamada al método produce una excepción.In some cases, passing either a null string or an empty string as an argument in a method call throws an exception. Por ejemplo, al pasar una cadena nula para la Int32.Parse método produce una ArgumentNullExceptiony pasar una cadena vacía produce un FormatException.For example, passing a null string to the Int32.Parse method throws an ArgumentNullException, and passing an empty string throws a FormatException. En otros casos, un argumento de método puede ser una cadena nula o una cadena vacía.In other cases, a method argument can be either a null string or an empty string. Por ejemplo, si va a proporcionar un IFormattable implementación para una clase, desea equivalen a una cadena nula y una cadena vacía con el especificador de formato general ("G").For example, if you are providing an IFormattable implementation for a class, you want to equate both a null string and an empty string with the general ("G") format specifier.

El String clase incluye los siguientes métodos de dos conveniencia que permiten probar si una cadena es null o está vacío:The String class includes the following two convenience methods that enable you to test whether a string is null or empty:

  • IsNullOrEmpty, que indica si una cadena es null o es igual a String.Empty.IsNullOrEmpty, which indicates whether a string is either null or is equal to String.Empty. Este método elimina la necesidad de usar código como el siguiente:This method eliminates the need to use code such as the following:

    if (str == nullptr || str->Equals(String::Empty))
    
    if (str == null || str.Equals(String.Empty))
    
    If str Is Nothing OrElse str.Equals(String.Empty) Then
    
  • IsNullOrWhiteSpace, que indica si una cadena es null, es igual a String.Empty, o consta únicamente de caracteres de espacio en blanco.IsNullOrWhiteSpace, which indicates whether a string is null, equals String.Empty, or consists exclusively of white-space characters. Este método elimina la necesidad de usar código como el siguiente:This method eliminates the need to use code such as the following:

    if (str == nullptr || str->Equals(String::Empty) || str->Trim()->Equals(String::Empty))
    
    if (str == null || str.Equals(String.Empty) || str.Trim().Equals(String.Empty))
    
    If str Is Nothing OrElse str.Equals(String.Empty) OrElse str.Trim().Equals(String.Empty)
    

En el ejemplo siguiente se usa el IsNullOrEmpty método en el IFormattable.ToString implementación de un personalizado Temperature clase.The following example uses the IsNullOrEmpty method in the IFormattable.ToString implementation of a custom Temperature class. El método es compatible con las cadenas de formato "G", "C", "F" y "K".The method supports the "G", "C", "F", and "K" format strings. Si una cadena de formato vacío o un formato de cadena cuyo valor es null se pasa al método, se cambia su valor a la cadena de formato "G".If an empty format string or a format string whose value is null is passed to the method, its value is changed to the "G" format string.

public:
   virtual String^ ToString(String^ format, IFormatProvider^ provider) 
   {
      if (String::IsNullOrEmpty(format)) format = "G";  
      if (provider == nullptr) provider = CultureInfo::CurrentCulture;
      
      switch (Convert::ToUInt16(format->ToUpperInvariant()))
      {
         // Return degrees in Celsius.    
         case 'G':
         case 'C':
            return temp.ToString("F2", provider) + L"�C";
         // Return degrees in Fahrenheit.
         case 'F': 
            return (temp * 9 / 5 + 32).ToString("F2", provider) + L"�F";
         // Return degrees in Kelvin.
         case 'K':   
            return (temp + 273.15).ToString();
         default:
            throw gcnew FormatException(
                  String::Format("The {0} format string is not supported.", 
                                 format));
      }                                   
   }
public string ToString(string format, IFormatProvider provider) 
{
   if (String.IsNullOrEmpty(format)) format = "G";  
   if (provider == null) provider = CultureInfo.CurrentCulture;
   
   switch (format.ToUpperInvariant())
   {
      // Return degrees in Celsius.    
      case "G":
      case "C":
         return temp.ToString("F2", provider) + "°C";
      // Return degrees in Fahrenheit.
      case "F": 
         return (temp * 9 / 5 + 32).ToString("F2", provider) + "°F";
      // Return degrees in Kelvin.
      case "K":   
         return (temp + 273.15).ToString();
      default:
         throw new FormatException(
               String.Format("The {0} format string is not supported.", 
                             format));
   }                                   
}
Public Overloads Function ToString(fmt As String, provider As IFormatProvider) As String _
                Implements IFormattable.ToString
   If String.IsNullOrEmpty(fmt) Then fmt = "G"  
   If provider Is Nothing Then provider = CultureInfo.CurrentCulture
   
   Select Case fmt.ToUpperInvariant()
      ' Return degrees in Celsius.    
      Case "G", "C"
         Return temp.ToString("F2", provider) + "°C"
      ' Return degrees in Fahrenheit.
      Case "F" 
         Return (temp * 9 / 5 + 32).ToString("F2", provider) + "°F"
      ' Return degrees in Kelvin.
      Case "K"   
         Return (temp + 273.15).ToString()
      Case Else
         Throw New FormatException(
               String.Format("The {0} format string is not supported.", 
                             fmt))
    End Select                                   
End Function

La inmutabilidad y la clase StringBuilderImmutability and the StringBuilder class

Un String objeto se denomina inmutable (de solo lectura), porque su valor no puede modificarse una vez que se ha creado.A String object is called immutable (read-only), because its value cannot be modified after it has been created. Los métodos que parecen modificar una String objeto realmente se devuelven en un nuevo String objeto que contiene la modificación.Methods that appear to modify a String object actually return a new String object that contains the modification.

Dado que las cadenas son inmutables, rutinas de manipulación de cadena que llevan a cabo repiten adiciones o eliminaciones en lo que parece ser que una sola cadena puede suponer una reducción del rendimiento significativa.Because strings are immutable, string manipulation routines that perform repeated additions or deletions to what appears to be a single string can exact a significant performance penalty. Por ejemplo, el código siguiente utiliza un generador de números aleatorios para crear una cadena con 1000 caracteres en el intervalo 0 x 0001 a 0x052F.For example, the following code uses a random number generator to create a string with 1000 characters in the range 0x0001 to 0x052F. Aunque el código parece que utiliza la concatenación de cadenas para anexar un carácter de nueva a la cadena existente denominada str, realmente crea una nueva String objeto para cada operación de concatenación.Although the code appears to use string concatenation to append a new character to the existing string named str, it actually creates a new String object for each concatenation operation.

using namespace System;
using namespace System::IO;
using namespace System::Text;

void main()
{
   Random^ rnd = gcnew Random();

   String^ str = String::Empty;
   StreamWriter^ sw = gcnew StreamWriter(".\\StringFile.txt", 
                        false, Encoding::Unicode);

   for (int ctr = 0; ctr <= 1000; ctr++) {
      str += Convert::ToChar(rnd->Next(1, 0x0530)); 
      if (str->Length % 60 == 0)
         str += Environment::NewLine;          
   }                    
   sw->Write(str);
   sw->Close();
}
using System;
using System.IO;
using System.Text;

public class Example
{
   public static void Main()
   {
      Random rnd = new Random();
      
      string str = String.Empty;
      StreamWriter sw = new StreamWriter(@".\StringFile.txt", 
                           false, Encoding.Unicode);

      for (int ctr = 0; ctr <= 1000; ctr++) {
         str += Convert.ToChar(rnd.Next(1, 0x0530)); 
         if (str.Length % 60 == 0)
            str += Environment.NewLine;          
      }                    
      sw.Write(str);
      sw.Close();
   }
}
Imports System.IO
Imports System.Text

Module Example
   Public Sub Main()
      Dim rnd As New Random()
      
      Dim str As String = String.Empty
      Dim sw As New StreamWriter(".\StringFile.txt", 
                           False, Encoding.Unicode)

      For ctr As Integer = 0 To 1000
         str += ChrW(rnd.Next(1, &h0530)) 
         If str.Length Mod 60 = 0 Then str += vbCrLf          
      Next                    
      sw.Write(str)
      sw.Close()
   End Sub
End Module

Puede usar el StringBuilder clase en lugar de la String clase para las operaciones que realizan varios cambios en el valor de una cadena.You can use the StringBuilder class instead of the String class for operations that make multiple changes to the value of a string. A diferencia de las instancias de la String (clase), StringBuilder objetos son mutables; al concatenar, anexar o eliminar subcadenas de una cadena, las operaciones se realizan en una sola cadena.Unlike instances of the String class, StringBuilder objects are mutable; when you concatenate, append, or delete substrings from a string, the operations are performed on a single string. Cuando haya terminado de modificar el valor de un StringBuilder objeto, puede llamar a su StringBuilder.ToString método para convertirlo en una cadena.When you have finished modifying the value of a StringBuilder object, you can call its StringBuilder.ToString method to convert it to a string. En el ejemplo siguiente se sustituye el String usado en el ejemplo anterior para concatenar los 1000 caracteres aleatorios en el intervalo de 0 x 0001 a 0x052F con un StringBuilder objeto.The following example replaces the String used in the previous example to concatenate 1000 random characters in the range to 0x0001 to 0x052F with a StringBuilder object.

using namespace System;
using namespace System::IO;
using namespace System::Text;

void main()
{
   Random^ rnd = gcnew Random();

   StringBuilder^ sb = gcnew StringBuilder();
   StreamWriter^ sw = gcnew StreamWriter(".\\StringFile.txt", 
                        false, Encoding::Unicode);

   for (int ctr = 0; ctr <= 1000; ctr++) {
      sb->Append(Convert::ToChar(rnd->Next(1, 0x0530))); 
      if (sb->Length % 60 == 0)
         sb->AppendLine();          
   }                    
   sw->Write(sb->ToString());
   sw->Close();
}
using System;
using System.IO;
using System.Text;

public class Example
{
   public static void Main()
   {
      Random rnd = new Random();
      StringBuilder sb = new StringBuilder();
      StreamWriter sw = new StreamWriter(@".\StringFile.txt", 
                                         false, Encoding.Unicode);

      for (int ctr = 0; ctr <= 1000; ctr++) {
         sb.Append(Convert.ToChar(rnd.Next(1, 0x0530))); 
         if (sb.Length % 60 == 0)
            sb.AppendLine();          
      }                    
      sw.Write(sb.ToString());
      sw.Close();
   }
}
Imports System.IO
Imports System.Text

Module Example
   Public Sub Main()
      Dim rnd As New Random()
      Dim sb As New StringBuilder()
      Dim sw As New StreamWriter(".\StringFile.txt", 
                                 False, Encoding.Unicode)

      For ctr As Integer = 0 To 1000
         sb.Append(ChrW(rnd.Next(1, &h0530))) 
         If sb.Length Mod 60 = 0 Then sb.AppendLine()          
      Next                    
      sw.Write(sb.ToString())
      sw.Close()
   End Sub
End Module

Ordinal frente a operaciones sensibles a la referencia culturalOrdinal vs. culture-sensitive operations

Los miembros de la String clase operaciones ordinal o la referencia cultural (lingüístico) en un String objeto.Members of the String class perform either ordinal or culture-sensitive (linguistic) operations on a String object. Una operación ordinal actúa sobre el valor numérico de cada Char objeto.An ordinal operation acts on the numeric value of each Char object. Una operación de la referencia cultural actúa sobre el valor de la String objeto y mayúsculas y minúsculas específicas de referencias culturales de toma, ordenación, formato y las reglas de análisis en la cuenta.A culture-sensitive operation acts on the value of the String object, and takes culture-specific casing, sorting, formatting, and parsing rules into account. Operaciones sensibles a la referencia cultural que se ejecutan en el contexto de una referencia cultural declarada explícitamente o la referencia cultural implícita.Culture-sensitive operations execute in the context of an explicitly declared culture or the implicit current culture. Los dos tipos de operaciones pueden producir resultados muy diferentes cuando se llevan a cabo en la misma cadena.The two kinds of operations can produce very different results when they are performed on the same string.

.NET también admite operaciones de cadena lingüístico culturales mediante el uso de la referencia cultural (CultureInfo.InvariantCulture), que se basa generalmente en la configuración de la referencia cultural del idioma inglés independiente de la región..NET also supports culture-insensitive linguistic string operations by using the invariant culture (CultureInfo.InvariantCulture), which is loosely based on the culture settings of the English language independent of region. A diferencia de otras System.Globalization.CultureInfo se garantiza que la siguen siendo coherentes en un único equipo del sistema al sistema y en las versiones de .NET de configuración, la configuración de la referencia cultural invariable.Unlike other System.Globalization.CultureInfo settings, the settings of the invariant culture are guaranteed to remain consistent on a single computer, from system to system, and across versions of .NET. La referencia cultural puede ser considerada como una especie de caja negra que garantiza la estabilidad de las comparaciones de cadenas y ordenación entre todas las referencias culturales.The invariant culture can be seen as a kind of black box that ensures stability of string comparisons and ordering across all cultures.

Importante

Si la aplicación toma una decisión de seguridad sobre un identificador simbólico, como un nombre de archivo o canalización con nombre, o sobre los datos persistentes, como los datos basados en texto en un archivo XML, la operación debe utilizar una comparación ordinal en lugar de una comparación dependiente de la referencia cultural.If your application makes a security decision about a symbolic identifier such as a file name or named pipe, or about persisted data such as the text-based data in an XML file, the operation should use an ordinal comparison instead of a culture-sensitive comparison. Esto es porque una comparación dependiente de la referencia cultural puede producir resultados diferentes en función de la referencia cultural en vigor, mientras que una comparación ordinal depende únicamente el valor binario de los caracteres comparados.This is because a culture-sensitive comparison can yield different results depending on the culture in effect, whereas an ordinal comparison depends solely on the binary value of the compared characters.

Importante

Mayoría de los métodos que realizan operaciones de cadenas que incluye una sobrecarga que tenga un parámetro de tipo StringComparison, que le permite especificar si el método realiza una operación ordinal o la referencia cultural.Most methods that perform string operations include an overload that has a parameter of type StringComparison, which enables you to specify whether the method performs an ordinal or culture-sensitive operation. En general, debe llamar a esta sobrecarga para aclarar la intención del método de llamada al.In general, you should call this overload to make the intent of your method call clear. Para obtener procedimientos recomendados y orientación para el uso de ordinales y culturales operaciones en cadenas, vea prácticas recomendadas para el uso de cadenas.For best practices and guidance for using ordinal and culture-sensitive operations on strings, see Best Practices for Using Strings.

Operaciones para mayúsculas y minúsculas, análisis y formato, comparación y ordenación, y probar la igualdad puede ser cualquier ordinal o referencia cultural.Operations for casing, parsing and formatting, comparison and sorting, and testing for equality can be either ordinal or culture-sensitive. Las secciones siguientes tratan cada categoría de la operación.The following sections discuss each category of operation.

Sugerencia

Siempre debe llamar una sobrecarga del método que realiza la intención del método de llamada no cifrado.You should always call a method overload that makes the intent of your method call clear. Por ejemplo, en lugar de llamar el Compare(String, String) método para realizar una comparación de referencias culturales de dos cadenas mediante las convenciones de la referencia cultural actual, debe llamar a la Compare(String, String, StringComparison) método con un valor de StringComparison.CurrentCulture para el comparisonType argumento.For example, instead of calling the Compare(String, String) method to perform a culture-sensitive comparison of two strings by using the conventions of the current culture, you should call the Compare(String, String, StringComparison) method with a value of StringComparison.CurrentCulture for the comparisonType argument. Para obtener más información, consulte Procedimientos recomendados para el uso de cadenas.For more information, see Best Practices for Using Strings.

Puede descargar las tablas de pesos de ordenación, un conjunto de archivos de texto que contienen información sobre los pesos de caracteres que se usan en las operaciones de ordenación y comparación para los sistemas operativos Windows, además de la tabla de elementos de intercalación Unicode predeterminada, que se trata de la tabla de pesos de ordenación para Linux y macOS.You can download the Sorting Weight Tables, a set of text files that contain information on the character weights used in sorting and comparison operations for Windows operating systems, and the Default Unicode Collation Element Table, the sort weight table for Linux and macOS.

Mayúsculas y minúsculasCasing

Las reglas de mayúsculas y minúsculas determinan cómo cambiar las mayúsculas y minúsculas de un carácter Unicode; Por ejemplo, de minúsculas a mayúsculas.Casing rules determine how to change the capitalization of a Unicode character; for example, from lowercase to uppercase. A menudo, se realiza una operación de mayúsculas y minúsculas antes de una comparación de cadenas.Often, a casing operation is performed before a string comparison. Por ejemplo, se puede convertir una cadena a mayúsculas para que se puede comparar con otra cadena en mayúsculas.For example, a string might be converted to uppercase so that it can be compared with another uppercase string. Puede convertir los caracteres de una cadena a minúsculas mediante una llamada a la ToLower o ToLowerInvariant método y se pueden convertir a mayúsculas mediante una llamada a la ToUpper o ToUpperInvariant método.You can convert the characters in a string to lowercase by calling the ToLower or ToLowerInvariant method, and you can convert them to uppercase by calling the ToUpper or ToUpperInvariant method. Además, puede usar el TextInfo.ToTitleCase método para convertir una cadena a mayúsculas.In addition, you can use the TextInfo.ToTitleCase method to convert a string to title case.

Las operaciones de mayúsculas y minúsculas pueden basarse en las reglas de la referencia cultural actual, una referencia cultural especificada o la referencia cultural invariable.Casing operations can be based on the rules of the current culture, a specified culture, or the invariant culture. Como asignaciones mayúsculas y minúsculas pueden variar según la referencia cultural utilizada, el resultado de las operaciones de mayúsculas y minúsculas puede variar en función de la referencia cultural.Because case mappings can vary depending on the culture used, the result of casing operations can vary based on culture. Las diferencias de mayúsculas y minúsculas reales son de tres tipos:The actual differences in casing are of three kinds:

  • Las diferencias en la asignación de mayúsculas del alfabeto LATINO letra mayúscula I (u+0049) LATINO pequeña letra I (u+0069) LATINO letra mayúscula I con punto superior (0130) y LATIN pequeña letra DOTLESS I (0131).Differences in the case mapping of LATIN CAPITAL LETTER I (U+0049), LATIN SMALL LETTER I (U+0069), LATIN CAPITAL LETTER I WITH DOT ABOVE (U+0130), and LATIN SMALL LETTER DOTLESS I (U+0131). En las referencias culturales de az-Latn-AZ (latino, Azerbaiyán) y el tr-TR (turco (Turquía)) y en el tr, az y referencias culturales neutras de az-Latn, es el equivalente en minúsculas de la letra mayúscula LATÍN I LATÍN pequeña letra DOTLESS I y es el equivalente en mayúsculas del LATÍN pequeña letra I LETRA MAYÚSCULA LATÍN I CON UN PUNTO ANTERIOR.In the tr-TR (Turkish (Turkey)) and az-Latn-AZ (Azerbaijan, Latin) cultures, and in the tr, az, and az-Latn neutral cultures, the lowercase equivalent of LATIN CAPITAL LETTER I is LATIN SMALL LETTER DOTLESS I, and the uppercase equivalent of LATIN SMALL LETTER I is LATIN CAPITAL LETTER I WITH DOT ABOVE. En todas las otras referencias culturales, incluida la referencia cultural invariable, LATINO pequeña letra I y LATIN CAPITAL letra I son equivalentes en mayúsculas y minúsculas.In all other cultures, including the invariant culture, LATIN SMALL LETTER I and LATIN CAPITAL LETTER I are lowercase and uppercase equivalents.

    El ejemplo siguiente se muestra cómo una comparación de cadenas que se ha diseñado impedir el acceso de archivo del sistema puede producir un error si se basa en una comparación de mayúsculas y minúsculas de la referencia cultural.The following example demonstrates how a string comparison designed to prevent file system access can fail if it relies on a culture-sensitive casing comparison. (Las convenciones de mayúsculas y minúsculas de la referencia cultural invariable deben haberse utilizadas.)(The casing conventions of the invariant culture should have been used.)

    using System;
    using System.Globalization;
    using System.Threading;
    
    public class Example
    {
       const string disallowed = "file";
       
       public static void Main()
       {
          IsAccessAllowed(@"FILE:\\\c:\users\user001\documents\FinancialInfo.txt");
       }
    
       private static void IsAccessAllowed(String resource)
       {
          CultureInfo[] cultures = { CultureInfo.CreateSpecificCulture("en-US"),
                                     CultureInfo.CreateSpecificCulture("tr-TR") };
          String scheme = null;
          int index = resource.IndexOfAny( new Char[] { '\\', '/' } );
          if (index > 0) 
             scheme = resource.Substring(0, index - 1);
    
          // Change the current culture and perform the comparison.
          foreach (var culture in cultures) {
             Thread.CurrentThread.CurrentCulture = culture;
             Console.WriteLine("Culture: {0}", CultureInfo.CurrentCulture.DisplayName);
             Console.WriteLine(resource);
             Console.WriteLine("Access allowed: {0}", 
                               ! String.Equals(disallowed, scheme, StringComparison.CurrentCultureIgnoreCase));      
             Console.WriteLine();
          }   
       }
    }
    // The example displays the following output:
    //       Culture: English (United States)
    //       FILE:\\\c:\users\user001\documents\FinancialInfo.txt
    //       Access allowed: False
    //       
    //       Culture: Turkish (Turkey)
    //       FILE:\\\c:\users\user001\documents\FinancialInfo.txt
    //       Access allowed: True
    
    Imports System.Globalization
    Imports System.Threading
    
    Module Example
       Const disallowed = "file"
       
       Public Sub Main()
          IsAccessAllowed("FILE:\\\c:\users\user001\documents\FinancialInfo.txt")
       End Sub
    
       Private Sub IsAccessAllowed(resource As String)
          Dim cultures() As CultureInfo = { CultureInfo.CreateSpecificCulture("en-US"),
                                            CultureInfo.CreateSpecificCulture("tr-TR") }
          Dim scheme As String = Nothing
          Dim index As Integer = resource.IndexOfAny( {"\"c, "/"c })
          If index > 0 Then scheme = resource.Substring(0, index - 1)
    
          ' Change the current culture and perform the comparison.
          For Each culture In cultures
             Thread.CurrentThread.CurrentCulture = culture
             Console.WriteLine("Culture: {0}", CultureInfo.CurrentCulture.DisplayName)
             Console.WriteLine(resource)
             Console.WriteLine("Access allowed: {0}", 
                               Not String.Equals(disallowed, scheme, StringComparison.CurrentCultureIgnoreCase))      
             Console.WriteLine()
          Next   
       End Sub      
    End Module
    ' The example displays the following output:
    '       Culture: English (United States)
    '       FILE:\\\c:\users\user001\documents\FinancialInfo.txt
    '       Access allowed: False
    '       
    '       Culture: Turkish (Turkey)
    '       FILE:\\\c:\users\user001\documents\FinancialInfo.txt
    '       Access allowed: True
    
  • Diferencias entre la referencia cultural invariable y todas las demás referencias culturales en asignaciones de mayúsculas.Differences in case mappings between the invariant culture and all other cultures. En estos casos, aplicando las reglas de mayúsculas y minúsculas de la referencia cultural invariable para cambiar un carácter en mayúsculas o minúsculas, devuelve el mismo carácter.In these cases, using the casing rules of the invariant culture to change a character to uppercase or lowercase returns the same character. Para todas las otras culturas y devuelve un carácter diferente.For all other cultures, it returns a different character. En la tabla siguiente se enumeran algunos de los caracteres afectados.Some of the affected characters are listed in the following table.

    CarácterCharacter Si cambia aIf changed to Valores devueltosReturns
    INICIO DE SESIÓN DE MICRAS (00B5)MICRON SIGN (U+00B5) MayúsculasUppercase LETRA MAYÚSCULA GRIEGA MU (U +-39C)GREEK CAPITAL LETTER MU (U+-39C)
    LETRA LATINA MAYÚSCULA I CON UN PUNTO ANTERIOR (0130)LATIN CAPITAL LETTER I WITH DOT ABOVE (U+0130) MinúsculasLowercase LETRA MINÚSCULA LATÍN I (U+0069)LATIN SMALL LETTER I (U+0069)
    LETRA MINÚSCULA LATINA DOTLESS ME (0131)LATIN SMALL LETTER DOTLESS I (U+0131) MayúsculasUppercase LETRA MAYÚSCULA LATÍN I (U+0049)LATIN CAPITAL LETTER I (U+0049)
    LETRA LATINA MINÚSCULA S LARGA (017F)LATIN SMALL LETTER LONG S (U+017F) MayúsculasUppercase LATIN CAPITAL LETTER S (0053)LATIN CAPITAL LETTER S (U+0053)
    D. LETRA LATINA MAYÚSCULA CON LA LETRA MINÚSCULA Z CON ACENTO CIRCUNFLEJO (U + 01C 5)LATIN CAPITAL LETTER D WITH SMALL LETTER Z WITH CARON (U+01C5) MinúsculasLowercase LETRA LATINA MINÚSCULA DZ CON ACENTO CIRCUNFLEJO (U + 01C 6)LATIN SMALL LETTER DZ WITH CARON (U+01C6)
    YPOGEGRAMMENI GRIEGO DE COMBINACIÓN (0345)COMBINING GREEK YPOGEGRAMMENI (U+0345) MayúsculasUppercase LETRA MAYÚSCULA GRIEGA IOTA (0399)GREEK CAPITAL LETTER IOTA (U+0399)
  • Diferencias en las asignaciones de casos de pares de dos letras mayúsculas y minúsculas mezcladas en el intervalo de caracteres ASCII.Differences in case mappings of two-letter mixed-case pairs in the ASCII character range. En la mayoría de las referencias culturales, un par de dos letras mayúsculas y minúsculas mezcladas es igual que el par equivalente de dos letras en mayúscula o minúscula.In most cultures, a two-letter mixed-case pair is equal to the equivalent two-letter uppercase or lowercase pair. Esto no es cierto para los siguientes pares de dos letras en las siguientes referencias culturales, porque en cada caso se comparan para un dígrafo:This is not true for the following two-letter pairs in the following cultures, because in each case they are compared to a digraph:

    • "lJ" y "nJ" en la referencia cultural hr-HR (croata (Croacia))."lJ" and "nJ" in the hr-HR (Croatian (Croatia)) culture.

    • "cH" en el cs-CZ (checo (República Checa)) y referencias culturales sk-SK (eslovaco (Eslovaquia))."cH" in the cs-CZ (Czech (Czech Republic)) and sk-SK (Slovak (Slovakia)) cultures.

    • "aA" en la referencia cultural da-DK (danés (Dinamarca))."aA" in the da-DK (Danish (Denmark)) culture.

    • "cS", "dZ", "dZS", "nY", "sZ", "tY" y "zS" en la referencia cultural hu-HU (húngaro (Hungría))."cS", "dZ", "dZS", "nY", "sZ", "tY", and "zS" in the hu-HU (Hungarian (Hungary)) culture.

    • "cH" y "lL" en la referencia cultural es-ES_tradnl (español (España, alfabetización tradicional))."cH" and "lL" in the es-ES_tradnl (Spanish (Spain, Traditional Sort)) culture.

    • "cH", "2gi", "kH", "nG" "nH", "pH", "qU", "tH" y "tR" en la referencia cultural vi-VN (vietnamita (Vietnam))."cH", "gI", "kH", "nG" "nH", "pH", "qU', "tH", and "tR" in the vi-VN (Vietnamese (Vietnam)) culture.

    Sin embargo, es habitual encontrar una situación en la que una comparación de la referencia cultural de estos pares crea problemas, ya que son habituales en cadenas fijas o identificadores de estos pares.However, it is unusual to encounter a situation in which a culture-sensitive comparison of these pairs creates problems, because these pairs are uncommon in fixed strings or identifiers.

El ejemplo siguiente muestra algunas de las diferencias en las reglas de mayúsculas y minúsculas entre referencias culturales al convertir cadenas a mayúsculas.The following example illustrates some of the differences in casing rules between cultures when converting strings to uppercase.

using namespace System;
using namespace System::Globalization;
using namespace System::IO;

String^ ShowHexValue(String^ s);

void main()
{
   StreamWriter^ sw = gcnew StreamWriter(".\\case.txt");   
   array<String^>^ words = gcnew array<String^> { L"file", L"sıfır", L"Dženana" };
   array<CultureInfo^>^ cultures = gcnew array<CultureInfo^> { CultureInfo::InvariantCulture, 
                                                               gcnew CultureInfo("en-US"),  
                                                               gcnew CultureInfo("tr-TR") };

   for each (String^ word in words) {
      sw->WriteLine("{0}:", word);
      for each (CultureInfo^ culture in cultures) {
         String^ name = String::IsNullOrEmpty(culture->Name) ? 
                              "Invariant" : culture->Name;
         String^ upperWord = word->ToUpper(culture);
         sw->WriteLine("   {0,10}: {1,7} {2, 38}", name, 
                        upperWord, ShowHexValue(upperWord));

      }
      sw->WriteLine();  
   }
   sw->Close();
}

String^ ShowHexValue(String^ s)
{
   String^ retval = nullptr;
   for each (Char ch in s) {
      array<Byte>^ bytes = BitConverter::GetBytes(ch);
      retval += String::Format("{0:X2} {1:X2} ", bytes[1], bytes[0]);     
   }
   return retval;
} 
// The example displays the following output: 
//    file: 
//        Invariant:    FILE               00 46 00 49 00 4C 00 45  
//            en-US:    FILE               00 46 00 49 00 4C 00 45  
//            tr-TR:    FİLE               00 46 01 30 00 4C 00 45  
//     
//    sıfır: 
//        Invariant:   SıFıR         00 53 01 31 00 46 01 31 00 52  
//            en-US:   SIFIR         00 53 00 49 00 46 00 49 00 52  
//            tr-TR:   SIFIR         00 53 00 49 00 46 00 49 00 52  
//     
//    Dženana: 
//        Invariant:  DžENANA   01 C5 00 45 00 4E 00 41 00 4E 00 41  
//            en-US:  DŽENANA   01 C4 00 45 00 4E 00 41 00 4E 00 41  
//            tr-TR:  DŽENANA   01 C4 00 45 00 4E 00 41 00 4E 00 41 
using System;
using System.Globalization;
using System.IO;

public class Example
{
   public static void Main()
   {
      StreamWriter sw = new StreamWriter(@".\case.txt");   
      string[] words = { "file", "sıfır", "Dženana" };
      CultureInfo[] cultures = { CultureInfo.InvariantCulture, 
                                 new CultureInfo("en-US"),  
                                 new CultureInfo("tr-TR") };

      foreach (var word in words) {
         sw.WriteLine("{0}:", word);
         foreach (var culture in cultures) {
            string name = String.IsNullOrEmpty(culture.Name) ? 
                                 "Invariant" : culture.Name;
            string upperWord = word.ToUpper(culture);
            sw.WriteLine("   {0,10}: {1,7} {2, 38}", name, 
                         upperWord, ShowHexValue(upperWord));
     
         }
         sw.WriteLine();  
      }
      sw.Close();
   }

   private static string ShowHexValue(string s)
   {
      string retval = null;
      foreach (var ch in s) {
         byte[] bytes = BitConverter.GetBytes(ch);
         retval += String.Format("{0:X2} {1:X2} ", bytes[1], bytes[0]);     
      }
      return retval;
   } 
}
// The example displays the following output:
//    file:
//        Invariant:    FILE               00 46 00 49 00 4C 00 45 
//            en-US:    FILE               00 46 00 49 00 4C 00 45 
//            tr-TR:    FİLE               00 46 01 30 00 4C 00 45 
//    
//    sıfır:
//        Invariant:   SıFıR         00 53 01 31 00 46 01 31 00 52 
//            en-US:   SIFIR         00 53 00 49 00 46 00 49 00 52 
//            tr-TR:   SIFIR         00 53 00 49 00 46 00 49 00 52 
//    
//    Dženana:
//        Invariant:  DžENANA   01 C5 00 45 00 4E 00 41 00 4E 00 41 
//            en-US:  DŽENANA   01 C4 00 45 00 4E 00 41 00 4E 00 41 
//            tr-TR:  DŽENANA   01 C4 00 45 00 4E 00 41 00 4E 00 41 
Imports System.Globalization
Imports System.IO

Module Example
   Public Sub Main()
      Dim sw As New StreamWriter(".\case.txt")   
      Dim words As String() = { "file", "sıfır", "Dženana" }
      Dim cultures() As CultureInfo = { CultureInfo.InvariantCulture, 
                                        New CultureInfo("en-US"),  
                                        New CultureInfo("tr-TR") }

      For Each word In words
         sw.WriteLine("{0}:", word)
         For Each culture In cultures
            Dim name As String = If(String.IsNullOrEmpty(culture.Name),  
                                 "Invariant", culture.Name)
            Dim upperWord As String = word.ToUpper(culture)
            sw.WriteLine("   {0,10}: {1,7} {2, 38}", name, 
                         upperWord, ShowHexValue(upperWord))
     
         Next
         sw.WriteLine()  
      Next
      sw.Close()
   End Sub

   Private Function ShowHexValue(s As String) As String
      Dim retval As String = Nothing
      For Each ch In s
         Dim bytes() As Byte = BitConverter.GetBytes(ch)
         retval += String.Format("{0:X2} {1:X2} ", bytes(1), bytes(0))     
      Next
      Return retval
   End Function
End Module
' The example displays the following output:
'    file:
'        Invariant:    FILE               00 46 00 49 00 4C 00 45 
'            en-US:    FILE               00 46 00 49 00 4C 00 45 
'            tr-TR:    FİLE               00 46 01 30 00 4C 00 45 
'    
'    sıfır:
'        Invariant:   SıFıR         00 53 01 31 00 46 01 31 00 52 
'            en-US:   SIFIR         00 53 00 49 00 46 00 49 00 52 
'            tr-TR:   SIFIR         00 53 00 49 00 46 00 49 00 52 
'    
'    Dženana:
'        Invariant:  DžENANA   01 C5 00 45 00 4E 00 41 00 4E 00 41 
'            en-US:  DŽENANA   01 C4 00 45 00 4E 00 41 00 4E 00 41 
'            tr-TR:  DŽENANA   01 C4 00 45 00 4E 00 41 00 4E 00 41  

Análisis y formatoParsing and formatting

Formato y análisis son operaciones inversas.Formatting and parsing are inverse operations. Reglas de formato determinan cómo convertir un valor, como una fecha y hora o un número, en su representación de cadena, mientras que las reglas de análisis determinan cómo convertir una representación de cadena en un valor como una fecha y hora.Formatting rules determine how to convert a value, such as a date and time or a number, to its string representation, whereas parsing rules determine how to convert a string representation to a value such as a date and time. Las reglas de análisis y formato dependen de las convenciones culturales.Both formatting and parsing rules are dependent on cultural conventions. El ejemplo siguiente muestra las ambigüedades que pueden surgir al interpretar una cadena de fecha específica de la referencia cultural.The following example illustrates the ambiguity that can arise when interpreting a culture-specific date string. Sin conocer las convenciones de la referencia cultural que se usó para generar una cadena de fecha, no es posible saber si el 01/03/2011, 03/01/2011 y 3/1/2011 representan el 3 de enero de 2011 o 1 de marzo de 2011.Without knowing the conventions of the culture that was used to produce a date string, it is not possible to know whether 03/01/2011, 3/1/2011, and 01/03/2011 represent January 3, 2011 or March 1, 2011.

using namespace System;
using namespace System::Globalization;

void main()
{
   DateTime^ date = gcnew DateTime(2011, 3, 1);
   array<CultureInfo^>^ cultures = gcnew array<CultureInfo^> { CultureInfo::InvariantCulture, 
                                                               gcnew CultureInfo("en-US"), 
                                                               gcnew CultureInfo("fr-FR") };

   for each (CultureInfo^ culture in cultures)
      Console::WriteLine("{0,-12} {1}", String::IsNullOrEmpty(culture->Name) ?
                        "Invariant" : culture->Name, 
                        date->ToString("d", culture));                                    
}
// The example displays the following output: 
//       Invariant    03/01/2011 
//       en-US        3/1/2011 
//       fr-FR        01/03/2011
using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      DateTime date = new DateTime(2011, 3, 1);
      CultureInfo[] cultures = { CultureInfo.InvariantCulture, 
                                 new CultureInfo("en-US"), 
                                 new CultureInfo("fr-FR") };

      foreach (var culture in cultures)
         Console.WriteLine("{0,-12} {1}", String.IsNullOrEmpty(culture.Name) ?
                           "Invariant" : culture.Name, 
                           date.ToString("d", culture));                                    
   }
}
// The example displays the following output:
//       Invariant    03/01/2011
//       en-US        3/1/2011
//       fr-FR        01/03/2011
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim dat As Date = #3/1/2011#
      Dim cultures() As CultureInfo = { CultureInfo.InvariantCulture, 
                                        New CultureInfo("en-US"), 
                                        New CultureInfo("fr-FR") }

      For Each culture In cultures
         Console.WriteLine("{0,-12} {1}", If(String.IsNullOrEmpty(culture.Name), 
                           "Invariant", culture.Name), 
                           dat.ToString("d", culture))
      Next                                                         
   End Sub
End Module
' The example displays the following output:
'       Invariant    03/01/2011
'       en-US        3/1/2011
'       fr-FR        01/03/2011

De forma similar, como se muestra en el ejemplo siguiente, una sola cadena puede producir diferentes fechas según la referencia cultural cuyas convenciones se usan en la operación de análisis.Similarly, as the following example shows, a single string can produce different dates depending on the culture whose conventions are used in the parsing operation.

using namespace System;
using namespace System::Globalization;

void main()
{
   String^ dateString = "07/10/2011";
   array<CultureInfo^>^ cultures = gcnew array<CultureInfo^> { CultureInfo::InvariantCulture, 
                                                               CultureInfo::CreateSpecificCulture("en-GB"), 
                                                               CultureInfo::CreateSpecificCulture("en-US") };
   Console::WriteLine("{0,-12} {1,10} {2,8} {3,8}\n", "Date String", "Culture", 
                                                "Month", "Day");
   for each (CultureInfo^ culture in cultures) {
      DateTime date = DateTime::Parse(dateString, culture);
      Console::WriteLine("{0,-12} {1,10} {2,8} {3,8}", dateString, 
                        String::IsNullOrEmpty(culture->Name) ?
                        "Invariant" : culture->Name, 
                        date.Month, date.Day);
   }                      
}
// The example displays the following output: 
//       Date String     Culture    Month      Day 
//        
//       07/10/2011    Invariant        7       10 
//       07/10/2011        en-GB       10        7 
//       07/10/2011        en-US        7       10

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string dateString = "07/10/2011";
      CultureInfo[] cultures = { CultureInfo.InvariantCulture, 
                                 CultureInfo.CreateSpecificCulture("en-GB"), 
                                 CultureInfo.CreateSpecificCulture("en-US") };
      Console.WriteLine("{0,-12} {1,10} {2,8} {3,8}\n", "Date String", "Culture", 
                                                 "Month", "Day");
      foreach (var culture in cultures) {
         DateTime date = DateTime.Parse(dateString, culture);
         Console.WriteLine("{0,-12} {1,10} {2,8} {3,8}", dateString, 
                           String.IsNullOrEmpty(culture.Name) ?
                           "Invariant" : culture.Name, 
                           date.Month, date.Day);
      }                      
   }
}
// The example displays the following output:
//       Date String     Culture    Month      Day
//       
//       07/10/2011    Invariant        7       10
//       07/10/2011        en-GB       10        7
//       07/10/2011        en-US        7       10
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim dateString As String = "07/10/2011"
      Dim cultures() As CultureInfo = { CultureInfo.InvariantCulture, 
                                        CultureInfo.CreateSpecificCulture("en-GB"), 
                                        CultureInfo.CreateSpecificCulture("en-US") }
      Console.WriteLine("{0,-12} {1,10} {2,8} {3,8}", "Date String", "Culture", 
                                                 "Month", "Day")
      Console.WriteLine()                                                 
      For Each culture In cultures
         Dim dat As Date = DateTime.Parse(dateString, culture)
         Console.WriteLine("{0,-12} {1,10} {2,8} {3,8}", dateString, 
                           If(String.IsNullOrEmpty(culture.Name), 
                           "Invariant", culture.Name), 
                           dat.Month, dat.Day)
      Next
   End Sub
End Module
' The example displays the following output:
'       Date String     Culture    Month      Day
'       
'       07/10/2011    Invariant        7       10
'       07/10/2011        en-GB       10        7
'       07/10/2011        en-US        7       10

Comparación de cadenas y ordenaciónString comparison and sorting

Convenciones para comparar y ordenar cadenas varían culturales.Conventions for comparing and sorting strings vary from culture to culture. Por ejemplo, el criterio de ordenación puede basarse en la fonética o en la representación visual de caracteres.For example, the sort order may be based on phonetics or on the visual representation of characters. En los idiomas de Asia oriental, los caracteres se ordenan teniendo en cuenta los trazos y el radical de los ideogramas.In East Asian languages, characters are sorted by the stroke and radical of ideographs. El criterio de ordenación también depende del orden que se emplea en los distintos idiomas y referencias culturales para el alfabeto.Sorting also depends on the order languages and cultures use for the alphabet. Por ejemplo, el idioma danés tiene un carácter "Æ" que se ordena después de la "Z" en el alfabeto.For example, the Danish language has an "Æ" character that it sorts after "Z" in the alphabet. Además, se pueden realizar comparaciones entre mayúsculas y minúsculas o mayúsculas y minúsculas, y en algunos casos también difieren las reglas de mayúsculas y minúsculas según la referencia cultural.In addition, comparisons can be case-sensitive or case-insensitive, and in some cases casing rules also differ by culture. Comparación ordinal, por otro lado, usa los puntos de código Unicode de caracteres individuales en una cadena al comparar y ordenar cadenas.Ordinal comparison, on the other hand, uses the Unicode code points of individual characters in a string when comparing and sorting strings.

Las reglas de ordenación determinan que el orden alfabético de caracteres Unicode y cómo dos cadenas se comparan entre sí.Sort rules determine the alphabetic order of Unicode characters and how two strings compare to each other. Por ejemplo, el String.Compare(String, String, StringComparison) método compara dos cadenas según la StringComparison parámetro.For example, the String.Compare(String, String, StringComparison) method compares two strings based on the StringComparison parameter. Si el valor del parámetro es StringComparison.CurrentCulture, el método realiza una comparación lingüística que usa las convenciones de la referencia cultural actual; si el valor del parámetro es StringComparison.Ordinal, el método realiza una comparación ordinal.If the parameter value is StringComparison.CurrentCulture, the method performs a linguistic comparison that uses the conventions of the current culture; if the parameter value is StringComparison.Ordinal, the method performs an ordinal comparison. Por lo tanto, como muestra el siguiente ejemplo, si la referencia cultural actual es inglés Inglés, la primera llamada a la String.Compare(String, String, StringComparison) método (mediante la comparación dependiente de la referencia cultural) considera "a" menor que "A", pero se considera que la segunda llamada al mismo método (mediante la comparación ordinal) "a" mayor que "A".Consequently, as the following example shows, if the current culture is U.S. English, the first call to the String.Compare(String, String, StringComparison) method (using culture-sensitive comparison) considers "a" less than "A", but the second call to the same method (using ordinal comparison) considers "a" greater than "A".

using namespace System;
using namespace System::Globalization;
using namespace System::Threading;

void main()
{
   Thread::CurrentThread->CurrentCulture = CultureInfo::CreateSpecificCulture("en-US");
   Console::WriteLine(String::Compare("A", "a", StringComparison::CurrentCulture));
   Console::WriteLine(String::Compare("A", "a", StringComparison::Ordinal));
}
// The example displays the following output: 
//       1 
//       -32
using System;
using System.Globalization;
using System.Threading;

public class Example
{
   public static void Main()
   {
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US");
      Console.WriteLine(String.Compare("A", "a", StringComparison.CurrentCulture));
      Console.WriteLine(String.Compare("A", "a", StringComparison.Ordinal));
   }
}
// The example displays the following output:
//       1
//       -32
Imports System.Globalization
Imports System.Threading

Module Example
   Public Sub Main()
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US")
      Console.WriteLine(String.Compare("A", "a", StringComparison.CurrentCulture))
      Console.WriteLine(String.Compare("A", "a", StringComparison.Ordinal))
   End Sub
End Module
' The example displays the following output:
'       1                                                                                     
'       -32

.NET es compatible con la palabra, cadena y las reglas de ordenación ordinal:.NET supports word, string, and ordinal sort rules:

  • Una operación de ordenación de palabras realiza una comparación de cadenas donde se tiene en cuenta la referencia cultural y donde ciertos caracteres Unicode no alfanuméricos pueden tener asignados pesos especiales.A word sort performs a culture-sensitive comparison of strings in which certain nonalphanumeric Unicode characters might have special weights assigned to them. Por ejemplo, el guión (-) podría tener un peso muy pequeño asignado para que "coop" y "Co-op" aparecerían juntos en una lista ordenada.For example, the hyphen (-) might have a very small weight assigned to it so that "coop" and "co-op" appear next to each other in a sorted list. Para obtener una lista de los String métodos que se comparan dos cadenas utilizando reglas de ordenación de palabras, vea el operaciones de cadena por categoría sección.For a list of the String methods that compare two strings using word sort rules, see the String operations by category section.

  • Una ordenación por cadena también realiza una comparación dependiente de la referencia cultural.A string sort also performs a culture-sensitive comparison. Es similar a la ordenación por palabra, salvo que no hay casos especiales, y todos los símbolos alfanuméricos van antes todos los caracteres Unicode alfanuméricos.It is similar to a word sort, except that there are no special cases, and all nonalphanumeric symbols come before all alphanumeric Unicode characters. Se pueden comparar dos cadenas utilizando reglas de ordenación de cadenas mediante una llamada a la CompareInfo.Compare sobrecargas del método que tienen un options parámetro que proporciona un valor de CompareOptions.StringSort.Two strings can be compared using string sort rules by calling the CompareInfo.Compare method overloads that have an options parameter that is supplied a value of CompareOptions.StringSort. Tenga en cuenta que esto es el único método que proporciona .NET para comparar dos cadenas utilizando reglas de ordenación de cadenas.Note that this is the only method that .NET provides to compare two strings using string sort rules.

  • Una ordenación ordinal compara las cadenas basadas en el valor numérico de cada objeto Char en la cadena.An ordinal sort compares strings based on the numeric value of each Char object in the string. Una comparación ordinal es automáticamente entre mayúsculas y minúsculas, porque las versiones en mayúsculas y minúsculas de un carácter tienen distintos puntos de código.An ordinal comparison is automatically case-sensitive because the lowercase and uppercase versions of a character have different code points. Sin embargo, si el caso no es importante, puede especificar una comparación ordinal que no distingue entre mayúsculas.However, if case is not important, you can specify an ordinal comparison that ignores case. Esto es equivalente a convertir la cadena a mayúsculas mediante la referencia cultural invariable y, a continuación, realizar una comparación ordinal en el resultado.This is equivalent to converting the string to uppercase by using the invariant culture and then performing an ordinal comparison on the result. Para obtener una lista de los String métodos que comparan dos cadenas utilizando reglas de ordenación ordinal, vea el operaciones de cadena por categoría sección.For a list of the String methods that compare two strings using ordinal sort rules, see the String operations by category section.

Una comparación dependiente de la referencia cultural es cualquier comparación que utiliza explícita o implícitamente un CultureInfo objeto, incluida la referencia cultural especificada por el CultureInfo.InvariantCulture propiedad.A culture-sensitive comparison is any comparison that explicitly or implicitly uses a CultureInfo object, including the invariant culture that is specified by the CultureInfo.InvariantCulture property. La referencia cultural implícita es la referencia cultural actual, que se especifica mediante el Thread.CurrentCulture y CultureInfo.CurrentCulture propiedades.The implicit culture is the current culture, which is specified by the Thread.CurrentCulture and CultureInfo.CurrentCulture properties. Hay una variación considerable en el criterio de ordenación de caracteres alfabéticos (es decir, los caracteres para el que el Char.IsLetter propiedad devuelve true) entre distintas referencias culturales.There is considerable variation in the sort order of alphabetic characters (that is, characters for which the Char.IsLetter property returns true) across cultures. Puede especificar una comparación de la referencia cultural que utiliza las convenciones de una referencia cultural concreta al suministrar un CultureInfo de objeto a un método de comparación de cadenas como Compare(String, String, CultureInfo, CompareOptions).You can specify a culture-sensitive comparison that uses the conventions of a specific culture by supplying a CultureInfo object to a string comparison method such as Compare(String, String, CultureInfo, CompareOptions). Puede especificar una comparación de la referencia cultural que utiliza las convenciones de la referencia cultural actual proporcionando StringComparison.CurrentCulture, StringComparison.CurrentCultureIgnoreCase, o cualquier miembro de la CompareOptions enumeración distinto CompareOptions.Ordinal o CompareOptions.OrdinalIgnoreCase un adecuado sobrecarga de la Compare método.You can specify a culture-sensitive comparison that uses the conventions of the current culture by supplying StringComparison.CurrentCulture, StringComparison.CurrentCultureIgnoreCase, or any member of the CompareOptions enumeration other than CompareOptions.Ordinal or CompareOptions.OrdinalIgnoreCase to an appropriate overload of the Compare method. Una comparación dependiente de la referencia cultural generalmente resulta adecuada para la ordenación, mientras que una comparación ordinal no es.A culture-sensitive comparison is generally appropriate for sorting whereas an ordinal comparison is not. Una comparación ordinal generalmente resulta adecuada para determinar si dos cadenas son iguales (es decir, para determinar la identidad), mientras que una comparación de referencias culturales no lo es.An ordinal comparison is generally appropriate for determining whether two strings are equal (that is, for determining identity) whereas a culture-sensitive comparison is not.

El ejemplo siguiente muestra la diferencia entre la comparación ordinal y las referencias culturales.The following example illustrates the difference between culture-sensitive and ordinal comparison. Este ejemplo devuelve tres cadenas, "Apple", "Primer lugar" y "AEble", mediante la comparación ordinal y las convenciones de las referencias culturales da-DK y en-US (cada uno de los cuales es la referencia cultural predeterminada en el momento del Compare se llama al método).The example evaluates three strings, "Apple", "Æble", and "AEble", using ordinal comparison and the conventions of the da-DK and en-US cultures (each of which is the default culture at the time the Compare method is called). Dado que el idioma danés el carácter "Æ" trata como carácter individual y ordena después de la "Z" en el alfabeto, la cadena "Æble" es mayor que "Apple".Because the Danish language treats the character "Æ" as an individual letter and sorts it after "Z" in the alphabet, the string "Æble" is greater than "Apple". Sin embargo, "Primer lugar" no se considera equivalente a "AEble", por lo que también es mayor que "AEble" "primer lugar".However, "Æble" is not considered equivalent to "AEble", so "Æble" is also greater than "AEble". La referencia cultural en-US no incluye la letra "Æ", pero lo trata como equivalente a "AE", que explica por qué "Primer lugar" es menor que "Apple", pero igual a "AEble".The en-US culture doesn't include the letter"Æ" but treats it as equivalent to "AE", which explains why "Æble" is less than "Apple" but equal to "AEble". Comparación ordinal, por otro lado, considera "Apple" para ser menor que "Primer lugar" y "Primer lugar" sea mayor que "AEble".Ordinal comparison, on the other hand, considers "Apple" to be less than "Æble", and "Æble" to be greater than "AEble".

using System;
using System.Globalization;
using System.Threading;

public class CompareStringSample
{
   public static void Main()
   {
      string str1 = "Apple";
      string str2 = "Æble"; 
      string str3 = "AEble";
      
      // Set the current culture to Danish in Denmark.
      Thread.CurrentThread.CurrentCulture = new CultureInfo("da-DK");
      Console.WriteLine("Current culture: {0}", 
                        CultureInfo.CurrentCulture.Name);
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str1, str2, String.Compare(str1, str2));
      Console.WriteLine("Comparison of {0} with {1}: {2}\n", 
                        str2, str3, String.Compare(str2, str3));
      
      // Set the current culture to English in the U.S.
      Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
      Console.WriteLine("Current culture: {0}", 
                        CultureInfo.CurrentCulture.Name);
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str1, str2, String.Compare(str1, str2));
      Console.WriteLine("Comparison of {0} with {1}: {2}\n", 
                        str2, str3, String.Compare(str2, str3));
      
      // Perform an ordinal comparison.
      Console.WriteLine("Ordinal comparison");
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str1, str2, 
                        String.Compare(str1, str2, StringComparison.Ordinal));
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str2, str3, 
                        String.Compare(str2, str3, StringComparison.Ordinal));
   }
}
// The example displays the following output:
//       Current culture: da-DK
//       Comparison of Apple with Æble: -1
//       Comparison of Æble with AEble: 1
//       
//       Current culture: en-US
//       Comparison of Apple with Æble: 1
//       Comparison of Æble with AEble: 0
//       
//       Ordinal comparison
//       Comparison of Apple with Æble: -133
//       Comparison of Æble with AEble: 133
Imports System.Globalization
Imports System.Threading

Public Module Example
   Public Sub Main()
      Dim str1 As String = "Apple"
      Dim str2 As String = "Æble"
      Dim str3 As String = "AEble"
      
      ' Set the current culture to Danish in Denmark.
      Thread.CurrentThread.CurrentCulture = New CultureInfo("da-DK")
      Console.WriteLine("Current culture: {0}", 
                        CultureInfo.CurrentCulture.Name)
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str1, str2, String.Compare(str1, str2))
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str2, str3, String.Compare(str2, str3))
      Console.WriteLine()
      
      ' Set the current culture to English in the U.S.
      Thread.CurrentThread.CurrentCulture = New CultureInfo("en-US")
      Console.WriteLine("Current culture: {0}", 
                        CultureInfo.CurrentCulture.Name)
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str1, str2, String.Compare(str1, str2))
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str2, str3, String.Compare(str2, str3))
      Console.WriteLine()
      
      ' Perform an ordinal comparison.
      Console.WriteLine("Ordinal comparison")
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str1, str2, 
                        String.Compare(str1, str2, StringComparison.Ordinal))
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str2, str3, 
                        String.Compare(str2, str3, StringComparison.Ordinal))
   End Sub
End Module
' The example displays the following output:
'       Current culture: da-DK
'       Comparison of Apple with Æble: -1
'       Comparison of Æble with AEble: 1
'       
'       Current culture: en-US
'       Comparison of Apple with Æble: 1
'       Comparison of Æble with AEble: 0
'       
'       Ordinal comparison
'       Comparison of Apple with Æble: -133
'       Comparison of Æble with AEble: 133

Utilice las siguientes directrices generales para elegir un método de comparación de ordenación o de cadena apropiado:Use the following general guidelines to choose an appropriate sorting or string comparison method:

  • Si desea que las cadenas se ordene en función de la referencia cultural del usuario, debe ordénelas según las convenciones de la referencia cultural actual.If you want the strings to be ordered based on the user's culture, you should order them based on the conventions of the current culture. Si cambia la referencia cultural del usuario, el orden de las cadenas ordenadas también cambiará en consecuencia.If the user's culture changes, the order of sorted strings will also change accordingly. Por ejemplo, una aplicación de diccionario de sinónimos siempre debe ordenar palabras en función de la referencia cultural del usuario.For example, a thesaurus application should always sort words based on the user's culture.

  • Si desea que las cadenas se ordenen según las convenciones de una referencia cultural concreta, debe solicitarlos proporcionando un CultureInfo objeto que representa esa referencia cultural a un método de comparación.If you want the strings to be ordered based on the conventions of a specific culture, you should order them by supplying a CultureInfo object that represents that culture to a comparison method. Por ejemplo, en una aplicación diseñada para enseñar a los alumnos un idioma concreto, desea que las cadenas se ordenen según las convenciones de una de las referencias culturales que habla ese idioma.For example, in an application designed to teach students a particular language, you want strings to be ordered based on the conventions of one of the cultures that speaks that language.

  • Si desea que el orden de las cadenas que permanecen sin cambios en distintas referencias culturales, debería ordénelas según las convenciones de la referencia cultural invariable o utilice una comparación ordinal.If you want the order of strings to remain unchanged across cultures, you should order them based on the conventions of the invariant culture or use an ordinal comparison. Por ejemplo, se usaría a una ordenación ordinal para organizar los nombres de archivos, procesos, exclusiones mutuas o canalizaciones con nombre.For example, you would use an ordinal sort to organize the names of files, processes, mutexes, or named pipes.

  • Para obtener una comparación que implica una decisión de seguridad (por ejemplo, si un nombre de usuario es válido), siempre debe realizar una prueba de igualdad ordinal mediante una llamada a una sobrecarga de la Equals método.For a comparison that involves a security decision (such as whether a username is valid), you should always perform an ordinal test for equality by calling an overload of the Equals method.

Nota

La versión de .NET dependen de la ordenación de referencias culturales y las mayúsculas y minúsculas de las reglas utilizadas en la comparación de cadenas.The culture-sensitive sorting and casing rules used in string comparison depend on the version of the .NET. En .NET Framework 4.5 y versiones posteriores que se ejecutan en el Windows 8Windows 8 sistema operativo, ordenación, mayúsculas y minúsculas, normalización y obtener información de carácter Unicode se ajusta al estándar Unicode 6.0.In the .NET Framework 4.5 and later versions running on the Windows 8Windows 8 operating system, sorting, casing, normalization, and Unicode character information conforms to the Unicode 6.0 standard. En otros sistemas operativos Windows, cumple el estándar Unicode 5.0.On other Windows operating systems, it conforms to the Unicode 5.0 standard. En .NET Core, depende de la versión del estándar Unicode compatibles con el sistema operativo subyacente.On .NET Core, it depends on the version of the Unicode Standard supported by the underlying operating system.

Para obtener más información acerca de palabra, cadena y las reglas de ordenación ordinal, vea el System.Globalization.CompareOptions tema.For more information about word, string, and ordinal sort rules, see the System.Globalization.CompareOptions topic. Para obtener más recomendaciones sobre cuándo usar cada regla, vea prácticas recomendadas para el uso de cadenas.For additional recommendations on when to use each rule, see Best Practices for Using Strings.

Normalmente, no llamar a cadena de los métodos de comparación como Compare directamente para determinar el criterio de ordenación de cadenas.Ordinarily, you don't call string comparison methods such as Compare directly to determine the sort order of strings. En su lugar, se llama a métodos de comparación, como los métodos de ordenación Array.Sort o List<T>.Sort.Instead, comparison methods are called by sorting methods such as Array.Sort or List<T>.Sort. El ejemplo siguiente realiza cuatro diferentes operaciones de ordenación (ordenación por palabra utilizando la referencia cultural actual, utilizando la referencia cultural de ordenación de palabras, ordenación ordinal y ordenación por cadena usando la referencia cultural invariable) sin llamar explícitamente a un método de comparación de cadenas Aunque especifique el tipo de comparación que se va a usar.The following example performs four different sorting operations (word sort using the current culture, word sort using the invariant culture, ordinal sort, and string sort using the invariant culture) without explicitly calling a string comparison method, although they do specify the type of comparison to use. Tenga en cuenta que cada tipo de ordenación genera una única ordenación de cadenas de su matriz.Note that each type of sort produces a unique ordering of strings in its array.

using namespace System;
using namespace System::Collections;
using namespace System::Collections::Generic;
using namespace System::Globalization;

// IComparer<String> implementation to perform string sort. 
ref class SCompare : System::Collections::Generic::IComparer<String^>
{
public:
   SCompare() {};

   virtual int Compare(String^ x, String^ y)
   {
      return CultureInfo::CurrentCulture->CompareInfo->Compare(x, y, CompareOptions::StringSort);
   }
};

void main()
{
   array<String^>^ strings = gcnew array<String^> { "coop", "co-op", "cooperative", 
                                                    L"co\x00ADoperative", L"c�ur", "coeur" };

   // Perform a word sort using the current (en-US) culture. 
   array<String^>^ current = gcnew array<String^>(strings->Length); 
   strings->CopyTo(current, 0); 
   Array::Sort(current, StringComparer::CurrentCulture);

   // Perform a word sort using the invariant culture. 
   array<String^>^ invariant = gcnew array<String^>(strings->Length);
   strings->CopyTo(invariant, 0); 
   Array::Sort(invariant, StringComparer::InvariantCulture);

   // Perform an ordinal sort. 
   array<String^>^ ordinal = gcnew array<String^>(strings->Length);
   strings->CopyTo(ordinal, 0); 
   Array::Sort(ordinal, StringComparer::Ordinal);

   // Perform a string sort using the current culture. 
   array<String^>^ stringSort = gcnew array<String^>(strings->Length);
   strings->CopyTo(stringSort, 0); 
   Array::Sort(stringSort, gcnew SCompare());

   // Display array values
   Console::WriteLine("{0,13} {1,13} {2,15} {3,13} {4,13}\n", 
                     "Original", "Word Sort", "Invariant Word", 
                     "Ordinal Sort", "String Sort");
   for (int ctr = 0; ctr < strings->Length; ctr++)
      Console::WriteLine("{0,13} {1,13} {2,15} {3,13} {4,13}", 
                         strings[ctr], current[ctr], invariant[ctr], 
                         ordinal[ctr], stringSort[ctr] );          
}
// The example displays the following output: 
//         Original     Word Sort  Invariant Word  Ordinal Sort   String Sort 
//     
//             coop          c�ur            c�ur         co-op         co-op 
//            co-op         coeur           coeur         coeur          c�ur 
//      cooperative          coop            coop          coop         coeur 
//      co�operative         co-op           co-op   cooperative          coop 
//             c�ur   cooperative     cooperative   co�operative   cooperative 
//            coeur   co�operative     co�operative          c�ur   co�operative
using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
 
public class Example
{
   public static void Main()
   {
      string[] strings = { "coop", "co-op", "cooperative", 
                           "co\u00ADoperative", "cœur", "coeur" };

      // Perform a word sort using the current (en-US) culture.
      string[] current = new string[strings.Length]; 
      strings.CopyTo(current, 0); 
      Array.Sort(current, StringComparer.CurrentCulture);

      // Perform a word sort using the invariant culture.
      string[] invariant = new string[strings.Length];
      strings.CopyTo(invariant, 0); 
      Array.Sort(invariant, StringComparer.InvariantCulture);

      // Perform an ordinal sort.
      string[] ordinal = new string[strings.Length];
      strings.CopyTo(ordinal, 0); 
      Array.Sort(ordinal, StringComparer.Ordinal);

      // Perform a string sort using the current culture.
      string[] stringSort = new string[strings.Length];
      strings.CopyTo(stringSort, 0); 
      Array.Sort(stringSort, new SCompare());

      // Display array values
      Console.WriteLine("{0,13} {1,13} {2,15} {3,13} {4,13}\n", 
                        "Original", "Word Sort", "Invariant Word", 
                        "Ordinal Sort", "String Sort");
      for (int ctr = 0; ctr < strings.Length; ctr++)
         Console.WriteLine("{0,13} {1,13} {2,15} {3,13} {4,13}", 
                           strings[ctr], current[ctr], invariant[ctr], 
                           ordinal[ctr], stringSort[ctr] );          
   }
}

// IComparer<String> implementation to perform string sort.
internal class SCompare : IComparer<String>
{
   public int Compare(string x, string y)
   {
      return CultureInfo.CurrentCulture.CompareInfo.Compare(x, y, CompareOptions.StringSort);
   }
}
// The example displays the following output:
//         Original     Word Sort  Invariant Word  Ordinal Sort   String Sort
//    
//             coop          cœur            cœur         co-op         co-op
//            co-op         coeur           coeur         coeur          cœur
//      cooperative          coop            coop          coop         coeur
//     co­operative         co-op           co-op   cooperative          coop
//             cœur   cooperative     cooperative  co­operative   cooperative
//            coeur  co­operative    co­operative          cœur  co­operative
Imports System.Collections
Imports System.Collections.Generic
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim strings() As String = { "coop", "co-op", "cooperative", 
                                  "co" + ChrW(&h00AD) + "operative", 
                                  "cœur", "coeur" }

      ' Perform a word sort using the current (en-US) culture.
      Dim current(strings.Length - 1) As String  
      strings.CopyTo(current, 0) 
      Array.Sort(current, StringComparer.CurrentCulture)

      ' Perform a word sort using the invariant culture.
      Dim invariant(strings.Length - 1) As String
      strings.CopyTo(invariant, 0) 
      Array.Sort(invariant, StringComparer.InvariantCulture)

      ' Perform an ordinal sort.
      Dim ordinal(strings.Length - 1) As String
      strings.CopyTo(ordinal, 0) 
      Array.Sort(ordinal, StringComparer.Ordinal)

      ' Perform a string sort using the current culture.
      Dim stringSort(strings.Length - 1) As String
      strings.CopyTo(stringSort, 0) 
      Array.Sort(stringSort, new SCompare())

      ' Display array values
      Console.WriteLine("{0,13} {1,13} {2,15} {3,13} {4,13}", 
                        "Original", "Word Sort", "Invariant Word", 
                        "Ordinal Sort", "String Sort")
      Console.WriteLine()
                                                      
      For ctr As Integer = 0 To strings.Length - 1
         Console.WriteLine("{0,13} {1,13} {2,15} {3,13} {4,13}", 
                           strings(ctr), current(ctr), invariant(ctr), 
                           ordinal(ctr), stringSort(ctr))   
      Next                                  
   End Sub
End Module

' IComparer<String> implementation to perform string sort.
Friend Class SCompare : Implements IComparer(Of String)
   Public Function Compare(x As String, y As String) As Integer _
                   Implements IComparer(Of String).Compare
      Return CultureInfo.CurrentCulture.CompareInfo.Compare(x, y, CompareOptions.StringSort)
   End Function
End Class
' The example displays the following output:
'         Original     Word Sort  Invariant Word  Ordinal Sort   String Sort
'    
'             coop          cœur            cœur         co-op         co-op
'            co-op         coeur           coeur         coeur          cœur
'      cooperative          coop            coop          coop         coeur
'     co­operative         co-op           co-op   cooperative          coop
'             cœur   cooperative     cooperative  co­operative   cooperative
'            coeur  co­operative    co­operative          cœur  co­operative

Sugerencia

Internamente, .NET usa claves de ordenación para admitir la comparación de cadenas cultural.Internally, .NET uses sort keys to support culturally sensitive string comparison. A cada carácter de una cadena se le otorgan varias categorías de prioridad de ordenación, entre las que se incluyen el orden alfabético, el uso de mayúsculas y minúsculas y los signos diacríticos.Each character in a string is given several categories of sort weights, including alphabetic, case, and diacritic. Un criterio de ordenación, representado por la SortKey clase, proporciona un repositorio de estas categorías para una cadena determinada.A sort key, represented by the SortKey class, provides a repository of these weights for a particular string. Si la aplicación realiza un gran número de búsqueda o clasificación de las operaciones en el mismo conjunto de cadenas, puede mejorar su rendimiento generando y almacenando las claves de ordenación para todas las cadenas que utiliza.If your app performs a large number of searching or sorting operations on the same set of strings, you can improve its performance by generating and storing sort keys for all the strings that it uses. Cuando se requiere una operación de ordenación o de comparación, usar las claves de ordenación en lugar de las cadenas.When a sort or comparison operation is required, you use the sort keys instead of the strings. Para obtener más información, vea la clase SortKey.For more information, see the SortKey class.

Si no se especifica una convención de comparación de cadenas, métodos de ordenación como Array.Sort(Array) realizar una ordenación culturales, distingue mayúsculas de minúsculas en las cadenas.If you don't specify a string comparison convention, sorting methods such as Array.Sort(Array) perform a culture-sensitive, case-sensitive sort on strings. El ejemplo siguiente muestra cómo cambiar la referencia cultural actual afecta al orden de las cadenas ordenadas en una matriz.The following example illustrates how changing the current culture affects the order of sorted strings in an array. Crea una matriz de tres cadenas.It creates an array of three strings. En primer lugar, se establece la propiedad System.Threading.Thread.CurrentThread.CurrentCulture en en-US y se llama al método Array.Sort(Array).First, it sets the System.Threading.Thread.CurrentThread.CurrentCulture property to en-US and calls the Array.Sort(Array) method. El criterio de ordenación resultante se basa en las convenciones de ordenación de la referencia cultural Inglés (Estados Unidos).The resulting sort order is based on sorting conventions for the English (United States) culture. A continuación, el ejemplo establece la propiedad System.Threading.Thread.CurrentThread.CurrentCulture en da-DK y llama de nuevo al método Array.Sort.Next, the example sets the System.Threading.Thread.CurrentThread.CurrentCulture property to da-DK and calls the Array.Sort method again. Observe que el criterio de ordenación resultante difiere del resultado de en-US porque usa las convenciones de ordenación correspondientes a la referencia cultural Danés (Dinamarca).Notice how the resulting sort order differs from the en-US results because it uses the sorting conventions for Danish (Denmark).

using System;
using System.Globalization;
using System.Threading;

public class ArraySort 
{
   public static void Main(String[] args) 
   {
      // Create and initialize a new array to store the strings.
      string[] stringArray = { "Apple", "Æble", "Zebra"};

      // Display the values of the array.
      Console.WriteLine( "The original string array:");
      PrintIndexAndValues(stringArray);

      // Set the CurrentCulture to "en-US".
      Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
      // Sort the values of the array.
      Array.Sort(stringArray);

      // Display the values of the array.
      Console.WriteLine("After sorting for the culture \"en-US\":");
      PrintIndexAndValues(stringArray); 

      // Set the CurrentCulture to "da-DK".
      Thread.CurrentThread.CurrentCulture = new CultureInfo("da-DK");
      // Sort the values of the Array.
      Array.Sort(stringArray);

      // Display the values of the array.
      Console.WriteLine("After sorting for the culture \"da-DK\":");
      PrintIndexAndValues(stringArray); 
   }
   public static void PrintIndexAndValues(string[] myArray)  
   {
      for (int i = myArray.GetLowerBound(0); i <= 
            myArray.GetUpperBound(0); i++ )
         Console.WriteLine("[{0}]: {1}", i, myArray[i]);
      Console.WriteLine();      
   }
}
// The example displays the following output:
//       The original string array:
//       [0]: Apple
//       [1]: Æble
//       [2]: Zebra
//       
//       After sorting for the "en-US" culture:
//       [0]: Æble
//       [1]: Apple
//       [2]: Zebra
//       
//       After sorting for the culture "da-DK":
//       [0]: Apple
//       [1]: Zebra
//       [2]: Æble
Imports System.Globalization
Imports System.IO
Imports System.Threading

Public Class TextToFile   
   Public Shared Sub Main()
      ' Creates and initializes a new array to store 
      ' these date/time objects.
      Dim stringArray() As String = { "Apple", "Æble", "Zebra"}
      
      ' Displays the values of the array.
      Console.WriteLine("The original string array:")
      PrintIndexAndValues(stringArray)
      
      ' Set the CurrentCulture to "en-US".
      Thread.CurrentThread.CurrentCulture = New CultureInfo("en-US")
      ' Sort the values of the Array.
      Array.Sort(stringArray)
      
      ' Display the values of the array.
      Console.WriteLine("After sorting for the ""en-US"" culture:")
      PrintIndexAndValues(stringArray)
      
      ' Set the CurrentCulture to "da-DK".
      Thread.CurrentThread.CurrentCulture = New CultureInfo("da-DK")
      ' Sort the values of the Array.
      Array.Sort(stringArray)
      
      ' Displays the values of the Array.
      Console.WriteLine("After sorting for the culture ""da-DK"":")
      PrintIndexAndValues(stringArray)
   End Sub

   Public Shared Sub PrintIndexAndValues(myArray() As String)
      For i As Integer = myArray.GetLowerBound(0) To myArray.GetUpperBound(0)
         Console.WriteLine("[{0}]: {1}", i, myArray(i))
      Next
      Console.WriteLine()
   End Sub 
End Class
' The example displays the following output:
'       The original string array:
'       [0]: Apple
'       [1]: Æble
'       [2]: Zebra
'       
'       After sorting for the "en-US" culture:
'       [0]: Æble
'       [1]: Apple
'       [2]: Zebra
'       
'       After sorting for the culture "da-DK":
'       [0]: Apple
'       [1]: Zebra
'       [2]: Æble

Advertencia

Si su objetivo principal en la comparación de cadenas es determinar si son iguales, se debe llamar a la String.Equals método.If your primary purpose in comparing strings is to determine whether they are equal, you should call the String.Equals method. Normalmente, debe utilizar Equals para realizar una comparación ordinal.Typically, you should use Equals to perform an ordinal comparison. El String.Compare método está pensado principalmente para ordenar cadenas.The String.Compare method is intended primarily to sort strings.

Los métodos de búsqueda de cadena como String.StartsWith y String.IndexOf, también puede realizar comparaciones de cadenas de referencias culturales u ordinal.String search methods, such as String.StartsWith and String.IndexOf, also can perform culture-sensitive or ordinal string comparisons. El ejemplo siguiente muestra las diferencias entre las comparaciones ordinales y culturales utilizando el IndexOf método.The following example illustrates the differences between ordinal and culture-sensitive comparisons using the IndexOf method. Una búsqueda de la referencia cultural en la que la referencia cultural actual es inglés (Estados Unidos), considera que la subcadena "oe" para que coincida con la ligadura "œ".A culture-sensitive search in which the current culture is English (United States) considers the substring "oe" to match the ligature "œ". Dado que un guion (00AD) es un carácter de ancho cero, la búsqueda trata el guion como equivalente a Empty y encuentra una coincidencia al principio de la cadena.Because a soft hyphen (U+00AD) is a zero-width character, the search treats the soft hyphen as equivalent to Empty and finds a match at the beginning of the string. Por otro lado, una búsqueda ordinal, no encuentra a una coincidencia en cualquier caso.An ordinal search, on the other hand, does not find a match in either case.

using namespace System;

void FindInString(String^ s, String^ substring, StringComparison options);

void main()
{
   // Search for "oe" and "�u" in "�ufs" and "oeufs".
   String^ s1 = L"�ufs";
   String^ s2 = L"oeufs";
   FindInString(s1, "oe", StringComparison::CurrentCulture);
   FindInString(s1, "oe", StringComparison::Ordinal);
   FindInString(s2, "�u", StringComparison::CurrentCulture);
   FindInString(s2, "�u", StringComparison::Ordinal);
   Console::WriteLine();

   String^ s3 = L"co\x00ADoperative";
   FindInString(s3, L"\x00AD", StringComparison::CurrentCulture);
   FindInString(s3, L"\x00AD", StringComparison::Ordinal);
}

void FindInString(String^ s, String^ substring, StringComparison options)
{
   int result = s->IndexOf(substring, options);
   if (result != -1)
      Console::WriteLine("'{0}' found in {1} at position {2}", 
                        substring, s, result);
   else
      Console::WriteLine("'{0}' not found in {1}", 
                        substring, s);                                                  
}
// The example displays the following output:
//      'oe' found in oufs at position 0
//      'oe' not found in oufs
//      'ou' found in oeufs at position 0
//      'ou' not found in oeufs
//
//      '-' found in co-operative at position 0
//      '-' found in co-operative at position 2
using System;

public class Example
{
   public static void Main()
   {
      // Search for "oe" and "œu" in "œufs" and "oeufs".
      string s1 = "œufs";
      string s2 = "oeufs";
      FindInString(s1, "oe", StringComparison.CurrentCulture);
      FindInString(s1, "oe", StringComparison.Ordinal);
      FindInString(s2, "œu", StringComparison.CurrentCulture);
      FindInString(s2, "œu", StringComparison.Ordinal);
      Console.WriteLine();
      
      string s3 = "co\u00ADoperative";
      FindInString(s3, "\u00AD", StringComparison.CurrentCulture);
      FindInString(s3, "\u00AD", StringComparison.Ordinal);
   }

   private static void FindInString(string s, string substring, StringComparison options)
   {
      int result = s.IndexOf(substring, options);
      if (result != -1)
         Console.WriteLine("'{0}' found in {1} at position {2}", 
                           substring, s, result);
      else
         Console.WriteLine("'{0}' not found in {1}", 
                           substring, s);                                                  
   }
}
// The example displays the following output:
//       'oe' found in œufs at position 0
//       'oe' not found in œufs
//       'œu' found in oeufs at position 0
//       'œu' not found in oeufs
//       
//       '­' found in co­operative at position 0
//       '­' found in co­operative at position 2
Module Example
   Public Sub Main()
      ' Search for "oe" and "œu" in "œufs" and "oeufs".
      Dim s1 As String = "œufs"
      Dim s2 As String = "oeufs"
      FindInString(s1, "oe", StringComparison.CurrentCulture)
      FindInString(s1, "oe", StringComparison.Ordinal)
      FindInString(s2, "œu", StringComparison.CurrentCulture)
      FindInString(s2, "œu", StringComparison.Ordinal)
      Console.WriteLine()
      
      Dim softHyphen As String = ChrW(&h00AD)
      Dim s3 As String = "co" + softHyphen + "operative"
      FindInString(s3, softHyphen, StringComparison.CurrentCulture)
      FindInString(s3, softHyphen, StringComparison.Ordinal)
   End Sub

   Private Sub FindInString(s As String, substring As String, 
                            options As StringComparison)
      Dim result As Integer = s.IndexOf(substring, options)
      If result <> -1
         Console.WriteLine("'{0}' found in {1} at position {2}", 
                           substring, s, result)
      Else
         Console.WriteLine("'{0}' not found in {1}", 
                           substring, s)
      End If                                                                          
   End Sub
End Module
' The example displays the following output:
'       'oe' found in œufs at position 0
'       'oe' not found in œufs
'       'œu' found in oeufs at position 0
'       'œu' not found in oeufs
'       
'       '­' found in co­operative at position 0
'       '­' found in co­operative at position 2

Buscar cadenasSearching Strings

Los métodos de búsqueda de cadena como String.StartsWith y String.IndexOf, también puede llevar a cabo la referencia cultural o comparaciones de cadenas ordinales para determinar si un carácter o subcadena se encuentra en una cadena especificada.String search methods, such as String.StartsWith and String.IndexOf, also can perform culture-sensitive or ordinal string comparisons to determine whether a character or substring is found in a specified string.

Los métodos de búsqueda en el String clase que buscar un carácter individual, como el IndexOf método o un conjunto de caracteres, como el IndexOfAny método, todas realizan una búsqueda ordinal.The search methods in the String class that search for an individual character, such as the IndexOf method, or one of a set of characters, such as the IndexOfAny method, all perform an ordinal search. Para llevar a cabo una búsqueda de la referencia cultural de un carácter, debe llamar a un CompareInfo método como CompareInfo.IndexOf(String, Char) o CompareInfo.LastIndexOf(String, Char).To perform a culture-sensitive search for a character, you must call a CompareInfo method such as CompareInfo.IndexOf(String, Char) or CompareInfo.LastIndexOf(String, Char). Tenga en cuenta que los resultados de buscar un carácter mediante la comparación ordinal y la referencia cultural pueden ser muy diferentes.Note that the results of searching for a character using ordinal and culture-sensitive comparison can be very different. Por ejemplo, una búsqueda de un carácter Unicode compuesto como la ligadura "Æ" (U + 00 C 6) podría coincidir con cualquier aparición de sus componentes en la secuencia correcta, como "AE" (U + 041U + 0045), dependiendo de la referencia cultural.For example, a search for a precomposed Unicode character such as the ligature "Æ" (U+00C6) might match any occurrence of its components in the correct sequence, such as "AE" (U+041U+0045), depending on the culture. El ejemplo siguiente muestra la diferencia entre el String.IndexOf(Char) y CompareInfo.IndexOf(String, Char) métodos cuando se busca un carácter individual.The following example illustrates the difference between the String.IndexOf(Char) and CompareInfo.IndexOf(String, Char) methods when searching for an individual character. La ligadura "æ" (00E6) se encuentra en la cadena "aérea" al usar las convenciones de la referencia cultural en-US, pero no cuando se utilizan las convenciones de la referencia cultural da-DK o al realizar una comparación ordinal.The ligature "æ" (U+00E6) is found in the string "aerial" when using the conventions of the en-US culture, but not when using the conventions of the da-DK culture or when performing an ordinal comparison.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      String[] cultureNames = { "da-DK", "en-US" };
      CompareInfo ci;
      String str = "aerial";
      Char ch = 'æ';  // U+00E6
      
      Console.Write("Ordinal comparison -- ");
      Console.WriteLine("Position of '{0}' in {1}: {2}", ch, str,
                        str.IndexOf(ch));
      
      foreach (var cultureName in cultureNames) {
         ci = CultureInfo.CreateSpecificCulture(cultureName).CompareInfo;
         Console.Write("{0} cultural comparison -- ", cultureName);
         Console.WriteLine("Position of '{0}' in {1}: {2}", ch, str,
                           ci.IndexOf(str, ch));
      }
   }
}
// The example displays the following output:
//       Ordinal comparison -- Position of 'æ' in aerial: -1
//       da-DK cultural comparison -- Position of 'æ' in aerial: -1
//       en-US cultural comparison -- Position of 'æ' in aerial: 0
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim cultureNames() As String = { "da-DK", "en-US" }
      Dim ci As CompareInfo
      Dim str As String = "aerial"
      Dim ch As Char = "æ"c  ' U+00E6
      
      Console.Write("Ordinal comparison -- ")
      Console.WriteLine("Position of '{0}' in {1}: {2}", ch, str,
                        str.IndexOf(ch))
      
      For Each cultureName In cultureNames
         ci = CultureInfo.CreateSpecificCulture(cultureName).CompareInfo
         Console.Write("{0} cultural comparison -- ", cultureName)
         Console.WriteLine("Position of '{0}' in {1}: {2}", ch, str,
                           ci.IndexOf(str, ch))
      Next
   End Sub
End Module
' The example displays the following output:
'       Ordinal comparison -- Position of 'æ' in aerial: -1
'       da-DK cultural comparison -- Position of 'æ' in aerial: -1
'       en-US cultural comparison -- Position of 'æ' in aerial: 0

Por otro lado, String métodos que busquen una cadena en lugar de un carácter de realiza una búsqueda de la referencia cultural, si las opciones de búsqueda no se especifican explícitamente a un parámetro de tipo de la clase StringComparison.On the other hand, String class methods that search for a string rather than a character perform a culture-sensitive search if search options are not explicitly specified by a parameter of type StringComparison. La única excepción es Contains, que realiza una búsqueda ordinal.The sole exception is Contains, which performs an ordinal search.

Probar la igualdadTesting for equality

Use el String.Compare método para determinar la relación de dos cadenas en el criterio de ordenación.Use the String.Compare method to determine the relationship of two strings in the sort order. Normalmente, esto es una operación de la referencia cultural.Typically, this is a culture-sensitive operation. En cambio, llame a la String.Equals método para comprobar la igualdad.In contrast, call the String.Equals method to test for equality. Dado que la prueba de igualdad normalmente compara la entrada del usuario con alguna cadena conocido, como un nombre de usuario válida, una contraseña o una ruta de acceso del sistema de archivos, normalmente es una operación ordinal.Because the test for equality usually compares user input with some known string, such as a valid user name, a password, or a file system path, it is typically an ordinal operation.

Advertencia

Es posible comprobar la igualdad llamando el String.Compare método y determinar si el valor devuelto es cero.It is possible to test for equality by calling the String.Compare method and determining whether the return value is zero. Sin embargo, no se recomienda esta práctica.However, this practice is not recommended. Para determinar si dos cadenas son iguales, debe llamar a una de las sobrecargas de los String.Equals método.To determine whether two strings are equal, you should call one of the overloads of the String.Equals method. La sobrecarga preferida para llamar a es la instancia Equals(String, StringComparison) estático o método Equals(String, String, StringComparison) método, porque ambos métodos incluyen un System.StringComparison parámetro que especifique explícitamente el tipo de comparación.The preferred overload to call is either the instance Equals(String, StringComparison) method or the static Equals(String, String, StringComparison) method, because both methods include a System.StringComparison parameter that explicitly specifies the type of comparison.

El ejemplo siguiente muestra el peligro de llevar a cabo una comparación dependiente de la referencia cultural para la igualdad cuando un ordinal que se debería utilizar en su lugar.The following example illustrates the danger of performing a culture-sensitive comparison for equality when an ordinal one should be used instead. En este caso, la intención del código es prohibir el acceso al sistema de archivos de las direcciones URL que comienzan con "FILE://" o "file://" mediante la realización de una comparación entre mayúsculas y minúsculas del principio de una dirección URL con la cadena "FILE://".In this case, the intent of the code is to prohibit file system access from URLs that begin with "FILE://" or "file://" by performing a case-insensitive comparison of the beginning of a URL with the string "FILE://". Sin embargo, si se realiza una comparación de la referencia cultural utilizando la referencia cultural de turco (Turquía) en una dirección URL que comienza con "file://", la comparación de igualdad produce un error, porque el turco equivalente en mayúsculas de minúsculas "i" es "İ" en lugar de "I".However, if a culture-sensitive comparison is performed using the Turkish (Turkey) culture on a URL that begins with "file://", the comparison for equality fails, because the Turkish uppercase equivalent of the lowercase "i" is "İ" instead of "I". Como resultado, por accidente se permite el acceso al sistema de archivos.As a result, file system access is inadvertently permitted. Por otro lado, si se realiza una comparación ordinal, la comparación de igualdad se realiza correctamente y se deniega el acceso al sistema de archivos.On the other hand, if an ordinal comparison is performed, the comparison for equality succeeds, and file system access is denied.

using namespace System;
using namespace System::Globalization;
using namespace System::Threading;

bool TestForEquality(String^ str, StringComparison cmp);

void main()
{
   Thread::CurrentThread->CurrentCulture = CultureInfo::CreateSpecificCulture("tr-TR");      

   String^ filePath = "file://c:/notes.txt";

   Console::WriteLine("Culture-sensitive test for equality:");
   if (! TestForEquality(filePath, StringComparison::CurrentCultureIgnoreCase))
      Console::WriteLine("Access to {0} is allowed.", filePath);
   else
      Console::WriteLine("Access to {0} is not allowed.", filePath);

   Console::WriteLine("\nOrdinal test for equality:");
   if (! TestForEquality(filePath, StringComparison::OrdinalIgnoreCase))
      Console::WriteLine("Access to {0} is allowed.", filePath);
   else
      Console::WriteLine("Access to {0} is not allowed.", filePath);
}

bool TestForEquality(String^ str, StringComparison cmp)
{
      int position = str->IndexOf("://");
      if (position < 0) return false;

      String^ substring = str->Substring(0, position);  
      return substring->Equals("FILE", cmp);
}
// The example displays the following output: 
//       Culture-sensitive test for equality: 
//       Access to file://c:/notes.txt is allowed. 
//        
//       Ordinal test for equality: 
//       Access to file://c:/notes.txt is not allowed.
using System;
using System.Globalization;
using System.Threading;

public class Example
{
   public static void Main()
   {
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("tr-TR");      

      string filePath = "file://c:/notes.txt";
      
      Console.WriteLine("Culture-sensitive test for equality:");
      if (! TestForEquality(filePath, StringComparison.CurrentCultureIgnoreCase))
         Console.WriteLine("Access to {0} is allowed.", filePath);
      else
         Console.WriteLine("Access to {0} is not allowed.", filePath);
      
      Console.WriteLine("\nOrdinal test for equality:");
      if (! TestForEquality(filePath, StringComparison.OrdinalIgnoreCase))
         Console.WriteLine("Access to {0} is allowed.", filePath);
      else
         Console.WriteLine("Access to {0} is not allowed.", filePath);
   }

   private static bool TestForEquality(string str, StringComparison cmp)
   {
      int position = str.IndexOf("://");
      if (position < 0) return false;

      string substring = str.Substring(0, position);  
      return substring.Equals("FILE", cmp);
   }
}
// The example displays the following output:
//       Culture-sensitive test for equality:
//       Access to file://c:/notes.txt is allowed.
//       
//       Ordinal test for equality:
//       Access to file://c:/notes.txt is not allowed.
Imports System.Globalization
Imports System.Threading

Module Example
   Public Sub Main()
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("tr-TR")      

      Dim filePath As String = "file://c:/notes.txt"
      
      Console.WriteLine("Culture-sensitive test for equality:")
      If Not TestForEquality(filePath, StringComparison.CurrentCultureIgnoreCase) Then
         Console.WriteLine("Access to {0} is allowed.", filePath)
      Else
         Console.WriteLine("Access to {0} is not allowed.", filePath)
      End If       
      Console.WriteLine()
      
      Console.WriteLine("Ordinal test for equality:")
      If Not TestForEquality(filePath, StringComparison.OrdinalIgnoreCase) Then
         Console.WriteLine("Access to {0} is allowed.", filePath)
      Else
         Console.WriteLine("Access to {0} is not allowed.", filePath)
      End If       
   End Sub
   
   Private Function TestForEquality(str As String, cmp As StringComparison) As Boolean
      Dim position As Integer = str.IndexOf("://")
      If position < 0 Then Return False

      Dim substring As String = str.Substring(0, position)  
      Return substring.Equals("FILE", cmp)
   End Function
End Module
' The example displays the following output:
'       Culture-sensitive test for equality:
'       Access to file://c:/notes.txt is allowed.
'       
'       Ordinal test for equality:
'       Access to file://c:/notes.txt is not allowed.

NormalizaciónNormalization

Algunos caracteres Unicode tienen varias representaciones.Some Unicode characters have multiple representations. Por ejemplo, cualquiera de los puntos de código siguiente puede representar la letra "ắ":For example, any of the following code points can represent the letter "ắ":

  • 1EAF U +U+1EAF

  • U + 0103 U + 0301U+0103 U+0301

  • U + 0061 U + 0306 U + 0301U+0061 U+0306 U+0301

Varias representaciones de un único carácter complican la búsqueda, ordenación, coincidencia y otras operaciones de cadena.Multiple representations for a single character complicate searching, sorting, matching, and other string operations.

El estándar Unicode define un proceso denominado normalización, que devuelve una representación binaria de un carácter Unicode para cualquiera de sus representaciones binarias equivalentes.The Unicode standard defines a process called normalization that returns one binary representation of a Unicode character for any of its equivalent binary representations. La normalización puede utilizar varios algoritmos, denominados formas de normalización, que siguen reglas distintas.Normalization can use several algorithms, called normalization forms, that follow different rules. .NET es compatible con formas de normalización Unicode C, D, KC y KD..NET supports Unicode normalization forms C, D, KC, and KD. Cuando se han normalizado las cadenas a la misma forma de normalización, pueden compararse por medio de una comparación ordinal.When strings have been normalized to the same normalization form, they can be compared by using ordinal comparison.

Una comparación ordinal es una comparación binaria del valor escalar Unicode de correspondiente Char objetos de cada cadena.An ordinal comparison is a binary comparison of the Unicode scalar value of corresponding Char objects in each string. La String clase incluye una serie de métodos que puede realizar una comparación ordinal, incluido lo siguiente:The String class includes a number of methods that can perform an ordinal comparison, including the following:

Puede determinar si una cadena se normaliza a la forma de normalización C mediante una llamada a la String.IsNormalized() puede llamar al método, o bien el String.IsNormalized(NormalizationForm) método para determinar si se normaliza una cadena a una forma de normalización especificada.You can determine whether a string is normalized to normalization form C by calling the String.IsNormalized() method, or you can call the String.IsNormalized(NormalizationForm) method to determine whether a string is normalized to a specified normalization form. También puede llamar a la String.Normalize() puede llamar al método para convertir una cadena en forma de normalización C, o bien el String.Normalize(NormalizationForm) método para convertir una cadena en una forma de normalización especificada.You can also call the String.Normalize() method to convert a string to normalization form C, or you can call the String.Normalize(NormalizationForm) method to convert a string to a specified normalization form. Para obtener información detallada sobre la normalización y comparar cadenas, vea el Normalize() y Normalize(NormalizationForm) métodos.For step-by-step information about normalizing and comparing strings, see the Normalize() and Normalize(NormalizationForm) methods.

El siguiente ejemplo muestra la normalización de cadenas.The following simple example illustrates string normalization. Define la letra "ố" de tres maneras diferentes en tres cadenas diferentes y utiliza una comparación ordinal de igualdad para determinar que cada cadena difiere de las dos cadenas.It defines the letter "ố" in three different ways in three different strings, and uses an ordinal comparison for equality to determine that each string differs from the other two strings. A continuación, convierte cada cadena en las formas de normalización admitidas y vuelva a realiza una comparación ordinal de cada cadena en una forma de normalización especificada.It then converts each string to the supported normalization forms, and again performs an ordinal comparison of each string in a specified normalization form. En cada caso, la segunda prueba de igualdad muestra que las cadenas son iguales.In each case, the second test for equality shows that the strings are equal.

using namespace System;
using namespace System::Globalization;
using namespace System::IO;
using namespace System::Text;

public ref class Example
{
private:
   StreamWriter^ sw;

   void TestForEquality(... array<String^>^  words)
   {
      for (int ctr = 0; ctr <= words->Length - 2; ctr++)
         for (int ctr2 = ctr + 1; ctr2 <= words->Length - 1; ctr2++) 
            sw->WriteLine("{0} ({1}) = {2} ({3}): {4}", 
                         words[ctr], ShowBytes(words[ctr]),
                         words[ctr2], ShowBytes(words[ctr2]),
                         words[ctr]->Equals(words[ctr2], StringComparison::Ordinal));
   }

   String^ ShowBytes(String^ str)
   {
      String^ result = nullptr;
      for each (Char ch in str)
         result += String::Format("{0} ", Convert::ToUInt16(ch).ToString("X4")); 
      return result->Trim();            
   } 

   array<String^>^ NormalizeStrings(NormalizationForm nf, ... array<String^>^ words)
   {
      for (int ctr = 0; ctr < words->Length; ctr++)
         if (! words[ctr]->IsNormalized(nf))
            words[ctr] = words[ctr]->Normalize(nf); 
      return words;   
   }

public: 
   void Execute()
   {
      sw = gcnew StreamWriter(".\\TestNorm1.txt");

      // Define three versions of the same word.  
      String^ s1 = L"sống";        // create word with U+1ED1 
      String^ s2 = L"s\x00F4\x0301ng";
      String^ s3 = L"so\x0302\x0301ng";

      TestForEquality(s1, s2, s3);      
      sw->WriteLine();

      // Normalize and compare strings using each normalization form. 
      for each (String^ formName in Enum::GetNames(NormalizationForm::typeid))
      {
         sw->WriteLine("Normalization {0}:\n", formName); 
         NormalizationForm nf = (NormalizationForm) Enum::Parse(NormalizationForm::typeid, formName);
         array<String^>^ sn = NormalizeStrings(nf, s1, s2, s3 );
         TestForEquality(sn);           
         sw->WriteLine("\n");                                        
      }

      sw->Close(); 
   }
};

void main()
{
   Example^ ex = gcnew Example();
   ex->Execute();
}
// The example produces the following output:
// The example displays the following output: 
//       sống (0073 1ED1 006E 0067) = sống (0073 00F4 0301 006E 0067): False 
//       sống (0073 1ED1 006E 0067) = sống (0073 006F 0302 0301 006E 0067): False 
//       sống (0073 00F4 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): False 
//        
//       Normalization FormC: 
//        
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True 
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True 
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True 
//        
//        
//       Normalization FormD: 
//        
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True 
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True 
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True 
//        
//        
//       Normalization FormKC: 
//        
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True 
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True 
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True 
//        
//        
//       Normalization FormKD: 
//        
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True 
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True 
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
using System;
using System.Globalization;
using System.IO;
using System.Text;

public class Example
{
   private static StreamWriter sw;
   
   public static void Main()
   {
      sw = new StreamWriter(@".\TestNorm1.txt");

      // Define three versions of the same word. 
      string s1 = "sống";        // create word with U+1ED1
      string s2 = "s\u00F4\u0301ng";
      string s3 = "so\u0302\u0301ng";

      TestForEquality(s1, s2, s3);      
      sw.WriteLine();

      // Normalize and compare strings using each normalization form.
      foreach (string formName in Enum.GetNames(typeof(NormalizationForm)))
      {
         sw.WriteLine("Normalization {0}:\n", formName); 
         NormalizationForm nf = (NormalizationForm) Enum.Parse(typeof(NormalizationForm), formName);
         string[] sn = NormalizeStrings(nf, s1, s2, s3);
         TestForEquality(sn);           
         sw.WriteLine("\n");                                        
      }
      
      sw.Close();   
   }

   private static void TestForEquality(params string[] words)
   {
      for (int ctr = 0; ctr <= words.Length - 2; ctr++)
         for (int ctr2 = ctr + 1; ctr2 <= words.Length - 1; ctr2++) 
            sw.WriteLine("{0} ({1}) = {2} ({3}): {4}", 
                         words[ctr], ShowBytes(words[ctr]),
                         words[ctr2], ShowBytes(words[ctr2]),
                         words[ctr].Equals(words[ctr2], StringComparison.Ordinal));
   }

   private static string ShowBytes(string str)
   {
      string result = null;
      foreach (var ch in str)
         result += String.Format("{0} ", Convert.ToUInt16(ch).ToString("X4")); 
      return result.Trim();            
   } 
   
   private static string[] NormalizeStrings(NormalizationForm nf, params string[] words)
   {
      for (int ctr = 0; ctr < words.Length; ctr++)
         if (! words[ctr].IsNormalized(nf))
            words[ctr] = words[ctr].Normalize(nf); 
      return words;   
   }
}
// The example displays the following output:
//       sống (0073 1ED1 006E 0067) = sống (0073 00F4 0301 006E 0067): False
//       sống (0073 1ED1 006E 0067) = sống (0073 006F 0302 0301 006E 0067): False
//       sống (0073 00F4 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): False
//       
//       Normalization FormC:
//       
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       
//       
//       Normalization FormD:
//       
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
//       
//       
//       Normalization FormKC:
//       
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       
//       
//       Normalization FormKD:
//       
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
Imports System.Globalization
Imports System.IO
Imports System.Text

Module Example
   Private sw As StreamWriter
       
   Public Sub Main()
      sw = New StreamWriter(".\TestNorm1.txt")

      ' Define three versions of the same word. 
      Dim s1 As String = "sống"        ' create word with U+1ED1
      Dim s2 AS String = "s" + ChrW(&h00F4) + ChrW(&h0301) + "ng"
      Dim s3 As String = "so" + ChrW(&h0302) + ChrW(&h0301) + "ng"

      TestForEquality(s1, s2, s3)      
      sw.WriteLine()

      ' Normalize and compare strings using each normalization form.
      For Each formName In [Enum].GetNames(GetType(NormalizationForm))
         sw.WriteLine("Normalization {0}:", formName) 
         Dim nf As NormalizationForm = CType([Enum].Parse(GetType(NormalizationForm), formName),  
                                             NormalizationForm)
         Dim sn() As String = NormalizeStrings(nf, s1, s2, s3)
         TestForEquality(sn)           
         sw.WriteLine(vbCrLf)                                        
      Next
      
      sw.Close()   
   End Sub

   Private Sub TestForEquality(ParamArray words As String())
      For ctr As Integer = 0 To words.Length - 2
         For ctr2 As Integer = ctr + 1 To words.Length - 1 
            sw.WriteLine("{0} ({1}) = {2} ({3}): {4}", 
                         words(ctr), ShowBytes(words(ctr)),
                         words(ctr2), ShowBytes(words(ctr2)),
                         words(ctr).Equals(words(ctr2), StringComparison.Ordinal))
         Next                
      Next   
   End Sub

   Private Function ShowBytes(str As String) As String
      Dim result As String = Nothing
      For Each ch In str
         result += String.Format("{0} ", Convert.ToUInt16(ch).ToString("X4")) 
      Next
      Return result.Trim()            
   End Function  
   
   Private Function NormalizeStrings(nf As NormalizationForm, ParamArray words() As String) As String()
      For ctr As Integer = 0 To words.Length - 1
         If Not words(ctr).IsNormalized(nf) Then
            words(ctr) = words(ctr).Normalize(nf)
         End If    
      Next
      Return words   
   End Function
End Module
' The example displays the following output:
'       sống (0073 1ED1 006E 0067) = sống (0073 00F4 0301 006E 0067): False
'       sống (0073 1ED1 006E 0067) = sống (0073 006F 0302 0301 006E 0067): False
'       sống (0073 00F4 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): False
'       
'       Normalization FormC:
'       
'       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
'       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
'       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
'       
'       
'       Normalization FormD:
'       
'       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
'       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
'       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
'       
'       
'       Normalization FormKC:
'       
'       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
'       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
'       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
'       
'       
'       Normalization FormKD:
'       
'       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
'       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
'       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True

Para obtener más información sobre la normalización y formas de normalización, consulte System.Text.NormalizationForm, así como Unicode Standard Annex #15: Unicode Normalization Forms y normalización preguntas más frecuentes sobre en el sitio Web Unicode.org.For more information about normalization and normalization forms, see System.Text.NormalizationForm, as well as Unicode Standard Annex #15: Unicode Normalization Forms and the Normalization FAQ on the unicode.org website.

Operaciones de cadenas por categoríaString operations by category

El String clase proporciona miembros para comparar cadenas, las pruebas de las cadenas de igualdad, búsqueda de subcadenas en una cadena, modificar una cadena, extraer subcadenas de una cadena, combinar cadenas, dar formato a valores, copiar una cadena, o caracteres y la normalización de una cadena.The String class provides members for comparing strings, testing strings for equality, finding characters or substrings in a string, modifying a string, extracting substrings from a string, combining strings, formatting values, copying a string, and normalizing a string.

Comparar cadenasComparing strings

Puede comparar cadenas para determinar su posición relativa en el criterio de ordenación mediante el siguiente String métodos:You can compare strings to determine their relative position in the sort order by using the following String methods:

  • Compare Devuelve un entero que indica la relación de una cadena en una segunda cadena en el criterio de ordenación.Compare returns an integer that indicates the relationship of one string to a second string in the sort order.

  • CompareOrdinal Devuelve un entero que indica la relación de una cadena en una segunda cadena que se basa en una comparación de sus puntos de código.CompareOrdinal returns an integer that indicates the relationship of one string to a second string based on a comparison of their code points.

  • CompareTo Devuelve un entero que indica la relación de la instancia de cadena actual con otra cadena en el criterio de ordenación.CompareTo returns an integer that indicates the relationship of the current string instance to a second string in the sort order. El CompareTo(String) método proporciona la IComparable y IComparable<T> implementaciones para el String clase.The CompareTo(String) method provides the IComparable and IComparable<T> implementations for the String class.

Cadenas de pruebas de igualdadTesting strings for equality

Se llama a la Equals método para determinar si dos cadenas son iguales.You call the Equals method to determine whether two strings are equal. La instancia Equals(String, String, StringComparison) y estático Equals(String, StringComparison) sobrecargas permiten especificar si la comparación es ordinal o de la referencia cultural, y si es considerar caso o a omitirse.The instance Equals(String, String, StringComparison) and the static Equals(String, StringComparison) overloads let you specify whether the comparison is culture-sensitive or ordinal, and whether case is considered or ignored. Mayoría de las pruebas de igualdad es ordinal y las comparaciones de igualdad que determinan el acceso a un recurso del sistema (por ejemplo, un objeto del sistema de archivos) siempre deben ser ordinales.Most tests for equality are ordinal, and comparisons for equality that determine access to a system resource (such as a file system object) should always be ordinal.

Buscar caracteres en una cadenaFinding characters in a string

La String clase incluye dos tipos de métodos de búsqueda:The String class includes two kinds of search methods:

Advertencia

Si desea buscar una cadena para un modelo concreto en lugar de una subcadena concreta, debe usar expresiones regulares.If you want to search a string for a particular pattern rather than a specific substring, you should use regular expressions. Para obtener más información, consulte expresiones regulares de .NET.For more information, see .NET Regular Expressions.

Modificación de una cadenaModifying a string

La String clase incluye los siguientes métodos que parecen modificar el valor de una cadena:The String class includes the following methods that appear to modify the value of a string:

  • Insert Inserta una cadena en el actual String instancia.Insert inserts a string into the current String instance.

  • PadLeft una o más apariciones de un carácter especificado se inserta al principio de una cadena.PadLeft inserts one or more occurrences of a specified character at the beginning of a string.

  • PadRight Inserta una o más apariciones de un carácter especificado al final de una cadena.PadRight inserts one or more occurrences of a specified character at the end of a string.

  • Remove elimina una subcadena de la actual String instancia.Remove deletes a substring from the current String instance.

  • Replace reemplaza una subcadena por otra subcadena actual String instancia.Replace replaces a substring with another substring in the current String instance.

  • ToLower y ToLowerInvariant convertir todos los caracteres de una cadena a minúsculas.ToLower and ToLowerInvariant convert all the characters in a string to lowercase.

  • ToUpper y ToUpperInvariant convertir todos los caracteres de una cadena a mayúsculas.ToUpper and ToUpperInvariant convert all the characters in a string to uppercase.

  • Trim Quita todas las apariciones de un carácter de principio y al final de una cadena.Trim removes all occurrences of a character from the beginning and end of a string.

  • TrimEnd Quita todas las apariciones de un carácter de final de una cadena.TrimEnd removes all occurrences of a character from the end of a string.

  • TrimStart Quita todas las apariciones de un carácter desde el principio de una cadena.TrimStart removes all occurrences of a character from the beginning of a string.

Importante

Todos los métodos de modificación de cadenas que devuelven un nuevo String objeto.All string modification methods return a new String object. No modifican el valor de la instancia actual.They don't modify the value of the current instance.

Extraer subcadenas de una cadenaExtracting substrings from a string

El String.Split método separa una cadena única en varias cadenas.The String.Split method separates a single string into multiple strings. Las sobrecargas del método le permiten especificar varios delimitadores, para determinar el número máximo de subcadenas que se extrae el método y para determinar si las cadenas vacías (que se producen cuando los delimitadores son adyacentes) se incluyen entre las cadenas devueltas.Overloads of the method allow you to specify multiple delimiters, to determine the maximum number of substrings that the method extracts, and to determine whether empty strings (which occur when delimiters are adjacent) are included among the returned strings.

Cadenas de combinaciónCombining strings

La siguiente String métodos se pueden usar para la concatenación de cadenas:The following String methods can be used for string concatenation:

  • Concat combina una o varias subcadenas en una sola cadena.Concat combines one or more substrings into a single string.

  • Join Concatena una o varias subcadenas en un solo elemento y agrega un separador entre cada subcadena.Join concatenates one or more substrings into a single element and adds a separator between each substring.

Dar formato a valoresFormatting values

El String.Format método usa la característica de formato compuesto para reemplazar uno o más marcadores de posición en una cadena con la representación de cadena de algún objeto o valor.The String.Format method uses the composite formatting feature to replace one or more placeholders in a string with the string representation of some object or value. El Format método se suele usar para hacer lo siguiente:The Format method is often used to do the following:

  • Para incrustar la representación de cadena de un valor numérico en una cadena.To embed the string representation of a numeric value in a string.

  • Para incrustar la representación de cadena de un valor de fecha y hora en una cadena.To embed the string representation of a date and time value in a string.

  • Para incrustar la representación de cadena de un valor de enumeración en una cadena.To embed the string representation of an enumeration value in a string.

  • Para incrustar la representación de cadena de un objeto que admite el IFormattable interfaz en una cadena.To embed the string representation of some object that supports the IFormattable interface in a string.

  • Justificar a la derecha o justificar a la izquierda una subcadena en un campo dentro de una cadena mayor.To right-justify or left-justify a substring in a field within a larger string.

Para obtener información detallada acerca del formato de las operaciones y ejemplos, vea el Format sobrecargar el resumen.For detailed information about formatting operations and examples, see the Format overload summary.

Copiar una cadenaCopying a string

Puede llamar a la siguiente String métodos para realizar una copia de una cadena:You can call the following String methods to make a copy of a string:

  • Clone Devuelve una referencia a una existente String objeto.Clone returns a reference to an existing String object.

  • Copy crea una copia de una cadena existente.Copy creates a copy of an existing string.

  • CopyTo copia una parte de una cadena en una matriz de caracteres.CopyTo copies a portion of a string to a character array.

La normalización de una cadenaNormalizing a string

En Unicode, un solo carácter puede tener varios puntos de código.In Unicode, a single character can have multiple code points. Normalización convierte estos caracteres equivalentes en la misma representación binaria.Normalization converts these equivalent characters into the same binary representation. El String.Normalize método realiza la normalización y el String.IsNormalized método determina si se normaliza una cadena.The String.Normalize method performs the normalization, and the String.IsNormalized method determines whether a string is normalized.

Para obtener más información y un ejemplo, vea el normalización anteriormente en este tema.For more information and an example, see the Normalization section earlier in this topic.

Constructors

String(Char*) String(Char*) String(Char*) String(Char*)

Inicializa una nueva instancia de la clase String con el valor indicado por un puntero especificado que apunta a una matriz de caracteres Unicode. Initializes a new instance of the String class to the value indicated by a specified pointer to an array of Unicode characters.

String(Char*, Int32, Int32) String(Char*, Int32, Int32) String(Char*, Int32, Int32) String(Char*, Int32, Int32)

Inicializa una nueva instancia de la clase String con el valor indicado por un puntero especificado que apunta a una matriz de caracteres Unicode, una posición de carácter inicial dentro de dicha matriz y una longitud. Initializes a new instance of the String class to the value indicated by a specified pointer to an array of Unicode characters, a starting character position within that array, and a length.

String(Char, Int32) String(Char, Int32) String(Char, Int32) String(Char, Int32)

Inicializa una nueva instancia de la clase String con el valor indicado por un carácter Unicode especificado que se repite un número de veces determinado. Initializes a new instance of the String class to the value indicated by a specified Unicode character repeated a specified number of times.

String(Char[]) String(Char[]) String(Char[]) String(Char[])

Inicializa una nueva instancia de la clase String en el valor indicado por una matriz de caracteres Unicode. Initializes a new instance of the String class to the value indicated by an array of Unicode characters.

String(Char[], Int32, Int32) String(Char[], Int32, Int32) String(Char[], Int32, Int32) String(Char[], Int32, Int32)

Inicializa una nueva instancia de la clase String con el valor indicado por una matriz de caracteres Unicode, una posición de carácter inicial dentro de dicha matriz y una longitud. Initializes a new instance of the String class to the value indicated by an array of Unicode characters, a starting character position within that array, and a length.

String(ReadOnlySpan<Char>) String(ReadOnlySpan<Char>) String(ReadOnlySpan<Char>) String(ReadOnlySpan<Char>)
String(SByte*) String(SByte*) String(SByte*) String(SByte*)

Inicializa una nueva instancia de la clase String con el valor indicado por un puntero a una matriz de enteros de 8 bits con signo. Initializes a new instance of the String class to the value indicated by a pointer to an array of 8-bit signed integers.

String(SByte*, Int32, Int32) String(SByte*, Int32, Int32) String(SByte*, Int32, Int32) String(SByte*, Int32, Int32)

Inicializa una nueva instancia de la clase String con el valor indicado por un puntero a una matriz de enteros de 8 bits con signo especificado, una posición inicial dentro de dicha matriz y una longitud. Initializes a new instance of the String class to the value indicated by a specified pointer to an array of 8-bit signed integers, a starting position within that array, and a length.

String(SByte*, Int32, Int32, Encoding) String(SByte*, Int32, Int32, Encoding) String(SByte*, Int32, Int32, Encoding) String(SByte*, Int32, Int32, Encoding)

Inicializa una nueva instancia de la clase String con el valor indicado por un puntero a una matriz de enteros de 8 bits con signo especificado, una posición inicial dentro de dicha matriz, una longitud y un objeto Encoding. Initializes a new instance of the String class to the value indicated by a specified pointer to an array of 8-bit signed integers, a starting position within that array, a length, and an Encoding object.

Fields

Empty Empty Empty Empty

Representa la cadena vacía. Represents the empty string. Este campo es de solo lectura. This field is read-only.

Properties

Chars[Int32] Chars[Int32] Chars[Int32] Chars[Int32]

Obtiene el objeto Char situado en una posición específica en el objeto String actual. Gets the Char object at a specified position in the current String object.

Length Length Length Length

Obtiene el número de caracteres del objeto String actual. Gets the number of characters in the current String object.

Methods

Clone() Clone() Clone() Clone()

Devuelve una referencia a la instancia de String. Returns a reference to this instance of String.

Compare(String, Int32, String, Int32, Int32) Compare(String, Int32, String, Int32, Int32) Compare(String, Int32, String, Int32, Int32) Compare(String, Int32, String, Int32, Int32)

Compara subcadenas de dos objetos String especificados y devuelve un entero que indica su posición relativa en el criterio de ordenación. Compares substrings of two specified String objects and returns an integer that indicates their relative position in the sort order.

Compare(String, Int32, String, Int32, Int32, Boolean) Compare(String, Int32, String, Int32, Int32, Boolean) Compare(String, Int32, String, Int32, Int32, Boolean) Compare(String, Int32, String, Int32, Int32, Boolean)

Compara las subcadenas de dos objetos String especificados, pasando por alto o teniendo en cuenta el uso de mayúsculas y minúsculas, y devuelve un entero que indica su posición relativa en el criterio de ordenación. Compares substrings of two specified String objects, ignoring or honoring their case, and returns an integer that indicates their relative position in the sort order.

Compare(String, Int32, String, Int32, Int32, Boolean, CultureInfo) Compare(String, Int32, String, Int32, Int32, Boolean, CultureInfo) Compare(String, Int32, String, Int32, Int32, Boolean, CultureInfo) Compare(String, Int32, String, Int32, Int32, Boolean, CultureInfo)

Compara las subcadenas de dos objetos String especificados, pasando por alto o teniendo en cuenta el uso de mayúsculas y minúsculas, usa información específica de la referencia cultural para influir en la comparación y devuelve un entero que indica su posición relativa en el criterio de ordenación. Compares substrings of two specified String objects, ignoring or honoring their case and using culture-specific information to influence the comparison, and returns an integer that indicates their relative position in the sort order.

Compare(String, Int32, String, Int32, Int32, CultureInfo, CompareOptions) Compare(String, Int32, String, Int32, Int32, CultureInfo, CompareOptions) Compare(String, Int32, String, Int32, Int32, CultureInfo, CompareOptions) Compare(String, Int32, String, Int32, Int32, CultureInfo, CompareOptions)

Compara las subcadenas de dos objetos String especificados usando las opciones de comparación especificadas e información específica de la referencia cultural para influir en la comparación y devuelve un entero que indica la relación mutua de las dos subcadenas en el criterio de ordenación. Compares substrings of two specified String objects using the specified comparison options and culture-specific information to influence the comparison, and returns an integer that indicates the relationship of the two substrings to each other in the sort order.

Compare(String, Int32, String, Int32, Int32, StringComparison) Compare(String, Int32, String, Int32, Int32, StringComparison) Compare(String, Int32, String, Int32, Int32, StringComparison) Compare(String, Int32, String, Int32, Int32, StringComparison)

Compara las subcadenas de dos objetos String especificados usando las reglas especificadas y devuelve un entero que indica su posición relativa en el criterio de ordenación. Compares substrings of two specified String objects using the specified rules, and returns an integer that indicates their relative position in the sort order.

Compare(String, String) Compare(String, String) Compare(String, String) Compare(String, String)

Compara dos objetos String especificados y devuelve un entero que indica su posición relativa en el criterio de ordenación. Compares two specified String objects and returns an integer that indicates their relative position in the sort order.

Compare(String, String, Boolean) Compare(String, String, Boolean) Compare(String, String, Boolean) Compare(String, String, Boolean)

Compara dos objetos String especificados, pasando por alto o teniendo en cuenta el uso de mayúsculas y minúsculas, y devuelve un entero que indica su posición relativa en el criterio de ordenación. Compares two specified String objects, ignoring or honoring their case, and returns an integer that indicates their relative position in the sort order.

Compare(String, String, Boolean, CultureInfo) Compare(String, String, Boolean, CultureInfo) Compare(String, String, Boolean, CultureInfo) Compare(String, String, Boolean, CultureInfo)

Compara dos objetos String especificados, pasando por alto o teniendo en cuenta el uso de mayúsculas y minúsculas, usa información específica de la referencia cultural para influir en la comparación y devuelve un entero que indica su posición relativa en el criterio de ordenación. Compares two specified String objects, ignoring or honoring their case, and using culture-specific information to influence the comparison, and returns an integer that indicates their relative position in the sort order.

Compare(String, String, CultureInfo, CompareOptions) Compare(String, String, CultureInfo, CompareOptions) Compare(String, String, CultureInfo, CompareOptions) Compare(String, String, CultureInfo, CompareOptions)

Compara dos objetos String especificados usando las opciones de comparación especificadas e información específica de la referencia cultural para influir en la comparación y devuelve un entero que indica la relación mutua de las dos cadenas en el criterio de ordenación. Compares two specified String objects using the specified comparison options and culture-specific information to influence the comparison, and returns an integer that indicates the relationship of the two strings to each other in the sort order.

Compare(String, String, StringComparison) Compare(String, String, StringComparison) Compare(String, String, StringComparison) Compare(String, String, StringComparison)

Compara dos objetos String especificados usando las reglas especificadas y devuelve un entero que indica su posición relativa en el criterio de ordenación. Compares two specified String objects using the specified rules, and returns an integer that indicates their relative position in the sort order.

CompareOrdinal(String, Int32, String, Int32, Int32) CompareOrdinal(String, Int32, String, Int32, Int32) CompareOrdinal(String, Int32, String, Int32, Int32) CompareOrdinal(String, Int32, String, Int32, Int32)

Compara las subcadenas de dos objetos String especificados mediante la evaluación de los valores numéricos de los correspondientes objetos Char en cada subcadena. Compares substrings of two specified String objects by evaluating the numeric values of the corresponding Char objects in each substring.

CompareOrdinal(String, String) CompareOrdinal(String, String) CompareOrdinal(String, String) CompareOrdinal(String, String)

Compara dos objetos String especificados mediante la evaluación de los valores numéricos de los objetos Char correspondientes de cada cadena. Compares two specified String objects by evaluating the numeric values of the corresponding Char objects in each string.

CompareTo(Object) CompareTo(Object) CompareTo(Object) CompareTo(Object)

Compara esta instancia con un Object especificado e indica si la posición de esta instancia es anterior, posterior o igual que la posición del Object especificado en el criterio de ordenación. Compares this instance with a specified Object and indicates whether this instance precedes, follows, or appears in the same position in the sort order as the specified Object.

CompareTo(String) CompareTo(String) CompareTo(String) CompareTo(String)

Compara esta instancia con un objeto String especificado e indica si la posición de esta instancia es anterior, posterior o igual que la posición de la cadena especificada en el criterio de ordenación. Compares this instance with a specified String object and indicates whether this instance precedes, follows, or appears in the same position in the sort order as the specified string.

Concat(IEnumerable<String>) Concat(IEnumerable<String>) Concat(IEnumerable<String>) Concat(IEnumerable<String>)

Concatena los miembros de una colección IEnumerable<T> construida de tipo String. Concatenates the members of a constructed IEnumerable<T> collection of type String.

Concat(Object) Concat(Object) Concat(Object) Concat(Object)

Crea la representación de cadena de un objeto especificado. Creates the string representation of a specified object.

Concat(Object, Object) Concat(Object, Object) Concat(Object, Object) Concat(Object, Object)

Concatena las representaciones de cadena de dos objetos especificados. Concatenates the string representations of two specified objects.

Concat(Object, Object, Object) Concat(Object, Object, Object) Concat(Object, Object, Object) Concat(Object, Object, Object)

Concatena las representaciones de cadena de tres objetos especificados. Concatenates the string representations of three specified objects.

Concat(Object, Object, Object, Object) Concat(Object, Object, Object, Object) Concat(Object, Object, Object, Object) Concat(Object, Object, Object, Object)

Concatena las representaciones de cadena de cuatro objetos especificados y cualquier otro objeto especificado en una lista opcional de parámetros de longitud variable. Concatenates the string representations of four specified objects and any objects specified in an optional variable length parameter list.

Concat(Object[]) Concat(Object[]) Concat(Object[]) Concat(Object[])

Concatena las representaciones de cadena de los elementos de una matriz Object especificada. Concatenates the string representations of the elements in a specified Object array.

Concat(String, String) Concat(String, String) Concat(String, String) Concat(String, String)

Concatena dos instancias de String especificadas. Concatenates two specified instances of String.

Concat(String, String, String) Concat(String, String, String) Concat(String, String, String) Concat(String, String, String)

Concatena tres instancias de String especificadas. Concatenates three specified instances of String.

Concat(String, String, String, String) Concat(String, String, String, String) Concat(String, String, String, String) Concat(String, String, String, String)

Concatena cuatro instancias de String especificadas. Concatenates four specified instances of String.

Concat(String[]) Concat(String[]) Concat(String[]) Concat(String[])

Concatena los elementos en una matriz String especificada. Concatenates the elements of a specified String array.

Concat<T>(IEnumerable<T>) Concat<T>(IEnumerable<T>) Concat<T>(IEnumerable<T>) Concat<T>(IEnumerable<T>)

Concatena los miembros de una implementación de IEnumerable<T>. Concatenates the members of an IEnumerable<T> implementation.

Contains(Char) Contains(Char) Contains(Char) Contains(Char)
Contains(Char, StringComparison) Contains(Char, StringComparison) Contains(Char, StringComparison) Contains(Char, StringComparison)
Contains(String) Contains(String) Contains(String) Contains(String)

Devuelve un valor que indica si una subcadena especificada aparece dentro de esta cadena. Returns a value indicating whether a specified substring occurs within this string.

Contains(String, StringComparison) Contains(String, StringComparison) Contains(String, StringComparison) Contains(String, StringComparison)
Copy(String) Copy(String) Copy(String) Copy(String)

Crea una nueva instancia de String con el mismo valor que una String especificada. Creates a new instance of String with the same value as a specified String.

CopyTo(Int32, Char[], Int32, Int32) CopyTo(Int32, Char[], Int32, Int32) CopyTo(Int32, Char[], Int32, Int32) CopyTo(Int32, Char[], Int32, Int32)

Copia un número especificado de caracteres situados en una posición especificada de la instancia en una posición determinada de una matriz de caracteres Unicode. Copies a specified number of characters from a specified position in this instance to a specified position in an array of Unicode characters.

Create<TState>(Int32, TState, SpanAction<Char,TState>) Create<TState>(Int32, TState, SpanAction<Char,TState>) Create<TState>(Int32, TState, SpanAction<Char,TState>) Create<TState>(Int32, TState, SpanAction<Char,TState>)
EndsWith(Char) EndsWith(Char) EndsWith(Char) EndsWith(Char)
EndsWith(String) EndsWith(String) EndsWith(String) EndsWith(String)

Determina si el final de esta instancia de cadena coincide con la cadena especificada. Determines whether the end of this string instance matches the specified string.

EndsWith(String, Boolean, CultureInfo) EndsWith(String, Boolean, CultureInfo) EndsWith(String, Boolean, CultureInfo) EndsWith(String, Boolean, CultureInfo)

Determina si el final de esta instancia de cadena coincide con la cadena especificada cuando se comparan usando la referencia cultural especificada. Determines whether the end of this string instance matches the specified string when compared using the specified culture.

EndsWith(String, StringComparison) EndsWith(String, StringComparison) EndsWith(String, StringComparison) EndsWith(String, StringComparison)

Determina si el final de esta instancia de cadena coincide con la cadena especificada cuando se comparan usando la opción de comparación especificada. Determines whether the end of this string instance matches the specified string when compared using the specified comparison option.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Determina si esta instancia y un objeto especificado, que también debe ser un objeto String, tienen el mismo valor. Determines whether this instance and a specified object, which must also be a String object, have the same value.

Equals(String) Equals(String) Equals(String) Equals(String)

Determina si esta instancia y otro objeto String especificado tienen el mismo valor. Determines whether this instance and another specified String object have the same value.

Equals(String, String) Equals(String, String) Equals(String, String) Equals(String, String)

Determina si dos objetos String especificados tienen el mismo valor. Determines whether two specified String objects have the same value.

Equals(String, String, StringComparison) Equals(String, String, StringComparison) Equals(String, String, StringComparison) Equals(String, String, StringComparison)

Determina si dos objetos String especificados tienen el mismo valor. Determines whether two specified String objects have the same value. Un parámetro especifica la referencia cultural, el uso de mayúsculas y minúsculas, así como las reglas de ordenación usadas en la comparación. A parameter specifies the culture, case, and sort rules used in the comparison.

Equals(String, StringComparison) Equals(String, StringComparison) Equals(String, StringComparison) Equals(String, StringComparison)

Determina si esta cadena y un objeto String especificado tienen el mismo valor. Determines whether this string and a specified String object have the same value. Un parámetro especifica la referencia cultural, el uso de mayúsculas y minúsculas, así como las reglas de ordenación usadas en la comparación. A parameter specifies the culture, case, and sort rules used in the comparison.

Format(IFormatProvider, String, Object) Format(IFormatProvider, String, Object) Format(IFormatProvider, String, Object) Format(IFormatProvider, String, Object)

Sustituye el elemento o elementos de formato en una cadena específica con la representación de cadena del objeto correspondiente. Replaces the format item or items in a specified string with the string representation of the corresponding object. Un parámetro proporciona información de formato específica de la referencia cultural. A parameter supplies culture-specific formatting information.

Format(IFormatProvider, String, Object, Object) Format(IFormatProvider, String, Object, Object) Format(IFormatProvider, String, Object, Object) Format(IFormatProvider, String, Object, Object)

Reemplaza los elementos de formato de una cadena por la representación de cadena de dos objetos especificados. Replaces the format items in a string with the string representation of two specified objects. Un parámetro proporciona información de formato específica de la referencia cultural. A parameter supplies culture-specific formatting information.

Format(IFormatProvider, String, Object, Object, Object) Format(IFormatProvider, String, Object, Object, Object) Format(IFormatProvider, String, Object, Object, Object) Format(IFormatProvider, String, Object, Object, Object)

Reemplaza los elementos de formato de una cadena por la representación de cadena de tres objetos especificados. Replaces the format items in a string with the string representation of three specified objects. Un parámetro proporciona información de formato específica de la referencia cultural. An parameter supplies culture-specific formatting information.

Format(IFormatProvider, String, Object[]) Format(IFormatProvider, String, Object[]) Format(IFormatProvider, String, Object[]) Format(IFormatProvider, String, Object[])

Reemplaza los elementos de formato de una cadena por las representaciones de cadena de los objetos correspondientes en una matriz especificada. Replaces the format items in a string with the string representations of corresponding objects in a specified array. Un parámetro proporciona información de formato específica de la referencia cultural. A parameter supplies culture-specific formatting information.

Format(String, Object) Format(String, Object) Format(String, Object) Format(String, Object)

Reemplaza uno o más elementos de formato de una cadena por la representación de cadena de un objeto especificado. Replaces one or more format items in a string with the string representation of a specified object.

Format(String, Object, Object) Format(String, Object, Object) Format(String, Object, Object) Format(String, Object, Object)

Reemplaza los elementos de formato de una cadena por la representación de cadena de dos objetos especificados. Replaces the format items in a string with the string representation of two specified objects.

Format(String, Object, Object, Object) Format(String, Object, Object, Object) Format(String, Object, Object, Object) Format(String, Object, Object, Object)

Reemplaza los elementos de formato de una cadena por la representación de cadena de tres objetos especificados. Replaces the format items in a string with the string representation of three specified objects.

Format(String, Object[]) Format(String, Object[]) Format(String, Object[]) Format(String, Object[])

Reemplaza el elemento de formato de una cadena especificada por la representación de cadena de un objeto correspondiente de una matriz especificada. Replaces the format item in a specified string with the string representation of a corresponding object in a specified array.

GetEnumerator() GetEnumerator() GetEnumerator() GetEnumerator()

Recupera un objeto que puede recorrer en iteración los caracteres individuales de esta cadena. Retrieves an object that can iterate through the individual characters in this string.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Devuelve el código hash para esta cadena. Returns the hash code for this string.

GetHashCode(StringComparison) GetHashCode(StringComparison) GetHashCode(StringComparison) GetHashCode(StringComparison)
GetType() GetType() GetType() GetType()

Obtiene el Type de la instancia actual. Gets the Type of the current instance.

(Inherited from Object)
GetTypeCode() GetTypeCode() GetTypeCode() GetTypeCode()

Devuelve la interfaz TypeCode para la clase String. Returns the TypeCode for class String.

IndexOf(Char) IndexOf(Char) IndexOf(Char) IndexOf(Char)

Devuelve el índice de base cero de la primera aparición del carácter Unicode especificado en esta cadena. Reports the zero-based index of the first occurrence of the specified Unicode character in this string.

IndexOf(Char, Int32) IndexOf(Char, Int32) IndexOf(Char, Int32) IndexOf(Char, Int32)

Devuelve el índice de base cero de la primera aparición del carácter Unicode especificado en esta cadena. Reports the zero-based index of the first occurrence of the specified Unicode character in this string. La búsqueda comienza en una posición de carácter especificada. The search starts at a specified character position.

IndexOf(Char, Int32, Int32) IndexOf(Char, Int32, Int32) IndexOf(Char, Int32, Int32) IndexOf(Char, Int32, Int32)

Devuelve el índice de base en cero de la primera aparición del carácter especificado en la instancia en cuestión. Reports the zero-based index of the first occurrence of the specified character in this instance. La búsqueda comienza en una posición de carácter especificada y examina un número especificado de posiciones de caracteres. The search starts at a specified character position and examines a specified number of character positions.

IndexOf(Char, StringComparison) IndexOf(Char, StringComparison) IndexOf(Char, StringComparison) IndexOf(Char, StringComparison)
IndexOf(String) IndexOf(String) IndexOf(String) IndexOf(String)

Indica el índice de base cero de la primera aparición de la cadena especificada en la instancia en cuestión. Reports the zero-based index of the first occurrence of the specified string in this instance.

IndexOf(String, Int32) IndexOf(String, Int32) IndexOf(String, Int32) IndexOf(String, Int32)

Indica el índice de base cero de la primera aparición de la cadena especificada en la instancia en cuestión. Reports the zero-based index of the first occurrence of the specified string in this instance. La búsqueda comienza en una posición de carácter especificada. The search starts at a specified character position.

IndexOf(String, Int32, Int32) IndexOf(String, Int32, Int32) IndexOf(String, Int32, Int32) IndexOf(String, Int32, Int32)

Indica el índice de base cero de la primera aparición de la cadena especificada en la instancia en cuestión. Reports the zero-based index of the first occurrence of the specified string in this instance. La búsqueda comienza en una posición de carácter especificada y examina un número especificado de posiciones de caracteres. The search starts at a specified character position and examines a specified number of character positions.

IndexOf(String, Int32, Int32, StringComparison) IndexOf(String, Int32, Int32, StringComparison) IndexOf(String, Int32, Int32, StringComparison) IndexOf(String, Int32, Int32, StringComparison)

Devuelve el índice de base cero de la primera aparición de la cadena especificada en el objeto String actual. Reports the zero-based index of the first occurrence of the specified string in the current String object. Los parámetros indican la posición inicial de búsqueda en la cadena actual, el número de caracteres de la cadena actual en los que buscar y el tipo de búsqueda que se va a usar para la cadena especificada. Parameters specify the starting search position in the current string, the number of characters in the current string to search, and the type of search to use for the specified string.

IndexOf(String, Int32, StringComparison) IndexOf(String, Int32, StringComparison) IndexOf(String, Int32, StringComparison) IndexOf(String, Int32, StringComparison)

Devuelve el índice de base cero de la primera aparición de la cadena especificada en el objeto String actual. Reports the zero-based index of the first occurrence of the specified string in the current String object. Los parámetros indican la posición inicial de búsqueda en la cadena actual y el tipo de búsqueda que se usa para la cadena especificada. Parameters specify the starting search position in the current string and the type of search to use for the specified string.

IndexOf(String, StringComparison) IndexOf(String, StringComparison) IndexOf(String, StringComparison) IndexOf(String, StringComparison)

Devuelve el índice de base cero de la primera aparición de la cadena especificada en el objeto String actual. Reports the zero-based index of the first occurrence of the specified string in the current String object. Un parámetro especifica el tipo de búsqueda que se va a usar para la cadena especificada. A parameter specifies the type of search to use for the specified string.

IndexOfAny(Char[]) IndexOfAny(Char[]) IndexOfAny(Char[]) IndexOfAny(Char[])

Devuelve el índice de base cero de la primera aparición en la instancia de un carácter de una matriz de caracteres Unicode especificada. Reports the zero-based index of the first occurrence in this instance of any character in a specified array of Unicode characters.

IndexOfAny(Char[], Int32) IndexOfAny(Char[], Int32) IndexOfAny(Char[], Int32) IndexOfAny(Char[], Int32)

Devuelve el índice de base cero de la primera aparición en la instancia de un carácter de una matriz de caracteres Unicode especificada. Reports the zero-based index of the first occurrence in this instance of any character in a specified array of Unicode characters. La búsqueda comienza en una posición de carácter especificada. The search starts at a specified character position.

IndexOfAny(Char[], Int32, Int32) IndexOfAny(Char[], Int32, Int32) IndexOfAny(Char[], Int32, Int32) IndexOfAny(Char[], Int32, Int32)

Devuelve el índice de base cero de la primera aparición en la instancia de un carácter de una matriz de caracteres Unicode especificada. Reports the zero-based index of the first occurrence in this instance of any character in a specified array of Unicode characters. La búsqueda comienza en una posición de carácter especificada y examina un número especificado de posiciones de caracteres. The search starts at a specified character position and examines a specified number of character positions.

Insert(Int32, String) Insert(Int32, String) Insert(Int32, String) Insert(Int32, String)

Devuelve una nueva cadena en la que se inserta una cadena especificada en una posición de índice concreta en esta instancia. Returns a new string in which a specified string is inserted at a specified index position in this instance.

Intern(String) Intern(String) Intern(String) Intern(String)

Recupera la referencia del sistema al objeto String especificado. Retrieves the system's reference to the specified String.

IsInterned(String) IsInterned(String) IsInterned(String) IsInterned(String)

Recupera una referencia a un objeto String especificado. Retrieves a reference to a specified String.

IsNormalized() IsNormalized() IsNormalized() IsNormalized()

Indica si esta cadena tiene la forma de normalización Unicode C. Indicates whether this string is in Unicode normalization form C.

IsNormalized(NormalizationForm) IsNormalized(NormalizationForm) IsNormalized(NormalizationForm) IsNormalized(NormalizationForm)

Indica si esta cadena tiene la forma de normalización Unicode especificada. Indicates whether this string is in the specified Unicode normalization form.

IsNullOrEmpty(String) IsNullOrEmpty(String) IsNullOrEmpty(String) IsNullOrEmpty(String)

Indica si el valor de la cadena especificada es null o una cadena de Empty. Indicates whether the specified string is null or an Empty string.

IsNullOrWhiteSpace(String) IsNullOrWhiteSpace(String) IsNullOrWhiteSpace(String) IsNullOrWhiteSpace(String)

Indica si la cadena especificada es null, está vacía o consta únicamente de caracteres de espacio en blanco. Indicates whether a specified string is null, empty, or consists only of white-space characters.

Join(Char, Object[]) Join(Char, Object[]) Join(Char, Object[]) Join(Char, Object[])
Join(Char, String[]) Join(Char, String[]) Join(Char, String[]) Join(Char, String[])
Join(Char, String[], Int32, Int32) Join(Char, String[], Int32, Int32) Join(Char, String[], Int32, Int32) Join(Char, String[], Int32, Int32)
Join(String, IEnumerable<String>) Join(String, IEnumerable<String>) Join(String, IEnumerable<String>) Join(String, IEnumerable<String>)

Concatena los miembros de una colección IEnumerable<T> construida de tipo String, usando el separador especificado entre todos los miembros. Concatenates the members of a constructed IEnumerable<T> collection of type String, using the specified separator between each member.

Join(String, Object[]) Join(String, Object[]) Join(String, Object[]) Join(String, Object[])

Concatena los elementos de una matriz de objetos, usando el separador especificado entre todos los elementos. Concatenates the elements of an object array, using the specified separator between each element.

Join(String, String[]) Join(String, String[]) Join(String, String[]) Join(String, String[])

Concatena todos los elementos de una matriz de cadenas, usando el separador especificado entre todos los elementos. Concatenates all the elements of a string array, using the specified separator between each element.

Join(String, String[], Int32, Int32) Join(String, String[], Int32, Int32) Join(String, String[], Int32, Int32) Join(String, String[], Int32, Int32)

Concatena los elementos especificados de una matriz de cadenas, usando el separador indicado entre todos los elementos. Concatenates the specified elements of a string array, using the specified separator between each element.

Join<T>(Char, IEnumerable<T>) Join<T>(Char, IEnumerable<T>) Join<T>(Char, IEnumerable<T>) Join<T>(Char, IEnumerable<T>)
Join<T>(String, IEnumerable<T>) Join<T>(String, IEnumerable<T>) Join<T>(String, IEnumerable<T>) Join<T>(String, IEnumerable<T>)

Concatena los miembros de una colección, usando el separador especificado entre todos los miembros. Concatenates the members of a collection, using the specified separator between each member.

LastIndexOf(Char) LastIndexOf(Char) LastIndexOf(Char) LastIndexOf(Char)

Devuelve la posición de índice de base cero de la última aparición de un carácter Unicode especificado en la instancia. Reports the zero-based index position of the last occurrence of a specified Unicode character within this instance.

LastIndexOf(Char, Int32) LastIndexOf(Char, Int32) LastIndexOf(Char, Int32) LastIndexOf(Char, Int32)

Devuelve la posición de índice de base cero de la última aparición de un carácter Unicode especificado en la instancia. Reports the zero-based index position of the last occurrence of a specified Unicode character within this instance. La búsqueda se inicia en una posición de carácter especificada y continúa hacia atrás hacia el principio de la cadena. The search starts at a specified character position and proceeds backward toward the beginning of the string.

LastIndexOf(Char, Int32, Int32) LastIndexOf(Char, Int32, Int32) LastIndexOf(Char, Int32, Int32) LastIndexOf(Char, Int32, Int32)

Devuelve la posición de índice de base cero de la última aparición del carácter Unicode especificado en una subcadena de la instancia. Reports the zero-based index position of the last occurrence of the specified Unicode character in a substring within this instance. La búsqueda se inicia en una posición de caracteres especificada y continúa hacia atrás hacia el principio de la cadena durante un número especificado de posiciones de caracteres. The search starts at a specified character position and proceeds backward toward the beginning of the string for a specified number of character positions.

LastIndexOf(String) LastIndexOf(String) LastIndexOf(String) LastIndexOf(String)

Indica la posición de índice de base cero de la última aparición de una cadena especificada en la instancia en cuestión. Reports the zero-based index position of the last occurrence of a specified string within this instance.

LastIndexOf(String, Int32) LastIndexOf(String, Int32) LastIndexOf(String, Int32) LastIndexOf(String, Int32)

Indica la posición de índice de base cero de la última aparición de una cadena especificada en la instancia en cuestión. Reports the zero-based index position of the last occurrence of a specified string within this instance. La búsqueda se inicia en una posición de carácter especificada y continúa hacia atrás hacia el principio de la cadena. The search starts at a specified character position and proceeds backward toward the beginning of the string.

LastIndexOf(String, Int32, Int32) LastIndexOf(String, Int32, Int32) LastIndexOf(String, Int32, Int32) LastIndexOf(String, Int32, Int32)

Indica la posición de índice de base cero de la última aparición de una cadena especificada en la instancia en cuestión. Reports the zero-based index position of the last occurrence of a specified string within this instance. La búsqueda se inicia en una posición de caracteres especificada y continúa hacia atrás hacia el principio de la cadena durante un número especificado de posiciones de caracteres. The search starts at a specified character position and proceeds backward toward the beginning of the string for a specified number of character positions.

LastIndexOf(String, Int32, Int32, StringComparison) LastIndexOf(String, Int32, Int32, StringComparison) LastIndexOf(String, Int32, Int32, StringComparison) LastIndexOf(String, Int32, Int32, StringComparison)

Indica la posición de índice de base cero de la última aparición de una cadena especificada en la instancia en cuestión. Reports the zero-based index position of the last occurrence of a specified string within this instance. La búsqueda se inicia en una posición de caracteres especificada y continúa hacia atrás hacia el principio de la cadena durante el número especificado de posiciones de caracteres. The search starts at a specified character position and proceeds backward toward the beginning of the string for the specified number of character positions. Un parámetro especifica el tipo de comparación que se debe realizar cuando se busca la cadena especificada. A parameter specifies the type of comparison to perform when searching for the specified string.

LastIndexOf(String, Int32, StringComparison) LastIndexOf(String, Int32, StringComparison) LastIndexOf(String, Int32, StringComparison) LastIndexOf(String, Int32, StringComparison)

Devuelve el índice de base cero de la última aparición de una cadena especificada dentro del objeto String actual. Reports the zero-based index of the last occurrence of a specified string within the current String object. La búsqueda se inicia en una posición de carácter especificada y continúa hacia atrás hacia el principio de la cadena. The search starts at a specified character position and proceeds backward toward the beginning of the string. Un parámetro especifica el tipo de comparación que se debe realizar cuando se busca la cadena especificada. A parameter specifies the type of comparison to perform when searching for the specified string.

LastIndexOf(String, StringComparison) LastIndexOf(String, StringComparison) LastIndexOf(String, StringComparison) LastIndexOf(String, StringComparison)

Devuelve el índice de base cero de la última aparición de una cadena especificada dentro del objeto String actual. Reports the zero-based index of the last occurrence of a specified string within the current String object. Un parámetro especifica el tipo de búsqueda que se va a usar para la cadena especificada. A parameter specifies the type of search to use for the specified string.

LastIndexOfAny(Char[]) LastIndexOfAny(Char[]) LastIndexOfAny(Char[]) LastIndexOfAny(Char[])

Devuelve la posición de índice de base cero de la última aparición en la instancia de uno o varios caracteres especificados de una matriz de caracteres Unicode. Reports the zero-based index position of the last occurrence in this instance of one or more characters specified in a Unicode array.

LastIndexOfAny(Char[], Int32) LastIndexOfAny(Char[], Int32) LastIndexOfAny(Char[], Int32) LastIndexOfAny(Char[], Int32)

Devuelve la posición de índice de base cero de la última aparición en la instancia de uno o varios caracteres especificados de una matriz de caracteres Unicode. Reports the zero-based index position of the last occurrence in this instance of one or more characters specified in a Unicode array. La búsqueda se inicia en una posición de carácter especificada y continúa hacia atrás hacia el principio de la cadena. The search starts at a specified character position and proceeds backward toward the beginning of the string.

LastIndexOfAny(Char[], Int32, Int32) LastIndexOfAny(Char[], Int32, Int32) LastIndexOfAny(Char[], Int32, Int32) LastIndexOfAny(Char[], Int32, Int32)

Devuelve la posición de índice de base cero de la última aparición en la instancia de uno o varios caracteres especificados de una matriz de caracteres Unicode. Reports the zero-based index position of the last occurrence in this instance of one or more characters specified in a Unicode array. La búsqueda se inicia en una posición de caracteres especificada y continúa hacia atrás hacia el principio de la cadena durante un número especificado de posiciones de caracteres. The search starts at a specified character position and proceeds backward toward the beginning of the string for a specified number of character positions.

MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Crea una copia superficial del Object actual. Creates a shallow copy of the current Object.

(Inherited from Object)
Normalize() Normalize() Normalize() Normalize()

Devuelve una nueva cadena cuyo valor textual es igual que esta cadena, pero cuya representación binaria tiene la forma de normalización Unicode C. Returns a new string whose textual value is the same as this string, but whose binary representation is in Unicode normalization form C.

Normalize(NormalizationForm) Normalize(NormalizationForm) Normalize(NormalizationForm) Normalize(NormalizationForm)

Devuelve una nueva cadena cuyo valor textual es igual que esta cadena, pero cuya representación binaria tiene la forma de normalización Unicode especificada. Returns a new string whose textual value is the same as this string, but whose binary representation is in the specified Unicode normalization form.

PadLeft(Int32) PadLeft(Int32) PadLeft(Int32) PadLeft(Int32)

Devuelve una nueva cadena que alinea a la derecha los caracteres de la instancia e inserta espacios en blanco a la izquierda hasta alcanzar la longitud total especificada. Returns a new string that right-aligns the characters in this instance by padding them with spaces on the left, for a specified total length.

PadLeft(Int32, Char) PadLeft(Int32, Char) PadLeft(Int32, Char) PadLeft(Int32, Char)

Devuelve una nueva cadena que alinea a la derecha los caracteres de la instancia e inserta a la izquierda un carácter Unicode especificado hasta alcanzar la longitud total especificada. Returns a new string that right-aligns the characters in this instance by padding them on the left with a specified Unicode character, for a specified total length.

PadRight(Int32) PadRight(Int32) PadRight(Int32) PadRight(Int32)

Devuelve una nueva cadena que alinea a la izquierda los caracteres de la cadena e inserta espacios en blanco a la derecha hasta alcanzar la longitud total especificada. Returns a new string that left-aligns the characters in this string by padding them with spaces on the right, for a specified total length.

PadRight(Int32, Char) PadRight(Int32, Char) PadRight(Int32, Char) PadRight(Int32, Char)

Devuelve una nueva cadena que alinea a la izquierda los caracteres de la cadena e inserta a la derecha un carácter Unicode especificado hasta alcanzar la longitud total especificada. Returns a new string that left-aligns the characters in this string by padding them on the right with a specified Unicode character, for a specified total length.

Remove(Int32) Remove(Int32) Remove(Int32) Remove(Int32)

Devuelve una nueva cadena en la que se han eliminado todos los caracteres de la instancia actual, a partir de una posición especificada y hasta la última posición. Returns a new string in which all the characters in the current instance, beginning at a specified position and continuing through the last position, have been deleted.

Remove(Int32, Int32) Remove(Int32, Int32) Remove(Int32, Int32) Remove(Int32, Int32)

Devuelve una nueva cadena en la que se ha eliminado un número de caracteres especificado en la instancia actual a partir de una posición especificada. Returns a new string in which a specified number of characters in the current instance beginning at a specified position have been deleted.

Replace(Char, Char) Replace(Char, Char) Replace(Char, Char) Replace(Char, Char)

Devuelve una nueva cadena en la que todas las apariciones de un carácter Unicode especificado de esta instancia se reemplazan por otro carácter Unicode especificado. Returns a new string in which all occurrences of a specified Unicode character in this instance are replaced with another specified Unicode character.

Replace(String, String) Replace(String, String) Replace(String, String) Replace(String, String)

Devuelve una nueva cadena en la que todas las apariciones de una cadena especificada en la instancia actual se reemplazan por otra cadena especificada. Returns a new string in which all occurrences of a specified string in the current instance are replaced with another specified string.

Replace(String, String, Boolean, CultureInfo) Replace(String, String, Boolean, CultureInfo) Replace(String, String, Boolean, CultureInfo) Replace(String, String, Boolean, CultureInfo)
Replace(String, String, StringComparison) Replace(String, String, StringComparison) Replace(String, String, StringComparison) Replace(String, String, StringComparison)
Split(Char, Int32, StringSplitOptions) Split(Char, Int32, StringSplitOptions) Split(Char, Int32, StringSplitOptions) Split(Char, Int32, StringSplitOptions)
Split(Char, StringSplitOptions) Split(Char, StringSplitOptions) Split(Char, StringSplitOptions) Split(Char, StringSplitOptions)
Split(Char[]) Split(Char[]) Split(Char[]) Split(Char[])

Divide una cadena en subcadenas basadas en los caracteres de una matriz. Splits a string into substrings that are based on the characters in an array.

Split(Char[], Int32) Split(Char[], Int32) Split(Char[], Int32) Split(Char[], Int32)

Divide una cadena en un número máximo de subcadenas en función de los caracteres de una matriz. Splits a string into a maximum number of substrings based on the characters in an array. Número máximo de subcadenas que se va devolver. You also specify the maximum number of substrings to return.

Split(Char[], Int32, StringSplitOptions) Split(Char[], Int32, StringSplitOptions) Split(Char[], Int32, StringSplitOptions) Split(Char[], Int32, StringSplitOptions)

Divide una cadena en un número máximo de subcadenas en función de los caracteres de una matriz. Splits a string into a maximum number of substrings based on the characters in an array.

Split(Char[], StringSplitOptions) Split(Char[], StringSplitOptions) Split(Char[], StringSplitOptions) Split(Char[], StringSplitOptions)

Divide una cadena en subcadenas en función de los caracteres de una matriz. Splits a string into substrings based on the characters in an array. Puede especificar si las subcadenas incluyen elementos de matriz vacíos. You can specify whether the substrings include empty array elements.

Split(String, Int32, StringSplitOptions) Split(String, Int32, StringSplitOptions) Split(String, Int32, StringSplitOptions) Split(String, Int32, StringSplitOptions)
Split(String, StringSplitOptions) Split(String, StringSplitOptions) Split(String, StringSplitOptions) Split(String, StringSplitOptions)
Split(String[], Int32, StringSplitOptions) Split(String[], Int32, StringSplitOptions) Split(String[], Int32, StringSplitOptions) Split(String[], Int32, StringSplitOptions)

Divide una cadena en un número máximo de subcadenas en función de las cadenas de una matriz. Splits a string into a maximum number of substrings based on the strings in an array. Puede especificar si las subcadenas incluyen elementos de matriz vacíos. You can specify whether the substrings include empty array elements.

Split(String[], StringSplitOptions) Split(String[], StringSplitOptions) Split(String[], StringSplitOptions) Split(String[], StringSplitOptions)

Divide una cadena en subcadenas en función de las cadenas de una matriz. Splits a string into substrings based on the strings in an array. Puede especificar si las subcadenas incluyen elementos de matriz vacíos. You can specify whether the substrings include empty array elements.

StartsWith(Char) StartsWith(Char) StartsWith(Char) StartsWith(Char)
StartsWith(String) StartsWith(String) StartsWith(String) StartsWith(String)

Determina si el principio de esta instancia de cadena coincide con la cadena especificada. Determines whether the beginning of this string instance matches the specified string.

StartsWith(String, Boolean, CultureInfo) StartsWith(String, Boolean, CultureInfo) StartsWith(String, Boolean, CultureInfo) StartsWith(String, Boolean, CultureInfo)

Determina si el principio de esta instancia de cadena coincide con la cadena especificada cuando se comparan usando la referencia cultural especificada. Determines whether the beginning of this string instance matches the specified string when compared using the specified culture.

StartsWith(String, StringComparison) StartsWith(String, StringComparison) StartsWith(String, StringComparison) StartsWith(String, StringComparison)

Determina si el principio de esta instancia de cadena coincide con la cadena especificada cuando se comparan usando la opción de comparación especificada. Determines whether the beginning of this string instance matches the specified string when compared using the specified comparison option.

Substring(Int32) Substring(Int32) Substring(Int32) Substring(Int32)

Recupera una subcadena de la instancia. Retrieves a substring from this instance. La subcadena empieza en una posición de caracteres especificada y continúa hasta el final de la cadena. The substring starts at a specified character position and continues to the end of the string.

Substring(Int32, Int32) Substring(Int32, Int32) Substring(Int32, Int32) Substring(Int32, Int32)

Recupera una subcadena de la instancia. Retrieves a substring from this instance. La subcadena comienza en una posición de carácter especificada y tiene una longitud especificada. The substring starts at a specified character position and has a specified length.

ToCharArray() ToCharArray() ToCharArray() ToCharArray()

Copia los caracteres de la instancia en una matriz de caracteres Unicode. Copies the characters in this instance to a Unicode character array.

ToCharArray(Int32, Int32) ToCharArray(Int32, Int32) ToCharArray(Int32, Int32) ToCharArray(Int32, Int32)

Copia los caracteres de una subcadena especificada de la instancia en una matriz de caracteres Unicode. Copies the characters in a specified substring in this instance to a Unicode character array.

ToLower() ToLower() ToLower() ToLower()

Devuelve una copia de esta cadena convertida en minúsculas. Returns a copy of this string converted to lowercase.

ToLower(CultureInfo) ToLower(CultureInfo) ToLower(CultureInfo) ToLower(CultureInfo)

Devuelve una copia de esta cadena convertida en minúsculas, aplicando las reglas de mayúsculas y minúsculas de la referencia cultural especificada. Returns a copy of this string converted to lowercase, using the casing rules of the specified culture.

ToLowerInvariant() ToLowerInvariant() ToLowerInvariant() ToLowerInvariant()

Devuelve una copia de este objeto String convertido en minúsculas, aplicando las reglas de mayúsculas y minúsculas de la referencia cultural de todos los idiomas. Returns a copy of this String object converted to lowercase using the casing rules of the invariant culture.

ToString() ToString() ToString() ToString()

Devuelve la instancia de String; no se efectúa una conversión real. Returns this instance of String; no actual conversion is performed.

ToString(IFormatProvider) ToString(IFormatProvider) ToString(IFormatProvider) ToString(IFormatProvider)

Devuelve la instancia de String; no se efectúa una conversión real. Returns this instance of String; no actual conversion is performed.

ToUpper() ToUpper() ToUpper() ToUpper()

Devuelve una copia de esta cadena convertida en mayúsculas. Returns a copy of this string converted to uppercase.

ToUpper(CultureInfo) ToUpper(CultureInfo) ToUpper(CultureInfo) ToUpper(CultureInfo)

Devuelve una copia de esta cadena convertida en mayúsculas, aplicando las reglas de mayúsculas y minúsculas de la referencia cultural especificada. Returns a copy of this string converted to uppercase, using the casing rules of the specified culture.

ToUpperInvariant() ToUpperInvariant() ToUpperInvariant() ToUpperInvariant()

Devuelve una copia de este objeto String convertido en mayúsculas, aplicando las reglas de mayúsculas y minúsculas de la referencia cultural de todos los idiomas. Returns a copy of this String object converted to uppercase using the casing rules of the invariant culture.

Trim() Trim() Trim() Trim()

Quita todos los caracteres de espacio en blanco del principio y el final del objeto String actual. Removes all leading and trailing white-space characters from the current String object.

Trim(Char) Trim(Char) Trim(Char) Trim(Char)
Trim(Char[]) Trim(Char[]) Trim(Char[]) Trim(Char[])

Quita todas las apariciones del principio y el final de un conjunto de caracteres especificados en una matriz del objeto String actual. Removes all leading and trailing occurrences of a set of characters specified in an array from the current String object.

TrimEnd() TrimEnd() TrimEnd() TrimEnd()
TrimEnd(Char) TrimEnd(Char) TrimEnd(Char) TrimEnd(Char)
TrimEnd(Char[]) TrimEnd(Char[]) TrimEnd(Char[]) TrimEnd(Char[])

Quita todas las apariciones del final de un conjunto de caracteres especificados en una matriz del objeto String actual. Removes all trailing occurrences of a set of characters specified in an array from the current String object.

TrimStart() TrimStart() TrimStart() TrimStart()
TrimStart(Char) TrimStart(Char) TrimStart(Char) TrimStart(Char)
TrimStart(Char[]) TrimStart(Char[]) TrimStart(Char[]) TrimStart(Char[])

Quita todas las apariciones del principio de un conjunto de caracteres especificados en una matriz del objeto String actual. Removes all leading occurrences of a set of characters specified in an array from the current String object.

Operators

Equality(String, String) Equality(String, String) Equality(String, String) Equality(String, String)

Determina si dos cadenas especificadas tienen el mismo valor. Determines whether two specified strings have the same value.

Implicit(String to ReadOnlySpan<Char>) Implicit(String to ReadOnlySpan<Char>) Implicit(String to ReadOnlySpan<Char>) Implicit(String to ReadOnlySpan<Char>)
Inequality(String, String) Inequality(String, String) Inequality(String, String) Inequality(String, String)

Determina si dos cadenas especificadas tienen valores diferentes. Determines whether two specified strings have different values.

Explicit Interface Implementations

IComparable.CompareTo(Object) IComparable.CompareTo(Object) IComparable.CompareTo(Object) IComparable.CompareTo(Object)
IConvertible.GetTypeCode() IConvertible.GetTypeCode() IConvertible.GetTypeCode() IConvertible.GetTypeCode()
IConvertible.ToBoolean(IFormatProvider) IConvertible.ToBoolean(IFormatProvider) IConvertible.ToBoolean(IFormatProvider) IConvertible.ToBoolean(IFormatProvider)

Para una descripción de este miembro, vea ToBoolean(IFormatProvider). For a description of this member, see ToBoolean(IFormatProvider).

IConvertible.ToByte(IFormatProvider) IConvertible.ToByte(IFormatProvider) IConvertible.ToByte(IFormatProvider) IConvertible.ToByte(IFormatProvider)

Para una descripción de este miembro, vea ToByte(IFormatProvider). For a description of this member, see ToByte(IFormatProvider).

IConvertible.ToChar(IFormatProvider) IConvertible.ToChar(IFormatProvider) IConvertible.ToChar(IFormatProvider) IConvertible.ToChar(IFormatProvider)

Para una descripción de este miembro, vea ToChar(IFormatProvider). For a description of this member, see ToChar(IFormatProvider).

IConvertible.ToDateTime(IFormatProvider) IConvertible.ToDateTime(IFormatProvider) IConvertible.ToDateTime(IFormatProvider) IConvertible.ToDateTime(IFormatProvider)

Para una descripción de este miembro, vea ToDateTime(IFormatProvider). For a description of this member, see ToDateTime(IFormatProvider).

IConvertible.ToDecimal(IFormatProvider) IConvertible.ToDecimal(IFormatProvider) IConvertible.ToDecimal(IFormatProvider) IConvertible.ToDecimal(IFormatProvider)

Para una descripción de este miembro, vea ToDecimal(IFormatProvider). For a description of this member, see ToDecimal(IFormatProvider).

IConvertible.ToDouble(IFormatProvider) IConvertible.ToDouble(IFormatProvider) IConvertible.ToDouble(IFormatProvider) IConvertible.ToDouble(IFormatProvider)

Para una descripción de este miembro, vea ToDouble(IFormatProvider). For a description of this member, see ToDouble(IFormatProvider).

IConvertible.ToInt16(IFormatProvider) IConvertible.ToInt16(IFormatProvider) IConvertible.ToInt16(IFormatProvider) IConvertible.ToInt16(IFormatProvider)

Para una descripción de este miembro, vea ToInt16(IFormatProvider). For a description of this member, see ToInt16(IFormatProvider).

IConvertible.ToInt32(IFormatProvider) IConvertible.ToInt32(IFormatProvider) IConvertible.ToInt32(IFormatProvider) IConvertible.ToInt32(IFormatProvider)

Para una descripción de este miembro, vea ToInt32(IFormatProvider). For a description of this member, see ToInt32(IFormatProvider).

IConvertible.ToInt64(IFormatProvider) IConvertible.ToInt64(IFormatProvider) IConvertible.ToInt64(IFormatProvider) IConvertible.ToInt64(IFormatProvider)

Para una descripción de este miembro, vea ToInt64(IFormatProvider). For a description of this member, see ToInt64(IFormatProvider).

IConvertible.ToSByte(IFormatProvider) IConvertible.ToSByte(IFormatProvider) IConvertible.ToSByte(IFormatProvider) IConvertible.ToSByte(IFormatProvider)

Para una descripción de este miembro, vea ToSByte(IFormatProvider). For a description of this member, see ToSByte(IFormatProvider).

IConvertible.ToSingle(IFormatProvider) IConvertible.ToSingle(IFormatProvider) IConvertible.ToSingle(IFormatProvider) IConvertible.ToSingle(IFormatProvider)

Para una descripción de este miembro, vea ToSingle(IFormatProvider). For a description of this member, see ToSingle(IFormatProvider).

IConvertible.ToString(IFormatProvider) IConvertible.ToString(IFormatProvider) IConvertible.ToString(IFormatProvider) IConvertible.ToString(IFormatProvider)
IConvertible.ToType(Type, IFormatProvider) IConvertible.ToType(Type, IFormatProvider) IConvertible.ToType(Type, IFormatProvider) IConvertible.ToType(Type, IFormatProvider)

Para una descripción de este miembro, vea ToType(Type, IFormatProvider). For a description of this member, see ToType(Type, IFormatProvider).

IConvertible.ToUInt16(IFormatProvider) IConvertible.ToUInt16(IFormatProvider) IConvertible.ToUInt16(IFormatProvider) IConvertible.ToUInt16(IFormatProvider)

Para una descripción de este miembro, vea ToUInt16(IFormatProvider). For a description of this member, see ToUInt16(IFormatProvider).

IConvertible.ToUInt32(IFormatProvider) IConvertible.ToUInt32(IFormatProvider) IConvertible.ToUInt32(IFormatProvider) IConvertible.ToUInt32(IFormatProvider)

Para una descripción de este miembro, vea ToUInt32(IFormatProvider). For a description of this member, see ToUInt32(IFormatProvider).

IConvertible.ToUInt64(IFormatProvider) IConvertible.ToUInt64(IFormatProvider) IConvertible.ToUInt64(IFormatProvider) IConvertible.ToUInt64(IFormatProvider)

Para una descripción de este miembro, vea ToUInt64(IFormatProvider). For a description of this member, see ToUInt64(IFormatProvider).

IEnumerable.GetEnumerator() IEnumerable.GetEnumerator() IEnumerable.GetEnumerator() IEnumerable.GetEnumerator()

Devuelve un enumerador que recorre en iteración el objeto String actual. Returns an enumerator that iterates through the current String object.

IEnumerable<Char>.GetEnumerator() IEnumerable<Char>.GetEnumerator() IEnumerable<Char>.GetEnumerator() IEnumerable<Char>.GetEnumerator()

Devuelve un enumerador que recorre en iteración el objeto String actual. Returns an enumerator that iterates through the current String object.

Applies to

Thread Safety

Este tipo es seguro para la ejecución de subprocesos. This type is thread safe.

See Also