Char Struct

Definizione

Spazio dei nomi:

System

Assembly:

System.Runtime.dll

Assembly:

netstandard.dll

Assembly:

mscorlib.dll

Rappresenta un carattere come unità di codice UTF-16.

public value class char : IComparable, IComparable<char>, IConvertible, IEquatable<char>

public value class char : IComparable, IComparable<char>, IConvertible, IEquatable<char>, ISpanFormattable

public value class char : IComparable, IConvertible

public value class char : IComparable, IComparable<char>, IEquatable<char>

public struct Char : IComparable, IComparable<char>, IConvertible, IEquatable<char>

public struct Char : IComparable, IComparable<char>, IConvertible, IEquatable<char>, ISpanFormattable

[System.Serializable]
public struct Char : IComparable, IConvertible

[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public struct Char : IComparable, IComparable<char>, IConvertible, IEquatable<char>

public struct Char : IComparable, IComparable<char>, IEquatable<char>

type char = struct
    interface IConvertible

type char = struct
    interface IConvertible
    interface ISpanFormattable
    interface IFormattable

[<System.Serializable>]
type char = struct
    interface IConvertible

[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type char = struct
    interface IConvertible

type char = struct

Public Structure Char
Implements IComparable, IComparable(Of Char), IConvertible, IEquatable(Of Char)

Public Structure Char
Implements IComparable, IComparable(Of Char), IConvertible, IEquatable(Of Char), ISpanFormattable

Public Structure Char
Implements IComparable, IConvertible

Public Structure Char
Implements IComparable, IComparable(Of Char), IEquatable(Of Char)

Ereditarietà

Object

ValueType

Char

Attributi

SerializableAttribute ComVisibleAttribute

Implementazioni

IComparable IComparable<Char> IConvertible IEquatable<Char> IFormattable ISpanFormattable

Esempio

Nell'esempio di codice seguente vengono illustrati alcuni metodi in Char .

using namespace System;
int main()
{
   char chA = 'A';
   char ch1 = '1';
   String^ str =  "test string";
   Console::WriteLine( chA.CompareTo( 'B' ) ); // Output: "-1" (meaning 'A' is 1 less than 'B')
   Console::WriteLine( chA.Equals( 'A' ) ); // Output: "True"
   Console::WriteLine( Char::GetNumericValue( ch1 ) ); // Output: "1"
   Console::WriteLine( Char::IsControl( '\t' ) ); // Output: "True"
   Console::WriteLine( Char::IsDigit( ch1 ) ); // Output: "True"
   Console::WriteLine( Char::IsLetter( ',' ) ); // Output: "False"
   Console::WriteLine( Char::IsLower( 'u' ) ); // Output: "True"
   Console::WriteLine( Char::IsNumber( ch1 ) ); // Output: "True"
   Console::WriteLine( Char::IsPunctuation( '.' ) ); // Output: "True"
   Console::WriteLine( Char::IsSeparator( str, 4 ) ); // Output: "True"
   Console::WriteLine( Char::IsSymbol( '+' ) ); // Output: "True"
   Console::WriteLine( Char::IsWhiteSpace( str, 4 ) ); // Output: "True"
   Console::WriteLine( Char::Parse(  "S" ) ); // Output: "S"
   Console::WriteLine( Char::ToLower( 'M' ) ); // Output: "m"
   Console::WriteLine( 'x' ); // Output: "x"
}

using System;

public class CharStructureSample
{
    public static void Main()
    {
        char chA = 'A';
        char ch1 = '1';
        string str = "test string";

        Console.WriteLine(chA.CompareTo('B'));          //-----------  Output: "-1" (meaning 'A' is 1 less than 'B')
        Console.WriteLine(chA.Equals('A'));             //-----------  Output: "True"
        Console.WriteLine(Char.GetNumericValue(ch1));   //-----------  Output: "1"
        Console.WriteLine(Char.IsControl('\t'));        //-----------  Output: "True"
        Console.WriteLine(Char.IsDigit(ch1));           //-----------  Output: "True"
        Console.WriteLine(Char.IsLetter(','));          //-----------  Output: "False"
        Console.WriteLine(Char.IsLower('u'));           //-----------  Output: "True"
        Console.WriteLine(Char.IsNumber(ch1));          //-----------  Output: "True"
        Console.WriteLine(Char.IsPunctuation('.'));     //-----------  Output: "True"
        Console.WriteLine(Char.IsSeparator(str, 4));    //-----------  Output: "True"
        Console.WriteLine(Char.IsSymbol('+'));          //-----------  Output: "True"
        Console.WriteLine(Char.IsWhiteSpace(str, 4));   //-----------  Output: "True"
        Console.WriteLine(Char.Parse("S"));             //-----------  Output: "S"
        Console.WriteLine(Char.ToLower('M'));           //-----------  Output: "m"
        Console.WriteLine('x'.ToString());              //-----------  Output: "x"
    }
}

open System

let chA = 'A'
let ch1 = '1'
let str = "test string"

printfn $"{chA.CompareTo 'B'}"          //-----------  Output: "-1" (meaning 'A' is 1 less than 'B')
printfn $"{chA.Equals 'A'}"             //-----------  Output: "True"
printfn $"{Char.GetNumericValue ch1}"   //-----------  Output: "1"
printfn $"{Char.IsControl '\t'}"        //-----------  Output: "True"
printfn $"{Char.IsDigit ch1}"           //-----------  Output: "True"
printfn $"{Char.IsLetter ','}"          //-----------  Output: "False"
printfn $"{Char.IsLower 'u'}"           //-----------  Output: "True"
printfn $"{Char.IsNumber ch1}"          //-----------  Output: "True"
printfn $"{Char.IsPunctuation '.'}"     //-----------  Output: "True"
printfn $"{Char.IsSeparator(str, 4)}"   //-----------  Output: "True"
printfn $"{Char.IsSymbol '+'}"          //-----------  Output: "True"
printfn $"{Char.IsWhiteSpace(str, 4)}"  //-----------  Output: "True"
printfn $"""{Char.Parse "S"}"""         //-----------  Output: "S"
printfn $"{Char.ToLower 'M'}"           //-----------  Output: "m"
printfn $"{'x'}"                        //-----------  Output: "x"

Module CharStructure

    Public Sub Main()

        Dim chA As Char
        chA = "A"c
        Dim ch1 As Char
        ch1 = "1"c
        Dim str As String
        str = "test string"

        Console.WriteLine(chA.CompareTo("B"c))          ' Output: "-1" (meaning 'A' is 1 less than 'B')
        Console.WriteLine(chA.Equals("A"c))             ' Output: "True"
        Console.WriteLine(Char.GetNumericValue(ch1))    ' Output: "1"
        Console.WriteLine(Char.IsControl(Chr(9)))       ' Output: "True"
        Console.WriteLine(Char.IsDigit(ch1))            ' Output: "True"
        Console.WriteLine(Char.IsLetter(","c))          ' Output: "False"
        Console.WriteLine(Char.IsLower("u"c))           ' Output: "True"
        Console.WriteLine(Char.IsNumber(ch1))           ' Output: "True"
        Console.WriteLine(Char.IsPunctuation("."c))     ' Output: "True"
        Console.WriteLine(Char.IsSeparator(str, 4))     ' Output: "True"
        Console.WriteLine(Char.IsSymbol("+"c))          ' Output: "True"
        Console.WriteLine(Char.IsWhiteSpace(str, 4))    ' Output: "True"
        Console.WriteLine(Char.Parse("S"))              ' Output: "S"
        Console.WriteLine(Char.ToLower("M"c))           ' Output: "m"
        Console.WriteLine("x"c.ToString())              ' Output: "x"

    End Sub

End Module

Commenti

.NET usa la Char struttura per rappresentare i punti di codice Unicode usando la codifica UTF-16. Il valore di un Char oggetto è il valore numerico (ordinale) a 16 bit.

Se non si ha familiarità con Unicode, valori scalari, punti di codice, coppie di surrogati, UTF-16 e il tipo, vedere Introduzione alla codifica dei caratteri Rune in .NET.

Nelle sezioni seguenti viene esaminata la relazione tra un oggetto e un carattere Char e vengono illustrate alcune attività comuni eseguite con le istanze di Char . È consigliabile prendere in considerazione il tipo , introdotto Rune in .NET Core 3.0, come alternativa all'esecuzione Char di alcune di queste attività.

• Oggetti Char, caratteri Unicode e stringhe
• Caratteri e categorie di caratteri
• Caratteri ed elementi di testo
• Operazioni comuni
• Valori char e interoperabilità

Oggetti Char, caratteri Unicode e stringhe

Un String oggetto è una raccolta sequenziale di strutture che rappresenta una stringa di Char testo. La maggior parte dei caratteri Unicode può essere rappresentata da un singolo oggetto, ma un carattere codificato come carattere di base, coppia di surrogati e/o sequenza di caratteri di combinazione è rappresentato Char da più Char oggetti . Per questo motivo, una Char struttura in un oggetto non è necessariamente equivalente a un singolo carattere String Unicode.

Più unità di codice a 16 bit vengono usate per rappresentare singoli caratteri Unicode nei casi seguenti:

• Glifi, che possono essere costituiti da un singolo carattere o da un carattere di base seguito da uno o più caratteri di combinazione. Ad esempio, il carattere â è rappresentato da un oggetto la cui unità di codice è U+0061 seguita da un oggetto la cui unità di codice Char Char è U+0308. Il carattere ì può anche essere definito da un singolo oggetto Char con un'unità di codice U+00E4. Nell'esempio seguente viene illustrato che il carattere zioni è costituito da due Char oggetti .

  using System;
  using System.IO;
  
  public class Example
  {
     public static void Main()
     {
        StreamWriter sw = new StreamWriter("chars1.txt");
        char[] chars = { '\u0061', '\u0308' };
        string strng = new String(chars);
        sw.WriteLine(strng);
        sw.Close();
     }
  }
  // The example produces the following output:
  //       ä
  

  open System
  open System.IO
  
  let sw = new StreamWriter("chars1.txt")
  let chars = [| '\u0061'; '\u0308' |]
  let string = String chars
  sw.WriteLine string
  sw.Close()
  
  // The example produces the following output:
  //       ä
  

  Imports System.IO
  
  Module Example
     Public Sub Main()
        Dim sw As New StreamWriter("chars1.txt")
        Dim chars() As Char = { ChrW(&h0061), ChrW(&h0308) }
        Dim strng As New String(chars)
        sw.WriteLine(strng) 
        sw.Close()
     End Sub
  End Module
  ' The example produces the following output:
  '       ä
  

• Caratteri esterni al piano BMP (Basic Multilingual Plane) Unicode. Unicode supporta sedici piani oltre al BMP, che rappresenta il piano 0. Un punto di codice Unicode è rappresentato in UTF-32 da un valore a 21 bit che include il piano. U+1D160, ad esempio, rappresenta il carattere DELLA NOT8A SIMBOLO SYMBOL. Poiché la codifica UTF-16 ha solo 16 bit, i caratteri esterni a BMP sono rappresentati da coppie di surrogati in UTF-16. L'esempio seguente illustra che l'equivalente UTF-32 di U+1D160, il carattere SYMBOL EIGHTH NOTE, è U+D834 U+DD60. U+D834 è il surrogato alto; l'intervallo di surrogati alti va da U+D800 a U+DBFF. U+DD60 è il surrogato basso; i surrogati bassi vanno da U+DC00 a U+DFFF.

  using System;
  using System.IO;
  
  public class Example
  {
     public static void Main()
     {
        StreamWriter sw = new StreamWriter(@".\chars2.txt");
        int utf32 = 0x1D160;
        string surrogate = Char.ConvertFromUtf32(utf32);
        sw.WriteLine("U+{0:X6} UTF-32 = {1} ({2}) UTF-16",
                     utf32, surrogate, ShowCodePoints(surrogate));
        sw.Close();
     }
  
     private static string ShowCodePoints(string value)
     {
        string retval = null;
        foreach (var ch in value)
           retval += String.Format("U+{0:X4} ", Convert.ToUInt16(ch));
  
        return retval.Trim();
     }
  }
  // The example produces the following output:
  //       U+01D160 UTF-32 = ð (U+D834 U+DD60) UTF-16
  

  open System
  open System.IO
  
  let showCodePoints (value: char seq) =
      let str =
          value
          |> Seq.map (fun ch -> $"U+{Convert.ToUInt16 ch:X4}")
          |> String.concat ""
      str.Trim()
  
  let sw = new StreamWriter(@".\chars2.txt")
  let utf32 = 0x1D160
  let surrogate = Char.ConvertFromUtf32 utf32
  sw.WriteLine $"U+{utf32:X6} UTF-32 = {surrogate} ({showCodePoints surrogate}) UTF-16"
  sw.Close()
  
  // The example produces the following output:
  //       U+01D160 UTF-32 = ð (U+D834 U+DD60) UTF-16
  

  Imports System.IO
  
  Module Example
     Public Sub Main()
        Dim sw As New StreamWriter(".\chars2.txt")
        Dim utf32 As Integer = &h1D160
        Dim surrogate As String = Char.ConvertFromUtf32(utf32)
        sw.WriteLine("U+{0:X6} UTF-32 = {1} ({2}) UTF-16", 
                     utf32, surrogate, ShowCodePoints(surrogate))
        sw.Close()                    
     End Sub
  
     Private Function ShowCodePoints(value As String) As String
        Dim retval As String = Nothing
        For Each ch In value
           retval += String.Format("U+{0:X4} ", Convert.ToUInt16(ch))
        Next
        Return retval.Trim()
     End Function
  End Module
  ' The example produces the following output:
  '       U+01D160 UTF-32 = ð (U+D834 U+DD60) UTF-16
  

Caratteri e categorie di caratteri

Ogni carattere Unicode o coppia di surrogati valida appartiene a una categoria Unicode. In .NET le categorie Unicode sono rappresentate dai membri dell'enumerazione e includono valori come UnicodeCategory , e , ad UnicodeCategory.CurrencySymbol UnicodeCategory.LowercaseLetter UnicodeCategory.SpaceSeparator esempio.

Per determinare la categoria Unicode di un carattere, chiamare il GetUnicodeCategory metodo . Nell'esempio seguente viene chiamato per GetUnicodeCategory visualizzare la categoria Unicode di ogni carattere in una stringa. L'esempio funziona correttamente solo se nell'istanza non sono presenti coppie di String surrogati.

using System;
using System.Globalization;

class Example
{
   public static void Main()
   {
      // Define a string with a variety of character categories.
      String s = "The red car drove down the long, narrow, secluded road.";
      // Determine the category of each character.
      foreach (var ch in s)
         Console.WriteLine("'{0}': {1}", ch, Char.GetUnicodeCategory(ch));
   }
}
// The example displays the following output:
//      'T': UppercaseLetter
//      'h': LowercaseLetter
//      'e': LowercaseLetter
//      ' ': SpaceSeparator
//      'r': LowercaseLetter
//      'e': LowercaseLetter
//      'd': LowercaseLetter
//      ' ': SpaceSeparator
//      'c': LowercaseLetter
//      'a': LowercaseLetter
//      'r': LowercaseLetter
//      ' ': SpaceSeparator
//      'd': LowercaseLetter
//      'r': LowercaseLetter
//      'o': LowercaseLetter
//      'v': LowercaseLetter
//      'e': LowercaseLetter
//      ' ': SpaceSeparator
//      'd': LowercaseLetter
//      'o': LowercaseLetter
//      'w': LowercaseLetter
//      'n': LowercaseLetter
//      ' ': SpaceSeparator
//      't': LowercaseLetter
//      'h': LowercaseLetter
//      'e': LowercaseLetter
//      ' ': SpaceSeparator
//      'l': LowercaseLetter
//      'o': LowercaseLetter
//      'n': LowercaseLetter
//      'g': LowercaseLetter
//      ',': OtherPunctuation
//      ' ': SpaceSeparator
//      'n': LowercaseLetter
//      'a': LowercaseLetter
//      'r': LowercaseLetter
//      'r': LowercaseLetter
//      'o': LowercaseLetter
//      'w': LowercaseLetter
//      ',': OtherPunctuation
//      ' ': SpaceSeparator
//      's': LowercaseLetter
//      'e': LowercaseLetter
//      'c': LowercaseLetter
//      'l': LowercaseLetter
//      'u': LowercaseLetter
//      'd': LowercaseLetter
//      'e': LowercaseLetter
//      'd': LowercaseLetter
//      ' ': SpaceSeparator
//      'r': LowercaseLetter
//      'o': LowercaseLetter
//      'a': LowercaseLetter
//      'd': LowercaseLetter
//      '.': OtherPunctuation

open System

// Define a string with a variety of character categories.
let s = "The red car drove down the long, narrow, secluded road."
// Determine the category of each character.
for ch in s do
    printfn $"'{ch}': {Char.GetUnicodeCategory ch}"

// The example displays the following output:
//      'T': UppercaseLetter
//      'h': LowercaseLetter
//      'e': LowercaseLetter
//      ' ': SpaceSeparator
//      'r': LowercaseLetter
//      'e': LowercaseLetter
//      'd': LowercaseLetter
//      ' ': SpaceSeparator
//      'c': LowercaseLetter
//      'a': LowercaseLetter
//      'r': LowercaseLetter
//      ' ': SpaceSeparator
//      'd': LowercaseLetter
//      'r': LowercaseLetter
//      'o': LowercaseLetter
//      'v': LowercaseLetter
//      'e': LowercaseLetter
//      ' ': SpaceSeparator
//      'd': LowercaseLetter
//      'o': LowercaseLetter
//      'w': LowercaseLetter
//      'n': LowercaseLetter
//      ' ': SpaceSeparator
//      't': LowercaseLetter
//      'h': LowercaseLetter
//      'e': LowercaseLetter
//      ' ': SpaceSeparator
//      'l': LowercaseLetter
//      'o': LowercaseLetter
//      'n': LowercaseLetter
//      'g': LowercaseLetter
//      ',': OtherPunctuation
//      ' ': SpaceSeparator
//      'n': LowercaseLetter
//      'a': LowercaseLetter
//      'r': LowercaseLetter
//      'r': LowercaseLetter
//      'o': LowercaseLetter
//      'w': LowercaseLetter
//      ',': OtherPunctuation
//      ' ': SpaceSeparator
//      's': LowercaseLetter
//      'e': LowercaseLetter
//      'c': LowercaseLetter
//      'l': LowercaseLetter
//      'u': LowercaseLetter
//      'd': LowercaseLetter
//      'e': LowercaseLetter
//      'd': LowercaseLetter
//      ' ': SpaceSeparator
//      'r': LowercaseLetter
//      'o': LowercaseLetter
//      'a': LowercaseLetter
//      'd': LowercaseLetter
//      '.': OtherPunctuation

Imports System.Globalization

Module Example
   Public Sub Main()
      ' Define a string with a variety of character categories.
      Dim s As String = "The car drove down the narrow, secluded road."
      ' Determine the category of each character.
      For Each ch In s
         Console.WriteLine("'{0}': {1}", ch, Char.GetUnicodeCategory(ch)) 
      Next
   End Sub
End Module
' The example displays the following output:
'       'T': UppercaseLetter
'       'h': LowercaseLetter
'       'e': LowercaseLetter
'       ' ': SpaceSeparator
'       'r': LowercaseLetter
'       'e': LowercaseLetter
'       'd': LowercaseLetter
'       ' ': SpaceSeparator
'       'c': LowercaseLetter
'       'a': LowercaseLetter
'       'r': LowercaseLetter
'       ' ': SpaceSeparator
'       'd': LowercaseLetter
'       'r': LowercaseLetter
'       'o': LowercaseLetter
'       'v': LowercaseLetter
'       'e': LowercaseLetter
'       ' ': SpaceSeparator
'       'd': LowercaseLetter
'       'o': LowercaseLetter
'       'w': LowercaseLetter
'       'n': LowercaseLetter
'       ' ': SpaceSeparator
'       't': LowercaseLetter
'       'h': LowercaseLetter
'       'e': LowercaseLetter
'       ' ': SpaceSeparator
'       'l': LowercaseLetter
'       'o': LowercaseLetter
'       'n': LowercaseLetter
'       'g': LowercaseLetter
'       ',': OtherPunctuation
'       ' ': SpaceSeparator
'       'n': LowercaseLetter
'       'a': LowercaseLetter
'       'r': LowercaseLetter
'       'r': LowercaseLetter
'       'o': LowercaseLetter
'       'w': LowercaseLetter
'       ',': OtherPunctuation
'       ' ': SpaceSeparator
'       's': LowercaseLetter
'       'e': LowercaseLetter
'       'c': LowercaseLetter
'       'l': LowercaseLetter
'       'u': LowercaseLetter
'       'd': LowercaseLetter
'       'e': LowercaseLetter
'       'd': LowercaseLetter
'       ' ': SpaceSeparator
'       'r': LowercaseLetter
'       'o': LowercaseLetter
'       'a': LowercaseLetter
'       'd': LowercaseLetter
'       '.': OtherPunctuation

Internamente, per i caratteri esterni all'intervallo ASCII (da U+0000 a U+00FF), il metodo dipende dalle categorie GetUnicodeCategory Unicode segnalate dalla CharUnicodeInfo classe . A partire .NET Framework 4.6.2, i caratteri Unicode vengono classificati in base a Standard Unicode, versione 8.0.0. Nelle versioni del .NET Framework da .NET Framework 4 a .NET Framework 4.6.1, vengono classificate in base a Standard Unicode, versione 6.3.0.

Caratteri ed elementi di testo

Poiché un singolo carattere può essere rappresentato da più oggetti, non è sempre Char significativo lavorare con singoli Char oggetti. Ad esempio, l'esempio seguente converte i punti di codice Unicode che rappresentano i numeri Egei da zero a 9 in unità di codice con codifica UTF-16. Poiché equa erroneamente gli oggetti con i caratteri, segnala erroneamente che la stringa risultante contiene Char 20 caratteri.

using System;

public class Example
{
   public static void Main()
   {
      string result = String.Empty;
      for (int ctr = 0x10107; ctr <= 0x10110; ctr++)  // Range of Aegean numbers.
         result += Char.ConvertFromUtf32(ctr);

      Console.WriteLine("The string contains {0} characters.", result.Length);
   }
}
// The example displays the following output:
//     The string contains 20 characters.

open System

let result =
    [ for i in 0x10107..0x10110 do  // Range of Aegean numbers.
        Char.ConvertFromUtf32 i ]
    |> String.concat ""

printfn $"The string contains {result.Length} characters."


// The example displays the following output:
//     The string contains 20 characters.

Module Example
   Public Sub Main()
      Dim result As String = String.Empty
      For ctr As Integer = &h10107 To &h10110     ' Range of Aegean numbers.
         result += Char.ConvertFromUtf32(ctr)
      Next         
      Console.WriteLine("The string contains {0} characters.", result.Length) 
   End Sub
End Module
' The example displays the following output:
'     The string contains 20 characters.

È possibile eseguire le operazioni seguenti per evitare il presupposto che un Char oggetto rappresenti un singolo carattere.

• È possibile usare un oggetto nella sua interezza invece di usare i singoli caratteri per String rappresentare e analizzare il contenuto linguistico.

• È possibile usare String.EnumerateRunes come illustrato nell'esempio seguente:

  int CountLetters(string s)
  {
      int letterCount = 0;
  
      foreach (Rune rune in s.EnumerateRunes())
      {
          if (Rune.IsLetter(rune))
          { letterCount++; }
      }
  
      return letterCount;
  }
  

  let countLetters (s: string) =
      let mutable letterCount = 0
  
      for rune in s.EnumerateRunes() do
          if Rune.IsLetter rune then
              letterCount <- letterCount + 1
  
      letterCount
  

• È possibile usare la StringInfo classe per lavorare con gli elementi di testo anziché con singoli Char oggetti. Nell'esempio seguente viene utilizzato l'oggetto per contare il numero di elementi di testo in una stringa costituita dai numeri StringInfo egei da zero a nove. Poiché considera una coppia di surrogati un singolo carattere, segnala correttamente che la stringa contiene dieci caratteri.

  using System;
  using System.Globalization;
  
  public class Example
  {
     public static void Main()
     {
        string result = String.Empty;
        for (int ctr = 0x10107; ctr <= 0x10110; ctr++)  // Range of Aegean numbers.
           result += Char.ConvertFromUtf32(ctr);
  
        StringInfo si = new StringInfo(result);
        Console.WriteLine("The string contains {0} characters.",
                          si.LengthInTextElements);
     }
  }
  // The example displays the following output:
  //       The string contains 10 characters.
  

  open System
  open System.Globalization
  
  let result =
      [ for i in 0x10107..0x10110 do  // Range of Aegean numbers.
          Char.ConvertFromUtf32 i ]
      |> String.concat ""
  
  
  let si = StringInfo result
  printfn $"The string contains {si.LengthInTextElements} characters."
  
  // The example displays the following output:
  //       The string contains 10 characters.
  

  Imports System.Globalization
  
  Module Example
     Public Sub Main()
        Dim result As String = String.Empty
        For ctr As Integer = &h10107 To &h10110     ' Range of Aegean numbers.
           result += Char.ConvertFromUtf32(ctr)
        Next         
        Dim si As New StringInfo(result)
        Console.WriteLine("The string contains {0} characters.", si.LengthInTextElements) 
     End Sub
  End Module
  ' The example displays the following output:
  '       The string contains 10 characters.
  

• Se una stringa contiene un carattere di base con uno o più caratteri di combinazione, è possibile chiamare il metodo per convertire la sottostringa in una singola unità di codice con codifica String.Normalize UTF-16. Nell'esempio seguente viene chiamato il metodo per convertire il carattere di base U+0061 (LATIN SMALL LETTER A) e la combinazione del carattere String.Normalize U+0308 (COMBINING DIAERESIS) in U+00E4 (LATIN SMALL LETTER A WITH DIAERESIS).

  using System;
  
  public class Example
  {
     public static void Main()
     {
        string combining = "\u0061\u0308";
        ShowString(combining);
  
        string normalized = combining.Normalize();
        ShowString(normalized);
     }
  
     private static void ShowString(string s)
     {
        Console.Write("Length of string: {0} (", s.Length);
        for (int ctr = 0; ctr < s.Length; ctr++) {
           Console.Write("U+{0:X4}", Convert.ToUInt16(s[ctr]));
           if (ctr != s.Length - 1) Console.Write(" ");
        }
        Console.WriteLine(")\n");
     }
  }
  // The example displays the following output:
  //       Length of string: 2 (U+0061 U+0308)
  //
  //       Length of string: 1 (U+00E4)
  

  open System
  
  let showString (s: string) =
      printf $"Length of string: {s.Length} ("
      for i = 0 to s.Length - 1 do
          printf $"U+{Convert.ToUInt16 s[i]:X4}"
          if i <> s.Length - 1 then printf " "
      printfn ")\n"
  
  let combining = "\u0061\u0308"
  showString combining
  
  let normalized = combining.Normalize()
  showString normalized
  
  // The example displays the following output:
  //       Length of string: 2 (U+0061 U+0308)
  //
  //       Length of string: 1 (U+00E4)
  

  Module Example
     Public Sub Main()
        Dim combining As String = ChrW(&h0061) + ChrW(&h0308)
        ShowString(combining)
        
        Dim normalized As String = combining.Normalize()
        ShowString(normalized)
     End Sub
     
     Private Sub ShowString(s As String)
        Console.Write("Length of string: {0} (", s.Length)
        For ctr As Integer = 0 To s.Length - 1
           Console.Write("U+{0:X4}", Convert.ToUInt16(s(ctr)))
           If ctr <> s.Length - 1 Then Console.Write(" ")
        Next 
        Console.WriteLine(")")
        Console.WriteLine()
     End Sub
  End Module
  ' The example displays the following output:
  '       Length of string: 2 (U+0061 U+0308)
  '       
  '       Length of string: 1 (U+00E4)
  

Operazioni comuni

La struttura fornisce metodi per confrontare oggetti, convertire il valore dell'oggetto corrente in un oggetto di un altro tipo e determinare la Char categoria Unicode di un Char Char Char oggetto:

Per	Usare questi System.Char metodi
Confrontare Char oggetti	CompareTo e Equals
Convertire un punto di codice in una stringa	ConvertFromUtf32 Vedere anche il Rune tipo .
Convertire un Char oggetto o una coppia di surrogati di oggetti in un punto di Char codice	Per un singolo carattere: Convert.ToInt32(Char) Per una coppia di surrogati o un carattere in una stringa: Char.ConvertToUtf32 Vedere anche il Rune tipo .
Ottenere la categoria Unicode di un carattere	GetUnicodeCategory Vedere anche Rune.GetUnicodeCategory.
Determinare se un carattere si trova in una particolare categoria Unicode, ad esempio cifra, lettera, punteggiatura, carattere di controllo e così via	IsControl, IsDigit IsHighSurrogate , , , , IsLetter , , , , , , , IsLetterOrDigit , , IsLower IsLowSurrogate IsNumber IsPunctuation IsSeparator IsSurrogate IsSurrogatePair IsSymbol IsUpper e IsWhiteSpace Vedere anche i metodi corrispondenti sul Rune tipo.
Convertire un Char oggetto che rappresenta un numero in un tipo di valore numerico	GetNumericValue Vedere anche Rune.GetNumericValue.
Convertire un carattere in una stringa in un Char oggetto	Parse e TryParse
Convertire un Char oggetto in un String oggetto	ToString
Modificare la distinzione tra maiuscole e minuscole di un Char oggetto	ToLower, ToLowerInvariant, ToUpper e ToUpperInvariant Vedere anche i metodi corrispondenti sul Rune tipo.

Valori char e interoperabilità

Quando un tipo gestito, rappresentato come unità di codice con codifica Unicode UTF-16, viene passato al codice non gestito, il gestore di marshalling di interoperabilità converte il set di caratteri in ANSI per impostazione Char predefinita. È possibile applicare l'attributo alle platform invoke e l'attributo a una dichiarazione di interoperabilità COM per controllare il set di caratteri utilizzato DllImportAttribute da un tipo sottoposto a StructLayoutAttribute Char marshalling.

Campi

MaxValue	Rappresenta il valore massimo possibile di Char. Questo campo è costante.
MinValue	Rappresenta il valore minimo possibile di un oggetto Char. Questo campo è costante.

Metodi

CompareTo(Char)	Confronta questa istanza con un oggetto Char specificato e indica se l'istanza precede, segue o viene visualizzata nella stessa posizione dell'oggetto Char specificato all'interno dell'ordinamento.
CompareTo(Object)	Confronta questa istanza con un oggetto specificato e indica se l'istanza precede, segue o viene visualizzata nella stessa posizione dell'oggetto Object specificato all'interno dell'ordinamento.
ConvertFromUtf32(Int32)	Converte il punto di codice Unicode specificato in una stringa codificata UTF-16.
ConvertToUtf32(Char, Char)	Converte il valore di una coppia di surrogati codificata UTF-16 in un punto di codice Unicode.
ConvertToUtf32(String, Int32)	In corrispondenza della posizione specificata all'interno di una stringa, converte il valore di un carattere o di una coppia di surrogati con codifica UTF-16 in un punto di codice Unicode.
Equals(Char)	Restituisce un valore che indica se questa istanza è uguale all'oggetto Char specificato.
Equals(Object)	Restituisce un valore che indica se questa istanza è uguale a un oggetto specificato.
GetHashCode()	Restituisce il codice hash per l'istanza.
GetNumericValue(Char)	Converte il carattere numerico Unicode specificato in un numero a virgola mobile a precisione doppia.
GetNumericValue(String, Int32)	Converte il carattere numerico Unicode nella posizione specificata di una determinata stringa in un numero a virgola mobile a precisione doppia.
GetTypeCode()	Restituisce l'oggetto TypeCode del tipo di valore Char.
GetUnicodeCategory(Char)	Categorizza un carattere Unicode specificato in un gruppo identificato da uno dei valori UnicodeCategory.
GetUnicodeCategory(String, Int32)	Categorizza il carattere in corrispondenza della posizione specificata in una determinata stringa in un gruppo identificato da uno dei valori UnicodeCategory.
IsAscii(Char)	Restituisce true se è un carattere ASCII c ([ U+0000..U+007F ]).
IsControl(Char)	Indica se il carattere Unicode specificato è stato categorizzato come carattere di controllo.
IsControl(String, Int32)	Indica se il carattere in corrispondenza della posizione specificata in una determinata stringa è stato categorizzato come carattere di controllo.
IsDigit(Char)	Indica se il carattere Unicode specificato è stato categorizzato come cifra decimale.
IsDigit(String, Int32)	Indica se il carattere in corrispondenza della posizione specificata in una determinata stringa è stato categorizzato come cifra decimale.
IsHighSurrogate(Char)	Indica se l'oggetto Char specificato è un surrogato alto.
IsHighSurrogate(String, Int32)	Indica se l'oggetto Char in corrispondenza della posizione specificata all'interno di una stringa è un surrogato alto.
IsLetter(Char)	Indica se il carattere Unicode specificato è stato categorizzato come lettera Unicode.
IsLetter(String, Int32)	Indica se il carattere in corrispondenza della posizione specificata in una determinata stringa è stato categorizzato come lettera Unicode.
IsLetterOrDigit(Char)	Indica se il carattere Unicode specificato è stato categorizzato come lettera o cifra decimale.
IsLetterOrDigit(String, Int32)	Indica se il carattere in corrispondenza della posizione specificata in una determinata stringa è stato categorizzato come lettera o cifra decimale.
IsLower(Char)	Indica se il carattere Unicode specificato è stato categorizzato come lettera minuscola.
IsLower(String, Int32)	Indica se il carattere in corrispondenza della posizione specificata in una determinata stringa è stato categorizzato come lettera minuscola.
IsLowSurrogate(Char)	Indica se l'oggetto Char specificato è un surrogato basso.
IsLowSurrogate(String, Int32)	Indica se l'oggetto Char in corrispondenza della posizione specificata all'interno di una stringa è un surrogato basso.
IsNumber(Char)	Indica se il carattere Unicode specificato è stato categorizzato come numero.
IsNumber(String, Int32)	Indica se il carattere in corrispondenza della posizione specificata in una determinata stringa è stato categorizzato come numero.
IsPunctuation(Char)	Indica se il carattere Unicode specificato è stato categorizzato come segno di punteggiatura.
IsPunctuation(String, Int32)	Indica se il carattere in corrispondenza della posizione specificata in una determinata stringa è stato categorizzato come segno di punteggiatura.
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.
IsSurrogate(Char)	Indica se il carattere specificato dispone di un'unità di codice surrogato.
IsSurrogate(String, Int32)	Indica se il carattere in corrispondenza della posizione specificata in una determinata stringa dispone di un'unità di codice surrogato.
IsSurrogatePair(Char, Char)	Indica se i due oggetti Char specificati formano una coppia di surrogati.
IsSurrogatePair(String, Int32)	Indica se due oggetti Char adiacenti in corrispondenza di una posizione specificata all'interno di una stringa formano una coppia di surrogati.
IsSymbol(Char)	Indica se il carattere Unicode specificato è stato categorizzato come carattere simbolo.
IsSymbol(String, Int32)	Indica se il carattere in corrispondenza della posizione specificata in una determinata stringa è stato categorizzato come carattere simbolo.
IsUpper(Char)	Indica se il carattere Unicode specificato è stato categorizzato come lettera maiuscola.
IsUpper(String, Int32)	Indica se il carattere in corrispondenza della posizione specificata in una determinata stringa è stato categorizzato come lettera maiuscola.
IsWhiteSpace(Char)	Indica se il carattere Unicode specificato è stato categorizzato come spazio.
IsWhiteSpace(String, Int32)	Indica se il carattere in corrispondenza della posizione specificata in una determinata stringa è stato categorizzato come spazio.
Parse(String)	Converte il valore della stringa specificata nell'equivalente carattere Unicode.
ToLower(Char)	Converte il valore di un carattere Unicode nell'equivalente carattere minuscolo.
ToLower(Char, CultureInfo)	Converte il valore di uno specifico carattere Unicode nell'equivalente carattere minuscolo mediante le informazioni di formattazione relative alle impostazioni cultura specificate.
ToLowerInvariant(Char)	Converte il valore di un carattere Unicode nell'equivalente carattere minuscolo mediante le regole relative all'utilizzo di maiuscole e minuscole delle impostazioni cultura invarianti.
ToString()	Converte il valore dell'istanza corrente nell'equivalente rappresentazione di stringa.
ToString(Char)	Converte il carattere Unicode specificato nell'equivalente rappresentazione di stringa.
ToString(IFormatProvider)	Converte il valore dell'istanza corrente nella rappresentazione di stringa equivalente, usando le informazioni sul formato relative alle impostazioni cultura specificate.
ToUpper(Char)	Converte il valore di un carattere Unicode nell'equivalente carattere maiuscolo.
ToUpper(Char, CultureInfo)	Converte il valore di uno specifico carattere Unicode nell'equivalente carattere maiuscolo mediante le informazioni di formattazione relative alle impostazioni cultura specificate.
ToUpperInvariant(Char)	Converte il valore di un carattere Unicode nell'equivalente carattere maiuscolo mediante le regole relative all'utilizzo di maiuscole e minuscole delle impostazioni cultura invarianti.
TryParse(String, Char)	Converte il valore della stringa specificata nell'equivalente carattere Unicode. Un codice restituito indica se la conversione ha avuto esito positivo o negativo.

Implementazioni dell'interfaccia esplicita

IComparable.CompareTo(Object)	Confronta l'istanza corrente con un altro oggetto dello stesso tipo e restituisce un intero che indica se l'istanza corrente precede, segue o si trova nella stessa posizione dell'altro oggetto all'interno dell'ordinamento.
IConvertible.GetTypeCode()	Restituisce l'oggetto TypeCode per questa istanza.
IConvertible.ToBoolean(IFormatProvider)	Nota Questa conversione non è supportata. Qualsiasi tentativo di eseguire tale operazione genera un'eccezione InvalidCastException.
IConvertible.ToByte(IFormatProvider)	Per una descrizione di questo membro, vedere ToByte(IFormatProvider).
IConvertible.ToChar(IFormatProvider)	Per una descrizione di questo membro, vedere ToChar(IFormatProvider).
IConvertible.ToDateTime(IFormatProvider)	Nota Questa conversione non è supportata. Qualsiasi tentativo di eseguire tale operazione genera un'eccezione InvalidCastException.
IConvertible.ToDecimal(IFormatProvider)	Nota Questa conversione non è supportata. Qualsiasi tentativo di eseguire tale operazione genera un'eccezione InvalidCastException.
IConvertible.ToDouble(IFormatProvider)	Nota Questa conversione non è supportata. Qualsiasi tentativo di eseguire tale operazione genera un'eccezione InvalidCastException.
IConvertible.ToInt16(IFormatProvider)	Per una descrizione di questo membro, vedere ToInt16(IFormatProvider).
IConvertible.ToInt32(IFormatProvider)	Per una descrizione di questo membro, vedere ToInt32(IFormatProvider).
IConvertible.ToInt64(IFormatProvider)	Per una descrizione di questo membro, vedere ToInt64(IFormatProvider).
IConvertible.ToSByte(IFormatProvider)	Per una descrizione di questo membro, vedere ToSByte(IFormatProvider).
IConvertible.ToSingle(IFormatProvider)	Nota Questa conversione non è supportata. Qualsiasi tentativo di eseguire tale operazione genera un'eccezione InvalidCastException.
IConvertible.ToString(IFormatProvider)	Converte il valore di questa istanza in una stringa equivalente usando le informazioni di formattazione specifiche delle impostazioni cultura.
IConvertible.ToType(Type, IFormatProvider)	Per una descrizione di questo membro, vedere ToType(Type, IFormatProvider).
IConvertible.ToUInt16(IFormatProvider)	Per una descrizione di questo membro, vedere ToUInt16(IFormatProvider).
IConvertible.ToUInt32(IFormatProvider)	Per una descrizione di questo membro, vedere ToUInt32(IFormatProvider).
IConvertible.ToUInt64(IFormatProvider)	Per una descrizione di questo membro, vedere ToUInt64(IFormatProvider).
IFormattable.ToString(String, IFormatProvider)	Formatta il valore dell'istanza corrente usando il formato specificato.
ISpanFormattable.TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Tenta di formattare il valore dell'istanza corrente nell'intervallo di caratteri specificato.

Thread safety

Tutti i membri di questo tipo sono thread-safe. I membri che sembrano modificare lo stato dell'istanza restituiscono effettivamente una nuova istanza inizializzata con il nuovo valore. Come per qualsiasi altro tipo, la lettura e la scrittura in una variabile condivisa che contiene un'istanza di questo tipo devono essere protette da un blocco per garantire la thread safety.

Vedi anche

• IComparable
• IConvertible
• String