Char Estructura

Definición

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<char>, IConvertible, IEquatable<char>, IParsable<char>, ISpanParsable<char>, System::Numerics::IAdditionOperators<char, char, char>, System::Numerics::IAdditiveIdentity<char, char>, System::Numerics::IBinaryInteger<char>, System::Numerics::IBinaryNumber<char>, System::Numerics::IBitwiseOperators<char, char, char>, System::Numerics::IComparisonOperators<char, char>, System::Numerics::IDecrementOperators<char>, System::Numerics::IDivisionOperators<char, char, char>, System::Numerics::IEqualityOperators<char, char>, System::Numerics::IIncrementOperators<char>, System::Numerics::IMinMaxValue<char>, System::Numerics::IModulusOperators<char, char, char>, System::Numerics::IMultiplicativeIdentity<char, char>, System::Numerics::IMultiplyOperators<char, char, char>, System::Numerics::INumber<char>, System::Numerics::INumberBase<char>, System::Numerics::IShiftOperators<char, char>, System::Numerics::ISubtractionOperators<char, char, char>, System::Numerics::IUnaryNegationOperators<char, char>, System::Numerics::IUnaryPlusOperators<char, char>, System::Numerics::IUnsignedNumber<char>
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 readonly struct Char : IComparable, IComparable<char>, IConvertible, IEquatable<char>
public readonly struct Char : IComparable, IComparable<char>, IConvertible, IEquatable<char>, ISpanFormattable
public readonly struct Char : IComparable<char>, IConvertible, IEquatable<char>, IParsable<char>, ISpanParsable<char>, System.Numerics.IAdditionOperators<char,char,char>, System.Numerics.IAdditiveIdentity<char,char>, System.Numerics.IBinaryInteger<char>, System.Numerics.IBinaryNumber<char>, System.Numerics.IBitwiseOperators<char,char,char>, System.Numerics.IComparisonOperators<char,char>, System.Numerics.IDecrementOperators<char>, System.Numerics.IDivisionOperators<char,char,char>, System.Numerics.IEqualityOperators<char,char>, System.Numerics.IIncrementOperators<char>, System.Numerics.IMinMaxValue<char>, System.Numerics.IModulusOperators<char,char,char>, System.Numerics.IMultiplicativeIdentity<char,char>, System.Numerics.IMultiplyOperators<char,char,char>, System.Numerics.INumber<char>, System.Numerics.INumberBase<char>, System.Numerics.IShiftOperators<char,char>, System.Numerics.ISubtractionOperators<char,char,char>, System.Numerics.IUnaryNegationOperators<char,char>, System.Numerics.IUnaryPlusOperators<char,char>, System.Numerics.IUnsignedNumber<char>
[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
type char = struct
    interface IConvertible
    interface IFormattable
    interface IParsable<char>
    interface ISpanFormattable
    interface ISpanParsable<char>
    interface IAdditionOperators<char, char, char>
    interface IAdditiveIdentity<char, char>
    interface IBinaryInteger<char>
    interface IBinaryNumber<char>
    interface IBitwiseOperators<char, char, char>
    interface IComparisonOperators<char, char>
    interface IEqualityOperators<char, char>
    interface IDecrementOperators<char>
    interface IDivisionOperators<char, char, char>
    interface IIncrementOperators<char>
    interface IModulusOperators<char, char, char>
    interface IMultiplicativeIdentity<char, char>
    interface IMultiplyOperators<char, char, char>
    interface INumber<char>
    interface INumberBase<char>
    interface ISubtractionOperators<char, char, char>
    interface IUnaryNegationOperators<char, char>
    interface IUnaryPlusOperators<char, char>
    interface IShiftOperators<char, char>
    interface IMinMaxValue<char>
    interface IUnsignedNumber<char>
[<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 IAdditionOperators(Of Char, Char, Char), IAdditiveIdentity(Of Char, Char), IBinaryInteger(Of Char), IBinaryNumber(Of Char), IBitwiseOperators(Of Char, Char, Char), IComparable(Of Char), IComparisonOperators(Of Char, Char), IConvertible, IDecrementOperators(Of Char), IDivisionOperators(Of Char, Char, Char), IEqualityOperators(Of Char, Char), IEquatable(Of Char), IIncrementOperators(Of Char), IMinMaxValue(Of Char), IModulusOperators(Of Char, Char, Char), IMultiplicativeIdentity(Of Char, Char), IMultiplyOperators(Of Char, Char, Char), INumber(Of Char), INumberBase(Of Char), IParsable(Of Char), IShiftOperators(Of Char, Char), ISpanParsable(Of Char), ISubtractionOperators(Of Char, Char, Char), IUnaryNegationOperators(Of Char, Char), IUnaryPlusOperators(Of Char, Char), IUnsignedNumber(Of Char)
Public Structure Char
Implements IComparable, IConvertible
Public Structure Char
Implements IComparable, IComparable(Of Char), IEquatable(Of Char)
Herencia
Atributos
Implementaciones

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 de 16 bits (ordinal).

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

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

Objetos Char, caracteres Unicode y cadenas

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

Se usan varias unidades de código de 16 bits para representar caracteres Unicode individuales 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 ä se representa mediante un Char objeto cuya unidad de código es U+0061 seguida de un Char objeto cuya unidad de código es U+0308. (El carácter ä también se puede definir mediante un solo Char objeto que tiene una unidad de código de U+00E4). En el ejemplo siguiente se muestra que el carácter ä 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 por un valor de 21 bits que incluye el plano. Por ejemplo, U+1D160 representa el carácter MUSICAL SYMBOL EIGHTH NOTE. Dado que la codificación UTF-16 tiene solo 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 MUSICAL SYMBOL EIGHTH NOTE, es U+D834 U+DD60. U+D834 es el suplente alto; los suplentes altos oscilan entre U+D800 y U+DBFF. U+DD60 es el suplente bajo; los suplentes bajos oscilan entre U+DC00 y 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
    

Caracteres y categorías de caracteres

Cada carácter Unicode o un par suplente válido pertenece a una categoría Unicode. En .NET, las categorías Unicode se representan mediante miembros de la UnicodeCategory enumeración e incluyen valores como UnicodeCategory.CurrencySymbol, UnicodeCategory.LowercaseLettery UnicodeCategory.SpaceSeparator, por 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 ningún par suplente 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 caracteres fuera del intervalo ASCII (U+0000 a U+00FF), el GetUnicodeCategory método depende de las categorías Unicode notificadas por la CharUnicodeInfo clase. A partir de .NET Framework 4.6.2, los caracteres Unicode se clasifican en función del 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 en función del estándar Unicode, versión 6.3.0.

Caracteres y elementos de texto

Dado que un solo carácter se puede representar mediante varios Char objetos, no siempre es significativo trabajar con objetos individuales Char . Por ejemplo, en el ejemplo siguiente se convierten los puntos de código Unicode que representan los números Egeo de cero a 9 a unidades de código codificadas UTF-16. Dado que equivale erróneamente a Char objetos con caracteres, informa inexactamente de 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 String objeto en su totalidad en lugar de trabajar con sus caracteres individuales para representar y analizar el contenido lingüístico.

  • Puede usar String.EnumerateRunes como 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 StringInfo clase para trabajar con elementos de texto en lugar de objetos individuales Char . En el ejemplo siguiente se usa el StringInfo objeto para contar el número de elementos de texto de una cadena que consta de los números Egeo 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 String.Normalize método para convertir la subcadena en una sola unidad de código codificada UTF-16. En el ejemplo siguiente se llama al String.Normalize método para convertir el carácter base U+0061 (LATIN SMALL LETTER A) y combinar el carácter U+0308 (COMBINING DIAERESIS) en U+00E4 (LETRA PEQUEÑA LATINA 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 Char objetos, convertir el valor del objeto actual Char en un objeto de otro tipo y determinar la categoría Unicode de un Char objeto:

Para hacer esto Usar estos System.Char métodos
Comparar Char objetos CompareTo y Equals
Convertir un punto de código en una cadena ConvertFromUtf32

Vea 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

Vea 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, etc. IsControl, IsDigit, IsHighSurrogate, IsLetter, IsLetterOrDigit, IsLower, , IsNumberIsSurrogateIsLowSurrogateIsSeparatorIsSurrogatePairIsPunctuationIsSymbol, IsUpper, yIsWhiteSpace

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 de caracteres e interoperabilidad

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

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

Clamp(Char, Char, Char)

Sujeta un valor a un valor mínimo inclusivo y máximo.

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.

CreateChecked<TOther>(TOther)

Crea una instancia del tipo actual a partir de un valor, iniciando una excepción de desbordamiento para los valores que se encuentran fuera del intervalo representable del tipo actual.

CreateSaturating<TOther>(TOther)

Crea una instancia del tipo actual a partir de un valor, saturando los valores que se encuentran fuera del intervalo representable del tipo actual.

CreateTruncating<TOther>(TOther)

Crea una instancia del tipo actual a partir de un valor, truncando los valores que se encuentran fuera del intervalo representable del tipo actual.

DivRem(Char, Char)

Calcula el cociente y el resto de dos valores.

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 c es un carácter ASCII ([ 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.

IsPow2(Char)

Determina si un valor es una potencia de dos.

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.

LeadingZeroCount(Char)

Calcula el número de ceros a la izquierda en un valor.

Log2(Char)

Calcula el registro2 de un valor.

Max(Char, Char)

Compara dos valores con el proceso, que es mayor.

Min(Char, Char)

Compara dos valores con el proceso, que es menor.

Parse(String)

Convierte el valor de la cadena especificada en el carácter Unicode equivalente.

PopCount(Char)

Calcula el número de bits establecidos en un valor.

RotateLeft(Char, Int32)

Gira un valor de izquierda por una cantidad determinada.

RotateRight(Char, Int32)

Gira un valor a la derecha por una cantidad determinada.

Sign(Char)

Calcula el signo de un valor.

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.

TrailingZeroCount(Char)

Calcula el número de ceros finales en un valor.

TryCreate<TOther>(TOther, Char)

Intenta crear una instancia del tipo actual a partir de un valor.

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

IBinaryInteger<Char>.GetByteCount()

Obtiene el número de bytes que se escribirán como parte de TryWriteLittleEndian(Span<Byte>, Int32).

IBinaryInteger<Char>.GetShortestBitLength()

Obtiene la longitud, en bits, de la representación complementaria de dos más corta del valor actual.

IBinaryInteger<Char>.TryWriteLittleEndian(Span<Byte>, Int32)

Intenta escribir el valor actual, en formato little-endian, en un intervalo determinado.

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.

Se aplica a

Seguridad para subprocesos

Todos los miembros de este tipo son seguros para subprocesos. Los miembros que parecen modificar el estado de la 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 deben estar protegidas por un bloqueo para garantizar la seguridad de los subprocesos.

Consulte también