Char.IsSeparator Método

Definição

Espaço de Nomes:: System

Assemblagens:: mscorlib.dll, System.Runtime.dll

Assemblagens:: netstandard.dll, System.Runtime.dll

Assemblagem:: System.Runtime.dll

Assemblagem:: mscorlib.dll

Assemblagem:: netstandard.dll

Importante

Algumas informações dizem respeito a um produto pré-lançado que pode ser substancialmente modificado antes de ser lançado. A Microsoft não faz garantias, de forma expressa ou implícita, em relação à informação aqui apresentada.

Indica se um carácter Unicode é categorizado como carácter separador.

Sobrecargas

Name	Description
IsSeparator(Char)	Indica se o carácter Unicode especificado está categorizado como carácter separador.
IsSeparator(String, Int32)	Indica se o carácter na posição especificada numa cadeia específica é categorizado como um carácter separador.

Observações

O padrão Unicode reconhece três subcategorias de separadores:

separadores de espaço (a UnicodeCategory.SpaceSeparator categoria), que inclui caracteres como \u0020.
Separadores de linha (a UnicodeCategory.LineSeparator categoria), que inclui \u2028.
Separadores de parágrafo (a UnicodeCategory.ParagraphSeparator categoria), que inclui \u2029.

Note

O padrão Unicode classifica os caracteres \u000A (LF), \u000C (FF) e \u000D (CR) como caracteres de controlo (membros da UnicodeCategory.Control categoria), e não como caracteres separadores.

IsSeparator(Char)

Origem:: Char.cs

Origem:: Char.cs

Origem:: Char.cs

Origem:: Char.cs

Origem:: Char.cs

Indica se o carácter Unicode especificado está categorizado como carácter separador.

public:
 static bool IsSeparator(char c);

public static bool IsSeparator(char c);

static member IsSeparator : char -> bool

Public Shared Function IsSeparator (c As Char) As Boolean

Parâmetros

c: Char

O carácter Unicode a avaliar.

Devoluções

Boolean

true se c for um carácter separador; caso contrário, false.

Exemplos

O exemplo seguinte lista os Char objetos que são classificados como caracteres separadores.

using System;

public class Class1
{
   public static void Main()
   {
      for (int ctr = (int)(Char.MinValue); ctr <= (int)(Char.MaxValue); ctr++)
      {
         char ch = (Char)ctr;
         if (Char.IsSeparator(ch))
            Console.WriteLine(@"\u{(int)ch:X4} ({Char.GetUnicodeCategory(ch)})");
      }
   }
}
// The example displays the following output:
//       \u0020 (SpaceSeparator)
//       \u00A0 (SpaceSeparator)
//       \u1680 (SpaceSeparator)
//       \u180E (SpaceSeparator)
//       \u2000 (SpaceSeparator)
//       \u2001 (SpaceSeparator)
//       \u2002 (SpaceSeparator)
//       \u2003 (SpaceSeparator)
//       \u2004 (SpaceSeparator)
//       \u2005 (SpaceSeparator)
//       \u2006 (SpaceSeparator)
//       \u2007 (SpaceSeparator)
//       \u2008 (SpaceSeparator)
//       \u2009 (SpaceSeparator)
//       \u200A (SpaceSeparator)
//       \u2028 (LineSeparator)
//       \u2029 (ParagraphSeparator)
//       \u202F (SpaceSeparator)
//       \u205F (SpaceSeparator)
//       \u3000 (SpaceSeparator)

open System

for char in Char.MinValue..Char.MaxValue do
    if Char.IsSeparator char then    
        printfn $@"\u{int char:X4} ({Char.GetUnicodeCategory char})"

// The example displays the following output:
//       \u0020 (SpaceSeparator)
//       \u00A0 (SpaceSeparator)
//       \u1680 (SpaceSeparator)
//       \u180E (SpaceSeparator)
//       \u2000 (SpaceSeparator)
//       \u2001 (SpaceSeparator)
//       \u2002 (SpaceSeparator)
//       \u2003 (SpaceSeparator)
//       \u2004 (SpaceSeparator)
//       \u2005 (SpaceSeparator)
//       \u2006 (SpaceSeparator)
//       \u2007 (SpaceSeparator)
//       \u2008 (SpaceSeparator)
//       \u2009 (SpaceSeparator)
//       \u200A (SpaceSeparator)
//       \u2028 (LineSeparator)
//       \u2029 (ParagraphSeparator)
//       \u202F (SpaceSeparator)
//       \u205F (SpaceSeparator)
//       \u3000 (SpaceSeparator)

Module Example
   Public Sub Main()
      For ctr As Integer = Convert.ToInt32(Char.MinValue) To Convert.ToInt32(Char.MaxValue)
         Dim ch As Char = ChrW(ctr)
         If Char.IsSeparator(ch) Then
            Console.WriteLine("\u{0:X4} ({1})", AscW(ch), Char.GetUnicodeCategory(ch).ToString())
         End If
      Next
   End Sub
End Module
' The example displays the following output:
'       \u0020 (SpaceSeparator)
'       \u00A0 (SpaceSeparator)
'       \u1680 (SpaceSeparator)
'       \u180E (SpaceSeparator)
'       \u2000 (SpaceSeparator)
'       \u2001 (SpaceSeparator)
'       \u2002 (SpaceSeparator)
'       \u2003 (SpaceSeparator)
'       \u2004 (SpaceSeparator)
'       \u2005 (SpaceSeparator)
'       \u2006 (SpaceSeparator)
'       \u2007 (SpaceSeparator)
'       \u2008 (SpaceSeparator)
'       \u2009 (SpaceSeparator)
'       \u200A (SpaceSeparator)
'       \u2028 (LineSeparator)
'       \u2029 (ParagraphSeparator)
'       \u202F (SpaceSeparator)
'       \u205F (SpaceSeparator)
'       \u3000 (SpaceSeparator)

Observações

O padrão Unicode reconhece três subcategorias de separadores:

separadores de espaço (a UnicodeCategory.SpaceSeparator categoria), que inclui caracteres como \u0020.
Separadores de linha (a UnicodeCategory.LineSeparator categoria), que inclui \u2028.
Separadores de parágrafo (a UnicodeCategory.ParagraphSeparator categoria), que inclui \u2029.

Note

O padrão Unicode classifica os caracteres \u000A (LF), \u000C (FF) e \u000D (CR) como caracteres de controlo (membros da UnicodeCategory.Control categoria), e não como caracteres separadores.

Ver também

Aplica-se a

IsSeparator(String, Int32)

Origem:: Char.cs

Origem:: Char.cs

Origem:: Char.cs

Origem:: Char.cs

Origem:: Char.cs

Indica se o carácter na posição especificada numa cadeia específica é categorizado como um carácter separador.

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

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

static member IsSeparator : string * int -> bool

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

Parâmetros

s: String

Uma cadeia de caracteres.

index: Int32

A posição do carácter a avaliar em s.

Devoluções

Boolean

true se o carácter na posição index de s for um carácter separador; caso contrário, false.

Exceções

ArgumentNullException

s é null.

ArgumentOutOfRangeException

index é inferior a zero ou maior que a última posição em s.

Exemplos

O exemplo abaixo demonstra IsSeparator.

using System;

public class IsSeparatorSample {
    public static void Main() {
        string str = "twain1 twain2";

        Console.WriteLine(Char.IsSeparator('a'));		// Output: "False"
        Console.WriteLine(Char.IsSeparator(str, 6));	// Output: "True"
    }
}

open System

let str = "twain1 twain2"

printfn $"{Char.IsSeparator 'a'}"       // Output: "False"
printfn $"{Char.IsSeparator(str, 6)}"   // Output: "True"

Module IsSeparatorSample

    Sub Main()

        Dim str As String
        str = "twain1 twain2"

        Console.WriteLine(Char.IsSeparator("a"c))       ' Output: "False"
        Console.WriteLine(Char.IsSeparator(str, 6))     ' Output: "True"

    End Sub

End Module

Observações

As posições dos caracteres numa cadeia são indexadas a partir de zero.

O padrão Unicode reconhece três subcategorias de separadores:

separadores de espaço (a UnicodeCategory.SpaceSeparator categoria), que inclui caracteres como \u0020.
Separadores de linha (a UnicodeCategory.LineSeparator categoria), que inclui \u2028.
Separadores de parágrafo (a UnicodeCategory.ParagraphSeparator categoria), que inclui \u2029.

Note

O padrão Unicode classifica os caracteres \u000A (LF), \u000C (FF) e \u000D (CR) como caracteres de controlo (membros da UnicodeCategory.Control categoria), e não como caracteres separadores.

Ver também

Aplica-se a

Comentários

Esta página foi útil?