Char Struct

Definitie

Naamruimte:

System

Assembly's:

netstandard.dll, System.Runtime.dll

Bron:

Char.cs

Vertegenwoordigt een teken als een UTF-16-code-eenheid.

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)

Overname

Object

ValueType

Char

Implementeringen

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>

Voorbeelden

In het volgende codevoorbeeld ziet u enkele van de methoden in Char.

using System;

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

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

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

Opmerkingen

De Char structuur vertegenwoordigt Unicode-codepunten met behulp van UTF-16-codering. De waarde van een Char object is de 16-bits numerieke waarde (rangtelwaarde).

Als u niet bekend bent met Unicode, scalaire waarden, codepunten, surrogaatparen, UTF-16 en het Rune type, raadpleegt u Inleiding tot tekencodering in .NET.

In dit artikel wordt de relatie tussen een Char object en een teken onderzocht en worden enkele algemene taken besproken die worden uitgevoerd met Char exemplaren. U wordt aangeraden rekening te houden met het Rune type, geïntroduceerd in .NET Core 3.0, als alternatief Char voor het uitvoeren van een aantal van deze taken.

Char-objecten, Unicode-tekens en tekenreeksen

Een String object is een sequentiële verzameling Char structuren die een tekenreeks van tekst vertegenwoordigt. De meeste Unicode-tekens kunnen worden vertegenwoordigd door één Char object, maar een teken dat is gecodeerd als basisteken, surrogaatpaar en/of het combineren van tekenreeksen wordt weergegeven door meerdere Char objecten. Daarom is een Char structuur in een String object niet noodzakelijkerwijs gelijk aan één Unicode-teken.

In de volgende gevallen worden meerdere 16-bits code-eenheden gebruikt om enkele Unicode-tekens weer te geven:

• Glyphs, die kunnen bestaan uit één teken of uit een basisteken, gevolgd door een of meer combinatietekens. Het teken ä wordt bijvoorbeeld vertegenwoordigd door een Char object waarvan de code-eenheid U+0061 is, gevolgd door een Char object waarvan de code-eenheid U+0308 is. (Het teken ä kan ook worden gedefinieerd door één Char object met een code-eenheid van U+00E4.) In het volgende voorbeeld ziet u dat het teken ä uit twee Char objecten bestaat.

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

• Tekens buiten het Unicode Basis Meertalig Vlak (BMP). Unicode ondersteunt zestien vliegtuigen naast de BMP, die vlak 0 vertegenwoordigt. Een Unicode-codepunt wordt weergegeven in UTF-32 door een 21-bits waarde die het vlak bevat. U+1D160 vertegenwoordigt bijvoorbeeld het teken MUSICAL SYMBOL ACHTSTE NOOT. Omdat UTF-16-codering slechts 16 bits heeft, worden tekens buiten de BMP vertegenwoordigd door surrogaatparen in UTF-16. In het volgende voorbeeld ziet u dat het UTF-32-equivalent van U+1D160, het teken MUSICAL SYMBOL ACHTSTE NOOT, U+D834 U+DD60 is. U+D834 is het hoge surrogaat; hoge surrogaten variëren van U+D800 tot en met U+DBFF. U+DD60 is het lage surrogaat; lage surrogaten variëren van U+DC00 tot en met 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
  

Tekens en tekencategorieën

Elk Unicode-teken of geldig surrogaatpaar behoort tot een Unicode-categorie. In .NET worden Unicode-categorieën vertegenwoordigd door leden van de UnicodeCategory opsomming en bevatten ze waarden zoals UnicodeCategory.CurrencySymbol, UnicodeCategory.LowercaseLetteren UnicodeCategory.SpaceSeparatorbijvoorbeeld.

Als u de Unicode-categorie van een teken wilt bepalen, roept u de GetUnicodeCategory methode aan. In het volgende voorbeeld wordt GetUnicodeCategory aangeroepen om de Unicode-categorie van elk teken in een tekenreeks weer te geven. Het voorbeeld werkt alleen correct als er geen surrogaatparen in het String exemplaar zijn.

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

Intern, voor tekens buiten het ASCII-bereik (U+0000 tot en met U+00FF), is de GetUnicodeCategory methode afhankelijk van Unicode-categorieën die door de CharUnicodeInfo klasse worden gerapporteerd. Unicode-tekens worden geclassificeerd op basis van de Unicode-standaard, versie 8.0.0.

Tekens en tekstelementen

Omdat één teken kan worden vertegenwoordigd door meerdere Char objecten, is het niet altijd zinvol om met afzonderlijke Char objecten te werken. In het volgende voorbeeld worden bijvoorbeeld de Unicode-codepunten die de Egeïsche getallen nul tot en met 9 vertegenwoordigen, geconverteerd naar UTF-16 gecodeerde code-eenheden. Omdat Char objecten onterecht worden vergeleken met tekens, wordt er ten onrecht gerapporteerd dat de resulterende tekenreeks 20 tekens bevat.

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.

U kunt het volgende doen om te voorkomen dat een Char object één teken vertegenwoordigt:

• U kunt met een String object in zijn geheel werken in plaats van met de afzonderlijke tekens te werken om taalkundige inhoud weer te geven en te analyseren.

• U kunt deze gebruiken String.EnumerateRunes zoals wordt weergegeven in het volgende voorbeeld:

  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
  

• U kunt de StringInfo klasse gebruiken om te werken met tekstelementen in plaats van afzonderlijke Char objecten. In het volgende voorbeeld wordt het StringInfo object gebruikt om het aantal tekstelementen in een tekenreeks te tellen dat bestaat uit de Egeïsche getallen nul tot en met negen. Omdat het een surrogaatpaar als één teken beschouwt, wordt correct gerapporteerd dat de string tien tekens bevat.

  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.
  

• Als een tekenreeks een basisteken bevat met een of meer combinaties van tekens, kunt u de String.Normalize methode aanroepen om de subtekenreeks te converteren naar één gecodeerde UTF-16-code-eenheid. In het volgende voorbeeld wordt de String.Normalize methode aangeroepen om het basisteken U+0061 (LATIJNSE KLEINE LETTER A) en het combinerende diakritische teken U+0308 (COMBINING DIAERESIS) te converteren naar U+00E4 (LATIJNSE KLEINE LETTER A MET DIAERESIS).

  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)
  

Algemene bewerkingen

De Char structuur biedt methoden om objecten te vergelijken Char , de waarde van het huidige Char object te converteren naar een object van een ander type en de Unicode-categorie van een Char object te bepalen:

Om dit te doen	Gebruik deze System.Char methoden
Objecten vergelijken Char	CompareTo en Equals
Een codepunt converteren naar een tekenreeks	ConvertFromUtf32 Zie ook het Rune type.
Een Char object of een surrogaatpaar objecten Char converteren naar een codepunt	Voor één teken: Convert.ToInt32(Char) Voor een surrogaatpaar of een teken in een tekenreeks: Char.ConvertToUtf32 Zie ook het Rune type.
De Unicode-categorie van een teken ophalen	GetUnicodeCategory Zie ook Rune.GetUnicodeCategory.
Bepalen of een teken zich in een bepaalde Unicode-categorie bevindt, zoals cijfer, letter, interpunctie, besturingselementteken enzovoort	IsControl, IsDigit, IsHighSurrogate, IsLetter, IsLetterOrDigit, IsLower, IsLowSurrogate, IsNumber, IsPunctuation, IsSeparator, IsSurrogate, IsSurrogatePair, IsSymbol, IsUpper, en IsWhiteSpace Zie ook de bijbehorende methoden voor het Rune type.
Char Een object converteren dat een getal vertegenwoordigt naar een numeriek waardetype	GetNumericValue Zie ook Rune.GetNumericValue.
Een teken in een tekenreeks converteren naar een Char object	Parse en TryParse
Een Char object converteren naar een String object	ToString
Het hoofdlettergebruik van een Char object wijzigen	ToLower, ToLowerInvariant, ToUpper en ToUpperInvariant Zie ook de bijbehorende methoden voor het Rune type.

Tekenwaarden en interoperabiliteit

Wanneer een beheerd Char type, dat wordt weergegeven als een Unicode UTF-16-code-eenheid, wordt doorgegeven aan niet-beheerde code, converteert de interop marshaller de tekenset standaard naar ANSI. U kunt het DllImportAttribute kenmerk toepassen op declaraties voor platformaanroepen en het StructLayoutAttribute kenmerk op een COM-interoperabiliteitsdeclaratie om te bepalen welke tekenset een marshaled Char type gebruikt.

Velden

Name	Description
MaxValue	Vertegenwoordigt de grootst mogelijke waarde van een Char. Dit veld is constant.
MinValue	Vertegenwoordigt de kleinste mogelijke waarde van een Char. Dit veld is constant.

Methoden

Name	Description
CompareTo(Char)	Vergelijkt dit exemplaar met een opgegeven Char object en geeft aan of deze instantie voorafgaat, volgt of op dezelfde positie wordt weergegeven in de sorteervolgorde als het opgegeven Char object.
CompareTo(Object)	Vergelijkt dit exemplaar met een opgegeven object en geeft aan of deze instantie voorafgaat, volgt of op dezelfde positie wordt weergegeven in de sorteervolgorde als de opgegeven Object.
ConvertFromUtf32(Int32)	Converteert het opgegeven Unicode-codepunt naar een UTF-16-gecodeerde tekenreeks.
ConvertToUtf32(Char, Char)	Converteert de waarde van een UTF-16 gecodeerd surrogaatpaar naar een Unicode-codepunt.
ConvertToUtf32(String, Int32)	Converteert de waarde van een UTF-16 gecodeerd teken of surrogaatpaar op een opgegeven positie in een tekenreeks naar een Unicode-codepunt.
Equals(Char)	Retourneert een waarde die aangeeft of dit exemplaar gelijk is aan het opgegeven Char object.
Equals(Object)	Retourneert een waarde die aangeeft of dit exemplaar gelijk is aan een opgegeven object.
GetHashCode()	Retourneert de hash-code voor dit exemplaar.
GetNumericValue(Char)	Converteert het opgegeven numerieke Unicode-teken naar een getal met dubbele precisie.
GetNumericValue(String, Int32)	Converteert het numerieke Unicode-teken op de opgegeven positie in een opgegeven tekenreeks naar een getal met dubbele precisie.
GetTypeCode()	Geeft als resultaat het TypeCode voor waardetype Char.
GetUnicodeCategory(Char)	Hiermee categoriseert u een opgegeven Unicode-teken in een groep die wordt geïdentificeerd door een van de UnicodeCategory waarden.
GetUnicodeCategory(String, Int32)	Categoriseert het teken op de opgegeven positie in een opgegeven tekenreeks in een groep die wordt geïdentificeerd door een van de UnicodeCategory waarden.
IsAscii(Char)	Retourneert true een c ASCII-teken ([ U+0000..U+007F ]).
IsAsciiDigit(Char)	Geeft aan of een teken is gecategoriseerd als een ASCII-cijfer.
IsAsciiHexDigit(Char)	Geeft aan of een teken is gecategoriseerd als een ASCII hexadecimaal cijfer.
IsAsciiHexDigitLower(Char)	Geeft aan of een teken is gecategoriseerd als een ASCII-kleine hexadecimale cijfer.
IsAsciiHexDigitUpper(Char)	Geeft aan of een teken is gecategoriseerd als een ASCII hoofdletter hexadecimaal cijfer.
IsAsciiLetter(Char)	Geeft aan of een teken is gecategoriseerd als een ASCII-letter.
IsAsciiLetterLower(Char)	Geeft aan of een teken is gecategoriseerd als een ASCII-letter in kleine letters.
IsAsciiLetterOrDigit(Char)	Geeft aan of een teken is gecategoriseerd als een ASCII-letter of cijfer.
IsAsciiLetterUpper(Char)	Geeft aan of een teken is gecategoriseerd als een ASCII-letter in hoofdletters.
IsBetween(Char, Char, Char)	Geeft aan of een teken zich binnen het opgegeven inclusieve bereik bevindt.
IsControl(Char)	Geeft aan of het opgegeven Unicode-teken is gecategoriseerd als een besturingselementteken.
IsControl(String, Int32)	Geeft aan of het teken op de opgegeven positie in een opgegeven tekenreeks is gecategoriseerd als een besturingselementteken.
IsDigit(Char)	Geeft aan of het opgegeven Unicode-teken is gecategoriseerd als een decimaal getal.
IsDigit(String, Int32)	Hiermee wordt aangegeven of het teken op de opgegeven positie in een opgegeven tekenreeks is gecategoriseerd als een decimaal cijfer.
IsHighSurrogate(Char)	Geeft aan of het opgegeven Char object een hoog surrogaat is.
IsHighSurrogate(String, Int32)	Geeft aan of het Char object op de opgegeven positie in een tekenreeks een hoog surrogaat is.
IsLetter(Char)	Geeft aan of het opgegeven Unicode-teken is gecategoriseerd als een Unicode-letter.
IsLetter(String, Int32)	Geeft aan of het teken op de opgegeven positie in een opgegeven tekenreeks is gecategoriseerd als een Unicode-letter.
IsLetterOrDigit(Char)	Geeft aan of het opgegeven Unicode-teken is gecategoriseerd als een letter of een decimaal cijfer.
IsLetterOrDigit(String, Int32)	Hiermee wordt aangegeven of het teken op de opgegeven positie in een opgegeven tekenreeks is gecategoriseerd als een letter of een decimaal cijfer.
IsLower(Char)	Hiermee wordt aangegeven of het opgegeven Unicode-teken is gecategoriseerd als een kleine letter.
IsLower(String, Int32)	Hiermee wordt aangegeven of het teken op de opgegeven positie in een opgegeven tekenreeks is gecategoriseerd als een kleine letter.
IsLowSurrogate(Char)	Geeft aan of het opgegeven Char object een laag surrogaat is.
IsLowSurrogate(String, Int32)	Geeft aan of het Char object op de opgegeven positie in een tekenreeks een laag surrogaat is.
IsNumber(Char)	Geeft aan of het opgegeven Unicode-teken is gecategoriseerd als een getal.
IsNumber(String, Int32)	Geeft aan of het teken op de opgegeven positie in een opgegeven tekenreeks is gecategoriseerd als een getal.
IsPunctuation(Char)	Geeft aan of het opgegeven Unicode-teken is gecategoriseerd als leesteken.
IsPunctuation(String, Int32)	Hiermee wordt aangegeven of het teken op de opgegeven positie in een opgegeven tekenreeks is gecategoriseerd als leesteken.
IsSeparator(Char)	Geeft aan of het opgegeven Unicode-teken is gecategoriseerd als scheidingsteken.
IsSeparator(String, Int32)	Geeft aan of het teken op de opgegeven positie in een opgegeven tekenreeks is gecategoriseerd als scheidingsteken.
IsSurrogate(Char)	Geeft aan of het opgegeven teken een surrogaatcode-eenheid heeft.
IsSurrogate(String, Int32)	Geeft aan of het teken op de opgegeven positie in een opgegeven tekenreeks een surrogaatcode-eenheid heeft.
IsSurrogatePair(Char, Char)	Geeft aan of de twee opgegeven Char objecten een surrogaatpaar vormen.
IsSurrogatePair(String, Int32)	Geeft aan of twee aangrenzende Char objecten op een opgegeven positie in een tekenreeks een surrogaatpaar vormen.
IsSymbol(Char)	Geeft aan of het opgegeven Unicode-teken is gecategoriseerd als een symboolteken.
IsSymbol(String, Int32)	Geeft aan of het teken op de opgegeven positie in een opgegeven tekenreeks is gecategoriseerd als een symboolteken.
IsUpper(Char)	Geeft aan of het opgegeven Unicode-teken is gecategoriseerd als een hoofdletter.
IsUpper(String, Int32)	Geeft aan of het teken op de opgegeven positie in een opgegeven tekenreeks is gecategoriseerd als een hoofdletter.
IsWhiteSpace(Char)	Hiermee wordt aangegeven of het opgegeven Unicode-teken is gecategoriseerd als witruimte.
IsWhiteSpace(String, Int32)	Geeft aan of het teken op de opgegeven positie in een opgegeven tekenreeks is gecategoriseerd als witruimte.
Parse(String)	Converteert de waarde van de opgegeven tekenreeks naar het equivalente Unicode-teken.
ToLower(Char, CultureInfo)	Converteert de waarde van een opgegeven Unicode-teken naar het equivalent in kleine letters met behulp van opgegeven cultuurspecifieke opmaakinformatie.
ToLower(Char)	Converteert de waarde van een Unicode-teken naar het equivalent in kleine letters.
ToLowerInvariant(Char)	Converteert de waarde van een Unicode-teken naar het equivalent in kleine letters met behulp van de hoofdletterregels van de invariante cultuur.
ToString()	Converteert de waarde van dit exemplaar naar de equivalente tekenreeksweergave.
ToString(Char)	Converteert het opgegeven Unicode-teken naar de equivalente tekenreeksweergave.
ToString(IFormatProvider)	Converteert de waarde van dit exemplaar naar de equivalente tekenreeksweergave met behulp van de opgegeven cultuurspecifieke notatiegegevens.
ToUpper(Char, CultureInfo)	Converteert de waarde van een opgegeven Unicode-teken naar het bijbehorende equivalent in hoofdletters met behulp van opgegeven cultuurspecifieke opmaakinformatie.
ToUpper(Char)	Converteert de waarde van een Unicode-teken naar het equivalent in hoofdletters.
ToUpperInvariant(Char)	Converteert de waarde van een Unicode-teken naar het equivalent in hoofdletters met behulp van de hoofdletterregels van de invariante cultuur.
TryParse(String, Char)	Converteert de waarde van de opgegeven tekenreeks naar het equivalente Unicode-teken. Een retourcode geeft aan of de conversie is geslaagd of mislukt.

Expliciete interface-implementaties

Name	Description
IAdditionOperators<Char,Char,Char>.Addition(Char, Char)	Voegt twee waarden samen om de som te berekenen.
IAdditionOperators<Char,Char,Char>.CheckedAddition(Char, Char)	Voegt twee waarden samen om de som te berekenen.
IAdditiveIdentity<Char,Char>.AdditiveIdentity	Hiermee haalt u de additieve identiteit van het huidige type op.
IBinaryInteger<Char>.GetByteCount()	Hiermee haalt u het aantal bytes op dat wordt geschreven als onderdeel van TryWriteLittleEndian(Span<Byte>, Int32).
IBinaryInteger<Char>.GetShortestBitLength()	Hiermee haalt u de lengte, in bits, van de kortste twee's complementweergave van de huidige waarde op.
IBinaryInteger<Char>.LeadingZeroCount(Char)	Berekent het aantal voorloopnul bits in een waarde.
IBinaryInteger<Char>.PopCount(Char)	Berekent het aantal bits dat in een waarde is ingesteld.
IBinaryInteger<Char>.RotateLeft(Char, Int32)	Hiermee draait u een waarde naar links met een bepaald bedrag.
IBinaryInteger<Char>.RotateRight(Char, Int32)	Hiermee draait u een waarde naar rechts met een bepaald bedrag.
IBinaryInteger<Char>.TrailingZeroCount(Char)	Berekent het aantal volgnullen bits in een waarde.
IBinaryInteger<Char>.TryReadBigEndian(ReadOnlySpan<Byte>, Boolean, Char)	Vertegenwoordigt een teken als een UTF-16-code-eenheid.
IBinaryInteger<Char>.TryReadLittleEndian(ReadOnlySpan<Byte>, Boolean, Char)	Vertegenwoordigt een teken als een UTF-16-code-eenheid.
IBinaryInteger<Char>.TryWriteBigEndian(Span<Byte>, Int32)	Probeert de huidige waarde in big-endian-indeling naar een bepaalde periode te schrijven.
IBinaryInteger<Char>.TryWriteLittleEndian(Span<Byte>, Int32)	Probeert de huidige waarde in little-endian-indeling naar een bepaalde periode te schrijven.
IBinaryNumber<Char>.AllBitsSet	Hiermee haalt u een exemplaar op van het binaire type waarin alle bits zijn ingesteld.
IBinaryNumber<Char>.IsPow2(Char)	Bepaalt of een waarde een macht van twee is.
IBinaryNumber<Char>.Log2(Char)	Berekent het logboek2 van een waarde.
IBitwiseOperators<Char,Char,Char>.BitwiseAnd(Char, Char)	Berekent de bitsgewijze en van twee waarden.
IBitwiseOperators<Char,Char,Char>.BitwiseOr(Char, Char)	Berekent de bitsgewijze of twee waarden.
IBitwiseOperators<Char,Char,Char>.ExclusiveOr(Char, Char)	Berekent de exclusieve of twee waarden.
IBitwiseOperators<Char,Char,Char>.OnesComplement(Char)	Berekent de een-complementweergave van een bepaalde waarde.
IComparisonOperators<Char,Char,Boolean>.GreaterThan(Char, Char)	Vergelijkt twee waarden om te bepalen welke groter is.
IComparisonOperators<Char,Char,Boolean>.GreaterThanOrEqual(Char, Char)	Vergelijkt twee waarden om te bepalen welke groter of gelijk is.
IComparisonOperators<Char,Char,Boolean>.LessThan(Char, Char)	Vergelijkt twee waarden om te bepalen welke kleiner is.
IComparisonOperators<Char,Char,Boolean>.LessThanOrEqual(Char, Char)	Vergelijkt twee waarden om te bepalen welke kleiner of gelijk is.
IConvertible.ToBoolean(IFormatProvider)	Opmerking Deze conversie wordt niet ondersteund. Poging dit te doen, werpt een InvalidCastException op.
IConvertible.ToByte(IFormatProvider)	Zie voor een beschrijving van dit lid ToByte(IFormatProvider).
IConvertible.ToChar(IFormatProvider)	Zie voor een beschrijving van dit lid ToChar(IFormatProvider).
IConvertible.ToDateTime(IFormatProvider)	Opmerking Deze conversie wordt niet ondersteund. Poging dit te doen, werpt een InvalidCastException op.
IConvertible.ToDecimal(IFormatProvider)	Opmerking Deze conversie wordt niet ondersteund. Poging dit te doen, werpt een InvalidCastException op.
IConvertible.ToDouble(IFormatProvider)	Opmerking Deze conversie wordt niet ondersteund. Poging dit te doen, werpt een InvalidCastException op.
IConvertible.ToInt16(IFormatProvider)	Zie voor een beschrijving van dit lid ToInt16(IFormatProvider).
IConvertible.ToInt32(IFormatProvider)	Zie voor een beschrijving van dit lid ToInt32(IFormatProvider).
IConvertible.ToInt64(IFormatProvider)	Zie voor een beschrijving van dit lid ToInt64(IFormatProvider).
IConvertible.ToSByte(IFormatProvider)	Zie voor een beschrijving van dit lid ToSByte(IFormatProvider).
IConvertible.ToSingle(IFormatProvider)	Opmerking Deze conversie wordt niet ondersteund. Poging dit te doen, werpt een InvalidCastException op.
IConvertible.ToType(Type, IFormatProvider)	Zie voor een beschrijving van dit lid ToType(Type, IFormatProvider).
IConvertible.ToUInt16(IFormatProvider)	Zie voor een beschrijving van dit lid ToUInt16(IFormatProvider).
IConvertible.ToUInt32(IFormatProvider)	Zie voor een beschrijving van dit lid ToUInt32(IFormatProvider).
IConvertible.ToUInt64(IFormatProvider)	Zie voor een beschrijving van dit lid ToUInt64(IFormatProvider).
IDecrementOperators<Char>.CheckedDecrement(Char)	Een waarde verlagen.
IDecrementOperators<Char>.Decrement(Char)	Een waarde verlagen.
IDivisionOperators<Char,Char,Char>.Division(Char, Char)	Verdeelt de ene waarde door een andere om het quotiënt te berekenen.
IEqualityOperators<Char,Char,Boolean>.Equality(Char, Char)	Vergelijkt twee waarden om gelijkheid te bepalen.
IEqualityOperators<Char,Char,Boolean>.Inequality(Char, Char)	Vergelijkt twee waarden om ongelijkheid te bepalen.
IFormattable.ToString(String, IFormatProvider)	Hiermee wordt de waarde van het huidige exemplaar opgemaakt met behulp van de opgegeven indeling.
IIncrementOperators<Char>.CheckedIncrement(Char)	Hiermee wordt een waarde verhoogd.
IIncrementOperators<Char>.Increment(Char)	Hiermee wordt een waarde verhoogd.
IMinMaxValue<Char>.MaxValue	Hiermee wordt de maximumwaarde van het huidige type opgehaald.
IMinMaxValue<Char>.MinValue	Hiermee wordt de minimumwaarde van het huidige type opgehaald.
IModulusOperators<Char,Char,Char>.Modulus(Char, Char)	Verdeelt twee waarden samen om hun modulus of restgetal te berekenen.
IMultiplicativeIdentity<Char,Char>.MultiplicativeIdentity	Hiermee haalt u de vermenigvuldigende identiteit van het huidige type op.
IMultiplyOperators<Char,Char,Char>.CheckedMultiply(Char, Char)	Vermenigvuldigt twee waarden samen om het product te berekenen.
IMultiplyOperators<Char,Char,Char>.Multiply(Char, Char)	Vermenigvuldigt twee waarden samen om het product te berekenen.
INumberBase<Char>.Abs(Char)	Berekent de absolute waarde van een waarde.
INumberBase<Char>.IsCanonical(Char)	Bepaalt of een waarde zich in de canonieke weergave bevindt.
INumberBase<Char>.IsComplexNumber(Char)	Bepaalt of een waarde een complex getal vertegenwoordigt.
INumberBase<Char>.IsEvenInteger(Char)	Bepaalt of een waarde een even integraal getal vertegenwoordigt.
INumberBase<Char>.IsFinite(Char)	Bepaalt of een waarde eindig is.
INumberBase<Char>.IsImaginaryNumber(Char)	Bepaalt of een waarde een puur imaginair getal vertegenwoordigt.
INumberBase<Char>.IsInfinity(Char)	Bepaalt of een waarde oneindig is.
INumberBase<Char>.IsInteger(Char)	Bepaalt of een waarde een integraal getal vertegenwoordigt.
INumberBase<Char>.IsNaN(Char)	Bepaalt of een waarde NaN is.
INumberBase<Char>.IsNegative(Char)	Bepaalt of een waarde negatief is.
INumberBase<Char>.IsNegativeInfinity(Char)	Bepaalt of een waarde een negatief oneindigheid is.
INumberBase<Char>.IsNormal(Char)	Bepaalt of een waarde normaal is.
INumberBase<Char>.IsOddInteger(Char)	Bepaalt of een waarde een oneven integraal getal vertegenwoordigt.
INumberBase<Char>.IsPositive(Char)	Bepaalt of een waarde positief is.
INumberBase<Char>.IsPositiveInfinity(Char)	Bepaalt of een waarde positief oneindig is.
INumberBase<Char>.IsRealNumber(Char)	Bepaalt of een waarde een reëel getal vertegenwoordigt.
INumberBase<Char>.IsSubnormal(Char)	Bepaalt of een waarde subnormaal is.
INumberBase<Char>.IsZero(Char)	Bepaalt of een waarde nul is.
INumberBase<Char>.MaxMagnitude(Char, Char)	Vergelijkt twee waarden met berekeningen die groter zijn.
INumberBase<Char>.MaxMagnitudeNumber(Char, Char)	Vergelijkt twee waarden met berekeningen die de grotere grootte hebben en de andere waarde retourneren als een invoer is NaN.
INumberBase<Char>.MinMagnitude(Char, Char)	Vergelijkt twee waarden met berekeningen die kleiner zijn.
INumberBase<Char>.MinMagnitudeNumber(Char, Char)	Vergelijkt twee waarden met berekeningen die de lagere grootte hebben en de andere waarde retourneren als een invoer is NaN.
INumberBase<Char>.MultiplyAddEstimate(Char, Char, Char)	Berekent een schatting van (left * right) + addend.
INumberBase<Char>.One	Hiermee haalt u de waarde 1 voor het type op.
INumberBase<Char>.Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Parseert een reeks tekens in een waarde.
INumberBase<Char>.Parse(String, NumberStyles, IFormatProvider)	Parseert een tekenreeks in een waarde.
INumberBase<Char>.Radix	Bepaalt de radix of basis voor een type.
INumberBase<Char>.TryConvertFromChecked<TOther>(TOther, Char)	Vertegenwoordigt een teken als een UTF-16-code-eenheid.
INumberBase<Char>.TryConvertFromSaturating<TOther>(TOther, Char)	Vertegenwoordigt een teken als een UTF-16-code-eenheid.
INumberBase<Char>.TryConvertFromTruncating<TOther>(TOther, Char)	Vertegenwoordigt een teken als een UTF-16-code-eenheid.
INumberBase<Char>.TryConvertToChecked<TOther>(Char, TOther)	Probeert een exemplaar van het huidige type te converteren naar een ander type, waardoor een overloop-uitzondering wordt gegenereerd voor waarden die buiten het vertegenwoordigbare bereik van het huidige type vallen.
INumberBase<Char>.TryConvertToSaturating<TOther>(Char, TOther)	Hiermee wordt geprobeerd een exemplaar van het huidige type te converteren naar een ander type, waarbij alle waarden die buiten het vertegenwoordigbare bereik van het huidige type vallen, worden verzadigingswaarden weergegeven.
INumberBase<Char>.TryConvertToTruncating<TOther>(Char, TOther)	Hiermee wordt geprobeerd een exemplaar van het huidige type te converteren naar een ander type, waarbij alle waarden worden afgekapt die buiten het vertegenwoordigbare bereik van het huidige type vallen.
INumberBase<Char>.TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Char)	Vertegenwoordigt een teken als een UTF-16-code-eenheid.
INumberBase<Char>.TryParse(String, NumberStyles, IFormatProvider, Char)	Vertegenwoordigt een teken als een UTF-16-code-eenheid.
INumberBase<Char>.Zero	Hiermee haalt u de waarde 0 voor het type op.
IParsable<Char>.Parse(String, IFormatProvider)	Parseert een tekenreeks in een waarde.
IParsable<Char>.TryParse(String, IFormatProvider, Char)	Vertegenwoordigt een teken als een UTF-16-code-eenheid.
IShiftOperators<Char,Int32,Char>.LeftShift(Char, Int32)	Hiermee verschuift u een waarde naar links met een bepaald bedrag.
IShiftOperators<Char,Int32,Char>.RightShift(Char, Int32)	Hiermee wordt een waarde naar rechts verplaatst met een bepaald bedrag.
IShiftOperators<Char,Int32,Char>.UnsignedRightShift(Char, Int32)	Hiermee wordt een waarde naar rechts verplaatst met een bepaald bedrag.
ISpanFormattable.TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Probeert de waarde van het huidige exemplaar op te maken in de opgegeven reeks tekens.
ISpanParsable<Char>.Parse(ReadOnlySpan<Char>, IFormatProvider)	Parseert een reeks tekens in een waarde.
ISpanParsable<Char>.TryParse(ReadOnlySpan<Char>, IFormatProvider, Char)	Vertegenwoordigt een teken als een UTF-16-code-eenheid.
ISubtractionOperators<Char,Char,Char>.CheckedSubtraction(Char, Char)	Trekt twee waarden af om het verschil te berekenen.
ISubtractionOperators<Char,Char,Char>.Subtraction(Char, Char)	Trekt twee waarden af om het verschil te berekenen.
IUnaryNegationOperators<Char,Char>.CheckedUnaryNegation(Char)	Berekent de gecontroleerde unaire negatie van een waarde.
IUnaryNegationOperators<Char,Char>.UnaryNegation(Char)	Berekent de unaire negatie van een waarde.
IUnaryPlusOperators<Char,Char>.UnaryPlus(Char)	Berekent het unaire plusteken van een waarde.
IUtf8SpanFormattable.TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Probeert de waarde van het huidige exemplaar op te maken als UTF-8 in het opgegeven bereik van bytes.
IUtf8SpanParsable<Char>.Parse(ReadOnlySpan<Byte>, IFormatProvider)	Vertegenwoordigt een teken als een UTF-16-code-eenheid.
IUtf8SpanParsable<Char>.TryParse(ReadOnlySpan<Byte>, IFormatProvider, Char)	Vertegenwoordigt een teken als een UTF-16-code-eenheid.

Veiligheid thread

Alle leden van dit type zijn thread-veilig. Leden die de exemplaarstatus lijken te wijzigen, retourneren daadwerkelijk een nieuw exemplaar dat is geïnitialiseerd met de nieuwe waarde. Net als bij elk ander type moet lezen en schrijven naar een gedeelde variabele die een exemplaar van dit type bevat, worden beveiligd door een vergrendeling om de veiligheid van threads te garanderen.

Zie ook

• IComparable
• IConvertible
• String