C# Learning Diary 28 --- Indexeur, indexeur surchargé

Les indexeurs permettent d'indexer les instances de classes ou de structures comme un tableau. Lorsque vous définissez un indexeur pour une classe, la classe se comportera comme un tableau. Vous pouvez utiliser l'accesseur de tableau '[]' pour cela. on accède à la classe. L'indexeur est similaire à l'attribut, mais l'indexeur prend des paramètres (on peut aussi penser que l'indexeur est un attribut d'une classe, qui est également implémenté via un accesseur (une méthode spéciale))

Pour que ce soit plus clair, donnons un exemple. L'université est la période la plus tranquille de la vie. Les étudiants peuvent faire beaucoup de choses qu'ils voulaient faire mais qu'ils n'ont pas faites pour diverses raisons. 1.. Afin d'arrêter le comportement de sauter des cours, à chaque fois en classe, l'enseignant appellera le nom ou le numéro de l'élève. Je suis en classe 4. L'enseignant aime appeler le numéro de l'élève, "Classe 4 n°1". " puis répondez à voix haute " À... " ", " Classe 4, n° 2", " Classe 4, n° 3 "... " N° 3. Camarade de classe. ", " Le professeur HC666 a mal au ventre et est parti à l'hôpital aujourd'hui." (Bonjour, Chine. Colocataire ^_^), "Oh, n°4"... L'appel du professeur est un index de la classe 4.

Si class4 est considéré comme un objet instancié par la classe Classes, class[1] est l'index du camarade de classe n°1, (pensez au tableau et vous comprendrez) alors comment l'implémenter ?

Définir l'indexeur :

Comme mentionné ci-dessus, les indexeurs sont similaires aux propriétés. Naturellement, les accesseurs get et set sont également indispensables. Défini, comme suit :

   public 返回值类型 this[参数类型 参数]  
             {
                                 get { return 参数指定的值;   }    //get访问器
                    set {  /*设置参数指定的值 */    }     //set访问器
            }

Instance de l'indexeur :

Nous coderons l'exemple ci-dessus comme suit :

using System;  
using System.Collections.Generic;  
using System.Linq;  
using System.Text;  
  
namespace Test1  
{//定义一个能被索引的类  
    class Classes  
    {//对类的索引实质是对类中数组的索引  
       public string[] StudentName=new string[6];  
        //定义索引器  
       public string this[int ID]  
       {  
           get { return StudentName[ID]; }  
           set { StudentName[ID] = value; } //set访问器自带value参数  
         
       }  
      
    }  
    class Program  
    {  
        static void Main(string[] args)  
        {  
            Classes class4 = new Classes();  
            //索引写入  
            for (int i = 1; i < 6; i++)  
            {  
                class4[i] = "HC"+i;  
            }  
            //索引读出  
            for (int j = 1; j < 6; j++)  
            {  
                Console.WriteLine(j+"号\t"+class4[j]);  
            }  
              
        }  
    }  
}

Résultat :

Recharger l'indexeur :

Dans le programme ci-dessus, nous avons indexé le nom de l'étudiant via le numéro d'étudiant, alors comment y parvenir par son nom Quoi sur l'indexation du numéro d'étudiant ? Nous considérons l'index comme une méthode spéciale. La méthode peut utiliser la surcharge pour obtenir la même fonction avec des paramètres différents, de sorte que l'indexeur peut naturellement être surchargé. L'utilisation est similaire à la surcharge de méthode (cliquez ici pour voir la surcharge de méthode). Nous continuerons l'exemple ci-dessus. Cette fois, nous devons utiliser l'index de nom pour obtenir le numéro d'étudiant :

using System;  
using System.Collections.Generic;  
using System.Linq;  
using System.Text;  
  
namespace Test1  
{//定义一个能被索引的类  
    class Classes  
    {//对类的索引实质是对类中数组的索引  
       public string[] StudentName=new string[6];  
        //定义索引器  
       public string this[int ID]  
       {  
           get { return StudentName[ID]; }  
           set { StudentName[ID] = value; } //set访问器自带value参数  
         
       }  
        //重载索引器参数设为string类型  
       public uint this[string name]  
       {  
           get  
           { //找到与name匹配的学号  
               uint index=1;  
               while (StudentName[index] != name && index < 6)  
               { index++; }  
               return index;  
             
           }  
           set { }  
       }  
      
    }  
    class Program  
    {  
        static void Main(string[] args)  
        {  
            Classes class4 = new Classes();  
            //索引写入  
            for (int i = 1; i < 6; i++)  
            {  
                class4[i] = "HC"+i;  
            }  
            //索引读出，通过学号索引出姓名  
            for (int j = 1; j < 6; j++)  
            {  
                Console.WriteLine(j+"号\t"+class4[j]);  
            }  
            //通过姓名索引出学号  
            for (int k = 1; k < 6; k++)  
            {   
                string name="HC"+k;  
                Console.WriteLine(name+"\t"+class4[name]+"号");//对比上面用法一样参数不一样              
            }  
        }  
    }  
}

Résultat :

Nous avons dit plus haut que lorsqu'une classe définit un indexeur, cette classe peut être traitée comme un tableau. Lors de l'apprentissage des tableaux, nous savons que les tableaux ont plusieurs dimensions et indexeurs. catégorie? ? L'instruction de parcours foreach que nous utilisons pour parcourir le tableau peut-elle également être utilisée pour cette classe ? ? Je le présenterai dans le prochain article ! ! (Parce que l'école va avoir une panne de courant...) J'espère que vous continuerez à prendre en charge HC666^_^

Ce qui précède est le contenu du journal d'apprentissage C# 28 --- indexeur, indexeur surchargé. Pour plus de contenu connexe, veuillez prêter attention au site Web PHP chinois (www.php.cn) !