Indexeurs dans les interfaces (Guide de programmation C#)Indexers in Interfaces (C# Programming Guide)

Des indexeurs peuvent être déclarés dans une interface.Indexers can be declared on an interface. Les accesseurs d’indexeurs d’interface se distinguent sur plusieurs plans des accesseurs d’indexeurs de classe, à savoir :Accessors of interface indexers differ from the accessors of class indexers in the following ways:

  • Les accesseurs d’interface n’utilisent pas de modificateurs.Interface accessors do not use modifiers.

  • Un accesseur d’interface n’a pas de corps.An interface accessor does not have a body.

Par conséquent, un accesseur vise à indiquer si l’indexeur est en lecture-écriture, en lecture seule ou en écriture seule.Thus, the purpose of the accessor is to indicate whether the indexer is read-write, read-only, or write-only.

L’exemple ci-dessous porte sur un accesseur d’indexeur d’interface :The following is an example of an interface indexer accessor:

public interface ISomeInterface
{
    //...

    // Indexer declaration:
    string this[int index]
    {
        get;
        set;
    }
}

La signature d’un indexeur doit se distinguer de tous les autres indexeurs déclarés dans la même interface.The signature of an indexer must differ from the signatures of all other indexers declared in the same interface.

ExempleExample

L’exemple suivant montre comment implémenter des indexeurs d’interface.The following example shows how to implement interface indexers.

// Indexer on an interface:
public interface ISomeInterface
{
    // Indexer declaration:
    int this[int index]
    {
        get;
        set;
    }
}

// Implementing the interface.
class IndexerClass : ISomeInterface
{
    private int[] arr = new int[100];
    public int this[int index]   // indexer declaration
    {
        get
        {
            // The arr object will throw IndexOutOfRange exception.
            return arr[index];
        }
        set
        {
            arr[index] = value;
        }
    }
}

class MainClass
{
    static void Main()
    {
        IndexerClass test = new IndexerClass();
        System.Random rand = new System.Random();
        // Call the indexer to initialize its elements.
        for (int i = 0; i < 10; i++)
        {
            test[i] = rand.Next();
        }
        for (int i = 0; i < 10; i++)
        {
            System.Console.WriteLine("Element #{0} = {1}", i, test[i]);
        }

        // Keep the console window open in debug mode.
        System.Console.WriteLine("Press any key to exit.");
        System.Console.ReadKey();
    }
}
/* Sample output:
    Element #0 = 360877544
    Element #1 = 327058047
    Element #2 = 1913480832
    Element #3 = 1519039937
    Element #4 = 601472233
    Element #5 = 323352310
    Element #6 = 1422639981
    Element #7 = 1797892494
    Element #8 = 875761049
    Element #9 = 393083859
 */

Dans l’exemple précédent, vous pouvez utiliser l’implémentation de membre d’interface explicite en utilisant le nom qualifié complet du membre d’interface.In the preceding example, you could use the explicit interface member implementation by using the fully qualified name of the interface member. Par exemple :For example:

string ISomeInterface.this[int index]   
{   
}   

Cependant, le nom qualifié complet est seulement nécessaire pour éviter toute ambiguïté quand la classe implémente plusieurs interfaces avec la même signature d’indexeur.However, the fully qualified name is only needed to avoid ambiguity when the class is implementing more than one interface with the same indexer signature. Par exemple, si une classe Employee implémente deux interfaces, ICitizen et IEmployee, et que les deux interfaces ont la même signature d’indexeur, l’implémentation de membre d’interface explicite est nécessaire.For example, if an Employee class is implementing two interfaces, ICitizen and IEmployee, and both interfaces have the same indexer signature, the explicit interface member implementation is necessary. Autrement dit, la déclaration d’indexeur suivante :That is, the following indexer declaration:

string IEmployee.this[int index]   
{   
}   

implémente l’indexeur dans l’interface IEmployee, alors que la déclaration suivante :implements the indexer on the IEmployee interface, while the following declaration:

string ICitizen.this[int index]
{   
}   

implémente l’interface dans l’interface ICitizen.implements the indexer on the ICitizen interface.

Voir aussiSee also