「C#」はMediaWiki上の制約から、この項目が表示されます。プログラミング言語については「C Sharp」をご覧ください。

「C」のその他の用法については「C (曖昧さ回避)」をご覧ください。

Cは、ラテン文字（アルファベット）の3番目の文字。小文字は c 。ギリシア文字のΓ（ガンマ）に由来し、キリル文字のГは同系である。

キリル文字のСは別字で、ラテン文字のSに相当する文字である。

大文字、小文字とも半円形ないし不完全な円である。

フラクトゥールでは${\displaystyle {\mathfrak {C\ c}}}$

• ポーランド語、チェコ語、スロバキア語、スロベニア語などのスラヴ系言語、バルト語派に分類されるラトビア語、リトアニア語、その他ハンガリー語やアルバニア語など、ラテン文字を用いる東欧の言語の多くでは、c は後続音の如何にかかわらず、常に [ts] 音を表す。ポーランド人ルドヴィコ・ザメンホフの考案によるエスペラントもまた同様である。

  （例） ハンガリー語: cukor ［ツコル］ 「砂糖」

• また中国語のピンインにおいては、“息を出さない「ツ」音” [ts] を z と書くのに対して、“息を強く出す「ツ」音” [tsʰ] を c と表している。

  （例） 中国語: cānkǎo 参考 ［ツァンカオ］ 「参考にする」

• 東欧以外のいくつかの言語では c を [ʧ] の音標とするものがある。インドネシア語やマレー語はその代表である。

  （例） インドネシア語: cokelat ［チョクラッ］ 「チョコレート」

• トルコ語や、トルコ語に倣って正書法を定めたアゼルバイジャン語などでは、c は [dʒ] （ヂャ行のような子音）を表し、[ʧ] にはセディーユ付きの ç が当てられている。

  （例） トルコ語: cuma ［ヂュマー］ 「金曜日」

• 国際音声記号では、[c] は 無声硬口蓋閉鎖音を表す。
• ラテン文字による正書法のない言語などで音素寄りの音標文字としてラテン文字を使う場合は、c は [c] や [ʧ] の音に当てることが多い。主要な例としてサンスクリットがある。また日本人になじみの深い例として、アイヌ語のラテン文字表記を挙げることができる。

（例） サンスクリット: candraḥ ［チャンドラ］ 「月」、アイヌ語: cise ［チセ］ 「家」

• ズールー語、コサ語では吸着音の一種、歯吸着音[ǀ]を表す。

• 各種ダイアクリティカルマークの付いた c については、#関連項目を参照。
• 二重音字としては、ゲルマン系の言語で ck [k] が広く定着しているほか、多くの言語で ch が様々に使われている。 後者については ch を参照のこと。
• 国際音声記号で用いる ɔ や ɕ については、それぞれの項目を参照。

• 百を意味する数字。語源はラテン語で「百」を意味するcentum。ないしその派生語の略。
  • 1/100 を表すSI接頭辞センチ（小文字）。
  • ¢は英語ではセントと読み、基本通貨単位（ユーロやドルなど）の1/100を表す単位として多くの国で使われる（国によって呼び名は異なる）。
  • ローマ数字の百。
• 十二を意味する数字。十六進法や二十進法など、十三進法以上(参照: 位取り記数法#Nが十を超過)において十二（十進法の12）を一桁で表すために用いられる。
• circa (c.)　 通例、年代と共に用いて、およそ、約、...の頃の意。 「c.1162–1227」は、1162年頃生まれ・1227年没（正確）。
• 炭素の元素記号。
• 電荷の単位クーロンのシンボル。
• 温度を示すセルシウス度（摂氏）で用いられる記号（℃）。
• 数学では一般に既知の数、集合、行列等を示す、A, Bに次ぐ文字として用いられる。
• 大文字太字の Cは、数学において複素数 (complex number) 全体の集合を表す。
• 中心化群 C_G(S)
• 関数の滑らかさ C^k
• 定数 (constant) を表す。特に積分定数を表す時は通例大文字。
• _nC_m は組合せ (combination) の総数。
• 対称操作のひとつである回転を表現する記号。具体的な使用例は分子対称性を参照。
• 実数連続体の基数。
• 光速度（celeritas）を表す（小文字）。
• 自然科学では熱容量・電気容量（capasity、大文字だが比熱容量を表す際は小文字）、濃度(concentration)、光度 （カンデラ:candela）を示す文字に用いる。電気容量を表すことから、回路素子のコンデンサ (condenser, capacitor) を表す際にも用いる
• 加熱を示すときに用いられる場合がある。加熱を表すフランス語「Chauffage」の略。
• トランジスタの端子の1つ。コレクタ (collector)
• CPUのコア(core)のこと。
• C言語。プログラミング言語の1つ。ここから派生した言語であるC++と組み合わせてC/C++と表記されることもある。
• 虫歯を表す。また C1 - C4 （CはCariesの頭文字。）でその進行度を表す。
• 文法で、補語 (complement)、可算名詞 (countable) の略号。
• 音楽で用いられる拍子の1つ、4 分の 4拍子の記号は大文字の C に似ているが、起源的に関係がない。
• カラー印刷などで使われる基本色 YMC, YMCK の中のシアン (Cyan)。
• 音楽で用いられる音名の1つ（英米式、ツェー（独式））。イタリア式で「do」（ド）、日本式では「ハ」に相当。 → ハ (音名)
  • 音階の1番目の音であることから、日本の音楽・芸能関係者の間で1を表す隠語として使われる。例：C（ツェー）万=1万（円）
• 写真の印画紙の面種が光沢仕上げ (crystal) であることを意味する。対する絹目はS (silk) で示す。
• 視力検査で用いられるランドルト環は、Cを基にしている。
• ケッペンの気候区分の温帯を表すC
• マクロ経済学で、Cは消費 (consumption)を表す。また、cは限界消費性向を表す。

• 野球で捕手（キャッチャー、英:Catcher）を表す略称。
• サッカーで主将（キャプテン、英:captain）を表す略称。キャプテンマークなどに「C」と表示。
• アメリカンフットボールでセンター。
• バスケットボールでセンター。
• 大文字のCを丸で囲んだ著作権マークは著作権 (Copyright) を表す記号。マルC。「©」
• 鉄道の駅ナンバリングにおける路線記号。
  • 東京メトロ千代田線 (Chiyoda)
  • 富山地方鉄道富山軌道線・富山港線 (Chihō)
  • JR草津線
  • Osaka Metro中央線・近鉄けいはんな線 (Chūō)
  • JR境線
• 体操競技の技の難度の1つ。現在はB難度の上、D難度の下。「ウルトラC」という言葉は、これに由来する（この言葉の生まれた当時は、3ランク制でC難度が最高だった）。
• 日本国有鉄道の機関車で、動軸が3軸の形式に付される記号。C62、EC40など。
• 日本で電車の用途を表す記号で、運転台付きの車両（制御車）のこと。電動車、付随車を表す記号と組み合わせて、Mc、Tcのように表される。
• 創造 (creation) の頭文字。多くの日本企業で社名などに用いられている。
• 古代ローマ人の個人名ガイウス (Gaius) の略。
• 日本のプロ野球球団広島東洋カープ (Carp) の略号。
• Jリーグのクラブのセレッソ大阪 (Cerezo) 。
  • また、中央大学（陸上部・野球部）、智辯学園（高校野球部、高校陸上部、高校野球部、高校陸上部、和歌山高校野球部、和歌山高校野球部等）及び中京大学附属中京高等学校（陸上部・野球部）等の教育機関でも略号として使われている。
• 軍用航空機の形式で輸送機を表す記号。
• 民間航空機の登録番号（レジスタ）における国籍表示でカナダを表す。
• 人名の敬称「ちゃん」を表す。紙媒体ではマルC（©）、WWWや電子メールでは全角小文字のC（ｃ）が主に使われる。1990年代後半から日本語コミュニティにおいて10代前半を中心に流行（同様に、「くん」はK）。
• （古）男女関係の進行段階で、肉体関係 (H)。
• 欧州の自動車のカテゴリー、全長を基準に設定されている記号。Cセグメント。VW・ゴルフ、トヨタ・カローラ等が代表的な車種である。
• コンピュータエンターテインメントレーティング機構のレーティング表示において15歳以上対象を表す（2006年3月以降）。
• 「チャーリー」フォネティックコードの第三コード。
• シティグループのニューヨーク証券取引所証券コード（ティッカーシンボル）
• 旅客機の座席区分でビジネスクラスを表す。
• 「C調」は通常ハ長調を意味するが、「いい調子」をひっくり返したジャズ・音楽業界の隠語でもある。1960年代から一般に広まる。現在はほぼ死語。
  • 「C調気分で-」というフレーズの入った曲が存在する（サザンオールスターズ）。
• C○○（○○は数字）でコミックマーケット○○（通算○○回目のコミックマーケット）を示す。

• 「C」 - 中山美穂のデビュー曲。
• 「C」 (アルバム) - 中山美穂のデビューアルバム。
• C (Base Ball Bearのアルバム) - Base Ball Bearのアルバム。
• メルセデス・ベンツ・Cクラス。
• いすゞ自動車が発売していたバスシリーズ（CLM・CJM・CJAなど）。いすゞ・C系を参照。
• C (アニメ) - フジテレビジョン系列で放送のテレビアニメ。

フォネティックコード	モールス符号
Charlie	－・－・

信号旗	手旗信号	点字

ウィクショナリーに関連の辞書項目があります。

c、C

• Ć ć - アキュート・アクセント
• Ĉ ĉ - サーカムフレックス
• Ç ç - セディーユ
• Ċ ċ - ドット符号
• Č č - ハーチェク

表 話 編 歴 ラテン文字
Aa  Bb  Cc  Dd  Ee  Ff  Gg  Hh  Ii  Jj  Kk  Ll  Mm  Nn/Ññ  Oo  Pp  Qq  Rr  Ss  Tt  Uu  Vv  Ww  Xx  Yy  Zz  表 話 編 歴 ダイアクリティカルマーク付きC / Cから派生した文字 Ćć  Ĉĉ  Čč  Ċċ  Çç  Ḉḉ  Ȼȼ  Ƈƈ  ɕ 表 話 編 歴 Cとラテン文字/アラビア数字1文字の組み合わせ Ca  Cb  Cc  Cd  Ce  Cf  Cg  Ch  Ci  Cj  Ck  Cl  Cm  Cn  Co  Cp  Cq  Cr  Cs  Ct  Cu  Cv  Cw  Cx  Cy  Cz CA  CB  CC  CD  CE  CF  CG  CH  CI  CJ  CK  CL  CM  CN  CO  CP  CQ  CR  CS  CT  CU  CV  CW  CX  CY  CZ AC  BC  CC  DC  EC  FC  GC  HC  IC  JC  KC  LC  MC  NC  OC  PC  QC  RC  SC  TC  UC  VC  WC  XC  YC  ZC Ac  Bc  Cc  Dc  Ec  Fc  Gc  Hc  Ic  Jc  Kc  Lc  Mc  Nc  Oc  Pc  Qc  Rc  Sc  Tc  Uc  Vc  Wc  Xc  Yc  Zc C0  C1  C2  C3  C4  C5  C6  C7  C8  C9    —   0C  1C  2C  3C  4C  5C  6C  7C  8C  9C 一覧（文字-文字(en) / 文字-数字(en) / 数字-文字(en)）
一覧 基本26文字 ダイアクリティカルマーク 約物 ローマ数字 歴史 古文書 アルファベット ISO/IEC 646 Unicode カテゴリ

この項目では、プログラミング言語について説明しています。音名のC♯については「嬰ハ」をご覧ください。

C#

C#のロゴ
パラダイム	構造化プログラミング、命令型プログラミング、オブジェクト指向プログラミング、イベント駆動型プログラミング、関数型プログラミング、ジェネリックプログラミング、リフレクション、クラスベース、正格プログラミング、マルチパラダイムプログラミング
登場時期	2000年 (25年前) (2000)
設計者	マイクロソフト（アンダース・ヘルスバーグ率いるチーム）
開発者	マイクロソフト
最新リリース	13.0/ 2024年11月12日 (2か月前) (2024-11-12)[a 1]
型付け	強い静的型付け（4.0から動的型導入）
主な処理系	CLR, Mono
影響を受けた言語	C++、C言語、Java、Delphi、Modula-3、Cω、Eiffel、F Sharp、Haskell、Icon、J Sharp、Microsoft Visual J++、Object Pascal、Rust、ML、Visual Basic
影響を与えた言語	D言語, F#, Java, Nemerle, Vala, TypeScript
プラットフォーム	Windows, macOS, Linuxなど
ライセンス	Apacheライセンス (Roslyn)
ウェブサイト	docs.microsoft.com/ja-jp/dotnet/csharp/
拡張子	cs、csx
テンプレートを表示

プログラミング言語

>>他のプログラミング言語

■カテゴリ / ■テンプレート

C#（シーシャープ）は、マイクロソフトが開発した、汎用のマルチパラダイムプログラミング言語である。C#は、Javaに似た構文を持ち、C++に比べて扱いやすく、プログラムの記述量も少なくて済む。また、C#は、Windowsの.NET Framework上で動作することを前提として開発された言語であるが、2023年現在はクロスプラットフォームな.NETランタイム上で動作する。デスクトップ・モバイルを含むアプリケーション開発や、ASP.NETをはじめとするWebサービスの開発フレームワーク、ゲームエンジンのUnityでの採用事例などもある。

開発にはボーランドのTurbo PascalやDelphiを開発したアンダース・ヘルスバーグを筆頭として多数のDelphi開発陣が参加している。 構文はC系言語（C言語、C++、Javaなど）の影響を受けており、その他の要素には、以前、ヘルスバーグが所属していたボーランド設計のDelphiの影響が見受けられる。また、主要言語へのasync/await構文や、ヘルスバーグが言語設計に関わるTypeScriptでのジェネリクス採用など、他言語への影響も見られる。

C#は共通言語基盤（共通言語ランタイムなど）が解釈する共通中間言語にコンパイルされて実行される。

また、C#はマルチパラダイムをサポートする汎用高レベルプログラミング言語で、静的型付け、タイプセーフ、スコープ、命令型、宣言型、関数型、汎用型、オブジェクト指向（クラスベース）、コンポーネント指向のプログラミング分野を含んでいる。他にも自動ボックス化、デリゲート、 プロパティ、インデクサ、カスタム属性、ポインタ演算操作、構造体（値型オブジェクト）、多次元配列、可変長引数、async/await構文、null安全などの機能を持つ。また、Javaと同様に大規模ライブラリ、プロセッサ・アーキテクチャに依存しない実行形態、ガベージコレクション、JITコンパイルによる実行の高速化、AOTコンパイラによる高速実行、などが実現されている（もっともこれらはC#の機能というより.NET によるものである）。

共通言語基盤 (CLI) といった周辺技術も含め、マイクロソフトのフレームワークである「.NET」の一部である。また、以前のVisual J++で「非互換なJava」をJavaに持ち込もうとしたマイクロソフトとは異なり、その多くの^{[注釈 1]}仕様を積極的に公開し、標準化機構に託して自由な利用を許す^{[注釈 2]}など、同社の姿勢の変化があらわれている。

.NET構想における中心的な開発言語であり、XML WebサービスやASP.NETの記述にも使用される。他の.NET系の言語でも記述可能だが、.NET APIはC#からの利用を第一に想定されており、他の.NET系言語（特に2023年以降新構文の追加なしと宣言されたVB.NET^{[a 2]}）では利用できない、あるいは将来的に利用できなくなる機能が存在する。

マイクロソフトの統合開発環境(Microsoft Visual Studio)では、Microsoft Visual C#がC#に対応している。また、Visual Studio Codeに専用のC#向け拡張（C# DevKit）を導入することでクロスプラットフォームで開発することが可能^{[a 3]}。

共通言語仕様のCLSによって、他のCLS準拠の言語（F#やVisual Basic .NETやVisual C++ (C++/CLI) など）と相互に連携することができる。

さまざまな意味において、基盤であるCLIの機能をもっとも反映している言語であるといえる。C#にある組み込み型のほとんどは、CLIフレームワークに実装されている値型と対応している。

しかし、C#の言語仕様はコンパイラのコード生成については何も言及していないため、CLRに対応しなければならないとか、共通中間言語 (CIL) などの特定のフォーマットのコードを生成しなければならないとかいうことは述べられていない。

そのため、理論的にはC++やFORTRANのように環境依存のマシン語を生成することも可能である。しかし、現在存在するすべてのC#コンパイラはCLIをターゲットにしている。

.NET 7.0以降で可能になった事前コンパイルの一種である「Native AOT」でデプロイすることで実行可能な環境依存のバイナリを出力することが可能である。しかしながらこの手法もCLIとランタイムを事前に各アーキテクチャ向けのバイナリに変換しているだけであり、CLIを経由することに変わりはない。^{[a 23]}

特殊な例としては、UnityのScripting Backendである「IL2CPP」^[8]や「Burst」^[9]がある。 IL2CPPはC#をコンパイルしたCILをさらにC++コードへと変換後、ネイティブバイナリへC++コンパイラによってコンパイルされる。BurstはC#をコンパイルしたCILをLLVMコンパイラによってネイティブバイナリへコンパイルするものである。

最新のC#ではHello Worldを下記の通りに1行で記述できる^{[a 24]}。

Console.WriteLine("Hello World!");

上記のコードは、コンパイラによって下記の様なコードに展開される。

using System;

namespace Wikipedia
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello World!");
        }
    }
}

次の言語機能によって実現されている。ただし、未対応の古いコンパイラを用いる場合は、省略できない。

• 最上位レベルのステートメント^{[a 25][注釈 4]}
• 暗黙的なusing^{[a 26][注釈 5][注釈 6]}

C#では、CやC++と比較してさまざまな制限や改良が加えられている。また、仕様の多くはC#言語というよりは、基盤である .NET そのものに依拠している。Javaで導入された制限および改良をC#でも同様に採用しているものが多いが、C#で新たに導入された改良がのちにJavaにも同様に採用されたものもある。その例を次に挙げる。

• 外のブロックで宣言した変数と同じ名前の変数を、内のブロックで再宣言（シャドウ）してはいけない。再宣言は便利なこともあれば、混乱や曖昧のもとと主張されることもあるが、C#では禁止されている。
• C#にはブール型boolが存在し、while文やif文のように条件をとるステートメントには、bool型の式を与えなければならない。C言語では、ブール型が無くint型（0を偽とし、非0を真とする）に兼用させた上、（ヌルポインタを偽とみなすこととするといろいろと便利だった、ということもあり）ポインタでもwhile文やif文に与える式にできる、という仕様としていた。これは便利なこともあったが、本来比較式を記述すべきところで誤って代入式を記述してもコンパイル適合となってしまうなど、ミスが見逃されることもあった。C#ではミスを防止するため^[要出典]に、そのような仕様ではなくブール型を独立させ、またブール型を厳密に要求する場所を多くしている。
• switch文に整数型あるいは整数型に準ずる型のみならず、文字列型stringを使用できる。caseラベルには、整数型あるいは整数型に準ずる型の定数のみならず、文字列リテラル（文字列定数）を使用できる。
  • C# 7.0 以降では caseラベルに複雑なパターンマッチングを行うことが可能で複雑な判定を簡易な記述で記載が可能。^{[b 9]}
• 組み込み型のサイズおよび内部表現が仕様で定められており、プラットフォームや処理系に依存しない。浮動小数点数はIEEE 754に準拠する^{[a 27]}。文字および文字列はUTF-16エンコーディングを採用する^{[a 28]}。
  • C# 9.0以降では CPUによってサイズの異なる整数型 nint/nuintが追加された ^{[b 10]}
  • C# 11.0 以降では文字列をUTF-8として扱う「UTF-8文字列リテラル」が追加された^{[a 29]}

• ポインタをサポートする。ポインタはunsafeスコープ内のみで使用することができ、適切な権限をもつプログラムのみがunsafeとマークされたコードを実行することができる。オブジェクトへのアクセスの大部分は管理された安全な参照によってなされ、大部分の算術演算はオーバフローのチェックがなされる。unsafeポインタは値型や文字列を指すことができる。セーフコードでは、必ずしもそうする必要はないものの、IntPtr型を通してポインタをやりとりすることができる。
• マネージドなメモリを明示的に解放する方法は存在せず、参照されなくなったメモリはガベージコレクタによって自動的に解放される。ガベージコレクタは、メモリの解放忘れによって起こるメモリリークを解消する。C#は、データベース接続のようなアンマネージドなリソースに対しても明示的に制御する方法を提供している。これはIDisposableインタフェースとusingステートメントまたはusing宣言によってなされる。

• グローバル変数やグローバルメソッドは存在しない。すべてのフィールドとメソッドはクラスあるいは構造体の一部として宣言されなければならない。

例えばC/C++のprintf()関数のように名前空間レベルに存在するフリー関数を定義することはできない。ほとんどの場合クラスおよび構造体は名前の衝突を避けるために名前空間に所属する。

• 名前空間は階層構造をもつ。つまり、名前空間は他の名前空間の中に宣言することができる。
• 組み込みの値型を含めたすべての型は、objectクラス (System.Object) の派生型である。つまりobjectクラスのもつすべてのプロパティやメソッドを継承する。例えば、すべての型はToString()メソッドをもつ。
• クラス (class) は参照型であり、構造体 (struct) および列挙型 (enum) は値型である。構造体はクラスよりも軽量で、C/C++との相互運用性に優れるが、派生型を定義することができない。
• クラスおよび構造体は複数のインタフェースを実装することができるが、多重継承はサポートされない。
• C#はC++に比べて型安全である。既定の暗黙変換は、整数の範囲を広げる変換や、派生クラスから基底クラスへの変換といった、安全な変換のみに限定される。これは、コンパイル時、JITコンパイル時、そして一部の動的なケースでは実行時に強制される。ブール型と整数型、列挙型と整数型、の間は暗黙変換はできない。暗黙変換をユーザー定義する際は、明示的にそのように指定しなければならない。これはC++のコンストラクタとは違った仕様である。
• C#は「Null安全」である。Null許容型、Null許容参照型を持ち、Null合体演算子などの構文・演算子を持つ。
• 列挙型のメンバーは、列挙型のスコープの中に置かれる。また、列挙型の定数名を取得することができる。さらに、列挙型の定数名から動的に定数値を得ることができる。
• アクセサの定義と利用を簡略化するためにプロパティ構文を利用できる。C++およびJavaにおけるカプセル化では、通例getter/setterアクセサとなるメンバー関数あるいはメソッドを定義して利用するが、C#ではプロパティ機能により、カプセル化を維持しつつ、あたかもフィールドを直接読み書きするような直感的な構文でオブジェクトの状態にアクセスすることができる。プロパティによってメンバーのアクセス制御やデータの正当性チェックを実行することができる。なお、イベントハンドラーに利用するデリゲートのカプセル化にはイベント構文 (event) が用意されている。
• ジェネリクス（総称型）の採用（C# 2.0以降）。C++のテンプレート、Javaのジェネリックスと異なりコンパイル後も型情報が保持される。また、Javaのジェネリクスと異なりプリミティブ型も型変数として使うことができる。

部分型 (Partial Type) が導入された^{[a 4]}。以下のようにクラスや構造体の宣言にpartial修飾子をつけることで、その宣言を分割することができる。

partial class MyClass { int a; }
partial class MyClass { int b; }

これは以下と同義である:

class MyClass { int a; int b; }

これによって、巨大なクラスを分割したり、自動生成されたコードを分離したりすることができる。partial 修飾子はすべての宣言につける必要がある。

^[10]

ジェネリクスが導入された^{[a 4]}。これは.NET Framework 2.0の機能である。クラス、構造体、インタフェース、デリゲート、メソッドに対して適用することができる。

.NETのGenericsはC++のテンプレート、あるいはJavaにおけるそれとも異なるもので、コンパイルによってではなく実行時にランタイムによって特殊化される。これによって異なる言語間の運用を可能にし、リフレクションによって型パラメーターに関する情報を取得することができる。また、where節によって型パラメーターに制約を与えることができる。一方、C++のように型パラメーターとして式を指定することはできない。なお、ジェネリックメソッドの呼び出し時に引数によって型パラメーターが推論できる場合、型パラメーターの指定は省略できる。 ^[11]

静的クラスが導入された^{[a 4]}。static属性をクラスの宣言につけることで、クラスはインスタンス化できなくなり、静的なメンバーしか持つことができなくなる。

^[10]

イテレータ#C# 2.0を参照。

^[12]

yieldキーワードによるコルーチンを使うことで、イテレータの生成を楽に実装できるようになった。

クロージャの機能を提供する匿名デリゲートが導入された。

Property Accessors プロパティのget もしくは setアクセサのどちらかにアクセス修飾子を指定することでアクセス制御が別個にできるようになった^{[a 4]}。次の例では、getアクセサはpublic、setアクセサはprivateである。

public class MyClass
{
  private string status = string.Empty;
  public string Status
  {
    get { return status; }
    private set { status = value; }
  }
}

^[13]

nullを保持できる値型、Nullableが導入された^{[a 4]}。

int? i = 512;
i = null;

int? j = i + 500; //jはnullとなる。nullとの演算の結果はnullになる。

int?はNullable<int>の糖衣構文である。また、nullを保持しているNull許容型のインスタンスをボックス化しようとすると、単に空参照 (null) に変換される^{[a 30]}。

int? x = null;
object o = x;
System.Console.WriteLine(o == null); //Trueが出力される

^[14]

また、null結合演算子 (??)が導入された。これは、nullでない最初の値を返す。

object obj1 = null;
object obj2 = new object();
object obj3 = new object();
return obj1 ?? obj2 ?? obj3; // obj2 を返す

この演算子は主にNullable型を非Nullable型に代入するときに使われる。

int? i = null;
int j = i ?? -1; // nullをint型に代入することはできない

• 匿名メソッド^[15]
• External Aliases/Namespace Aliases Qualifiers^[16]
• プラグマディレクティブ/C言語の様な固定長の配列表記Fix Size Buffers^[17]

var キーワードが導入され、型推論を利用したローカル変数の宣言ができるようになった^{[a 4]}。

var s = "foo";
// 上の文は右辺が string 型であるため、次のように解釈される:
string s = "foo";
// 以下に挙げる文は誤りである（コンパイルエラーとなる）:
var v; // 初期化式を欠いている (型を推論する対象が存在しない)
var v = null; // 型が推論できない (曖昧である)

拡張メソッド (extension method) が導入された^{[a 4]}。既存のクラスを継承して新たなクラスを定義することなく、新たなインスタンスメソッドを疑似的に追加定義することができる。具体的には、入れ子になっていない、非ジェネリックの静的クラス内に、this 修飾子をつけた、拡張メソッドを追加する対象の型の引数を最初に持つメソッドをまず定義する。これによって、通常の静的メソッドとしての呼び出しの他に、指定した型のインスタンスメソッドとしての呼び出しを行うことができるメソッドを作ることができる。以下に例を挙げる:

public static class StringUtil
{
  public static string Repeat(this string str, int count)
  {
    var array = new string[count];
    for (var i = 0; i < count; ++i) array[i] = str;
    return string.Concat(array);
  }
}

この例は、文字列（string 型のインスタンス）を指定した回数繰り返し連結したものを返すメソッド Repeat を、既存の string 型に追加している。このメソッドは、以下のように呼び出すことができる:

// 静的メソッドとしての呼び出し
StringUtil.Repeat("foo", 4);
// 拡張メソッドとしての呼び出し
"foo".Repeat(4);
// (どちらの例も "foofoofoofoo" を返す)

また、列挙型やインタフェースなど本来メソッドの実装を持ち得ない型に、見かけ上インスタンスメソッドを追加することも可能である。以下に例を挙げる:

public enum Way
{
  None, Left, Right, Up, Down
}

public static class EnumUtil
{
  public static Way Reverse(this Way src)
  {
    switch (src)
    {
      case Way.Left:  return Way.Right;
      case Way.Right: return Way.Left;
      case Way.Up:    return Way.Down;
      case Way.Down:  return Way.Up;
      default: return Way.None;
    }
  }
}

このメソッドは以下のように呼び出すことができる:

Way l = Way.Left;
Way r = l.Reverse(); // Way.Right

拡張メソッドは糖衣構文の一種であり、カプセル化の原則に違反するものではないが、必要な場合に限り注意して実装することがガイドラインとして推奨されている^{[a 31]}。

部分メソッドが導入された^{[a 4]}。部分型（partial 型）内で定義された private で、かつ戻り値が void のメソッドに partial 修飾子をつけることでメソッドの宣言と定義を分離させることができる。定義されていない部分メソッドは何も行わず、何らエラーを発生させることもない。例えば:

partial class Class
{
  partial void DebugOutput(string message);
  
  void Method()
  {
    DebugOutput("Some message");
    Console.WriteLine("Did something.");
  }
}

上のコードにおいて Method() を呼び出すと、Did something. と表示されるだけだが、ここで以下のコード:

partial class Class
{
  partial void DebugOutput(string message)
  {
    Console.Write("[DEBUG: {0}] ", message);
  }
}

を追加した上で Method() を呼び出すと、[DEBUG: Some message] Did something. と表示される。

ラムダ式が導入された^{[a 4]}。この名前はラムダ計算に由来する。

以下の匿名メソッド

// iを変数としてi+1を返すメソッド
delegate (int i) { return i + 1; }

は、ラムダ式を使って次のように記述できる:

(int i) => i + 1; /* 式形式のラムダ */
//或いは:
(int i) => { return i + 1; }; /* ステートメント形式のラムダ */

ラムダ式は匿名メソッドと同様に扱えるが、式形式のラムダがExpression<TDelegate>型として扱われた場合のみ匿名メソッドとして扱われず、コンパイラによって式木を構築するコードに変換される。匿名デリゲートが実行前にコンパイルされたCILを保持するのに対し、式木はCILに実行時コンパイル可能であるDOMのような式の木構造そのものを保持する。これはLINQクエリをSQLクエリなどに変換する際に役立つ。

以下は、3つの任意の名前の変数、整数、括弧、及び四則演算子のみで構成された式を逆ポーランド記法に変換する汎用的なコードである:

public static string ToRPN(Expression<Func<int, int, int, int>> expression)
{
  return Parse((BinaryExpression) expression.Body).TrimEnd(' ');
}

private static string Parse(BinaryExpression expr)
{
  string str = "";
  
  if (expr.Left is BinaryExpression)
  {
    str += Parse((BinaryExpression) expr.Left);
  }
  else if (expr.Left is ParameterExpression)
  {
    str += ((ParameterExpression) expr.Left).Name + " ";
  }
  else if (expr.Left is ConstantExpression)
  {
    str += ((ConstantExpression) expr.Left).Value + " ";
  }

  if (expr.Right is BinaryExpression)
  {
    str += Parse((BinaryExpression) expr.Right);
  }
  else if (expr.Right is ParameterExpression)
  {
    str += ((ParameterExpression) expr.Right).Name + " ";
  }
  else if (expr.Right is ConstantExpression)
  {
    str += ((ConstantExpression) expr.Right).Value + " ";
  }
  
  return str + expr.NodeType.ToString()
    .Replace("Add", "+")
    .Replace("Subtract", "-")
    .Replace("Multiply", "*")
    .Replace("Divide", "/")
    + " ";
}

// 呼び出し例:
ToRPN((x, y, z) => (x + 1) * ((y - 2) / z)); // "x 1 + y 2 - z / *" を返す

オブジェクトの初期化が式として簡潔に記述できるようになった。

var p = new Point { X = 640, Y = 480 };
// 上の文は次のように解釈される:
Point __p = new Point();
__p.X = 640;
__p.Y = 480;
Point p = __p;

また、コレクションの初期化も同様に簡潔に記述できるようになった。

var l = new List<int> {1, 2, 3};
var d = new Dictionary<string, int> {{"a", 1}, {"b", 2}, {"c", 3}};
// 上の文は次のように解釈される:
List<int> __l = new List<int>();
__l.Add(1);
__l.Add(2);
__l.Add(3);
List<int> l = __l;
Dictionary<string, int> __d = new Dictionary<string, int>();
__d.Add("a", 1);
__d.Add("b", 2);
__d.Add("c", 3);
Dictionary<string, int> d = __d;

但し、上のコードでは匿名の変数に便宜的に __p、__l、__d と命名している。実際はプログラマはこの変数にアクセスすることはできない。

プロパティをより簡潔に記述するための自動実装プロパティが導入された^{[a 4]}。プロパティの定義に get; set; と記述することで、プロパティの値を保持するための匿名のフィールド（プログラマは直接参照することはできない）と、そのフィールドにアクセスするためのアクセサが暗黙に定義される。また、C# 5.0 までは get;とset;のどちらか片方だけを記述することは出来なかったが、C# 6.0 からは get; のみが可能。以下のコード:

public int Value { get; set; }

は、以下のようなコードに相当する動作をする:

private int __value;
public int Value
{
  get { return __value; }
  set { __value = value; }
}

但し、上のコードでは匿名のフィールドに便宜的に __value と命名している。実際はプログラマはこのフィールドにアクセスすることはできない。

一時的に使用される型を簡単に定義するための匿名型が導入された^{[a 4]}。以下に例を挙げる:

new { Name = "John Doe", Age = 20 }

上の式は、以下の内容のクラスを暗黙に定義する。定義されたクラスは匿名であるが故にプログラマは参照できない。

public string Name { get; }
public int Age { get; }

同じ型、同じ名前のプロパティを同じ順序で並べた匿名型は同じであることが保証されている。即ち、以下のコード:

var her = new { Name = "Jane Doe", Age = 20 }
var him = new { Name = "John Doe", Age = 20 }

において、her.GetType() == him.GetType() は true である。

new キーワードを用いた配列の宣言の際、型を省略できるようになった。匿名型の配列を宣言する際に威力を発揮する。

var a = new[] {"foo", "bar", null};
// 上の文は次のように解釈される:
string[] a = new string[] {"foo", "bar", null};
// 以下の文:
var a = new[] {"foo", "bar", 123};
// は次のように解釈されることなく、誤りとなる:
object[] a = new object[] {"foo", "bar", 123};

LINQ をサポートするために、クエリ式が導入された^{[a 4]}。これは SQL の構文に類似しており、最終的に通常のメソッド呼び出しに変換されるものである。以下に例を示す:

var passedStudents =
  from s in students
  where s.MathScore + s.MusicScore + s.EnglishScore > 200
  select s.Name;

上のコードは以下のように変換される:

var passedStudents = students
  .Where(s => s.MathScore + s.MusicScore + s.EnglishScore > 200)
  .Select(s => s.Name);

C# 3.0で追加された構文の多くは式であるため、より巨大な式（当然クエリ式も含まれる）の一部として組み込むことができる。旧来複数の文に分けたり、作業用の変数を用意して記述していたコードを単独の式としてより簡潔に記述できる可能性がある。

出井秀行著の『実戦で役立つ C#プログラミングのイディオム/定石&パターン』（技術評論社、2017年）という書籍ではクエリ構文よりメソッド構文を推奨しており、クエリ構文ではLINQの全ての機能を使用できるわけではないこと、メソッド呼び出しは処理を連続して読める可読性があること、メソッド呼び出しであればMicrosoft Visual Studioの強力なインテリセンスが利用できることを理由に、著者はクエリ構文をほとんど使用していないと記している。

dynamicキーワードが導入され、動的型付け変数を定義できるようになった^{[a 4]}。dynamic型として宣言されたオブジェクトに対する操作のバインドは実行時まで遅延される。

// xはint型と推論される:
var x = 1; 
// yはdynamic型として扱われる:
dynamic y = 2; 

public dynamic GetValue(dynamic obj)
{
  // objにValueが定義されていなくとも、コンパイルエラーとはならない:
  return obj.Value;
}

VBやC++に実装されているオプション引数・名前付き引数が、C#でも利用できるようになった^{[a 4]}。

public void MethodA()
{
  // 第1引数と第2引数を指定、第3引数は未指定:
  Console.WriteLine("Ans: " + MethodB(1, 2));  // Ans: 3 … 1 + 2 + 0となっている

  // 第1引数と第3引数を指定、第2引数は未指定:
  Console.WriteLine("Ans: " + MethodB(A: 1, C: 3));  // Ans: 4 … 1 + 0 + 3となっている
}

// 引数が指定されなかった場合のデフォルト値を等号で結ぶ:
public int MethodB(int A = 0, int B = 0, int C = 0)
{
  return A + B + C;
}

ジェネリクスの型引数に対してin、out修飾子を指定することにより、ジェネリクスの共変性・反変性を指定できるようになった^{[a 4]}。

IEnumerable<string> x = new List<string> { "a", "b", "c" };
// IEnumerable<T>インターフェイスは型引数にout修飾子が指定されているため、共変である。
// したがって、C# 4.0では次の行はコンパイルエラーにならない
IEnumerable<object> y = x;

• 非同期処理 (async/await)^{[a 4]}
• 呼び出し元情報属性^{[a 4]}
• foreach の仕様変更

• 自動実装プロパティの初期化子^{[a 32]}
• get のみの自動実装プロパティおよびコンストラクタ代入^{[a 32]}
• 静的 using ディレクティブ^{[a 32]}
• インデックス初期化子^{[a 32]}
• catch/finally での await^{[a 32]}
• 例外フィルタ^{[a 32]}
• 式形式のメンバー (expression-bodied members)^{[a 32]}
• null条件演算子^{[a 32]}
• 文字列補間（テンプレート文字列）^{[a 32]}
• nameof 演算子^{[a 32]}
• #pragma
• コレクションの初期化子での拡張メソッド^{[a 32]}
• オーバーロード解決の改善^{[a 32]}

静的 using ディレクティブを利用することで、型名の指定無しに他クラスの静的メンバーの呼び出しを行えるようになった。利用するにはusing staticの後に完全修飾なクラス名を指定する。

using static System.Math;
// ↑ソースコードの上部で宣言
class Hogehoge {
    // System.Math.Pow() , System.Math.PI を修飾無しで呼び出す
    double area = Pow(radius, 2) * PI;
}

catchの後にwhenキーワードを使用することで、処理する例外を限定することができるようになった。

try {
    // ...
}
catch (AggregateException ex) when (ex.InnerException is ArgumentException) {
    // ...
}

• 出力変数宣言
• パターンマッチング (is 式/switch 文)
• タプル (タプル記法/分解/値の破棄)
• ローカル関数
• 数値リテラルの改善(桁セパレータ/バイナリリテラル)
• ref戻り値、ref変数
• 非同期戻り値型の汎用化
• Expression-bodied 機能の拡充(コンストラクタ/デストラクタ/get/set/add/remove)
• Throw 式

out引数で値を受け取る場合、その場所で変数宣言可能となった^{[a 33]}。

total += int.TryParse("123", out var num) ? num : 0;

is式の構文が拡張され、型の後ろに変数名を宣言できるようになった^{[a 33]}。 拡張されたis式はマッチした場合に宣言した変数にキャストした値を代入し、さらにtrueと評価される。 マッチしなかった場合はfalseと評価され、宣言した変数は未初期化状態となる。

void CheckAndSquare(object obj) {
    // objの型チェックと同時にnumに値を代入する。
    if (obj is int num && num >= 0) {
        num = num * num;
    }
    else {
        num = 0;
    }
    // if文の条件セクションは、ifの外側と同じスコープ
    Console.WriteLine(num);
}

switch文のマッチ方法が拡張され、caseラベルに従来の「定数パターン」に加え、新たに「型パターン」を指定できるようになった。 また、「型パターン」のcaseラベルでは、when句に条件を指定することができる。 「型パターン」を含むswitch文では、必ずしも条件が排他的でなくなったため、最初にマッチしたcaseラベルの処理が実行される。^{[a 34]}

void Decide(object obj) {
    switch (obj) {
        case int num when num < 0:
            Console.WriteLine($"{num}は負の数です。");
            break;
        case int num:
            Console.WriteLine($"{num}を二乗すると{num * num}です。");
            break;
        case "B":
            Console.WriteLine($"これはBです。");
            break;
        case string str when str.StartsWith("H"):
            Console.WriteLine($"{str}はHから始まる文字列です。");
            break;
        case string str:
            Console.WriteLine($"{str}は文字列です。");
            break;
        case null:
            Console.WriteLine($"nullです");
            break;
        default:
            Console.WriteLine("判別できませんでした");
            break;
    }
}

タプルのための軽量な構文が導入された^{[a 33]}。従来のSystem.Tupleクラスとは別に、System.ValueTuple構造体が新しく追加された。

2個以上の要素を持つタプルのための記法が導入された。 引数リストと同様の形式で、タプルを記述できる。

// タプル記法
(int, string) tuple = (123, "Apple");
Console.WriteLine($"{tuple.Item1}個の{tuple.Item2}");

多値戻り値を簡単に扱えるように、分解がサポートされた^{[a 33]}。

var tuple = (123, "Apple");
// 分解
(int quantity, string name) = tuple;
Console.WriteLine($"{quantity}個の{name}");

分解はタプルに限らない。Deconstruct()メソッドが定義されたクラスでも、分解を利用できる^{[a 33]}。

以下に、DateTime型に分解を導入する例を示す。

static class DateExt {
    public static void Deconstruct(this DateTime dateTime, out int year, out int month, out int day) {
        year = dateTime.Year;
        month = dateTime.Month;
        day = dateTime.Day;
    }
}

上記のコードでDateTime型にDeconstruct()拡張メソッドを定義し、

// 分解
(int year, int month, int day) = DateTime.Now;

のように左辺で3つの変数に値を受け取ることができる。

分解、out引数、パターンマッチングで、値の破棄を明示するために_が利用できるようになった。 破棄された値は、後で参照することはできない。

// 年と日は使わない
(_, int month, _) = DateTime.Now;

// 解析結果だけ取得し、変換された値は使わない
bool isNumeric = int.TryParse(str, out _);

switch (obj) {
    // string型で分岐するが、値は使わない
    case string _:
        // Do something.
        break;
}

refキーワードの使用方法が拡張された。これによって、安全な参照の使い道が広がった。

戻り値の型をrefで修飾することで、オブジェクトの参照を戻り値とすることができる。

// 二つの参照引数の内、値の大きいものの参照戻り値を返す
static ref int Max(ref int left, ref int right) {
    if (left >= right) {
        return ref left;
    }
    else {
        return ref right;
    }
}

変数の寿命は変わらないため、メソッド終了時に破棄されるローカル変数をref戻り値とすることはできない。

static int s_count = 1;

// メンバーの参照はref戻り値になる。
static ref int ReturnMember() {
    return ref s_count;
}
// ref引数はもちろんref戻り値になる。
static ref int ReturnRefParam(ref int something) {
    return ref something;
}
// ローカル変数をref戻り値とすることはできない。
// static ref int ReturnLocal() {
//     int x = 1;
//     return ref x;
// }

ローカル変数の型をrefで修飾することで、参照を代入することができる。

// 参照戻り値を参照変数で受け取る
ref int max = ref Max(ref x, ref y);
// limitとmaxは同じ値を参照する
ref int limit = ref max;

Mainメソッドの戻り値として、Task型、Task(int)型が認められた^{[a 35]}。

static Task Main()

static Task<int> Main()

型推論可能な場面では、defaultの型指定は省略可能となった^{[a 35]}。

int number = default;
string name = default;

C#7.2で追加された仕様は以下の通り^{[a 36][a 37]}。

値型におけるパフォーマンス向上を意図した複数の機能が追加された。

引数にinを指定することで、読み取り専用参照渡しを指定できる。 また、戻り値にref readonlyを指定することで、読み取り専用参照戻り値を指定できる。

これにより、構造体のコピーを避けると共に、意図しない値の変更を抑止できる。

構造体宣言時にreadonlyを指定することで、真の読み取り専用構造体を定義できる。 readonly構造体の全てのフィールドはreadonlyでなければならず、thisポインタも読み取り専用となる。

これにより、メンバーアクセス時の意図しない防御的コピーを抑止できる。

構造体宣言時にrefを指定することで、ヒープ領域へのコピーを防ぐ構造体がサポートされる。 ref構造体では、box化できない、配列を作成できない、型引数になることができない、など、ヒープ領域へのコピーを防ぐための厳しい制限がかかる。

この機能は、Span<T>のような構造体をサポートするために利用され、unsafe文脈以外でのstackallocの利用をも可能とする。

C#4.0で追加された名前付き引数が末尾以外でも利用できるようになった。

Hogehoge(name: "John", 17);

同一アセンブリ内、かつ、継承先からのアクセス許可を表すprivate protectedアクセス修飾子が追加された。

十六進リテラルの0x、二進リテラルの0bの直後のアンダースコアが認められた。

int bin = 0b_01_01;
int hex = 0x_AB_CD;

C#7.3では以下の仕様が追加された^{[a 38]}。

• ジェネリック型制約の種類の追加
  • System.Enum, System.Delegate
  • unmanaged (文脈キーワード)

unsafe class MyGenericsClass<T1,T2,T3> 
    where T1 : System.Enum
    where T2 : System.Delegate
    where T3 : unmanaged {

    public MyGenericsClass(T1 enum1, T1 enum2, T2 func, T3 unmanagedValue) {
        if (enum1.HasFlag(enum2)) {
            func.DynamicInvoke();
        }
        else {
            T3* ptr = &unmanagedValue;
        }
    }
}

• refローカル変数の再割り当て
• stackalloc初期化子
• Indexing movable fixed buffers
• カスタムfixedステートメント
• オーバーロード解決ルールの改善
• 出力変数宣言の利用箇所の追加

class MyOutVar {
    // メンバー変数初期化子やコンストラクタ初期化子で出力変数宣言が可能
    readonly int x = int.TryParse("123", out var number) ? number : -1;
}

• タプル同士の比較

(long, long) tuple = (1L, 2L);
// タプルのすべての要素間で == が比較可能
if (tuple == (1, 2)) { }
// 要素数が異なるタプル同士は比較できない。
//if (tuple == (1, 2, 3)) { }

• バッキングフィールドに対するAttribute指定

// C#7.2までは無効な指定(コンパイル自体は可能。無視される)
// C#7.3からはバッキングフィールドに対するAttribute指定と見なされる
[field: NonSerialized]
public int MyProperty { get; set; }

C# 8.0で追加された仕様は以下の通り。^{[a 39][18]}

参照型にnull許容性を指定できるようになった。参照型の型名に?を付加した場合にnull許容参照型となる。

参照型の型名に?を付加しない場合、null非許容参照型となる。

フロー解析レベルでのnull許容性チェックが行われる。null許容値型のNullable<T>のような新しい型は導入されない。

参照型のnull許容性は、null許容コンテキストによって有効、無効の切り替えが可能である。 C#7.3以前の互換性のために、既定では無効となっている。

• Nullable コンパイルオプション： プロジェクト全体でのnull許容コンテキストを指定する
• #nullable ディレクティブ： ソースコードの部分ごとにnull許容コンテキストを指定する
  • annotations オプション、warningsオプションにより、適用範囲を限定できる

null許容参照型の変数名の後に !を使用することで、フロー解析時の警告が免除される。

インタフェースのメンバーに既定の実装を指定できるようになった。また、インタフェースに静的メンバーを持つことができるようになった。

さらに、インタフェースのメンバーにアクセシビリティを指定できるようになった。

• 既定のアクセシビリティは、従来通り public となる。
• 実装があるインスタンスメンバーは、既定で virtual となり override可能である。
• 実装をoverrideさせないためにsealedを指定することができる。

switch式が追加された。 プロパティパターン、タプルパターン、位置指定パターンの追加により、再帰的なパターンマッチングが可能になった。

• switch式
• 再帰パターン
  • プロパティパターン
  • タプルパターン
  • 位置指定パターン

IAsyncEnumerable<T> インタフェースを返すことで、イテレータ構文と非同期構文の共存が可能になった。

async IAsyncEnumerable<int> EnumerateAsync() {
    await Task.Delay(100);
    yield return 1;
    await Task.Delay(100);
    yield return 2;
}

await foreachによって非同期ストリームを列挙する。

async void SpendAsync() {
    await foreach (var item in EnumerateAsync()) {
        Console.WriteLine(item);
    }
}

IndexとRangeを指定できる専用構文が追加された。

  Index a = 1; // new Index(1, fromEnd: false)
  Index b = ^1; // new Index(1, fromEnd: true)
  Range range = a..b; // new Range(start: a, end: b)

• 静的ローカル関数
• null結合代入演算子
• 構造体の読み取り専用メンバー
• using 宣言
• ref構造体のDispose
• ジェネリクスを含むアンマネージ型
• 式中のstackalloc
• 文字列補間のトークン順序の緩和

C# 9.0で追加された仕様は以下の通り。

^{[a 40]}

• レコード
• プロパティのinitアクセサ
• 最上位レベルステートメント
• パターンマッチングの拡張
• new式の型推論
• 条件演算子の型推論
• 共変戻り値
• GetEnumeratorの拡張メソッド対応
• 静的匿名関数
• ラムダ式引数の破棄
• ローカル関数への属性適用
• パフォーマンスと相互運用
  • ネイティブサイズの整数型(nint nuint型)
  • 関数ポインタ(delegate*型)
  • 変数初期化フラグの抑制
• コードジェネレータのサポート
  • モジュール初期化子
  • 部分メソッドの拡張

C# 10.0で追加された仕様は以下の通り。

^{[a 41]}

• レコード構造体
• 構造体型の機能強化
• 補間された文字列ハンドラー
• global using ディレクティブ
• ファイル スコープの名前空間の宣言
• 拡張プロパティのパターン
• ラムダ式の機能強化
• const 補間文字列を許可する
• レコードの型で ToString() を封印できる
• 限定代入の機能強化
• 同じ分解で代入と宣言の両方を許可する
• メソッドで AsyncMethodBuilder 属性を許可する
• CallerArgumentExpression 属性
• 拡張 #line pragma
• 警告ウェーブ 6

C# 11.0で追加された仕様は以下の通り^{[a 14][b 6]}。

エスケープなどの加工を施さない文字列を3個の二重引用符で括って表現できる様になった。未加工の文字リテラルとも呼ばれる。

string logMsg = """
	原因不明のエラーが発生しました。
	詳細はログファイル "C:\Logs\exception.log" を確認してください。
	""";

属性の型が型引数を持てる様になった。

// 属性
[AttributeUsage(AttributeTargets.Class, AllowMultiple = true, Inherited = true)]
public class ConverterContractAttribute<TFrom, TTo> : Attribute { }

// 使用例
[ConverterContract<byte, string>()]
[ConverterContract<sbyte, string>()]
[ConverterContract<short, string>()]
[ConverterContract<ushort, string>()]
[ConverterContract<int, string>()]
[ConverterContract<uint, string>()]
[ConverterContract<long, string>()]
[ConverterContract<ulong, string>()]
public class IntToStringConverter
{
	// ...
}

リストや配列に対するパターンマッチが可能になった^{[a 42][b 11]}。

int[] nums = new[] { 0, 1, 2, 3, 4, 5 };
if (nums is [ 0, 1, 2, .. ]) {
	Console.WriteLine("配列は 0, 1, 2 から始まります。");
} else {
	Console.WriteLine("配列は 0, 1, 2 から始まりません。");
}

また、Span<char>やReadOnlySpan<char>に対して文字列を用いたパターンマッチが可能になった。

bool CheckSignature(ReadOnlySpan<char> sig)
{
	return sig is "HOGE";
}

型引数に「数値型または数値型に類似している型」である事を示す制約を付け加える機能が導入された^{[a 43][b 12]}。また、それに呼応して下記の変更が行われた。

• 明示的な論理シフト演算子（>>>演算子）が追加された。
• シフト演算子の右側の引数の型に対する制限の撤廃され、int型以外の型を指定できる様になった。
• checked演算子のオーバーロードができる様になった。
• インターフェースのメソッドに対してstatic abstractキーワード（静的抽象）とstatic virtualキーワード（静的仮想）を指定できる様になった^{[a 44][a 45]}。
• インターフェース内に演算子を定義できる様になった。

ジェネリック型数値演算を用いた一例を下記に示す^{[a 46][a 47]}。

// 大抵の演算子インターフェイスは System.Numerics 内に実装されている。
using System.Numerics;

// 任意の型に対して加算を行う事ができる関数。
static T MyAdd<T>(T value1, T value2)
	where T: IAdditionOperators<T, T, T> // 加算が可能な型のみを受け付ける制約。
	=> value1 + value2; // + 演算子を使う事ができる。

// 上記の関数定義のみで、下記の様に加算演算が定義された型であれば、任意の型で呼び出す事ができる。
int    a = MyAdd(  123,   456); // 結果：579
ulong  b = MyAdd(111UL, 222UL); // 結果：333
double c = MyAdd( 1.5D,  2.1D); // 結果：3.6

• UTF-8 文字列リテラル
• 文字列補間式の改行
• ファイルローカル型
• 必須メンバー
• auto-default 構造体（構造体の未初期化のフィールド変数が自動的に既定値に初期化される）
• nameof のスコープ拡張
• IntPtr に別名 nint、UIntPtr に別名 nuint が付いた
• ref フィールド
• scoped ref 変数
• メソッドグループからデリゲートへの変換の改善
• 警告ウェーブ 7

C# 12.0で追加された仕様は以下の通り^{[a 17][b 7]}。

レコード型（record）以外のクラス（class）と構造体（struct）でプライマリコンストラクターが使えるようになった。

class Example(string message) 
{
    public string Message { get; } = message;
}

配列、コレクション、Span<T>などの初期化の記法が共通の記法（[]）で書けるようになった。

// Create an array:
int[] a = [1, 2, 3, 4, 5, 6, 7, 8];

// Create a list:
List<string> b = ["one", "two", "three"];

// Create a span
Span<char> c  = ['a', 'b', 'c', 'd', 'e', 'f', 'h', 'i'];

コレクション式で複数のコレクションをインライン展開できる新しい演算子（..）が追加された。

int[] row0 = [1, 2, 3];
int[] row1 = [4, 5, 6];
int[] row2 = [7, 8, 9];
// 1, 2, 3, 4, 5, 6, 7, 8, 9,
int[] single = [.. row0, .. row1, .. row2];