Tilläggsindexerare

Champion-fråga: https://github.com/dotnet/csharplang/issues/9856

Deklaration

Grammatik

Tilläggsindexerare läggs till i uppsättningen tillåtna medlemmar i en tilläggsdeklaration genom att grammatiken utökas enligt följande (i förhållande till förslag/csharp-14.0/extensions.md):

extension_member_declaration
        : method_declaration
        | property_declaration
        | indexer_declaration // new
        | operator_declaration
        ;

Precis som vanliga indexerare har tilläggsindexerare ingen identifierare och identifieras av deras parameterlista. Tilläggsindexerare kan använda den fullständiga uppsättning funktioner som vanliga indexerare stöder idag (accessor-organ, uttrycksbaserade medlemmar, ref-returnerande accessorer, scoped parametrar, attribut osv.).

Eftersom indexerare alltid är instansmedlemmar måste ett tilläggsblock som deklarerar en indexerare ange en namngiven mottagarparameter.

De befintliga begränsningarna för tilläggsmedlemmar fortsätter att gälla: indexerare i en tilläggsdeklaration kan inte ange abstract, , overridevirtual, new, sealed, partialprotected (eller någon av de relaterade hjälpmedelsmodifierarna) eller init accessorer.

public static class BitExtensions
{
    extension(int i)
    {
        public bool this[int index]
        {
            get => ...;
        }
    }
}

Alla regler från C#-standarden som gäller för vanliga indexerare gäller för tilläggsindexerare, men tilläggsmedlemmar har ingen implicit eller explicit this.

Den befintliga inferensregeln för tilläggsmedlem gäller fortfarande: För varje medlem i tilläggstillägget som inte är en metod måste alla typparametrar i dess tilläggsblock användas i den kombinerade uppsättningen parametrar från tillägget och medlemmen.

IndexerName-attribut

IndexerNameAttribute kan tillämpas på en tilläggsindexerare. Attributet genereras inte i metadata, men dess värde påverkar konflikter mellan medlemmar, det bestämmer namnet på egenskapen och accessorerna i metadata och används när det [DefaultMemberAttribute] genererar (se Metadata).

Consumption

Indexerarens åtkomst

Reglerna i Indexer-åtkomst uppdateras: om den normala bearbetningen av indexerarens åtkomst inte hittar någon tillämplig indexerare görs ett försök att bearbeta konstruktionen som en tilläggsindexerareåtkomst.

1. Försök att binda med de instansindexerare som deklarerats (eller ärvt) på mottagartypen. Om en lämplig kandidat hittas väljer överbelastningsmatchning bland instansmedlemmarna som i dag och stoppas.
2. Försök att binda med implicita instansindexerare deklarerade (eller ärvda) på mottagartypen. Om en lämplig kandidat hittas väljer överbelastningsmatchning bland instansmedlemmarna som i dag och stoppas.
3. Försök att binda som en tilläggsindexerareåtkomst. Om den här processen hittar en lämplig kandidat väljer överlagringslösning bland dessa tilläggsmedlemmar enligt beskrivningen nedan och stoppar.
4. Försök att binda som implicit indexerareåtkomst för tillägg. Om den här processen hittar en lämplig kandidat väljer överlagringslösning bland dessa tilläggsmedlemmar enligt beskrivningen nedan och stoppar.

Obs! Avsnittet för elementåtkomst hanterar fallet där ett argument har typen dynamic, så att det aldrig bearbetas som en indexerares åtkomst.

Tilläggsindexerarens åtkomst

Tilläggsmedlemmar, inklusive tilläggsindexerare, beaktas aldrig när mottagaren är ett base_access uttryck.

Obs! Vi bearbetar bara en element_access som en indexerares åtkomst om mottagaren är en variabel eller ett värde, så tilläggsindexerare beaktas aldrig när mottagaren är en typ.

Med tanke på en element_accessE[A] är målet att identifiera en tilläggsindexerare.

En kandidattilläggsindexerare gäller för mottagar E - och argumentlistan A om en utökad signatur, som består av typparametrarna i tilläggsblocket och en parameterlista som kombinerar tilläggsparametern med indexerarens parametrar, gäller för en argumentlista som kombinerar mottagaren E med argumentlistan A.

Vi återanvänder scope-walk för tilläggsmetoden: vi går igenom samma omfång som konsulteras för anrop av tilläggsmetod, inklusive aktuella och omslutande lexikala omfång och using namnrymd eller using static importer.

Med tanke på varje omfång i tur och ordning:

• Tilläggsblock i icke-generiska statiska klassdeklarationer i det aktuella omfånget beaktas.
• Indexerarna i dessa tilläggsblock utgör kandidatuppsättningen.
• Kandidater som inte är tillgängliga tas bort från uppsättningen.
• Kandidater som inte är tillämpliga (enligt definitionen ovan) tas bort från uppsättningen.
• Om den resulterande uppsättningen kandidatindexerare är tom fortsätter vi till nästa omfång eller misslyckas med att lösa en tilläggsindexerares åtkomst om vi nådde det sista omfånget (vi fortsätter att försöka lösa det som en implicit indexerare för tillägg i så fall).
• Annars tillämpas överbelastningsmatchning på kandidatuppsättningen. Om det inte går att identifiera en enda bästa indexerare är tilläggsindexerarens åtkomst tvetydig och ett kompileringsfel inträffar.

Med hjälp av den här bästa indexeraren som identifierades i föregående steg bearbetas indexerarens åtkomst sedan som en statisk metodanrop.

Beroende på i vilken kontext den används orsakar en indexerare åtkomst anrop av antingen get_accessor eller indexerarens set_accessor .
Om indexerarens åtkomst är målet för en tilldelning anropas den set_accessor statiska implementeringsmetoden för att tilldela ett nytt värde.
I alla andra fall anropas den get_accessor statiska implementeringsmetoden för att hämta det aktuella värdet.
Hur som helst använder anropet allmänna argument som härleds under tillämplighetskontrollen och mottagaren som det första argumentet.

Implicit indexerareåtkomst för tillägg

En implicit System.Index (eller System.Range) tilläggsindexeringsåtkomst gäller om:

1. element_access har ett enda argument som är av typen System.Index (eller System.Range), och
2. en tillämplig Length egenskap eller Count (instans eller tillägg) finns på mottagartypen, och
3. en tillämplig this[int] indexerare (eller Slice(int, int)) (instans eller tillägg) finns på mottagartypen.

Andra formulär för elementåtkomst

Alla konstruktioner som defersar till elementåtkomstbindning (null-villkorlig elementåtkomst eller tilldelningar, indextilldelningar i objektinitierare eller list- och spridningsmönster) deltar automatiskt i tilläggsindexerarens lösning som beskrivs ovan.

Uttrycksträd

Tilläggsindexerare kan inte avbildas i uttrycksträd.

XML-dokument

CREF-syntax gör det möjligt att referera till en tilläggsindexerare och dess åtkomstorer, samt dess implementeringsmetoder.

Exempel:

/// <see cref="E.extension(int).this[string]"/>
/// <see cref="E.extension(int).get_Item(string)"/>
/// <see cref="E.extension(int).get_Item"/>
/// <see cref="E.extension(int).set_Item(string, int)"/>
/// <see cref="E.extension(int).set_Item"/>
/// <see cref="E.get_Item(int, string)"/>
/// <see cref="E.get_Item"/>
/// <see cref="E.set_Item(int, string, int)"/>
/// <see cref="E.set_Item"/>
public static class E
{
    extension(int i)
    {
        /// <summary></summary>
        public int this[string s]
        {
            get => throw null;
            set => throw null;
        }
    }
}

Metadata

Tilläggsindexerare följer samma sänkningsmodell som tilläggsegenskaper. För varje clr-nivåtilläggsgrupperingstyp som innehåller minst en indexerare genererar kompilatorn:

• En tilläggsegenskap med namnet Item (eller värdet som tillhandahålls av IndexerNameAttribute) med accessor-organ som throw NotImplementedException() och ett [ExtensionMarkerName] attribut som refererar till lämplig tilläggsmarkörtyp.
• Implementeringsmetoder med namnet get_Item/set_Item i den omslutande statiska klassen. Dessa metoder förbereder mottagarparametern till parameterlistan och innehåller de användardefinierade organen. De är static och deltar i överbelastningsmatchning på samma sätt som implementeringsmetoder för tilläggsegenskaper.

För att spegla vanliga indexerares [DefaultMemberAttribute] beteende genererar kompilatorn även alla tilläggsgrupperingstyper som innehåller en eller flera tilläggsindexerare. Attributet är MemberName lika med metadatanamnet för indexeraren (Item som standard eller värdet från IndexerNameAttribute).

Example

Källkod:

static class BitExtensions
{
    extension<T>(T t)
    {
        public bool this[int index]
        {
            get => ...;
            set => ...;
        }
    }
}

Genererad metadata (förenklad till C#-liknande syntax):

[Extension]
static class BitExtensions
{
    [Extension, SpecialName, DefaultMember("Item")]
    public sealed class <G>$T0 // grouping type
    {
        [SpecialName]
        public static class <M>$T_t // marker type
        {
            [SpecialName]
            public static void <Extension>$(T t) { } // marker method
        }

        [ExtensionMarkerName("<M>$T_t")]
        public bool this[int index] // extension indexer
        {
            get => throw new NotImplementedException();
            set => throw new NotImplementedException();
        }
    }

    // accessor implementation methods
    public static bool get_Item<T>(T t, int index) => ...;
    public static void set_Item<T>(T t, int index, bool value) => ...;
}

Öppna ärenden

int i = 0;
i[42, null] = new object(); // fails inference
E.set_Item(i, 42, null, new object()); // infer `E.set_Item<object>`

public static class E
{
    extension<T>(int i)
    {
        public T this[int j, T t] { set { } }
    }
}

#nullable enable

int i = 0;
i[new object()] = null; // infer `E.extension<object!>` and warn on conversion of null literal to `object!`
E.set_Item(i, new object(), null); // infer `E.set_Item<object?>`

public static class E
{
    extension<T>(int i)
    {
        public T this[T t] { set { } }
    }
}

C c = new C();
_ = c[..]; // Cannot apply indexing with [] to an expression of type 'C'

class C
{
    public int Length => 0;
}

static class E
{
    public static C Slice(this C c, int i, int j) => null!;
}

C c = new C();
var x1 = c[^1];
var x2 = c[1..];

if (c is [.., var y1]) { }
if (c is [_, .. var y2]) { }

class C { }

static class E
{
  extension(C c)
  {
    object this[System.Index] => ...;
    C this[System.Range] => ...;
    int Length => ...;
  }
}

C c = new C();
if (c is [var y1, .. var y2]) { }

class C
{
  C Slice(int i, int j) => ...;
}

static class E
{
  extension(C c)
  {
    object this[System.Index] => ...;
    int Length => ...;
  }
}

C c = new C();
_ = c[^1];

class C
{
  public int Length => ...;
  public int this[int i] => ...;
}

static class E
{
  extension(C c)
  {
    public int this[System.Index i] => ...;
  }
}

_ = c[1..^1];

static class E
{
  extension(C c)
  {
    public int Length => 3;
  }
  public static C Slice(this C c, int i, int j) => ...;
}

C c = new C();
int[] i = [0, .. c]; // Uses Length, if available, to allocate the right size

int[] i = ...;
_ = i[new C()];

public static class E
{
    extension(int[] i)
    {
        public int this[C c] => throw null;
    }
}

string s = "...;
_ = s[new C()];

public static class E
{
    extension(int[] i)
    {
        public int this[C c] => throw null;
    }
}