Char Estructura

Definición

Espacio de nombres:

System

Ensamblado:

System.Runtime.dll

Ensamblado:

netstandard.dll

Ensamblado:

mscorlib.dll

Representa un carácter como unidad de código UTF-16.

public value class char : IComparable, IComparable<char>, IConvertible, IEquatable<char>

public value class char : IComparable, IComparable<char>, IConvertible, IEquatable<char>, ISpanFormattable

public value class char : IComparable, IConvertible

public value class char : IComparable, IComparable<char>, IEquatable<char>

public struct Char : IComparable, IComparable<char>, IConvertible, IEquatable<char>

public struct Char : IComparable, IComparable<char>, IConvertible, IEquatable<char>, ISpanFormattable

[System.Serializable]
public struct Char : IComparable, IConvertible

[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public struct Char : IComparable, IComparable<char>, IConvertible, IEquatable<char>

public struct Char : IComparable, IComparable<char>, IEquatable<char>

type char = struct
    interface IConvertible

type char = struct
    interface IConvertible
    interface ISpanFormattable
    interface IFormattable

[<System.Serializable>]
type char = struct
    interface IConvertible

[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type char = struct
    interface IConvertible

type char = struct

Public Structure Char
Implements IComparable, IComparable(Of Char), IConvertible, IEquatable(Of Char)

Public Structure Char
Implements IComparable, IComparable(Of Char), IConvertible, IEquatable(Of Char), ISpanFormattable

Public Structure Char
Implements IComparable, IConvertible

Public Structure Char
Implements IComparable, IComparable(Of Char), IEquatable(Of Char)

Herencia

Object

ValueType

Char

Atributos

SerializableAttribute ComVisibleAttribute

Implementaciones

IComparable IComparable<Char> IConvertible IEquatable<Char> IFormattable ISpanFormattable

Ejemplos

En el ejemplo de código siguiente se muestran algunos de los métodos de Char .

using namespace System;
int main()
{
   char chA = 'A';
   char ch1 = '1';
   String^ str =  "test string";
   Console::WriteLine( chA.CompareTo( 'B' ) ); // Output: "-1" (meaning 'A' is 1 less than 'B')
   Console::WriteLine( chA.Equals( 'A' ) ); // Output: "True"
   Console::WriteLine( Char::GetNumericValue( ch1 ) ); // Output: "1"
   Console::WriteLine( Char::IsControl( '\t' ) ); // Output: "True"
   Console::WriteLine( Char::IsDigit( ch1 ) ); // Output: "True"
   Console::WriteLine( Char::IsLetter( ',' ) ); // Output: "False"
   Console::WriteLine( Char::IsLower( 'u' ) ); // Output: "True"
   Console::WriteLine( Char::IsNumber( ch1 ) ); // Output: "True"
   Console::WriteLine( Char::IsPunctuation( '.' ) ); // Output: "True"
   Console::WriteLine( Char::IsSeparator( str, 4 ) ); // Output: "True"
   Console::WriteLine( Char::IsSymbol( '+' ) ); // Output: "True"
   Console::WriteLine( Char::IsWhiteSpace( str, 4 ) ); // Output: "True"
   Console::WriteLine( Char::Parse(  "S" ) ); // Output: "S"
   Console::WriteLine( Char::ToLower( 'M' ) ); // Output: "m"
   Console::WriteLine( 'x' ); // Output: "x"
}

using System;

public class CharStructureSample
{
    public static void Main()
    {
        char chA = 'A';
        char ch1 = '1';
        string str = "test string";

        Console.WriteLine(chA.CompareTo('B'));          //-----------  Output: "-1" (meaning 'A' is 1 less than 'B')
        Console.WriteLine(chA.Equals('A'));             //-----------  Output: "True"
        Console.WriteLine(Char.GetNumericValue(ch1));   //-----------  Output: "1"
        Console.WriteLine(Char.IsControl('\t'));        //-----------  Output: "True"
        Console.WriteLine(Char.IsDigit(ch1));           //-----------  Output: "True"
        Console.WriteLine(Char.IsLetter(','));          //-----------  Output: "False"
        Console.WriteLine(Char.IsLower('u'));           //-----------  Output: "True"
        Console.WriteLine(Char.IsNumber(ch1));          //-----------  Output: "True"
        Console.WriteLine(Char.IsPunctuation('.'));     //-----------  Output: "True"
        Console.WriteLine(Char.IsSeparator(str, 4));    //-----------  Output: "True"
        Console.WriteLine(Char.IsSymbol('+'));          //-----------  Output: "True"
        Console.WriteLine(Char.IsWhiteSpace(str, 4));   //-----------  Output: "True"
        Console.WriteLine(Char.Parse("S"));             //-----------  Output: "S"
        Console.WriteLine(Char.ToLower('M'));           //-----------  Output: "m"
        Console.WriteLine('x'.ToString());              //-----------  Output: "x"
    }
}

open System

let chA = 'A'
let ch1 = '1'
let str = "test string"

printfn $"{chA.CompareTo 'B'}"          //-----------  Output: "-1" (meaning 'A' is 1 less than 'B')
printfn $"{chA.Equals 'A'}"             //-----------  Output: "True"
printfn $"{Char.GetNumericValue ch1}"   //-----------  Output: "1"
printfn $"{Char.IsControl '\t'}"        //-----------  Output: "True"
printfn $"{Char.IsDigit ch1}"           //-----------  Output: "True"
printfn $"{Char.IsLetter ','}"          //-----------  Output: "False"
printfn $"{Char.IsLower 'u'}"           //-----------  Output: "True"
printfn $"{Char.IsNumber ch1}"          //-----------  Output: "True"
printfn $"{Char.IsPunctuation '.'}"     //-----------  Output: "True"
printfn $"{Char.IsSeparator(str, 4)}"   //-----------  Output: "True"
printfn $"{Char.IsSymbol '+'}"          //-----------  Output: "True"
printfn $"{Char.IsWhiteSpace(str, 4)}"  //-----------  Output: "True"
printfn $"""{Char.Parse "S"}"""         //-----------  Output: "S"
printfn $"{Char.ToLower 'M'}"           //-----------  Output: "m"
printfn $"{'x'}"                        //-----------  Output: "x"

Module CharStructure

    Public Sub Main()

        Dim chA As Char
        chA = "A"c
        Dim ch1 As Char
        ch1 = "1"c
        Dim str As String
        str = "test string"

        Console.WriteLine(chA.CompareTo("B"c))          ' Output: "-1" (meaning 'A' is 1 less than 'B')
        Console.WriteLine(chA.Equals("A"c))             ' Output: "True"
        Console.WriteLine(Char.GetNumericValue(ch1))    ' Output: "1"
        Console.WriteLine(Char.IsControl(Chr(9)))       ' Output: "True"
        Console.WriteLine(Char.IsDigit(ch1))            ' Output: "True"
        Console.WriteLine(Char.IsLetter(","c))          ' Output: "False"
        Console.WriteLine(Char.IsLower("u"c))           ' Output: "True"
        Console.WriteLine(Char.IsNumber(ch1))           ' Output: "True"
        Console.WriteLine(Char.IsPunctuation("."c))     ' Output: "True"
        Console.WriteLine(Char.IsSeparator(str, 4))     ' Output: "True"
        Console.WriteLine(Char.IsSymbol("+"c))          ' Output: "True"
        Console.WriteLine(Char.IsWhiteSpace(str, 4))    ' Output: "True"
        Console.WriteLine(Char.Parse("S"))              ' Output: "S"
        Console.WriteLine(Char.ToLower("M"c))           ' Output: "m"
        Console.WriteLine("x"c.ToString())              ' Output: "x"

    End Sub

End Module

Comentarios

.NET usa la Char estructura para representar puntos de código Unicode mediante la codificación UTF-16. El valor de un Char objeto es su valor numérico (ordinal) de 16 bits.

Si no está familiarizado con Unicode, los valores escalares, los puntos de código, los pares suplentes, UTF-16 y el tipo, consulte Introducción a la codificación de caracteres en Rune .NET.

En las secciones siguientes se examina la relación entre un objeto y un carácter y se Char analizan algunas tareas comunes realizadas con Char instancias de . Se recomienda considerar el tipo, introducido en Rune .NET Core 3.0, como alternativa a para realizar Char algunas de estas tareas.

• Objetos Char, caracteres Unicode y cadenas
• Categorías de caracteres y caracteres
• Caracteres y elementos de texto
• Operaciones comunes
• Valores char e interoperabilidad

Objetos Char, caracteres Unicode y cadenas

Un String objeto es una colección secuencial de estructuras que representa una cadena de Char texto. La mayoría de los caracteres Unicode se pueden representar mediante un único objeto, pero un carácter codificado como un carácter base, un par suplente o una secuencia de caracteres combinados se representa mediante Char varios Char objetos. Por esta razón, una estructura de un objeto no es necesariamente Char equivalente a un único carácter String Unicode.

Se usan varias unidades de código de 16 bits para representar caracteres Unicode únicos en los casos siguientes:

• Glifos, que pueden constar de un solo carácter o de un carácter base seguido de uno o varios caracteres combinados. Por ejemplo, el carácter mente está representado por un objeto cuya unidad de código es U+0061 seguida de un objeto cuya unidad de código es Char Char U+0308. (El carácter ): también se puede definir mediante un único objeto que tiene una unidad de código Char de U+00E4). En el ejemplo siguiente se muestra que el carácter ntes consta de dos Char objetos .

  using System;
  using System.IO;
  
  public class Example
  {
     public static void Main()
     {
        StreamWriter sw = new StreamWriter("chars1.txt");
        char[] chars = { '\u0061', '\u0308' };
        string strng = new String(chars);
        sw.WriteLine(strng);
        sw.Close();
     }
  }
  // The example produces the following output:
  //       ä
  

  open System
  open System.IO
  
  let sw = new StreamWriter("chars1.txt")
  let chars = [| '\u0061'; '\u0308' |]
  let string = String chars
  sw.WriteLine string
  sw.Close()
  
  // The example produces the following output:
  //       ä
  

  Imports System.IO
  
  Module Example
     Public Sub Main()
        Dim sw As New StreamWriter("chars1.txt")
        Dim chars() As Char = { ChrW(&h0061), ChrW(&h0308) }
        Dim strng As New String(chars)
        sw.WriteLine(strng) 
        sw.Close()
     End Sub
  End Module
  ' The example produces the following output:
  '       ä
  

• Caracteres fuera del plano multilingüe básico (BMP) unicode. Unicode admite dieciséis planos además del BMP, que representa el plano 0. Un punto de código Unicode se representa en UTF-32 mediante un valor de 21 bits que incluye el plano. Por ejemplo, U+1D160 representa el carácter DE LA NOTA DE OCHO SÍMBOLOS DE MÚSICA. Dado que la codificación UTF-16 solo tiene 16 bits, los caracteres fuera de BMP se representan mediante pares suplentes en UTF-16. En el ejemplo siguiente se muestra que el equivalente UTF-32 de U+1D160, el carácter DE OCHO NOTAS DEL SÍMBOLO MUSICAL, es U+D834 U+DD60. U+D834 es el suplente alto; los suplentes altos van desde U+D800 hasta U+DBFF. U+DD60 es el suplente bajo; los suplentes bajos van desde U+DC00 hasta U+DFFF.

  using System;
  using System.IO;
  
  public class Example
  {
     public static void Main()
     {
        StreamWriter sw = new StreamWriter(@".\chars2.txt");
        int utf32 = 0x1D160;
        string surrogate = Char.ConvertFromUtf32(utf32);
        sw.WriteLine("U+{0:X6} UTF-32 = {1} ({2}) UTF-16",
                     utf32, surrogate, ShowCodePoints(surrogate));
        sw.Close();
     }
  
     private static string ShowCodePoints(string value)
     {
        string retval = null;
        foreach (var ch in value)
           retval += String.Format("U+{0:X4} ", Convert.ToUInt16(ch));
  
        return retval.Trim();
     }
  }
  // The example produces the following output:
  //       U+01D160 UTF-32 = ð (U+D834 U+DD60) UTF-16
  

  open System
  open System.IO
  
  let showCodePoints (value: char seq) =
      let str =
          value
          |> Seq.map (fun ch -> $"U+{Convert.ToUInt16 ch:X4}")
          |> String.concat ""
      str.Trim()
  
  let sw = new StreamWriter(@".\chars2.txt")
  let utf32 = 0x1D160
  let surrogate = Char.ConvertFromUtf32 utf32
  sw.WriteLine $"U+{utf32:X6} UTF-32 = {surrogate} ({showCodePoints surrogate}) UTF-16"
  sw.Close()
  
  // The example produces the following output:
  //       U+01D160 UTF-32 = ð (U+D834 U+DD60) UTF-16
  

  Imports System.IO
  
  Module Example
     Public Sub Main()
        Dim sw As New StreamWriter(".\chars2.txt")
        Dim utf32 As Integer = &h1D160
        Dim surrogate As String = Char.ConvertFromUtf32(utf32)
        sw.WriteLine("U+{0:X6} UTF-32 = {1} ({2}) UTF-16", 
                     utf32, surrogate, ShowCodePoints(surrogate))
        sw.Close()                    
     End Sub
  
     Private Function ShowCodePoints(value As String) As String
        Dim retval As String = Nothing
        For Each ch In value
           retval += String.Format("U+{0:X4} ", Convert.ToUInt16(ch))
        Next
        Return retval.Trim()
     End Function
  End Module
  ' The example produces the following output:
  '       U+01D160 UTF-32 = ð (U+D834 U+DD60) UTF-16
  

Categorías de caracteres y caracteres

Cada carácter Unicode o par suplente válido pertenece a una categoría Unicode. En .NET, las categorías Unicode se representan mediante miembros de la enumeración e incluyen valores como UnicodeCategory , y , por UnicodeCategory.CurrencySymbol UnicodeCategory.LowercaseLetter UnicodeCategory.SpaceSeparator ejemplo.

Para determinar la categoría Unicode de un carácter, llame al GetUnicodeCategory método . Por ejemplo, en el ejemplo siguiente se llama GetUnicodeCategory a para mostrar la categoría Unicode de cada carácter de una cadena. El ejemplo solo funciona correctamente si no hay pares suplentes en la String instancia.

using System;
using System.Globalization;

class Example
{
   public static void Main()
   {
      // Define a string with a variety of character categories.
      String s = "The red car drove down the long, narrow, secluded road.";
      // Determine the category of each character.
      foreach (var ch in s)
         Console.WriteLine("'{0}': {1}", ch, Char.GetUnicodeCategory(ch));
   }
}
// The example displays the following output:
//      'T': UppercaseLetter
//      'h': LowercaseLetter
//      'e': LowercaseLetter
//      ' ': SpaceSeparator
//      'r': LowercaseLetter
//      'e': LowercaseLetter
//      'd': LowercaseLetter
//      ' ': SpaceSeparator
//      'c': LowercaseLetter
//      'a': LowercaseLetter
//      'r': LowercaseLetter
//      ' ': SpaceSeparator
//      'd': LowercaseLetter
//      'r': LowercaseLetter
//      'o': LowercaseLetter
//      'v': LowercaseLetter
//      'e': LowercaseLetter
//      ' ': SpaceSeparator
//      'd': LowercaseLetter
//      'o': LowercaseLetter
//      'w': LowercaseLetter
//      'n': LowercaseLetter
//      ' ': SpaceSeparator
//      't': LowercaseLetter
//      'h': LowercaseLetter
//      'e': LowercaseLetter
//      ' ': SpaceSeparator
//      'l': LowercaseLetter
//      'o': LowercaseLetter
//      'n': LowercaseLetter
//      'g': LowercaseLetter
//      ',': OtherPunctuation
//      ' ': SpaceSeparator
//      'n': LowercaseLetter
//      'a': LowercaseLetter
//      'r': LowercaseLetter
//      'r': LowercaseLetter
//      'o': LowercaseLetter
//      'w': LowercaseLetter
//      ',': OtherPunctuation
//      ' ': SpaceSeparator
//      's': LowercaseLetter
//      'e': LowercaseLetter
//      'c': LowercaseLetter
//      'l': LowercaseLetter
//      'u': LowercaseLetter
//      'd': LowercaseLetter
//      'e': LowercaseLetter
//      'd': LowercaseLetter
//      ' ': SpaceSeparator
//      'r': LowercaseLetter
//      'o': LowercaseLetter
//      'a': LowercaseLetter
//      'd': LowercaseLetter
//      '.': OtherPunctuation

open System

// Define a string with a variety of character categories.
let s = "The red car drove down the long, narrow, secluded road."
// Determine the category of each character.
for ch in s do
    printfn $"'{ch}': {Char.GetUnicodeCategory ch}"

// The example displays the following output:
//      'T': UppercaseLetter
//      'h': LowercaseLetter
//      'e': LowercaseLetter
//      ' ': SpaceSeparator
//      'r': LowercaseLetter
//      'e': LowercaseLetter
//      'd': LowercaseLetter
//      ' ': SpaceSeparator
//      'c': LowercaseLetter
//      'a': LowercaseLetter
//      'r': LowercaseLetter
//      ' ': SpaceSeparator
//      'd': LowercaseLetter
//      'r': LowercaseLetter
//      'o': LowercaseLetter
//      'v': LowercaseLetter
//      'e': LowercaseLetter
//      ' ': SpaceSeparator
//      'd': LowercaseLetter
//      'o': LowercaseLetter
//      'w': LowercaseLetter
//      'n': LowercaseLetter
//      ' ': SpaceSeparator
//      't': LowercaseLetter
//      'h': LowercaseLetter
//      'e': LowercaseLetter
//      ' ': SpaceSeparator
//      'l': LowercaseLetter
//      'o': LowercaseLetter
//      'n': LowercaseLetter
//      'g': LowercaseLetter
//      ',': OtherPunctuation
//      ' ': SpaceSeparator
//      'n': LowercaseLetter
//      'a': LowercaseLetter
//      'r': LowercaseLetter
//      'r': LowercaseLetter
//      'o': LowercaseLetter
//      'w': LowercaseLetter
//      ',': OtherPunctuation
//      ' ': SpaceSeparator
//      's': LowercaseLetter
//      'e': LowercaseLetter
//      'c': LowercaseLetter
//      'l': LowercaseLetter
//      'u': LowercaseLetter
//      'd': LowercaseLetter
//      'e': LowercaseLetter
//      'd': LowercaseLetter
//      ' ': SpaceSeparator
//      'r': LowercaseLetter
//      'o': LowercaseLetter
//      'a': LowercaseLetter
//      'd': LowercaseLetter
//      '.': OtherPunctuation

Imports System.Globalization

Module Example
   Public Sub Main()
      ' Define a string with a variety of character categories.
      Dim s As String = "The car drove down the narrow, secluded road."
      ' Determine the category of each character.
      For Each ch In s
         Console.WriteLine("'{0}': {1}", ch, Char.GetUnicodeCategory(ch)) 
      Next
   End Sub
End Module
' The example displays the following output:
'       'T': UppercaseLetter
'       'h': LowercaseLetter
'       'e': LowercaseLetter
'       ' ': SpaceSeparator
'       'r': LowercaseLetter
'       'e': LowercaseLetter
'       'd': LowercaseLetter
'       ' ': SpaceSeparator
'       'c': LowercaseLetter
'       'a': LowercaseLetter
'       'r': LowercaseLetter
'       ' ': SpaceSeparator
'       'd': LowercaseLetter
'       'r': LowercaseLetter
'       'o': LowercaseLetter
'       'v': LowercaseLetter
'       'e': LowercaseLetter
'       ' ': SpaceSeparator
'       'd': LowercaseLetter
'       'o': LowercaseLetter
'       'w': LowercaseLetter
'       'n': LowercaseLetter
'       ' ': SpaceSeparator
'       't': LowercaseLetter
'       'h': LowercaseLetter
'       'e': LowercaseLetter
'       ' ': SpaceSeparator
'       'l': LowercaseLetter
'       'o': LowercaseLetter
'       'n': LowercaseLetter
'       'g': LowercaseLetter
'       ',': OtherPunctuation
'       ' ': SpaceSeparator
'       'n': LowercaseLetter
'       'a': LowercaseLetter
'       'r': LowercaseLetter
'       'r': LowercaseLetter
'       'o': LowercaseLetter
'       'w': LowercaseLetter
'       ',': OtherPunctuation
'       ' ': SpaceSeparator
'       's': LowercaseLetter
'       'e': LowercaseLetter
'       'c': LowercaseLetter
'       'l': LowercaseLetter
'       'u': LowercaseLetter
'       'd': LowercaseLetter
'       'e': LowercaseLetter
'       'd': LowercaseLetter
'       ' ': SpaceSeparator
'       'r': LowercaseLetter
'       'o': LowercaseLetter
'       'a': LowercaseLetter
'       'd': LowercaseLetter
'       '.': OtherPunctuation

Internamente, para los caracteres fuera del intervalo ASCII (U+0000 a U+00FF), el método depende de las categorías Unicode notificadas GetUnicodeCategory por la CharUnicodeInfo clase . A partir .NET Framework 4.6.2, los caracteres Unicode se clasifican según el estándar Unicode, versión 8.0.0. En las versiones de .NET Framework de .NET Framework 4 a .NET Framework 4.6.1, se clasifican según el estándar Unicode, versión 6.3.0.

Caracteres y elementos de texto

Dado que un solo carácter se puede representar mediante varios objetos, no siempre es significativo trabajar Char con objetos Char individuales. Por ejemplo, en el ejemplo siguiente se convierten los puntos de código Unicode que representan las unidades de código codificadas con codificación UTF-16 entre cero y 9. Dado que equivale erróneamente los objetos con caracteres, notifica Char inexactamente que la cadena resultante tiene 20 caracteres.

using System;

public class Example
{
   public static void Main()
   {
      string result = String.Empty;
      for (int ctr = 0x10107; ctr <= 0x10110; ctr++)  // Range of Aegean numbers.
         result += Char.ConvertFromUtf32(ctr);

      Console.WriteLine("The string contains {0} characters.", result.Length);
   }
}
// The example displays the following output:
//     The string contains 20 characters.

open System

let result =
    [ for i in 0x10107..0x10110 do  // Range of Aegean numbers.
        Char.ConvertFromUtf32 i ]
    |> String.concat ""

printfn $"The string contains {result.Length} characters."


// The example displays the following output:
//     The string contains 20 characters.

Module Example
   Public Sub Main()
      Dim result As String = String.Empty
      For ctr As Integer = &h10107 To &h10110     ' Range of Aegean numbers.
         result += Char.ConvertFromUtf32(ctr)
      Next         
      Console.WriteLine("The string contains {0} characters.", result.Length) 
   End Sub
End Module
' The example displays the following output:
'     The string contains 20 characters.

Puede hacer lo siguiente para evitar la suposición de que un Char objeto representa un solo carácter.

• Puede trabajar con un objeto en su totalidad en lugar de trabajar con sus String caracteres individuales para representar y analizar contenido lingüístico.

• Puede usar como String.EnumerateRunes se muestra en el ejemplo siguiente:

  int CountLetters(string s)
  {
      int letterCount = 0;
  
      foreach (Rune rune in s.EnumerateRunes())
      {
          if (Rune.IsLetter(rune))
          { letterCount++; }
      }
  
      return letterCount;
  }
  

  let countLetters (s: string) =
      let mutable letterCount = 0
  
      for rune in s.EnumerateRunes() do
          if Rune.IsLetter rune then
              letterCount <- letterCount + 1
  
      letterCount
  

• Puede usar la clase StringInfo para trabajar con elementos de texto en lugar de objetos Char individuales. En el ejemplo siguiente se usa el objeto para contar el número de elementos de texto de una cadena que consta de los números StringInfo de A registro de cero a nueve. Dado que considera un par suplente un solo carácter, informa correctamente de que la cadena contiene diez caracteres.

  using System;
  using System.Globalization;
  
  public class Example
  {
     public static void Main()
     {
        string result = String.Empty;
        for (int ctr = 0x10107; ctr <= 0x10110; ctr++)  // Range of Aegean numbers.
           result += Char.ConvertFromUtf32(ctr);
  
        StringInfo si = new StringInfo(result);
        Console.WriteLine("The string contains {0} characters.",
                          si.LengthInTextElements);
     }
  }
  // The example displays the following output:
  //       The string contains 10 characters.
  

  open System
  open System.Globalization
  
  let result =
      [ for i in 0x10107..0x10110 do  // Range of Aegean numbers.
          Char.ConvertFromUtf32 i ]
      |> String.concat ""
  
  
  let si = StringInfo result
  printfn $"The string contains {si.LengthInTextElements} characters."
  
  // The example displays the following output:
  //       The string contains 10 characters.
  

  Imports System.Globalization
  
  Module Example
     Public Sub Main()
        Dim result As String = String.Empty
        For ctr As Integer = &h10107 To &h10110     ' Range of Aegean numbers.
           result += Char.ConvertFromUtf32(ctr)
        Next         
        Dim si As New StringInfo(result)
        Console.WriteLine("The string contains {0} characters.", si.LengthInTextElements) 
     End Sub
  End Module
  ' The example displays the following output:
  '       The string contains 10 characters.
  

• Si una cadena contiene un carácter base que tiene uno o varios caracteres combinados, puede llamar al método para convertir la subcadena en una sola unidad de código String.Normalize codificada en UTF-16. En el ejemplo siguiente se llama al método para convertir el carácter String.Normalize base U+0061 (LATIN SMALL LETTER A) y combinar el carácter U+0308 (COMBINING DIAERESIS) en U+00E4 (LATIN SMALL LETTER A WITH DIAERESIS).

  using System;
  
  public class Example
  {
     public static void Main()
     {
        string combining = "\u0061\u0308";
        ShowString(combining);
  
        string normalized = combining.Normalize();
        ShowString(normalized);
     }
  
     private static void ShowString(string s)
     {
        Console.Write("Length of string: {0} (", s.Length);
        for (int ctr = 0; ctr < s.Length; ctr++) {
           Console.Write("U+{0:X4}", Convert.ToUInt16(s[ctr]));
           if (ctr != s.Length - 1) Console.Write(" ");
        }
        Console.WriteLine(")\n");
     }
  }
  // The example displays the following output:
  //       Length of string: 2 (U+0061 U+0308)
  //
  //       Length of string: 1 (U+00E4)
  

  open System
  
  let showString (s: string) =
      printf $"Length of string: {s.Length} ("
      for i = 0 to s.Length - 1 do
          printf $"U+{Convert.ToUInt16 s[i]:X4}"
          if i <> s.Length - 1 then printf " "
      printfn ")\n"
  
  let combining = "\u0061\u0308"
  showString combining
  
  let normalized = combining.Normalize()
  showString normalized
  
  // The example displays the following output:
  //       Length of string: 2 (U+0061 U+0308)
  //
  //       Length of string: 1 (U+00E4)
  

  Module Example
     Public Sub Main()
        Dim combining As String = ChrW(&h0061) + ChrW(&h0308)
        ShowString(combining)
        
        Dim normalized As String = combining.Normalize()
        ShowString(normalized)
     End Sub
     
     Private Sub ShowString(s As String)
        Console.Write("Length of string: {0} (", s.Length)
        For ctr As Integer = 0 To s.Length - 1
           Console.Write("U+{0:X4}", Convert.ToUInt16(s(ctr)))
           If ctr <> s.Length - 1 Then Console.Write(" ")
        Next 
        Console.WriteLine(")")
        Console.WriteLine()
     End Sub
  End Module
  ' The example displays the following output:
  '       Length of string: 2 (U+0061 U+0308)
  '       
  '       Length of string: 1 (U+00E4)
  

Operaciones comunes

La Char estructura proporciona métodos para comparar objetos, convertir el valor del objeto actual en un objeto de otro tipo y determinar la Char categoría Unicode de un objeto Char Char :

Para hacer esto	Use estos System.Char métodos
Comparar Char objetos	CompareTo y Equals
Convertir un punto de código en una cadena	ConvertFromUtf32 Consulte también el Rune tipo .
Convertir un Char objeto o un par suplente de objetos en un punto de Char código	Para un solo carácter: Convert.ToInt32(Char) Para un par suplente o un carácter en una cadena: Char.ConvertToUtf32 Consulte también el Rune tipo .
Obtener la categoría Unicode de un carácter	GetUnicodeCategory Vea también Rune.GetUnicodeCategory.
Determinar si un carácter está en una categoría Unicode determinada, como dígito, letra, puntuación, carácter de control, y así sucesivamente	IsControl, IsDigit , , , , , , , IsHighSurrogate , IsLetter , , , IsLetterOrDigit , IsLower IsLowSurrogate IsNumber IsPunctuation IsSeparator IsSurrogate IsSurrogatePair IsSymbol IsUpper y IsWhiteSpace Consulte también los métodos correspondientes en el Rune tipo.
Convertir un Char objeto que representa un número en un tipo de valor numérico	GetNumericValue Vea también Rune.GetNumericValue.
Convertir un carácter de una cadena en un Char objeto	Parse y TryParse
Convertir un Char objeto en un String objeto	ToString
Cambiar el caso de un Char objeto	ToLower, ToLowerInvariant, ToUpper y ToUpperInvariant. Consulte también los métodos correspondientes en el Rune tipo.

Valores char e interoperabilidad

Cuando un tipo administrado, que se representa como una unidad de código con codificación UTF-16 Unicode, se pasa a código no administrado, el serializador de interoperabilidad convierte el juego de caracteres en ANSI de Char forma predeterminada. Puede aplicar el atributo a las declaraciones de invocación de plataforma y el atributo a una declaración de interoperabilidad COM para controlar qué juego de caracteres usa DllImportAttribute StructLayoutAttribute un tipo Char serializado.

Campos

MaxValue	Representa el mayor valor posible de un Char. Este campo es constante.
MinValue	Representa el menor valor posible de un Char. Este campo es constante.

Métodos

CompareTo(Char)	Compara esta instancia con un objeto Char especificado e indica si esta instancia precede o sigue al objeto Char especificado o aparece en la misma posición que él en el criterio de ordenación.
CompareTo(Object)	Compara esta instancia con un objeto Object especificado e indica si esta instancia precede o sigue al objeto especificado o aparece en la misma posición que él en el criterio de ordenación.
ConvertFromUtf32(Int32)	Convierte el punto de código Unicode especificado en una cadena codificada mediante UTF-16.
ConvertToUtf32(Char, Char)	Convierte el valor de un par suplente codificado mediante UTF-16 en un punto de código Unicode.
ConvertToUtf32(String, Int32)	Convierte el valor de un par suplente o carácter codificado mediante UTF-16 que está situado en una posición concreta de una cadena en un punto de código Unicode.
Equals(Char)	Devuelve un valor que indica si esta instancia es igual que el objeto Char especificado.
Equals(Object)	Devuelve un valor que indica si esta instancia es igual que un objeto especificado.
GetHashCode()	Devuelve el código hash de esta instancia.
GetNumericValue(Char)	Convierte el carácter Unicode numérico especificado en un número de punto flotante de precisión doble.
GetNumericValue(String, Int32)	Convierte el carácter Unicode numérico situado en la posición especificada de una cadena especificada en un número de punto flotante de precisión doble.
GetTypeCode()	Devuelve el TypeCode para el tipo de valor Char.
GetUnicodeCategory(Char)	Clasifica un carácter Unicode especificado dentro de un grupo identificado por uno de los valores de UnicodeCategory.
GetUnicodeCategory(String, Int32)	Clasifica el carácter que ocupa la posición especificada en una cadena especificada dentro de un grupo identificado por uno de los valores de UnicodeCategory.
IsAscii(Char)	Devuelve true si es un carácter ASCII c ([ U+0000..U+007F ]).
IsControl(Char)	Indica si el carácter Unicode especificado se clasifica por categorías como un carácter de control.
IsControl(String, Int32)	Indica si el carácter que ocupa la posición especificada en una cadena especificada se clasifica por categorías como un carácter de control.
IsDigit(Char)	Indica si el carácter Unicode especificado se clasifica por categorías como un dígito decimal.
IsDigit(String, Int32)	Indica si el carácter que ocupa la posición especificada en una cadena especificada se clasifica por categorías como un dígito decimal.
IsHighSurrogate(Char)	Indica si el objeto Char especificado es un suplente alto.
IsHighSurrogate(String, Int32)	Indica si el objeto Char situado en la posición especificada de una cadena es un suplente alto.
IsLetter(Char)	Indica si el carácter Unicode especificado pertenece a alguna categoría de letras Unicode.
IsLetter(String, Int32)	Indica si el carácter que ocupa la posición especificada en una determinada cadena pertenece a alguna categoría de letras Unicode.
IsLetterOrDigit(Char)	Indica si el carácter Unicode especificado pertenece a alguna categoría de letras o dígitos decimales.
IsLetterOrDigit(String, Int32)	Indica si el carácter que ocupa la posición especificada en una cadena especificada pertenece a alguna categoría de letras o dígitos decimales.
IsLower(Char)	Indica si el carácter Unicode especificado se clasifica por categorías como una letra minúscula.
IsLower(String, Int32)	Indica si el carácter que ocupa la posición especificada en una cadena especificada se clasifica por categorías como una letra minúscula.
IsLowSurrogate(Char)	Indica si el objeto Char especificado es un suplente bajo.
IsLowSurrogate(String, Int32)	Indica si el objeto Char situado en la posición especificada de una cadena es un suplente bajo.
IsNumber(Char)	Indica si el carácter Unicode especificado se clasifica por categorías como un número.
IsNumber(String, Int32)	Indica si el carácter que ocupa la posición especificada en una cadena especificada se clasifica por categorías como un número.
IsPunctuation(Char)	Indica si el carácter Unicode especificado se clasifica por categorías como un signo de puntuación.
IsPunctuation(String, Int32)	Indica si el carácter que ocupa la posición especificada en una cadena especificada se clasifica por categorías como un signo de puntuación.
IsSeparator(Char)	Indica si el carácter Unicode especificado se clasifica por categorías como un carácter separador.
IsSeparator(String, Int32)	Indica si el carácter que ocupa la posición especificada en una cadena especificada se clasifica por categorías como un carácter separador.
IsSurrogate(Char)	Indica si el carácter especificado tiene una unidad de código suplente.
IsSurrogate(String, Int32)	Indica si el carácter situado en la posición especificada de la cadena especificada tiene una unidad de código suplente.
IsSurrogatePair(Char, Char)	Indica si los dos objetos Char especificados forman un par suplente.
IsSurrogatePair(String, Int32)	Indica si dos objetos Char adyacentes en la posición especificada de una cadena forman un par suplente.
IsSymbol(Char)	Indica si el carácter Unicode especificado se clasifica por categorías como un carácter de símbolo.
IsSymbol(String, Int32)	Indica si el carácter que ocupa la posición especificada en una cadena especificada se clasifica por categorías como un carácter de símbolo.
IsUpper(Char)	Indica si el carácter Unicode especificado se clasifica por categorías como una letra mayúscula.
IsUpper(String, Int32)	Indica si el carácter que ocupa la posición especificada en una cadena especificada se clasifica por categorías como una letra mayúscula.
IsWhiteSpace(Char)	Indica si el carácter Unicode especificado se clasifica por categorías como un espacio en blanco.
IsWhiteSpace(String, Int32)	Indica si el carácter que ocupa la posición especificada en una cadena especificada se clasifica por categorías como un espacio en blanco.
Parse(String)	Convierte el valor de la cadena especificada en el carácter Unicode equivalente.
ToLower(Char)	Convierte el valor de un carácter Unicode en un carácter equivalente, pero en minúsculas.
ToLower(Char, CultureInfo)	Convierte el valor de un carácter Unicode especificado en un carácter equivalente pero en minúsculas mediante la información de formato específica de la referencia cultural especificada.
ToLowerInvariant(Char)	Convierte el valor de un carácter Unicode en su equivalente en minúsculas utilizando las reglas sobre mayúsculas y minúsculas de la referencia cultural de todos los idiomas.
ToString()	Convierte el valor de esta instancia en la representación de cadena equivalente.
ToString(Char)	Convierte el carácter Unicode especificado en la representación de cadena equivalente.
ToString(IFormatProvider)	Convierte el valor de esta instancia en la representación de cadena equivalente mediante la información de formato específica de la referencia cultural especificada.
ToUpper(Char)	Convierte el valor de un carácter Unicode en un carácter equivalente, pero en mayúsculas.
ToUpper(Char, CultureInfo)	Convierte el valor de un carácter Unicode especificado en el carácter equivalente pero en mayúsculas mediante la información de formato específica de la referencia cultural especificada.
ToUpperInvariant(Char)	Convierte el valor de un carácter Unicode en su equivalente en mayúsculas utilizando las reglas sobre mayúsculas y minúsculas de la referencia cultural de todos los idiomas.
TryParse(String, Char)	Convierte el valor de la cadena especificada en el carácter Unicode equivalente. Un código devuelto indica si la conversión fue correcta o no.

Implementaciones de interfaz explícitas

IComparable.CompareTo(Object)	Compara la instancia actual con otro objeto del mismo tipo y devuelve un entero que indica si la posición de la instancia actual es anterior, posterior o igual que la del otro objeto en el criterio de ordenación.
IConvertible.GetTypeCode()	Devuelve el TypeCode para esta instancia.
IConvertible.ToBoolean(IFormatProvider)	Nota No se admite esta conversión. Si se intenta, se produce una excepción InvalidCastException.
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)	Nota No se admite esta conversión. Si se intenta, se produce una excepción InvalidCastException.
IConvertible.ToDecimal(IFormatProvider)	Nota No se admite esta conversión. Si se intenta, se produce una excepción InvalidCastException.
IConvertible.ToDouble(IFormatProvider)	Nota No se admite esta conversión. Si se intenta, se produce una excepción InvalidCastException.
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)	Nota No se admite esta conversión. Si se intenta, se produce una excepción InvalidCastException.
IConvertible.ToString(IFormatProvider)	Convierte el valor de esta instancia en una cadena equivalente mediante el uso de la información de formato específica de la referencia cultural establecida.
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).
IFormattable.ToString(String, IFormatProvider)	Da formato al valor de la instancia actual usando el formato especificado.
ISpanFormattable.TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Intenta dar formato al valor de la instancia actual en el intervalo de caracteres proporcionado.

Seguridad para subprocesos

Todos los miembros de este tipo son seguros para subprocesos. Los miembros que parecen modificar el estado de instancia devuelven realmente una nueva instancia inicializada con el nuevo valor. Al igual que con cualquier otro tipo, la lectura y escritura en una variable compartida que contiene una instancia de este tipo debe protegerse mediante un bloqueo para garantizar la seguridad de los subprocesos.

Consulte también

• IComparable
• IConvertible
• String