Char 構造体

定義

名前空間:: System

アセンブリ:: mscorlib.dll, System.Runtime.dll

アセンブリ:: netstandard.dll, System.Runtime.dll

アセンブリ:: System.Runtime.dll

アセンブリ:: mscorlib.dll

アセンブリ:: netstandard.dll

ソース:: Char.cs

ソース:: Char.cs

ソース:: Char.cs

ソース:: Char.cs

ソース:: Char.cs

重要

一部の情報は、リリース前に大きく変更される可能性があるプレリリースされた製品に関するものです。 Microsoft は、ここに記載されている情報について、明示または黙示を問わず、一切保証しません。

文字を UTF-16 コード単位として表します。

public value class char : IComparable, IComparable<char>, IConvertible, IEquatable<char>

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 value class char : IComparable, IComparable<char>, IConvertible, IEquatable<char>, ISpanFormattable

public value class char : IComparable<char>, IConvertible, IEquatable<char>, IParsable<char>, ISpanParsable<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 value class char : IComparable, IConvertible

public value class char : IComparable, IComparable<char>, IEquatable<char>

public struct Char : IComparable, IComparable<char>, IConvertible, IEquatable<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>

public readonly struct Char : IComparable, IComparable<char>, IConvertible, IEquatable<char>

public readonly struct Char : IComparable, IComparable<char>, IConvertible, IEquatable<char>, ISpanFormattable

public readonly struct Char : IComparable<char>, IConvertible, IEquatable<char>, IParsable<char>, ISpanParsable<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>

[System.Serializable]
public struct Char : IComparable, IConvertible

[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public struct Char : IComparable, IComparable<char>, IConvertible, IEquatable<char>

public struct Char : IComparable, IComparable<char>, IEquatable<char>

type char = struct
    interface IConvertible

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>

type char = struct
    interface IConvertible
    interface ISpanFormattable
    interface IFormattable

type char = struct
    interface IConvertible
    interface IFormattable
    interface IParsable<char>
    interface ISpanFormattable
    interface ISpanParsable<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>

type char = struct
    interface IConvertible
    interface IFormattable
    interface IParsable<char>
    interface ISpanFormattable
    interface ISpanParsable<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 IUtf8SpanFormattable
    interface IUtf8SpanParsable<char>
    interface IShiftOperators<char, int, char>
    interface IMinMaxValue<char>
    interface IUnsignedNumber<char>

[<System.Serializable>]
type char = struct
    interface IConvertible

[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type char = struct
    interface IConvertible

type char = struct

Public Structure Char
Implements IComparable, IComparable(Of Char), IConvertible, IEquatable(Of 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)

Public Structure Char
Implements IComparable, IComparable(Of Char), IConvertible, IEquatable(Of Char), ISpanFormattable

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)

Public Structure Char
Implements IComparable, IConvertible

Public Structure Char
Implements IComparable, IComparable(Of Char), IEquatable(Of Char)

継承: Object

ValueType
Char

属性: SerializableAttribute ComVisibleAttribute

実装: 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>

例

次のコード例は、 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

注釈

Char構造体は、UTF-16 エンコードを使用して Unicode コードポイントを表します。 Char オブジェクトの値は、その 16 ビット数値 (序数) 値です。

Unicode、スカラー値、コードポイント、サロゲートペア、UTF-16、および Rune 型に慣れていない場合は、「 .NET での文字エンコードの概要」を参照してください。

この記事では、 Char オブジェクトと文字の関係を調べ、 Char インスタンスで実行される一般的なタスクについて説明します。これらのタスクの一部を実行するためのRuneの代わりに、.NET Core 3.0 で導入されたChar型を検討することをお勧めします。

Char オブジェクト、Unicode 文字、および文字列

String オブジェクトは、テキストの文字列を表すChar構造体のシーケンシャルコレクションです。ほとんどの Unicode 文字は 1 つの Char オブジェクトで表すことができますが、基本文字、サロゲートペア、結合文字シーケンスとしてエンコードされる文字は、複数の Char オブジェクトによって表されます。このため、Char オブジェクト内のString構造体は、必ずしも単一の Unicode 文字と等しいとは限りません。

次の場合、1 つの Unicode 文字を表すために複数の 16 ビットコード単位が使用されます。

グリフ。1 文字または基本文字の後に 1 つ以上の結合文字が続く場合があります。たとえば、文字 ä は、コード単位が U+0061 の Char オブジェクトと、そのコード単位が U+0308 である Char オブジェクトによって表されます。 (文字 ä は、U+00E4 のコード単位を持つ 1 つの Char オブジェクトでも定義できます。次の例は、文字 ä が 2 つの Char オブジェクトで構成されていることを示しています。

using System;
using System.IO;

public class Example1
{
    public static void Main()
    {
        StreamWriter sw = new StreamWriter("chars1.txt");
        char[] chars = [ '\u0061', '\u0308' ];
        string strng = new String(chars);
        sw.WriteLine(strng);
        sw.Close();
    }
}
// The example produces the following output:
//       ä

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:
//       ä

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 基本多言語プレーン (BMP) の外側の文字。 Unicode では、平面 0 を表す BMP に加えて 16 個の平面がサポートされています。 Unicode コードポイントは、プレーンを含む 21 ビット値によって UTF-32 で表されます。たとえば、U+1D160 は、音楽記号の八分音符文字を表します。 UTF-16 エンコードには 16 ビットしかないため、BMP の外部の文字は UTF-16 のサロゲートペアによって表されます。次の例は、U+1D160 に相当する UTF-32 (MUSICAL SYMBOL 8 ノート文字) が U+D834 U+DD60 であることを示しています。 U+D834 は上位サロゲートです。上位サロゲートの範囲は U+D800 から U+DBFF です。 U+DD60 は低サロゲートです。低サロゲートの範囲は U+DC00 から U+DFFF です。

using System;
using System.IO;

public class Example3
{
    public static void Main()
    {
        StreamWriter sw = new StreamWriter(@".\chars2.txt");
        int utf32 = 0x1D160;
        string surrogate = Char.ConvertFromUtf32(utf32);
        sw.WriteLine($"U+{utf32:X6} UTF-32 = {surrogate} ({ShowCodePoints(surrogate)}) UTF-16");
        sw.Close();
    }

    private static string ShowCodePoints(string value)
    {
        string retval = null;
        foreach (var ch in value)
            retval += $"U+{Convert.ToUInt16(ch):X4} ";

        return retval.Trim();
    }
}
// The example produces the following output:
//       U+01D160 UTF-32 = ð (U+D834 U+DD60) UTF-16

open System
open System.IO

let showCodePoints (value: char seq) =
    let str =
        value
        |> Seq.map (fun ch -> $"U+{Convert.ToUInt16 ch:X4}")
        |> String.concat ""
    str.Trim()

let sw = new StreamWriter(@".\chars2.txt")
let utf32 = 0x1D160
let surrogate = Char.ConvertFromUtf32 utf32
sw.WriteLine $"U+{utf32:X6} UTF-32 = {surrogate} ({showCodePoints surrogate}) UTF-16"
sw.Close()

// The example produces the following output:
//       U+01D160 UTF-32 = ð (U+D834 U+DD60) UTF-16

Imports System.IO

Module Example4
    Public Sub Main()
        Dim sw As New StreamWriter(".\chars2.txt")
        Dim utf32 As Integer = &H1D160
        Dim surrogate As String = Char.ConvertFromUtf32(utf32)
        sw.WriteLine("U+{0:X6} UTF-32 = {1} ({2}) UTF-16",
                   utf32, surrogate, ShowCodePoints(surrogate))
        sw.Close()
    End Sub

    Private Function ShowCodePoints(value As String) As String
        Dim retval As String = Nothing
        For Each ch In value
            retval += String.Format("U+{0:X4} ", Convert.ToUInt16(ch))
        Next
        Return retval.Trim()
    End Function
End Module
' The example produces the following output:
'       U+01D160 UTF-32 = ð (U+D834 U+DD60) UTF-16

文字と文字カテゴリ

各 Unicode 文字または有効なサロゲートペアは、Unicode カテゴリに属しています。 .NET では、Unicode カテゴリは UnicodeCategory 列挙体のメンバーによって表され、たとえば、 UnicodeCategory.CurrencySymbol、 UnicodeCategory.LowercaseLetter、 UnicodeCategory.SpaceSeparatorなどの値が含まれます。

文字の Unicode カテゴリを確認するには、 GetUnicodeCategory メソッドを呼び出します。たとえば、次の例では、 GetUnicodeCategory を呼び出して、文字列内の各文字の Unicode カテゴリを表示します。この例は、 String インスタンスにサロゲートペアがない場合にのみ正しく機能します。

using System;
using System.Globalization;

class Example
{
   public static void Main()
   {
      // Define a string with a variety of character categories.
      String s = "The red car drove down the long, narrow, secluded road.";
      // Determine the category of each character.
      foreach (var ch in s)
         Console.WriteLine($"'{ch}': {Char.GetUnicodeCategory(ch)}");
   }
}
// The example displays the following output:
//      'T': UppercaseLetter
//      'h': LowercaseLetter
//      'e': LowercaseLetter
//      ' ': SpaceSeparator
//      'r': LowercaseLetter
//      'e': LowercaseLetter
//      'd': LowercaseLetter
//      ' ': SpaceSeparator
//      'c': LowercaseLetter
//      'a': LowercaseLetter
//      'r': LowercaseLetter
//      ' ': SpaceSeparator
//      'd': LowercaseLetter
//      'r': LowercaseLetter
//      'o': LowercaseLetter
//      'v': LowercaseLetter
//      'e': LowercaseLetter
//      ' ': SpaceSeparator
//      'd': LowercaseLetter
//      'o': LowercaseLetter
//      'w': LowercaseLetter
//      'n': LowercaseLetter
//      ' ': SpaceSeparator
//      't': LowercaseLetter
//      'h': LowercaseLetter
//      'e': LowercaseLetter
//      ' ': SpaceSeparator
//      'l': LowercaseLetter
//      'o': LowercaseLetter
//      'n': LowercaseLetter
//      'g': LowercaseLetter
//      ',': OtherPunctuation
//      ' ': SpaceSeparator
//      'n': LowercaseLetter
//      'a': LowercaseLetter
//      'r': LowercaseLetter
//      'r': LowercaseLetter
//      'o': LowercaseLetter
//      'w': LowercaseLetter
//      ',': OtherPunctuation
//      ' ': SpaceSeparator
//      's': LowercaseLetter
//      'e': LowercaseLetter
//      'c': LowercaseLetter
//      'l': LowercaseLetter
//      'u': LowercaseLetter
//      'd': LowercaseLetter
//      'e': LowercaseLetter
//      'd': LowercaseLetter
//      ' ': SpaceSeparator
//      'r': LowercaseLetter
//      'o': LowercaseLetter
//      'a': LowercaseLetter
//      'd': LowercaseLetter
//      '.': OtherPunctuation

open System

// Define a string with a variety of character categories.
let s = "The red car drove down the long, narrow, secluded road."
// Determine the category of each character.
for ch in s do
    printfn $"'{ch}': {Char.GetUnicodeCategory ch}"

// The example displays the following output:
//      'T': UppercaseLetter
//      'h': LowercaseLetter
//      'e': LowercaseLetter
//      ' ': SpaceSeparator
//      'r': LowercaseLetter
//      'e': LowercaseLetter
//      'd': LowercaseLetter
//      ' ': SpaceSeparator
//      'c': LowercaseLetter
//      'a': LowercaseLetter
//      'r': LowercaseLetter
//      ' ': SpaceSeparator
//      'd': LowercaseLetter
//      'r': LowercaseLetter
//      'o': LowercaseLetter
//      'v': LowercaseLetter
//      'e': LowercaseLetter
//      ' ': SpaceSeparator
//      'd': LowercaseLetter
//      'o': LowercaseLetter
//      'w': LowercaseLetter
//      'n': LowercaseLetter
//      ' ': SpaceSeparator
//      't': LowercaseLetter
//      'h': LowercaseLetter
//      'e': LowercaseLetter
//      ' ': SpaceSeparator
//      'l': LowercaseLetter
//      'o': LowercaseLetter
//      'n': LowercaseLetter
//      'g': LowercaseLetter
//      ',': OtherPunctuation
//      ' ': SpaceSeparator
//      'n': LowercaseLetter
//      'a': LowercaseLetter
//      'r': LowercaseLetter
//      'r': LowercaseLetter
//      'o': LowercaseLetter
//      'w': LowercaseLetter
//      ',': OtherPunctuation
//      ' ': SpaceSeparator
//      's': LowercaseLetter
//      'e': LowercaseLetter
//      'c': LowercaseLetter
//      'l': LowercaseLetter
//      'u': LowercaseLetter
//      'd': LowercaseLetter
//      'e': LowercaseLetter
//      'd': LowercaseLetter
//      ' ': SpaceSeparator
//      'r': LowercaseLetter
//      'o': LowercaseLetter
//      'a': LowercaseLetter
//      'd': LowercaseLetter
//      '.': OtherPunctuation

Imports System.Globalization

Module Example1
    Public Sub Main()
        ' Define a string with a variety of character categories.
        Dim s As String = "The car drove down the narrow, secluded road."
        ' Determine the category of each character.
        For Each ch In s
            Console.WriteLine("'{0}': {1}", ch, Char.GetUnicodeCategory(ch))
        Next
    End Sub
End Module
' The example displays the following output:
'       'T': UppercaseLetter
'       'h': LowercaseLetter
'       'e': LowercaseLetter
'       ' ': SpaceSeparator
'       'r': LowercaseLetter
'       'e': LowercaseLetter
'       'd': LowercaseLetter
'       ' ': SpaceSeparator
'       'c': LowercaseLetter
'       'a': LowercaseLetter
'       'r': LowercaseLetter
'       ' ': SpaceSeparator
'       'd': LowercaseLetter
'       'r': LowercaseLetter
'       'o': LowercaseLetter
'       'v': LowercaseLetter
'       'e': LowercaseLetter
'       ' ': SpaceSeparator
'       'd': LowercaseLetter
'       'o': LowercaseLetter
'       'w': LowercaseLetter
'       'n': LowercaseLetter
'       ' ': SpaceSeparator
'       't': LowercaseLetter
'       'h': LowercaseLetter
'       'e': LowercaseLetter
'       ' ': SpaceSeparator
'       'l': LowercaseLetter
'       'o': LowercaseLetter
'       'n': LowercaseLetter
'       'g': LowercaseLetter
'       ',': OtherPunctuation
'       ' ': SpaceSeparator
'       'n': LowercaseLetter
'       'a': LowercaseLetter
'       'r': LowercaseLetter
'       'r': LowercaseLetter
'       'o': LowercaseLetter
'       'w': LowercaseLetter
'       ',': OtherPunctuation
'       ' ': SpaceSeparator
'       's': LowercaseLetter
'       'e': LowercaseLetter
'       'c': LowercaseLetter
'       'l': LowercaseLetter
'       'u': LowercaseLetter
'       'd': LowercaseLetter
'       'e': LowercaseLetter
'       'd': LowercaseLetter
'       ' ': SpaceSeparator
'       'r': LowercaseLetter
'       'o': LowercaseLetter
'       'a': LowercaseLetter
'       'd': LowercaseLetter
'       '.': OtherPunctuation

内部的には、ASCII 範囲外の文字 (U+0000 から U+00FF) の場合、 GetUnicodeCategory メソッドは、 CharUnicodeInfo クラスによって報告される Unicode カテゴリに依存します。 Unicode 文字は、 Unicode 標準バージョン 8.0.0 に基づいて分類されます。

文字とテキスト要素

1 つの文字を複数の Char オブジェクトで表すことができるため、個々の Char オブジェクトを操作することは必ずしも意味がありません。たとえば、次の例では、0 から 9 までのエーゲ数字を表す Unicode コードポイントを UTF-16 でエンコードされたコード単位に変換します。 Charオブジェクトを文字と誤って同一視しているため、結果として得られる文字列が 20 文字であると誤って報告しています。

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.

Char オブジェクトが 1 文字を表すという前提を回避するには、次の操作を行います。

個々の文字を操作して言語コンテンツを表したり分析したりするのではなく、 String オブジェクト全体を操作できます。

次の例に示すように、 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

StringInfo クラスを使用して、個々のChar オブジェクトの代わりにテキスト要素を操作できます。次の例では、 StringInfo オブジェクトを使用して、0 から 9 までのエーゲ数字で構成される文字列内のテキスト要素の数をカウントします。サロゲートペアは 1 文字と見なされるため、文字列に 10 文字が含まれていることが正しく報告されます。

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.

文字列に 1 つ以上の組み合わせ文字を含む基本文字が含まれている場合は、 String.Normalize メソッドを呼び出して、部分文字列を 1 つの UTF-16 でエンコードされたコード単位に変換できます。次の例では、 String.Normalize メソッドを呼び出して、基本文字 U+0061 (ラテン小文字 A) と結合文字 U+0308 (COMBINING DIAERESIS) を U+00E4 (ラテン小文字 A WITH DIAERESIS) に変換します。

using System;

public class Example2
{
    public static void Main()
    {
        string combining = "\u0061\u0308";
        ShowString(combining);

        string normalized = combining.Normalize();
        ShowString(normalized);
    }

    private static void ShowString(string s)
    {
        Console.Write($"Length of string: {s.Length} (");
        for (int ctr = 0; ctr < s.Length; ctr++)
        {
            Console.Write($"U+{Convert.ToUInt16(s[ctr]):X4}");
            if (ctr != s.Length - 1) Console.Write(" ");
        }
        Console.WriteLine(")\n");
    }
}
// The example displays the following output:
//       Length of string: 2 (U+0061 U+0308)
//
//       Length of string: 1 (U+00E4)

open System

let showString (s: string) =
    printf $"Length of string: {s.Length} ("
    for i = 0 to s.Length - 1 do
        printf $"U+{Convert.ToUInt16 s[i]:X4}"
        if i <> s.Length - 1 then printf " "
    printfn ")\n"

let combining = "\u0061\u0308"
showString combining

let normalized = combining.Normalize()
showString normalized

// The example displays the following output:
//       Length of string: 2 (U+0061 U+0308)
//
//       Length of string: 1 (U+00E4)

Module Example3
    Public Sub Main()
        Dim combining As String = ChrW(&H61) + ChrW(&H308)
        ShowString(combining)

        Dim normalized As String = combining.Normalize()
        ShowString(normalized)
    End Sub

    Private Sub ShowString(s As String)
        Console.Write("Length of string: {0} (", s.Length)
        For ctr As Integer = 0 To s.Length - 1
            Console.Write("U+{0:X4}", Convert.ToUInt16(s(ctr)))
            If ctr <> s.Length - 1 Then Console.Write(" ")
        Next
        Console.WriteLine(")")
        Console.WriteLine()
    End Sub
End Module
' The example displays the following output:
'       Length of string: 2 (U+0061 U+0308)
'       
'       Length of string: 1 (U+00E4)

一般的な操作

Char構造体は、Charオブジェクトを比較し、現在のChar オブジェクトの値を別の型のオブジェクトに変換し、Char オブジェクトの Unicode カテゴリを決定するメソッドを提供します。

これを行うには	これらの `System.Char` メソッドを使用する
Char オブジェクトを比較する	CompareTo および Equals
コードポイントを文字列に変換する	ConvertFromUtf32 Runeの種類も参照してください。
Char オブジェクトまたはChar オブジェクトのサロゲートペアをコードポイントに変換する	1 文字の場合: Convert.ToInt32(Char) サロゲートペアまたは文字列内の文字の場合: Char.ConvertToUtf32 Runeの種類も参照してください。
文字の Unicode カテゴリを取得する	GetUnicodeCategory Rune.GetUnicodeCategory も参照してください。
数字、文字、句読点、制御文字など、特定の Unicode カテゴリに文字があるかどうかを判断する	IsControl、 IsDigit、 IsHighSurrogate、 IsLetter、 IsLetterOrDigit、 IsLower、 IsLowSurrogate、 IsNumber、 IsPunctuation、 IsSeparator、 IsSurrogate、 IsSurrogatePair、 IsSymbol、 IsUpper、および IsWhiteSpace Rune型の対応するメソッドも参照してください。
数値を表す Char オブジェクトを数値型に変換する	GetNumericValue Rune.GetNumericValue も参照してください。
文字列内の文字を Char オブジェクトに変換する	Parse および TryParse
Char オブジェクトを String オブジェクトに変換する	ToString
Char オブジェクトの大文字と小文字を変更する	ToLower、ToLowerInvariant、ToUpper、および ToUpperInvariant Rune型の対応するメソッドも参照してください。

Char 値と相互運用性

Unicode UTF-16 でエンコードされたコード単位として表されるマネージド Char 型がアンマネージコードに渡されると、相互運用マーシャラーは既定で文字セットを ANSI に変換します。 DllImportAttribute属性をプラットフォーム呼び出し宣言に適用し、StructLayoutAttribute属性を COM 相互運用宣言に適用して、マーシャリングされたChar型で使用する文字セットを制御できます。

フィールド

名前	説明
MaxValue	Charの可能な最大値を表します。このフィールドは定数です。
MinValue	Charの可能な限り小さい値を表します。このフィールドは定数です。

メソッド

名前	説明
CompareTo(Char)	このインスタンスを指定した Char オブジェクトと比較し、このインスタンスが、指定した Char オブジェクトと並べ替え順序で先行、フォロー、または同じ位置に表示されるかどうかを示します。
CompareTo(Object)	このインスタンスを指定したオブジェクトと比較し、このインスタンスが、指定した Objectと並べ替え順序で先行、フォロー、または同じ位置に表示されるかどうかを示します。
ConvertFromUtf32(Int32)	指定した Unicode コードポイントを UTF-16 でエンコードされた文字列に変換します。
ConvertToUtf32(Char, Char)	UTF-16 でエンコードされたサロゲートペアの値を Unicode コードポイントに変換します。
ConvertToUtf32(String, Int32)	文字列内の指定した位置にある UTF-16 エンコード文字またはサロゲートペアの値を Unicode コードポイントに変換します。
Equals(Char, StringComparison)	文字を UTF-16 コード単位として表します。
Equals(Char)	このインスタンスが指定した Char オブジェクトと等しいかどうかを示す値を返します。
Equals(Object)	このインスタンスが指定したオブジェクトと等しいかどうかを示す値を返します。
GetHashCode()	このインスタンスのハッシュコードを返します。
GetNumericValue(Char)	指定した数値 Unicode 文字を倍精度浮動小数点数に変換します。
GetNumericValue(String, Int32)	指定した文字列内の指定した位置にある数値 Unicode 文字を倍精度浮動小数点数に変換します。
GetTypeCode()	値型のTypeCodeのCharを返します。
GetUnicodeCategory(Char)	指定した Unicode 文字を、 UnicodeCategory 値のいずれかで識別されるグループに分類します。
GetUnicodeCategory(String, Int32)	指定した文字列内の指定した位置にある文字を、 UnicodeCategory 値のいずれかで識別されるグループに分類します。
IsAscii(Char)	`true`が ASCII 文字 ([U+0000..U+007F]) の場合は、`c`を返します。
IsAsciiDigit(Char)	文字が ASCII 数字として分類されているかどうかを示します。
IsAsciiHexDigit(Char)	文字が ASCII 16 進数として分類されるかどうかを示します。
IsAsciiHexDigitLower(Char)	文字が ASCII 小文字の 16 進数として分類されているかどうかを示します。
IsAsciiHexDigitUpper(Char)	文字が ASCII 大文字の 16 進数として分類されているかどうかを示します。
IsAsciiLetter(Char)	文字が ASCII 文字として分類されているかどうかを示します。
IsAsciiLetterLower(Char)	文字が小文字の ASCII 文字として分類されているかどうかを示します。
IsAsciiLetterOrDigit(Char)	文字が ASCII 文字または数字として分類されているかどうかを示します。
IsAsciiLetterUpper(Char)	文字が大文字の ASCII 文字として分類されているかどうかを示します。
IsBetween(Char, Char, Char)	文字が指定された包括範囲内にあるかどうかを示します。
IsControl(Char)	指定した Unicode 文字が制御文字として分類されるかどうかを示します。
IsControl(String, Int32)	指定した文字列内の指定した位置にある文字が制御文字として分類されるかどうかを示します。
IsDigit(Char)	指定した Unicode 文字が 10 進数字として分類されるかどうかを示します。
IsDigit(String, Int32)	指定した文字列内の指定した位置にある文字が 10 進数字として分類されるかどうかを示します。
IsHighSurrogate(Char)	指定した Char オブジェクトが上位サロゲートであるかどうかを示します。
IsHighSurrogate(String, Int32)	文字列内の指定した位置にある Char オブジェクトが上位サロゲートであるかどうかを示します。
IsLetter(Char)	指定した Unicode 文字が Unicode 文字として分類されているかどうかを示します。
IsLetter(String, Int32)	指定した文字列内の指定した位置にある文字が Unicode 文字として分類されるかどうかを示します。
IsLetterOrDigit(Char)	指定した Unicode 文字が文字または 10 進数字のどちらとして分類されるかを示します。
IsLetterOrDigit(String, Int32)	指定した文字列内の指定した位置にある文字が文字または 10 進数字として分類されるかどうかを示します。
IsLower(Char)	指定した Unicode 文字が小文字として分類されているかどうかを示します。
IsLower(String, Int32)	指定した文字列内の指定した位置にある文字が小文字として分類されるかどうかを示します。
IsLowSurrogate(Char)	指定した Char オブジェクトが低サロゲートであるかどうかを示します。
IsLowSurrogate(String, Int32)	文字列内の指定した位置にある Char オブジェクトが低サロゲートであるかどうかを示します。
IsNumber(Char)	指定した Unicode 文字が数値として分類されるかどうかを示します。
IsNumber(String, Int32)	指定した文字列内の指定した位置にある文字が数値として分類されるかどうかを示します。
IsPunctuation(Char)	指定した Unicode 文字が句読点として分類されているかどうかを示します。
IsPunctuation(String, Int32)	指定した文字列内の指定した位置にある文字が句読点として分類されるかどうかを示します。
IsSeparator(Char)	指定した Unicode 文字が区切り文字として分類されているかどうかを示します。
IsSeparator(String, Int32)	指定した文字列内の指定した位置にある文字を区切り文字として分類するかどうかを示します。
IsSurrogate(Char)	指定した文字にサロゲートコード単位があるかどうかを示します。
IsSurrogate(String, Int32)	指定した文字列内の指定した位置にある文字にサロゲートコード単位があるかどうかを示します。
IsSurrogatePair(Char, Char)	指定した 2 つの Char オブジェクトがサロゲートペアを形成するかどうかを示します。
IsSurrogatePair(String, Int32)	文字列内の指定した位置にある隣接する 2 つの Char オブジェクトがサロゲートペアを形成するかどうかを示します。
IsSymbol(Char)	指定した Unicode 文字がシンボル文字として分類されているかどうかを示します。
IsSymbol(String, Int32)	指定した文字列内の指定した位置にある文字がシンボル文字として分類されるかどうかを示します。
IsUpper(Char)	指定した Unicode 文字が大文字として分類されているかどうかを示します。
IsUpper(String, Int32)	指定した文字列内の指定した位置にある文字が大文字として分類されるかどうかを示します。
IsWhiteSpace(Char)	指定した Unicode 文字が空白として分類されるかどうかを示します。
IsWhiteSpace(String, Int32)	指定した文字列内の指定した位置にある文字が空白として分類されるかどうかを示します。
Parse(String)	指定した文字列の値を等価の Unicode 文字に変換します。
ToLower(Char, CultureInfo)	指定したカルチャ固有の書式情報を使用して、指定した Unicode 文字の値を小文字に変換します。
ToLower(Char)	Unicode 文字の値を小文字に変換します。
ToLowerInvariant(Char)	インバリアントカルチャの大文字と小文字の規則を使用して、Unicode 文字の値を小文字に変換します。
ToString()	このインスタンスの値を等価の文字列形式に変換します。
ToString(Char)	指定した Unicode 文字を等価の文字列形式に変換します。
ToString(IFormatProvider)	指定したカルチャ固有の書式情報を使用して、このインスタンスの値を同等の文字列形式に変換します。
ToUpper(Char, CultureInfo)	指定したカルチャ固有の書式情報を使用して、指定した Unicode 文字の値を大文字に変換します。
ToUpper(Char)	Unicode 文字の値を等価の大文字に変換します。
ToUpperInvariant(Char)	インバリアントカルチャの大文字と小文字の区別規則を使用して、Unicode 文字の値を大文字に変換します。
TryParse(String, Char)	指定した文字列の値を等価の Unicode 文字に変換します。戻りコードは、変換が成功したか失敗したかを示します。

明示的なインターフェイスの実装

名前	説明
IAdditionOperators<Char,Char,Char>.Addition(Char, Char)	合計を計算するために 2 つの値を加算します。
IAdditionOperators<Char,Char,Char>.CheckedAddition(Char, Char)	合計を計算するために 2 つの値を加算します。
IAdditiveIdentity<Char,Char>.AdditiveIdentity	現在の型の加法 ID を取得します。
IBinaryInteger<Char>.GetByteCount()	TryWriteLittleEndian(Span<Byte>, Int32)の一部として書き込まれるバイト数を取得します。
IBinaryInteger<Char>.GetShortestBitLength()	現在の値の最短 2 の補数表現の長さをビット単位で取得します。
IBinaryInteger<Char>.LeadingZeroCount(Char)	値の先頭の 0 ビットの数を計算します。
IBinaryInteger<Char>.Log10(Char)	文字を UTF-16 コード単位として表します。
IBinaryInteger<Char>.PopCount(Char)	値に設定されているビット数を計算します。
IBinaryInteger<Char>.RotateLeft(Char, Int32)	指定した量の値を左に回転します。
IBinaryInteger<Char>.RotateRight(Char, Int32)	指定した量の値を右に回転します。
IBinaryInteger<Char>.TrailingZeroCount(Char)	値の末尾の 0 ビットの数を計算します。
IBinaryInteger<Char>.TryReadBigEndian(ReadOnlySpan<Byte>, Boolean, Char)	文字を UTF-16 コード単位として表します。
IBinaryInteger<Char>.TryReadLittleEndian(ReadOnlySpan<Byte>, Boolean, Char)	文字を UTF-16 コード単位として表します。
IBinaryInteger<Char>.TryWriteBigEndian(Span<Byte>, Int32)	ビッグエンディアン形式の現在の値を特定のスパンに書き込もうとします。
IBinaryInteger<Char>.TryWriteLittleEndian(Span<Byte>, Int32)	現在の値をリトルエンディアン形式で特定のスパンに書き込もうとします。
IBinaryNumber<Char>.AllBitsSet	すべてのビットが設定されているバイナリ型のインスタンスを取得します。
IBinaryNumber<Char>.IsPow2(Char)	値が 2 の累乗であるかどうかを判断します。
IBinaryNumber<Char>.Log2(Char)	値の log2 を計算します。
IBitwiseOperators<Char,Char,Char>.BitwiseAnd(Char, Char)	2 つの値のビットごとの計算を行います。
IBitwiseOperators<Char,Char,Char>.BitwiseOr(Char, Char)	ビットごとの値または 2 つの値を計算します。
IBitwiseOperators<Char,Char,Char>.ExclusiveOr(Char, Char)	2 つの値の排他的または排他的な値を計算します。
IBitwiseOperators<Char,Char,Char>.OnesComplement(Char)	指定された値の 1 対補数表現を計算します。
IComparable.CompareTo(Object)	現在のインスタンスを同じ型の別のオブジェクトと比較し、現在のインスタンスが並べ替え順序で他のオブジェクトと同じ位置にあるかどうかを示す整数を返します。
IComparisonOperators<Char,Char,Boolean>.GreaterThan(Char, Char)	2 つの値を比較して、どちらが大きいかを判断します。
IComparisonOperators<Char,Char,Boolean>.GreaterThanOrEqual(Char, Char)	2 つの値を比較して、どちらが大きいか等しいかを判断します。
IComparisonOperators<Char,Char,Boolean>.LessThan(Char, Char)	2 つの値を比較して、どちらが小さいかを判断します。
IComparisonOperators<Char,Char,Boolean>.LessThanOrEqual(Char, Char)	2 つの値を比較して、次の値以下を決定します。
IConvertible.GetTypeCode()	このインスタンスの TypeCode を返します。
IConvertible.ToBoolean(IFormatProvider)	メモこの変換はサポートされていません。試みるとInvalidCastExceptionがスローされます。
IConvertible.ToByte(IFormatProvider)	このメンバーの説明については、 ToByte(IFormatProvider)を参照してください。
IConvertible.ToChar(IFormatProvider)	このメンバーの説明については、 ToChar(IFormatProvider)を参照してください。
IConvertible.ToDateTime(IFormatProvider)	メモこの変換はサポートされていません。試みるとInvalidCastExceptionがスローされます。
IConvertible.ToDecimal(IFormatProvider)	メモこの変換はサポートされていません。試みるとInvalidCastExceptionがスローされます。
IConvertible.ToDouble(IFormatProvider)	メモこの変換はサポートされていません。試みるとInvalidCastExceptionがスローされます。
IConvertible.ToInt16(IFormatProvider)	このメンバーの説明については、 ToInt16(IFormatProvider)を参照してください。
IConvertible.ToInt32(IFormatProvider)	このメンバーの説明については、 ToInt32(IFormatProvider)を参照してください。
IConvertible.ToInt64(IFormatProvider)	このメンバーの説明については、 ToInt64(IFormatProvider)を参照してください。
IConvertible.ToSByte(IFormatProvider)	このメンバーの説明については、 ToSByte(IFormatProvider)を参照してください。
IConvertible.ToSingle(IFormatProvider)	メモこの変換はサポートされていません。試みるとInvalidCastExceptionがスローされます。
IConvertible.ToString(IFormatProvider)	指定したカルチャ固有の書式情報を使用して、このインスタンスの値を等価の文字列に変換します。
IConvertible.ToType(Type, IFormatProvider)	このメンバーの説明については、 ToType(Type, IFormatProvider)を参照してください。
IConvertible.ToUInt16(IFormatProvider)	このメンバーの説明については、 ToUInt16(IFormatProvider)を参照してください。
IConvertible.ToUInt32(IFormatProvider)	このメンバーの説明については、 ToUInt32(IFormatProvider)を参照してください。
IConvertible.ToUInt64(IFormatProvider)	このメンバーの説明については、 ToUInt64(IFormatProvider)を参照してください。
IDecrementOperators<Char>.CheckedDecrement(Char)	値をデクリメントします。
IDecrementOperators<Char>.Decrement(Char)	値をデクリメントします。
IDivisionOperators<Char,Char,Char>.Division(Char, Char)	1 つの値を別の値で除算して商を計算します。
IEqualityOperators<Char,Char,Boolean>.Equality(Char, Char)	2 つの値を比較して等価性を判断します。
IEqualityOperators<Char,Char,Boolean>.Inequality(Char, Char)	2 つの値を比較して、不等値を判断します。
IFormattable.ToString(String, IFormatProvider)	指定した形式を使用して、現在のインスタンスの値を書式設定します。
IIncrementOperators<Char>.CheckedIncrement(Char)	値をインクリメントします。
IIncrementOperators<Char>.Increment(Char)	値をインクリメントします。
IMinMaxValue<Char>.MaxValue	現在の型の最大値を取得します。
IMinMaxValue<Char>.MinValue	現在の型の最小値を取得します。
IModulusOperators<Char,Char,Char>.Modulus(Char, Char)	2 つの値を除算して、剰余または剰余を計算します。
IMultiplicativeIdentity<Char,Char>.MultiplicativeIdentity	現在の型の乗法 ID を取得します。
IMultiplyOperators<Char,Char,Char>.CheckedMultiply(Char, Char)	2 つの値を乗算して積を計算します。
IMultiplyOperators<Char,Char,Char>.Multiply(Char, Char)	2 つの値を乗算して積を計算します。
INumberBase<Char>.Abs(Char)	値の絶対を計算します。
INumberBase<Char>.IsCanonical(Char)	値が正規表現内にあるかどうかを判断します。
INumberBase<Char>.IsComplexNumber(Char)	値が複素数を表すかどうかを判断します。
INumberBase<Char>.IsEvenInteger(Char)	値が偶数の整数を表すかどうかを判断します。
INumberBase<Char>.IsFinite(Char)	値が有限かどうかを判断します。
INumberBase<Char>.IsImaginaryNumber(Char)	値が純粋な虚数を表すかどうかを判断します。
INumberBase<Char>.IsInfinity(Char)	値が無限かどうかを判断します。
INumberBase<Char>.IsInteger(Char)	値が整数を表すかどうかを判断します。
INumberBase<Char>.IsNaN(Char)	値が NaN かどうかを判断します。
INumberBase<Char>.IsNegative(Char)	値が負の値かどうかを判断します。
INumberBase<Char>.IsNegativeInfinity(Char)	値が負の無限大かどうかを判断します。
INumberBase<Char>.IsNormal(Char)	値が正常かどうかを判断します。
INumberBase<Char>.IsOddInteger(Char)	値が奇数の整数を表すかどうかを判断します。
INumberBase<Char>.IsPositive(Char)	値が正かどうかを判断します。
INumberBase<Char>.IsPositiveInfinity(Char)	値が正の無限大かどうかを判断します。
INumberBase<Char>.IsRealNumber(Char)	値が実数を表すかどうかを判断します。
INumberBase<Char>.IsSubnormal(Char)	値が非正規かどうかを判断します。
INumberBase<Char>.IsZero(Char)	値が 0 かどうかを判断します。
INumberBase<Char>.MaxMagnitude(Char, Char)	2 つの値を、より大きいコンピューティングと比較します。
INumberBase<Char>.MaxMagnitudeNumber(Char, Char)	2 つの値を比較して、大きさが大きい計算を行い、入力が `NaN`場合はもう一方の値を返します。
INumberBase<Char>.MinMagnitude(Char, Char)	2 つの値を比較して計算します。計算の方が少なくなります。
INumberBase<Char>.MinMagnitudeNumber(Char, Char)	2 つの値を比較して、大きさが小さい計算を行い、入力が `NaN`場合はもう一方の値を返します。
INumberBase<Char>.MultiplyAddEstimate(Char, Char, Char)	(`left` * `right`) + `addend`の推定値を計算します。
INumberBase<Char>.One	型の `1` 値を取得します。
INumberBase<Char>.Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	文字のスパンを値に解析します。
INumberBase<Char>.Parse(String, NumberStyles, IFormatProvider)	文字列を値に解析します。
INumberBase<Char>.Radix	型の基数 (底) を取得します。
INumberBase<Char>.TryConvertFromChecked<TOther>(TOther, Char)	文字を UTF-16 コード単位として表します。
INumberBase<Char>.TryConvertFromSaturating<TOther>(TOther, Char)	文字を UTF-16 コード単位として表します。
INumberBase<Char>.TryConvertFromTruncating<TOther>(TOther, Char)	文字を UTF-16 コード単位として表します。
INumberBase<Char>.TryConvertToChecked<TOther>(Char, TOther)	現在の型のインスタンスを別の型に変換しようと試み、現在の型の表現可能な範囲外の値に対してオーバーフロー例外をスローします。
INumberBase<Char>.TryConvertToSaturating<TOther>(Char, TOther)	現在の型のインスタンスを別の型に変換しようとします。現在の型の表現可能な範囲外の値が飽和状態になります。
INumberBase<Char>.TryConvertToTruncating<TOther>(Char, TOther)	現在の型のインスタンスを別の型に変換し、現在の型の表現可能な範囲外の値を切り捨てようとします。
INumberBase<Char>.TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Char)	文字を UTF-16 コード単位として表します。
INumberBase<Char>.TryParse(String, NumberStyles, IFormatProvider, Char)	文字を UTF-16 コード単位として表します。
INumberBase<Char>.Zero	型の `0` 値を取得します。
IParsable<Char>.Parse(String, IFormatProvider)	文字列を値に解析します。
IParsable<Char>.TryParse(String, IFormatProvider, Char)	文字を UTF-16 コード単位として表します。
IShiftOperators<Char,Int32,Char>.LeftShift(Char, Int32)	指定した量の値を左にシフトします。
IShiftOperators<Char,Int32,Char>.RightShift(Char, Int32)	指定した量で値を右にシフトします。
IShiftOperators<Char,Int32,Char>.UnsignedRightShift(Char, Int32)	指定した量で値を右にシフトします。
ISpanFormattable.TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	現在のインスタンスの値を指定された文字スパンに書式設定しようとします。
ISpanParsable<Char>.Parse(ReadOnlySpan<Char>, IFormatProvider)	文字のスパンを値に解析します。
ISpanParsable<Char>.TryParse(ReadOnlySpan<Char>, IFormatProvider, Char)	文字を UTF-16 コード単位として表します。
ISubtractionOperators<Char,Char,Char>.CheckedSubtraction(Char, Char)	2 つの値を減算して差を計算します。
ISubtractionOperators<Char,Char,Char>.Subtraction(Char, Char)	2 つの値を減算して差を計算します。
IUnaryNegationOperators<Char,Char>.CheckedUnaryNegation(Char)	値のチェックされた単項否定を計算します。
IUnaryNegationOperators<Char,Char>.UnaryNegation(Char)	値の単項否定を計算します。
IUnaryPlusOperators<Char,Char>.UnaryPlus(Char)	値の単項プラスを計算します。
IUtf8SpanFormattable.TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider)	現在のインスタンスの値を UTF-8 として指定されたバイトスパンに書式設定しようとします。
IUtf8SpanParsable<Char>.Parse(ReadOnlySpan<Byte>, IFormatProvider)	文字を UTF-16 コード単位として表します。
IUtf8SpanParsable<Char>.TryParse(ReadOnlySpan<Byte>, IFormatProvider, Char)	文字を UTF-16 コード単位として表します。

適用対象

スレッドセーフ

この型のすべてのメンバーはスレッドセーフです。インスタンスの状態を変更するように見えるメンバーは、実際には新しい値で初期化された新しいインスタンスを返します。他の型と同様に、この型のインスタンスを含む共有変数の読み取りと書き込みは、スレッドセーフを保証するためにロックによって保護する必要があります。

こちらもご覧ください

フィードバック

このページはお役に立ちましたか?