Char Yapı

Tanım

Ad Alanı:

System

Bütünleştirilmiş Kodlar:

netstandard.dll, System.Runtime.dll

Kaynak:

Char.cs

Bir karakteri UTF-16 kod birimi olarak temsil eder.

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)

Devralma

Object

ValueType

Char

Uygulamalar

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>

Örnekler

Aşağıdaki kod örneği içindeki Charyöntemlerden bazılarını gösterir.

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

Açıklamalar

Yapısı, Char UTF-16 kodlamasını kullanarak Unicode kod noktalarını temsil eder. Bir Char nesnenin değeri, 16 bit sayısal (sıralı) değeridir.

Unicode, skaler değerler, kod noktaları, vekil çiftleri, UTF-16 ve Rune türü hakkında bilginiz yoksa bkz. .NET'te karakter kodlamaya giriş.

Bu makalede bir Char nesne ile bir karakter arasındaki ilişki incelenmekte ve Char örnekleriyle gerçekleştirilen bazı yaygın görevler tartışılmaktadır. Rune, .NET Core 3.0'da sunulan türü, bu görevlerden bazılarını gerçekleştirmeye Char alternatif olarak değerlendirmenizi öneririz.

Char nesneleri, Unicode karakterleri ve dizeler

String Nesne, bir metin dizesini Char temsil eden sıralı bir yapı koleksiyonudur. Unicode karakterlerin çoğu tek Char bir nesneyle temsil edilebilir, ancak temel karakter, vekil çift ve/veya karakter dizisini birleştiren bir karakter birden çok Char nesne tarafından temsil edilir. Bu nedenle, nesnedeki bir CharString yapı tek bir Unicode karakteriyle eşdeğer olmayabilir.

Aşağıdaki durumlarda tek Unicode karakterlerini temsil etmek için birden çok 16 bit kod birimi kullanılır:

• Glifler, tek bir karakterden veya bir temel karakterden ve ardından bir veya daha fazla birleştirme karakterinden oluşan yapılardır. Örneğin, ğkarakteri, kod birimi U+0061 olan ve Char ardından kod birimi U+0308 olan bir Char nesneyle temsil edilir. (ğkarakteri, U+00E4 kod birimine sahip tek Char bir nesne tarafından da tanımlanabilir.) Aşağıdaki örnekte ğkarakterinin iki Char nesneden oluştuğu gösterilmektedir.

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

• Unicode Temel Çok Dilli Düzlem (BMP) dışındaki karakterler. Unicode, 0 düzlemini temsil eden BMP'ye ek olarak on altı düzlemi destekler. Unicode kod noktası UTF-32'de düzlemi içeren 21 bit değerle temsil edilir. Örneğin U+1D160, MUSICAL SYMBOL EIGHTH NOTE karakterini temsil eder. UTF-16 kodlaması yalnızca 16 bit olduğundan, BMP dışındaki karakterler UTF-16'daki vekil çiftlerle temsil edilir. Aşağıdaki örnek, U+1D160'ın UTF-32 eşdeğeri olan MUSICAL SYMBOL EIGHTH NOTE karakterinin U+D834 U+DD60 olduğunu göstermektedir. U+D834 yüksek vekil çiftlidir; yüksek vekil çiftlikleri U+D800 ile U+DBFF arasındadır. U+DD60 düşük vekildir; düşük vekiller U+DC00 ile U+DFFF arasında değişir.

  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
  

Karakterler ve karakter kategorileri

Her Unicode karakteri veya geçerli vekil çift bir Unicode kategorisine aittir. .NET'te Unicode kategorileri numaralandırmanın UnicodeCategory üyeleri tarafından temsil edilir ve örneğin , UnicodeCategory.CurrencySymbolve UnicodeCategory.LowercaseLettergibi UnicodeCategory.SpaceSeparatordeğerler içerir.

Bir karakterin Unicode kategorisini belirlemek için yöntemini çağırın GetUnicodeCategory . Örneğin, aşağıdaki örnek bir dizedeki her karakterin Unicode kategorisini görüntülemek için öğesini çağırır GetUnicodeCategory . Örnek yalnızca örnekte vekil çiftler String yoksa düzgün çalışır.

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

Dahili olarak, ASCII aralığının dışındaki karakterler için (U+0000 ile U+00FF) GetUnicodeCategory yöntemi, sınıfı tarafından CharUnicodeInfo bildirilen Unicode kategorilerine bağlıdır. Unicode karakterleri Unicode Standard, Sürüm 8.0.0'a göre sınıflandırılır.

Karakterler ve metin öğeleri

Tek bir karakter birden çok Char nesneyle temsil edilebildiğinden, tek tek Char nesnelerle çalışmak her zaman anlamlı değildir. Örneğin aşağıdaki örnek, Ege sayılarını sıfırdan 9'a kadar temsil eden Unicode kod noktalarını UTF-16 kod birimlerine dönüştürür. Hatalı olarak nesneleri karakterlerle eşitlediğinden Char , sonuçta elde edilen dizenin 20 karakteri olduğunu yanlışlıkla bildirir.

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.

Bir nesnenin tek bir Char karakteri temsil ettiği varsayımını önlemek için aşağıdakileri yapabilirsiniz:

• Dil içeriğini temsil etmek ve analiz etmek için objenin tümüyle String çalışabilirsiniz, tek tek karakterleriyle çalışmak yerine.

• Aşağıdaki örnekte gösterildiği gibi kullanabilirsiniz 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
  

• sınıfını StringInfo tek tek Char nesneler yerine metin öğeleriyle çalışmak için kullanabilirsiniz. Aşağıdaki örnek, sıfırdan dokuza kadar Ege sayılarından oluşan bir dizedeki metin öğelerinin sayısını saymak için nesnesini kullanır StringInfo . Bir vekil çiftini tek bir karakter olarak değerlendirdiğinden, dizenin on karakter içerdiğini doğru şekilde bildirir.

  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.
  

• Dizede bir veya daha fazla birleştirme karakteri olan bir temel karakter varsa, alt dizeyi String.Normalize tek bir UTF-16 kodlanmış kod birimine dönüştürmek için yöntemini çağırabilirsiniz. Aşağıdaki örnek, U+0061 (LATIN KÜÇÜK HARF A) temel karakteri ve U+0308 (BİRLEŞİK DİYAREZ) karakterini U+00E4'e (LATIN KÜÇÜK HARF A DİYAREZLİ) dönüştürmek için String.Normalize yöntemini çağırır.

  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)
  

Yaygın işlemler

Yapı Char nesneleri karşılaştırmak, geçerli Char nesnenin değerini başka bir türdeki bir nesneye dönüştürmek ve Char nesnesinin Unicode kategorisini belirlemek için yöntemler sağlar:

Bunu yapmak için	Bu System.Char yöntemleri kullanın
Nesneleri karşılaştırma Char	CompareTo ve Equals
Kod noktasını dizeye dönüştürme	ConvertFromUtf32 Rune türüne de bakın.
Bir Char nesnesini veya Char nesnelerden oluşan bir vekil çifti kod noktası olarak dönüştürme	Tek bir karakter için: Convert.ToInt32(Char) Bir vekil çift veya dizedeki bir karakter için: Char.ConvertToUtf32 Rune türüne de bakın.
Bir karakterin Unicode kategorisini alma	GetUnicodeCategory Ayrıca bkz. Rune.GetUnicodeCategory.
Bir karakterin basamak, harf, noktalama işareti, denetim karakteri gibi belirli bir Unicode kategorisinde olup olmadığını belirleme	IsControl, IsDigit, IsHighSurrogate, IsLetter, IsLetterOrDigit, IsLower, IsLowSurrogate, IsNumber, IsPunctuation, IsSeparator, IsSurrogate, IsSurrogatePair, IsSymbol, IsUpper ve IsWhiteSpace Ayrıca Rune türüyle ilgili yöntemlere bakın.
Sayıyı temsil eden bir Char nesneyi sayısal değer türüne dönüştürme	GetNumericValue Ayrıca bkz. Rune.GetNumericValue.
Dizedeki bir karakteri nesneye dönüştürme Char	Parse ve TryParse
Nesneyi Char nesneye String dönüştürme	ToString
Bir Char objesinin yazım biçimini değiştir	ToLower, ToLowerInvariant, ToUpper ve ToUpperInvariant Ayrıca Rune türüyle ilgili yöntemlere bakın.

Karakter değerleri ve karşılıklı çalışma uyumluluğu

Unicode UTF-16 kod birimi olarak temsil edilen yönetilen Char türü, yönetilemeyen koda geçirildiğinde, birlikte çalışma sıralayıcısı varsayılan olarak karakter kümesini ANSI'ye çevirir. Platform çağırma bildirimlerine DllImportAttribute özniteliğini ve bir COM birlikte çalışma bildirimine StructLayoutAttribute özniteliğini uygulayarak, aktarılan Char türünün hangi karakter kümesini kullandığını denetleyebilirsiniz.

Alanlar

Name	Description
MaxValue	Bir öğesinin mümkün olan en büyük değerini Chartemsil eder. Bu alan sabittir.
MinValue	Bir öğesinin mümkün olan en küçük değerini Chartemsil eder. Bu alan sabittir.

Yöntemler

Name	Description
CompareTo(Char)	Bu örneği belirtilen Char bir nesneyle karşılaştırır ve bu örneğin belirtilen nesneyle aynı sıralama düzeninde Char önce gelip gelmeyeceğini, takip edip etmediğini veya görüntülenip görüntülenmediğini belirtir.
CompareTo(Object)	Bu örneği belirtilen bir nesneyle karşılaştırır ve bu örneğin belirtilen ile aynı sıralama düzeninde Objectönce gelip gelmeyeceğini, takip edip etmediğini veya görüntülenip görüntülenmediğini belirtir.
ConvertFromUtf32(Int32)	Belirtilen Unicode kod noktasını UTF-16 ile kodlanmış bir dizeye dönüştürür.
ConvertToUtf32(Char, Char)	UTF-16 kodlanmış vekil çiftinin değerini Unicode kod noktasına dönüştürür.
ConvertToUtf32(String, Int32)	UtF-16 ile kodlanmış bir karakterin veya vekil çiftin değerini bir dizedeki belirtilen konumda unicode kod noktasına dönüştürür.
Equals(Char)	Bu örneğin belirtilen Char nesneye eşit olup olmadığını gösteren bir değer döndürür.
Equals(Object)	Bu örneğin belirtilen bir nesneye eşit olup olmadığını gösteren bir değer döndürür.
GetHashCode()	Bu örneğin karma kodunu döndürür.
GetNumericValue(Char)	Belirtilen sayısal Unicode karakterini çift duyarlıklı kayan nokta sayısına dönüştürür.
GetNumericValue(String, Int32)	Belirtilen dizede belirtilen konumdaki sayısal Unicode karakterini çift duyarlıklı kayan nokta sayısına dönüştürür.
GetTypeCode()	değer türü TypeCodeiçin değerini Char döndürür.
GetUnicodeCategory(Char)	Belirtilen Unicode karakterini değerlerden biri UnicodeCategory tarafından tanımlanan bir gruba ayırır.
GetUnicodeCategory(String, Int32)	Belirtilen dizede belirtilen konumdaki karakteri değerlerden biri UnicodeCategory tarafından tanımlanan bir gruba ayırır.
IsAscii(Char)	ASCII karakteriyse true ([ U+0000..U+007F ]) döndürürc.
IsAsciiDigit(Char)	Bir karakterin ASCII basamak olarak kategorilere ayrılmış olup olmadığını gösterir.
IsAsciiHexDigit(Char)	Bir karakterin ASCII onaltılık basamak olarak kategorilere ayrılmış olup olmadığını gösterir.
IsAsciiHexDigitLower(Char)	Bir karakterin ASCII küçük harf onaltılık basamak olarak kategorilere ayrılmış olup olmadığını gösterir.
IsAsciiHexDigitUpper(Char)	Bir karakterin ASCII büyük harf onaltılık basamak olarak kategorilere ayrılmış olup olmadığını gösterir.
IsAsciiLetter(Char)	Bir karakterin ASCII harfi olarak kategorilere ayrılmış olup olmadığını gösterir.
IsAsciiLetterLower(Char)	Bir karakterin küçük harf ASCII harfi olarak kategorilere ayrılmış olup olmadığını gösterir.
IsAsciiLetterOrDigit(Char)	Bir karakterin ASCII harf veya basamak olarak kategorilere ayrılmış olup olmadığını gösterir.
IsAsciiLetterUpper(Char)	Bir karakterin büyük harf ASCII harfi olarak kategorilere ayrılmış olup olmadığını gösterir.
IsBetween(Char, Char, Char)	Bir karakterin belirtilen kapsayıcı aralık içinde olup olmadığını gösterir.
IsControl(Char)	Belirtilen Unicode karakterinin denetim karakteri olarak kategorilere ayrılmış olup olmadığını gösterir.
IsControl(String, Int32)	Belirtilen dizede belirtilen konumdaki karakterin denetim karakteri olarak kategorilere ayrılmış olup olmadığını gösterir.
IsDigit(Char)	Belirtilen Unicode karakterinin ondalık basamak olarak kategorilere ayrılmış olup olmadığını gösterir.
IsDigit(String, Int32)	Belirtilen dizede belirtilen konumdaki karakterin ondalık basamak olarak kategorilere ayrılmış olup olmadığını gösterir.
IsHighSurrogate(Char)	Belirtilen Char nesnenin yüksek vekil olup olmadığını gösterir.
IsHighSurrogate(String, Int32)	Bir dizede belirtilen konumdaki nesnenin Char yüksek vekil olup olmadığını gösterir.
IsLetter(Char)	Belirtilen Unicode karakterinin Unicode harfi olarak kategorilere ayrılmış olup olmadığını gösterir.
IsLetter(String, Int32)	Belirtilen dizede belirtilen konumdaki karakterin Unicode harfi olarak kategorilere ayrılmış olup olmadığını gösterir.
IsLetterOrDigit(Char)	Belirtilen Unicode karakterinin harf mi yoksa ondalık basamak olarak mı kategorilere ayrılmış olduğunu gösterir.
IsLetterOrDigit(String, Int32)	Belirtilen dizede belirtilen konumdaki karakterin harf mi yoksa ondalık basamak olarak mı kategorilere ayrılmış olduğunu gösterir.
IsLower(Char)	Belirtilen Unicode karakterinin küçük harf olarak kategorilere ayrılmış olup olmadığını gösterir.
IsLower(String, Int32)	Belirtilen dizede belirtilen konumdaki karakterin küçük harf olarak kategorilere ayrılmış olup olmadığını gösterir.
IsLowSurrogate(Char)	Belirtilen Char nesnenin düşük vekil olup olmadığını gösterir.
IsLowSurrogate(String, Int32)	Bir dizede belirtilen konumdaki nesnenin Char düşük vekil olup olmadığını gösterir.
IsNumber(Char)	Belirtilen Unicode karakterinin sayı olarak kategorilere ayrılmış olup olmadığını gösterir.
IsNumber(String, Int32)	Belirtilen dizede belirtilen konumdaki karakterin sayı olarak kategorilere ayrılmış olup olmadığını gösterir.
IsPunctuation(Char)	Belirtilen Unicode karakterinin noktalama işareti olarak kategorilere ayrılmış olup olmadığını gösterir.
IsPunctuation(String, Int32)	Belirtilen dizede belirtilen konumdaki karakterin noktalama işareti olarak kategorilere ayrılmış olup olmadığını gösterir.
IsSeparator(Char)	Belirtilen Unicode karakterinin ayırıcı karakter olarak kategorilere ayrılmış olup olmadığını gösterir.
IsSeparator(String, Int32)	Belirtilen dizede belirtilen konumdaki karakterin ayırıcı karakter olarak kategorilere ayrılmış olup olmadığını gösterir.
IsSurrogate(Char)	Belirtilen karakterin vekil kod birimi olup olmadığını gösterir.
IsSurrogate(String, Int32)	Belirtilen dizede belirtilen konumdaki karakterin vekil kod birimi olup olmadığını gösterir.
IsSurrogatePair(Char, Char)	Belirtilen Char iki nesnenin vekil çift oluşturup oluşturmadığını gösterir.
IsSurrogatePair(String, Int32)	Bir dizede belirtilen konumdaki iki bitişik Char nesnenin vekil çift oluşturup oluşturmadığını gösterir.
IsSymbol(Char)	Belirtilen Unicode karakterinin sembol karakteri olarak kategorilere ayrılmış olup olmadığını gösterir.
IsSymbol(String, Int32)	Belirtilen dizede belirtilen konumdaki karakterin sembol karakteri olarak kategorilere ayrılmış olup olmadığını gösterir.
IsUpper(Char)	Belirtilen Unicode karakterinin büyük harf olarak kategorilere ayrılmış olup olmadığını gösterir.
IsUpper(String, Int32)	Belirtilen dizede belirtilen konumdaki karakterin büyük harf olarak kategorilere ayrılmış olup olmadığını gösterir.
IsWhiteSpace(Char)	Belirtilen Unicode karakterinin boşluk olarak kategorilere ayrılmış olup olmadığını gösterir.
IsWhiteSpace(String, Int32)	Belirtilen dizede belirtilen konumdaki karakterin boşluk olarak kategorilere ayrılmış olup olmadığını gösterir.
Parse(String)	Belirtilen dizenin değerini eşdeğer Unicode karakterine dönüştürür.
ToLower(Char, CultureInfo)	Belirtilen kültüre özgü biçimlendirme bilgilerini kullanarak belirtilen Unicode karakterinin değerini küçük harf eşdeğerine dönüştürür.
ToLower(Char)	Unicode karakterinin değerini küçük harf eşdeğerine dönüştürür.
ToLowerInvariant(Char)	Sabit kültürün büyük/küçük harf kurallarını kullanarak Unicode karakterinin değerini küçük harf eşdeğerine dönüştürür.
ToString()	Bu örneğin değerini eşdeğer dize gösterimine dönüştürür.
ToString(Char)	Belirtilen Unicode karakterini eşdeğer dize gösterimine dönüştürür.
ToString(IFormatProvider)	Belirtilen kültüre özgü biçim bilgilerini kullanarak bu örneğin değerini eşdeğer dize gösterimine dönüştürür.
ToUpper(Char, CultureInfo)	Belirtilen kültüre özgü biçimlendirme bilgilerini kullanarak belirtilen Unicode karakterinin değerini büyük harf eşdeğerine dönüştürür.
ToUpper(Char)	Unicode karakterinin değerini büyük harf eşdeğerine dönüştürür.
ToUpperInvariant(Char)	Sabit kültürün büyük/küçük harf kurallarını kullanarak Unicode karakterinin değerini büyük harf eşdeğerine dönüştürür.
TryParse(String, Char)	Belirtilen dizenin değerini eşdeğer Unicode karakterine dönüştürür. Dönüş kodu, dönüştürmenin başarılı mı yoksa başarısız mı olduğunu gösterir.

Belirtik Arabirim Kullanımları

Name	Description
IAdditionOperators<Char,Char,Char>.Addition(Char, Char)	Toplamlarını hesaplamak için iki değeri bir araya ekler.
IAdditionOperators<Char,Char,Char>.CheckedAddition(Char, Char)	Toplamlarını hesaplamak için iki değeri bir araya ekler.
IAdditiveIdentity<Char,Char>.AdditiveIdentity	Geçerli türün ek kimliğini alır.
IBinaryInteger<Char>.GetByteCount()	bir parçası TryWriteLittleEndian(Span<Byte>, Int32)olarak yazılacak bayt sayısını alır.
IBinaryInteger<Char>.GetShortestBitLength()	Geçerli değerin en kısa ikisinin tamamlayıcı gösteriminin bit cinsinden uzunluğunu alır.
IBinaryInteger<Char>.LeadingZeroCount(Char)	Bir değerdeki baştaki sıfır bit sayısını hesaplar.
IBinaryInteger<Char>.PopCount(Char)	Bir değerde ayarlanan bit sayısını hesaplar.
IBinaryInteger<Char>.RotateLeft(Char, Int32)	Değeri belirli bir miktar sola döndürür.
IBinaryInteger<Char>.RotateRight(Char, Int32)	Değeri belirli bir miktara göre sağa döndürür.
IBinaryInteger<Char>.TrailingZeroCount(Char)	Bir değerdeki sondaki sıfır bit sayısını hesaplar.
IBinaryInteger<Char>.TryReadBigEndian(ReadOnlySpan<Byte>, Boolean, Char)	Bir karakteri UTF-16 kod birimi olarak temsil eder.
IBinaryInteger<Char>.TryReadLittleEndian(ReadOnlySpan<Byte>, Boolean, Char)	Bir karakteri UTF-16 kod birimi olarak temsil eder.
IBinaryInteger<Char>.TryWriteBigEndian(Span<Byte>, Int32)	Geçerli değeri büyük endian biçiminde belirli bir span'a yazmaya çalışır.
IBinaryInteger<Char>.TryWriteLittleEndian(Span<Byte>, Int32)	Geçerli değeri küçük endian biçiminde belirli bir span'a yazmaya çalışır.
IBinaryNumber<Char>.AllBitsSet	Tüm bitlerin ayarlandığı ikili türün bir örneğini alır.
IBinaryNumber<Char>.IsPow2(Char)	Bir değerin ikinin gücü olup olmadığını belirler.
IBinaryNumber<Char>.Log2(Char)	Bir değerin 2. günlüğünü hesaplar.
IBitwiseOperators<Char,Char,Char>.BitwiseAnd(Char, Char)	İki değerin bit düzeyinde ve değerini hesaplar.
IBitwiseOperators<Char,Char,Char>.BitwiseOr(Char, Char)	bit düzeyinde veya iki değeri hesaplar.
IBitwiseOperators<Char,Char,Char>.ExclusiveOr(Char, Char)	İki değerin özel veya özel değerini hesaplar.
IBitwiseOperators<Char,Char,Char>.OnesComplement(Char)	Belirli bir değerin bire tamamlayan gösterimini hesaplar.
IComparisonOperators<Char,Char,Boolean>.GreaterThan(Char, Char)	Hangisinin daha büyük olduğunu belirlemek için iki değeri karşılaştırır.
IComparisonOperators<Char,Char,Boolean>.GreaterThanOrEqual(Char, Char)	Hangisinin daha büyük veya eşit olduğunu belirlemek için iki değeri karşılaştırır.
IComparisonOperators<Char,Char,Boolean>.LessThan(Char, Char)	Hangisinin daha az olduğunu belirlemek için iki değeri karşılaştırır.
IComparisonOperators<Char,Char,Boolean>.LessThanOrEqual(Char, Char)	Hangisinin daha az veya eşit olduğunu belirlemek için iki değeri karşılaştırır.
IConvertible.ToBoolean(IFormatProvider)	Not Bu dönüştürme desteklenmez. Bunu yapmaya çalışmak bir InvalidCastException oluşturur.
IConvertible.ToByte(IFormatProvider)	Bu üyenin açıklaması için bkz ToByte(IFormatProvider). .
IConvertible.ToChar(IFormatProvider)	Bu üyenin açıklaması için bkz ToChar(IFormatProvider). .
IConvertible.ToDateTime(IFormatProvider)	Not Bu dönüştürme desteklenmez. Bunu yapmaya çalışmak bir InvalidCastException oluşturur.
IConvertible.ToDecimal(IFormatProvider)	Not Bu dönüştürme desteklenmez. Bunu yapmaya çalışmak bir InvalidCastException oluşturur.
IConvertible.ToDouble(IFormatProvider)	Not Bu dönüştürme desteklenmez. Bunu yapmaya çalışmak bir InvalidCastException oluşturur.
IConvertible.ToInt16(IFormatProvider)	Bu üyenin açıklaması için bkz ToInt16(IFormatProvider). .
IConvertible.ToInt32(IFormatProvider)	Bu üyenin açıklaması için bkz ToInt32(IFormatProvider). .
IConvertible.ToInt64(IFormatProvider)	Bu üyenin açıklaması için bkz ToInt64(IFormatProvider). .
IConvertible.ToSByte(IFormatProvider)	Bu üyenin açıklaması için bkz ToSByte(IFormatProvider). .
IConvertible.ToSingle(IFormatProvider)	Not Bu dönüştürme desteklenmez. Bunu yapmaya çalışmak bir InvalidCastException oluşturur.
IConvertible.ToType(Type, IFormatProvider)	Bu üyenin açıklaması için bkz ToType(Type, IFormatProvider). .
IConvertible.ToUInt16(IFormatProvider)	Bu üyenin açıklaması için bkz ToUInt16(IFormatProvider). .
IConvertible.ToUInt32(IFormatProvider)	Bu üyenin açıklaması için bkz ToUInt32(IFormatProvider). .
IConvertible.ToUInt64(IFormatProvider)	Bu üyenin açıklaması için bkz ToUInt64(IFormatProvider). .
IDecrementOperators<Char>.CheckedDecrement(Char)	Bir değeri azaltma.
IDecrementOperators<Char>.Decrement(Char)	Bir değeri azaltma.
IDivisionOperators<Char,Char,Char>.Division(Char, Char)	Kendi bölümünü hesaplamak için bir değeri diğerine böler.
IEqualityOperators<Char,Char,Boolean>.Equality(Char, Char)	Eşitliği belirlemek için iki değeri karşılaştırır.
IEqualityOperators<Char,Char,Boolean>.Inequality(Char, Char)	Eşitsizliği belirlemek için iki değeri karşılaştırır.
IFormattable.ToString(String, IFormatProvider)	Belirtilen biçimi kullanarak geçerli örneğin değerini biçimlendirin.
IIncrementOperators<Char>.CheckedIncrement(Char)	Bir değeri artırır.
IIncrementOperators<Char>.Increment(Char)	Bir değeri artırır.
IMinMaxValue<Char>.MaxValue	Geçerli türün en büyük değerini alır.
IMinMaxValue<Char>.MinValue	Geçerli türün en düşük değerini alır.
IModulusOperators<Char,Char,Char>.Modulus(Char, Char)	Modüllerini veya kalan değerlerini hesaplamak için iki değeri birbirine böler.
IMultiplicativeIdentity<Char,Char>.MultiplicativeIdentity	Geçerli türün çarpımlı kimliğini alır.
IMultiplyOperators<Char,Char,Char>.CheckedMultiply(Char, Char)	Ürünlerini hesaplamak için iki değeri bir araya getiren.
IMultiplyOperators<Char,Char,Char>.Multiply(Char, Char)	Ürünlerini hesaplamak için iki değeri bir araya getiren.
INumberBase<Char>.Abs(Char)	Bir değerin mutlak değerini hesaplar.
INumberBase<Char>.IsCanonical(Char)	Bir değerin kurallı gösteriminde olup olmadığını belirler.
INumberBase<Char>.IsComplexNumber(Char)	Bir değerin karmaşık bir sayıyı temsil ediyor olup olmadığını belirler.
INumberBase<Char>.IsEvenInteger(Char)	Bir değerin çift tamsayı sayıyı temsil eder olup olmadığını belirler.
INumberBase<Char>.IsFinite(Char)	Bir değerin sonlu olup olmadığını belirler.
INumberBase<Char>.IsImaginaryNumber(Char)	Bir değerin saf bir sanal sayıyı temsil ediyor olup olmadığını belirler.
INumberBase<Char>.IsInfinity(Char)	Bir değerin sonsuz olup olmadığını belirler.
INumberBase<Char>.IsInteger(Char)	Bir değerin tam sayı olup olmadığını belirler.
INumberBase<Char>.IsNaN(Char)	Bir değerin NaN olup olmadığını belirler.
INumberBase<Char>.IsNegative(Char)	Bir değerin negatif olup olmadığını belirler.
INumberBase<Char>.IsNegativeInfinity(Char)	Bir değerin negatif sonsuz olup olmadığını belirler.
INumberBase<Char>.IsNormal(Char)	Bir değerin normal olup olmadığını belirler.
INumberBase<Char>.IsOddInteger(Char)	Bir değerin tek bir tamsayı sayısını temsil ediyor olup olmadığını belirler.
INumberBase<Char>.IsPositive(Char)	Bir değerin pozitif olup olmadığını belirler.
INumberBase<Char>.IsPositiveInfinity(Char)	Bir değerin pozitif sonsuz olup olmadığını belirler.
INumberBase<Char>.IsRealNumber(Char)	Bir değerin gerçek bir sayıyı temsil ediyor olup olmadığını belirler.
INumberBase<Char>.IsSubnormal(Char)	Bir değerin normalin altında olup olmadığını belirler.
INumberBase<Char>.IsZero(Char)	Değerin sıfır olup olmadığını belirler.
INumberBase<Char>.MaxMagnitude(Char, Char)	daha büyük olan iki değeri işlemle karşılaştırır.
INumberBase<Char>.MaxMagnitudeNumber(Char, Char)	İki değeri, daha büyük bir büyüklüğe sahip olan ve giriş ise diğer değeri döndüren işlemle karşılaştırır NaN.
INumberBase<Char>.MinMagnitude(Char, Char)	daha az olan iki değeri işlemle karşılaştırır.
INumberBase<Char>.MinMagnitudeNumber(Char, Char)	daha az büyüklüğe sahip olan ve giriş ise diğer değeri döndüren iki değeri işlemle karşılaştırır NaN.
INumberBase<Char>.MultiplyAddEstimate(Char, Char, Char)	(left * right) + addendtahminini hesaplar.
INumberBase<Char>.One	Türün değerini 1 alır.
INumberBase<Char>.Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Bir karakter aralığını bir değere ayrıştırıyor.
INumberBase<Char>.Parse(String, NumberStyles, IFormatProvider)	Bir dizeyi bir değere ayrıştırıyor.
INumberBase<Char>.Radix	Türün radiksini veya tabanını alır.
INumberBase<Char>.TryConvertFromChecked<TOther>(TOther, Char)	Bir karakteri UTF-16 kod birimi olarak temsil eder.
INumberBase<Char>.TryConvertFromSaturating<TOther>(TOther, Char)	Bir karakteri UTF-16 kod birimi olarak temsil eder.
INumberBase<Char>.TryConvertFromTruncating<TOther>(TOther, Char)	Bir karakteri UTF-16 kod birimi olarak temsil eder.
INumberBase<Char>.TryConvertToChecked<TOther>(Char, TOther)	Geçerli türün bir örneğini başka bir türe dönüştürmeyi dener ve geçerli türün temsil edilebilir aralığının dışında kalan değerler için bir taşma özel durumu oluşturur.
INumberBase<Char>.TryConvertToSaturating<TOther>(Char, TOther)	Geçerli türün bir örneğini başka bir türe dönüştürmeyi dener ve geçerli türün temsil edilebilir aralığının dışında kalan değerleri doygunluğa getirir.
INumberBase<Char>.TryConvertToTruncating<TOther>(Char, TOther)	Geçerli türün bir örneğini başka bir türe dönüştürmeye çalışır ve geçerli türün temsil edilebilir aralığının dışında kalan tüm değerleri kısaltır.
INumberBase<Char>.TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Char)	Bir karakteri UTF-16 kod birimi olarak temsil eder.
INumberBase<Char>.TryParse(String, NumberStyles, IFormatProvider, Char)	Bir karakteri UTF-16 kod birimi olarak temsil eder.
INumberBase<Char>.Zero	Türün değerini 0 alır.
IParsable<Char>.Parse(String, IFormatProvider)	Bir dizeyi bir değere ayrıştırıyor.
IParsable<Char>.TryParse(String, IFormatProvider, Char)	Bir karakteri UTF-16 kod birimi olarak temsil eder.
IShiftOperators<Char,Int32,Char>.LeftShift(Char, Int32)	Değeri belirli bir miktar sola kaydırıyor.
IShiftOperators<Char,Int32,Char>.RightShift(Char, Int32)	Değeri belirli bir miktar sağa kaydırıyor.
IShiftOperators<Char,Int32,Char>.UnsignedRightShift(Char, Int32)	Değeri belirli bir miktar sağa kaydırıyor.
ISpanFormattable.TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Geçerli örneğin değerini sağlanan karakter aralığına biçimlendirmeye çalışır.
ISpanParsable<Char>.Parse(ReadOnlySpan<Char>, IFormatProvider)	Bir karakter aralığını bir değere ayrıştırıyor.
ISpanParsable<Char>.TryParse(ReadOnlySpan<Char>, IFormatProvider, Char)	Bir karakteri UTF-16 kod birimi olarak temsil eder.
ISubtractionOperators<Char,Char,Char>.CheckedSubtraction(Char, Char)	Farklarını hesaplamak için iki değeri çıkarır.
ISubtractionOperators<Char,Char,Char>.Subtraction(Char, Char)	Farklarını hesaplamak için iki değeri çıkarır.
IUnaryNegationOperators<Char,Char>.CheckedUnaryNegation(Char)	Bir değerin denetlenen bir tekli olumsuzlamasını hesaplar.
IUnaryNegationOperators<Char,Char>.UnaryNegation(Char)	Bir değerin tekli olumsuzlamasını hesaplar.
IUnaryPlusOperators<Char,Char>.UnaryPlus(Char)	Bir değerin birli artısını hesaplar.
IUtf8SpanFormattable.TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Geçerli örneğin değerini UTF-8 olarak sağlanan bayt aralığına biçimlendirmeye çalışır.
IUtf8SpanParsable<Char>.Parse(ReadOnlySpan<Byte>, IFormatProvider)	Bir karakteri UTF-16 kod birimi olarak temsil eder.
IUtf8SpanParsable<Char>.TryParse(ReadOnlySpan<Byte>, IFormatProvider, Char)	Bir karakteri UTF-16 kod birimi olarak temsil eder.

İş Parçacığı Güvenliği

Bu türün tüm üyeleri iş parçacığı güvenlidir. Örnek durumunu değiştirmek için görünen üyeler aslında yeni değerle başlatılan yeni bir örnek döndürür. Diğer türlerde olduğu gibi, iş parçacığı güvenliğini garanti etmek için bu türün bir örneğini içeren paylaşılan bir değişkene okuma ve yazma bir kilit tarafından korunmalıdır.

Ayrıca bkz.

• IComparable
• IConvertible
• String