Char Struct

Definizione

Spazio dei nomi:

System

Assembly:

System.Runtime.dll

Source:

Char.cs

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

public value class char : IComparable<char>, IConvertible, IEquatable<char>, IParsable<char>, ISpanParsable<char>, IUtf8SpanParsable<char>, System::Numerics::IAdditionOperators<char, char, char>, System::Numerics::IAdditiveIdentity<char, char>, System::Numerics::IBinaryInteger<char>, System::Numerics::IBinaryNumber<char>, System::Numerics::IBitwiseOperators<char, char, char>, System::Numerics::IComparisonOperators<char, char, bool>, System::Numerics::IDecrementOperators<char>, System::Numerics::IDivisionOperators<char, char, char>, System::Numerics::IEqualityOperators<char, char, bool>, System::Numerics::IIncrementOperators<char>, System::Numerics::IMinMaxValue<char>, System::Numerics::IModulusOperators<char, char, char>, System::Numerics::IMultiplicativeIdentity<char, char>, System::Numerics::IMultiplyOperators<char, char, char>, System::Numerics::INumber<char>, System::Numerics::INumberBase<char>, System::Numerics::IShiftOperators<char, int, char>, System::Numerics::ISubtractionOperators<char, char, char>, System::Numerics::IUnaryNegationOperators<char, char>, System::Numerics::IUnaryPlusOperators<char, char>, System::Numerics::IUnsignedNumber<char>

public readonly struct Char : IComparable<char>, IConvertible, IEquatable<char>, IParsable<char>, ISpanParsable<char>, IUtf8SpanParsable<char>, System.Numerics.IAdditionOperators<char,char,char>, System.Numerics.IAdditiveIdentity<char,char>, System.Numerics.IBinaryInteger<char>, System.Numerics.IBinaryNumber<char>, System.Numerics.IBitwiseOperators<char,char,char>, System.Numerics.IComparisonOperators<char,char,bool>, System.Numerics.IDecrementOperators<char>, System.Numerics.IDivisionOperators<char,char,char>, System.Numerics.IEqualityOperators<char,char,bool>, System.Numerics.IIncrementOperators<char>, System.Numerics.IMinMaxValue<char>, System.Numerics.IModulusOperators<char,char,char>, System.Numerics.IMultiplicativeIdentity<char,char>, System.Numerics.IMultiplyOperators<char,char,char>, System.Numerics.INumber<char>, System.Numerics.INumberBase<char>, System.Numerics.IShiftOperators<char,int,char>, System.Numerics.ISubtractionOperators<char,char,char>, System.Numerics.IUnaryNegationOperators<char,char>, System.Numerics.IUnaryPlusOperators<char,char>, System.Numerics.IUnsignedNumber<char>

type char = struct
    interface IConvertible
    interface IFormattable
    interface IParsable<char>
    interface ISpanFormattable
    interface ISpanParsable<char>
    interface IAdditionOperators<char, char, char>
    interface IAdditiveIdentity<char, char>
    interface IBinaryInteger<char>
    interface IBinaryNumber<char>
    interface IBitwiseOperators<char, char, char>
    interface IComparisonOperators<char, char, bool>
    interface IEqualityOperators<char, char, bool>
    interface IDecrementOperators<char>
    interface IDivisionOperators<char, char, char>
    interface IIncrementOperators<char>
    interface IModulusOperators<char, char, char>
    interface IMultiplicativeIdentity<char, char>
    interface IMultiplyOperators<char, char, char>
    interface INumber<char>
    interface INumberBase<char>
    interface ISubtractionOperators<char, char, char>
    interface IUnaryNegationOperators<char, char>
    interface IUnaryPlusOperators<char, char>
    interface IUtf8SpanFormattable
    interface IUtf8SpanParsable<char>
    interface IShiftOperators<char, int, char>
    interface IMinMaxValue<char>
    interface IUnsignedNumber<char>

Public Structure Char
Implements IAdditionOperators(Of Char, Char, Char), IAdditiveIdentity(Of Char, Char), IBinaryInteger(Of Char), IBinaryNumber(Of Char), IBitwiseOperators(Of Char, Char, Char), IComparable(Of Char), IComparisonOperators(Of Char, Char, Boolean), IConvertible, IDecrementOperators(Of Char), IDivisionOperators(Of Char, Char, Char), IEqualityOperators(Of Char, Char, Boolean), IEquatable(Of Char), IIncrementOperators(Of Char), IMinMaxValue(Of Char), IModulusOperators(Of Char, Char, Char), IMultiplicativeIdentity(Of Char, Char), IMultiplyOperators(Of Char, Char, Char), INumber(Of Char), INumberBase(Of Char), IParsable(Of Char), IShiftOperators(Of Char, Integer, Char), ISpanParsable(Of Char), ISubtractionOperators(Of Char, Char, Char), IUnaryNegationOperators(Of Char, Char), IUnaryPlusOperators(Of Char, Char), IUnsignedNumber(Of Char), IUtf8SpanParsable(Of Char)

Ereditarietà

Object

ValueType

Char

Implementazioni

IComparable IComparable<Char> IConvertible IEquatable<Char> IFormattable ISpanFormattable IComparable<TSelf> IEquatable<TSelf> IParsable<Char> IParsable<TSelf> ISpanParsable<Char> ISpanParsable<TSelf> IAdditionOperators<Char,Char,Char> IAdditionOperators<TSelf,TSelf,TSelf> IAdditiveIdentity<Char,Char> IAdditiveIdentity<TSelf,TSelf> IBinaryInteger<Char> IBinaryNumber<Char> IBinaryNumber<TSelf> IBitwiseOperators<Char,Char,Char> IBitwiseOperators<TSelf,TSelf,TSelf> IComparisonOperators<Char,Char,Boolean> IComparisonOperators<TSelf,TSelf,Boolean> IDecrementOperators<Char> IDecrementOperators<TSelf> IDivisionOperators<Char,Char,Char> IDivisionOperators<TSelf,TSelf,TSelf> IEqualityOperators<Char,Char,Boolean> IEqualityOperators<TSelf,TOther,TResult> IEqualityOperators<TSelf,TSelf,Boolean> IIncrementOperators<Char> IIncrementOperators<TSelf> IMinMaxValue<Char> IModulusOperators<Char,Char,Char> IModulusOperators<TSelf,TSelf,TSelf> IMultiplicativeIdentity<Char,Char> IMultiplicativeIdentity<TSelf,TSelf> IMultiplyOperators<Char,Char,Char> IMultiplyOperators<TSelf,TSelf,TSelf> INumber<Char> INumber<TSelf> INumberBase<Char> INumberBase<TSelf> IShiftOperators<Char,Int32,Char> IShiftOperators<TSelf,Int32,TSelf> ISubtractionOperators<Char,Char,Char> ISubtractionOperators<TSelf,TSelf,TSelf> IUnaryNegationOperators<Char,Char> IUnaryNegationOperators<TSelf,TSelf> IUnaryPlusOperators<Char,Char> IUnaryPlusOperators<TSelf,TSelf> IUnsignedNumber<Char> IUtf8SpanFormattable IUtf8SpanParsable<Char> IUtf8SpanParsable<TSelf>

Esempio

Nell'esempio di codice seguente vengono illustrati alcuni dei 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

Per altre informazioni su questa API, vedere Note sulle API supplementari per Char.

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 c è un carattere ASCII ([ U+0000..U+007F ]).
IsAsciiDigit(Char)	Indica se un carattere è classificato come cifra ASCII.
IsAsciiHexDigit(Char)	Indica se un carattere è classificato come cifra esadecimale ASCII.
IsAsciiHexDigitLower(Char)	Indica se un carattere è classificato come cifra esadecimale ASCII minuscola.
IsAsciiHexDigitUpper(Char)	Indica se un carattere è classificato come cifra esadecimale ASCII maiuscola.
IsAsciiLetter(Char)	Indica se un carattere è categorizzato come lettera ASCII.
IsAsciiLetterLower(Char)	Indica se un carattere è classificato come lettera ASCII minuscola.
IsAsciiLetterOrDigit(Char)	Indica se un carattere è categorizzato come lettera o cifra ASCII.
IsAsciiLetterUpper(Char)	Indica se un carattere è classificato come lettera ASCII maiuscola.
IsBetween(Char, Char, Char)	Indica se un carattere è compreso nell'intervallo inclusivo specificato.
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

IAdditionOperators<Char,Char,Char>.Addition(Char, Char)	Aggiunge due valori insieme per calcolare la somma.
IAdditionOperators<Char,Char,Char>.CheckedAddition(Char, Char)	Aggiunge due valori insieme per calcolare la somma.
IAdditiveIdentity<Char,Char>.AdditiveIdentity	Ottiene l'identità aggiuntiva del tipo corrente.
IBinaryInteger<Char>.GetByteCount()	Ottiene il numero di byte che verranno scritti come parte di TryWriteLittleEndian(Span<Byte>, Int32).
IBinaryInteger<Char>.GetShortestBitLength()	Ottiene la lunghezza, espressa in bit, della rappresentazione di complemento più breve del valore corrente.
IBinaryInteger<Char>.LeadingZeroCount(Char)	Calcola il numero di bit zero iniziali in un valore.
IBinaryInteger<Char>.PopCount(Char)	Calcola il numero di bit impostati in un valore.
IBinaryInteger<Char>.RotateLeft(Char, Int32)	Ruota un valore lasciato da una determinata quantità.
IBinaryInteger<Char>.RotateRight(Char, Int32)	Ruota un valore a destra di una determinata quantità.
IBinaryInteger<Char>.TrailingZeroCount(Char)	Calcola il numero di bit zero finali in un valore.
IBinaryInteger<Char>.TryReadBigEndian(ReadOnlySpan<Byte>, Boolean, Char)	Rappresenta un carattere come unità di codice UTF-16.
IBinaryInteger<Char>.TryReadLittleEndian(ReadOnlySpan<Byte>, Boolean, Char)	Rappresenta un carattere come unità di codice UTF-16.
IBinaryInteger<Char>.TryWriteBigEndian(Span<Byte>, Int32)	Tenta di scrivere il valore corrente, in formato big-endian, in un determinato intervallo.
IBinaryInteger<Char>.TryWriteLittleEndian(Span<Byte>, Int32)	Tenta di scrivere il valore corrente, in formato little-endian, in un determinato intervallo.
IBinaryNumber<Char>.AllBitsSet	Ottiene un'istanza del tipo binario in cui vengono impostati tutti i bit.
IBinaryNumber<Char>.IsPow2(Char)	Determina se un valore è una potenza di due.
IBinaryNumber<Char>.Log2(Char)	Calcola il log2 di un valore.
IBitwiseOperators<Char,Char,Char>.BitwiseAnd(Char, Char)	Calcola i valori bit per bit e di due valori.
IBitwiseOperators<Char,Char,Char>.BitwiseOr(Char, Char)	Calcola i valori bit per bit o di due valori.
IBitwiseOperators<Char,Char,Char>.ExclusiveOr(Char, Char)	Calcola l'esclusivo o di due valori.
IBitwiseOperators<Char,Char,Char>.OnesComplement(Char)	Calcola la rappresentazione di complemento di un determinato valore.
IComparisonOperators<Char,Char,Boolean>.GreaterThan(Char, Char)	Confronta due valori per determinare quale è maggiore.
IComparisonOperators<Char,Char,Boolean>.GreaterThanOrEqual(Char, Char)	Confronta due valori per determinare quale è maggiore o uguale.
IComparisonOperators<Char,Char,Boolean>.LessThan(Char, Char)	Confronta due valori per determinare quale è minore.
IComparisonOperators<Char,Char,Boolean>.LessThanOrEqual(Char, Char)	Confronta due valori per determinare quale è minore o uguale.
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.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).
IDecrementOperators<Char>.CheckedDecrement(Char)	Decrementa un valore.
IDecrementOperators<Char>.Decrement(Char)	Decrementa un valore.
IDivisionOperators<Char,Char,Char>.Division(Char, Char)	Divide un valore per un altro per calcolare il quoziente.
IEqualityOperators<Char,Char,Boolean>.Equality(Char, Char)	Confronta due valori per determinare l'uguaglianza.
IEqualityOperators<Char,Char,Boolean>.Inequality(Char, Char)	Confronta due valori per determinare la disuguaglianza.
IFormattable.ToString(String, IFormatProvider)	Formatta il valore dell'istanza corrente usando il formato specificato.
IIncrementOperators<Char>.CheckedIncrement(Char)	Incrementa un valore.
IIncrementOperators<Char>.Increment(Char)	Incrementa un valore.
IMinMaxValue<Char>.MaxValue	Ottiene il valore massimo del tipo corrente.
IMinMaxValue<Char>.MinValue	Ottiene il valore minimo del tipo corrente.
IModulusOperators<Char,Char,Char>.Modulus(Char, Char)	Divide due valori insieme per calcolare il modulo o il resto.
IMultiplicativeIdentity<Char,Char>.MultiplicativeIdentity	Ottiene l'identità moltiplicativa del tipo corrente.
IMultiplyOperators<Char,Char,Char>.CheckedMultiply(Char, Char)	Moltiplica due valori insieme per calcolare il prodotto.
IMultiplyOperators<Char,Char,Char>.Multiply(Char, Char)	Moltiplica due valori insieme per calcolare il prodotto.
INumberBase<Char>.Abs(Char)	Calcola l'assoluto di un valore.
INumberBase<Char>.IsCanonical(Char)	Determina se un valore è nella relativa rappresentazione canonica.
INumberBase<Char>.IsComplexNumber(Char)	Determina se un valore rappresenta un numero complesso.
INumberBase<Char>.IsEvenInteger(Char)	Determina se un valore rappresenta un numero integrale pari.
INumberBase<Char>.IsFinite(Char)	Determina se un valore è finito.
INumberBase<Char>.IsImaginaryNumber(Char)	Determina se un valore rappresenta un numero immaginario puro.
INumberBase<Char>.IsInfinity(Char)	Determina se un valore è infinito.
INumberBase<Char>.IsInteger(Char)	Determina se un valore rappresenta un numero integrale.
INumberBase<Char>.IsNaN(Char)	Determina se un valore è NaN.
INumberBase<Char>.IsNegative(Char)	Determina se un valore è negativo.
INumberBase<Char>.IsNegativeInfinity(Char)	Determina se un valore è infinito negativo.
INumberBase<Char>.IsNormal(Char)	Determina se un valore è normale.
INumberBase<Char>.IsOddInteger(Char)	Determina se un valore rappresenta un numero integrale dispari.
INumberBase<Char>.IsPositive(Char)	Determina se un valore è positivo.
INumberBase<Char>.IsPositiveInfinity(Char)	Determina se un valore è infinito positivo.
INumberBase<Char>.IsRealNumber(Char)	Determina se un valore rappresenta un numero reale.
INumberBase<Char>.IsSubnormal(Char)	Determina se un valore è sottonormaale.
INumberBase<Char>.IsZero(Char)	Determina se un valore è zero.
INumberBase<Char>.MaxMagnitude(Char, Char)	Confronta due valori con il calcolo maggiore.
INumberBase<Char>.MaxMagnitudeNumber(Char, Char)	Confronta due valori con il calcolo che ha la grandezza maggiore e restituisce l'altro valore se un input è NaN.
INumberBase<Char>.MinMagnitude(Char, Char)	Confronta due valori con il calcolo minore.
INumberBase<Char>.MinMagnitudeNumber(Char, Char)	Confronta due valori con il calcolo con la grandezza minore e restituendo l'altro valore se un input è NaN.
INumberBase<Char>.One	Ottiene il valore 1 per il tipo.
INumberBase<Char>.Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Analizza un intervallo di caratteri in un valore.
INumberBase<Char>.Parse(String, NumberStyles, IFormatProvider)	Analizza una stringa in un valore.
INumberBase<Char>.Radix	Ottiene il radix, o base, per il tipo .
INumberBase<Char>.TryConvertFromChecked<TOther>(TOther, Char)	Rappresenta un carattere come unità di codice UTF-16.
INumberBase<Char>.TryConvertFromSaturating<TOther>(TOther, Char)	Rappresenta un carattere come unità di codice UTF-16.
INumberBase<Char>.TryConvertFromTruncating<TOther>(TOther, Char)	Rappresenta un carattere come unità di codice UTF-16.
INumberBase<Char>.TryConvertToChecked<TOther>(Char, TOther)	Tenta di convertire un'istanza del tipo corrente in un altro tipo, generando un'eccezione di overflow per tutti i valori che non rientrano nell'intervallo rappresentabile del tipo corrente.
INumberBase<Char>.TryConvertToSaturating<TOther>(Char, TOther)	Tenta di convertire un'istanza del tipo corrente in un altro tipo, saturazione di tutti i valori che non rientrano nell'intervallo rappresentabile del tipo corrente.
INumberBase<Char>.TryConvertToTruncating<TOther>(Char, TOther)	Tenta di convertire un'istanza del tipo corrente in un altro tipo, troncando tutti i valori che non rientrano nell'intervallo rappresentabile del tipo corrente.
INumberBase<Char>.TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Char)	Rappresenta un carattere come unità di codice UTF-16.
INumberBase<Char>.TryParse(String, NumberStyles, IFormatProvider, Char)	Rappresenta un carattere come unità di codice UTF-16.
INumberBase<Char>.Zero	Ottiene il valore 0 per il tipo.
IParsable<Char>.Parse(String, IFormatProvider)	Analizza una stringa in un valore.
IParsable<Char>.TryParse(String, IFormatProvider, Char)	Rappresenta un carattere come unità di codice UTF-16.
IShiftOperators<Char,Int32,Char>.LeftShift(Char, Int32)	Sposta un valore lasciato da un determinato importo.
IShiftOperators<Char,Int32,Char>.RightShift(Char, Int32)	Sposta un valore a destra in base a una determinata quantità.
IShiftOperators<Char,Int32,Char>.UnsignedRightShift(Char, Int32)	Sposta un valore a destra in base a una determinata quantità.
ISpanFormattable.TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Tenta di formattare il valore dell'istanza corrente nell'intervallo di caratteri specificato.
ISpanParsable<Char>.Parse(ReadOnlySpan<Char>, IFormatProvider)	Analizza un intervallo di caratteri in un valore.
ISpanParsable<Char>.TryParse(ReadOnlySpan<Char>, IFormatProvider, Char)	Rappresenta un carattere come unità di codice UTF-16.
ISubtractionOperators<Char,Char,Char>.CheckedSubtraction(Char, Char)	Sottrae due valori per calcolare la differenza.
ISubtractionOperators<Char,Char,Char>.Subtraction(Char, Char)	Sottrae due valori per calcolare la differenza.
IUnaryNegationOperators<Char,Char>.CheckedUnaryNegation(Char)	Calcola la negazione unaria controllata di un valore.
IUnaryNegationOperators<Char,Char>.UnaryNegation(Char)	Calcola la negazione unaria di un valore.
IUnaryPlusOperators<Char,Char>.UnaryPlus(Char)	Calcola il segno più unario di un valore.
IUtf8SpanFormattable.TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Tenta di formattare il valore dell'istanza corrente come UTF-8 nell'intervallo di byte 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