Questo articolo è stato tradotto automaticamente. Per visualizzare l'articolo in inglese, selezionare la casella di controllo Inglese. È possibile anche visualizzare il testo inglese in una finestra popup posizionando il puntatore del mouse sopra il testo.
Traduzione
Inglese

Struttura Char

 

Data di pubblicazione: agosto 2016

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

Spazio dei nomi:   System
Assembly:  mscorlib (in mscorlib.dll)

[SerializableAttribute]
[ComVisibleAttribute(true)]
public struct Char : IComparable, IConvertible, IComparable<char>, 
	IEquatable<char>

NomeDescrizione
System_CAPS_pubmethodCompareTo(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.

System_CAPS_pubmethodCompareTo(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.

System_CAPS_pubmethodSystem_CAPS_staticConvertFromUtf32(Int32)

Converte il punto di codice Unicode specificato in una stringa codificata UTF-16.

System_CAPS_pubmethodSystem_CAPS_staticConvertToUtf32(Char, Char)

Converte il valore di una coppia di surrogati codificata UTF-16 in un punto di codice Unicode.

System_CAPS_pubmethodSystem_CAPS_staticConvertToUtf32(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.

System_CAPS_pubmethodEquals(Char)

Restituisce un valore che indica se questa istanza è uguale all'oggetto Char specificato.

System_CAPS_pubmethodEquals(Object)

Restituisce un valore che indica se questa istanza è uguale ad un oggetto specificato. (Esegue l'override di ValueType.Equals(Object).)

System_CAPS_pubmethodGetHashCode()

Restituisce il codice hash per questa istanza. (Esegue l'override di ValueType.GetHashCode().)

System_CAPS_pubmethodSystem_CAPS_staticGetNumericValue(Char)

Converte il carattere numerico Unicode specificato in un numero in virgola mobile a doppia precisione.

System_CAPS_pubmethodSystem_CAPS_staticGetNumericValue(String, Int32)

Converte il carattere numerico Unicode nella posizione specificata di una determinata stringa in un numero in virgola mobile a precisione doppia.

System_CAPS_pubmethodGetType()

Ottiene l'oggetto Type dell'istanza corrente.(Ereditato da Object.)

System_CAPS_pubmethodGetTypeCode()

Restituisce l'oggetto TypeCode del tipo di valore Char.

System_CAPS_pubmethodSystem_CAPS_staticGetUnicodeCategory(Char)

Categorizza un carattere Unicode specificato in un gruppo identificato da uno dei valori UnicodeCategory.

System_CAPS_pubmethodSystem_CAPS_staticGetUnicodeCategory(String, Int32)

Categorizza il carattere in corrispondenza della posizione specificata in una determinata stringa in un gruppo identificato da uno dei valori UnicodeCategory.

System_CAPS_pubmethodSystem_CAPS_staticIsControl(Char)

Indica se il carattere Unicode specificato è categorizzato come un carattere di controllo.

System_CAPS_pubmethodSystem_CAPS_staticIsControl(String, Int32)

Indica se il carattere in corrispondenza della posizione specificata in una determinata stringa è categorizzato come un carattere di controllo.

System_CAPS_pubmethodSystem_CAPS_staticIsDigit(Char)

Indica se il carattere Unicode specificato è stato categorizzato come una cifra decimale.

System_CAPS_pubmethodSystem_CAPS_staticIsDigit(String, Int32)

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

System_CAPS_pubmethodSystem_CAPS_staticIsHighSurrogate(Char)

Indica se l'oggetto Char specificato è un surrogato alto.

System_CAPS_pubmethodSystem_CAPS_staticIsHighSurrogate(String, Int32)

Indica se l'oggetto Char in corrispondenza della posizione specificata all'interno di una stringa è un surrogato alto.

System_CAPS_pubmethodSystem_CAPS_staticIsLetter(Char)

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

System_CAPS_pubmethodSystem_CAPS_staticIsLetter(String, Int32)

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

System_CAPS_pubmethodSystem_CAPS_staticIsLetterOrDigit(Char)

Indica se il carattere Unicode specificato è stato categorizzato come una lettera o una cifra decimale.

System_CAPS_pubmethodSystem_CAPS_staticIsLetterOrDigit(String, Int32)

Indica se il carattere in corrispondenza della posizione specificata in una determinata stringa è categorizzato come una lettera o una cifra decimale.

System_CAPS_pubmethodSystem_CAPS_staticIsLower(Char)

Indica se il carattere Unicode specificato è categorizzato come una lettera minuscola.

System_CAPS_pubmethodSystem_CAPS_staticIsLower(String, Int32)

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

System_CAPS_pubmethodSystem_CAPS_staticIsLowSurrogate(Char)

Indica se l'oggetto Char specificato è un surrogato basso.

System_CAPS_pubmethodSystem_CAPS_staticIsLowSurrogate(String, Int32)

Indica se l'oggetto Char in corrispondenza della posizione specificata all'interno di una stringa è un surrogato basso.

System_CAPS_pubmethodSystem_CAPS_staticIsNumber(Char)

Indica se il carattere Unicode specificato è categorizzato come un numero.

System_CAPS_pubmethodSystem_CAPS_staticIsNumber(String, Int32)

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

System_CAPS_pubmethodSystem_CAPS_staticIsPunctuation(Char)

Indica se il carattere Unicode specificato è categorizzato come un segno di punteggiatura.

System_CAPS_pubmethodSystem_CAPS_staticIsPunctuation(String, Int32)

Indica se il carattere in corrispondenza della posizione specificata in una determinata stringa è categorizzato come un segno di punteggiatura.

System_CAPS_pubmethodSystem_CAPS_staticIsSeparator(Char)

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

System_CAPS_pubmethodSystem_CAPS_staticIsSeparator(String, Int32)

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

System_CAPS_pubmethodSystem_CAPS_staticIsSurrogate(Char)

Indica se il carattere specificato dispone di un'unità di codice surrogata.

System_CAPS_pubmethodSystem_CAPS_staticIsSurrogate(String, Int32)

Indica se il carattere in corrispondenza della posizione specificata in una determinata stringa dispone di un'unità di codice surrogata.

System_CAPS_pubmethodSystem_CAPS_staticIsSurrogatePair(Char, Char)

Indica se i due oggetti Char specificati formano una coppia di surrogati.

System_CAPS_pubmethodSystem_CAPS_staticIsSurrogatePair(String, Int32)

Indica se due oggetti Char adiacenti in corrispondenza di una posizione specificata all'interno di una stringa formano una coppia di surrogati.

System_CAPS_pubmethodSystem_CAPS_staticIsSymbol(Char)

Indica se il carattere Unicode specificato è categorizzato come un carattere simbolo.

System_CAPS_pubmethodSystem_CAPS_staticIsSymbol(String, Int32)

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

System_CAPS_pubmethodSystem_CAPS_staticIsUpper(Char)

Indica se il carattere Unicode specificato è categorizzato come una lettera maiuscola.

System_CAPS_pubmethodSystem_CAPS_staticIsUpper(String, Int32)

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

System_CAPS_pubmethodSystem_CAPS_staticIsWhiteSpace(Char)

Indica se il carattere Unicode specificato è categorizzato come uno spazio.

System_CAPS_pubmethodSystem_CAPS_staticIsWhiteSpace(String, Int32)

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

System_CAPS_pubmethodSystem_CAPS_staticParse(String)

Converte il valore della stringa specificata nel suo equivalente carattere Unicode.

System_CAPS_pubmethodSystem_CAPS_staticToLower(Char)

Converte il valore di un carattere Unicode nel suo equivalente carattere minuscolo.

System_CAPS_pubmethodSystem_CAPS_staticToLower(Char, CultureInfo)

Converte il valore di uno specifico carattere Unicode nel suo equivalente carattere minuscolo mediante le informazioni di formattazione relative alle impostazioni di cultura specificate.

System_CAPS_pubmethodSystem_CAPS_staticToLowerInvariant(Char)

Converte il valore di un carattere Unicode nel suo equivalente carattere minuscolo mediante le regole relative all'utilizzo di maiuscole e minuscole delle impostazioni di cultura invarianti.

System_CAPS_pubmethodToString()

Converte il valore dell'istanza corrente nella sua equivalente rappresentazione in forma di stringa. (Esegue l'override di ValueType.ToString().)

System_CAPS_pubmethodSystem_CAPS_staticToString(Char)

Converte il carattere Unicode specificato nella sua equivalente rappresentazione in forma di stringa.

System_CAPS_pubmethodToString(IFormatProvider)

Converte il valore dell'istanza corrente nella sua rappresentazione equivalente in forma di stringa, utilizzando le informazioni sul formato relative alle impostazioni di cultura specificate.

System_CAPS_pubmethodSystem_CAPS_staticToUpper(Char)

Converte il valore di un carattere Unicode nel suo equivalente carattere maiuscolo.

System_CAPS_pubmethodSystem_CAPS_staticToUpper(Char, CultureInfo)

Converte il valore di uno specifico carattere Unicode nel suo equivalente carattere maiuscolo mediante le informazioni di formattazione relative alle impostazioni di cultura specificate.

System_CAPS_pubmethodSystem_CAPS_staticToUpperInvariant(Char)

Converte il valore di un carattere Unicode nell'equivalente carattere maiuscolo mediante le regole relative all'utilizzo di maiuscole e minuscole delle impostazioni di cultura invarianti.

System_CAPS_pubmethodSystem_CAPS_staticTryParse(String, Char)

Converte il valore della stringa specificata nel suo equivalente carattere Unicode. Un codice restituito indica se la conversione ha avuto esito positivo o negativo.

NomeDescrizione
System_CAPS_pubfieldSystem_CAPS_staticMaxValue

Rappresenta il valore massimo possibile di Char. Questo campo è costante.

System_CAPS_pubfieldSystem_CAPS_staticMinValue

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

NomeDescrizione
System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToBoolean(IFormatProvider)

Questa API supporta l'infrastruttura prodotto e non può essere usata direttamente dal codice. Nota   Questa conversione non è supportata. Qualsiasi tentativo di eseguire tale operazione genera un'eccezione InvalidCastException.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToByte(IFormatProvider)

Questa API supporta l'infrastruttura prodotto e non può essere usata direttamente dal codice. Per una descrizione di questo membro, vedere IConvertible.ToByte.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToChar(IFormatProvider)

Questa API supporta l'infrastruttura prodotto e non può essere usata direttamente dal codice. Per una descrizione di questo membro, vedere IConvertible.ToChar.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToDateTime(IFormatProvider)

Questa API supporta l'infrastruttura prodotto e non può essere usata direttamente dal codice. Nota   Questa conversione non è supportata. Qualsiasi tentativo di eseguire tale operazione genera un'eccezione InvalidCastException.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToDecimal(IFormatProvider)

Questa API supporta l'infrastruttura prodotto e non può essere usata direttamente dal codice. Nota   Questa conversione non è supportata. Qualsiasi tentativo di eseguire tale operazione genera un'eccezione InvalidCastException.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToDouble(IFormatProvider)

Questa API supporta l'infrastruttura prodotto e non può essere usata direttamente dal codice. Nota   Questa conversione non è supportata. Qualsiasi tentativo di eseguire tale operazione genera un'eccezione InvalidCastException.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToInt16(IFormatProvider)

Questa API supporta l'infrastruttura prodotto e non può essere usata direttamente dal codice. Per una descrizione di questo membro, vedere IConvertible.ToInt16.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToInt32(IFormatProvider)

Questa API supporta l'infrastruttura prodotto e non può essere usata direttamente dal codice. Per una descrizione di questo membro, vedere IConvertible.ToInt32.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToInt64(IFormatProvider)

Questa API supporta l'infrastruttura prodotto e non può essere usata direttamente dal codice. Per una descrizione di questo membro, vedere IConvertible.ToInt64.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToSByte(IFormatProvider)

Questa API supporta l'infrastruttura prodotto e non può essere usata direttamente dal codice. Per una descrizione di questo membro, vedere IConvertible.ToSByte.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToSingle(IFormatProvider)

Questa API supporta l'infrastruttura prodotto e non può essere usata direttamente dal codice. Nota   Questa conversione non è supportata. Qualsiasi tentativo di eseguire tale operazione genera un'eccezione InvalidCastException.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToType(Type, IFormatProvider)

Questa API supporta l'infrastruttura prodotto e non può essere usata direttamente dal codice. Per una descrizione di questo membro, vedere IConvertible.ToType.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToUInt16(IFormatProvider)

Questa API supporta l'infrastruttura prodotto e non può essere usata direttamente dal codice. Per una descrizione di questo membro, vedere IConvertible.ToUInt16.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToUInt32(IFormatProvider)

Questa API supporta l'infrastruttura prodotto e non può essere usata direttamente dal codice. Per una descrizione di questo membro, vedere IConvertible.ToUInt32.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToUInt64(IFormatProvider)

Questa API supporta l'infrastruttura prodotto e non può essere usata direttamente dal codice. Per una descrizione di questo membro, vedere IConvertible.ToUInt64.

Il .NET Framework utilizza il Char struttura per rappresentare un carattere Unicode. Lo Unicode Standard identifica ogni carattere Unicode con un numero scalare univoco a 21 bit chiamato un punto di codice e definisce il formato di codifica UTF-16 che specifica le modalità di codifica di un punto di codice in una sequenza di uno o più valori a 16 bit. Ogni valore a 16 bit compreso tra esadecimali 0x0000 e 0xFFFF, viene archiviato in un Char struttura. Il valore di un Char oggetto è un valore numerico a 16 bit (ordinale).

Nelle sezioni seguenti di esaminare la relazione tra un Char oggetto e un carattere e illustrano alcune attività comuni con Char istanze.

Oggetti char, caratteri Unicode e stringhe
Caratteri e le categorie di caratteri
Caratteri e gli elementi di testo
Operazioni comuni
Interoperabilità e valori Char

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

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

  • Icone, possono essere costituita da un singolo carattere o un carattere di base seguiti da uno o più caratteri di combinazione. Ad esempio, il carattere ä è rappresentato da un Char il cui codice unità è U + 0061 seguito da un oggetto Char oggetto la cui unità di codice è U + 0308. (Il carattere ä può essere definito anche da un unico Char oggetto che dispone di un'unità di codice di U + 00E4.) Nell'esempio seguente viene illustrato che il carattere ä costituita 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:
    //       ä
    
  • Caratteri di fuori di Unicode Basic Multilingual Plane (BMP). Unicode supporta sedici piani oltre a 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. Ad esempio U + 1D160 rappresenta il carattere di simbolo MUSICALE. Perché la codifica UTF-16 è solo a 16 bit, i caratteri di fuori di BMP sono rappresentati da coppie di surrogati UTF-16. Nell'esempio seguente viene illustrato che l'equivalente di UTF-32 di U + 1D160, il carattere di simbolo MUSICALE, è U + D834 U + DD60. U + D834 è il surrogato alto; surrogati alti vanno da U + D800 e U + DBFF. U + DD60 è il surrogato basso; surrogati bassi vanno da U + DC00 e 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
    

Ogni coppia di surrogati valida o un carattere Unicode appartiene a una categoria Unicode. In .NET Framework, alle categorie Unicode sono rappresentate dai membri del UnicodeCategory enumerazione e includere i valori, ad esempio UnicodeCategory.CurrencySymbol, UnicodeCategory.LowercaseLetter, e UnicodeCategory.SpaceSeparator, ad esempio.

Per determinare la categoria Unicode di un carattere, chiamare il GetUnicodeCategory metodo. Ad esempio, nell'esempio seguente chiama il GetUnicodeCategory per visualizzare la categoria Unicode di ogni carattere in una stringa.

using System;
using System.Globalization;

class Example
{
   public static void Main()
   {
      // Define a string with a variety of character categories.
      String s = "The car drove down the 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

Internamente, i caratteri di fuori dell'intervallo ASCII (U + 0000 a U + 00FF), il GetUnicodeCategory metodo dipende dalle categorie Unicode segnalate dalla CharUnicodeInfo classe. A partire dal .NET Framework 4.6.2, caratteri Unicode vengono classificati in base alle The Unix Standard, Version 8.0.0. Nelle versioni di .NET Framework dal .NET Framework 4 per il .NET Framework 4.6.1, sono classificati in base a The Unix Standard, Version 6.3.0.

Poiché un singolo carattere può essere rappresentato da più Char oggetti, non è sempre significativo per lavorare con singole Char oggetti. Ad esempio, nell'esempio seguente converte i punti di codice Unicode che rappresentano i numeri Egeo zero a 9 per unità di codice codificata UTF-16. Poiché erroneamente equivale Char gli oggetti con caratteri, in modo non corretto, segnala che la stringa risultante è di 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.

È possibile eseguire il comando seguente per evitare il presupposto che un Char oggetto rappresenta un singolo carattere.

  • È possibile utilizzare un String oggetto nella sua interezza invece di lavorare con dei singoli caratteri per rappresentare e analizzare contenuto linguistico.

  • È possibile utilizzare il StringInfo classe per funzionare con gli elementi di testo anziché singoli Char oggetti. L'esempio seguente usa il StringInfo oggetto per contare il numero di elementi di testo in una stringa che include l'Egee numeri pari a zero e nove. Perché considera una coppia di surrogati un singolo carattere, correttamente segnala 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.
    
  • Se una stringa contiene un carattere di base che contiene uno o più caratteri di combinazione, è possibile chiamare il String.Normalize metodo per convertire la sottostringa in una singola unità di codice con codifica UTF-16. Nell'esempio seguente viene chiamato il String.Normalize per convertire il carattere di base U + 0061 (LATIN SMALL LETTER A) e combinazione carattere U + 0308 (combinazione di LATINO) a U + 00E4 (LATIN SMALL lettera A con LATINO).

    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)
    

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

Operazione da eseguire

Usare questi System.Char metodi

Confrontare Char oggetti

CompareTo e Equals

Convertire un punto di codice in una stringa

ConvertFromUtf32

Convertire un Char oggetto o una coppia di surrogati Char oggetti da un punto di codice

Per un singolo carattere:Convert.ToInt32(Char)

Per una coppia di surrogati o un carattere in una stringa:Char.ConvertToUtf32

Ottenere la categoria Unicode di un carattere

GetUnicodeCategory

Determinare se un carattere appartiene a una categoria Unicode specifica, come 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, andIsWhiteSpace

Convertire un Char oggetto che rappresenta un numero in un tipo di valore numerico

GetNumericValue

Converte un carattere in una stringa in un Char oggetto

Parse e TryParse

Convertire un Char l'oggetto in un String oggetto

ToString

Nel caso di modifica un Char oggetto

ToLower, ToLowerInvariant, ToUpper e ToUpperInvariant

Quando un oggetto gestito Char tipo, che è rappresentata come un'unità di codice con codifica Unicode UTF-8, viene passato a codice non gestito, il marshalling di interoperabilità converte il set di caratteri da ANSI. È possibile applicare il DllImportAttribute dichiarazioni di attributo in platform invoke e StructLayoutAttribute dell'attributo a una dichiarazione di interoperabilità COM per controllare quale set di caratteri un sottoposto a marshalling Char tipo utilizzato.

Esempio di codice seguente vengono illustrati alcuni dei metodi in Char.

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"
	}
}

Universal Windows Platform
Disponibile da 8
.NET Framework
Disponibile da 1.1
Libreria di classi portabile
Supportato in: piattaforme .NET portabili
Silverlight
Disponibile da 2.0
Windows Phone Silverlight
Disponibile da 7.0
Windows Phone
Disponibile da 8.1

Tutti i membri di questo tipo sono thread-safe. I membri che apparentemente modificano lo stato dell'istanza è in realtà restituiscono una nuova istanza inizializzata con il nuovo valore. Come con qualsiasi altro tipo, lettura e scrittura in una variabile condivisa che contiene un'istanza di questo tipo deve essere protetto da un blocco per garantire la thread safety.

Torna all'inizio
Mostra: