Char Struct-datatyp

Definition

Namnområde:

System

Sammansättningar:

netstandard.dll, System.Runtime.dll

Källa:

Char.cs

Representerar ett tecken som en UTF-16-kodenhet.

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)

Arv

Object

ValueType

Char

Implementeringar

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>

Exempel

I följande kodexempel visas några av metoderna i 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

Kommentarer

Strukturen Char representerar Unicode-kodpunkter med hjälp av UTF-16-kodning. Värdet för ett Char objekt är dess 16-bitars numeriska värde (ordningstal).

Om du inte är bekant med Unicode, skalärvärden, kodpunkter, surrogatpar, UTF-16 och Rune typen läser du Introduktion till teckenkodning i .NET.

Den här artikeln undersöker relationen mellan ett Char objekt och ett tecken och diskuterar några vanliga uppgifter som utförs med Char instanser. Vi rekommenderar att du överväger den Rune-typ som introducerades i .NET Core 3.0 som ett alternativ till Char för att utföra vissa av dessa uppgifter.

Teckenobjekt, Unicode-tecken och strängar

Ett String objekt är en sekventiell samling Char strukturer som representerar en textsträng. De flesta Unicode-tecken kan representeras av ett enskilt Char objekt, men ett tecken som kodas som bastecken, surrogatpar och/eller kombination av teckensekvens representeras av flera Char objekt. Därför är en Char struktur i ett String objekt inte nödvändigtvis likvärdig med ett enda Unicode-tecken.

Flera 16-bitars kodenheter används för att representera enskilda Unicode-tecken i följande fall:

• Tecken, som kan bestå av ett enskilt tecken eller ett bastecken följt av ett eller flera kombinationstecken. Till exempel representeras ä av ett Char objekt vars kodenhet är U+0061 följt av ett Char objekt vars kodenhet är U+0308. (Tecknet ä kan också definieras av ett enskilt Char objekt som har en kodenhet på U+00E4.) I följande exempel visas att tecknet ä består av två Char objekt.

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

• Tecken utanför Unicode Basic Multilingual Plane (BMP). Unicode stöder sexton plan utöver BMP, som representerar plan 0. En Unicode-kodpunkt representeras i UTF-32 av ett 21-bitars värde som innehåller planet. Till exempel representerar U+1D160 tecknet MUSIKALISK SYMBOL ÅTTONDE NOT. Eftersom UTF-16-kodning bara har 16 bitar representeras tecken utanför BMP av surrogatpar i UTF-16. I följande exempel visas att UTF-32-motsvarigheten till U+1D160, tecknet MUSICAL SYMBOL EIGHTH NOTE, är U+D834 U+DD60. U+D834 är den högre surrogatpunkten; högre surrogater sträcker sig från U+D800 till U+DBFF. U+DD60 är ett lågt surrogat; låga surrogat sträcker sig från U+DC00 till 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
  

Tecken- och teckenkategorier

Varje Unicode-tecken eller ett giltigt surrogatpar tillhör en Unicode-kategori. I .NET representeras Unicode-kategorier av medlemmar i UnicodeCategory uppräkningen och inkluderar värden som UnicodeCategory.CurrencySymbol, UnicodeCategory.LowercaseLetteroch UnicodeCategory.SpaceSeparator, till exempel.

Om du vill fastställa Unicode-kategorin för ett tecken anropar du GetUnicodeCategory metoden. I följande exempel anropas GetUnicodeCategory till exempel för att visa Unicode-kategorin för varje tecken i en sträng. Exemplet fungerar bara korrekt om det inte finns några surrogatpar i instansen String .

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

För intern användning, när det gäller tecken utanför ASCII-intervallet för Unicode (U+0000 till U+00FF), beror metoden GetUnicodeCategory på de Unicode-kategorier som rapporteras av klassen CharUnicodeInfo. Unicode-tecken klassificeras baserat på Unicode Standard, version 8.0.0.

Tecken och textelement

Eftersom ett enskilt tecken kan representeras av flera Char objekt är det inte alltid meningsfullt att arbeta med enskilda Char objekt. I följande exempel konverteras till exempel Unicode-kodpunkterna som representerar egeiska talen noll till och med 9 till UTF-16-kodade kodenheter. Eftersom det felaktigt likställer Char objekt med tecken, rapporterar den felaktigt att den resulterande strängen har 20 tecken.

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.

Du kan göra följande för att undvika antagandet att ett Char objekt representerar ett enda tecken:

• Du kan arbeta med ett String objekt i sin helhet i stället för att arbeta med dess enskilda tecken för att representera och analysera språkligt innehåll.

• Du kan använda String.EnumerateRunes som du ser i följande exempel:

  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
  

• Du kan använda StringInfo klassen för att arbeta med textelement i stället för enskilda Char objekt. I följande exempel används objektet StringInfo för att räkna antalet textelement i en sträng som består av egeiska tal noll till nio. Eftersom det betraktar ett surrogatpar som ett enda tecken, rapporterar det korrekt att strängen innehåller tio tecken.

  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.
  

• Om en sträng innehåller ett bastecken som innehåller ett eller flera kombinationstecken kan du anropa String.Normalize metoden för att konvertera delsträngen till en enda UTF-16-kodad kodenhet. I följande exempel anropas String.Normalize metoden för att konvertera bastecknet U+0061 (LATIN SMALL LETTER A) och kombinera tecknet U+0308 (KOMBINERA DIAERESIS) till U+00E4 (LATIN SMALL LETTER A WITH 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)
  

Vanliga åtgärder

Strukturen Char innehåller metoder för att jämföra Char objekt, konvertera värdet för det aktuella Char objektet till ett objekt av en annan typ och fastställa Unicode-kategorin för ett Char objekt:

Om du vill	Använd dessa System.Char metoder
Jämför Char objekt	CompareTo och Equals
Konvertera en kodpunkt till en sträng	ConvertFromUtf32 Se även typ Rune .
Konvertera ett Char objekt eller ett surrogatpar med Char objekt till en kodpunkt	För ett enskilt tecken: Convert.ToInt32(Char) För ett surrogatpar eller ett tecken i en sträng: Char.ConvertToUtf32 Se även typ Rune .
Hämta Unicode-kategorin för ett tecken	GetUnicodeCategory Se även Rune.GetUnicodeCategory.
Avgör om ett tecken finns i en viss Unicode-kategori, till exempel siffra, bokstav, skiljetecken, kontrolltecken och så vidare	IsControl, IsDigit, IsHighSurrogate, IsLetter, IsLetterOrDigit, IsLower, IsLowSurrogate, IsNumber, IsPunctuation, IsSeparator, , IsSurrogate, IsSurrogatePair, IsSymbol, IsUpperoch IsWhiteSpace Se även motsvarande metoder för Rune typen.
Konvertera ett Char objekt som representerar ett tal till en numerisk värdetyp	GetNumericValue Se även Rune.GetNumericValue.
Konvertera ett tecken i en sträng till ett Char objekt	Parse och TryParse
Konvertera ett Char objekt till ett String objekt	ToString
Ändra ett objekts Char skiftläge	ToLower, ToLowerInvariant, ToUpperoch ToUpperInvariant Se även motsvarande metoder för Rune typen.

Teckenvärden och interoperabilitet

När en hanterad Char typ, som representeras som en Unicode UTF-16-kodad kodenhet, skickas till o-hanterad kod konverterar interop marshaller teckenuppsättningen till ANSI som standard. Du kan använda DllImportAttribute attributet för plattformsanropsdeklarationer och StructLayoutAttribute attributet för en COM-interopdeklaration för att styra vilka tecken som en konverterad Char typ använder.

Fält

Name	Description
MaxValue	Representerar det största möjliga värdet för en Char. Det här fältet är konstant.
MinValue	Representerar det minsta möjliga värdet för en Char. Det här fältet är konstant.

Metoder

Name	Description
CompareTo(Char)	Jämför den här instansen med ett angivet Char objekt och anger om den här instansen föregår, följer eller visas i samma position i sorteringsordningen som det angivna Char objektet.
CompareTo(Object)	Jämför den här instansen med ett angivet objekt och anger om den här instansen föregår, följer eller visas i samma position i sorteringsordningen som den angivna Object.
ConvertFromUtf32(Int32)	Konverterar den angivna Unicode-kodpunkten till en UTF-16-kodad sträng.
ConvertToUtf32(Char, Char)	Konverterar värdet för ett UTF-16-kodat surrogatpar till en Unicode-kodpunkt.
ConvertToUtf32(String, Int32)	Konverterar värdet för ett UTF-16-kodat tecken eller surrogatpar vid en angiven position i en sträng till en Unicode-kodpunkt.
Equals(Char)	Returnerar ett värde som anger om den här instansen är lika med det angivna Char objektet.
Equals(Object)	Returnerar ett värde som anger om den här instansen är lika med ett angivet objekt.
GetHashCode()	Returnerar hash-koden för den här instansen.
GetNumericValue(Char)	Konverterar det angivna numeriska Unicode-tecknet till ett flyttal med dubbel precision.
GetNumericValue(String, Int32)	Konverterar det numeriska Unicode-tecknet vid den angivna positionen i en angiven sträng till ett flyttal med dubbel precision.
GetTypeCode()	TypeCode Returnerar för värdetypen Char.
GetUnicodeCategory(Char)	Kategoriserar ett angivet Unicode-tecken i en grupp som identifieras av något av UnicodeCategory värdena.
GetUnicodeCategory(String, Int32)	Kategoriserar tecknet på den angivna positionen i en angiven sträng i en grupp som identifieras av något av UnicodeCategory värdena.
IsAscii(Char)	Returnerar true om c är ett ASCII-tecken ([ U+0000..U+007F ]).
IsAsciiDigit(Char)	Anger om ett tecken kategoriseras som en ASCII-siffra.
IsAsciiHexDigit(Char)	Anger om ett tecken kategoriseras som en ASCII hexadecimal siffra.
IsAsciiHexDigitLower(Char)	Anger om ett tecken kategoriseras som en ASCII-gemen hexadecimal siffra.
IsAsciiHexDigitUpper(Char)	Anger om ett tecken kategoriseras som en ASCII-versal hexadecimal siffra.
IsAsciiLetter(Char)	Anger om ett tecken kategoriseras som en ASCII-bokstav.
IsAsciiLetterLower(Char)	Anger om ett tecken kategoriseras som en gemen ASCII-bokstav.
IsAsciiLetterOrDigit(Char)	Anger om ett tecken kategoriseras som en ASCII-bokstav eller siffra.
IsAsciiLetterUpper(Char)	Anger om ett tecken kategoriseras som en ASCII-bokstav med versaler.
IsBetween(Char, Char, Char)	Anger om ett tecken ligger inom det angivna inkluderande intervallet.
IsControl(Char)	Anger om det angivna Unicode-tecknet kategoriseras som ett kontrolltecken.
IsControl(String, Int32)	Anger om tecknet på den angivna positionen i en angiven sträng kategoriseras som ett kontrolltecken.
IsDigit(Char)	Anger om det angivna Unicode-tecknet kategoriseras som en decimalsiffra.
IsDigit(String, Int32)	Anger om tecknet på den angivna positionen i en angiven sträng kategoriseras som en decimal.
IsHighSurrogate(Char)	Anger om det angivna Char objektet är en hög surrogat.
IsHighSurrogate(String, Int32)	Anger om Char objektet på den angivna positionen i en sträng är en hög surrogat.
IsLetter(Char)	Anger om det angivna Unicode-tecknet kategoriseras som en Unicode-bokstav.
IsLetter(String, Int32)	Anger om tecknet på den angivna positionen i en angiven sträng kategoriseras som en Unicode-bokstav.
IsLetterOrDigit(Char)	Anger om det angivna Unicode-tecknet kategoriseras som en bokstav eller en decimal.
IsLetterOrDigit(String, Int32)	Anger om tecknet på den angivna positionen i en angiven sträng kategoriseras som en bokstav eller en decimal.
IsLower(Char)	Anger om det angivna Unicode-tecknet kategoriseras som en gemen bokstav.
IsLower(String, Int32)	Anger om tecknet på den angivna positionen i en angiven sträng kategoriseras som en gemen bokstav.
IsLowSurrogate(Char)	Anger om det angivna Char objektet är en låg surrogat.
IsLowSurrogate(String, Int32)	Anger om objektet Char på den angivna positionen i en sträng är en låg surrogat.
IsNumber(Char)	Anger om det angivna Unicode-tecknet kategoriseras som ett tal.
IsNumber(String, Int32)	Anger om tecknet på den angivna positionen i en angiven sträng kategoriseras som ett tal.
IsPunctuation(Char)	Anger om det angivna Unicode-tecknet kategoriseras som ett skiljetecken.
IsPunctuation(String, Int32)	Anger om tecknet på den angivna positionen i en angiven sträng kategoriseras som ett skiljetecken.
IsSeparator(Char)	Anger om det angivna Unicode-tecknet kategoriseras som ett avgränsartecken.
IsSeparator(String, Int32)	Anger om tecknet på den angivna positionen i en angiven sträng kategoriseras som ett avgränsartecken.
IsSurrogate(Char)	Anger om det angivna tecknet har en surrogatkodenhet.
IsSurrogate(String, Int32)	Anger om tecknet på den angivna positionen i en angiven sträng har en surrogatkodenhet.
IsSurrogatePair(Char, Char)	Anger om de två angivna Char objekten bildar ett surrogatpar.
IsSurrogatePair(String, Int32)	Anger om två intilliggande Char objekt på en angiven position i en sträng bildar ett surrogatpar.
IsSymbol(Char)	Anger om det angivna Unicode-tecknet kategoriseras som ett symboltecken.
IsSymbol(String, Int32)	Anger om tecknet på den angivna positionen i en angiven sträng kategoriseras som ett symboltecken.
IsUpper(Char)	Anger om det angivna Unicode-tecknet kategoriseras som en versal bokstav.
IsUpper(String, Int32)	Anger om tecknet på den angivna positionen i en angiven sträng kategoriseras som en versal bokstav.
IsWhiteSpace(Char)	Anger om det angivna Unicode-tecknet kategoriseras som tomt utrymme.
IsWhiteSpace(String, Int32)	Anger om tecknet på den angivna positionen i en angiven sträng kategoriseras som tomt utrymme.
Parse(String)	Konverterar värdet för den angivna strängen till motsvarande Unicode-tecken.
ToLower(Char, CultureInfo)	Konverterar värdet för ett angivet Unicode-tecken till dess gemener med angiven kulturspecifik formateringsinformation.
ToLower(Char)	Konverterar värdet för ett Unicode-tecken till dess gemener.
ToLowerInvariant(Char)	Konverterar värdet för ett Unicode-tecken till dess gemener med hjälp av höljereglerna för den invarianta kulturen.
ToString()	Konverterar värdet för den här instansen till motsvarande strängrepresentation.
ToString(Char)	Konverterar det angivna Unicode-tecknet till motsvarande strängrepresentation.
ToString(IFormatProvider)	Konverterar värdet för den här instansen till motsvarande strängrepresentation med den angivna kulturspecifika formatinformationen.
ToUpper(Char, CultureInfo)	Konverterar värdet för ett angivet Unicode-tecken till dess versaler med angiven kulturspecifik formateringsinformation.
ToUpper(Char)	Konverterar värdet för ett Unicode-tecken till dess versaler.
ToUpperInvariant(Char)	Konverterar värdet för ett Unicode-tecken till dess versaler med hjälp av höljereglerna i den invarianta kulturen.
TryParse(String, Char)	Konverterar värdet för den angivna strängen till motsvarande Unicode-tecken. En returkod anger om konverteringen lyckades eller misslyckades.

Explicita gränssnittsimplementeringar

Name	Description
IAdditionOperators<Char,Char,Char>.Addition(Char, Char)	Lägger till två värden tillsammans för att beräkna summan.
IAdditionOperators<Char,Char,Char>.CheckedAddition(Char, Char)	Lägger till två värden tillsammans för att beräkna summan.
IAdditiveIdentity<Char,Char>.AdditiveIdentity	Hämtar den aktuella typens additiva identitet.
IBinaryInteger<Char>.GetByteCount()	Hämtar antalet byte som ska skrivas som en del av TryWriteLittleEndian(Span<Byte>, Int32).
IBinaryInteger<Char>.GetShortestBitLength()	Hämtar längden, i bitar, på de kortaste tvås komplementrepresentation av det aktuella värdet.
IBinaryInteger<Char>.LeadingZeroCount(Char)	Beräknar antalet inledande noll bitar i ett värde.
IBinaryInteger<Char>.PopCount(Char)	Beräknar antalet bitar som anges i ett värde.
IBinaryInteger<Char>.RotateLeft(Char, Int32)	Roterar ett värde som lämnas av ett angivet belopp.
IBinaryInteger<Char>.RotateRight(Char, Int32)	Roterar ett värde höger med ett angivet belopp.
IBinaryInteger<Char>.TrailingZeroCount(Char)	Beräknar antalet avslutande noll bitar i ett värde.
IBinaryInteger<Char>.TryReadBigEndian(ReadOnlySpan<Byte>, Boolean, Char)	Representerar ett tecken som en UTF-16-kodenhet.
IBinaryInteger<Char>.TryReadLittleEndian(ReadOnlySpan<Byte>, Boolean, Char)	Representerar ett tecken som en UTF-16-kodenhet.
IBinaryInteger<Char>.TryWriteBigEndian(Span<Byte>, Int32)	Försöker skriva det aktuella värdet, i stor endianskt format, till ett givet intervall.
IBinaryInteger<Char>.TryWriteLittleEndian(Span<Byte>, Int32)	Försöker skriva det aktuella värdet, i lite endianskt format, till ett givet intervall.
IBinaryNumber<Char>.AllBitsSet	Hämtar en instans av den binära typen där alla bitar anges.
IBinaryNumber<Char>.IsPow2(Char)	Avgör om ett värde är en kraft på två.
IBinaryNumber<Char>.Log2(Char)	Beräknar log2 för ett värde.
IBitwiseOperators<Char,Char,Char>.BitwiseAnd(Char, Char)	Beräknar bitvis och av två värden.
IBitwiseOperators<Char,Char,Char>.BitwiseOr(Char, Char)	Beräknar bitvis eller två värden.
IBitwiseOperators<Char,Char,Char>.ExclusiveOr(Char, Char)	Beräknar uteslutande eller av två värden.
IBitwiseOperators<Char,Char,Char>.OnesComplement(Char)	Beräknar enkomplementrepresentationen av ett visst värde.
IComparisonOperators<Char,Char,Boolean>.GreaterThan(Char, Char)	Jämför två värden för att avgöra vilket som är större.
IComparisonOperators<Char,Char,Boolean>.GreaterThanOrEqual(Char, Char)	Jämför två värden för att avgöra vilket som är större eller lika med.
IComparisonOperators<Char,Char,Boolean>.LessThan(Char, Char)	Jämför två värden för att avgöra vilket som är mindre.
IComparisonOperators<Char,Char,Boolean>.LessThanOrEqual(Char, Char)	Jämför två värden för att avgöra vilket som är mindre eller lika med.
IConvertible.ToBoolean(IFormatProvider)	Observera Den här konverteringen stöds inte. Om du försöker göra det utlöser en InvalidCastException.
IConvertible.ToByte(IFormatProvider)	En beskrivning av den här medlemmen finns i ToByte(IFormatProvider).
IConvertible.ToChar(IFormatProvider)	En beskrivning av den här medlemmen finns i ToChar(IFormatProvider).
IConvertible.ToDateTime(IFormatProvider)	Observera Den här konverteringen stöds inte. Om du försöker göra det utlöser en InvalidCastException.
IConvertible.ToDecimal(IFormatProvider)	Observera Den här konverteringen stöds inte. Om du försöker göra det utlöser en InvalidCastException.
IConvertible.ToDouble(IFormatProvider)	Observera Den här konverteringen stöds inte. Om du försöker göra det utlöser en InvalidCastException.
IConvertible.ToInt16(IFormatProvider)	En beskrivning av den här medlemmen finns i ToInt16(IFormatProvider).
IConvertible.ToInt32(IFormatProvider)	En beskrivning av den här medlemmen finns i ToInt32(IFormatProvider).
IConvertible.ToInt64(IFormatProvider)	En beskrivning av den här medlemmen finns i ToInt64(IFormatProvider).
IConvertible.ToSByte(IFormatProvider)	En beskrivning av den här medlemmen finns i ToSByte(IFormatProvider).
IConvertible.ToSingle(IFormatProvider)	Observera Den här konverteringen stöds inte. Om du försöker göra det utlöser en InvalidCastException.
IConvertible.ToType(Type, IFormatProvider)	En beskrivning av den här medlemmen finns i ToType(Type, IFormatProvider).
IConvertible.ToUInt16(IFormatProvider)	En beskrivning av den här medlemmen finns i ToUInt16(IFormatProvider).
IConvertible.ToUInt32(IFormatProvider)	En beskrivning av den här medlemmen finns i ToUInt32(IFormatProvider).
IConvertible.ToUInt64(IFormatProvider)	En beskrivning av den här medlemmen finns i ToUInt64(IFormatProvider).
IDecrementOperators<Char>.CheckedDecrement(Char)	Minskar ett värde.
IDecrementOperators<Char>.Decrement(Char)	Minskar ett värde.
IDivisionOperators<Char,Char,Char>.Division(Char, Char)	Delar upp ett värde med ett annat för att beräkna deras kvot.
IEqualityOperators<Char,Char,Boolean>.Equality(Char, Char)	Jämför två värden för att fastställa likhet.
IEqualityOperators<Char,Char,Boolean>.Inequality(Char, Char)	Jämför två värden för att fastställa ojämlikhet.
IFormattable.ToString(String, IFormatProvider)	Formaterar värdet för den aktuella instansen med det angivna formatet.
IIncrementOperators<Char>.CheckedIncrement(Char)	Ökar ett värde.
IIncrementOperators<Char>.Increment(Char)	Ökar ett värde.
IMinMaxValue<Char>.MaxValue	Hämtar det maximala värdet för den aktuella typen.
IMinMaxValue<Char>.MinValue	Hämtar det lägsta värdet för den aktuella typen.
IModulusOperators<Char,Char,Char>.Modulus(Char, Char)	Delar upp två värden för att beräkna deras modulus eller rest.
IMultiplicativeIdentity<Char,Char>.MultiplicativeIdentity	Hämtar den multiplicativa identiteten för den aktuella typen.
IMultiplyOperators<Char,Char,Char>.CheckedMultiply(Char, Char)	Multiplicerar två värden tillsammans för att beräkna produkten.
IMultiplyOperators<Char,Char,Char>.Multiply(Char, Char)	Multiplicerar två värden tillsammans för att beräkna produkten.
INumberBase<Char>.Abs(Char)	Beräknar det absoluta värdet.
INumberBase<Char>.IsCanonical(Char)	Avgör om ett värde finns i dess kanoniska representation.
INumberBase<Char>.IsComplexNumber(Char)	Avgör om ett värde representerar ett komplext tal.
INumberBase<Char>.IsEvenInteger(Char)	Avgör om ett värde representerar ett jämnt heltal.
INumberBase<Char>.IsFinite(Char)	Avgör om ett värde är begränsat.
INumberBase<Char>.IsImaginaryNumber(Char)	Avgör om ett värde representerar ett rent imaginärt tal.
INumberBase<Char>.IsInfinity(Char)	Avgör om ett värde är oändligt.
INumberBase<Char>.IsInteger(Char)	Avgör om ett värde representerar ett heltal.
INumberBase<Char>.IsNaN(Char)	Avgör om ett värde är NaN.
INumberBase<Char>.IsNegative(Char)	Avgör om ett värde är negativt.
INumberBase<Char>.IsNegativeInfinity(Char)	Avgör om ett värde är negativ oändlighet.
INumberBase<Char>.IsNormal(Char)	Avgör om ett värde är normalt.
INumberBase<Char>.IsOddInteger(Char)	Avgör om ett värde representerar ett udda integraltal.
INumberBase<Char>.IsPositive(Char)	Avgör om ett värde är positivt.
INumberBase<Char>.IsPositiveInfinity(Char)	Avgör om ett värde är positiv oändlighet.
INumberBase<Char>.IsRealNumber(Char)	Avgör om ett värde representerar ett verkligt tal.
INumberBase<Char>.IsSubnormal(Char)	Avgör om ett värde är subnormalt.
INumberBase<Char>.IsZero(Char)	Avgör om ett värde är noll.
INumberBase<Char>.MaxMagnitude(Char, Char)	Jämför två värden med beräkning som är större.
INumberBase<Char>.MaxMagnitudeNumber(Char, Char)	Jämför två värden med beräkning som har större storlek och returnerar det andra värdet om en indata är NaN.
INumberBase<Char>.MinMagnitude(Char, Char)	Jämför två värden med beräkning som är mindre.
INumberBase<Char>.MinMagnitudeNumber(Char, Char)	Jämför två värden med beräkning som har mindre storlek och returnerar det andra värdet om en indata är NaN.
INumberBase<Char>.MultiplyAddEstimate(Char, Char, Char)	Beräknar en uppskattning av (left * right) + addend.
INumberBase<Char>.One	Hämtar värdet 1 för typen.
INumberBase<Char>.Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Parsar ett teckenintervall till ett värde.
INumberBase<Char>.Parse(String, NumberStyles, IFormatProvider)	Parsar en sträng till ett värde.
INumberBase<Char>.Radix	Hämtar radixet, eller basen, för typen.
INumberBase<Char>.TryConvertFromChecked<TOther>(TOther, Char)	Representerar ett tecken som en UTF-16-kodenhet.
INumberBase<Char>.TryConvertFromSaturating<TOther>(TOther, Char)	Representerar ett tecken som en UTF-16-kodenhet.
INumberBase<Char>.TryConvertFromTruncating<TOther>(TOther, Char)	Representerar ett tecken som en UTF-16-kodenhet.
INumberBase<Char>.TryConvertToChecked<TOther>(Char, TOther)	Försöker konvertera en instans av den aktuella typen till en annan typ, vilket utlöser ett spill-undantag för värden som ligger utanför det representerarbara intervallet för den aktuella typen.
INumberBase<Char>.TryConvertToSaturating<TOther>(Char, TOther)	Försöker konvertera en instans av den aktuella typen till en annan typ, vilket mättar alla värden som ligger utanför det representerarbara intervallet för den aktuella typen.
INumberBase<Char>.TryConvertToTruncating<TOther>(Char, TOther)	Försöker konvertera en instans av den aktuella typen till en annan typ och trunkerar alla värden som ligger utanför det representerarbara intervallet för den aktuella typen.
INumberBase<Char>.TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Char)	Representerar ett tecken som en UTF-16-kodenhet.
INumberBase<Char>.TryParse(String, NumberStyles, IFormatProvider, Char)	Representerar ett tecken som en UTF-16-kodenhet.
INumberBase<Char>.Zero	Hämtar värdet 0 för typen.
IParsable<Char>.Parse(String, IFormatProvider)	Parsar en sträng till ett värde.
IParsable<Char>.TryParse(String, IFormatProvider, Char)	Representerar ett tecken som en UTF-16-kodenhet.
IShiftOperators<Char,Int32,Char>.LeftShift(Char, Int32)	Flyttar ett värde som lämnas av ett visst belopp.
IShiftOperators<Char,Int32,Char>.RightShift(Char, Int32)	Flyttar ett värde efter ett visst belopp.
IShiftOperators<Char,Int32,Char>.UnsignedRightShift(Char, Int32)	Flyttar ett värde efter ett visst belopp.
ISpanFormattable.TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Försöker formatera värdet för den aktuella instansen till det angivna intervallet med tecken.
ISpanParsable<Char>.Parse(ReadOnlySpan<Char>, IFormatProvider)	Parsar ett teckenintervall till ett värde.
ISpanParsable<Char>.TryParse(ReadOnlySpan<Char>, IFormatProvider, Char)	Representerar ett tecken som en UTF-16-kodenhet.
ISubtractionOperators<Char,Char,Char>.CheckedSubtraction(Char, Char)	Subtraherar två värden för att beräkna skillnaden.
ISubtractionOperators<Char,Char,Char>.Subtraction(Char, Char)	Subtraherar två värden för att beräkna skillnaden.
IUnaryNegationOperators<Char,Char>.CheckedUnaryNegation(Char)	Beräknar den kontrollerade obevakade negationen av ett värde.
IUnaryNegationOperators<Char,Char>.UnaryNegation(Char)	Beräknar en oharisk negation av ett värde.
IUnaryPlusOperators<Char,Char>.UnaryPlus(Char)	Beräknar det unary plus av ett värde.
IUtf8SpanFormattable.TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Försöker formatera värdet för den aktuella instansen som UTF-8 i det angivna byteintervallet.
IUtf8SpanParsable<Char>.Parse(ReadOnlySpan<Byte>, IFormatProvider)	Representerar ett tecken som en UTF-16-kodenhet.
IUtf8SpanParsable<Char>.TryParse(ReadOnlySpan<Byte>, IFormatProvider, Char)	Representerar ett tecken som en UTF-16-kodenhet.

Trådsäkerhet

Alla medlemmar av den här typen är trådsäkra. Medlemmar som verkar ändra instanstillstånd returnerar faktiskt en ny instans som initierats med det nya värdet. Precis som med andra typer måste läsning och skrivning till en delad variabel som innehåller en instans av den här typen skyddas av ett lås för att garantera trådsäkerheten.

Se även

• IComparable
• IConvertible
• String