拡張メンバー

チャンピオン号: https://github.com/dotnet/csharplang/issues/8697

宣言

構文

class_body
    : '{' class_member_declaration* '}' ';'?
    | ';'
    ;

class_member_declaration
    : constant_declaration
    | field_declaration
    | method_declaration
    | property_declaration
    | event_declaration
    | indexer_declaration
    | operator_declaration
    | constructor_declaration
    | finalizer_declaration
    | static_constructor_declaration
    | type_declaration
    | extension_declaration // add
    ;

extension_declaration // add
    : 'extension' type_parameter_list? '(' receiver_parameter ')' type_parameter_constraints_clause* extension_body
    ;

extension_body // add
    : '{' extension_member_declaration* '}' ';'?
    ;

extension_member_declaration // add
    : method_declaration
    | property_declaration
    | operator_declaration
    ;

receiver_parameter // add
    : attributes? parameter_modifiers? type identifier?
    ;

拡張宣言は、非ジェネリックで入れ子になっていない静的クラスでのみ宣言する必要があります。
extensionという名前を付ける型のエラーです。

スコーピング規則

拡張宣言の型パラメーターとレシーバー パラメーターは、拡張宣言の本体内のスコープ内にあります。 nameof式内を除き、静的メンバー内からレシーバー パラメーターを参照するのはエラーです。 拡張宣言の型パラメーターまたはレシーバー パラメーターと同じ名前を持つ型パラメーターまたはパラメーター (およびメンバー本体内のローカル変数とローカル関数) を宣言すると、エラーになります。

public static class E
{
    extension<T>(T[] ts)
    {
        public bool M1(T t) => ts.Contains(t);        // `T` and `ts` are in scope
        public static bool M2(T t) => ts.Contains(t); // Error: Cannot refer to `ts` from static context
        public void M3(int T, string ts) { }          // Error: Cannot reuse names `T` and `ts`
        public void M4<T, ts>(string s) { }           // Error: Cannot reuse names `T` and `ts`
    }
}

メンバー自体が、囲む拡張宣言の型パラメーターまたはレシーバー パラメーターと同じ名前を持つことはエラーではありません。 メンバー名は、拡張宣言内から単純な名前検索に直接見つかりません。したがって、lookup はメンバーではなく、その名前の型パラメーターまたはレシーバー パラメーターを検索します。

メンバーは、外側の静的クラスで直接宣言されている静的メソッドを生み出し、単純な名前検索を使用して見つけることができます。ただし、同じ名前の拡張宣言型パラメーターまたはレシーバー パラメーターが最初に見つかります。

public static class E
{
    extension<T>(T[] ts)
    {
        public void T() { M(ts); } // Generated static method M<T>(T[]) is found
        public void M() { T(ts); } // Error: T is a type parameter
    }
}

拡張コンテナーとしての静的クラス

拡張機能は、現在の拡張メソッドと同様に、最上位レベルの非ジェネリック静的クラス内で宣言されているため、従来の拡張メソッドと非拡張静的メンバーと共存できます。

public static class Enumerable
{
    // New extension declaration
    extension(IEnumerable source) { ... }
    
    // Classic extension method
    public static IEnumerable<TResult> Cast<TResult>(this IEnumerable source) { ... }
    
    // Non-extension member
    public static IEnumerable<int> Range(int start, int count) { ... } 
}

拡張宣言

拡張宣言は匿名であり、関連付けられている型パラメーターと制約に続いて拡張メンバー宣言のセットを 受け取る仕様 を提供します。 レシーバーの指定は、パラメーターの形式で指定することも、静的拡張メンバーのみが宣言されている場合は型にすることができます。

public static class Enumerable
{
    extension(IEnumerable source) // extension members for IEnumerable
    {
        public bool IsEmpty { get { ... } }
    }
    extension<TSource>(IEnumerable<TSource> source) // extension members for IEnumerable<TSource>
    {
        public IEnumerable<T> Where(Func<TSource, bool> predicate) { ... }
        public IEnumerable<TResult> Select<TResult>(Func<TSource, TResult> selector) { ... }
    }
    extension<TElement>(IEnumerable<TElement>) // static extension members for IEnumerable<TElement>
        where TElement : INumber<TElement>
    {
        public static IEnumerable<TElement> operator +(IEnumerable<TElement> first, IEnumerable<TElement> second) { ... }
    }
}

レシーバー仕様の型は レシーバー型 と呼ばれ、パラメーター名 (存在する場合) は レシーバー パラメーターと呼ばれます。

レシーバー パラメーターに名前が付けられている場合、レシーバー型は静的にできない可能性があります。
&lt;c0 originalTag="ept" originalId="1"&gt;レシーバー パラメーター</c0>は、名前が指定されていない場合は修飾子を持てません。また、それ以外の場合は、以下に示す refness 修飾子と &lt;c1 originalTag="ph" originalId="1" /&gt; のみを使用できます。
レシーバー パラメーターには、従来の拡張メソッドの最初のパラメーターと同じ制限があります。
[EnumeratorCancellation]属性は、レシーバー パラメーターに指定されている場合は無視されます。

拡張メンバー

拡張メンバー宣言は、対応するインスタンスおよびクラスおよび構造体宣言の静的メンバーと構文的には同じです (コンストラクターを除く)。 インスタンス メンバーは、レシーバー パラメーター名を持つレシーバーを参照します。

public static class Enumerable
{
    extension(IEnumerable source)
    {
        // 'source' refers to receiver
        public bool IsEmpty => !source.GetEnumerator().MoveNext();
    }
}

外側の拡張宣言でレシーバー パラメーターが指定されていない場合、インスタンス拡張メンバーを指定するとエラーになります。

public static class Enumerable
{
    extension(IEnumerable) // No parameter name
    {
        public bool IsEmpty => true; // Error: instance extension member not allowed
    }
}

拡張機能宣言のメンバーに対して、 abstract、 virtual、 override、 new、 sealed、 partial、および protected (および関連するアクセシビリティ修飾子) に対して、次の修飾子を指定するとエラーになります。
拡張宣言のメンバーに readonly 修飾子を指定するとエラーになります。
拡張宣言のプロパティには、 init アクセサーがない可能性があります。
レシーバー パラメーターに名前が付いていない場合、インスタンス メンバーは許可されません。

すべてのメンバーは、静的な外側のクラスの名前と拡張型の名前 (ある場合) とは異なる名前を持つ必要があります。

拡張メンバーを [ModuleInitializer] 属性で装飾するとエラーになります。

レフネス

既定では、レシーバーは、その他パラメーターと同様に、値によって、インスタンス拡張メンバーに渡されます。 ただし、パラメーター形式の拡張宣言レシーバーは、レシーバーの型が値型であることがわかっている限り、ref、ref readonly、および in を指定できます。

NULL 許容値と属性

レシーバー型は、null 許容参照型にすることもでき、それを含めることもできます。またパラメーター形式のレシーバー指定は、属性を指定できます。タ

public static class NullableExtensions
{
    extension(string? text)
    {
        public string AsNotNull => text is null ? "" : text;
    }
    extension([NotNullWhen(false)] string? text)
    {
        public bool IsNullOrEmpty => text is null or [];
    }
    extension<T> ([NotNull] T t) where T : class?
    {
        public void ThrowIfNull() => ArgumentNullException.ThrowIfNull(t);
    }
}

従来の拡張メソッドとの互換性

インスタンス拡張メソッドは、従来の拡張メソッドによって生成されるものと一致する成果物を生成します。

具体的には、生成された静的メソッドは、宣言された拡張メソッドの属性、修飾子、名前および、拡張宣言とメソッド宣言からこの順番で、連結された型パラメーター リスト、パラメーター リスト、制約リストを保有します。

public static class Enumerable
{
    extension<TSource>(IEnumerable<TSource> source) // Generate compatible extension methods
    {
        public IEnumerable<TSource> Where(Func<TSource, bool> predicate) { ... }
        public IEnumerable<TSource> Select<TResult>(Func<TSource, TResult> selector)  { ... }
    }
}

Generates:

[Extension]
public static class Enumerable
{
    [Extension]
    public static IEnumerable<TSource> Where<TSource>(IEnumerable<TSource> source, Func<TSource, bool> predicate) { ... }

    [Extension]
    public static IEnumerable<TSource> Select<TSource, TResult>(IEnumerable<TSource> source, Func<TSource, TResult> selector)  { ... }
}

オペレーター

拡張演算子には明示的なオペランド型がありますが、拡張宣言内で宣言する必要があります。

public static class Enumerable
{
    extension<TElement>(IEnumerable<TElement>) where TElement : INumber<TElement>
    {
        public static IEnumerable<TElement> operator *(IEnumerable<TElement> vector, TElement scalar) { ... }
        public static IEnumerable<TElement> operator *(TElement scalar, IEnumerable<TElement> vector) { ... }
    }
}

これにより、型パラメーターを宣言および推論でき、そのオペランド型の 1 つ内で通常のユーザー定義演算子を宣言する方法に似ています。

Checking

推論可能性: メソッド以外の拡張メンバーごとに、拡張ブロックのすべての型パラメーターを、拡張機能とメンバーのパラメーターの組み合わせで使用する必要があります。

独特： 特定の外側の静的クラス内では、同じレシーバー型 (恒等変換および型パラメーター名の置換を考慮) を持つ拡張メンバー宣言のセットは、クラスまたは構造体宣言内のメンバーに似た単一の宣言空間として扱われ、 一意性に関する同じ規則に従います。

public static class MyExtensions
{
    extension<T1>(IEnumerable<int>) // Error! T1 not inferrable
    {
        ...
    }
    extension<T2>(IEnumerable<T2>)
    {
        public bool IsEmpty { get ... }
    }
    extension<T3>(IEnumerable<T3>?)
    {
        public bool IsEmpty { get ... } // Error! Duplicate declaration
    }
}

この一意性ルールの適用には、同じ静的クラス内の従来の拡張メソッドが含まれます。 拡張宣言内のメソッドと比較するために、this パラメーターはそのレシーバー型に記載されている任意の型パラメーターと共に、レシーバー指定として扱われ、残りの型パラメーターとメソッド パラメーターは、メソッド シグネチャに使用されます。

public static class Enumerable
{
    public static IEnumerable<TResult> Cast<TResult>(this IEnumerable source) { ... }
    
    extension(IEnumerable source) 
    {
        IEnumerable<TResult> Cast<TResult>() { ... } // Error! Duplicate declaration
    }
}

従量課金

拡張メンバーの検索が試行されると、using インポートされている静的クラス内のすべての拡張宣言が、レシーバー型に関係なく、そのメンバーを候補として提供します。 ソリューションの一環としてのみ、互換性のないレシーバー型の候補が破棄されます。
引数の型 (実際のレシーバーを含む) と任意の型パラメーター (拡張宣言と拡張メンバー宣言の型を組み合わせたもの) の間で、完全なジェネリック型推論が試行されます。
明示的な型引数を指定すると、拡張宣言と拡張メンバー宣言の型パラメーターに置き換えるために使用されます。

string[] strings = ...;

var query = strings.Select(s => s.Length); // extension invocation
var query2 = strings.Select<string, int>(s => s.Length); // ... with explicit full set of type arguments

var query3 = Enumerable.Select(strings, s => s.Length); // static method invocation
var query4 = Enumerable.Where<string, int>(strings, s => s.Length); // ... with explicit full set of type arguments
 
public static class Enumerable
{
    extension<TSource>(IEnumerable<TSource> source)
    {
        public IEnumerable<TResult> Select<TResult>(Func<T, TResult> predicate) { ... }
    }
}

従来の拡張メソッドと同様に、出力される実装メソッドを静的に呼び出すことができます。
これにより、コンパイラは、同じ名前とアリティを持つ拡張メンバー間であいまいさを解消できます。

object.M(); // ambiguous
E1.M();

new object().M2(); // ambiguous
E1.M2(new object());

_ = _new object().P; // ambiguous
_ = E1.get_P(new object());

static class E1
{
    extension(object)
    {
        public static void M() { }
        public void M2() { }
        public int P => 42;
    }
}

static class E2
{
    extension(object)
    {
        public static void M() { }
        public void M2() { }
        public int P => 42;
    }
}

静的拡張メソッドは、インスタンス拡張メソッドと同様に解決されます (レシーバー型の追加引数を考慮します)。
拡張プロパティは拡張メソッドと同様に解決され、1 つのパラメーター (レシーバー パラメーター) と 1 つの引数 (実際のレシーバー値) が使用されます。

using static ディレクティブ

using_static_directiveを使用すると、型宣言の拡張ブロックのメンバーが拡張アクセスで使用できるようになります。

using static N.E;

new object().M();
object.M2();

_ = new object().Property;
_ = object.Property2;

C c = null;
_ = c + c;
c += 1;

namespace N
{
    static class E
    {
        extension(object o)
        {
            public void M() { }
            public static void M2() { }
            public int Property => 0;
            public static int Property2 => 0;
        }

        extension(C c)
        {
            public static C operator +(C c1, C c2) => throw null;
            public void operator +=(int i) => throw null;
        }
    }
}

class C { } 

以前と同様に、指定された型の宣言に直接含まれるアクセス可能な静的メンバー (拡張メソッドを除く) を直接参照できます。
つまり、実装メソッド (拡張メソッドを除く) を静的メソッドとして直接使用できます。

using static E;

M();
System.Console.Write(get_P());
set_P(43);
_ = op_Addition(0, 0);
_ = new object() + new object();

static class E
{
    extension(object)
    {
        public static void M() { }
        public static int P { get => 42; set { } }
        public static object operator +(object o1, object o2) { return o1; }
    }
}

using_static_directiveはまだ拡張メソッドを静的メソッドとして直接インポートしないため、非静的拡張メソッドの実装メソッドを静的メソッドとして直接呼び出すことはできません。

using static E;

M(1); // error: The name 'M' does not exist in the current context

static class E
{
    extension(int i)
    {
        public void M() { }
    }
}

OverloadResolutionPriorityAttribute（オーバーロード解決優先順位属性）

外側の静的クラス内の拡張メンバーは、ORPA 値に従った優先順位付けの対象となります。 外側の静的クラスは、ORPA 規則で考慮される "包含型" と見なされます。
拡張プロパティに存在する ORPA 属性は、プロパティのアクセサーの実装メソッドにコピーされるため、これらのアクセサーがあいまいさを解消する構文を使用する場合に優先順位付けが尊重されます。

入口点

拡張ブロックのメソッドは、エントリ ポイント候補として適格ではありません（「7.1 アプリケーションの起動」を参照）。 注: 実装方法は、引き続き候補になる可能性があります。

引き下げ

拡張宣言の下位戦略は、言語レベルの決定ではありません。 ただし、言語セマンティクスを実装する以外に、特定の要件を満たす必要があります。

• 生成された型、メンバー、およびメタデータの形式は、他のコンパイラが使用して生成できるように、すべてのケースで明確に指定する必要があります。
• 生成されたアーティファクトは安定している必要があります。つまり、妥当な今後の変更によって、以前のバージョンに対してコンパイルされたコンシューマーが中断されないようにする必要があります。

これらの要件は、実装の進行に合わせてさらに改良が必要であり、妥当な実装アプローチを可能にするために、コーナー ケースで妥協する必要がある場合があります。

宣言のメタデータ

目標

次の設計では、次のことができます。

• 拡張宣言シンボルのラウンドトリップをメタデータ（完全アセンブリと参照アセンブリ）を通して実行する
• 拡張メンバーへの安定した参照 (xml ドキュメント)
• 出力された名前をローカルで決定することは、EnC の役に立ちます。
• パブリック API の追跡。

xml ドキュメントの場合、拡張メンバーの docID はメタデータ内の拡張メンバーの docID です。 たとえば、 cref="Extension.extension(object).M(int)" で使用される docID は M:Extension.<>E__ExtensionGroupingTypeNameForObject.M(System.Int32) であり、その docID は、拡張ブロックの再コンパイルと順序付けの間で安定しています。 理想的には、拡張ブロックの制約が変更された場合にも安定したままですが、メンバーの競合に対する言語設計に悪影響を及ぼすことなく、それを実現する設計は見つかりませんでした。

EnC の場合、どこで更新された拡張メンバーがメタデータに出力されているかを、ローカルで（変更された拡張メンバーを確認するだけで）知ることができると便利です。

パブリック API 追跡の場合、より安定した名前を使用すると、ノイズが軽減されます。 ただし、技術的には、このようなシナリオでは拡張機能のグループ化の型名を使用しないでください。 拡張メンバー Mを見ると、拡張機能のグループ化の種類の名前は関係なく、重要なのは、それが属する拡張ブロックの署名です。 パブリック API 署名は、 Extension.<>E__ExtensionGroupingTypeNameForObject.M(System.Int32) ではなく、 Extension.extension(object).M(int)と見なす必要があります。 言い換えると、拡張メンバーは、2 セットの型パラメーターと 2 セットのパラメーターを持つものとして見なされます。

概要

拡張ブロックは、CLR レベルのシグネチャによってグループ化されます。 各 CLR 等価性グループは、コンテンツ ベースの名前を持つ 拡張グループ化の種類 として出力されます。 その後、CLR 等価グループ内の拡張ブロックは、C# の等価性によってサブグループ化されます。 各 C# 等価グループは、対応する拡張グループ型にネストされた、内容に基づいた名前を持つ拡張マーカー型として出力されます。 拡張マーカーの種類には、拡張パラメーターをエンコードする 1 つの 拡張マーカー メソッド が含まれています。 拡張マーカーの種類を含む拡張マーカー メソッドは、完全な忠実性を持つ拡張ブロックのシグネチャをエンコードします。 各拡張メンバーの宣言は、適切な拡張グループ化型で出力され、属性を介してその名前によって拡張マーカー型を参照し、変更されたシグネチャを持つ最上位の静的 実装メソッド が伴います。

メタデータ エンコードのスキーマ化された概要を次に示します。

[Extension]
static class EnclosingStaticClass
{
    [Extension]
    public sealed class ExtensionGroupingType1 // has type parameters with minimal constraints sufficient to keep extension member declarations below valid
    {
        public static class ExtensionMarkerType1 // has re-declared type parameters with full fidelity of C# constraints
        {
            public static void <Extension>$(... extension parameter ...) // extension marker method
        }
        ... ExtensionMarkerType2, etc ...

        ... extension members for ExtensionGroupingType1, each points to its corresponding extension marker type ...
    }

    ... ExtensionGroupingType2, etc ...

    ... implementation methods ...
}

内包された静的クラスは、[Extension] 属性で出力されます。

CLR レベルのシグネチャと C#レベルの署名

拡張ブロックの CLR レベルのシグネチャの結果は次のとおりです。

• 型パラメーター名を T0、 T1などに正規化する
• 属性の削除
• パラメーター名の消去
• パラメーター修飾子 ( ref、 in、 scoped、... など) を消去する
• タプル名の消去
• NULL 値許容注釈の消去
• notnull制約の消去

注: その他の制約 ( new()、 struct、 class、 allows ref struct、 unmanaged、型の制約など) は保持されます。

拡張機能のグループ化の種類

拡張グループ化の種類は、同じ CLR レベルのシグネチャを持つソース内の拡張ブロックの各セットのメタデータに出力されます。

• その名前は発話できないものであり、CLR レベルのシグネチャの内容に基づいて決まります。 詳しくは、以下をご覧ください。
• その型パラメーターには正規化された名前 (T0、 T1、...) があり、属性はありません。
• これはパブリックであり、封印されています。
• specialname フラグと[Extension]属性でマークされます。

拡張機能のグループ化の種類のコンテンツ ベースの名前は、CLR レベルのシグネチャに基づいており、次のものが含まれます。

• 拡張パラメーターの型の完全修飾 CLR 名。
  • 参照される型パラメーター名は、 T0、 T1などに正規化されます。型宣言に表示される順序に基づいています。
  • 完全修飾名には、包含するアセンブリは含まれません。 型はアセンブリ間で移動するのが一般的であり、xml ドキュメント参照を壊すべきではありません。
• 型パラメーターの制約が含まれて並べ替えられるので、ソース コードでそれらを並べ替しても名前は変更されません。 具体的には：
  • 型パラメーターの制約は宣言順に一覧表示されます。 N 番目の型パラメーターの制約は、Nth+1 型パラメーターの前に発生します。
  • 型制約は、完全な名前を序数で比較することで並べ替えられます。
  • 非型制約は決定論的に順序付けされ、型制約とのあいまいさや競合を回避するために処理されます。
• これには属性が含まれていないため、タプル名、null 値の許容など、C#-isms は意図的に無視されます。

注: この名前は、C#-isms の再コンパイル、再順序付け、および変更 (つまり、CLR レベルのシグネチャに影響を与えない) にわたって安定した状態を維持することが保証されています。

拡張マーカーの種類

マーカー型は、拡張ブロックの C# ビューの完全な忠実性を得るために、その包含グループ化型 (拡張グループ化型) の型パラメーターを再宣言します。

拡張マーカーの種類は、同じ C# レベルのシグネチャを持つソース内の拡張ブロックの各セットのメタデータに出力されます。

• その名前は言うに言えないものであり、拡張ブロックの C# レベルのシグネチャの内容に基づいて決定されます。 詳しくは、以下をご覧ください。
• ソースで宣言されているグループ化型 (名前や属性を含む) に対して型パラメーターを再宣言します。
• パブリックで静的です。
• specialname フラグでマークされます。

拡張マーカーの種類のコンテンツ ベースの名前は、次に基づいています。

• 型パラメーターの名前は、拡張宣言に表示される順序に含まれます
• 型パラメーターの属性が含まれて並べ替えられるので、ソース コードでそれらを並べ替しても名前は変更されません。
• 型パラメーターの制約が含まれて並べ替えられるので、ソース コードでそれらを並べ替しても名前は変更されません。
• 拡張型の完全修飾 C# 名
  • これには、Null 許容注釈、タプル名などの項目が含まれます。
  • 完全修飾名には、格納されているアセンブリが含まれません。
• 拡張パラメーターの名前
• 決定的な順序での拡張パラメーター (ref、 ref readonly、 scoped、...) の修飾子
• 決定的な順序で拡張パラメーターに適用されるすべての属性の完全修飾名と属性引数

注: 名前は、再コンパイルと再順序付けの間で安定した状態を維持することが保証されます。
注: 拡張マーカーの種類と拡張マーカー メソッドは、参照アセンブリの一部として出力されます。

拡張マーカー メソッド

マーカー メソッドの目的は、拡張ブロックの拡張パラメーターをエンコードすることです。 拡張マーカー型のメンバーであるため、拡張マーカー型の再宣言された型パラメーターを参照できます。

各拡張マーカーの種類には、1 つのメソッドである拡張マーカー メソッドが含まれています。

• これは静的、非ジェネリック、void を返し、 <Extension>$と呼ばれます。
• その 1 つのパラメーターには、拡張パラメーターの属性、参照、型、および名前があります。
  拡張パラメーターで名前が指定されていない場合、パラメーター名は空です。
• specialname フラグでマークされます。

マーカー メソッドのアクセシビリティは、対応する宣言された拡張メンバーの中で最も制限の厳しいアクセシビリティになります。 private は、何も宣言されていない場合に使用されます。

拡張メンバー

ソースの拡張ブロック内のメソッド/プロパティ宣言は、メタデータ内の拡張グループ化型のメンバーとして表されます。

• 元のメソッドのシグネチャ (属性を含む) は保持されますが、その本文は throw NotImplementedException() に置き換えられます。
• これらは IL で参照しないでください。
• メソッド、プロパティ、およびアクセサーは、そのメンバーの拡張ブロックに対応する拡張マーカーの種類の名前を参照する [ExtensionMarkerName("...")] でマークされます。

実装メソッド

ソース内の拡張ブロック内のメソッド/プロパティ宣言のメソッド本体は、最上位の静的クラスの静的実装メソッドとして出力されます。

• 実装メソッドの名前は元のメソッドと同じです。
• 元のメソッドの型パラメーター（属性を含む）の前に、拡張ブロックから派生した型パラメーターが追加されています。
• 元のメソッドと同じアクセシビリティと属性があります。
• 静的メソッドを実装する場合、パラメーターと戻り値の型は同じです。
• インスタンス メソッドを実装する場合は、元のメソッドのシグネチャの前にパラメーターが追加されます。 このパラメーターの属性、参照、型、および名前は、関連する拡張ブロックで宣言された拡張パラメーターから派生します。
• 実装メソッドのパラメーターは、拡張ブロックの型パラメーターではなく、実装メソッドが所有する型パラメーターを参照します。
• 元のメンバーがインスタンスの通常のメソッドである場合、実装メソッドは [Extension] 属性でマークされます。

ExtensionMarkerName 属性

ExtensionMarkerNameAttribute 型はコンパイラでのみ使用され、ソースでは使用できません。 コンパイルにまだ含まれていない場合には、型宣言はコンパイラによって合成されます。

namespace System.Runtime.CompilerServices;

[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Interface | AttributeTargets.Delegate, Inherited = false)]
public sealed class ExtensionMarkerNameAttribute : Attribute
{
    public ExtensionMarkerNameAttribute(string name)
        => Name = name;

    public string Name { get; }
}

注: 一部の属性ターゲットは将来への備えとして設けられています（拡張入れ子型、拡張フィールド、拡張イベント）。ただし、AttributeTargets.Constructor は拡張コンストラクターがコンストラクターではないため含まれていません。

例

注: この例では、読みやすくするために、簡略化されたコンテンツ ベースの名前を使用します。 注: C# は型パラメーターの再宣言を表すことができないため、メタデータを表すコードは有効な C# コードではありません。

メンバーを含まないグループ化のしくみを示す例を次に示します。

class E
{
    extension<T>(IEnumerable<T> source)
    {
        ... member in extension<T>(IEnumerable<T> source)
    }

    extension<U>(ref IEnumerable<U?> p)
    {
        ... member in extension<U>(ref IEnumerable<U?> p)
    }

    extension<T>(IEnumerable<U> source)
        where T : IEquatable<U>
    {
        ... member in extension<T>(IEnumerable<U> source) where T : IEquatable<U>
    }
}

は次のように出力されます。

[Extension]
class E
{
    [Extension, SpecialName]
    public sealed class <>E__ContentName_For_IEnumerable_T<T0>
    {
        [SpecialName]
        public static class <>E__ContentName1 // note: re-declares type parameter T0 as T
        {
            [SpecialName]
            public static void <Extension>$(IEnumerable<T> source) { }
        }

        [SpecialName]
        public static class <>E__ContentName2 // note: re-declares type parameter T0 as U
        {
            [SpecialName]
            public static void <Extension>$(ref IEnumerable<U?> p) { }
        }

        [ExtensionMarkerName("<>E__ContentName1")]
        ... member in extension<T>(IEnumerable<T> source)

        [ExtensionMarkerName("<>E__ContentName2")]
        ... member in extension<U>(ref IEnumerable<U?> p)
    }

    [Extension, SpecialName]
    public sealed class <>ContentName_For_IEnumerable_T_With_Constraint<T0>
       where T0 : IEquatable<T0>
    {
        [SpecialName]
        public static class <>E__ContentName3 // note: re-declares type parameter T0 as U
        {
            [SpecialName]
            public static void <Extension>$(IEnumerable<U> source) { }
        }

        [ExtensionMarkerName("ContentName3")]
        public static bool IsPresent(U value) => throw null!;
    }

    ... implementation methods
}

メンバーの出力方法を示す例を次に示します。

static class IEnumerableExtensions
{
    extension<T>(IEnumerable<T> source) where T : notnull
    {
        public void Method() { ... }
        internal static int Property { get => ...; set => ...; }
        public int Property2 { get => ...; set => ...; }
    }

    extension(IAsyncEnumerable<int> values)
    {
        public async Task<int> SumAsync() { ... }
    }

    public static void Method2() { ... }
}

は次のように出力されます。

[Extension]
static class IEnumerableExtensions
{
    [Extension, SpecialName]
    public sealed class <>E__ContentName_For_IEnumerable_T<T0>
    {
        // Extension marker type is emitted as a nested type and re-declares its type parameters to include C#-isms
        // In this example, the type parameter `T0` is re-declared as `T` with a `notnull` constraint:
        // .class <>E__IEnumerableOfT<T>.<>E__ContentName_For_IEnumerable_T_Source
        // .typeparam T
        //     .custom instance void NullableAttribute::.ctor(uint8) = (...)
        [SpecialName]
        public static class <>E__ContentName_For_IEnumerable_T_Source
        {
            [SpecialName]
            public static <Extension>$(IEnumerable<T> source) => throw null;
        }

        [ExtensionMarkerName("<>E__ContentName_For_IEnumerable_T_Source")]
        public void Method() => throw null;

        [ExtensionMarkerName("<>E__ContentName_For_IEnumerable_T_Source")]
        internal static int Property
        {
            [ExtensionMarkerName("<>E__ContentName_For_IEnumerable_T_Source")]
            get => throw null;
            [ExtensionMarkerName("<>E__ContentName_For_IEnumerable_T_Source")]
            set => throw null;
        }

        [ExtensionMarkerName("<>E__ContentName_For_IEnumerable_T_Source")]
        public int Property2
        {
            [ExtensionMarkerName("<>E__ContentName_For_IEnumerable_T_Source")]
            get => throw null;
            [ExtensionMarkerName("<>E__ContentName_For_IEnumerable_T_Source")]
            set => throw null;
        }
    }

    [Extension, SpecialName]
    public sealed class <>E__ContentName_For_IAsyncEnumerable_Int
    {
        [SpecialName]
        public static class <>E__ContentName_For_IAsyncEnumerable_Int_Values
        {
            [SpecialName]
            public static <Extension>$(IAsyncEnumerable<int> values) => throw null;
        }

        [ExtensionMarkerName("<>E__ContentName_For_IAsyncEnumerable_Int_Values")]
        public Task<int> SumAsync() => throw null;
    }

    // Implementation for Method
    [Extension]
    public static void Method<T>(IEnumerable<T> source) { ... }

    // Implementation for Property
    internal static int get_Property<T>() { ... }
    internal static void set_Property<T>(int value) { ... }

    // Implementation for Property2
    public static int get_Property2<T>(IEnumerable<T> source) { ... }
    public static void set_Property2<T>(IEnumerable<T> source, int value) { ... }

    // Implementation for SumAsync
    [Extension]
    public static int SumAsync(IAsyncEnumerable<int> values) { ... }

    public static void Method2() { ... }
}

拡張メンバーがソースで使用されるたびに、それらを実装メソッドへの参照として出力します。 たとえば、enumerableOfInt.Method() の呼び出しは、IEnumerableExtensions.Method<int>(enumerableOfInt)の静的呼び出しとして出力されます。

XML ドキュメント

拡張ブロックのドキュメント コメントは、マーカーの種類に対して出力されます (拡張機能ブロックの DocID は、次の例で E.<>E__MarkerContentName_For_ExtensionOfT'1 )。
<paramref>と<typeparamref>) を使用して拡張パラメーターと型パラメーターを参照できます。
注: 拡張メンバーに拡張パラメーターまたは型パラメーター ( <param> および <typeparam>) を文書化することはできません。

2 つの拡張ブロックが 1 つのマーカーの種類として出力される場合、そのドキュメント コメントもマージされます。

xml ドキュメントを使用するツールは、必要に応じて拡張ブロックから拡張メンバーに <param> と <typeparam> をコピーします (つまり、パラメーター情報はインスタンス メンバーに対してのみコピーする必要があります)。

<inheritdoc>は実装メソッドで生成され、crefを持つ関連する拡張メンバーを参照します。 たとえば、getter の実装メソッドは、拡張プロパティのドキュメントを参照します。 拡張メンバーにドキュメント コメントがない場合、 <inheritdoc> は省略されます。

拡張ブロックと拡張メンバーについては、現在、次の場合は警告しません。

• 拡張パラメーターは文書化されていますが、拡張メンバーのパラメーターは文書化されていません
• またはその逆
• または、ドキュメントに記載されていない型パラメーターがある同等のシナリオの場合

たとえば、次のドキュメントコメント:

/// <summary>Summary for E</summary>
static class E
{
    /// <summary>Summary for extension block</summary>
    /// <typeparam name="T">Description for T</typeparam>
    /// <param name="t">Description for t</param>
    extension<T>(T t)
    {
        /// <summary>Summary for M, which may refer to <paramref name="t"/> and <typeparamref name="T"/></summary>
        /// <typeparam name="U">Description for U</typeparam>
        /// <param name="u">Description for u</param>
        public void M<U>(U u) => throw null!;

        /// <summary>Summary for P</summary>
        public int P => 0;
    }
}

次の xml を生成します。

<?xml version="1.0"?>
<doc>
    <assembly>
        <name>Test</name>
    </assembly>
    <members>
        <member name="T:E">
            <summary>Summary for E</summary>
        </member>
        <member name="T:E.&lt;&gt;E__MarkerContentName_For_ExtensionOfT`1">
            <summary>Summary for extension block</summary>
            <typeparam name="T">Description for T</typeparam>
            <param name="t">Description for t</param>
        </member>
        <member name="M:E.&lt;&gt;E__MarkerContentName_For_ExtensionOfT`1.M``1(``0)">
            <summary>Summary for M, which may refer to <paramref name="t"/> and <typeparamref name="T"/></summary>
            <typeparam name="U">Description for U</typeparam>
            <param name="u">Description for u</param>
        </member>
        <member name="P:E.&lt;&gt;E__MarkerContentName_For_ExtensionOfT`1.P">
            <summary>Summary for P</summary>
        </member>
        <member name="M:E.M``2(``0,``1)">
            <inheritdoc cref="M:E.&lt;&gt;E__MarkerContentName_For_ExtensionOfT`1.M``1(``0)"/>
        </member>
        <member name="M:E.get_P``1(``0)">
            <inheritdoc cref="P:E.&lt;&gt;E__MarkerContentName_For_ExtensionOfT`1.P"/>
        </member>
    </members>
</doc>

CREFの参照

拡張ブロックは入れ子になった型のように扱うことができます。これは、シグネチャによってアドレス指定できます (1 つの拡張パラメーターを持つメソッドであるかのように)。 例: E.extension(ref int).M()。

ただし、cref は拡張ブロック自体に対処できません。 E.extension(int) は、 E型の "extension" という名前のメソッドを参照できます。

static class E
{
  extension(ref int i)
  {
    void M() { } // can be addressed by cref="E.extension(ref int).M()" or cref="extension(ref int).M()" within E, but not cref="M()"
  }
  extension(ref  int i)
  {
    void M(int i2) { } // can be addressed by cref="E.extension(ref int).M(int)" or cref="extension(ref int).M(int)" within E
  }
}

検索処理は、一致するすべての拡張ブロックを参照します。
拡張メンバーへの修飾されていない参照を禁止するため、cref ではそれらを禁止することもできます。

構文は次のようになります。

member_cref
  : conversion_operator_member_cref
  | extension_member_cref // added
  | indexer_member_cref
  | name_member_cref
  | operator_member_cref
  ;

extension_member_cref // added
 : 'extension' type_argument_list? cref_parameter_list '.' member_cref
 ;

qualified_cref
  : type '.' member_cref
  ;

cref
  : member_cref
  | qualified_cref
  | type_cref
  ;

最上位レベル (extension_member_cref) でextension(int).Mを使用するか、別の拡張機能 (E.extension(int).extension(string).M) で入れ子にすることはエラーです。

重大な変更

"extension" という名前を型やエイリアスに付けることはできません。

未処理の問題

static class E
{
   extension<T>(ref T) where T : struct
      void M()
   extension<T>(T) where T : class
      void M()
}

public static class E
{
  extension(ref int)
  {
    public static void M()
  }
}

public static class E
{
  public static class <>ExtensionTypeXYZ
  {
    .. marker method ...
    void M()
  }
}

public static class E
{
  extension(ref int)
    static void M()
  extension(int)
    static void M()
}

static class E
{
   extension<T>(ref T) where T : struct
      void M()
   extension<T>(T) where T : class
      void M()
}

static class E
{
   extension<T>(ref T)
      void M()
   extension<T>(T)
      void M()
}
// portability issue: since we're grouping without accounting for refness, the emitted extension members conflict (not implementation members). Mitigation: keep as classic extensions or split to another static class

static class E
{
    extension<T>(T t)
    {
        public void M<U>(U u) where T : C<U>  { } // error: 'E.extension<T>(T).M<U>(U)' does not define type parameter 'T'
    }
}

public class C<T> { }

    extension([System.Diagnostics.CodeAnalysis.DoesNotReturnIf(false)] bool b)
    {
        public void AssertTrue() => throw null!;
    }

    extension([System.Diagnostics.CodeAnalysis.NotNullIfNotNull("o")] ref int? i)
    {
        public void M(object? o)  => throw null!;
    }

public static class Extensions
{
    extension(Type1)
    {
        [OverloadResolutionPriority(1)]
        public void Overload(...)
    }
    extension(Type2)
    {
        public void Overload(...)
    }
}

public static class Extensions
{
    extension(int[] i)
    {
        public P { get => }
    }
    extension(ReadOnlySpan<int> r)
    {
       [OverloadResolutionPriority(1)]
       public P { get => }
    }
}

string s = "ran";
_ = s.P<object>; // error

static class E
{
    extension<T>(T t)
    {
        public int P => 0;
    }
}

int.M();

static class E1
{
    extension(int)
    {
        public static void M() { }
    }
}
static class E2
{
    extension(in int i)
    {
        public static void M() => throw null;
    }
}

string s = null;
s.M(); // error

static class E
{
    extension(string s)
    {
        public System.Action M => throw null;
    }
    extension(object o)
    {
        public string M() => throw null;
    }
}

static class E
{
    extension(object o)
    {
        public void M() 
        {
            M2();
        }
        public void M2() { }
    }
}

public static class Extensions
{
    extension(PrivateType p)
    {
        // We report inconsistent accessibility error, 
        //   because we generate a `public static void M(PrivateType p)` implementation in enclosing type
        public void M() { } 

        public static void M2() { } // should we also report here, even though not technically necessary?
    }

    private class PrivateType { }
}

static class E
{
    extension(object)
    {
        public void Method() {  }
        public static void Method() { }
    }
}

extension_member_declaration // add
    : constant_declaration
    | field_declaration
    | method_declaration
    | property_declaration
    | event_declaration
    | indexer_declaration
    | operator_declaration
    | constructor_declaration
    | finalizer_declaration
    | static_constructor_declaration
    | type_declaration
    ;

public static class Enumerable
{
    extension(IEnumerable<int>)
    {
        public static IEnumerable(int start, int count) => Range(start, count);
    }
    public static IEnumerable<int> Range(int start, int count) { ... } 
}

var range = new IEnumerable<int>(1, 100);

public static class EmptyExtensions : extension(IEnumerable source)
{
    public bool IsEmpty => !source.GetEnumerator().MoveNext();
}

public static class Bits
{
    extension(ref ulong bits) public bool this[int index]
    {
        get => (bits & Mask(index)) != 0;
        set => bits = value ? bits | Mask(index) : bits & ~Mask(index);
    }
    static ulong Mask(int index) => 1ul << index;
}
 
public static class Enumerable
{
    extension<TSource>(IEnumerable<TSource> source) public IEnumerable<TSource> Where(Func<TSource, bool> predicate) { ... }
}