String Clase

Definición

Representa texto como una secuencia de unidades de código UTF-16.

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

Comentarios

Una cadena es una colección secuencial de caracteres que se usa para representar texto. Un objeto es una colección secuencial de objetos que representan una cadena; un objeto String corresponde a una unidad de código System.Char System.Char UTF-16. El valor del objeto es el contenido de la colección secuencial de objetos y ese valor es String System.Char inmutable (es decir, es de solo lectura). Para obtener más información sobre la inmutabilidad de las cadenas, vea la sección Inmutabilidad y la clase StringBuilder. El tamaño máximo de un String objeto en memoria es de 2 GB o aproximadamente 1 mil millones de caracteres.

Para obtener más información sobre Unicode, UTF-16, unidades de código, puntos de código y los tipos y , vea Introducción a la codificación de Char Rune caracteres en .NET.

En esta sección:

Creación de instancias de un objeto String
Objetos Char y caracteres Unicode
Cadenas y el estándar Unicode
Cadenas y caracteres NULL incrustados
Cadenas e índices
Cadenas null y cadenas vacías
Inmutabilidad y la clase StringBuilder
Operaciones ordinales frente a operaciones que distinguen la referencia cultural
Normalización
Operaciones de cadena por categoría

Creación de instancias de un objeto String

Puede crear instancias de un String objeto de las maneras siguientes:

  • Asignando un literal de cadena a una String variable. Este es el método más usado para crear una cadena. En el ejemplo siguiente se usa la asignación para crear varias cadenas. Tenga en cuenta que, en C#, dado que la barra diagonal inversa ( ) es un carácter de escape, las barras \ diagonales inversas literales de una cadena deben ser de escape o toda la cadena debe ser @-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
    
  • Llamando a un String constructor de clase. En el ejemplo siguiente se crea una instancia de cadenas mediante una llamada a varios constructores de clase. Tenga en cuenta que algunos de los constructores incluyen punteros a matrices de caracteres o matrices de bytes con signo como parámetros. Visual Basic no admite llamadas a estos constructores. Para obtener información detallada sobre String los constructores, vea el String resumen del constructor.

    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
    
  • Mediante el operador de concatenación de cadenas (+ en C# y & o + en Visual Basic) para crear una sola cadena a partir de cualquier combinación de instancias y literales de String cadena. En el ejemplo siguiente se muestra el uso del operador de concatenación de cadenas.

    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.
    
  • Recuperando una propiedad o llamando a un método que devuelve una cadena. En el ejemplo siguiente se usan los métodos de la String clase para extraer una subcadena de una cadena mayor.

    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
    
  • Llamando a un método de formato para convertir un valor u objeto en su representación de cadena. En el ejemplo siguiente se usa la característica de formato compuesto para insertar la representación de cadena de dos objetos en una cadena.

    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.
    

Objetos Char y caracteres Unicode

Cada carácter de una cadena se define mediante un valor escalar Unicode, también denominado punto de código Unicode o valor ordinal (numérico) del carácter Unicode. Cada punto de código se codifica mediante la codificación UTF-16 y el valor numérico de cada elemento de la codificación se representa mediante un Char objeto .

Nota

Tenga en cuenta que, dado que una instancia de consta de una colección secuencial de unidades de código UTF-16, es posible crear un objeto que no sea una cadena Unicode bien String String formada. Por ejemplo, es posible crear una cadena que tenga un suplente bajo sin un suplente alto correspondiente. Aunque algunos métodos, como los métodos de codificación y codificación de objetos en el espacio de nombres, pueden realizar comprobaciones para asegurarse de que las cadenas tienen el formato correcto, los miembros de clase no garantizan que una cadena tenga el formato System.Text String correcto.

Normalmente, un único objeto representa un único punto de código; es decir, el valor numérico de Char es igual al punto de Char código. Por ejemplo, el punto de código del carácter "a" es U+0061. Sin embargo, un punto de código puede requerir más de un elemento codificado (más de un Char objeto). El estándar Unicode define dos tipos de caracteres que corresponden a varios objetos: grafemas y puntos de código complementarios Unicode que corresponden a caracteres de los planos Char adicionales Unicode.

  • Un grafeno se representa mediante un carácter base seguido de uno o varios caracteres de combinación. Por ejemplo, el carácter mente está representado por un objeto cuyo punto de código es U+0061 seguido de un objeto cuyo punto de código Char Char es U+0308. Este carácter también se puede definir mediante un único Char objeto que tiene un punto de código de U+00E4. Como se muestra en el ejemplo siguiente, una comparación de igualdad que tiene en cuenta la referencia cultural indica que estas dos representaciones son iguales, aunque no lo hace una comparación ordinal normal. Sin embargo, si las dos cadenas se normalizan, una comparación ordinal también indica que son iguales. (Para obtener más información sobre la normalización de cadenas, vea la sección Normalización).

    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
    
  • Un punto de código complementario Unicode (un par suplente) se representa mediante un objeto cuyo punto de código es un suplente alto seguido de un objeto cuyo punto de código es un suplente Char Char bajo. Las unidades de código de suplentes altos van de U+D800 a U+DBFF. Las unidades de código de suplentes bajos van de U+DC00 a U+DFFF. Los pares suplentes se usan para representar caracteres en los 16 planos adicionales Unicode. En el ejemplo siguiente se crea un carácter suplente y se pasa al método para determinar si se trata de Char.IsSurrogatePair(Char, Char) un par suplente.

    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
    
    string surrogate = "\uD800\uDC03";
    for (int ctr = 0; ctr < surrogate.Length; ctr++) 
       Console.Write($"U+{(ushort)surrogate[ctr]:X2} ");
    
    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
    

Cadenas y el estándar Unicode

Los caracteres de una cadena se representan mediante unidades de código codificadas UTF-16, que corresponden a Char valores.

Cada carácter de una cadena tiene una categoría de caracteres Unicode asociada, que se representa en .NET mediante la UnicodeCategory enumeración . La categoría de un carácter o un par suplente se puede determinar llamando al CharUnicodeInfo.GetUnicodeCategory método .

.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. En todas las versiones de .NET y en todas las plataformas del sistema operativo, la base de datos de caracteres Unicode proporciona información sobre la categoría de caracteres.

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.

Versión de .NET Versión del estándar Unicode
.NET Framework 1.1 Estándar Unicode, versión 4.0.0
.NET Framework 2.0 Estándar Unicode, versión 5.0.0
.NET Framework 3.5 Estándar Unicode, versión 5.0.0
.NET Framework 4 Estándar Unicode, versión 5.0.0
.NET Framework 4.5 Estándar Unicode, versión 6.3.0
.NET Framework 4.5.1 Estándar Unicode, versión 6.3.0
.NET Framework 4.5.2 Estándar Unicode, versión 6.3.0
.NET Framework 4.6 Estándar Unicode, versión 6.3.0
.NET Framework 4.6.1 Estándar Unicode, versión 6.3.0
.NET Framework 4.6.2 y versiones posteriores Estándar Unicode, versión 8.0.0
.NET Core 2.1 Estándar Unicode, versión 8.0.0
.NET Core 3.1 Estándar Unicode, versión 11.0.0
.NET 5 Estándar Unicode, versión 13.0.0

Además, .NET admite la comparación y ordenación de cadenas en función del estándar Unicode. .NET Framework 4 y versiones anteriores mantienen su propia tabla de datos de cadena. Esto también sucede con las versiones de .NET Framework a partir de .NET Framework 4.5 que se ejecuta en Windows 7. A partir de .NET Framework 4.5 que se ejecuta en Windows 8 y versiones posteriores del sistema operativo Windows, el runtime delega las operaciones de comparación y ordenación de cadenas en el sistema operativo. En .NET Core y .NET 5+, los componentes internacionales para bibliotecas Unicode proporcionan información de comparación y ordenación de cadenas (excepto en las versiones Windows anteriores a Actualización de mayo de 2019 de Windows 10). En la tabla siguiente se enumeran las versiones de .NET y las versiones del estándar Unicode en las que se basan la comparación y la ordenación de caracteres.

Versión de .NET Versión del estándar Unicode
.NET Framework 1.1 Estándar Unicode, versión 4.0.0
.NET Framework 2.0 Estándar Unicode, versión 5.0.0
.NET Framework 3.5 Estándar Unicode, versión 5.0.0
.NET Framework 4 Estándar Unicode, versión 5.0.0
.NET Framework 4.5 y versiones posteriores en Windows 7 Estándar Unicode, versión 5.0.0
.NET Framework 4.5 y versiones posteriores en Windows 8 y versiones posteriores Windows sistemas operativos Estándar Unicode, versión 6.3.0
.NET Core, y .NET 5 y versiones posteriores Depende de la versión del estándar Unicode compatible con el sistema operativo subyacente.

Cadenas y caracteres NULL incrustados

En .NET, un String objeto puede incluir caracteres NULL incrustados, que cuentan como parte de la longitud de la cadena. Sin embargo, en algunos lenguajes como C y C++, un carácter nulo indica el final de una cadena; no se considera parte de la cadena y no se cuenta como parte de la longitud de la cadena. Esto significa que las siguientes suposiciones comunes que los programadores o bibliotecas de C y C++ escritos en C o C++ podrían hacer sobre las cadenas no son necesariamente válidas cuando se aplican a String objetos:

  • El valor devuelto por las strlen funciones o no es necesariamente igual a wcslen String.Length .

  • La cadena creada por las strcpy_s funciones o no es necesariamente idéntica a la cadena creada por el método wcscpy_s String.Copy .

Debe asegurarse de que el código nativo de C y C++ que crea instancias de objetos y el código que se pasa a los objetos a través de la invocación de plataforma, no suponga que un carácter nulo incrustado marca el final de la String String cadena.

Los caracteres NULL incrustados en una cadena también se tratan de forma diferente cuando se ordena (o compara) una cadena y cuando se busca una cadena. Los caracteres NULL se omiten al realizar comparaciones que tienen en cuenta la referencia cultural entre dos cadenas, incluidas las comparaciones que usan la referencia cultural invariable. Se consideran solo para comparaciones ordinales o ordinales que no tienen en cuenta mayúsculas de minúsculas. Por otro lado, los caracteres NULL incrustados siempre se tienen en cuenta al buscar una cadena con métodos como Contains StartsWith , y IndexOf .

Cadenas e índices

Un índice es la posición de Char un objeto (no un carácter Unicode) en String . Un índice es un número no único de base cero que comienza desde la primera posición de la cadena, que es la posición de índice cero. Varios métodos de búsqueda, como IndexOf y LastIndexOf , devuelven el índice de un carácter o subcadena en la instancia de cadena.

La Chars[] propiedad permite tener acceso a objetos Char individuales por su posición de índice en la cadena. Dado que la propiedad es la propiedad predeterminada (en Visual Basic) o el Chars[] indexador (en C#), puede acceder a los objetos individuales de una cadena mediante código como el Char siguiente. Este código busca espacios en blanco o caracteres de puntuación en una cadena para determinar cuántas palabras contiene la cadena.

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.
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.

Dado que la clase implementa la interfaz , también puede recorrer en iteración los objetos de una cadena mediante una construcción , como se muestra String IEnumerable en el ejemplo Char foreach siguiente.

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.
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.

Es posible que los valores de índice consecutivos no se correspondan con caracteres Unicode consecutivos, ya que un carácter Unicode podría codificarse como más de un Char objeto. En concreto, una cadena puede contener unidades de texto de varios caracteres formadas por un carácter base seguido de uno o varios caracteres combinados o de pares suplentes. Para trabajar con caracteres Unicode en lugar de Char objetos, use las System.Globalization.StringInfo clases y o el método y la estructura TextElementEnumerator String.EnumerateRunes Rune . En el ejemplo siguiente se muestra la diferencia entre el código que funciona con Char objetos y el código que funciona con caracteres Unicode. Compara el número de caracteres o elementos de texto de cada palabra de una oración. La cadena incluye dos secuencias de un carácter base seguido de un carácter de combinación.

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
// 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++;
   }
}

System.Globalization.TextElementEnumerator te = 
   System.Globalization.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

Este ejemplo funciona con elementos de texto mediante el método StringInfo.GetTextElementEnumerator y la clase para TextElementEnumerator enumerar todos los elementos de texto de una cadena. También puede recuperar una matriz que contiene el índice inicial de cada elemento de texto llamando al StringInfo.ParseCombiningCharacters método .

Para obtener más información sobre cómo trabajar con unidades de texto en lugar de valores individuales, vea Introducción a Char la codificación de caracteres en .NET.

Cadenas null y cadenas vacías

Una cadena que se ha declarado pero no se le ha asignado un valor es null . Al intentar llamar a métodos en esa cadena, se produce una excepción NullReferenceException . Una cadena null es diferente de una cadena vacía, que es una cadena cuyo valor es "" o String.Empty . En algunos casos, pasar una cadena null o una cadena vacía como argumento en una llamada de método produce una excepción. Por ejemplo, si se pasa una cadena null al método se produce una excepción y al Int32.Parse pasar una cadena vacía se produce una ArgumentNullException FormatException excepción . En otros casos, un argumento de método puede ser una cadena null o una cadena vacía. Por ejemplo, si va a proporcionar una implementación para una clase, quiere igualar una cadena null y una cadena vacía con el especificador de formato IFormattable general ("G").

La String clase incluye los dos métodos de conveniencia siguientes que permiten probar si una cadena está o null vacía:

  • IsNullOrEmpty, que indica si una cadena es null o es igual a String.Empty . Este método elimina la necesidad de usar código como el siguiente:

    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 , es igual a o consta exclusivamente de null caracteres de espacio en String.Empty blanco. Este método elimina la necesidad de usar código como el siguiente:

    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 IsNullOrEmpty el método en la implementación de una clase IFormattable.ToString Temperature personalizada. El método admite las cadenas de formato "G", "C", "F" y "K". Si una cadena de formato vacía o una cadena de formato cuyo valor se pasa al método, su valor se cambia a la cadena de null formato "G".

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

Inmutabilidad y la clase StringBuilder

Un String objeto se denomina inmutable (solo lectura), porque su valor no se puede modificar una vez creado. Los métodos que parecen modificar String un objeto devuelven realmente un nuevo String objeto que contiene la modificación.

Dado que las cadenas son inmutables, las rutinas de manipulación de cadenas que realizan adiciones o eliminaciones repetidas en lo que parece ser una sola cadena pueden exactamente una reducción significativa del rendimiento. Por ejemplo, el código siguiente usa un generador de números aleatorios para crear una cadena con 1000 caracteres en el intervalo 0x0001 para 0x052F. Aunque el código parece usar la concatenación de cadenas para anexar un nuevo carácter a la cadena existente denominada , realmente crea un nuevo objeto str para cada operación de String concatenación.

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 += (char)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 la clase StringBuilder en lugar de la clase para las operaciones que String realicen varios cambios en el valor de una cadena. A diferencia de las instancias de la clase , los objetos son mutables; al concatenar, anexar o eliminar subcadenas de una cadena, las operaciones se realizan String StringBuilder en una sola cadena. Cuando haya terminado de modificar el valor de un objeto, puede llamar a StringBuilder su método para convertirlo en una StringBuilder.ToString cadena. En el ejemplo siguiente se reemplaza el utilizado en el ejemplo anterior para String concatenar 1000 caracteres aleatorios en el intervalo para 0x0001 para 0x052F con un StringBuilder objeto .

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((char)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

Operaciones ordinales frente a operaciones que distinguen la referencia cultural

Los miembros de String la clase realizan operaciones ordinales o culturales (lingüísticas) en un objeto String . Una operación ordinal actúa sobre el valor numérico de cada Char objeto. Una operación que tiene en cuenta la referencia cultural actúa sobre el valor del objeto y tiene en cuenta las reglas de uso de mayúsculas y minúsculas, ordenación, formato y análisis específicas String de la referencia cultural. Las operaciones que tienen en cuenta la referencia cultural se ejecutan en el contexto de una referencia cultural declarada explícitamente o de la referencia cultural actual implícita. Los dos tipos de operaciones pueden producir resultados muy diferentes cuando se realizan en la misma cadena.

.NET también admite operaciones de cadena lingüísticas que no tienen en cuenta la referencia cultural mediante la referencia cultural invariable ( ), que se basa de forma flexible en la configuración de referencia cultural del idioma inglés independientemente de la CultureInfo.InvariantCulture región. A diferencia de otras configuraciones, se garantiza que la configuración de la referencia cultural invariable siga siendo coherente en un solo equipo, desde el sistema al sistema y entre las System.Globalization.CultureInfo versiones de .NET. La referencia cultural invariable se puede ver como un tipo de caja negra que garantiza la estabilidad de las comparaciones de cadenas y el orden en todas las referencia culturales.

Importante

Si la aplicación toma una decisión de seguridad sobre un identificador simbólico, como un nombre de archivo o una canalización con nombre, o sobre los datos persistentes, como los datos basados en texto en un archivo XML, la operación debe usar una comparación ordinal en lugar de una comparación que tenga en cuenta la referencia cultural. Esto se debe a que 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 del valor binario de los caracteres comparados.

Importante

La mayoría de los métodos que realizan operaciones de cadena incluyen una sobrecarga que tiene un parámetro de tipo , que permite especificar si el método realiza una operación ordinal o que tiene en cuenta la StringComparison referencia cultural. En general, debe llamar a esta sobrecarga para que la intención de la llamada al método sea clara. Para obtener procedimientos recomendados e instrucciones para usar operaciones ordinales y de referencia cultural en cadenas, vea Procedimientos recomendados para el uso de cadenas.

Las operaciones de usode mayúsculas y minúsculas,el análisis y el formato,la comparación y la ordenación, y las pruebas de igualdad pueden ser ordinales o sensibles a la referencia cultural. En las secciones siguientes se describe cada categoría de operación.

Sugerencia

Siempre debe llamar a una sobrecarga de método que haga que la intención de la llamada al método sea clara. Por ejemplo, en lugar de llamar al método para realizar una comparación de dos cadenas que tiene en cuenta la referencia cultural mediante las convenciones de la referencia cultural actual, debe llamar al método con un valor de para Compare(String, String) Compare(String, String, StringComparison) el argumento StringComparison.CurrentCulture comparisonType . Para obtener más información, consulte Procedimientos recomendados para el uso de cadenas.

Puede descargar las tablas de peso de ordenación, un conjunto de archivos de texto que contienen información sobre los pesos de caracteres usados en las operaciones de ordenación y comparación, desde los vínculos siguientes:

Uso de mayúsculas y minúsculas

Las reglas de mayúsculas y minúsculas determinan cómo cambiar el uso de mayúsculas y minúsculas de un carácter Unicode; por ejemplo, de minúsculas a mayúsculas. A menudo, se realiza una operación de uso de mayúsculas y minúsculas antes de una comparación de cadenas. Por ejemplo, una cadena se puede convertir a mayúsculas para que se pueda comparar con otra cadena en mayúsculas. Puede convertir los caracteres de una cadena a minúsculas llamando al método o , y puede convertirlos a mayúsculas llamando ToLower ToLowerInvariant al método o ToUpper ToUpperInvariant . Además, puede usar el método para TextInfo.ToTitleCase convertir una cadena en mayúsculas y minúsculas.

Nota

.NET Core solo se ejecuta en sistemas Linux y macOS: El comportamiento de intercalación de las referencia culturales de C y Posix siempre distingue mayúsculas de minúsculas porque estas no usan el orden de intercalación Unicode esperado. Se recomienda que utilice una referencia cultural que no sea de C o Posix para realizar operaciones de ordenación que tengan en cuenta la referencia cultural y no distingan mayúsculas y minúsculas.

Las operaciones de mayúsculas y minúsculas se pueden basar en las reglas de la referencia cultural actual, una referencia cultural especificada o la referencia cultural invariable. Dado que las asignaciones de casos pueden variar en función de la referencia cultural utilizada, el resultado de las operaciones de mayúsculas y minúsculas puede variar en función de la referencia cultural. Las diferencias reales en el uso de mayúsculas y minúsculas son de tres tipos:

  • Diferencias en la asignación de mayúsculas y minúsculas de LATIN LETTER I (U+0049), LATIN SMALL LETTER I (U+0069), LATIN CAPITAL LETTER I WITH DOT ABOVE (U+0130) y LATIN SMALL LETTER DOTLESS I (U+0131). En las culturas tr-TR (turco (Turco)) y az-Latn-AZ (Inquieto, Latino), y en las culturas tr, az y az-Latn neutral, el equivalente en minúscula de LATIN CAPITAL LETTER I es LATIN SMALL LETTER DOTLESS I y el equivalente en mayúsculas de LATIN SMALL LETTER I es LATIN CAPITAL LETTER I WITH DOT ABOVE. En todas las demás culturas, incluida la referencia cultural invariable, LATIN SMALL LETTER I y LATIN CAPITAL LETTER I son equivalentes en minúsculas y mayúsculas.

    En el ejemplo siguiente se muestra cómo puede producirse un error en una comparación de cadenas diseñada para impedir el acceso al sistema de archivos si se basa en una comparación de mayúsculas y minúsculas que tiene en cuenta la referencia cultural. (Se deben haber usado las convenciones de mayúsculas y minúsculas de la referencia cultural invariable).

    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 en las asignaciones de mayúsculas y minúsculas entre la referencia cultural invariable y todas las demás. En estos casos, el uso de las reglas de mayúsculas y minúsculas de la referencia cultural invariable para cambiar un carácter a mayúsculas o minúsculas devuelve el mismo carácter. Para todas las demás referencia culturales, devuelve un carácter diferente. Algunos de los caracteres afectados se muestran en la tabla siguiente.

    Carácter Si se cambia a Devoluciones
    MICRON SIGN (U+00B5) Mayúsculas LETRAS MAYÚSCULAS DE GRIEGO MU (U+-39C)
    LATIN CAPITAL LETTER I WITH DOT ABOVE (U+0130) Minúsculas LATIN SMALL LETTER I (U+0069)
    LATIN SMALL LETTER DOTLESS I (U+0131) Mayúsculas LATIN CAPITAL LETTER I (U+0049)
    LATIN SMALL LETTER LONG S (U+017F) Mayúsculas LATIN CAPITAL LETTER S (U+0053)
    LATIN CAPITAL LETTER D WITH SMALL LETTER Z WITH CARON (U+01C5) Minúsculas LATIN SMALL LETTER AMERICA WITH CARON (U+01C6)
    COMBINACIÓN DE YPOGEGRAMMENI GRIEGO (U+0345) Mayúsculas LETRAS DE CAPITAL GRIEGO IOTA (U+0399)
  • Diferencias en las asignaciones de mayúsculas y minúsculas de pares de mayúsculas y minúsculas mixtos de dos letras en el intervalo de caracteres ASCII. En la mayoría de las referencia culturales, un par de mayúsculas y minúsculas de dos letras es igual al par de dos letras mayúsculas o minúsculas equivalente. Esto no es cierto para los siguientes pares de dos letras en las siguientes referencia culturales, porque en cada caso se comparan con un digráfico:

    • "lJ" y "nJ" en la referencia cultural hr-HR (rehánésica [República Deiña]).

    • "cH" en las culturas cs-SKU (Checo (República Checo)) y sk-SK (Checo (Alemania)).

    • "aA" en la referencia cultural da-DK (danés [Dinamarca]).

    • "cS", "dZ", "dZS", "nY", "sZ", "tY" y "zS" en la referencia cultural hu-HU (Húngaro (Inso)).

    • "cH" e "lL" en la referencia cultural es-ES_tradnl (español (España, Ordenación tradicional)).

    • "cH", "gI", "kH", "nG" "nH", "pH", "qU', "tH" y "tR" en la referencia cultural vi-VN (Invergía (Nama)).

    Sin embargo, no es habitual encontrar una situación en la que una comparación de estos pares que tiene en cuenta la referencia cultural crea problemas, ya que estos pares no son comunes en cadenas fijas o identificadores.

En el ejemplo siguiente se muestran algunas de las diferencias en las reglas de mayúsculas y minúsculas entre las referencia culturales al convertir cadenas a mayúsculas.

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 formato

El formato y el análisis son operaciones inversas. Las 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. Tanto las reglas de formato como las reglas de análisis dependen de las convenciones culturales. En el ejemplo siguiente se muestra la ambigüedad que puede surgir al interpretar una cadena de fecha específica de la referencia cultural. Sin conocer las convenciones de la referencia cultural que se usó para generar una cadena de fecha, no es posible saber si 03/01/2011, 3/1/2011 y 01/03/2011 representan el 3 de enero de 2011 o el 1 de marzo de 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 generar fechas diferentes en función de la referencia cultural cuyas convenciones se usan en la operación de análisis.

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 y ordenación de cadenas

Las convenciones para comparar y ordenar cadenas varían de referencia cultural a referencia cultural. Por ejemplo, el criterio de ordenación puede basarse en fonética o en la representación visual de caracteres. En los idiomas de Este de Asia, los caracteres se ordenan teniendo en cuenta los trazos y el radical de los ideogramas. El criterio de ordenación también depende del orden que se emplea en los distintos idiomas y referencias culturales para el alfabeto. Por ejemplo, el idioma danés tiene un carácter "Æ" que se ordena después de la "Z" en el alfabeto. Además, las comparaciones pueden distingue mayúsculas de minúsculas o no distingue mayúsculas de minúsculas, y las reglas de mayúsculas y minúsculas pueden diferir según la referencia cultural. Por otro lado, la comparación ordinal usa los puntos de código Unicode de caracteres individuales de una cadena al comparar y ordenar cadenas.

Las reglas de ordenación determinan el orden alfabético de los caracteres Unicode y cómo se comparan dos cadenas entre sí. Por ejemplo, el String.Compare(String, String, StringComparison) método compara dos cadenas basadas en el StringComparison parámetro . Si el valor del parámetro es , 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 , el método realiza una comparación StringComparison.CurrentCulture StringComparison.Ordinal ordinal. Por lo tanto, como se muestra en el ejemplo siguiente, si la referencia cultural actual es inglés de EE. UU., la primera llamada al método (mediante la comparación según la referencia cultural) considera "a" menor que "A", pero la segunda llamada al mismo método (mediante la comparación String.Compare(String, String, StringComparison) ordinal) considera "a" mayor que "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 admite reglas de ordenación de palabras, cadenas y ordinales:

  • 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. Por ejemplo, el guion (-) podría tener asignado un peso muy pequeño para que "clo" y "co-op" aparezcan juntos en una lista ordenada. Para obtener una lista de los métodos que comparan dos cadenas mediante reglas de ordenación de String palabras, vea la sección Operaciones de cadena por categoría.

  • Una ordenación de cadena también realiza una comparación que tiene en cuenta la referencia cultural. Es similar a una ordenación de palabras, salvo que no hay casos especiales y todos los símbolos no alfanuméricos van delante de todos los caracteres Unicode alfanuméricos. Se pueden comparar dos cadenas mediante reglas de ordenación de cadenas llamando a las sobrecargas de método que tienen un parámetro que CompareInfo.Compare se proporciona un valor de options CompareOptions.StringSort . Tenga en cuenta que este es el único método que proporciona .NET para comparar dos cadenas mediante reglas de ordenación de cadenas.

  • Una ordenación ordinal compara las cadenas basadas en el valor numérico de cada objeto Char en la cadena. Una comparación ordinal distingue mayúsculas de minúsculas automáticamente porque las versiones en minúsculas y mayúsculas de un carácter tienen puntos de código diferentes. Sin embargo, si case no es importante, puede especificar una comparación ordinal que ignore case. Esto equivale a convertir la cadena a mayúsculas mediante la referencia cultural invariable y, a continuación, realizar una comparación ordinal en el resultado. Para obtener una lista de los métodos que comparan dos cadenas mediante reglas de ordenación ordinal, vea la sección Operaciones de cadena String por categoría.

Una comparación dependiente de la referencia cultural es cualquier comparación que use explícita o implícitamente un objeto , incluida la referencia cultural invariable especificada CultureInfo por la propiedad CultureInfo.InvariantCulture . La referencia cultural implícita es la referencia cultural actual, especificada por las Thread.CurrentCulture propiedades CultureInfo.CurrentCulture y . Hay una variación considerable en el criterio de ordenación de los caracteres alfabéticos (es decir, los caracteres para los que la propiedad devuelve ) entre Char.IsLetter true las referencia culturales. Puede especificar una comparación que tiene en cuenta la referencia cultural que usa las convenciones de una referencia cultural específica si proporciona un objeto a un método de comparación de CultureInfo cadenas como Compare(String, String, CultureInfo, CompareOptions) . Puede especificar una comparación que use las convenciones de la referencia cultural actual si proporciona , o cualquier miembro de la enumeración que no sea o a una sobrecarga adecuada StringComparison.CurrentCulture StringComparison.CurrentCultureIgnoreCase del método CompareOptions CompareOptions.Ordinal CompareOptions.OrdinalIgnoreCase Compare . Por lo general, una comparación que tiene en cuenta la referencia cultural es adecuada para la ordenación, mientras que una comparación ordinal no lo es. Por lo general, una comparación ordinal es adecuada para determinar si dos cadenas son iguales (es decir, para determinar la identidad), mientras que una comparación que tiene en cuenta la referencia cultural no lo es.

En el ejemplo siguiente se muestra la diferencia entre la comparación ordinal y la referencia cultural. En el ejemplo se evalúan tres cadenas, "Apple", " Yble" y "AEble", mediante la comparación ordinal y las convenciones de las referencia culturales da-DK y en-US (cada una de las cuales es la referencia cultural predeterminada en el momento en que se llama al Compare método). Dado que el idioma danés trata el carácter "dín" como una letra individual y lo ordena después de "Z" en el alfabeto, la cadena " Able" es mayor que "Apple". Sin embargo, "..." no se considera equivalente a "AEble", por lo que "bles" también es mayor que "AEble". La referencia cultural en-US no incluye la letra " ETH", sino que la trata como equivalente a "AE", lo que explica por qué "Bles" es menor que "Apple", pero igual a "AEble". Por otro lado, la comparación ordinal considera que "Apple" es menor que "bles" y "bles" es mayor que "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

Use las siguientes directrices generales para elegir un método de ordenación o comparación de cadenas adecuado:

  • Si desea que las cadenas se ordenen según la referencia cultural del usuario, debe ordenarlas en función de las convenciones de la referencia cultural actual. Si cambia la referencia cultural del usuario, el orden de las cadenas ordenadas también cambiará en consecuencia. Por ejemplo, una aplicación de diccionario de sinónimos siempre debe ordenar las palabras en función de la referencia cultural del usuario.

  • Si desea que las cadenas se ordenen según las convenciones de una referencia cultural específica, debe ordenarlas suministrando un objeto que represente esa referencia cultural a un método CultureInfo de comparación. Por ejemplo, en una aplicación diseñada para enseñar a los alumnos un idioma determinado, quiere que las cadenas se ordenan en función de las convenciones de una de las culturas que habla ese idioma.

  • Si desea que el orden de las cadenas permanezca sin cambios entre las distintas referencia culturales, debe ordenarlas en función de las convenciones de la referencia cultural invariable o usar una comparación ordinal. Por ejemplo, usaría una ordenación ordinal para organizar los nombres de archivos, procesos, exclusiones mutuas o canalizaciones con nombre.

  • Para una comparación que implique una decisión de seguridad (por ejemplo, si un nombre de usuario es válido), siempre debe realizar una prueba ordinal de igualdad llamando a una sobrecarga del Equals método .

Nota

Las reglas de ordenación y uso de mayúsculas y minúsculas que se usan en la comparación de cadenas dependen de la versión de .NET. En .NET Core, la comparación de cadenas depende de la versión del estándar Unicode compatible con el sistema operativo subyacente. En .NET Framework 4.5 y versiones posteriores que se ejecutan en Windows 8 o versiones posteriores, la ordenación, el uso de mayúsculas y minúsculas, la normalización y la información de caracteres Unicode se ajustan al estándar Unicode 6.0. En otros Windows operativos, se ajustan al estándar Unicode 5.0.

Para obtener más información sobre las reglas de ordenación de palabras, cadenas y ordinales, vea el System.Globalization.CompareOptions tema . Para obtener recomendaciones adicionales sobre cuándo usar cada regla, vea Procedimientos recomendados para usar cadenas.

Normalmente, no se llama a métodos de comparación de cadenas como Compare directamente para determinar el criterio de ordenación de las cadenas. En su lugar, se llama a los métodos de comparación mediante la ordenación de métodos Array.Sort como o List<T>.Sort . En el ejemplo siguiente se realizan cuatro operaciones de ordenación diferentes (ordenación de palabras mediante la referencia cultural actual, ordenación de palabras mediante la referencia cultural invariable, ordenación ordinal y ordenación de cadenas mediante la referencia cultural invariable) sin llamar explícitamente a un método de comparación de cadenas, aunque especifican el tipo de comparación que se usará. Tenga en cuenta que cada tipo de ordenación genera una ordenación única de cadenas en su matriz.

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 culturalmente confidenciales. 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. Una clave de ordenación, representada por la clase , proporciona SortKey un repositorio de estos pesos para una cadena determinada. Si la aplicación realiza un gran número de operaciones de búsqueda u ordenación en el mismo conjunto de cadenas, puede mejorar su rendimiento generando y almacenando claves de ordenación para todas las cadenas que usa. Cuando se requiere una operación de ordenación o comparación, se usan las claves de ordenación en lugar de las cadenas. Para obtener más información, vea la clase SortKey.

Si no especifica una convención de comparación de cadenas, los métodos de ordenación, como, por ejemplo, realizan una ordenación que distingue entre mayúsculas y minúsculas de Array.Sort(Array) las cadenas. En el ejemplo siguiente se muestra cómo el cambio de la referencia cultural actual afecta al orden de las cadenas ordenadas en una matriz. Crea una matriz de tres cadenas. En primer lugar, se establece la propiedad System.Threading.Thread.CurrentThread.CurrentCulture en en-US y se llama al método Array.Sort(Array). El criterio de ordenación resultante se basa en las convenciones de ordenación de la referencia cultural Inglés (Estados Unidos). 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. 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).

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 el propósito principal para comparar cadenas es determinar si son iguales, debe llamar al String.Equals método . Normalmente, debe usar Equals para realizar una comparación ordinal. El String.Compare método está pensado principalmente para ordenar cadenas.

Los métodos de búsqueda de cadenas, como y , también pueden realizar comparaciones de String.StartsWith cadenas ordinales o de referencia String.IndexOf cultural. En el ejemplo siguiente se muestran las diferencias entre las comparaciones ordinales y las que tienen en cuenta la referencia cultural mediante el IndexOf método . Una búsqueda que tenga en cuenta la referencia cultural en la que la referencia cultural actual sea inglés (Estados Unidos) considera que la subcadena "oe" coincide con la ligadura "omisión". Dado que un guion flexible (U+00AD) es un carácter de ancho cero, la búsqueda trata el guion suave como equivalente a y busca una coincidencia al principio de la Empty cadena. Por otro lado, una búsqueda ordinal no encuentra ninguna coincidencia en ninguno de los casos.

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

Búsqueda en cadenas

Los métodos de búsqueda de cadenas, como y , también pueden realizar comparaciones de cadenas ordinales o de referencia cultural para determinar si se encuentra un carácter o String.StartsWith una subcadena en una cadena String.IndexOf especificada.

Los métodos de búsqueda de la clase que buscan un carácter individual, como el método , o uno de un conjunto de caracteres, como el método , realizan una búsqueda String IndexOf IndexOfAny ordinal. Para realizar una búsqueda que tiene en cuenta la referencia cultural de un carácter, debe llamar a un CompareInfo método como CompareInfo.IndexOf(String, Char) o CompareInfo.LastIndexOf(String, Char) . Tenga en cuenta que los resultados de la búsqueda de un carácter mediante la comparación ordinal y de referencia cultural pueden ser muy diferentes. Por ejemplo, una búsqueda de un carácter Unicode precompilado como la ligadura "dín" (U+00C6) podría coincidir con cualquier aparición de sus componentes en la secuencia correcta, como "AE" (U+041U+0045), según la referencia cultural. En el ejemplo siguiente se muestra la diferencia entre los String.IndexOf(Char) CompareInfo.IndexOf(String, Char) métodos y al buscar un carácter individual. La ligadura " obstante" (U+00E6) se encuentra en la cadena "aérea" cuando se usan las convenciones de la referencia cultural en-US, pero no cuando se usan las convenciones de la referencia cultural da-DK o al realizar una comparación ordinal.

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, los métodos de clase que buscan una cadena en lugar de un carácter realizan una búsqueda que tenga en cuenta la referencia cultural si un parámetro de tipo no especifica explícitamente las opciones de String StringComparison búsqueda. La única excepción es Contains , que realiza una búsqueda ordinal.

Pruebas de igualdad

Use el String.Compare método para determinar la relación de dos cadenas en el criterio de ordenación. Normalmente, se trata de una operación que tiene en cuenta la referencia cultural. Por el contrario, llame al String.Equals método para comprobar la igualdad. Dado que la prueba de igualdad normalmente compara la entrada del usuario con alguna cadena conocida, como un nombre de usuario válido, una contraseña o una ruta de acceso del sistema de archivos, suele ser una operación ordinal.

Advertencia

Es posible probar la igualdad llamando al método y String.Compare determinando si el valor devuelto es cero. Sin embargo, no se recomienda esta práctica. Para determinar si dos cadenas son iguales, debe llamar a una de las sobrecargas del String.Equals método . La sobrecarga preferida para llamar a es el método de instancia o el método estático, ya que ambos métodos incluyen un parámetro que especifica Equals(String, StringComparison) Equals(String, String, StringComparison) System.StringComparison explícitamente el tipo de comparación.

En el ejemplo siguiente se muestra el peligro de realizar una comparación de igualdad según la referencia cultural cuando se debe usar uno ordinal en su lugar. En este caso, la intención del código es prohibir el acceso del sistema de archivos desde direcciones URL que comienzan por "FILE://" o "file://" realizando una comparación sin mayúsculas de minúsculas del principio de una dirección URL con la cadena "FILE://". Sin embargo, si se realiza una comparación según la referencia cultural mediante la referencia cultural turco (Turco) en una dirección URL que comienza con "file://", se produce un error en la comparación de igualdad, porque el equivalente en mayúsculas turco de la "i" minúscula es " así" en lugar de "I". Como resultado, se permite el acceso al sistema de archivos accidentalmente. 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.

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ón

Algunos caracteres Unicode tienen varias representaciones. Por ejemplo, cualquiera de los siguientes puntos de código puede representar la letra "":

  • U+1EAF

  • U+0103 U+0301

  • U+0061 U+0306 U+0301

Varias representaciones para un solo carácter complican las operaciones de búsqueda, ordenación, coincidencia y otras cadenas.

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. La normalización puede usar varios algoritmos, denominados formularios de normalización, que siguen reglas diferentes. .NET admite los formularios de normalización Unicode C, D, KC y KD. Cuando las cadenas se han normalizado con el mismo formato de normalización, se pueden comparar mediante la comparación ordinal.

Una comparación ordinal es una comparación binaria del valor escalar Unicode de los objetos Char correspondientes en cada cadena. La String clase incluye varios métodos que pueden realizar una comparación ordinal, incluidos los siguientes:

Puede determinar si una cadena se normaliza con el formato de normalización C llamando al método , o puede llamar al método para determinar si una cadena se normaliza en un formulario String.IsNormalized() String.IsNormalized(NormalizationForm) de normalización especificado. También puede llamar al método para convertir una cadena al formato de normalización C, o puede llamar al método para convertir una cadena en un String.Normalize() String.Normalize(NormalizationForm) formulario de normalización especificado. Para obtener información paso a paso sobre la normalización y comparación de cadenas, vea los métodos Normalize() Normalize(NormalizationForm) y .

En el ejemplo simple siguiente se muestra la normalización de cadenas. Define la letra "" de tres maneras diferentes en tres cadenas diferentes y usa una comparación ordinal de igualdad para determinar que cada cadena difiere de las otras dos cadenas. A continuación, convierte cada cadena en los formularios de normalización admitidos y, de nuevo, realiza una comparación ordinal de cada cadena en un formulario de normalización especificado. En cada caso, la segunda prueba de igualdad muestra que las cadenas son iguales.

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 += $"{(ushort)ch: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 los formularios de normalización y normalización, vea , así como el anexo estándar System.Text.NormalizationForm Unicode n.º 15: formularios de normalización Unicode y las preguntas más frecuentes sobre normalización en el sitio unicode.org web.

Operaciones de cadena por categoría

La clase proporciona miembros para comparar cadenas, probar la igualdad de cadenas, buscar caracteres o subcadenas en una cadena, modificar una cadena, extraer subcadenas de una cadena, combinar cadenas, aplicar formato a valores, copiar una cadena y String normalizar una cadena.

Comparación de cadenas

Puede comparar cadenas para determinar su posición relativa en el criterio de ordenación mediante los métodos String siguientes:

  • Compare devuelve un entero que indica la relación de una cadena con una segunda cadena en el criterio de ordenación.

  • CompareOrdinal devuelve un entero que indica la relación de una cadena con una segunda cadena en función de una comparación de sus puntos de código.

  • CompareTo devuelve un entero que indica la relación de la instancia de cadena actual con una segunda cadena en el criterio de ordenación. El CompareTo(String) método proporciona las IComparable IComparable<T> implementaciones y para la clase String .

Prueba de la igualdad de cadenas

Llame al método Equals para determinar si dos cadenas son iguales. La instancia y las sobrecargas estáticas permiten especificar si la comparación tiene en cuenta la referencia cultural o el ordinal, y si se tiene en cuenta o se omite el uso de Equals(String, String, StringComparison) Equals(String, StringComparison) mayúsculas y minúsculas. La mayoría de las pruebas de igualdad son ordinales 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.

Buscar caracteres en una cadena

La String clase incluye dos tipos de métodos de búsqueda:

Advertencia

Si desea buscar en una cadena un patrón determinado en lugar de una subcadena específica, debe usar expresiones regulares. Para obtener más información, vea Expresiones regulares de .NET.

Modificar una cadena

La String clase incluye los métodos siguientes que parecen modificar el valor de una cadena:

  • Insert inserta una cadena en la instancia String actual.

  • PadLeft inserta una o varias apariciones de un carácter especificado al principio de una cadena.

  • PadRight inserta una o varias apariciones de un carácter especificado al final de una cadena.

  • Remove elimina una subcadena de la instancia String actual.

  • Replace reemplaza una subcadena por otra subcadena en la instancia String actual.

  • ToLower y ToLowerInvariant convierten todos los caracteres de una cadena a minúsculas.

  • ToUpper y ToUpperInvariant convierten todos los caracteres de una cadena a mayúsculas.

  • Trim quita todas las apariciones de un carácter del principio y el final de una cadena.

  • TrimEnd quita todas las apariciones de un carácter del final de una cadena.

  • TrimStart quita todas las apariciones de un carácter del principio de una cadena.

Importante

Todos los métodos de modificación de cadenas devuelven un nuevo String objeto . No modifican el valor de la instancia actual.

Extracción de subcadenas de una cadena

El String.Split método separa una sola cadena en varias cadenas. Las sobrecargas del método permiten especificar varios delimitadores, limitar el número de subcadenas que extrae el método, recortar el espacio en blanco de las subcadenas y especificar si las cadenas vacías (que se producen cuando los delimitadores son adyacentes) se incluyen entre las cadenas devueltas.

Combinar cadenas

Los String métodos siguientes se pueden usar para la concatenación de cadenas:

  • Concat combina una o varias subcadenas en una sola cadena.

  • Join concatena una o varias subcadenas en un único elemento y agrega un separador entre cada subcadena.

Valores de formato

El método usa la característica de formato compuesto para reemplazar uno o varios marcadores de posición de una cadena por la representación de cadena String.Format de algún objeto o valor. El Format método se usa a menudo para hacer lo siguiente:

  • Para insertar la representación de cadena de un valor numérico en una cadena.

  • Para insertar la representación de cadena de un valor de fecha y hora en una cadena.

  • Para insertar la representación de cadena de un valor de enumeración en una cadena.

  • Para insertar la representación de cadena de algún objeto que admite la IFormattable interfaz en una cadena.

  • Para justificar a la derecha o a la izquierda una subcadena en un campo dentro de una cadena mayor.

Para obtener información detallada sobre las operaciones de formato y los ejemplos, consulte el Format resumen de sobrecarga.

Copiar una cadena

Puede llamar a los String métodos siguientes para realizar una copia de una cadena:

  • Clone devuelve una referencia a un objeto String existente.

  • Copy crea una copia de una cadena existente.

  • CopyTo copia una parte de una cadena en una matriz de caracteres.

Normalización de una cadena

En Unicode, un solo carácter puede tener varios puntos de código. La normalización convierte estos caracteres equivalentes en la misma representación binaria. El String.Normalize método realiza la normalización y el método determina si se String.IsNormalized normaliza una cadena.

Para obtener más información y un ejemplo, vea la sección Normalización anteriormente en este tema.

Constructores

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.

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.

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.

String(Char[])

Inicializa una nueva instancia de la clase String en el valor de caracteres Unicode indicado en la matriz de caracteres especificada.

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.

String(ReadOnlySpan<Char>)

Inicializa una nueva instancia de la clase String en el valor de caracteres Unicode indicado en el intervalo de solo lectura especificado.

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.

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.

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.

Campos

Empty

Representa la cadena vacía. Este campo es de solo lectura.

Propiedades

Chars[Int32]

Obtiene el objeto Char situado en una posición específica en el objeto String actual.

Length

Obtiene el número de caracteres del objeto String actual.

Métodos

Clone()

Devuelve una referencia a la instancia de String.

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.

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.

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.

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.

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.

Compare(String, String)

Compara dos objetos String especificados y devuelve un entero que indica su posición relativa en el criterio de ordenación.

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.

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.

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.

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.

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.

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.

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.

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.

Concat(IEnumerable<String>)

Concatena los miembros de una colección IEnumerable<T> construida de tipo String.

Concat(Object)

Crea la representación de cadena de un objeto especificado.

Concat(Object, Object)

Concatena las representaciones de cadena de dos objetos especificados.

Concat(Object, Object, Object)

Concatena las representaciones de cadena de tres objetos especificados.

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.

Concat(Object[])

Concatena las representaciones de cadena de los elementos de una matriz Object especificada.

Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>)

Concatena las representaciones de cadena de dos intervalos especificados de caracteres de solo lectura.

Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>)

Concatena las representaciones de cadena de tres intervalos especificados de caracteres de solo lectura.

Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>)

Concatena las representaciones de cadena de cuatro intervalos especificados de caracteres de solo lectura.

Concat(String, String)

Concatena dos instancias de String especificadas.

Concat(String, String, String)

Concatena tres instancias de String especificadas.

Concat(String, String, String, String)

Concatena cuatro instancias de String especificadas.

Concat(String[])

Concatena los elementos en una matriz String especificada.

Concat<T>(IEnumerable<T>)

Concatena los miembros de una implementación de IEnumerable<T>.

Contains(Char)

Devuelve un valor que indica si un carácter especificado aparece dentro de esta cadena.

Contains(Char, StringComparison)

Devuelve un valor que indica si un carácter especificado aparece dentro de esta cadena, mediante las reglas de comparación especificadas.

Contains(String)

Devuelve un valor que indica si una subcadena especificada aparece dentro de esta cadena.

Contains(String, StringComparison)

Devuelve un valor que indica si una cadena especificada aparece dentro de esta cadena, mediante las reglas de comparación especificadas.

Copy(String)
Obsoleto.

Crea una nueva instancia de String con el mismo valor que una String especificada.

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.

CopyTo(Span<Char>)

Copia el contenido de esta cadena en el intervalo de destino.

Create(IFormatProvider, DefaultInterpolatedStringHandler)

Crea una nueva cadena utilizando el proveedor especificado para controlar el formato de la cadena interpolada especificada.

Create(IFormatProvider, Span<Char>, DefaultInterpolatedStringHandler)

Crea una nueva cadena utilizando el proveedor especificado para controlar el formato de la cadena interpolada especificada.

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

Crea una cadena con una longitud específica y la inicializa después de la creación mediante la devolución de llamada especificada.

EndsWith(Char)

Determina si el final de esta instancia de cadena coincide con el carácter especificado.

EndsWith(String)

Determina si el final de esta instancia de cadena coincide con la cadena especificada.

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.

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.

EnumerateRunes()

Devuelve una enumeración de Rune desde esta cadena.

Equals(Object)

Determina si esta instancia y un objeto especificado, que también debe ser un objeto String, tienen el mismo valor.

Equals(String)

Determina si esta instancia y otro objeto String especificado tienen el mismo valor.

Equals(String, String)

Determina si dos objetos String especificados tienen el mismo valor.

Equals(String, String, StringComparison)

Determina si dos objetos String especificados tienen el mismo valor. 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.

Equals(String, StringComparison)

Determina si esta cadena y un objeto String especificado tienen el mismo valor. 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.

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. Un parámetro proporciona información de formato específica de la referencia cultural.

Format(IFormatProvider, String, Object, Object)

Reemplaza los elementos de formato de una cadena por la representación de cadena de dos objetos especificados. Un parámetro proporciona información de formato específica de la referencia cultural.

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

Reemplaza los elementos de formato de una cadena por la representación de cadena de tres objetos especificados. Un parámetro proporciona información de formato específica de la referencia cultural.

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. Un parámetro proporciona información de formato específica de la referencia cultural.

Format(String, Object)

Reemplaza uno o más elementos de formato de una cadena por la representación de cadena de un objeto especificado.

Format(String, Object, Object)

Reemplaza los elementos de formato de una cadena por la representación de cadena de dos objetos especificados.

Format(String, Object, Object, Object)

Reemplaza los elementos de formato de una cadena por la representación de cadena de tres objetos especificados.

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.

GetEnumerator()

Recupera un objeto que puede recorrer en iteración los caracteres individuales de esta cadena.

GetHashCode()

Devuelve el código hash para esta cadena.

GetHashCode(ReadOnlySpan<Char>)

Devuelve el código hash del intervalo de caracteres de solo lectura proporcionado.

GetHashCode(ReadOnlySpan<Char>, StringComparison)

Devuelve el código hash del intervalo de caracteres de solo lectura proporcionado mediante las reglas especificadas.

GetHashCode(StringComparison)

Devuelve el código hash de esta cadena mediante las reglas especificadas.

GetPinnableReference()

Devuelve una referencia al elemento de la cadena en el índice cero.

Este método está pensado para admitir compiladores de .NET y no está pensado para que lo llame el código de usuario.

GetType()

Obtiene el Type de la instancia actual.

(Heredado de Object)
GetTypeCode()

Devuelve la instancia de TypeCode para la clase String.

IndexOf(Char)

Devuelve el índice de base cero de la primera aparición del carácter Unicode especificado en esta cadena.

IndexOf(Char, Int32)

Devuelve el índice de base cero de la primera aparición del carácter Unicode especificado en esta cadena. La búsqueda comienza en una posición de carácter especificada.

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. La búsqueda comienza en una posición de carácter especificada y examina un número especificado de posiciones de caracteres.

IndexOf(Char, StringComparison)

Devuelve el índice de base cero de la primera aparición del carácter Unicode especificado en esta cadena. Un parámetro especifica el tipo de búsqueda que se va a usar para el carácter especificado.

IndexOf(String)

Indica el índice de base cero de la primera aparición de la cadena especificada en la instancia en cuestión.

IndexOf(String, Int32)

Indica el índice de base cero de la primera aparición de la cadena especificada en la instancia en cuestión. La búsqueda comienza en una posición de carácter especificada.

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. La búsqueda comienza en una posición de carácter especificada y examina un número especificado de posiciones de caracteres.

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. 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.

IndexOf(String, Int32, StringComparison)

Devuelve el índice de base cero de la primera aparición de la cadena especificada en el objeto String actual. 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.

IndexOf(String, StringComparison)

Devuelve el índice de base cero de la primera aparición de la cadena especificada en el objeto String actual. Un parámetro especifica el tipo de búsqueda que se va a usar para la cadena especificada.

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.

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. La búsqueda comienza en una posición de carácter especificada.

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. La búsqueda comienza en una posición de carácter especificada y examina un número especificado de posiciones de caracteres.

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.

Intern(String)

Recupera la referencia del sistema al objeto String especificado.

IsInterned(String)

Recupera una referencia a un objeto String especificado.

IsNormalized()

Indica si esta cadena tiene la forma de normalización Unicode C.

IsNormalized(NormalizationForm)

Indica si esta cadena tiene la forma de normalización Unicode especificada.

IsNullOrEmpty(String)

Indica si el valor de la cadena especificada es null o una cadena vacía ("").

IsNullOrWhiteSpace(String)

Indica si la cadena especificada es null, está vacía o consta únicamente de caracteres de espacio en blanco.

Join(Char, Object[])

Concatena las representaciones de cadena de una matriz de objetos, mediante el separador especificado entre todos los miembros.

Join(Char, String[])

Concatena una matriz de cadenas mediante el separador especificado entre todos los miembros.

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

Concatena una matriz de cadenas mediante el separador especificado entre cada miembro, empezando por el elemento en value situado en la posición startIndex y concatenando hasta count elementos.

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.

Join(String, Object[])

Concatena los elementos de una matriz de objetos, usando el separador especificado entre todos los elementos.

Join(String, String[])

Concatena todos los elementos de una matriz de cadenas, usando el separador especificado entre todos los elementos.

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

Concatena los elementos especificados de una matriz de cadenas, usando el separador indicado entre todos los elementos.

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

Concatena los miembros de una colección, usando el separador especificado entre todos los miembros.

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

Concatena los miembros de una colección, usando el separador especificado entre todos los miembros.

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.

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. 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.

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. 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.

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.

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. 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.

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. 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.

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. 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. Un parámetro especifica el tipo de comparación que se debe realizar cuando se busca la cadena especificada.

LastIndexOf(String, Int32, StringComparison)

Devuelve el índice de base cero de la última aparición de una cadena especificada dentro del objeto String actual. 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. Un parámetro especifica el tipo de comparación que se debe realizar cuando se busca la cadena especificada.

LastIndexOf(String, StringComparison)

Devuelve el índice de base cero de la última aparición de una cadena especificada dentro del objeto String actual. Un parámetro especifica el tipo de búsqueda que se va a usar para la cadena especificada.

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.

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. 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.

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. 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.

MemberwiseClone()

Crea una copia superficial del Object actual.

(Heredado de Object)
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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

Replace(String, String, Boolean, CultureInfo)

Devuelve una cadena nueva en la que todas las repeticiones de una cadena especificada en la instancia actual se reemplazan por otra cadena especificada, mediante la referencia cultural y las mayúsculas y minúsculas proporcionadas.

Replace(String, String, StringComparison)

Devuelve una cadena nueva en la que todas las repeticiones de una cadena especificada en la instancia actual se reemplazan por otra cadena especificada, mediante el tipo de comparación proporcionado.

ReplaceLineEndings()

Reemplaza todas las secuencias de nueva línea de la cadena actual por NewLine .

ReplaceLineEndings(String)

Reemplaza todas las secuencias de nueva línea de la cadena actual por replacementText .

Split(Char, Int32, StringSplitOptions)

Divide una cadena en un número máximo de subcadenas en función de un carácter de delimitación especificado y, opcionalmente, las opciones especificadas. Divide una cadena en un número máximo de subcadenas en función del separador de caracteres proporcionado y ofrece la opción de omitir las subcadenas vacías del resultado.

Split(Char, StringSplitOptions)

Divide una cadena en subcadenas en función de un carácter de delimitación especificado y, opcionalmente, las opciones especificadas.

Split(Char[])

Divide una cadena en subcadenas en función de los caracteres de delimitación especificados.

Split(Char[], Int32)

Divide una cadena en un número máximo de subcadenas en función de los caracteres de delimitación especificados.

Split(Char[], Int32, StringSplitOptions)

Divide una cadena en un número máximo de subcadenas en función de los caracteres de delimitación especificados y, opcionalmente, las opciones especificadas.

Split(Char[], StringSplitOptions)

Divide una cadena en subcadenas en función de las opciones y los caracteres de delimitación especificados.

Split(String, Int32, StringSplitOptions)

Divide una cadena en un número máximo de subcadenas en función de una cadena de delimitación especificada y, opcionalmente, las opciones especificadas.

Split(String, StringSplitOptions)

Divide una cadena en subcadenas que se basan en el separador de cadena proporcionado.

Split(String[], Int32, StringSplitOptions)

Divide una cadena en un número máximo de subcadenas en función de las cadenas de delimitación especificadas y, opcionalmente, las opciones especificadas.

Split(String[], StringSplitOptions)

Divide una cadena en subcadenas en función de una cadena de delimitación especificada y, opcionalmente, las opciones especificadas.

StartsWith(Char)

Determina si esta instancia de cadena comienza con el carácter especificado.

StartsWith(String)

Determina si el principio de esta instancia de cadena coincide con la cadena especificada.

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.

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.

Substring(Int32)

Recupera una subcadena de la instancia. La subcadena empieza en una posición de caracteres especificada y continúa hasta el final de la cadena.

Substring(Int32, Int32)

Recupera una subcadena de la instancia. La subcadena comienza en una posición de carácter especificada y tiene una longitud especificada.

ToCharArray()

Copia los caracteres de la instancia en una matriz de caracteres Unicode.

ToCharArray(Int32, Int32)

Copia los caracteres de una subcadena especificada de la instancia en una matriz de caracteres Unicode.

ToLower()

Devuelve una copia de esta cadena convertida en minúsculas.

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.

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.

ToString()

Devuelve la instancia de String; no se efectúa una conversión real.

ToString(IFormatProvider)

Devuelve la instancia de String; no se efectúa una conversión real.

ToUpper()

Devuelve una copia de esta cadena convertida en mayúsculas.

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.

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.

Trim()

Quita todos los caracteres de espacio en blanco del principio y el final de la cadena actual.

Trim(Char)

Quita todas las instancias iniciales y finales de un carácter de la cadena actual.

Trim(Char[])

Quita todas las repeticiones del principio y el final de un conjunto de caracteres especificado en una matriz de la cadena actual.

TrimEnd()

Quita todos los caracteres de espacio en blanco del final de la cadena actual.

TrimEnd(Char)

Quita todas las repeticiones finales de un carácter de la cadena actual.

TrimEnd(Char[])

Quita todas las repeticiones del final de un conjunto de caracteres especificados en una matriz de la cadena actual.

TrimStart()

Quita todos los caracteres de espacio en blanco del principio de la cadena actual.

TrimStart(Char)

Quita todas las repeticiones iniciales de un carácter especificado de la cadena actual.

TrimStart(Char[])

Quita todas las repeticiones del inicio de un conjunto de caracteres especificados en una matriz de la cadena actual.

TryCopyTo(Span<Char>)

Copia el contenido de esta cadena en el intervalo de destino.

Operadores

Equality(String, String)

Determina si dos cadenas especificadas tienen el mismo valor.

Implicit(String to ReadOnlySpan<Char>)

Define una conversión implícita de una cadena determinada en un intervalo de caracteres de solo lectura.

Inequality(String, String)

Determina si dos cadenas especificadas tienen valores diferentes.

Implementaciones de interfaz explícitas

IComparable.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.

IConvertible.GetTypeCode()

Devuelve la instancia de TypeCode para la clase String.

IConvertible.ToBoolean(IFormatProvider)

Para obtener una descripción de este miembro, vea ToBoolean(IFormatProvider).

IConvertible.ToByte(IFormatProvider)

Para obtener una descripción de este miembro, vea ToByte(IFormatProvider).

IConvertible.ToChar(IFormatProvider)

Para obtener una descripción de este miembro, vea ToChar(IFormatProvider).

IConvertible.ToDateTime(IFormatProvider)

Para obtener una descripción de este miembro, vea ToDateTime(IFormatProvider).

IConvertible.ToDecimal(IFormatProvider)

Para obtener una descripción de este miembro, vea ToDecimal(IFormatProvider).

IConvertible.ToDouble(IFormatProvider)

Para obtener una descripción de este miembro, vea ToDouble(IFormatProvider).

IConvertible.ToInt16(IFormatProvider)

Para obtener una descripción de este miembro, vea ToInt16(IFormatProvider).

IConvertible.ToInt32(IFormatProvider)

Para obtener una descripción de este miembro, vea ToInt32(IFormatProvider).

IConvertible.ToInt64(IFormatProvider)

Para obtener una descripción de este miembro, vea ToInt64(IFormatProvider).

IConvertible.ToSByte(IFormatProvider)

Para obtener una descripción de este miembro, vea ToSByte(IFormatProvider).

IConvertible.ToSingle(IFormatProvider)

Para obtener una descripción de este miembro, vea ToSingle(IFormatProvider).

IConvertible.ToString(IFormatProvider)

Para obtener una descripción de este miembro, vea ToString(IFormatProvider).

IConvertible.ToType(Type, IFormatProvider)

Para obtener una descripción de este miembro, vea ToType(Type, IFormatProvider).

IConvertible.ToUInt16(IFormatProvider)

Para obtener una descripción de este miembro, vea ToUInt16(IFormatProvider).

IConvertible.ToUInt32(IFormatProvider)

Para obtener una descripción de este miembro, vea ToUInt32(IFormatProvider).

IConvertible.ToUInt64(IFormatProvider)

Para obtener una descripción de este miembro, vea ToUInt64(IFormatProvider).

IEnumerable.GetEnumerator()

Devuelve un enumerador que recorre en iteración el objeto String actual.

IEnumerable<Char>.GetEnumerator()

Devuelve un enumerador que recorre en iteración el objeto String actual.

Métodos de extensión

ToImmutableArray<TSource>(IEnumerable<TSource>)

Crea una matriz inmutable a partir de la colección especificada.

ToImmutableDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

Crea un diccionario inmutable de una colección de elementos existente, aplicando una función de transformación en las claves de origen.

ToImmutableDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)

Crea un diccionario inmutable basado en alguna transformación de una secuencia.

ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>)

Enumera y transforma una secuencia y genera un diccionario inmutable de su contenido.

ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IEqualityComparer<TKey>)

Enumera y transforma una secuencia y genera un diccionario inmutable de su contenido mediante el comparador de claves especificado.

ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IEqualityComparer<TKey>, IEqualityComparer<TValue>)

Enumera y transforma una secuencia y genera un diccionario inmutable de su contenido mediante el comparador de claves y valores especificado.

ToImmutableHashSet<TSource>(IEnumerable<TSource>)

Enumera una secuencia y genera un conjunto hash inmutable de su contenido.

ToImmutableHashSet<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)

Enumera una secuencia, genera un conjunto hash inmutable de su contenido y usa el comparador de igualdad especificado para este tipo de conjunto.

ToImmutableList<TSource>(IEnumerable<TSource>)

Enumera una secuencia y genera una lista inmutable de su contenido.

ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>)

Enumera y transforma una secuencia y genera un diccionario ordenado inmutable de su contenido.

ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IComparer<TKey>)

Enumera y transforma una secuencia y genera un diccionario ordenado inmutable de su contenido mediante el comparador de claves especificado.

ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IComparer<TKey>, IEqualityComparer<TValue>)

Enumera y transforma una secuencia y genera un diccionario ordenador inmutable de su contenido mediante el comparador de claves y valores especificado.

ToImmutableSortedSet<TSource>(IEnumerable<TSource>)

Enumera una secuencia y genera un conjunto ordenado inmutable de su contenido.

ToImmutableSortedSet<TSource>(IEnumerable<TSource>, IComparer<TSource>)

Enumera una secuencia, genera un conjunto ordenado inmutable de su contenido y usa el comparador especificado.

CopyToDataTable<T>(IEnumerable<T>)

Devuelve un objeto DataTable que contiene copias de los objetos DataRow, dado un objeto IEnumerable<T> de entrada donde el parámetro T genérico es DataRow.

CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption)

Copia objetos DataRow en el objeto DataTable especificado, dado un objeto IEnumerable<T> de entrada donde el parámetro T genérico es DataRow.

CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler)

Copia objetos DataRow en el objeto DataTable especificado, dado un objeto IEnumerable<T> de entrada donde el parámetro T genérico es DataRow.

Aggregate<TSource>(IEnumerable<TSource>, Func<TSource,TSource,TSource>)

Aplica una función de acumulador a una secuencia.

Aggregate<TSource,TAccumulate>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>)

Aplica una función de acumulador a una secuencia. El valor de inicialización especificado se utiliza como valor de inicio del acumulador.

Aggregate<TSource,TAccumulate,TResult>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>, Func<TAccumulate,TResult>)

Aplica una función de acumulador a una secuencia. El valor de inicialización especificado se utiliza como valor inicial del acumulador y la función especificada se utiliza para seleccionar el valor resultante.

All<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Determina si todos los elementos de una secuencia satisfacen una condición.

Any<TSource>(IEnumerable<TSource>)

Determina si una secuencia contiene elementos.

Any<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Determina si algún elemento de una secuencia satisface una condición.

Append<TSource>(IEnumerable<TSource>, TSource)

Anexa un valor al final de la secuencia.

AsEnumerable<TSource>(IEnumerable<TSource>)

Devuelve la entrada con tipo como IEnumerable<T>.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)

Calcula el promedio de una secuencia de valores Decimal que se obtiene al invocar una función de transformación en cada elemento de la secuencia de entrada.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Double>)

Calcula el promedio de una secuencia de valores Double que se obtiene al invocar una función de transformación en cada elemento de la secuencia de entrada.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)

Calcula el promedio de una secuencia de valores Int32 que se obtiene al invocar una función de transformación en cada elemento de la secuencia de entrada.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)

Calcula el promedio de una secuencia de valores Int64 que se obtiene al invocar una función de transformación en cada elemento de la secuencia de entrada.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)

Calcula el promedio de una secuencia de valores Decimal que aceptan valores NULL que se obtiene al invocar una función de transformación en cada elemento de la secuencia de entrada.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)

Calcula el promedio de una secuencia de valores Double que aceptan valores NULL que se obtiene al invocar una función de transformación en cada elemento de la secuencia de entrada.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)

Calcula el promedio de una secuencia de valores Int32 que aceptan valores NULL que se obtiene al invocar una función de transformación en cada elemento de la secuencia de entrada.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)

Calcula el promedio de una secuencia de valores Int64 que aceptan valores NULL que se obtiene al invocar una función de transformación en cada elemento de la secuencia de entrada.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)

Calcula el promedio de una secuencia de valores Single que aceptan valores NULL que se obtiene al invocar una función de transformación en cada elemento de la secuencia de entrada.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Single>)

Calcula el promedio de una secuencia de valores Single que se obtiene al invocar una función de transformación en cada elemento de la secuencia de entrada.

Cast<TResult>(IEnumerable)

Convierte los elementos de IEnumerable en el tipo especificado.

Chunk<TSource>(IEnumerable<TSource>, Int32)

Divide los elementos de una secuencia en fragmentos de tamaño como máximo size.

Concat<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)

Concatena dos secuencias.

Contains<TSource>(IEnumerable<TSource>, TSource)

Determina si una secuencia contiene un elemento especificado utilizando el comparador de igualdad predeterminado.

Contains<TSource>(IEnumerable<TSource>, TSource, IEqualityComparer<TSource>)

Determina si una secuencia contiene un elemento especificado utilizando un objeto IEqualityComparer<T> determinado.

Count<TSource>(IEnumerable<TSource>)

Devuelve el número de elementos de una secuencia.

Count<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Devuelve un número que representa cuántos elementos de la secuencia especificada satisfacen una condición.

DefaultIfEmpty<TSource>(IEnumerable<TSource>)

Devuelve los elementos de la secuencia especificada o el valor predeterminado del parámetro de tipo en una colección singleton si la secuencia está vacía.

DefaultIfEmpty<TSource>(IEnumerable<TSource>, TSource)

Devuelve los elementos de la secuencia especificada o el valor especificado en una colección singleton si la secuencia está vacía.

Distinct<TSource>(IEnumerable<TSource>)

Devuelve diversos elementos de una secuencia utilizando el comparador de igualdad predeterminado para comparar los valores.

Distinct<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)

Devuelve diversos elementos de una secuencia utilizando un objeto IEqualityComparer<T> especificado para comparar los valores.

DistinctBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

Devuelve elementos distintos de una secuencia según una función de selector de claves especificada.

DistinctBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)

Devuelve distintos elementos de una secuencia según una función de selector de claves especificada y utilizando un comparador especificado para comparar claves.

ElementAt<TSource>(IEnumerable<TSource>, Index)

Devuelve el elemento situado en un índice especificado de una secuencia.

ElementAt<TSource>(IEnumerable<TSource>, Int32)

Devuelve el elemento situado en un índice especificado de una secuencia.

ElementAtOrDefault<TSource>(IEnumerable<TSource>, Index)

Devuelve el elemento situado en un índice especificado de una secuencia o un valor predeterminado si el índice está fuera del intervalo.

ElementAtOrDefault<TSource>(IEnumerable<TSource>, Int32)

Devuelve el elemento situado en un índice especificado de una secuencia o un valor predeterminado si el índice está fuera del intervalo.

Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)

Proporciona la diferencia de conjuntos de dos secuencias utilizando el comparador de igualdad predeterminado para comparar los valores.

Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)

Proporciona la diferencia de conjuntos de dos secuencias utilizando el objeto IEqualityComparer<T> especificado para comparar los valores.

ExceptBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>)

Genera la diferencia de conjunto de dos secuencias según una función de selector de claves especificada.

ExceptBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>, IEqualityComparer<TKey>)

Genera la diferencia de conjunto de dos secuencias según una función de selector de claves especificada.

First<TSource>(IEnumerable<TSource>)

Devuelve el primer elemento de una secuencia.

First<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Devuelve el primer elemento de una secuencia que satisface una condición especificada.

FirstOrDefault<TSource>(IEnumerable<TSource>)

Devuelve el primer elemento de una secuencia o un valor predeterminado si la secuencia no contiene elementos.

FirstOrDefault<TSource>(IEnumerable<TSource>, TSource)

Devuelve el primer elemento de una secuencia o un valor predeterminado especificado si la secuencia no contiene elementos.

FirstOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Devuelve el primer elemento de la secuencia que satisface una condición o un valor predeterminado si no se encuentra dicho elemento.

FirstOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>, TSource)

Devuelve el primer elemento de la secuencia que satisface una condición o un valor predeterminado especificado si no se encuentra dicho elemento.

GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

Agrupa los elementos de una secuencia según una función del selector de claves especificada.

GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)

Agrupa los elementos de una secuencia según una función del selector de claves especificada y compara las claves utilizando un comparador especificado.

GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)

Agrupa los elementos de una secuencia según una función del selector de claves especificada y proyecta los elementos de cada grupo utilizando una función determinada.

GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)

Agrupa los elementos de una secuencia conforme a una función del selector de claves. Las claves se comparan utilizando un comparador y los elementos de cada grupo se proyectan utilizando una función especificada.

GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>)

Agrupa los elementos de una secuencia según una función del selector de claves especificada y crea un valor de resultado a partir de cada grupo y su clave.

GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>, IEqualityComparer<TKey>)

Agrupa los elementos de una secuencia según una función del selector de claves especificada y crea un valor de resultado a partir de cada grupo y su clave. Las claves se comparan utilizando un comparador especificado.

GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>,TResult>)

Agrupa los elementos de una secuencia según una función del selector de claves especificada y crea un valor de resultado a partir de cada grupo y su clave. Los elementos de cada grupo se proyectan utilizando una función determinada.

GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource, TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>, TResult>, IEqualityComparer<TKey>)

Agrupa los elementos de una secuencia según una función del selector de claves especificada y crea un valor de resultado a partir de cada grupo y su clave. Los valores de las claves se comparan utilizando un comparador especificado y los elementos de cada grupo se proyectan utilizando una función especificada.

GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,IEnumerable<TInner>, TResult>)

Establece una correlación entre los elementos de dos secuencias en función de la igualdad de sus claves y agrupa los resultados. El comparador de igualdad predeterminado se usa para comparar claves.

GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,IEnumerable<TInner>, TResult>, IEqualityComparer<TKey>)

Establece una correlación entre los elementos de dos secuencias basándose en la igualdad de clave y agrupa los resultados. Se usa un IEqualityComparer<T> especificado para comparar claves.

Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)

Proporciona la intersección de conjuntos de dos secuencias utilizando el comparador de igualdad predeterminado para comparar los valores.

Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)

Proporciona la intersección de conjuntos de dos secuencias utilizando el objeto IEqualityComparer<T> especificado para comparar los valores.

IntersectBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>)

Genera la intersección de conjuntos de dos secuencias según una función de selector de claves especificada.

IntersectBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>, IEqualityComparer<TKey>)

Genera la intersección de conjuntos de dos secuencias según una función de selector de claves especificada.

Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>)

Establece la correlación de dos secuencias basándose en claves coincidentes. El comparador de igualdad predeterminado se usa para comparar claves.

Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>, IEqualityComparer<TKey>)

Establece la correlación de dos secuencias basándose en claves coincidentes. Se usa un IEqualityComparer<T> especificado para comparar claves.

Last<TSource>(IEnumerable<TSource>)

Devuelve el último elemento de una secuencia.

Last<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Devuelve el último elemento de una secuencia que satisface una condición especificada.

LastOrDefault<TSource>(IEnumerable<TSource>)

Devuelve el último elemento de una secuencia o un valor predeterminado si la secuencia no contiene elementos.

LastOrDefault<TSource>(IEnumerable<TSource>, TSource)

Devuelve el último elemento de una secuencia o un valor predeterminado especificado si la secuencia no contiene ningún elemento.

LastOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Devuelve el último elemento de una secuencia que satisface una condición o un valor predeterminado si no se encuentra dicho elemento.

LastOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>, TSource)

Devuelve el último elemento de una secuencia que satisface una condición o un valor predeterminado especificado si no se encuentra dicho elemento.

LongCount<TSource>(IEnumerable<TSource>)

Devuelve un valor Int64 que representa el número total de elementos de una secuencia.

LongCount<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Devuelve un valor Int64 que representa el número de elementos de una secuencia que satisfacen una condición.

Max<TSource>(IEnumerable<TSource>)

Devuelve el valor máximo de una secuencia genérica.

Max<TSource>(IEnumerable<TSource>, IComparer<TSource>)

Devuelve el valor máximo de una secuencia genérica.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)

Invoca una función de transformación en cada elemento de una secuencia y devuelve el valor Decimal máximo.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Double>)

Invoca una función de transformación en cada elemento de una secuencia y devuelve el valor Double máximo.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)

Invoca una función de transformación en cada elemento de una secuencia y devuelve el valor Int32 máximo.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)

Invoca una función de transformación en cada elemento de una secuencia y devuelve el valor Int64 máximo.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)

Invoca una función de transformación en cada elemento de una secuencia y devuelve el valor Decimal máximo que acepta valores NULL.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)

Invoca una función de transformación en cada elemento de una secuencia y devuelve el valor Double máximo que acepta valores NULL.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)

Invoca una función de transformación en cada elemento de una secuencia y devuelve el valor Int32 máximo que acepta valores NULL.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)

Invoca una función de transformación en cada elemento de una secuencia y devuelve el valor Int64 máximo que acepta valores NULL.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)

Invoca una función de transformación en cada elemento de una secuencia y devuelve el valor Single máximo que acepta valores NULL.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Single>)

Invoca una función de transformación en cada elemento de una secuencia y devuelve el valor Single máximo.

Max<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)

Invoca una función de transformación en cada elemento de una secuencia genérica y devuelve el valor máximo resultante.

MaxBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

Devuelve el valor máximo de una secuencia genérica según una función de selector de claves especificada.

MaxBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)

Devuelve el valor máximo de una secuencia genérica según una función de selector de claves y un comparador de claves especificados.

Min<TSource>(IEnumerable<TSource>)

Devuelve el valor mínimo de una secuencia genérica.

Min<TSource>(IEnumerable<TSource>, IComparer<TSource>)

Devuelve el valor mínimo de una secuencia genérica.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)

Invoca una función de transformación en cada elemento de una secuencia y devuelve el valor Decimal mínimo.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Double>)

Invoca una función de transformación en cada elemento de una secuencia y devuelve el valor Double mínimo.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)

Invoca una función de transformación en cada elemento de una secuencia y devuelve el valor Int32 mínimo.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)

Invoca una función de transformación en cada elemento de una secuencia y devuelve el valor Int64 mínimo.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)

Invoca una función de transformación en cada elemento de una secuencia y devuelve el valor Decimal mínimo que acepta valores NULL.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)

Invoca una función de transformación en cada elemento de una secuencia y devuelve el valor Double mínimo que acepta valores NULL.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)

Invoca una función de transformación en cada elemento de una secuencia y devuelve el valor Int32 mínimo que acepta valores NULL.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)

Invoca una función de transformación en cada elemento de una secuencia y devuelve el valor Int64 mínimo que acepta valores NULL.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)

Invoca una función de transformación en cada elemento de una secuencia y devuelve el valor Single mínimo que acepta valores NULL.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Single>)

Invoca una función de transformación en cada elemento de una secuencia y devuelve el valor Single mínimo.

Min<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)

Invoca una función de transformación en cada elemento de una secuencia genérica y devuelve el valor mínimo resultante.

MinBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

Devuelve el valor mínimo de una secuencia genérica según una función de selector de claves especificada.

MinBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)

Devuelve el valor mínimo de una secuencia genérica según una función de selector de claves y un comparador de claves especificados.

OfType<TResult>(IEnumerable)

Filtra los elementos de IEnumerable en función de un tipo especificado.

OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

Ordena de manera ascendente los elementos de una secuencia en función de una clave.

OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)

Ordena de manera ascendente los elementos de una secuencia utilizando un comparador especificado.

OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

Ordena de manera descendente los elementos de una secuencia en función de una clave.

OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)

Ordena de manera descendente los elementos de una secuencia utilizando un comparador especificado.

Prepend<TSource>(IEnumerable<TSource>, TSource)

Agrega un valor al principio de la secuencia.

Reverse<TSource>(IEnumerable<TSource>)

Invierte el orden de los elementos de una secuencia.

Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)

Proyecta cada elemento de una secuencia a un nuevo formulario.

Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,TResult>)

Proyecta cada elemento de una secuencia en un nuevo formulario incorporando el índice del elemento.

SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>)

Proyecta cada elemento de una secuencia en una interfaz IEnumerable<T> y reduce las secuencias resultantes en una secuencia.

SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>)

Proyecta cada elemento de una secuencia en una interfaz IEnumerable<T> y reduce las secuencias resultantes en una secuencia. El índice de cada elemento de origen se utiliza en el formulario proyectado de ese elemento.

SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>)

Proyecta cada elemento de una secuencia en IEnumerable<T>, reduce las secuencias resultantes en una única secuencia e invoca una función del selector de resultados en cada elemento.

SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>)

Proyecta cada elemento de una secuencia en IEnumerable<T>, reduce las secuencias resultantes en una única secuencia e invoca una función del selector de resultados en cada elemento. El índice de cada elemento de origen se utiliza en el formulario proyectado intermedio de ese elemento.

SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)

Determina si dos secuencias son iguales; para ello, se comparan sus elementos mediante el comparador de igualdad predeterminado para su tipo.

SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)

Determina si dos secuencias son iguales; para ello, compara sus elementos utilizando una interfaz IEqualityComparer<T> especificada.

Single<TSource>(IEnumerable<TSource>)

Devuelve el único elemento de una secuencia y produce una excepción si no hay exactamente un elemento en la secuencia.

Single<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Devuelve el único elemento de una secuencia que cumpla una condición especificada y produce una excepción si existe más de un elemento de este tipo.

SingleOrDefault<TSource>(IEnumerable<TSource>)

Devuelve el único elemento de una secuencia o un valor predeterminado si la secuencia está vacía; este método produce una excepción si hay más de un elemento en la secuencia.

SingleOrDefault<TSource>(IEnumerable<TSource>, TSource)

Devuelve el único elemento de una secuencia o un valor predeterminado especificado si la secuencia está vacía; Este método produce una excepción si hay más de un elemento en la secuencia.

SingleOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Devuelve el único elemento de una secuencia que cumpla la condición especificada, o bien, un valor predeterminado si ese elemento no existe; este método produce una excepción si varios elementos cumplen la condición.

SingleOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>, TSource)

Devuelve el único elemento de una secuencia que satisface una condición especificada o un valor predeterminado especificado si no existe dicho elemento; Este método produce una excepción si más de un elemento cumple la condición.

Skip<TSource>(IEnumerable<TSource>, Int32)

Omite un número especificado de elementos en una secuencia y luego devuelve los elementos restantes.

SkipLast<TSource>(IEnumerable<TSource>, Int32)

Devuelve una nueva colección que contiene los elementos de source con los últimos elementos de count de la colección de origen omitida.

SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Omite los elementos de una secuencia en tanto que el valor de una condición especificada sea true y luego devuelve los elementos restantes.

SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)

Omite los elementos de una secuencia en tanto que el valor de una condición especificada sea true y luego devuelve los elementos restantes. El índice del elemento se usa en la lógica de la función de predicado.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)

Calcula la suma de una secuencia de valores Decimal que se obtiene al invocar una función de transformación en cada elemento de la secuencia de entrada.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>)

Calcula la suma de una secuencia de valores Double que se obtiene al invocar una función de transformación en cada elemento de la secuencia de entrada.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)

Calcula la suma de una secuencia de valores Int32 que se obtiene al invocar una función de transformación en cada elemento de la secuencia de entrada.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)

Calcula la suma de una secuencia de valores Int64 que se obtiene al invocar una función de transformación en cada elemento de la secuencia de entrada.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)

Calcula la suma de una secuencia de valores Decimal que aceptan valores NULL que se obtiene al invocar una función de transformación en cada elemento de la secuencia de entrada.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)

Calcula la suma de una secuencia de valores Double que aceptan valores NULL que se obtiene al invocar una función de transformación en cada elemento de la secuencia de entrada.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)

Calcula la suma de una secuencia de valores Int32 que aceptan valores NULL que se obtiene al invocar una función de transformación en cada elemento de la secuencia de entrada.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)

Calcula la suma de una secuencia de valores Int64 que aceptan valores NULL que se obtiene al invocar una función de transformación en cada elemento de la secuencia de entrada.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)

Calcula la suma de una secuencia de valores Single que aceptan valores NULL que se obtiene al invocar una función de transformación en cada elemento de la secuencia de entrada.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Single>)

Calcula la suma de una secuencia de valores Single que se obtiene al invocar una función de transformación en cada elemento de la secuencia de entrada.

Take<TSource>(IEnumerable<TSource>, Int32)

Devuelve un número especificado de elementos contiguos desde el principio de una secuencia.

Take<TSource>(IEnumerable<TSource>, Range)

Devuelve un intervalo especificado de elementos contiguos de una secuencia.

TakeLast<TSource>(IEnumerable<TSource>, Int32)

Devuelve una nueva colección enumerable que contiene los últimos elementos count de source.

TakeWhile<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Devuelve los elementos de una secuencia en tanto que el valor de una condición especificada sea true.

TakeWhile<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)

Devuelve los elementos de una secuencia en tanto que el valor de una condición especificada sea true. El índice del elemento se usa en la lógica de la función de predicado.

ToArray<TSource>(IEnumerable<TSource>)

Crea una matriz a partir de un IEnumerable<T>.

ToDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

Crea una clase Dictionary<TKey,TValue> a partir de una interfaz IEnumerable<T> según una función del selector de claves especificada.

ToDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)

Crea un objeto Dictionary<TKey,TValue> a partir de un objeto IEnumerable<T> según una función del selector de claves especificada y el comparador de claves.

ToDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)

Crea un objeto Dictionary<TKey,TValue> a partir de un objeto IEnumerable<T> según el selector de claves especificado y las funciones del selector de elementos.

ToDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)

Crea un objeto Dictionary<TKey,TValue> a partir de un objeto IEnumerable<T> según una función del selector de claves especificada, un comparador y una función del selector de elementos.

ToHashSet<TSource>(IEnumerable<TSource>)

Crea un HashSet<T> a partir de un IEnumerable<T>.

ToHashSet<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)

Crea un objeto HashSet<T> a partir de una instancia de IEnumerable<T> mediante comparer para comparar claves.

ToList<TSource>(IEnumerable<TSource>)

Crea un List<T> a partir de un IEnumerable<T>.

ToLookup<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

Crea una clase Lookup<TKey,TElement> a partir de una interfaz IEnumerable<T> según una función del selector de claves especificada.

ToLookup<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)

Crea un objeto Lookup<TKey,TElement> a partir de un objeto IEnumerable<T> según una función del selector de claves especificada y el comparador de claves.

ToLookup<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)

Crea un objeto Lookup<TKey,TElement> a partir de un objeto IEnumerable<T> según el selector de claves especificado y las funciones del selector de elementos.

ToLookup<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)

Crea un objeto Lookup<TKey,TElement> a partir de un objeto IEnumerable<T> según una función del selector de claves, un comparador y una función del selector de elementos especificados.

TryGetNonEnumeratedCount<TSource>(IEnumerable<TSource>, Int32)

Intenta determinar el número de elementos de una secuencia sin forzar una enumeración.

Union<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)

Proporciona la unión de conjuntos de dos secuencias utilizando el comparador de igualdad predeterminado.

Union<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)

Proporciona la unión de conjuntos de dos secuencias a través de un objeto IEqualityComparer<T> especificado.

UnionBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TSource>, Func<TSource,TKey>)

Genera la unión de conjunto de dos secuencias según una función de selector de claves especificada.

UnionBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)

Genera la unión de conjunto de dos secuencias según una función de selector de claves especificada.

Where<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Filtra una secuencia de valores en función de un predicado.

Where<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)

Filtra una secuencia de valores en función de un predicado. El índice de cada elemento se usa en la lógica de la función de predicado.

Zip<TFirst,TSecond>(IEnumerable<TFirst>, IEnumerable<TSecond>)

Genera una secuencia de tuplas con elementos a partir de las dos secuencias especificadas.

Zip<TFirst,TSecond,TThird>(IEnumerable<TFirst>, IEnumerable<TSecond>, IEnumerable<TThird>)

Genera una secuencia de tuplas con elementos de las tres secuencias especificadas.

Zip<TFirst,TSecond,TResult>(IEnumerable<TFirst>, IEnumerable<TSecond>, Func<TFirst,TSecond,TResult>)

Aplica la función especificada a los elementos correspondientes de dos secuencias, lo que genera una secuencia de resultados.

AsParallel(IEnumerable)

Habilita la paralelización de una consulta.

AsParallel<TSource>(IEnumerable<TSource>)

Habilita la paralelización de una consulta.

AsQueryable(IEnumerable)

Convierte una interfaz IEnumerable en IQueryable.

AsQueryable<TElement>(IEnumerable<TElement>)

Convierte un parámetro IEnumerable<T> genérico en un parámetro IQueryable<T> genérico.

AsMemory(String)

Crea un objeto ReadOnlyMemory<Char> en la parte de la cadena de destino.

AsMemory(String, Index)

Crea un objeto ReadOnlyMemory<Char> en una parte de la cadena de destino a partir de un índice especificado.

AsMemory(String, Int32)

Crea un objeto ReadOnlyMemory<Char> en una parte de la cadena de destino a partir de una posición de caracteres especificada.

AsMemory(String, Int32, Int32)

Crea un objeto ReadOnlyMemory<Char> en una parte de la cadena de destino a partir de una posición especificada con una longitud.

AsMemory(String, Range)

Crea un objeto ReadOnlyMemory<Char> en un intervalo especificado de la cadena de destino.

AsSpan(String)

Crea un intervalo de solo lectura en una cadena.

AsSpan(String, Int32)

Crea un intervalo de solo lectura en una parte de la cadena de destino desde una posición especificada hasta el final de la cadena.

AsSpan(String, Int32, Int32)

Crea un intervalo de solo lectura en una parte de la cadena de destino a partir de una posición especificada y con un número de caracteres especificado.

IsNormalized(String)

Indica si la cadena especificada tiene la forma de normalización C de Unicode.

IsNormalized(String, NormalizationForm)

Indica si una cadena tiene la forma de normalización Unicode especificada o no.

Normalize(String)

Normaliza una cadena a una forma de normalización C de Unicode.

Normalize(String, NormalizationForm)

Normaliza una cadena a la forma de normalización Unicode especificada.

Ancestors<T>(IEnumerable<T>)

Devuelve una colección de elementos que contiene los antecesores de todos los nodos de la colección de origen.

Ancestors<T>(IEnumerable<T>, XName)

Devuelve una colección de elementos filtrada que contiene los antecesores de todos los nodos de la colección de origen. En la colección sólo se incluyen los elementos que tienen un objeto XName coincidente.

DescendantNodes<T>(IEnumerable<T>)

Devuelve una colección de los nodos descendientes de todos los documentos y elementos de la colección de origen.

Descendants<T>(IEnumerable<T>)

Devuelve una colección de elementos que contiene los elementos descendientes de todos los elementos y documentos de la colección de origen.

Descendants<T>(IEnumerable<T>, XName)

Devuelve una colección filtrada de elementos que contiene los elementos descendientes de todos los elementos y documentos de la colección de origen. En la colección sólo se incluyen los elementos que tienen un objeto XName coincidente.

Elements<T>(IEnumerable<T>)

Devuelve una colección de los elementos secundarios de todos los elementos y documentos de la colección de origen.

Elements<T>(IEnumerable<T>, XName)

Devuelve una colección filtrada de los elementos secundarios de todos los elementos y documentos de la colección de origen. En la colección sólo se incluyen los elementos que tienen un objeto XName coincidente.

InDocumentOrder<T>(IEnumerable<T>)

Devuelve una colección de nodos que contiene todos los nodos de la colección de origen, clasificados por documento.

Nodes<T>(IEnumerable<T>)

Devuelve una colección de los nodos secundarios de todos los documentos y elementos de la colección de origen.

Remove<T>(IEnumerable<T>)

Quita todos los nodos de la colección de origen de su nodo primario.

Se aplica a

Seguridad para subprocesos

Este tipo es seguro para la ejecución de subprocesos.

Consulte también