Char.IsLowSurrogate Méthode

Référence

Définition

Espace de noms:: System

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Indique si l'objet Char spécifié est un caractère de substitution faible.

Surcharges

IsLowSurrogate(Char)	Indique si l'objet Char spécifié est un caractère de substitution faible.
IsLowSurrogate(String, Int32)	Indique si l'objet Char à la position spécifiée dans une chaîne est un caractère de substitution faible.

Exemples

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

// This example demonstrates the Char.IsLowSurrogate() method
//                                    IsHighSurrogate() method
//                                    IsSurrogatePair() method
using namespace System;
int main()
{
   Char cHigh = L'\xD800';
   Char cLow = L'\xDC00';
   array<Char>^temp0 = {L'a',L'\xD800',L'\xDC00',L'z'};
   String^ s1 = gcnew String( temp0 );
   String^ divider = String::Concat( Environment::NewLine, gcnew 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

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

*/

// 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

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

*/

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

let cHigh = '\uD800'
let cLow  = '\uDC00'
let s1 = String [| 'a'; '\uD800'; '\uDC00'; 'z' |]
let divider = String.Concat(Environment.NewLine, String('-', 70), Environment.NewLine)

printfn $"""
Hexadecimal code point of the character, cHigh: {int cHigh:X4}
Hexadecimal code point of the character, cLow:  {int cLow:X4}

Characters in string, s1: 'a', high surrogate, low surrogate, 'z'
Hexadecimal code points of the characters in string, s1: """

for i = 0 to s1.Length - 1 do
    printfn $"s1[{i}] = {int s1[i]:X4} "

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

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

printfn $"""Is each of the following pairs of characters a surrogate pair?
C1) cHigh and cLow?  - {Char.IsSurrogatePair(cHigh, cLow)}
C2) s1[0] and s1[1]? - {Char.IsSurrogatePair(s1, 0)}
C3) s1[1] and s1[2]? - {Char.IsSurrogatePair(s1, 1)}
C4) s1[2] and s1[3]? - {Char.IsSurrogatePair(s1, 2)}"
{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
//
// ----------------------------------------------------------------------

' This example demonstrates the Char.IsLowSurrogate() method
'                                    IsHighSurrogate() method
'                                    IsSurrogatePair() method
Class Sample
   Public Shared Sub Main()
      Dim cHigh As Char = ChrW(&HD800)
      Dim cLow  As Char = ChrW(&HDC00)
      Dim s1 = New [String](New Char() {"a"c, ChrW(&HD800), ChrW(&HDC00), "z"c})
      Dim divider As String = [String].Concat(Environment.NewLine, _
                                              New [String]("-"c, 70), _
                                              Environment.NewLine)
      
      Console.WriteLine()
      Console.WriteLine("Hexadecimal code point of the character, cHigh: {0:X4}", AscW(cHigh))
      Console.WriteLine("Hexadecimal code point of the character, cLow:  {0:X4}", AscW(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: ")
      Dim i As Integer
      For i = 0 To s1.Length - 1
         Console.WriteLine("s1({0}) = {1:X4} ", i, AscW(s1.Chars(i)))
      Next 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)
   End Sub
End Class
'
'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
'
'----------------------------------------------------------------------
'

IsLowSurrogate(Char)

Source:: Char.cs

Source:: Char.cs

Source:: Char.cs

Indique si l'objet Char spécifié est un caractère de substitution faible.

public:
 static bool IsLowSurrogate(char c);

public static bool IsLowSurrogate (char c);

static member IsLowSurrogate : char -> bool

Public Shared Function IsLowSurrogate (c As Char) As Boolean

Paramètres

c: Char

Caractère à évaluer.

Retours

Boolean

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

Remarques

En plus de représenter des caractères uniques à l’aide d’un point de code 16 bits, l’encodage UTF-16 permet de représenter des caractères abstraits à l’aide de deux points de code 16 bits, ce qui est appelé paire de substitution. Le deuxième élément de cette paire est le substitut faible. Son point de code peut aller de U+DC00 à U+DFFF. Un substitut individuel n’a pas sa propre interprétation; elle n’est significative que lorsqu’elle est utilisée dans le cadre d’une paire de substitution.

Voir aussi

Rune

S’applique à

IsLowSurrogate(String, Int32)

Source:: Char.cs

Source:: Char.cs

Source:: Char.cs

Indique si l'objet Char à la position spécifiée dans une chaîne est un caractère de substitution faible.

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

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

static member IsLowSurrogate : string * int -> bool

Public Shared Function IsLowSurrogate (s As String, index As Integer) As Boolean

Paramètres

s: String

Chaîne.

index: Int32

Position du caractère à évaluer dans s.

Retours

Boolean

true si la valeur numérique du caractère spécifié dans le paramètre s 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

Le index paramètre est de base zéro.

Voir aussi

Rune

S’applique à

Partager via

Char.IsLowSurrogate Méthode

Définition

Surcharges

Exemples

IsLowSurrogate(Char)

Paramètres

Retours

Remarques

Voir aussi

S’applique à

IsLowSurrogate(String, Int32)

Paramètres

Retours

Exceptions

Remarques

Voir aussi

S’applique à

Ressources supplémentaires