Char Struktura

Definicja

Przestrzeń nazw:

System

Zestaw:

System.Runtime.dll

Reprezentuje znak jako jednostkę kodu 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)

Dziedziczenie

Object

ValueType

Char

Implementuje

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>

Przykłady

Poniższy przykład kodu przedstawia niektóre metody w pliku 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

Uwagi

Platforma .NET używa Char struktury do reprezentowania punktów kodu Unicode przy użyciu kodowania UTF-16. Wartość Char obiektu to 16-bitowa wartość liczbowa (porządkowa).

Jeśli nie znasz formatu Unicode, wartości skalarnych, punktów kodu, par zastępczych, UTF-16 i Rune typu, zobacz Wprowadzenie do kodowania znaków na platformie .NET.

W poniższych sekcjach opisano relację między obiektem Char a znakiem i omówiono niektóre typowe zadania wykonywane z wystąpieniami Char . Zalecamy rozważenie typu wprowadzonego Rune na platformie .NET Core 3.0 jako alternatywy Char dla wykonywania niektórych z tych zadań.

• Obiekty char, znaki Unicode i ciągi
• Znaki i kategorie znaków
• Znaki i elementy tekstowe
• Typowe operacje
• Wartości znaków i współdziałanie

Obiekty char, znaki Unicode i ciągi

Obiekt String jest sekwencyjną kolekcją Char struktur, która reprezentuje ciąg tekstu. Większość znaków Unicode może być reprezentowana przez pojedynczy Char obiekt, ale znak zakodowany jako znak podstawowy, para zastępcza i/lub łącząca sekwencję znaków jest reprezentowana przez wiele Char obiektów. Z tego powodu Char struktura obiektu String nie musi być równoważna pojedynczemu znakowi Unicode.

Wiele 16-bitowych jednostek kodu służy do reprezentowania pojedynczych znaków Unicode w następujących przypadkach:

• Glyphs, które mogą składać się z pojedynczego znaku lub znaku podstawowego, po którym następuje co najmniej jeden znak łączący. Na przykład znak ä jest reprezentowany przez Char obiekt, którego jednostka kodu to U+0061, Char po którym następuje obiekt, którego jednostka kodu to U+0308. (Znak ä można również zdefiniować za pomocą pojedynczego Char obiektu, który ma jednostkę kodu U+00E4). Poniższy przykład ilustruje, że znak ä składa się z dwóch Char obiektów.

  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:
  '       ä
  

• Znaki poza podstawową płaszczyzną wielojęzyczną Unicode (BMP). Kod Unicode obsługuje szesnaście płaszczyzn oprócz protokołu BMP, który reprezentuje płaszczyznę 0. Punkt kodu Unicode jest reprezentowany w formacie UTF-32 przez wartość 21-bitową zawierającą płaszczyznę. Na przykład U+1D160 reprezentuje ZNAK ÓSMEJ NOTATKI SYMBOLU MUZYCZNEgo. Ponieważ kodowanie UTF-16 ma tylko 16 bitów, znaki poza BMP są reprezentowane przez pary zastępcze w UTF-16. Poniższy przykład ilustruje, że odpowiednik UTF-32 U+1D160, znak MUSICAL SYMBOL ÓSMEJ NOTATKI, jest U+D834 U+DD60. U+D834 jest wysokim zastępcą; wysokie wartości zastępcze wahają się od U+D800 do U+DBFF. U+DD60 jest niskim zastępcą; niski zakres zastępczych od U+DC00 do 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
  

Znaki i kategorie znaków

Każdy znak Unicode lub prawidłowa para zastępcza należy do kategorii Unicode. Na platformie .NET kategorie Unicode są reprezentowane przez elementy członkowskie wyliczenia UnicodeCategory i obejmują na przykład wartości, takie jak UnicodeCategory.CurrencySymbol, UnicodeCategory.LowercaseLetteri UnicodeCategory.SpaceSeparator.

Aby określić kategorię Unicode znaku, wywołaj metodę GetUnicodeCategory . Na przykład poniższy przykład wywołuje metodę GetUnicodeCategory , aby wyświetlić kategorię Unicode każdego znaku w ciągu. Przykład działa poprawnie tylko wtedy, gdy w wystąpieniu String nie ma par zastępczych.

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

Wewnętrznie w przypadku znaków spoza zakresu ASCII (U+0000 do U+00FF) GetUnicodeCategory metoda zależy od kategorii Unicode zgłoszonych przez klasę CharUnicodeInfo . Począwszy od .NET Framework 4.6.2, znaki Unicode są klasyfikowane na podstawie standardu Unicode w wersji 8.0.0. W wersjach .NET Framework z .NET Framework 4 do .NET Framework 4.6.1 są klasyfikowane na podstawie standardu Unicode w wersji 6.3.0.

Znaki i elementy tekstowe

Ponieważ pojedynczy znak może być reprezentowany przez wiele Char obiektów, nie zawsze ma znaczenie dla pracy z poszczególnymi Char obiektami. Na przykład poniższy przykład konwertuje punkty kodu Unicode reprezentujące liczby egejskie od 9 do zakodowanych jednostek kodu UTF-16. Ponieważ błędnie równa Char obiekty znakami, niedokładnie zgłasza, że wynikowy ciąg ma 20 znaków.

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.

Możesz wykonać następujące czynności, aby uniknąć założenia, że Char obiekt reprezentuje pojedynczy znak:

• Możesz pracować z obiektem String w całości, zamiast pracować z poszczególnymi znakami, aby reprezentować i analizować zawartość językową.

• Możesz użyć String.EnumerateRunes polecenia , jak pokazano w poniższym przykładzie:

  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
  

• Klasę można używać StringInfo do pracy z elementami tekstowymi zamiast poszczególnych Char obiektów. W poniższym przykładzie użyto StringInfo obiektu do zliczenia liczby elementów tekstowych w ciągu składającym się z liczb egejskich od zera do dziewięciu. Ponieważ uwzględnia ona parę zastępczą pojedynczego znaku, poprawnie zgłasza, że ciąg zawiera dziesięć znaków.

  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.
  

• Jeśli ciąg zawiera znak podstawowy zawierający co najmniej jeden znak łączący, możesz wywołać String.Normalize metodę w celu przekonwertowania podciągów na pojedynczą zakodowaną jednostkę kodu UTF-16. Poniższy przykład wywołuje metodę String.Normalize w celu przekonwertowania znaku podstawowego U+0061 (ŁACIŃSKA MAŁA LITERA A) i połączenia znaku U+0308 (ŁĄCZENIE DIAERESIS) do U+00E4 (MAŁA LITERA ŁACIŃSKA A Z DIAEREZĄ).

  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)
  

Typowe operacje

Struktura Char udostępnia metody porównywania Char obiektów, konwertowania wartości bieżącego Char obiektu na obiekt innego typu i określania kategorii Char Unicode obiektu:

Wymagana czynność	Użyj tych System.Char metod
Porównanie Char obiektów	CompareTo i Equals
Konwertowanie punktu kodu na ciąg	ConvertFromUtf32 Zobacz również Rune typ.
Char Konwertowanie obiektu lub pary zastępczej Char obiektów na punkt kodu	Dla pojedynczego znaku: Convert.ToInt32(Char) W przypadku pary zastępczej lub znaku w ciągu: Char.ConvertToUtf32 Zobacz również Rune typ.
Pobieranie kategorii Unicode znaku	GetUnicodeCategory Zobacz też Rune.GetUnicodeCategory.
Określanie, czy znak znajduje się w określonej kategorii Unicode, takiej jak cyfra, litera, znak interpunkcyjny, znak kontrolny itd.	IsControlIsDigit, IsHighSurrogate, IsLetterOrDigitIsLowSurrogateIsNumberIsPunctuationIsLowerIsLetterIsSurrogateIsSurrogatePairIsSeparatorIsSymbol, i IsUpperIsWhiteSpace Zobacz również odpowiednie metody w typie Rune .
Char Konwertowanie obiektu reprezentującego liczbę na typ wartości liczbowej	GetNumericValue Zobacz też Rune.GetNumericValue.
Konwertowanie znaku w ciągu na Char obiekt	Parse i TryParse
Konwertowanie Char obiektu na String obiekt	ToString
Zmienianie wielkości liter Char obiektu	ToLower, ToLowerInvariant, ToUpperi ToUpperInvariant Zobacz również odpowiednie metody w typie Rune .

Wartości znaków i współdziałanie

Gdy typ zarządzany Char , który jest reprezentowany jako jednostka kodu zakodowanego w formacie Unicode UTF-16, jest przekazywany do niezarządzanego kodu, marshaler międzyoperacyjny konwertuje znak ustawiony na ANSI domyślnie. Atrybut można zastosować DllImportAttribute do deklaracji wywołania platformy i StructLayoutAttribute atrybutu do deklaracji międzyoperacyjnej MODELU COM, aby kontrolować, który zestaw znaków jest używany przez typ marshalowany Char .

Pola

MaxValue	Reprezentuje największą możliwą wartość elementu Char. To pole jest stałe.
MinValue	Reprezentuje najmniejszą możliwą wartość elementu Char. To pole jest stałe.

Metody

CompareTo(Char)	Porównuje to wystąpienie z określonym Char obiektem i wskazuje, czy to wystąpienie poprzedza, następuje lub pojawia się w tej samej pozycji w kolejności sortowania co określony Char obiekt.
CompareTo(Object)	Porównuje to wystąpienie z określonym obiektem i wskazuje, czy to wystąpienie poprzedza, następuje lub pojawia się w tej samej pozycji w kolejności sortowania co określony Object.
ConvertFromUtf32(Int32)	Konwertuje określony punkt kodu Unicode na ciąg zakodowany w formacie UTF-16.
ConvertToUtf32(Char, Char)	Konwertuje wartość zakodowanej pary zastępczej UTF-16 na punkt kodu Unicode.
ConvertToUtf32(String, Int32)	Konwertuje wartość zakodowanego znaku UTF-16 lub pary zastępczej w określonej pozycji w ciągu na punkt kodu Unicode.
Equals(Char)	Zwraca wartość wskazującą, czy to wystąpienie jest równe określonemu Char obiektowi.
Equals(Object)	Zwraca wartość wskazującą, czy to wystąpienie jest równe podanemu obiektowi.
GetHashCode()	Zwraca wartość skrótu dla tego wystąpienia.
GetNumericValue(Char)	Konwertuje określony znak liczbowy Unicode na liczbę zmiennoprzecinkową o podwójnej precyzji.
GetNumericValue(String, Int32)	Konwertuje numeryczny znak Unicode w określonej pozycji w określonym ciągu na liczbę zmiennoprzecinkową o podwójnej precyzji.
GetTypeCode()	Zwraca wartość TypeCode dla typu Charwartości .
GetUnicodeCategory(Char)	Kategoryzuje określony znak Unicode w grupie zidentyfikowanej przez jedną z UnicodeCategory wartości.
GetUnicodeCategory(String, Int32)	Kategoryzuje znak na określonej pozycji w określonym ciągu w grupie zidentyfikowanej przez jedną z UnicodeCategory wartości.
IsAscii(Char)	Zwraca true wartość , jeśli c jest znakiem ASCII ([ U+0000..U+007F ]).
IsAsciiDigit(Char)	Wskazuje, czy znak jest kategoryzowany jako cyfra ASCII.
IsAsciiHexDigit(Char)	Wskazuje, czy znak jest kategoryzowany jako cyfra szesnastkowy ASCII.
IsAsciiHexDigitLower(Char)	Wskazuje, czy znak jest kategoryzowany jako cyfra szesnastkowy ASCII.
IsAsciiHexDigitUpper(Char)	Wskazuje, czy znak jest kategoryzowany jako cyfra szesnastkowy ASCII.
IsAsciiLetter(Char)	Wskazuje, czy znak jest kategoryzowany jako litera ASCII.
IsAsciiLetterLower(Char)	Wskazuje, czy znak jest kategoryzowany jako mała litera ASCII.
IsAsciiLetterOrDigit(Char)	Wskazuje, czy znak jest kategoryzowany jako litera ASCII, czy cyfra.
IsAsciiLetterUpper(Char)	Wskazuje, czy znak jest kategoryzowany jako wielka litera ASCII.
IsBetween(Char, Char, Char)	Wskazuje, czy znak znajduje się w określonym zakresie inkluzywnym.
IsControl(Char)	Wskazuje, czy określony znak Unicode jest kategoryzowany jako znak kontrolki.
IsControl(String, Int32)	Wskazuje, czy znak w określonej pozycji w określonym ciągu jest kategoryzowany jako znak kontrolny.
IsDigit(Char)	Wskazuje, czy określony znak Unicode jest kategoryzowany jako cyfra dziesiętna.
IsDigit(String, Int32)	Wskazuje, czy znak w określonym położeniu w określonym ciągu jest kategoryzowany jako cyfra dziesiętna.
IsHighSurrogate(Char)	Wskazuje, czy określony Char obiekt jest wysokim zastępcą.
IsHighSurrogate(String, Int32)	Wskazuje, czy Char obiekt w określonej pozycji w ciągu jest wysokim zastępcą.
IsLetter(Char)	Wskazuje, czy określony znak Unicode jest kategoryzowany jako litera Unicode.
IsLetter(String, Int32)	Wskazuje, czy znak na określonej pozycji w określonym ciągu jest kategoryzowany jako litera Unicode.
IsLetterOrDigit(Char)	Wskazuje, czy określony znak Unicode jest kategoryzowany jako litera, czy cyfra dziesiętna.
IsLetterOrDigit(String, Int32)	Wskazuje, czy znak na określonej pozycji w określonym ciągu jest kategoryzowany jako litera, czy cyfra dziesiętna.
IsLower(Char)	Wskazuje, czy określony znak Unicode jest kategoryzowany jako mała litera.
IsLower(String, Int32)	Wskazuje, czy znak w określonej pozycji w określonym ciągu jest kategoryzowany jako mała litera.
IsLowSurrogate(Char)	Wskazuje, czy określony Char obiekt jest niskim zastępcą.
IsLowSurrogate(String, Int32)	Wskazuje, czy Char obiekt w określonej pozycji w ciągu jest niskim zastępcą.
IsNumber(Char)	Wskazuje, czy określony znak Unicode jest sklasyfikowany jako liczba.
IsNumber(String, Int32)	Wskazuje, czy znak na określonej pozycji w określonym ciągu jest kategoryzowany jako liczba.
IsPunctuation(Char)	Wskazuje, czy określony znak Unicode jest kategoryzowany jako znak interpunkcyjny.
IsPunctuation(String, Int32)	Wskazuje, czy znak w określonej pozycji w określonym ciągu jest kategoryzowany jako znak interpunkcyjny.
IsSeparator(Char)	Wskazuje, czy określony znak Unicode jest kategoryzowany jako znak separatora.
IsSeparator(String, Int32)	Wskazuje, czy znak na określonej pozycji w określonym ciągu jest kategoryzowany jako znak separatora.
IsSurrogate(Char)	Wskazuje, czy określony znak ma jednostkę kodu zastępczego.
IsSurrogate(String, Int32)	Wskazuje, czy znak na określonej pozycji w określonym ciągu ma jednostkę kodu zastępczego.
IsSurrogatePair(Char, Char)	Wskazuje, czy dwa określone Char obiekty tworzą parę zastępczą.
IsSurrogatePair(String, Int32)	Wskazuje, czy dwa sąsiadujące Char obiekty w określonej pozycji w ciągu tworzą parę zastępczą.
IsSymbol(Char)	Wskazuje, czy określony znak Unicode jest kategoryzowany jako znak symbolu.
IsSymbol(String, Int32)	Wskazuje, czy znak na określonej pozycji w określonym ciągu jest kategoryzowany jako znak symbolu.
IsUpper(Char)	Wskazuje, czy określony znak Unicode jest kategoryzowany jako wielka litera.
IsUpper(String, Int32)	Wskazuje, czy znak w określonej pozycji w określonym ciągu jest kategoryzowany jako wielka litera.
IsWhiteSpace(Char)	Wskazuje, czy określony znak Unicode jest kategoryzowany jako biały znak.
IsWhiteSpace(String, Int32)	Wskazuje, czy znak na określonej pozycji w określonym ciągu jest kategoryzowany jako biały odstęp.
Parse(String)	Konwertuje wartość określonego ciągu na równoważny znak Unicode.
ToLower(Char)	Konwertuje wartość znaku Unicode na jego małe litery równoważne.
ToLower(Char, CultureInfo)	Konwertuje wartość określonego znaku Unicode na jego małe litery równoważne przy użyciu określonych informacji o formatowaniu specyficznym dla kultury.
ToLowerInvariant(Char)	Konwertuje wartość znaku Unicode na jego małe litery równoważne przy użyciu reguł wielkości liter niezmiennej kultury.
ToString()	Konwertuje wartość tego wystąpienia na jego równoważną reprezentację w postaci ciągu.
ToString(Char)	Konwertuje określony znak Unicode na równoważną reprezentację ciągu.
ToString(IFormatProvider)	Konwertuje wartość tego wystąpienia na równoważną reprezentację ciągu przy użyciu określonych informacji o formacie specyficznym dla kultury.
ToUpper(Char)	Konwertuje wartość znaku Unicode na jego wielkie litery równoważne.
ToUpper(Char, CultureInfo)	Konwertuje wartość określonego znaku Unicode na jego wielkie litery równoważne przy użyciu określonych informacji o formatowaniu specyficznym dla kultury.
ToUpperInvariant(Char)	Konwertuje wartość znaku Unicode na jego wielkie litery przy użyciu reguł wielkości liter niezmiennej kultury.
TryParse(String, Char)	Konwertuje wartość określonego ciągu na równoważny znak Unicode. Kod powrotu wskazuje, czy konwersja zakończyła się pomyślnie, czy nie powiodła się.

Jawne implementacje interfejsu

IAdditionOperators<Char,Char,Char>.Addition(Char, Char)	Dodaje dwie wartości w celu obliczenia ich sumy.
IAdditionOperators<Char,Char,Char>.CheckedAddition(Char, Char)	Dodaje dwie wartości w celu obliczenia ich sumy.
IAdditiveIdentity<Char,Char>.AdditiveIdentity	Pobiera tożsamość addytywnego bieżącego typu.
IBinaryInteger<Char>.GetByteCount()	Pobiera liczbę bajtów, które zostaną zapisane w ramach TryWriteLittleEndian(Span<Byte>, Int32)elementu .
IBinaryInteger<Char>.GetShortestBitLength()	Pobiera długość w bitach najkrótszej reprezentacji bieżącej wartości.
IBinaryInteger<Char>.LeadingZeroCount(Char)	Oblicza liczbę wiodących bitów zerowych w wartości.
IBinaryInteger<Char>.PopCount(Char)	Oblicza liczbę bitów ustawionych w wartości.
IBinaryInteger<Char>.RotateLeft(Char, Int32)	Obraca wartość pozostawioną przez daną kwotę.
IBinaryInteger<Char>.RotateRight(Char, Int32)	Obraca wartość z prawej strony według danej kwoty.
IBinaryInteger<Char>.TrailingZeroCount(Char)	Oblicza liczbę końcowych bitów zerowych w wartości.
IBinaryInteger<Char>.TryReadBigEndian(ReadOnlySpan<Byte>, Boolean, Char)	Reprezentuje znak jako jednostkę kodu UTF-16.
IBinaryInteger<Char>.TryReadLittleEndian(ReadOnlySpan<Byte>, Boolean, Char)	Reprezentuje znak jako jednostkę kodu UTF-16.
IBinaryInteger<Char>.TryWriteBigEndian(Span<Byte>, Int32)	Próbuje zapisać bieżącą wartość w formacie big-endian do danego zakresu.
IBinaryInteger<Char>.TryWriteLittleEndian(Span<Byte>, Int32)	Próbuje zapisać bieżącą wartość w formacie little-endian do danego zakresu.
IBinaryNumber<Char>.AllBitsSet	Pobiera wystąpienie typu binarnego, w którym ustawiono wszystkie bity.
IBinaryNumber<Char>.IsPow2(Char)	Określa, czy wartość jest mocą dwóch.
IBinaryNumber<Char>.Log2(Char)	Oblicza dziennik2 wartości.
IBitwiseOperators<Char,Char,Char>.BitwiseAnd(Char, Char)	Oblicza bitowe i z dwóch wartości.
IBitwiseOperators<Char,Char,Char>.BitwiseOr(Char, Char)	Oblicza bitowe lub z dwóch wartości.
IBitwiseOperators<Char,Char,Char>.ExclusiveOr(Char, Char)	Oblicza wyłącznie lub dwie wartości.
IBitwiseOperators<Char,Char,Char>.OnesComplement(Char)	Oblicza reprezentację tej wartości jako uzupełnienie.
IComparisonOperators<Char,Char,Boolean>.GreaterThan(Char, Char)	Porównuje dwie wartości, aby określić, która wartość jest większa.
IComparisonOperators<Char,Char,Boolean>.GreaterThanOrEqual(Char, Char)	Porównuje dwie wartości, aby określić, która wartość jest większa lub równa.
IComparisonOperators<Char,Char,Boolean>.LessThan(Char, Char)	Porównuje dwie wartości, aby określić, która wartość jest mniejsza.
IComparisonOperators<Char,Char,Boolean>.LessThanOrEqual(Char, Char)	Porównuje dwie wartości, aby określić, które wartości są mniejsze lub równe.
IConvertible.ToBoolean(IFormatProvider)	Uwaga Ta konwersja nie jest obsługiwana. Próba wykonania tej czynności zgłasza błąd InvalidCastException.
IConvertible.ToByte(IFormatProvider)	Aby uzyskać opis tego elementu członkowskiego, zobacz ToByte(IFormatProvider).
IConvertible.ToChar(IFormatProvider)	Aby uzyskać opis tego elementu członkowskiego, zobacz ToChar(IFormatProvider).
IConvertible.ToDateTime(IFormatProvider)	Uwaga Ta konwersja nie jest obsługiwana. Próba wykonania tej czynności zgłasza błąd InvalidCastException.
IConvertible.ToDecimal(IFormatProvider)	Uwaga Ta konwersja nie jest obsługiwana. Próba wykonania tej czynności zgłasza błąd InvalidCastException.
IConvertible.ToDouble(IFormatProvider)	Uwaga Ta konwersja nie jest obsługiwana. Próba wykonania tej czynności zgłasza błąd InvalidCastException.
IConvertible.ToInt16(IFormatProvider)	Aby uzyskać opis tego elementu członkowskiego, zobacz ToInt16(IFormatProvider).
IConvertible.ToInt32(IFormatProvider)	Aby uzyskać opis tego elementu członkowskiego, zobacz ToInt32(IFormatProvider).
IConvertible.ToInt64(IFormatProvider)	Aby uzyskać opis tego elementu członkowskiego, zobacz ToInt64(IFormatProvider).
IConvertible.ToSByte(IFormatProvider)	Aby uzyskać opis tego elementu członkowskiego, zobacz ToSByte(IFormatProvider).
IConvertible.ToSingle(IFormatProvider)	Uwaga Ta konwersja nie jest obsługiwana. Próba wykonania tej czynności zgłasza błąd InvalidCastException.
IConvertible.ToType(Type, IFormatProvider)	Aby uzyskać opis tego elementu członkowskiego, zobacz ToType(Type, IFormatProvider).
IConvertible.ToUInt16(IFormatProvider)	Aby uzyskać opis tego elementu członkowskiego, zobacz ToUInt16(IFormatProvider).
IConvertible.ToUInt32(IFormatProvider)	Aby uzyskać opis tego elementu członkowskiego, zobacz ToUInt32(IFormatProvider).
IConvertible.ToUInt64(IFormatProvider)	Aby uzyskać opis tego elementu członkowskiego, zobacz ToUInt64(IFormatProvider).
IDecrementOperators<Char>.CheckedDecrement(Char)	Dekrementuje wartość.
IDecrementOperators<Char>.Decrement(Char)	Dekrementuje wartość.
IDivisionOperators<Char,Char,Char>.Division(Char, Char)	Dzieli jedną wartość przez inną, aby obliczyć ich iloraz.
IEqualityOperators<Char,Char,Boolean>.Equality(Char, Char)	Porównuje dwie wartości w celu określenia równości.
IEqualityOperators<Char,Char,Boolean>.Inequality(Char, Char)	Porównuje dwie wartości w celu określenia nierówności.
IFormattable.ToString(String, IFormatProvider)	Formatuje wartość bieżącego wystąpienia przy użyciu określonego formatu.
IIncrementOperators<Char>.CheckedIncrement(Char)	Zwiększa wartość.
IIncrementOperators<Char>.Increment(Char)	Zwiększa wartość.
IMinMaxValue<Char>.MaxValue	Pobiera maksymalną wartość bieżącego typu.
IMinMaxValue<Char>.MinValue	Pobiera minimalną wartość bieżącego typu.
IModulusOperators<Char,Char,Char>.Modulus(Char, Char)	Dzieli dwie wartości w celu obliczenia ich modulu lub reszty.
IMultiplicativeIdentity<Char,Char>.MultiplicativeIdentity	Pobiera tożsamość mnożenia bieżącego typu.
IMultiplyOperators<Char,Char,Char>.CheckedMultiply(Char, Char)	Mnoży dwie wartości w celu obliczenia ich produktu.
IMultiplyOperators<Char,Char,Char>.Multiply(Char, Char)	Mnoży dwie wartości w celu obliczenia ich produktu.
INumberBase<Char>.Abs(Char)	Oblicza wartość bezwzględną.
INumberBase<Char>.IsCanonical(Char)	Określa, czy wartość znajduje się w swojej reprezentacji kanonicznej.
INumberBase<Char>.IsComplexNumber(Char)	Określa, czy wartość reprezentuje liczbę zespolonej.
INumberBase<Char>.IsEvenInteger(Char)	Określa, czy wartość reprezentuje parzystą liczbę całkowitą.
INumberBase<Char>.IsFinite(Char)	Określa, czy wartość jest skończona.
INumberBase<Char>.IsImaginaryNumber(Char)	Określa, czy wartość reprezentuje czystą wyimaginowaną liczbę.
INumberBase<Char>.IsInfinity(Char)	Określa, czy wartość jest nieskończona.
INumberBase<Char>.IsInteger(Char)	Określa, czy wartość reprezentuje liczbę całkowitą.
INumberBase<Char>.IsNaN(Char)	Określa, czy wartość to NaN.
INumberBase<Char>.IsNegative(Char)	Określa, czy wartość jest ujemna.
INumberBase<Char>.IsNegativeInfinity(Char)	Określa, czy wartość jest ujemną nieskończonością.
INumberBase<Char>.IsNormal(Char)	Określa, czy wartość jest normalna.
INumberBase<Char>.IsOddInteger(Char)	Określa, czy wartość reprezentuje nieparzystą liczbę całkowitą.
INumberBase<Char>.IsPositive(Char)	Określa, czy wartość jest dodatnia.
INumberBase<Char>.IsPositiveInfinity(Char)	Określa, czy wartość jest dodatnią nieskończonością.
INumberBase<Char>.IsRealNumber(Char)	Określa, czy wartość reprezentuje liczbę rzeczywistą.
INumberBase<Char>.IsSubnormal(Char)	Określa, czy wartość jest podnormalna.
INumberBase<Char>.IsZero(Char)	Określa, czy wartość ma wartość zero.
INumberBase<Char>.MaxMagnitude(Char, Char)	Porównuje dwie wartości z obliczeniami, które są większe.
INumberBase<Char>.MaxMagnitudeNumber(Char, Char)	Porównuje dwie wartości do obliczeń o większej wielkości i zwraca inną wartość, jeśli dane wejściowe to NaN.
INumberBase<Char>.MinMagnitude(Char, Char)	Porównuje dwie wartości z obliczeniami, które są mniejsze.
INumberBase<Char>.MinMagnitudeNumber(Char, Char)	Porównuje dwie wartości do obliczeń o mniejszej wielkości i zwraca inną wartość, jeśli dane wejściowe to NaN.
INumberBase<Char>.One	Pobiera wartość 1 typu.
INumberBase<Char>.Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Analizuje zakres znaków w wartości.
INumberBase<Char>.Parse(String, NumberStyles, IFormatProvider)	Analizuje ciąg w wartość.
INumberBase<Char>.Radix	Pobiera promienie lub podstawę dla typu.
INumberBase<Char>.TryConvertFromChecked<TOther>(TOther, Char)	Reprezentuje znak jako jednostkę kodu UTF-16.
INumberBase<Char>.TryConvertFromSaturating<TOther>(TOther, Char)	Reprezentuje znak jako jednostkę kodu UTF-16.
INumberBase<Char>.TryConvertFromTruncating<TOther>(TOther, Char)	Reprezentuje znak jako jednostkę kodu UTF-16.
INumberBase<Char>.TryConvertToChecked<TOther>(Char, TOther)	Próbuje przekonwertować wystąpienie bieżącego typu na inny typ, zgłaszając wyjątek przepełnienia dla wszystkich wartości, które wykraczają poza reprezentatywny zakres bieżącego typu.
INumberBase<Char>.TryConvertToSaturating<TOther>(Char, TOther)	Próbuje przekonwertować wystąpienie bieżącego typu na inny typ, saturując wszystkie wartości, które mieszczą się poza reprezentatywnym zakresem bieżącego typu.
INumberBase<Char>.TryConvertToTruncating<TOther>(Char, TOther)	Próbuje przekonwertować wystąpienie bieżącego typu na inny typ, obcinając wszystkie wartości, które mieszczą się poza reprezentatywnym zakresem bieżącego typu.
INumberBase<Char>.TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Char)	Reprezentuje znak jako jednostkę kodu UTF-16.
INumberBase<Char>.TryParse(String, NumberStyles, IFormatProvider, Char)	Reprezentuje znak jako jednostkę kodu UTF-16.
INumberBase<Char>.Zero	Pobiera wartość 0 typu.
IParsable<Char>.Parse(String, IFormatProvider)	Analizuje ciąg w wartość.
IParsable<Char>.TryParse(String, IFormatProvider, Char)	Reprezentuje znak jako jednostkę kodu UTF-16.
IShiftOperators<Char,Int32,Char>.LeftShift(Char, Int32)	Przesuwa wartość pozostawioną przez daną kwotę.
IShiftOperators<Char,Int32,Char>.RightShift(Char, Int32)	Przesuwa wartość w prawo o daną kwotę.
IShiftOperators<Char,Int32,Char>.UnsignedRightShift(Char, Int32)	Przesuwa wartość w prawo o daną kwotę.
ISpanFormattable.TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Próbuje sformatować wartość bieżącego wystąpienia w podanym zakresie znaków.
ISpanParsable<Char>.Parse(ReadOnlySpan<Char>, IFormatProvider)	Analizuje zakres znaków w wartości.
ISpanParsable<Char>.TryParse(ReadOnlySpan<Char>, IFormatProvider, Char)	Reprezentuje znak jako jednostkę kodu UTF-16.
ISubtractionOperators<Char,Char,Char>.CheckedSubtraction(Char, Char)	Odejmuje dwie wartości, aby obliczyć ich różnicę.
ISubtractionOperators<Char,Char,Char>.Subtraction(Char, Char)	Odejmuje dwie wartości, aby obliczyć ich różnicę.
IUnaryNegationOperators<Char,Char>.CheckedUnaryNegation(Char)	Oblicza sprawdzoną jednoargumentową negację wartości.
IUnaryNegationOperators<Char,Char>.UnaryNegation(Char)	Oblicza jednoargumentowe negację wartości.
IUnaryPlusOperators<Char,Char>.UnaryPlus(Char)	Oblicza jednoargumentowy plus wartości.
IUtf8SpanFormattable.TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Próbuje sformatować wartość bieżącego wystąpienia jako UTF-8 w podanym zakresie bajtów.

Bezpieczeństwo wątkowe

Wszystkie elementy członkowskie tego typu są bezpieczne wątkowo. Elementy członkowskie, które na pierwszy rzut oka modyfikują stan wystąpienia, w rzeczywistości zwracają nowe wystąpienie zainicjowane z nową wartością. Podobnie jak w przypadku innych typów odczytywanie i zapisywanie w udostępnionej zmiennej, która zawiera wystąpienie tego typu, musi być chronione przez blokadę w celu zagwarantowania bezpieczeństwa wątków.

Zobacz też

• IComparable
• IConvertible
• String