Char.IsSurrogatePair Método

Referência

Definição

Namespace:: System

Assembly:: System.Runtime.dll

Assembly:: netstandard.dll

Assembly:: mscorlib.dll

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

Indica se dois objetos Char especificados formam um par alternativo.

Sobrecargas

IsSurrogatePair(String, Int32)	Indica se dois objetos Char adjacentes em uma posição especificada em uma cadeia de caracteres formam um par alternativo.
IsSurrogatePair(Char, Char)	Indica se os dois objetos Char especificados formam um par substituto.

Exemplos

O exemplo de código a seguir demonstra os métodos IsHighSurrogate, IsLowSurrogate e 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
'
'----------------------------------------------------------------------
'

IsSurrogatePair(String, Int32)

Indica se dois objetos Char adjacentes em uma posição especificada em uma cadeia de caracteres formam um par alternativo.

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

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

static member IsSurrogatePair : string * int -> bool

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

Parâmetros

s: String

Uma cadeia de caracteres.

index: Int32

A posição inicial do par de caracteres para avaliar dentro de s.

Retornos

Boolean

true se o s parâmetro inclui caracteres adjacentes em posições index e index + 1 e o valor numérico do caractere na posição index varia de U+D800 a U+DBFF, enquanto o valor numérico do caractere na posição index+ 1 varia de U+DC00 a U+DFFF; caso contrário, false.

Exceções

ArgumentNullException

s é null.

ArgumentOutOfRangeException

index não é uma posição dentro de s.

Comentários

Normalmente, um único caractere é representado por uma única unidade de código Unicode de 16 bits. A codificação UTF-16 também dá suporte a pares substitutos, que permitem que um único caractere abstrato seja representado por unidades de código de 2 16 bits. A primeira unidade de código, cujo valor pode variar de U + D800 para U + DBFF, é o grande substituto. A segunda unidade de código, cujo valor pode variar de U + DC00 para U + DFFF, é o substituto baixo. Pontos de código substitutos individuais não têm nenhuma interpretação própria. Para obter mais informações sobre substitutos e o padrão Unicode, consulte o Home Page Unicode.

Confira também

Aplica-se a

IsSurrogatePair(Char, Char)

Indica se os dois objetos Char especificados formam um par substituto.

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

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

static member IsSurrogatePair : char * char -> bool

Public Shared Function IsSurrogatePair (highSurrogate As Char, lowSurrogate As Char) As Boolean

Parâmetros

highSurrogate: Char

O caractere a ser avaliado como o substituto alto de um par substituto.

lowSurrogate: Char

O caractere a ser avaliado como o substituto baixo de um par substituto.

Retornos

Boolean

true se o valor numérico do parâmetro highSurrogate variar de U+D800 a U+DBFF e o valor numérico do parâmetro lowSurrogate variar de U+DC00 a U+DFFF, caso contrário, false.

Comentários

Confira também

Aplica-se a

Char.IsSurrogatePair Método

Definição

Sobrecargas

Exemplos

IsSurrogatePair(String, Int32)

Parâmetros

Retornos

Exceções

Comentários

Confira também

Aplica-se a

IsSurrogatePair(Char, Char)

Parâmetros

Retornos

Comentários

Confira também

Aplica-se a

Recursos adicionais