Char.IsSurrogatePair Méthode

Définition

Espace de noms:

System

Assembly:

System.Runtime.dll

Indique si deux objets Char spécifiés forment une paire de substitution.

Surcharges

IsSurrogatePair(Char, Char)	Indique si les deux objets Char spécifiés forment une paire de substitution.
IsSurrogatePair(String, Int32)	Indique si deux objets Char adjacents à une position spécifiée dans une chaîne forment une paire de substitution.

Exemples

L’exemple de code suivant illustre les IsHighSurrogateméthodes , IsLowSurrogateet IsSurrogatePair .

C#

// This example demonstrates the Char.IsLowSurrogate() method
//                                    IsHighSurrogate() method
//                                    IsSurrogatePair() method
using System;

class Sample
{
    public static void Main()
    {
    char cHigh = '\uD800';
    char cLow  = '\uDC00';
    string s1  = new String(new char[] {'a', '\uD800', '\uDC00', 'z'});
    string divider = String.Concat( Environment.NewLine, new String('-', 70),
                                    Environment.NewLine);

    Console.WriteLine();
    Console.WriteLine("Hexadecimal code point of the character, cHigh: {0:X4}", (int)cHigh);
    Console.WriteLine("Hexadecimal code point of the character, cLow:  {0:X4}", (int)cLow);
    Console.WriteLine();
    Console.WriteLine("Characters in string, s1: 'a', high surrogate, low surrogate, 'z'");
    Console.WriteLine("Hexadecimal code points of the characters in string, s1: ");
    for(int i = 0; i < s1.Length; i++)
        {
        Console.WriteLine("s1[{0}] = {1:X4} ", i, (int)s1[i]);
        }
    Console.WriteLine(divider);

    Console.WriteLine("Is each of the following characters a high surrogate?");
    Console.WriteLine("A1) cLow?  - {0}", Char.IsHighSurrogate(cLow));
    Console.WriteLine("A2) cHigh? - {0}", Char.IsHighSurrogate(cHigh));
    Console.WriteLine("A3) s1[0]? - {0}", Char.IsHighSurrogate(s1, 0));
    Console.WriteLine("A4) s1[1]? - {0}", Char.IsHighSurrogate(s1, 1));
    Console.WriteLine(divider);

    Console.WriteLine("Is each of the following characters a low surrogate?");
    Console.WriteLine("B1) cLow?  - {0}", Char.IsLowSurrogate(cLow));
    Console.WriteLine("B2) cHigh? - {0}", Char.IsLowSurrogate(cHigh));
    Console.WriteLine("B3) s1[0]? - {0}", Char.IsLowSurrogate(s1, 0));
    Console.WriteLine("B4) s1[2]? - {0}", Char.IsLowSurrogate(s1, 2));
    Console.WriteLine(divider);

    Console.WriteLine("Is each of the following pairs of characters a surrogate pair?");
    Console.WriteLine("C1) cHigh and cLow?  - {0}", Char.IsSurrogatePair(cHigh, cLow));
    Console.WriteLine("C2) s1[0] and s1[1]? - {0}", Char.IsSurrogatePair(s1, 0));
    Console.WriteLine("C3) s1[1] and s1[2]? - {0}", Char.IsSurrogatePair(s1, 1));
    Console.WriteLine("C4) s1[2] and s1[3]? - {0}", Char.IsSurrogatePair(s1, 2));
    Console.WriteLine(divider);
    }
}
/*
This example produces the following results:

Hexadecimal code point of the character, cHigh: D800
Hexadecimal code point of the character, cLow:  DC00

Characters in string, s1: 'a', high surrogate, low surrogate, 'z'
Hexadecimal code points of the characters in string, s1:
s1[0] = 0061
s1[1] = D800
s1[2] = DC00
s1[3] = 007A

----------------------------------------------------------------------

Is each of the following characters a high surrogate?
A1) cLow?  - False
A2) cHigh? - True
A3) s1[0]? - False
A4) s1[1]? - True

----------------------------------------------------------------------

Is each of the following characters a low surrogate?
B1) cLow?  - True
B2) cHigh? - False
B3) s1[0]? - False
B4) s1[2]? - True

----------------------------------------------------------------------

Is each of the following pairs of characters a surrogate pair?
C1) cHigh and cLow?  - True
C2) s1[0] and s1[1]? - False
C3) s1[1] and s1[2]? - True
C4) s1[2] and s1[3]? - False

----------------------------------------------------------------------

*/

IsSurrogatePair(Char, Char)

Source:

Char.cs

Indique si les deux objets Char spécifiés forment une paire de substitution.

C#

public static bool IsSurrogatePair (char highSurrogate, char lowSurrogate);

Paramètres

highSurrogate

Char

Caractère à évaluer comme substitut étendu d'une paire de substitution.

lowSurrogate

Char

Caractère à évaluer comme substitut faible d'une paire de substitution.

Retours

Boolean

true si la valeur numérique du paramètre highSurrogate est comprise entre U+D800 et U+DBFF, et si la valeur numérique du paramètre lowSurrogate est comprise entre U+DC00 et U+DFFF ; sinon, false.

Remarques

En règle générale, un caractère unique est représenté par une seule unité de code Unicode 16 bits. L’encodage UTF-16 prend également en charge les paires de substitution, qui permettent à un seul caractère abstrait d’être représenté par deux unités de code 16 bits. La première unité de code, dont la valeur peut aller de U+D800 à U+DBFF, est le substitut élevé. La deuxième unité de code, dont la valeur peut aller de U+DC00 à U+DFFF, est le substitut faible. Les points de code de substitution individuels n’ont pas leur propre interprétation. Pour plus d’informations sur les substituts et la norme Unicode, consultez la page d’accueil Unicode.

Voir aussi

• Rune
• IsHighSurrogate(Char)
• IsLowSurrogate(Char)

IsSurrogatePair(String, Int32)

Source:

Char.cs

Indique si deux objets Char adjacents à une position spécifiée dans une chaîne forment une paire de substitution.

C#

public static bool IsSurrogatePair (string s, int index);

Paramètres

s

String

Chaîne.

index

Int32

Position de départ de la paire de caractères à évaluer dans s.

Retours

Boolean

true si le paramètre s inclut des caractères adjacents aux positions index et index + 1, et que la valeur numérique du caractère à la position index est comprise entre U+D800 et U+DBFF, et que la valeur numérique du caractère à la position index+1 est comprise entre U+DC00 et U+DFFF ; sinon, false.

Exceptions

ArgumentNullException

s a la valeur null.

ArgumentOutOfRangeException

index n’est pas une position dans s.

Remarques

En règle générale, un caractère unique est représenté par une seule unité de code Unicode 16 bits. L’encodage UTF-16 prend également en charge les paires de substitution, qui permettent à un seul caractère abstrait d’être représenté par deux unités de code 16 bits. La première unité de code, dont la valeur peut aller de U+D800 à U+DBFF, est le substitut élevé. La deuxième unité de code, dont la valeur peut aller de U+DC00 à U+DFFF, est le substitut faible. Les points de code de substitution individuels n’ont pas leur propre interprétation. Pour plus d’informations sur les substituts et la norme Unicode, consultez la page d’accueil Unicode.

Voir aussi

• Rune
• IsHighSurrogate(Char)
• IsLowSurrogate(Char)