Char.IsSeparator Metodo

Riferimento

Definizione

Spazio dei nomi:: System

Assembly:: mscorlib.dll, System.Runtime.dll

Assembly:: netstandard.dll, System.Runtime.dll

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

Indica se un carattere Unicode è stato categorizzato come carattere separatore.

Overload

IsSeparator(Char)	Indica se il carattere Unicode specificato è stato categorizzato come carattere separatore.
IsSeparator(String, Int32)	Indica se il carattere in corrispondenza della posizione specificata in una determinata stringa è stato categorizzato come carattere separatore.

Commenti

Lo standard Unicode riconosce tre sottocategorie di separatori:

Separatori di spazio (categoria UnicodeCategory.SpaceSeparator ), che include caratteri come \u0020.
Separatori di riga (categoria UnicodeCategory.LineSeparator ), che include \u2028.
Separatori di paragrafo (categoria UnicodeCategory.ParagraphSeparator ), che include \u2029.

Nota

Lo standard Unicode classifica i caratteri \u000A (LF), \u000C (FF) e \u000D (CR) come caratteri di controllo (membri della UnicodeCategory.Control categoria), non come caratteri separatori.

IsSeparator(Char)

Origine:: Char.cs

Origine:: Char.cs

Origine:: Char.cs

Indica se il carattere Unicode specificato è stato categorizzato come carattere separatore.

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

Parametri

c: Char

Carattere Unicode da valutare.

Restituisce

Boolean

true se c è un carattere separatore; in caso contrario, false.

Esempio

Nell'esempio seguente vengono elencati gli Char oggetti classificati come caratteri separatori.

using namespace System;

int main()
{
   for (int ctr = Convert::ToInt32(Char::MinValue); ctr <= Convert::ToInt32(Char::MaxValue); ctr++)
   {
      wchar_t ch = ctr;
      if (Char::IsSeparator(ch))
         Console::WriteLine("\u{0:X4} ({1})", (int) ch, Char::GetUnicodeCategory(ch).ToString());
   }
}
// The example displays the following output:
//       0020 (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)

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)

Commenti

Lo standard Unicode riconosce tre sottocategorie di separatori:

Separatori di spazio (categoria UnicodeCategory.SpaceSeparator ), che include caratteri come \u0020.
Separatori di riga (categoria UnicodeCategory.LineSeparator ), che include \u2028.
Separatori di paragrafo (categoria UnicodeCategory.ParagraphSeparator ), che include \u2029.

Nota

Lo standard Unicode classifica i caratteri \u000A (LF), \u000C (FF) e \u000D (CR) come caratteri di controllo (membri della UnicodeCategory.Control categoria), non come caratteri separatori.

Vedi anche

Si applica a

.NET 10 e altre versioni

Prodotto	Versioni
.NET	Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9, 10
.NET Framework	1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1
.NET Standard	1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 2.0, 2.1
UWP	10.0

IsSeparator(String, Int32)

Origine:: Char.cs

Origine:: Char.cs

Origine:: Char.cs

Indica se il carattere in corrispondenza della posizione specificata in una determinata stringa è stato categorizzato come carattere separatore.

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

Parametri

s: String

Stringa.

index: Int32

Posizione del carattere da valutare in s.

Restituisce

Boolean

true se il carattere alla posizione index in s è un carattere separatore; in caso contrario, false.

Eccezioni

ArgumentNullException

s è null.

ArgumentOutOfRangeException

index è minore di zero o maggiore dell'ultima posizione in s.

Esempio

Nell'esempio seguente viene illustrato IsSeparator.

using namespace System;
int main()
{
   String^ str =  "twain1 twain2";
   Console::WriteLine( Char::IsSeparator( 'a' ) ); // Output: "False"
   Console::WriteLine( Char::IsSeparator( str, 6 ) ); // Output: "True"
}

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

Commenti

Le posizioni dei caratteri in una stringa vengono indicizzate a partire da zero.

Lo standard Unicode riconosce tre sottocategorie di separatori:

Separatori di spazio (categoria UnicodeCategory.SpaceSeparator ), che include caratteri come \u0020.
Separatori di riga (categoria UnicodeCategory.LineSeparator ), che include \u2028.
Separatori di paragrafo (categoria UnicodeCategory.ParagraphSeparator ), che include \u2029.

Nota

Lo standard Unicode classifica i caratteri \u000A (LF), \u000C (FF) e \u000D (CR) come caratteri di controllo (membri della UnicodeCategory.Control categoria), non come caratteri separatori.

Vedi anche

Si applica a

.NET 10 e altre versioni

Prodotto	Versioni
.NET	Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9, 10
.NET Framework	1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1
.NET Standard	1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 2.0, 2.1
UWP	10.0

Condividi tramite

Char.IsSeparator Metodo

Definizione

Overload

Commenti

IsSeparator(Char)

Parametri

Restituisce

Esempio

Commenti

Vedi anche

Si applica a

IsSeparator(String, Int32)

Parametri

Restituisce

Eccezioni

Esempio

Commenti

Vedi anche

Si applica a

Risorse aggiuntive