Char.IsLowSurrogate Metoda

Odwołanie

Definicja

Przestrzeń nazw:: System

Zestaw:: System.Runtime.dll

Zestaw:: netstandard.dll

Zestaw:: mscorlib.dll

Ważne

Niektóre informacje odnoszą się do produktu w wersji wstępnej, który może zostać znacząco zmodyfikowany przed wydaniem. Firma Microsoft nie udziela żadnych gwarancji, jawnych lub domniemanych, w odniesieniu do informacji podanych w tym miejscu.

Wskazuje, czy określony Char obiekt jest niskim surogatem.

Przeciążenia

IsLowSurrogate(String, Int32)	Wskazuje, czy Char obiekt w określonej pozycji w ciągu jest niskim surogatem.
IsLowSurrogate(Char)	Wskazuje, czy określony Char obiekt jest niskim surogatem.

Przykłady

W poniższym przykładzie kodu pokazano IsHighSurrogate metody IsLowSurrogate , i 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(String, Int32)

Wskazuje, czy Char obiekt w określonej pozycji w ciągu jest niskim surogatem.

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

Parametry

s: String

Ciąg.

index: Int32

Pozycja znaku do oceny w s .

Zwraca

Boolean

true jeśli wartość liczbowa określonego znaku w parametrze obejmuje zakresy od s U + DC00 do U + DFFF; w przeciwnym razie false .

Wyjątki

ArgumentNullException

s to null.

ArgumentOutOfRangeException

index nie jest pozycją w obrębie s .

Uwagi

Parametr index ma wartość zero.

Oprócz reprezentowania pojedynczych znaków przy użyciu 16-bitowego kodu znaku, kodowanie UTF-16 pozwala na przedstawianie znaków abstrakcyjnych za pomocą dwóch 16-bitowych kodów znaku, znanych jako para zastępcza. Drugim elementem w tej parze jest niski surogat. Jego punkt kodu może mieć zakres od U+DC00 do U+DFFF. Indywidualny znak zastępczy ma nie interpretacji własnych; jest istotny tylko wtedy, gdy jest używany jako część pary zastępczej.

Zobacz też

Rune

Dotyczy

IsLowSurrogate(Char)

Wskazuje, czy określony Char obiekt jest niskim surogatem.

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

Parametry

c: Char

Znak do oceny.

Zwraca

Boolean

true Wartość liczbowa parametru obejmuje zakres od c U+DC00 do U+DFFF; w przeciwnym razie false wartość .

Uwagi

Zobacz też

Rune

Dotyczy

Udostępnij za pośrednictwem

Char.IsLowSurrogate Metoda

Definicja

Przeciążenia

Przykłady

IsLowSurrogate(String, Int32)

Parametry

Zwraca

Wyjątki

Uwagi

Zobacz też

Dotyczy

IsLowSurrogate(Char)

Parametry

Zwraca

Uwagi

Zobacz też

Dotyczy

Dodatkowe zasoby