Char Struktúra

Definíció

Névtér:

System

Szerelvények:

netstandard.dll, System.Runtime.dll

Forrás:

Char.cs

Egy karaktert UTF-16 kódegységként jelöl.

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)

Öröklődés

Object

ValueType

Char

Példák

Az alábbi példakód néhány metódust mutat be a következőben 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

Megjegyzések

A Char struktúra Unicode-kódpontokat jelöl UTF-16 kódolással. Egy objektum értéke Char a 16 bites numerikus (ordinális) értéke.

Ha nem ismeri a Unicode-ot, a skaláris értékeket, a kódpontokat, a helyettesítő párokat, az UTF-16-ot és a típust, olvassa el a Rune.NET-ben használt karakterkódolás bemutatása című témakört.

Ez a cikk egy objektum és egy karakter közötti Char kapcsolatot vizsgálja, és a példányokkal Char végzett gyakori feladatokat ismerteti. Javasoljuk, hogy fontolja meg a Rune típust Char alternatívaként ezen feladatok némelyikének elvégzésére.

Karakterobjektumok, Unicode-karakterek és sztringek

Az String objektumok olyan struktúrák szekvenciális gyűjteményei Char , amelyek egy szöveges sztringet jelölnek. A Unicode-karakterek többségét egyetlen Char objektum jelölheti, de az alapkarakterek, a helyettesítő párok és/vagy a karaktersorozatok egyesítését több Char objektum jelöli. Ezért egy CharString objektum struktúrája nem feltétlenül egyenértékű egyetlen Unicode-karakterrel.

A rendszer több 16 bites kódegységet használ egyetlen Unicode-karakter megjelenítésére a következő esetekben:

• Karakterjelek, amelyek egyetlen karakterből vagy alap karakterből állhatnak, amelyet egy vagy több egyesítő karakter követ. Az ä karaktert például egy Char olyan objektum jelöli, amelynek kódegysége U+0061, majd egy Char olyan objektum, amelynek kódegysége U+0308. (Az ä karaktert egyetlen Char objektum is definiálhatja, amely az U+00E4 kódegységével rendelkezik.) Az alábbi példa azt szemlélteti, hogy az ä karakter két Char objektumból áll.

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

• A Unicode basic többnyelvű síkon (BMP) kívül eső karakterek. A Unicode a BMP mellett tizenhat síkot is támogat, amely a 0 síkot jelöli. A Unicode-kódpontokat az UTF-32-ben egy 21 bites érték jelöli, amely tartalmazza a síkot. Az U+1D160 például a ZENEI SZIMBÓLUM NYOLCADIK JEGYZET karakterét jelöli. Mivel az UTF-16 kódolás csak 16 bittel rendelkezik, a BMP-n kívüli karaktereket helyettesítő párok képviselik az UTF-16-ban. Az alábbi példa azt szemlélteti, hogy az U+1D160 UTF-32 megfelelője, a MUSICAL SYMBOL NYOLCADIK JEGYZET karaktere U+D834 U+DD60. U+D834 a felső helyettesítő; a felső helyettesítők tartománya U+D800 és U+DBFF között van. U+DD60 az alacsony helyettesítő; az alacsony helyettesítők tartománya U+DC00 és U+DFFF között van.

  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
  

Karakterek és karakterkategóriák

Minden Unicode-karakter vagy érvényes helyettesítő pár Unicode-kategóriához tartozik. A .NET-ben a Unicode-kategóriákat az UnicodeCategory enumerálás tagjai jelölik, és olyan értékeket tartalmaznak, mint UnicodeCategory.CurrencySymbolpéldául a , UnicodeCategory.LowercaseLetterés UnicodeCategory.SpaceSeparatorpéldául.

Egy karakter Unicode-kategóriájának meghatározásához hívja meg a metódust GetUnicodeCategory . Az alábbi példa például meghívja az GetUnicodeCategory egyes karakterek Unicode-kategóriájának megjelenítésére egy sztringben. A példa csak akkor működik megfelelően, ha a példányban String nincsenek szurrogát párok.

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

Az ASCII tartományon túli karakterek esetén (U+0080–U+00FF) a GetUnicodeCategory metódus a CharUnicodeInfo osztály által meghatározott Unicode-kategóriáktól függ. A Unicode-karakterek besorolása a Unicode Standard 8.0.0-s verziója alapján van besorolva.

Karakterek és szövegelemek

Mivel egyetlen karakter több Char objektummal is ábrázolható, nem mindig hasznos az egyes Char objektumok használata. Az alábbi példa például UTF-16 kódolású kódegységekké alakítja a nulla és 9 között az égei számokat képviselő Unicode-kódpontokat. Mivel tévesen egyezteti az Char objektumokat a karakterekkel, pontatlanul jelenti, hogy az eredményül kapott sztring 20 karakterből áll.

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.

Az alábbiakat követve elkerülheti azt a feltételezést, hogy egy Char objektum egyetlen karaktert jelöl:

• Az String objektumot teljes egészében használhatja ahelyett, hogy az egyes karakterekkel dolgozna a nyelvi tartalom ábrázolása és elemzése céljából.

• A következő példában látható módon használható String.EnumerateRunes :

  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
  

• Az osztály használatával az StringInfo egyes Char objektumok helyett szövegelemekkel dolgozhat. Az alábbi példa az objektumot használja a StringInfo szöveges elemek számának megszámlálására egy sztringben, amely az Égei-számok nullától kilencig való számából áll. Mivel egy helyettesítő párt egyetlen karakternek tekint, helyesen jelenti, hogy a karakterlánc tíz karaktert tartalmaz.

  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.
  

• Ha egy sztring egy vagy több egyesítési karaktert tartalmazó alapkaraktert tartalmaz, meghívhatja a String.Normalize metódust, hogy az alsztringet egyetlen UTF-16 kódolt kódegységre konvertálja. Az alábbi példa az String.Normalize metódust hívja meg, hogy az alapkarakter U+0061 (LATIN KISBETŰ A) és a kombináló karakter U+0308 (KETTŐSPONT) együttesen U+00E4 (LATIN KISBETŰ A KETTŐSPONTTAL) karakterré alakuljon át.

  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)
  

Gyakori műveletek

A Char struktúra metódusokat biztosít az objektumok összehasonlításához Char , az aktuális Char objektum értékének egy másik típusú objektummá alakításához, valamint egy objektum Unicode-kategóriájának meghatározásához Char :

Ehhez	Használja ezeket a System.Char módszereket
Objektumok összehasonlítása Char	CompareTo és Equals
Kódpont átalakítása sztringgé	ConvertFromUtf32 Lásd még a típust Rune .
Char Objektum vagy helyettesítő objektumpár Char átalakítása kódponttá	Egyetlen karakter esetén: Convert.ToInt32(Char) Helyettesítő pár vagy sztringben szereplő karakter esetén: Char.ConvertToUtf32 Lásd még a típust Rune .
Karakter Unicode-kategóriájának lekérése	GetUnicodeCategory Lásd még: Rune.GetUnicodeCategory.
Annak meghatározása, hogy egy karakter egy adott Unicode-kategóriába tartozik-e, például számjegy, betű, írásjel, vezérlő karakter stb.	IsControl, IsDigit, IsHighSurrogate, IsLetter, IsLetterOrDigit, IsLower, IsLowSurrogate, IsNumber, IsPunctuation, IsSeparator, IsSurrogate, IsSurrogatePair, IsSymbol, IsUpper és IsWhiteSpace Lásd még a Rune típus megfelelő metódusait.
Char Számokat ábrázoló objektum átalakítása numerikus értéktípussá	GetNumericValue Lásd még: Rune.GetNumericValue.
Sztring karakterének átalakítása objektummá Char	Parse és TryParse
Char Objektum átalakítása objektummá String	ToString
Egy Char objektum betűméretét módosítsa	ToLower, ToLowerInvariant, ToUpperés ToUpperInvariant Lásd még a Rune típus megfelelő metódusait.

Karakterértékek és interoperabilitás

Ha egy unicode UTF-16 kódolt kódegységként ábrázolt felügyelt Char típust nem felügyelt kódnak ad át, az interop-marshaller alapértelmezés szerint ANSI-vé alakítja a karakterkészletet. Az attribútumot a DllImportAttribute platformhívási deklarációkra, az StructLayoutAttribute attribútumot pedig egy COM-interop deklarációra alkalmazhatja annak szabályozására, hogy melyik karaktert használja a rögzített Char típus.

Mezők

Név	Description
MaxValue	A lehetséges legnagyobb értéket Charjelöli. Ez a mező állandó.
MinValue	A lehető legkisebb értéket jelöli.Char Ez a mező állandó.

Metódusok

Név	Description
CompareTo(Char)	Összehasonlítja ezt a példányt egy adott Char objektummal, és jelzi, hogy ez a példány megelőzi, követi vagy ugyanabban a sorrendben jelenik meg, mint a megadott Char objektum.
CompareTo(Object)	Összehasonlítja ezt a példányt egy megadott objektummal, és jelzi, hogy ez a példány megelőzi, követi vagy ugyanabban a sorrendben jelenik meg, mint a megadott Object.
ConvertFromUtf32(Int32)	A megadott Unicode-kódpontot UTF-16 kódolású sztringgé alakítja.
ConvertToUtf32(Char, Char)	Az UTF-16 kódolt helyettesítő pár értékét Unicode kódponttá alakítja.
ConvertToUtf32(String, Int32)	Egy UTF-16 kódolt karakter vagy helyettesítő pár értékét egy sztring megadott helyén Unicode kódponttá alakítja.
Equals(Char)	Olyan értéket ad vissza, amely jelzi, hogy ez a példány egyenlő-e a megadott Char objektummal.
Equals(Object)	Olyan értéket ad vissza, amely jelzi, hogy ez a példány egyenlő-e egy adott objektummal.
GetHashCode()	A példány kivonatkódját adja vissza.
GetNumericValue(Char)	A megadott numerikus Unicode-karaktert dupla pontosságú lebegőpontos számmá alakítja.
GetNumericValue(String, Int32)	A megadott sztringben megadott pozícióban lévő numerikus Unicode-karaktert dupla pontosságú lebegőpontos számmá alakítja.
GetTypeCode()	TypeCode Az értéktípus Charértékét adja vissza.
GetUnicodeCategory(Char)	Kategorizál egy megadott Unicode-karaktert egy olyan csoportba, amelyet az UnicodeCategory egyik érték azonosít.
GetUnicodeCategory(String, Int32)	Kategorizálja a karaktert egy adott sztring megadott helyén egy olyan csoportba, amelyet az UnicodeCategory egyik érték azonosít.
IsAscii(Char)	ASCII-karaktert ([ U+0000..U+007F ]) ad truec vissza.
IsAsciiDigit(Char)	Azt jelzi, hogy egy karakter ASCII-számjegyként van-e kategorizálva.
IsAsciiHexDigit(Char)	Azt jelzi, hogy egy karakter ASCII hexadecimális számjegyként van-e kategorizálva.
IsAsciiHexDigitLower(Char)	Azt jelzi, hogy egy karakter ASCII kisbetűs hexadecimális számjegyként van-e kategorizálva.
IsAsciiHexDigitUpper(Char)	Azt jelzi, hogy egy karakter ASCII nagybetűs hexadecimális számjegyként van-e kategorizálva.
IsAsciiLetter(Char)	Azt jelzi, hogy egy karakter ASCII-betűként van-e kategorizálva.
IsAsciiLetterLower(Char)	Azt jelzi, hogy egy karakter kisbetűs ASCII-betűként van-e kategorizálva.
IsAsciiLetterOrDigit(Char)	Azt jelzi, hogy egy karakter ASCII betűként vagy számjegyként van-e kategorizálva.
IsAsciiLetterUpper(Char)	Azt jelzi, hogy egy karakter nagybetűs ASCII-betűként van-e kategorizálva.
IsBetween(Char, Char, Char)	Azt jelzi, hogy egy karakter a megadott befogadó tartományon belül van-e.
IsControl(Char)	Azt jelzi, hogy a megadott Unicode-karakter vezérlőelem-karakterként van-e kategorizálva.
IsControl(String, Int32)	Azt jelzi, hogy egy adott sztring adott pozíciójában lévő karakter vezérlőelem-karakterként van-e kategorizálva.
IsDigit(Char)	Azt jelzi, hogy a megadott Unicode-karakter tizedesjegyként van-e kategorizálva.
IsDigit(String, Int32)	Azt jelzi, hogy a megadott sztring adott helyén lévő karakter tizedesjegyként van-e kategorizálva.
IsHighSurrogate(Char)	Azt jelzi, hogy a megadott Char objektum magas helyettesítő-e.
IsHighSurrogate(String, Int32)	Azt jelzi, hogy a Char sztringben megadott pozícióban lévő objektum magas helyettesítő-e.
IsLetter(Char)	Azt jelzi, hogy a megadott Unicode-karakter Unicode-betűként van-e kategorizálva.
IsLetter(String, Int32)	Azt jelzi, hogy a megadott sztring adott pozíciójában lévő karakter Unicode-betűként van-e kategorizálva.
IsLetterOrDigit(Char)	Azt jelzi, hogy a megadott Unicode-karakter betűként vagy tizedesjegyként van-e kategorizálva.
IsLetterOrDigit(String, Int32)	Azt jelzi, hogy egy adott sztring adott pozíciójában lévő karakter betűként vagy tizedesjegyként van-e kategorizálva.
IsLower(Char)	Azt jelzi, hogy a megadott Unicode-karakter kisbetűként van-e kategorizálva.
IsLower(String, Int32)	Azt jelzi, hogy a megadott sztring adott helyén lévő karakter kisbetűként van-e kategorizálva.
IsLowSurrogate(Char)	Azt jelzi, hogy a megadott Char objektum alacsony helyettesítő-e.
IsLowSurrogate(String, Int32)	Azt jelzi, hogy a Char sztringben megadott pozícióban lévő objektum alacsony helyettesítő-e.
IsNumber(Char)	Azt jelzi, hogy a megadott Unicode-karakter számként van-e kategorizálva.
IsNumber(String, Int32)	Azt jelzi, hogy egy adott sztring adott pozíciójában lévő karakter számként van-e kategorizálva.
IsPunctuation(Char)	Azt jelzi, hogy a megadott Unicode-karakter írásjelként van-e kategorizálva.
IsPunctuation(String, Int32)	Azt jelzi, hogy a megadott sztring adott helyén lévő karakter írásjelként van-e kategorizálva.
IsSeparator(Char)	Azt jelzi, hogy a megadott Unicode-karakter elválasztó karakterként van-e kategorizálva.
IsSeparator(String, Int32)	Azt jelzi, hogy egy adott sztring adott helyén lévő karakter elválasztó karakterként van-e kategorizálva.
IsSurrogate(Char)	Azt jelzi, hogy a megadott karakter rendelkezik-e helyettesítő kódegységtel.
IsSurrogate(String, Int32)	Azt jelzi, hogy a megadott sztring adott helyén lévő karakter rendelkezik-e helyettesítő kódegységtel.
IsSurrogatePair(Char, Char)	Azt jelzi, hogy a két megadott Char objektum helyettesítő párt alkot-e.
IsSurrogatePair(String, Int32)	Azt jelzi, hogy egy sztring adott helyén két szomszédos Char objektum alkot-e helyettesítő párt.
IsSymbol(Char)	Azt jelzi, hogy a megadott Unicode-karakter szimbólum karakterként van-e kategorizálva.
IsSymbol(String, Int32)	Azt jelzi, hogy a megadott sztring adott helyén lévő karakter szimbólumkaraktere-e.
IsUpper(Char)	Azt jelzi, hogy a megadott Unicode-karakter nagybetűként van-e kategorizálva.
IsUpper(String, Int32)	Azt jelzi, hogy a megadott sztring adott helyén lévő karakter nagybetűként van-e kategorizálva.
IsWhiteSpace(Char)	Azt jelzi, hogy a megadott Unicode-karakter üres területként van-e kategorizálva.
IsWhiteSpace(String, Int32)	Azt jelzi, hogy a megadott sztring adott helyén lévő karakter üres területként van-e kategorizálva.
Parse(String)	A megadott sztring értékét a megfelelő Unicode-karakterre konvertálja.
ToLower(Char, CultureInfo)	Egy megadott Unicode-karakter értékét a megadott kultúraspecifikus formázási információk használatával kisbetűs megfelelővé alakítja.
ToLower(Char)	Egy Unicode-karakter értékét kisbetűs megfelelővé alakítja.
ToLowerInvariant(Char)	Egy Unicode-karakter értékét kisbetűs megfelelőjé alakítja az invariáns kultúra casing szabályaival.
ToString()	A példány értékét a megfelelő sztring-ábrázolásúvá alakítja.
ToString(Char)	A megadott Unicode-karaktert a megfelelő karakterlánc-ábrázolásúvá alakítja.
ToString(IFormatProvider)	Ennek a példánynak az értékét a megadott kultúraspecifikus formátumadatok használatával konvertálja a megfelelő sztringre.
ToUpper(Char, CultureInfo)	Egy megadott Unicode-karakter értékét a megadott kultúraspecifikus formázási információk használatával a nagybetűs megfelelőjeké alakítja.
ToUpper(Char)	Egy Unicode-karakter értékét a nagybetűs megfelelőjeké alakítja.
ToUpperInvariant(Char)	Egy Unicode-karakter értékét a nagybetűs megfelelőjé alakítja az invariáns kultúra casing szabályaival.
TryParse(String, Char)	A megadott sztring értékét a megfelelő Unicode-karakterre konvertálja. A visszatérési kód azt jelzi, hogy az átalakítás sikeres vagy sikertelen volt-e.

Explicit interfész-implementációk

Név	Description
IAdditionOperators<Char,Char,Char>.Addition(Char, Char)	Két értéket ad hozzá az összeg kiszámításához.
IAdditionOperators<Char,Char,Char>.CheckedAddition(Char, Char)	Két értéket ad hozzá az összeg kiszámításához.
IAdditiveIdentity<Char,Char>.AdditiveIdentity	Lekéri az aktuális típus additív identitását.
IBinaryInteger<Char>.GetByteCount()	Beolvasja a program által a program részeként megírt bájtok TryWriteLittleEndian(Span<Byte>, Int32)számát.
IBinaryInteger<Char>.GetShortestBitLength()	Bitben lekéri az aktuális érték legrövidebb, egymást kiegészítő ábrázolásának hosszát.
IBinaryInteger<Char>.LeadingZeroCount(Char)	Kiszámítja a kezdő nulla bitek számát egy értékben.
IBinaryInteger<Char>.PopCount(Char)	Kiszámítja az értékben beállított bitek számát.
IBinaryInteger<Char>.RotateLeft(Char, Int32)	Egy adott összeggel balra hagyott érték elforgatása.
IBinaryInteger<Char>.RotateRight(Char, Int32)	Egy érték elforgatása egy adott összeggel jobbra.
IBinaryInteger<Char>.TrailingZeroCount(Char)	Kiszámítja a záró nulla bitek számát egy értékben.
IBinaryInteger<Char>.TryReadBigEndian(ReadOnlySpan<Byte>, Boolean, Char)	Egy karaktert UTF-16 kódegységként jelöl.
IBinaryInteger<Char>.TryReadLittleEndian(ReadOnlySpan<Byte>, Boolean, Char)	Egy karaktert UTF-16 kódegységként jelöl.
IBinaryInteger<Char>.TryWriteBigEndian(Span<Byte>, Int32)	Megpróbálja az aktuális értéket big-endian formátumban megírni egy adott időtartamra.
IBinaryInteger<Char>.TryWriteLittleEndian(Span<Byte>, Int32)	Az aktuális értéket kis endian formátumban próbálja meg írni egy adott időtartamra.
IBinaryNumber<Char>.AllBitsSet	Lekéri annak a bináris típusnak a példányát, amelyben az összes bit be van állítva.
IBinaryNumber<Char>.IsPow2(Char)	Meghatározza, hogy egy érték kettőből áll-e.
IBinaryNumber<Char>.Log2(Char)	Kiszámítja egy érték napló2-ét.
IBitwiseOperators<Char,Char,Char>.BitwiseAnd(Char, Char)	Kiszámítja a bitenkénti és két értéket.
IBitwiseOperators<Char,Char,Char>.BitwiseOr(Char, Char)	Kiszámítja a bitenkénti vagy két értéket.
IBitwiseOperators<Char,Char,Char>.ExclusiveOr(Char, Char)	Kiszámítja a kizárólagos vagy két értéket.
IBitwiseOperators<Char,Char,Char>.OnesComplement(Char)	Kiszámítja egy adott érték egyedkiegészítő ábrázolását.
IComparisonOperators<Char,Char,Boolean>.GreaterThan(Char, Char)	Két értéket hasonlít össze annak meghatározásához, hogy melyik a nagyobb.
IComparisonOperators<Char,Char,Boolean>.GreaterThanOrEqual(Char, Char)	Két értéket hasonlít össze annak meghatározásához, hogy melyik a nagyobb vagy egyenlő.
IComparisonOperators<Char,Char,Boolean>.LessThan(Char, Char)	Két értéket hasonlít össze annak meghatározásához, hogy melyik a kisebb.
IComparisonOperators<Char,Char,Boolean>.LessThanOrEqual(Char, Char)	Két értéket hasonlít össze annak meghatározásához, hogy melyik kisebb vagy egyenlő.
IConvertible.ToBoolean(IFormatProvider)	Megjegyzés Ez az átalakítás nem támogatott. Ennek megkísérlése kivált egy InvalidCastException.
IConvertible.ToByte(IFormatProvider)	Ennek a tagnak a leírását lásd ToByte(IFormatProvider): .
IConvertible.ToChar(IFormatProvider)	Ennek a tagnak a leírását lásd ToChar(IFormatProvider): .
IConvertible.ToDateTime(IFormatProvider)	Megjegyzés Ez az átalakítás nem támogatott. Ennek megkísérlése kivált egy InvalidCastException.
IConvertible.ToDecimal(IFormatProvider)	Megjegyzés Ez az átalakítás nem támogatott. Ennek megkísérlése kivált egy InvalidCastException.
IConvertible.ToDouble(IFormatProvider)	Megjegyzés Ez az átalakítás nem támogatott. Ennek megkísérlése kivált egy InvalidCastException.
IConvertible.ToInt16(IFormatProvider)	Ennek a tagnak a leírását lásd ToInt16(IFormatProvider): .
IConvertible.ToInt32(IFormatProvider)	Ennek a tagnak a leírását lásd ToInt32(IFormatProvider): .
IConvertible.ToInt64(IFormatProvider)	Ennek a tagnak a leírását lásd ToInt64(IFormatProvider): .
IConvertible.ToSByte(IFormatProvider)	Ennek a tagnak a leírását lásd ToSByte(IFormatProvider): .
IConvertible.ToSingle(IFormatProvider)	Megjegyzés Ez az átalakítás nem támogatott. Ennek megkísérlése kivált egy InvalidCastException.
IConvertible.ToType(Type, IFormatProvider)	Ennek a tagnak a leírását lásd ToType(Type, IFormatProvider): .
IConvertible.ToUInt16(IFormatProvider)	Ennek a tagnak a leírását lásd ToUInt16(IFormatProvider): .
IConvertible.ToUInt32(IFormatProvider)	Ennek a tagnak a leírását lásd ToUInt32(IFormatProvider): .
IConvertible.ToUInt64(IFormatProvider)	Ennek a tagnak a leírását lásd ToUInt64(IFormatProvider): .
IDecrementOperators<Char>.CheckedDecrement(Char)	Érték decresítése.
IDecrementOperators<Char>.Decrement(Char)	Érték decresítése.
IDivisionOperators<Char,Char,Char>.Division(Char, Char)	Az egyik értéket egy másikkal osztja el a hányados kiszámításához.
IEqualityOperators<Char,Char,Boolean>.Equality(Char, Char)	Két értéket hasonlít össze az egyenlőség meghatározásához.
IEqualityOperators<Char,Char,Boolean>.Inequality(Char, Char)	Két értéket hasonlít össze az egyenlőtlenség meghatározásához.
IFormattable.ToString(String, IFormatProvider)	Formázza az aktuális példány értékét a megadott formátummal.
IIncrementOperators<Char>.CheckedIncrement(Char)	Növekményes érték.
IIncrementOperators<Char>.Increment(Char)	Növekményes érték.
IMinMaxValue<Char>.MaxValue	Az aktuális típus maximális értékét adja meg.
IMinMaxValue<Char>.MinValue	Az aktuális típus minimális értékét adja meg.
IModulusOperators<Char,Char,Char>.Modulus(Char, Char)	Két értéket oszt össze a modulus vagy a maradék kiszámításához.
IMultiplicativeIdentity<Char,Char>.MultiplicativeIdentity	Lekéri az aktuális típus többszörös identitását.
IMultiplyOperators<Char,Char,Char>.CheckedMultiply(Char, Char)	Két értéket szoroz össze a termék kiszámításához.
IMultiplyOperators<Char,Char,Char>.Multiply(Char, Char)	Két értéket szoroz össze a termék kiszámításához.
INumberBase<Char>.Abs(Char)	Kiszámítja egy érték abszolút értékét.
INumberBase<Char>.IsCanonical(Char)	Meghatározza, hogy egy érték a vesszővel ábrázolt érték-e.
INumberBase<Char>.IsComplexNumber(Char)	Meghatározza, hogy egy érték összetett számot jelöl-e.
INumberBase<Char>.IsEvenInteger(Char)	Meghatározza, hogy egy érték páros integrál számot jelöl-e.
INumberBase<Char>.IsFinite(Char)	Meghatározza, hogy egy érték véges-e.
INumberBase<Char>.IsImaginaryNumber(Char)	Meghatározza, hogy egy érték tiszta képzeletbeli számot jelöl-e.
INumberBase<Char>.IsInfinity(Char)	Meghatározza, hogy egy érték végtelen-e.
INumberBase<Char>.IsInteger(Char)	Meghatározza, hogy egy érték egy integrál számot jelöl-e.
INumberBase<Char>.IsNaN(Char)	Meghatározza, hogy egy érték naN-e.
INumberBase<Char>.IsNegative(Char)	Meghatározza, hogy egy érték negatív-e.
INumberBase<Char>.IsNegativeInfinity(Char)	Meghatározza, hogy egy érték negatív végtelen-e.
INumberBase<Char>.IsNormal(Char)	Meghatározza, hogy egy érték normális-e.
INumberBase<Char>.IsOddInteger(Char)	Meghatározza, hogy egy érték páratlan integrál számot jelöl-e.
INumberBase<Char>.IsPositive(Char)	Meghatározza, hogy egy érték pozitív-e.
INumberBase<Char>.IsPositiveInfinity(Char)	Meghatározza, hogy egy érték pozitív végtelen-e.
INumberBase<Char>.IsRealNumber(Char)	Meghatározza, hogy egy érték valós számot jelöl-e.
INumberBase<Char>.IsSubnormal(Char)	Meghatározza, hogy egy érték szubnormális-e.
INumberBase<Char>.IsZero(Char)	Meghatározza, hogy egy érték nulla-e.
INumberBase<Char>.MaxMagnitude(Char, Char)	Két értéket hasonlít össze a nagyobb számítási értékekkel.
INumberBase<Char>.MaxMagnitudeNumber(Char, Char)	Két értéket hasonlít össze a számítással, amelynek nagyobb a nagysága, és a másik értéket adja vissza, ha egy bemenet .NaN
INumberBase<Char>.MinMagnitude(Char, Char)	Két értéket hasonlít össze a kisebb számítási értékkel.
INumberBase<Char>.MinMagnitudeNumber(Char, Char)	Két értéket hasonlít össze a számítással, amelynek kisebb a nagysága, és a másik értéket adja vissza, ha egy bemenet .NaN
INumberBase<Char>.MultiplyAddEstimate(Char, Char, Char)	Kiszámítja a (left * right) + addendbecslést.
INumberBase<Char>.One	Lekéri a típus értékét 1 .
INumberBase<Char>.Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Több karakterből álló elemet elemez egy értékben.
INumberBase<Char>.Parse(String, NumberStyles, IFormatProvider)	Egy sztringet egy értékbe elemez.
INumberBase<Char>.Radix	Lekéri a típus radixát vagy bázist.
INumberBase<Char>.TryConvertFromChecked<TOther>(TOther, Char)	Egy karaktert UTF-16 kódegységként jelöl.
INumberBase<Char>.TryConvertFromSaturating<TOther>(TOther, Char)	Egy karaktert UTF-16 kódegységként jelöl.
INumberBase<Char>.TryConvertFromTruncating<TOther>(TOther, Char)	Egy karaktert UTF-16 kódegységként jelöl.
INumberBase<Char>.TryConvertToChecked<TOther>(Char, TOther)	Megpróbálja átalakítani az aktuális típus egy példányát egy másik típusra, és túlcsordulási kivételt okoz az aktuális típus ábrázolható tartományán kívül eső értékek esetében.
INumberBase<Char>.TryConvertToSaturating<TOther>(Char, TOther)	Megpróbálja átalakítani az aktuális típus egy példányát egy másik típusra, és az aktuális típus reprezentáló tartományán kívül eső értékeket telít.
INumberBase<Char>.TryConvertToTruncating<TOther>(Char, TOther)	Megpróbálja átalakítani az aktuális típus egy példányát egy másik típusra, és csonkolja az aktuális típus ábrázolható tartományán kívül eső értékeket.
INumberBase<Char>.TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Char)	Egy karaktert UTF-16 kódegységként jelöl.
INumberBase<Char>.TryParse(String, NumberStyles, IFormatProvider, Char)	Egy karaktert UTF-16 kódegységként jelöl.
INumberBase<Char>.Zero	Lekéri a típus értékét 0 .
IParsable<Char>.Parse(String, IFormatProvider)	Egy sztringet egy értékbe elemez.
IParsable<Char>.TryParse(String, IFormatProvider, Char)	Egy karaktert UTF-16 kódegységként jelöl.
IShiftOperators<Char,Int32,Char>.LeftShift(Char, Int32)	Egy adott összeggel balra hagyott érték eltolása.
IShiftOperators<Char,Int32,Char>.RightShift(Char, Int32)	Egy érték eltolása egy adott összeggel jobbra.
IShiftOperators<Char,Int32,Char>.UnsignedRightShift(Char, Int32)	Egy érték eltolása egy adott összeggel jobbra.
ISpanFormattable.TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Megpróbálja formázni az aktuális példány értékét a megadott karaktertartományba.
ISpanParsable<Char>.Parse(ReadOnlySpan<Char>, IFormatProvider)	Több karakterből álló elemet elemez egy értékben.
ISpanParsable<Char>.TryParse(ReadOnlySpan<Char>, IFormatProvider, Char)	Egy karaktert UTF-16 kódegységként jelöl.
ISubtractionOperators<Char,Char,Char>.CheckedSubtraction(Char, Char)	Kivon két értéket a különbség kiszámításához.
ISubtractionOperators<Char,Char,Char>.Subtraction(Char, Char)	Kivon két értéket a különbség kiszámításához.
IUnaryNegationOperators<Char,Char>.CheckedUnaryNegation(Char)	Kiszámítja egy érték ellenőrizetlen negációját.
IUnaryNegationOperators<Char,Char>.UnaryNegation(Char)	Kiszámítja egy érték nem kötelező negációját.
IUnaryPlusOperators<Char,Char>.UnaryPlus(Char)	Kiszámítja egy érték unáris pluszát.
IUtf8SpanFormattable.TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Az aktuális példány értékét UTF-8 formátumban próbálja formázni a megadott bájttartományba.
IUtf8SpanParsable<Char>.Parse(ReadOnlySpan<Byte>, IFormatProvider)	Egy karaktert UTF-16 kódegységként jelöl.
IUtf8SpanParsable<Char>.TryParse(ReadOnlySpan<Byte>, IFormatProvider, Char)	Egy karaktert UTF-16 kódegységként jelöl.

Szálbiztonság

Az ilyen típusú tagok szálbiztosak. Azok a tagok, amelyek úgy tűnik, hogy módosítják a példány állapotát, valójában egy új példányt ad vissza, amely inicializálva van az új értékkel. Mint minden más típus esetén, az ilyen típusú példányt tartalmazó megosztott változókra való olvasást és írást zárolással kell védeni a szálbiztonság érdekében.

Lásd még

• IComparable
• IConvertible
• String