Warum ist es nicht möglich, generische Indexer in .NET zu definieren?

Question

Warum können Sie in .NET keinen generischen Indexer erstellen?

der folgende Code führt einen Compiler-Fehler:

public T this<T>[string key] 
    { 
     get { /* Return generic type T. */ } 
    } 

das Sie bedeutet das eine generische Indexer für eine generische Element Sammlung nicht schaffen können?

Answer 1

Das einzige, was ich daran denken kann, kann verwendet werden, ist etwas in dieser Richtung:

var settings = ConfigurationSection.AppSettings; 
var connectionString = settings<string>["connectionString"]; 
var timeout = settings<int>["timeout"]; 

Aber das ist eigentlich Sie nicht alles kaufen. Sie haben gerade rund Pars (wie in (int) Einstellungen [ „timeout“]) mit spitzen Klammern ersetzt, erhielten aber keine zusätzliche Typsicherheit, wie Sie frei

var timeout = settings<int>["connectionString"]; 

tun können, wenn Sie etwas, das stark ist, aber nicht statisch getippt, möchten Sie vielleicht bis C# 4.0 mit seinem dynamischen Schlüsselwort warten.

Answer 2

Sie können; lassen Sie einfach den <T> Teil von Ihrer Deklaration fallen und es wird gut funktionieren. das heißt

public T this[string key] 
{ 
    get { /* Return generic type T. */ } 
} 

(Angenommen, Ihre Klasse mit einem Typ-Parameter namens T generisch).

Answer 3

Ich weiß nicht warum, aber Indexer sind nur syntaktischer Zucker. Schreiben Sie stattdessen eine generische Methode und Sie erhalten die gleiche Funktionalität. Beispiel:

public T GetItem<T>(string key) 
    { 
     /* Return generic type T. */ 
    } 

Answer 4

Eigenschaften können in C# 2.0/3.0 nicht generisch sein, daher können Sie keinen generischen Indexer verwenden.

Answer 5

Hier ist ein Platz, wo dies nützlich wäre. Angenommen, Sie haben eine stark typisierte OptionKey<T> zur Deklaration von Optionen.

public static class DefaultOptions 
{ 
    public static OptionKey<bool> SomeBooleanOption { get; } 
    public static OptionKey<int> SomeIntegerOption { get; } 
} 

Wo Optionen durch die IOptions Schnittstelle ausgesetzt sind:

public interface IOptions 
{ 
    /* since options have a default value that can be returned if nothing's 
    * been set for the key, it'd be nice to use the property instead of the 
    * pair of methods. 
    */ 
    T this<T>[OptionKey<T> key] 
    { 
     get; 
     set; 
    } 

    T GetOptionValue<T>(OptionKey<T> key); 
    void SetOptionValue<T>(OptionKey<T> key, T value); 
} 

-Code dann das generische Indexer als eine nette stark typisierte Optionen Speicher verwenden:

void Foo() 
{ 
    IOptions o = ...; 
    o[DefaultOptions.SomeBooleanOption] = true; 
    int integerValue = o[DefaultOptions.SomeIntegerOption]; 
} 

Answer 6

Ich mag die Fähigkeit, einen Indexer zu haben, ohne einen direkten Verweis auf den "indexierten" Gegenstand auszugeben. Ich schrieb eine einfache „Rückruf“ unter Indexer Klasse ...

R = die zurückTyp aus dem Indexer P = der übergebene Typ in den Indexer

das All Indexer wirklich tut, ist die Vorgänge passieren zu der Deployer und ermöglichen ihnen zu verwalten, was tatsächlich passiert und wird zurückgegeben.

public class GeneralIndexer<R,P> 
    { 
     // Delegates 
     public delegate R gen_get(P parm); 
     public delegate void gen_set(P parm, R value); 
     public delegate P[] key_get(); 

     // Events 
     public event gen_get GetEvent; 
     public event gen_set SetEvent; 
     public event key_get KeyRequest; 

     public R this[P parm] 
     { 
      get { return GetEvent.Invoke(parm); } 
      set { SetEvent.Invoke(parm, value); } 
     } 

     public P[] Keys 
     { 
      get 
      { 
       return KeyRequest.Invoke(); 
      } 
     } 

    } 

Um es in einem Programm oder Klasse zu verwenden:

private GeneralIndexer<TimeSpan, string> TimeIndex = new GeneralIndexer<TimeSpan,string>(); 

{ 
      TimeIndex.GetEvent += new GeneralIndexer<TimeSpan, string>.gen_get(TimeIndex_GetEvent); 
      TimeIndex.SetEvent += new GeneralIndexer<TimeSpan, string>.gen_set(TimeIndex_SetEvent); 
      TimeIndex.KeyRequest += new GeneralIndexer<TimeSpan, string>.key_get(TimeIndex_KeyRequest); 

} 

funktioniert wie ein Champion vor allem, wenn Sie den Zugriff auf Ihre Liste überwachen möchten oder besondere Operationen tun, wenn etwas zugegriffen wird.