Char Struktura

Definicja

Przestrzeń nazw:

System

Zestawy:

netstandard.dll, System.Runtime.dll

Źródło:

Char.cs

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 IUtf8SpanFormattable
    interface IUtf8SpanParsable<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 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> IComparable<TSelf> IEquatable<TSelf> IFormattable IParsable<Char> IParsable<TSelf> ISpanFormattable ISpanParsable<Char> ISpanParsable<TSelf> IUtf8SpanFormattable IUtf8SpanParsable<Char> IUtf8SpanParsable<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>

Przykłady

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

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

Struktura Char reprezentuje punkty kodu Unicode przy użyciu kodowania UTF-16. Wartość obiektu Char jest jego 16-bitową wartością liczbową (porządkową).

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

W tym artykule analizowana jest relacja między obiektem Char a postacią oraz omawiane są niektóre typowe zadania wykonywane z użyciem instancji Char. Zalecamy rozważenie typu Rune wprowadzonego na platformie .NET Core 3.0 jako alternatywy dla Char wykonywania niektórych z tych zadań.

Obiekty char, znaki Unicode i ciągi

Obiekt String to sekwencyjny zbiór struktur Char reprezentujący ciąg tekstu. Większość znaków Unicode może być reprezentowana przez pojedynczy obiekt Char, ale znak zakodowany jako znak podstawowy, para zastępcza i/lub łączenie sekwencji znaków jest reprezentowany przez wiele obiektów Char. Z tego powodu struktura Char w obiekcie 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:

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

  using System;
  using System.IO;
  
  public class Example1
  {
      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 Example2
      Public Sub Main()
          Dim sw As New StreamWriter("chars1.txt")
          Dim chars() As Char = {ChrW(&H61), ChrW(&H308)}
          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 MUZYCZNY SYMBOL ÓSMEJ NUTY. Ponieważ kodowanie UTF-16 ma tylko 16 bitów, znaki poza BMP są reprezentowane przez pary zastępcze w formacie UTF-16. Poniższy przykład ilustruje, że odpowiednikiem UTF-32 dla U+1D160, znaku symbolu muzycznego ósmej nuty, jest U+D834 U+DD60. U+D834 jest wysokim surrogatem; wysokie surrogaty wahają się od U+D800 do U+DBFF. U+DD60 jest niskim surogatem; zakres niskich surogatów rozciąga się od U+DC00 do U+DFFF.

  using System;
  using System.IO;
  
  public class Example3
  {
      public static void Main()
      {
          StreamWriter sw = new StreamWriter(@".\chars2.txt");
          int utf32 = 0x1D160;
          string surrogate = Char.ConvertFromUtf32(utf32);
          sw.WriteLine($"U+{utf32:X6} UTF-32 = {surrogate} ({ShowCodePoints(surrogate)}) UTF-16");
          sw.Close();
      }
  
      private static string ShowCodePoints(string value)
      {
          string retval = null;
          foreach (var ch in value)
              retval += $"U+{Convert.ToUInt16(ch):X4} ";
  
          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 Example4
      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 zawierają 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 następujący przykład wywołuje 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($"'{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 Example1
    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 (od U+0000 do U+00FF) metoda GetUnicodeCategory zależy od kategorii Unicode zgłoszonych przez klasę CharUnicodeInfo. Znaki Unicode są klasyfikowane na podstawie standardu Unicode w wersji 8.0.0.

Znaki i elementy tekstowe

Ponieważ pojedynczy znak może być reprezentowany przez wiele obiektów Char, pracowanie z poszczególnymi obiektami Char nie zawsze ma sens. Na przykład poniższy przykład konwertuje punkty kodu Unicode reprezentujące liczby Morza Egejskiego od 9 do 9 do zakodowanych jednostek kodu UTF-16. Ponieważ błędnie utożsamia obiekty Char ze znakami, błędnie zgłasza, że ciąg wynikowy ma 20 znaków.

using System;

public class Example5
{
    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 {result.Length} characters.");
    }
}
// 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 Example5
    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.

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

• Możesz pracować z obiektem String w całości zamiast pracować z poszczególnymi znakami w celu reprezentowania i analizowania zawartości językowej.

• Możesz użyć String.EnumerateRunes, 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
  

• Możesz użyć klasy StringInfo do pracy z elementami tekstowymi zamiast pojedynczych obiektów Char. W poniższym przykładzie użyto obiektu StringInfo, aby zliczyć liczbę elementów tekstowych w ciągu składającym się z liczb morza egejskiego zero do dziewięciu. Ponieważ uważa ona parę zastępczą za pojedynczy znak, prawidłowo zgłasza, że ciąg zawiera dziesięć znaków.

  using System;
  using System.Globalization;
  
  public class Example4
  {
      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 {si.LengthInTextElements} characters.");
      }
  }
  // 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 Example6
      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, który ma co najmniej jeden znak łączący, możesz wywołać metodę String.Normalize, aby przekonwertować podciąg na pojedynczą jednostkę kodu zakodowanego w formacie UTF-16. Poniższy przykład wywołuje metodę String.Normalize, aby przekonwertować znak podstawowy U+0061 (MAŁA LITERA A) i połączyć znak U+0308 (POŁĄCZENIE DIAERESIS) do U+00E4 (MAŁA LITERA ŁACIŃSKA A Z DIAEREZĄ).

  using System;
  
  public class Example2
  {
      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: {s.Length} (");
          for (int ctr = 0; ctr < s.Length; ctr++)
          {
              Console.Write($"U+{Convert.ToUInt16(s[ctr]):X4}");
              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 Example3
      Public Sub Main()
          Dim combining As String = ChrW(&H61) + ChrW(&H308)
          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 obiektów Char, konwertowania wartości bieżącego obiektu Char na obiekt innego typu i określania kategorii Unicode obiektu Char:

Aby to zrobić	Użyj tych System.Char metod
Porównanie obiektów Char	CompareTo i Equals
Konwertowanie punktu kodu na ciąg	ConvertFromUtf32 Zobacz również typ Rune.
Konwertowanie obiektu Char lub pary zastępczej obiektów Char na punkt kodu	Dla pojedynczego znaku: Convert.ToInt32(Char) Dla pary zastępczej lub znaku w ciągu: Char.ConvertToUtf32 Zobacz również typ Rune.
Pobieranie kategorii Unicode znaku	GetUnicodeCategory Zobacz również Rune.GetUnicodeCategory.
Określanie, czy znak znajduje się w określonej kategorii Unicode, takiej jak cyfra, litera, znak interpunkcyjny, znak kontrolny itd.	IsControl, IsDigit, IsHighSurrogate, IsLetter, IsLetterOrDigit, IsLower, IsLowSurrogate, IsNumber, IsPunctuation, IsSeparator, IsSurrogate, IsSurrogatePair, IsSymbol, IsUpperi IsWhiteSpace Zobacz również analogiczne metody dla typu Rune.
Konwertowanie obiektu Char reprezentującego liczbę na typ wartości liczbowej	GetNumericValue Zobacz również Rune.GetNumericValue.
Konwertowanie znaku w ciągu na obiekt Char	Parse i TryParse
Konwertowanie obiektu Char na obiekt String	ToString
Zmień wielkość liter obiektu Char	ToLower, ToLowerInvariant, ToUpperi ToUpperInvariant Zobacz również analogiczne metody dla typu Rune.

Wartości znaków i interoperacyjności

Gdy zarządzany typ Char, który jest reprezentowany jako jednostka kodu w formacie Unicode UTF-16, jest przekazywany do niezarządzanego kodu, marshaller interfejsu domyślnie konwertuje zestaw znaków na ANSI. Atrybut DllImportAttribute można zastosować do deklaracji wywoływania platformy, a atrybut StructLayoutAttribute do deklaracji międzyoperacyjnej COM, aby kontrolować, który zestaw znaków używa marshaled typu Char.

Pola

Nazwa	Opis
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

Nazwa	Opis
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 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 na 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 określonemu obiektowi.
GetHashCode()	Zwraca kod skrótu dla tego wystąpienia.
GetNumericValue(Char)	Konwertuje określony znak Unicode liczbowy na liczbę zmiennoprzecinkową o podwójnej precyzji.
GetNumericValue(String, Int32)	Konwertuje numeryczny znak Unicode na określoną pozycję 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 identyfikowanej przez jedną z UnicodeCategory wartości.
GetUnicodeCategory(String, Int32)	Kategoryzuje znak na określonej pozycji w określonym ciągu w grupie identyfikowanej 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 klasyfikowany jako cyfra ASCII.
IsAsciiHexDigit(Char)	Wskazuje, czy znak jest klasyfikowany jako cyfra szesnastkowa ASCII.
IsAsciiHexDigitLower(Char)	Wskazuje, czy znak jest klasyfikowany jako cyfra szesnastkowa ASCII.
IsAsciiHexDigitUpper(Char)	Wskazuje, czy znak jest klasyfikowany jako cyfra szesnastkowa ASCII.
IsAsciiLetter(Char)	Wskazuje, czy znak jest klasyfikowany jako litera ASCII.
IsAsciiLetterLower(Char)	Wskazuje, czy znak jest klasyfikowany jako mała litera ASCII.
IsAsciiLetterOrDigit(Char)	Wskazuje, czy znak jest klasyfikowany jako litera ASCII lub cyfra.
IsAsciiLetterUpper(Char)	Wskazuje, czy znak jest klasyfikowany 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 klasyfikowany jako znak kontrolny.
IsControl(String, Int32)	Wskazuje, czy znak na określonej pozycji w określonym ciągu jest klasyfikowany jako znak kontrolny.
IsDigit(Char)	Wskazuje, czy określony znak Unicode jest klasyfikowany jako cyfra dziesiętna.
IsDigit(String, Int32)	Wskazuje, czy znak na określonej pozycji w określonym ciągu jest klasyfikowany jako cyfra dziesiętna.
IsHighSurrogate(Char)	Wskazuje, czy określony Char obiekt jest wysokim surogatem.
IsHighSurrogate(String, Int32)	Wskazuje, czy Char obiekt na określonej pozycji w ciągu jest wysokim zastępcą.
IsLetter(Char)	Wskazuje, czy określony znak Unicode jest klasyfikowany jako litera Unicode.
IsLetter(String, Int32)	Wskazuje, czy znak na określonej pozycji w określonym ciągu jest klasyfikowany jako litera Unicode.
IsLetterOrDigit(Char)	Wskazuje, czy określony znak Unicode jest klasyfikowany jako litera, czy cyfra dziesiętna.
IsLetterOrDigit(String, Int32)	Wskazuje, czy znak na określonej pozycji w określonym ciągu jest klasyfikowany jako litera lub cyfra dziesiętna.
IsLower(Char)	Wskazuje, czy określony znak Unicode jest klasyfikowany jako mała litera.
IsLower(String, Int32)	Wskazuje, czy znak na określonej pozycji w określonym ciągu jest klasyfikowany jako mała litera.
IsLowSurrogate(Char)	Wskazuje, czy określony Char obiekt jest niskim zastępcą.
IsLowSurrogate(String, Int32)	Wskazuje, czy Char obiekt na określonej pozycji w ciągu jest niskim zastępcą.
IsNumber(Char)	Wskazuje, czy określony znak Unicode jest klasyfikowany jako liczba.
IsNumber(String, Int32)	Wskazuje, czy znak na określonej pozycji w określonym ciągu jest klasyfikowany jako liczba.
IsPunctuation(Char)	Wskazuje, czy określony znak Unicode jest klasyfikowany jako znak interpunkcyjny.
IsPunctuation(String, Int32)	Wskazuje, czy znak na określonej pozycji w określonym ciągu jest klasyfikowany jako znak interpunkcyjny.
IsSeparator(Char)	Wskazuje, czy określony znak Unicode jest klasyfikowany jako znak separatora.
IsSeparator(String, Int32)	Wskazuje, czy znak na określonej pozycji w określonym ciągu jest klasyfikowany jako znak separatora.
IsSurrogate(Char)	Wskazuje, czy określony znak ma zastępczą jednostkę kodu.
IsSurrogate(String, Int32)	Wskazuje, czy znak na określonej pozycji w określonym ciągu ma zastępczą jednostkę kodu.
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 na określonej pozycji w ciągu tworzą parę zastępczą.
IsSymbol(Char)	Wskazuje, czy określony znak Unicode jest klasyfikowany jako znak symbolu.
IsSymbol(String, Int32)	Wskazuje, czy znak na określonej pozycji w określonym ciągu jest klasyfikowany jako znak symbolu.
IsUpper(Char)	Wskazuje, czy określony znak Unicode jest klasyfikowany jako wielka litera.
IsUpper(String, Int32)	Wskazuje, czy znak na określonej pozycji w określonym ciągu jest klasyfikowany jako wielka litera.
IsWhiteSpace(Char)	Wskazuje, czy określony znak Unicode jest skategoryzowany jako biały znak.
IsWhiteSpace(String, Int32)	Wskazuje, czy znak na określonej pozycji w określonym ciągu jest klasyfikowany jako biały znak.
Parse(String)	Konwertuje wartość określonego ciągu na odpowiedni znak Unicode.
ToLower(Char, CultureInfo)	Konwertuje wartość określonego znaku Unicode na jego małe litery równoważne przy użyciu określonych informacji formatowania specyficznych dla kultury.
ToLower(Char)	Konwertuje wartość znaku Unicode na jego małe litery równoważne.
ToLowerInvariant(Char)	Konwertuje wartość znaku Unicode na jej małe litery równoważne przy użyciu reguł wielkości liter niezmiennej kultury.
ToString()	Konwertuje wartość tego wystąpienia na równoważną reprezentację 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, 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.
ToUpper(Char)	Konwertuje wartość znaku Unicode na jego wielkie litery równoważne.
ToUpperInvariant(Char)	Konwertuje wartość znaku Unicode na jego wielkie litery równoważne przy użyciu reguł wielkości liter niezmiennej kultury.
TryParse(String, Char)	Konwertuje wartość określonego ciągu na odpowiedni znak Unicode. Kod powrotny wskazuje, czy konwersja zakończyła się powodzeniem, czy niepowodzeniem.

Jawne implementacje interfejsu

Nazwa	Opis
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 elementu TryWriteLittleEndian(Span<Byte>, Int32).
IBinaryInteger<Char>.GetShortestBitLength()	Pobiera długość w bitach najkrótszej reprezentacji wartości bieżącej.
IBinaryInteger<Char>.LeadingZeroCount(Char)	Oblicza liczbę bitów zera wiodącego 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ść w prawo o daną kwotę.
IBinaryInteger<Char>.TrailingZeroCount(Char)	Oblicza liczbę bitów końcowych zero 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 są ustawione wszystkie bity.
IBinaryNumber<Char>.IsPow2(Char)	Określa, czy wartość jest potęgą dwóch.
IBinaryNumber<Char>.Log2(Char)	Oblicza dziennik2 wartości.
IBitwiseOperators<Char,Char,Char>.BitwiseAnd(Char, Char)	Oblicza bitowe wartości i dwie wartości.
IBitwiseOperators<Char,Char,Char>.BitwiseOr(Char, Char)	Oblicza bitowe lub dwie wartości.
IBitwiseOperators<Char,Char,Char>.ExclusiveOr(Char, Char)	Oblicza wyłącznie lub dwie wartości.
IBitwiseOperators<Char,Char,Char>.OnesComplement(Char)	Oblicza reprezentację danej 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óre wartości są większe lub równe.
IComparisonOperators<Char,Char,Boolean>.LessThan(Char, Char)	Porównuje dwie wartości, aby określić, które wartości są mniejsze.
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 tego wyrzuca 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 tego wyrzuca InvalidCastException.
IConvertible.ToDecimal(IFormatProvider)	Uwaga Ta konwersja nie jest obsługiwana. Próba wykonania tego wyrzuca InvalidCastException.
IConvertible.ToDouble(IFormatProvider)	Uwaga Ta konwersja nie jest obsługiwana. Próba wykonania tego wyrzuca 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 tego wyrzuca 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, aby obliczyć ich modulo lub resztę.
IMultiplicativeIdentity<Char,Char>.MultiplicativeIdentity	Pobiera mnożenie tożsamości bieżącego typu.
IMultiplyOperators<Char,Char,Char>.CheckedMultiply(Char, Char)	Mnoży dwie wartości, aby obliczyć swój produkt.
IMultiplyOperators<Char,Char,Char>.Multiply(Char, Char)	Mnoży dwie wartości, aby obliczyć swój produkt.
INumberBase<Char>.Abs(Char)	Oblicza wartość bezwzględną.
INumberBase<Char>.IsCanonical(Char)	Określa, czy wartość znajduje się w jej kanonicznej reprezentacji.
INumberBase<Char>.IsComplexNumber(Char)	Określa, czy wartość reprezentuje liczbę zespolonej.
INumberBase<Char>.IsEvenInteger(Char)	Określa, czy wartość reprezentuje liczbę całkowitą parzystą.
INumberBase<Char>.IsFinite(Char)	Określa, czy wartość jest skończona.
INumberBase<Char>.IsImaginaryNumber(Char)	Określa, czy wartość reprezentuje czystą liczbę wyimaginowaną.
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 nieparzystną 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 nienormalna.
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 z obliczeniami o większej wielkości i zwraca drugą 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 z obliczeniami o mniejszej wielkości i zwraca drugą wartość, jeśli dane wejściowe to NaN.
INumberBase<Char>.MultiplyAddEstimate(Char, Char, Char)	Oblicza oszacowanie (left * right) i . addend
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ści.
INumberBase<Char>.Radix	Pobiera podstawę (radix) 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 mieszczą się poza dopuszczalnym zakresem 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 dopuszczalnym 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 wykraczają poza reprezentowany zakres 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ści.
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ść.
IUtf8SpanFormattable.TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Próbuje sformatować wartość bieżącego wystąpienia jako UTF-8 w podanym zakresie bajtów.
IUtf8SpanParsable<Char>.Parse(ReadOnlySpan<Byte>, IFormatProvider)	Reprezentuje znak jako jednostkę kodu UTF-16.
IUtf8SpanParsable<Char>.TryParse(ReadOnlySpan<Byte>, IFormatProvider, Char)	Reprezentuje znak jako jednostkę kodu UTF-16.

Bezpieczeństwo wątkowe

Wszyscy członkowie tego typu są bezpieczni wątkami. Elementy członkowskie, które wydają się modyfikować stan wystąpienia, zwracają nowe wystąpienie zainicjowane przy użyciu nowej wartości. Podobnie jak w przypadku dowolnego innego typu odczyt i zapis w zmiennej udostępnionej, która zawiera wystąpienie tego typu, musi być chroniona przez blokadę, aby zagwarantować bezpieczeństwo wątków.

Zobacz też

• IComparable
• IConvertible
• String