Char.ConvertToUtf32 Método

Referencia

Definición

Espacio de nombres:: System

Ensamblado:: System.Runtime.dll

Ensamblado:: netstandard.dll

Ensamblado:: mscorlib.dll

Importante

Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.

Convierte el valor de un par suplente codificado mediante UTF-16 en un punto de código Unicode.

Sobrecargas

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.

Ejemplos

En el ejemplo de código siguiente se muestran los ConvertToUtf32 métodos ConvertFromUtf32 y .

// This example demonstrates the Char.ConvertFromUtf32() method
//                           and Char.ConvertToUtf32() overloads.
using namespace System;
void Show( String^ s )
{
//   Console::Write( "0x{0:X}, 0x{1:X}", (int)s->get_Chars( 0 ), (int)s->get_Chars( 1 ) );
   Console::Write( "0x{0:X}, 0x{1:X}", (int)s[ 0 ], (int)s[ 1 ] );
}

int main()
{
   int music = 0x1D161; //U+1D161 = MUSICAL SYMBOL SIXTEENTH NOTE

   String^ s1;
   String^ comment1a = "Create a UTF-16 encoded string from a code point.";
   String^ comment1b = "Create a code point from a surrogate pair at a certain position in a string.";
   String^ comment1c = "Create a code point from a high surrogate and a low surrogate code point.";
   
   // -------------------------------------------------------------------
   //  Convert the code point U+1D161 to UTF-16. The UTF-16 equivalent of 
   //  U+1D161 is a surrogate pair with hexadecimal values D834 and DD61.
   Console::WriteLine( comment1a );
   s1 = Char::ConvertFromUtf32( music );
   Console::Write( "    1a) 0x{0:X} => ", music );
   Show( s1 );
   Console::WriteLine();
   
   //  Convert the surrogate pair in the string at index position 
   //  zero to a code point.
   Console::WriteLine( comment1b );
   music = Char::ConvertToUtf32( s1, 0 );
   Console::Write( "    1b) " );
   Show( s1 );
   Console::WriteLine( " => 0x{0:X}", music );
   
   //  Convert the high and low characters in the surrogate pair into a code point.
   Console::WriteLine( comment1c );
   music = Char::ConvertToUtf32( s1[ 0 ], s1[ 1 ] );
   Console::Write( "    1c) " );
   Show( s1 );
   Console::WriteLine( " => 0x{0:X}", music );
}

/*
This example produces the following results:

Create a UTF-16 encoded string from a code point.
    1a) 0x1D161 => 0xD834, 0xDD61
Create a code point from a surrogate pair at a certain position in a string.
    1b) 0xD834, 0xDD61 => 0x1D161
Create a code point from a high surrogate and a low surrogate code point.
    1c) 0xD834, 0xDD61 => 0x1D161

*/

// This example demonstrates the Char.ConvertFromUtf32() method
//                           and Char.ConvertToUtf32() overloads.
using System;

class Sample
{
    public static void Main()
    {
    int letterA = 0x0041;  //U+00041 = LATIN CAPITAL LETTER A
    int music   = 0x1D161; //U+1D161 = MUSICAL SYMBOL SIXTEENTH NOTE
    string s1;
    string comment   = "Create a UTF-16 encoded string from a code point.";
    string comment1b = "Create a code point from a UTF-16 encoded string.";
    string comment2b = "Create a code point from a surrogate pair at a certain position in a string.";
    string comment2c = "Create a code point from a high surrogate and a low surrogate code point.";

//  Convert code point U+0041 to UTF-16. The UTF-16 equivalent of
//  U+0041 is a Char with hexadecimal value 0041.

    Console.WriteLine(comment);
    s1 = Char.ConvertFromUtf32(letterA);
    Console.Write("    1a) 0x{0:X} => ", letterA);
    Show(s1);
    Console.WriteLine();

//  Convert the lone UTF-16 character to a code point.

    Console.WriteLine(comment1b);
    letterA = Char.ConvertToUtf32(s1, 0);
    Console.Write("    1b) ");
    Show(s1);
    Console.WriteLine(" => 0x{0:X}", letterA);
    Console.WriteLine();

// -------------------------------------------------------------------

//  Convert the code point U+1D161 to UTF-16. The UTF-16 equivalent of
//  U+1D161 is a surrogate pair with hexadecimal values D834 and DD61.

    Console.WriteLine(comment);
    s1 = Char.ConvertFromUtf32(music);
    Console.Write("    2a) 0x{0:X} => ", music);
    Show(s1);
    Console.WriteLine();

//  Convert the surrogate pair in the string at index position
//  zero to a code point.

    Console.WriteLine(comment2b);
    music = Char.ConvertToUtf32(s1, 0);
    Console.Write("    2b) ");
    Show(s1);
    Console.WriteLine(" => 0x{0:X}", music);

//  Convert the high and low characters in the surrogate pair into a code point.

    Console.WriteLine(comment2c);
    music = Char.ConvertToUtf32(s1[0], s1[1]);
    Console.Write("    2c) ");
    Show(s1);
    Console.WriteLine(" => 0x{0:X}", music);
    }

    private static void Show(string s)
    {
    for (int x = 0; x < s.Length; x++)
        {
        Console.Write("0x{0:X}{1}",
                       (int)s[x],
                       ((x == s.Length-1)? String.Empty : ", "));
        }
    }
}
/*
This example produces the following results:

Create a UTF-16 encoded string from a code point.
    1a) 0x41 => 0x41
Create a code point from a UTF-16 encoded string.
    1b) 0x41 => 0x41

Create a UTF-16 encoded string from a code point.
    2a) 0x1D161 => 0xD834, 0xDD61
Create a code point from a surrogate pair at a certain position in a string.
    2b) 0xD834, 0xDD61 => 0x1D161
Create a code point from a high surrogate and a low surrogate code point.
    2c) 0xD834, 0xDD61 => 0x1D161

*/

open System

let show (s: string) =
    for x = 0 to s.Length - 1 do
        printf $"""0x{int s[x]:X}{if x = s.Length - 1 then String.Empty else ", "}"""                    

[<EntryPoint>]
let main _ =
    let letterA = 0x0041  //U+00041 = LATIN CAPITAL LETTER A
    let music   = 0x1D161 //U+1D161 = MUSICAL SYMBOL SIXTEENTH NOTE
    let comment   = "Create a UTF-16 encoded string from a code point."
    let comment1b = "Create a code point from a UTF-16 encoded string."
    let comment2b = "Create a code point from a surrogate pair at a certain position in a string."
    let comment2c = "Create a code point from a high surrogate and a low surrogate code point."

//  Convert code point U+0041 to UTF-16. The UTF-16 equivalent of
//  U+0041 is a Char with hexadecimal value 0041.

    printfn $"{comment}"
    let s1 = Char.ConvertFromUtf32 letterA
    printf $"    1a) 0x{letterA:X} => "
    show s1
    printfn ""

//  Convert the lone UTF-16 character to a code point.

    printfn $"{comment1b}"
    let letterA = Char.ConvertToUtf32(s1, 0)
    printf "    1b) "
    show s1
    printfn $" => 0x{letterA:X}"
    printfn ""

// -------------------------------------------------------------------

//  Convert the code point U+1D161 to UTF-16. The UTF-16 equivalent of
//  U+1D161 is a surrogate pair with hexadecimal values D834 and DD61.

    printfn $"{comment}"
    let s1 = Char.ConvertFromUtf32 music
    printf $"    2a) 0x{music:X} => "
    show s1
    printfn ""

//  Convert the surrogate pair in the string at index position
//  zero to a code point.

    printfn $"{comment2b}" 
    let music = Char.ConvertToUtf32(s1, 0)
    printf "    2b) "
    show s1
    printfn $" => 0x{music:X}"

//  Convert the high and low characters in the surrogate pair into a code point.

    printfn $"{comment2c}"
    let music = Char.ConvertToUtf32(s1[0], s1[1])
    printf "    2c) "
    show s1
    printfn $" => 0x{music:X}"

    0

// This example produces the following results:
//
// Create a UTF-16 encoded string from a code point.
//     1a) 0x41 => 0x41
// Create a code point from a UTF-16 encoded string.
//     1b) 0x41 => 0x41
//
// Create a UTF-16 encoded string from a code point.
//     2a) 0x1D161 => 0xD834, 0xDD61
// Create a code point from a surrogate pair at a certain position in a string.
//     2b) 0xD834, 0xDD61 => 0x1D161
// Create a code point from a high surrogate and a low surrogate code point.
//     2c) 0xD834, 0xDD61 => 0x1D161

Class Sample
   Public Shared Sub Main()
      Dim letterA As Integer = &H41    'U+00041 = LATIN CAPITAL LETTER A
      Dim music As Integer   = &H1D161 'U+1D161 = MUSICAL SYMBOL SIXTEENTH NOTE
      Dim s1 As String
      Dim comment   As String = "Create a UTF-16 encoded string from a code point."
      Dim comment1b As String = "Create a code point from a UTF-16 encoded string."
      Dim comment2b As String = "Create a code point from a surrogate pair at a certain position in a string."
      Dim comment2c As String = "Create a code point from a high surrogate and a low surrogate code point."
      
      '  Convert code point U+0041 to UTF-16. The UTF-16 equivalent of 
      '  U+0041 is a Char with hexadecimal value 0041.

      Console.WriteLine(comment)
      s1 = [Char].ConvertFromUtf32(letterA)
      Console.Write("    1a) 0x{0:X} => ", letterA)
      Show(s1)
      Console.WriteLine()
      
      '  Convert the lone UTF-16 character to a code point.

      Console.WriteLine(comment1b)
      letterA = [Char].ConvertToUtf32(s1, 0)
      Console.Write("    1b) ")
      Show(s1)
      Console.WriteLine(" => 0x{0:X}", letterA)
      Console.WriteLine()
      
      ' -------------------------------------------------------------------

      '  Convert the code point U+1D161 to UTF-16. The UTF-16 equivalent of 
      '  U+1D161 is a surrogate pair with hexadecimal values D834 and DD61.

      Console.WriteLine(comment)
      s1 = [Char].ConvertFromUtf32(music)
      Console.Write("    2a) 0x{0:X} => ", music)
      Show(s1)
      Console.WriteLine()
      
      '  Convert the surrogate pair in the string at index position 
      '  zero to a code point.

      Console.WriteLine(comment2b)
      music = [Char].ConvertToUtf32(s1, 0)
      Console.Write("    2b) ")
      Show(s1)
      Console.WriteLine(" => 0x{0:X}", music)
      
      '  Convert the high and low characters in the surrogate pair into a code point.

      Console.WriteLine(comment2c)
      music = [Char].ConvertToUtf32(s1.Chars(0), s1.Chars(1))
      Console.Write("    2c) ")
      Show(s1)
      Console.WriteLine(" => 0x{0:X}", music)
   End Sub
   
   Private Shared Sub Show(s As String)
      Dim x As Integer
      If s.Length = 0 Then Exit Sub
      For x = 0 To s.Length - 1
         Console.Write("0x{0:X}{1}", _
                        AscW(s.Chars(x)), _
                        IIf(x = s.Length - 1, [String].Empty, ", "))
      Next 
   End Sub 
End Class 
'
'This example produces the following results:
'
'Create a UTF-16 encoded string from a code point.
'    1a) 0x41 => 0x41
'Create a code point from a UTF-16 encoded string.
'    1b) 0x41 => 0x41
'
'Create a UTF-16 encoded string from a code point.
'    2a) 0x1D161 => 0xD834, 0xDD61
'Create a code point from a surrogate pair at a certain position in a string.
'    2b) 0xD834, 0xDD61 => 0x1D161
'Create a code point from a high surrogate and a low surrogate code point.
'    2c) 0xD834, 0xDD61 => 0x1D161
'

ConvertToUtf32(Char, Char)

Convierte el valor de un par suplente codificado mediante UTF-16 en un punto de código Unicode.

public:
 static int ConvertToUtf32(char highSurrogate, char lowSurrogate);

public static int ConvertToUtf32 (char highSurrogate, char lowSurrogate);

static member ConvertToUtf32 : char * char -> int

Public Shared Function ConvertToUtf32 (highSurrogate As Char, lowSurrogate As Char) As Integer

Parámetros

highSurrogate: Char

Unidad de código suplente alto (es decir, una unidad de código que va de U+D800 a U+DBFF).

lowSurrogate: Char

Unidad de código suplente bajo (es decir, una unidad de código que va de U+DC00 a U+DFFF).

Devoluciones

Int32

Punto de código Unicode de 21 bits que representan los parámetros highSurrogate y lowSurrogate.

Excepciones

ArgumentOutOfRangeException

highSurrogate no está en el intervalo de U+D800 a U+DBFF, o lowSurrogate no está en el intervalo de U+DC00 a U+DFFF.

Comentarios

Use este método para convertir un par suplente en un punto de código Unicode de 21 bits. Para convertir datos UTF-16 en datos UTF-32, use la System.Text.UTF32Encoding clase .

Normalmente, la codificación UTF-16 representa un único carácter Unicode como una unidad de código de 16 bits. Sin embargo, también admite pares suplentes, que permiten representar un único carácter abstracto como dos unidades de código de 16 bits. Estos dos objetos deben tener unidades de código que van de U+D800 a U+DBFF para el primer suplente (alto) y de U+DC00 a U+DFFF para el segundo Char suplente (bajo). Los pares suplentes solo son compatibles con la codificación UTF-16. Este método permite convertir un carácter representado por un par suplente UTF-16 en un carácter mediante codificación UTF-32.

Consulte también

Se aplica a

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.

public:
 static int ConvertToUtf32(System::String ^ s, int index);

public static int ConvertToUtf32 (string s, int index);

static member ConvertToUtf32 : string * int -> int

Public Shared Function ConvertToUtf32 (s As String, index As Integer) As Integer

Parámetros

s: String

Cadena que contiene un carácter o par suplente.

index: Int32

Posición de índice del carácter o par suplente en s.

Devoluciones

Int32

Punto de código Unicode de 21 bits representado por el carácter o par suplente situado en la posición del parámetro s que especifica el parámetro index.

Excepciones

ArgumentNullException

s es null.

ArgumentOutOfRangeException

index no es una posición dentro de s.

ArgumentException

La posición de índice especificada contiene un par suplente y el primer carácter del par no es un suplente alto válido o el segundo carácter del par no es un suplente bajo válido.

Comentarios

Use este método para convertir un carácter o par suplente en un punto de código Unicode de 21 bits. Para convertir datos UTF-16 en datos UTF-32, use la System.Text.UTF32Encoding clase .

Consulte también

Se aplica a

Compartir a través de

Char.ConvertToUtf32 Método

Definición

Sobrecargas

Ejemplos

ConvertToUtf32(Char, Char)

Parámetros

Devoluciones

Excepciones

Comentarios

Consulte también

Se aplica a

ConvertToUtf32(String, Int32)

Parámetros

Devoluciones

Excepciones

Comentarios

Consulte también

Se aplica a

Recursos adicionales