This documentation is archived and is not being maintained.

Char.ConvertToUtf32 Method (Char, Char)

Converts the value of a UTF-16 encoded surrogate pair into a Unicode code point.

Namespace: System
Assembly: mscorlib (in mscorlib.dll)

public static int ConvertToUtf32 (
	char highSurrogate,
	char lowSurrogate
)
public static int ConvertToUtf32 (
	char highSurrogate, 
	char lowSurrogate
)
public static function ConvertToUtf32 (
	highSurrogate : char, 
	lowSurrogate : char
) : int
Not applicable.

Parameters

highSurrogate

A high surrogate character (that is, a code point ranging from U+D800 through U+DBFF).

lowSurrogate

A low surrogate character (that is, a code point ranging from U+DC00 through U+DFFF).

Return Value

The 21-bit Unicode code point represented by the highSurrogate and lowSurrogate parameters.

Exception typeCondition

ArgumentOutOfRangeException

highSurrogate is not in the range U+D800 through U+DBFF, or lowSurrogate is not in the range U+DC00 through U+DFFF.

Use this method to convert a surrogate pair into a 21-bit Unicode code point. To convert UTF-16 data into UTF-32 data, use the System.Text.UTF32Encoding class.

Ordinarily, UTF-16 encoding represents a single Unicode character as a 16-bit code point. However, it also supports surrogate pairs, which allow a single abstract character to be represented as two 16-bit code points. These two Char objects must have code points that range from U+D800 to U+DBFF for the first (high) surrogate and from U+DC00 to U+DFFF for the second (low) surrogate. Surrogate pairs are supported only by UTF-16 encoding. This method allows a character represented by a UTF-16 surrogate pair to be converted to a character using UTF-32 encoding.

The following code example demonstrates the ConvertToUtf32 and ConvertFromUtf32 methods.

// 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 character.";

//  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 character.
    2c) 0xD834, 0xDD61 => 0x1D161

*/

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

class Sample
{
    public static void main(String[] args)
    {
        int letterA = 0x41; //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 character.";
        //  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} => ", (Int32)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}", (Int32)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} => ", (Int32)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}", (Int32)music);
        //  Convert the high and low characters in the surrogate pair into a
        //  code point.
        Console.WriteLine(comment2C);
        music = Char.ConvertToUtf32(s1.get_Chars(0), s1.get_Chars(1));
        Console.Write("    2c) ");
        Show(s1);
        Console.WriteLine(" => 0x{0:X}", (Int32)music);
    } //main

    private static void Show(String s)
    {
        for (int x = 0; x < s.get_Length(); x++) {
            Console.Write("0x{0:X}{1}", (Int32)(s.get_Chars(x)),
                (x == s.get_Length() - 1) ? "" : ", ");
        }
    } //Show
} //Sample

/*
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 character.
    2c) 0xD834, 0xDD61 => 0x1D161

*/

Windows 98, Windows Server 2000 SP4, Windows Millennium Edition, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

The Microsoft .NET Framework 3.0 is supported on Windows Vista, Microsoft Windows XP SP2, and Windows Server 2003 SP1.

.NET Framework

Supported in: 3.0, 2.0
Show: