C# 索引器的理解和使用

概述
此部分内容引用自MSDN文档
运用索引器能够用类似于数组的办法为对象树立索引。
get取值函数返回值。set取值函数分配值。
this关键字用于界说索引器。
value关键字用于界说set索引器所赋的值。
索引器不必根据整数值进行索引；由你决定如何界说特定的查找机制。
索引器可被重载。
索引器能够有多个形参，例如当拜访二维数组时。
我对索引器的理解就是，他是一个读写自界说类中的数据调集的接口，衔接自界说类中的数据调集，并可对其进行读写操作
经过该接口简化或许丰厚对自界说类中数据调集的操作办法
索引器实践上相当于一个办法，支撑多个及多种类型的参数，不同的是，其返回值不可为void，并且索引器除可传入参数外，还可对其进行赋值，即it[0]=”测验数据0″
创立索引器时，其返回值类型亦为其value关键字所运用的类型，即界说了返回值类型的一起，也界说了其可接受的值类型
索引器运用要素
创立索引器时有几部分内容是有必要的：
有必要先创立索引器所需求的容器（我把它称为容器，暂时还没看到有对它的具体界说）
创立索引器需求运用this关键字
索引器中有必要要包括get和set拜访器，在C#7.0能够运用表达式主体（=>）简化
在运用表达式主体成员完结索引器时，有必要额定供给容器的修正接口，由于经过表达式主体完结的索引器是不包括set关键字的
单参数索引器
此索引器运用简略的string数组作为容器，此索引器运用int类型的i进行索引，返回值为string类型。
classSampleIndxer{
//可供索引器运用的容器，暂用数组privatestring[]sampleStrArr=newstring[10];
//创立索引器publicstringthis[inti]
{
get{returnsampleStrArr[i];}
set{sampleStrArr[i]=value;}
}
}classTest{
publicstaticvoidtest()
{
//简略索引器测验SampleIndxerit=newSampleIndxer();
it[0]=”测验数据0″;
it[1]=”测验数据1″;
Console.WriteLine(“it[0]:”+it[0]);
Console.WriteLine(“it[1]:”+it[1]);
Console.ReadLine();
}
}
索引器中一起也能够运用泛型作为参数
classSampleGenericIndexer<T>
{//可供索引器运用的主体变量，暂用泛型数组替代privateT[]sampleGenericStrArr=newT[10];publicTthis[inti]
{get{returnsampleGenericStrArr[i];}set{sampleGenericStrArr[i]=value;}
}
}classTest{
publicstaticvoidtest()
{
//泛型索引器测验SampleGenericIndexer<string>it=newSampleGenericIndexer<string>();
it[0]=”测验数据0″;
it[1]=”测验数据1”;
Console.WriteLine(“it[0]:”+it[0]);
Console.WriteLine(“it[1]:”+it[1]);
Console.ReadLine();
}
}
在C#7.0之后能够经过表达式主体完结索引器，需求留意的是，经过表达式主体完结索引器时，有必要供给数据修正的接口，由于经过表达式主体完结索引时仅供给了get拜访器，并未供给set拜访器。或许将容器的可拜访性设置为运用该类的当地能够拜访，直接对容器进行数据操作，仅运用索引器进行数据的读取。
classExpressionBodyIndexer<T>
{//可供索引器运用的主体变量，暂用泛型数组替代privateT[]expressionBodyStrArr=newT[10];//符号当时索引器的中已初始化数据的索引位置intnextIndex=0;//运用表达式主体(ExpressionBody)界说简化界说索引器publicTthis[inti]=>expressionBodyStrArr[i];//////表达式主体办法界说的索引器无法经过索引值设置其中的值///由于此状态下，索引器的数据为只读状态///有必要向外供给赋值的办法//////publicvoidAdd(Tvalue){if(nextIndex>=expressionBodyStrArr.Length)
{thrownewIndexOutOfRangeException($”当时调集数据已满，共{expressionBodyStrArr.Length}组数据”);
}
expressionBodyStrArr[nextIndex++]=value;
}
}classTest{publicstaticvoidtest(){//泛型索引器测验ExpressionBodyIndexer<string>it=newExpressionBodyIndexer<string>();//此条件下不可经过it[0]索引办法进行数据增加，由于他是只读的//有必要经过供给的Add办法增加数据it.Add(“测验数据0”);
it.Add(“测验数据1”);
it.Add(“测验数据2”);
Console.WriteLine(“it[0]:”+it[0]);
Console.WriteLine(“it[1]:”+it[1]);
Console.WriteLine(“it[2]:”+it[2]);
Console.ReadLine();
}
}
索引器既然是能够简化或许丰厚对自界说类中数据调集的操作办法，那么自然也能够运用略微复杂点的数据调集作为索引器的容器。本例中运用Dictionary作为容器。
classVariableLengthIndexer{//////可供索引器运用的容器，此处运用Dictionary替代，///完结运用string类型数据当作索引器的指针，一起完结索引器的可变长度///privateDictionary<string,string>dic=newDictionary<string,string>();//////运用表达式主体创立索引器/////////publicstringthis[strings]=>dic[s];publicvoidAdd(stringkey,stringvalue){if(dic.ContainsKey(key))
{
dic[key]=value;
}else{
dic.Add(key,value);
}
}
}classTest{publicstaticvoidtest(){//泛型索引器测验VariableLengthIndexerit=newVariableLengthIndexer();//此条件下不可经过it[0]索引办法进行数据增加，由于他是只读的//有必要经过供给的Add办法增加数据it.Add(“数据0″,”测验数据0”);
it.Add(“数据1″,”测验数据1”);
it.Add(“数据2″,”测验数据2”);
Console.WriteLine(“it[数据1]:”+it[“数据1”]);
Console.WriteLine(“it[数据2]:”+it[“数据2”]);
Console.WriteLine(“it[数据3]:”+it[“数据3″]);
Console.ReadLine();
}
}
前面的几个比如中，仅仅是关于索引器的认识，实践工作中并没有运用价值，由于所作的操作完全能够运用.NET中预界说的数据调集完结。个人觉得C#7.0之后供给的表达式主体实践效果并不大，甚至没有必要。个人认为索引器最大价值存在于get和set拜访器中关于数据操作的自界说处理，能够在拜访器中对数据进行修正或许过滤，这才是其比较好的价值体现。
经过在索引器中对数据处理做封装，能够简化往常大部分的操作，此类也可根据实践情况嵌入到数据库拜访实体类中。
//////本实例经过考试成果的处理演示索引器对数据处理的进程///classTestScore{privateDictionary<string,int>scores=newDictionary<string,int>();publicstringthis[strings]
{get{if(!scores.ContainsKey(s))
{return$”十分抱愧，{s}的成果尚未录入”;
}switch(scores[s])
{case10:case20:case30:case40:case50:return$”很惋惜，{s}不及格，分数仅为{scores[s]}”;case60:case70:return$”考的不错，{s}已及格，分数为{scores[s]}”;case80:case90:return$”成果优异，{s}成果优异，分数为{scores[s]}”;case100:return$”十分优异，{s}获取满分{scores[s]}分”;default:return$”{s}的成果或许存在反常，分数为{scores[s]}”;
}
}set{if(int.TryParse(value,outintv))
{//对分数做四舍五入处理v=(int)Math.Round(v*0.1)*10;if(!scores.ContainsKey(s))
{
scores.Add(s,v);
}else{
scores[s]=v;
}
}
}
}
}classTest{publicstaticvoidtest(){
TestScorets=newTestScore();
ts[“张三”]=”23″;
ts[“李四”]=”54″;
ts[“王二”]=”66″;
ts[“麻子”]=”89″;
ts[“王朝”]=”100″;
ts[“马汉”]=”5″;
ts[“老王”]=””;
Console.WriteLine(ts[“张三”]);
Console.WriteLine(ts[“李四”]);
Console.WriteLine(ts[“王二”]);
Console.WriteLine(ts[“麻子”]);
Console.WriteLine(ts[“王朝”]);
Console.WriteLine(ts[“马汉”]);
Console.WriteLine(ts[“老王”]);
Console.ReadLine();
}
}
多参数索引器
前面经过单参数所以其的完结分析了索引器的运用办法即或许的运用范围，下面进行下简略的拓展，分析多参数索引器的运用办法，仍旧运用上面分数的比如做演示。
structStudent
{publicstringName;publicstringClasses;publicstringGrade;publicintScore;publicoverridestringToString(){return$”{this.Grade}\t{this.Classes}\t{this.Name}\t{this.Score}”;
}
}publicclassArrayList1:ArrayList{publicoverrideboolContains(objectitem){if(item.GetType().ToString()==”Student”)
{foreach(varainthis)
{if(a.GetType().ToString()==”Student”)
{vars1=(Student)a;vars2=(Student)item;if(s1.Name==s2.Name&&s1.Classes==s2.Classes&&s1.Grade==s2.Grade)
{returntrue;
}returnfalse;
}
}
}returnbase.Contains(item);
}
}classTestScore{publicArrayList1ArrList=newArrayList1();publicstringthis[stringname,stringgrade,stringclasses]
{get{stringrtn=””;foreach(StudentainArrList)
{if(a.Name==name&&a.Classes==classes&&a.Grade==grade)
{switch(a.Score)
{case10:case20:case30:case40:case50:
rtn=$”很惋惜，{name}不及格，分数仅为{a.Score}”;break;case60:case70:
rtn=$”考的不错，{name}已及格，分数为{a.Score}”;break;case80:case90:
rtn=$”成果优异，{name}成果优异，分数为{a.Score}”;break;case100:
rtn=$”十分优异，{name}获取满分{a.Score}分”;break;default:
rtn=$”{name}的成果或许存在反常，分数为{a.Score}”;break;
}
}
}if(rtn==””)
{return$”十分抱愧，{name}的成果尚未录入”;
}returnrtn;
}set{if(int.TryParse(value,outintv))
{//对分数做四舍五入处理v=(int)Math.Round(v*0.1)*10;
Studentst=newStudent
{
Name=name,
Grade=grade,
Classes=classes,
Score=v
};//重复项，不再刺进，避免查找时呈现重复if(!ArrList.Contains(st))
{
ArrList.Add(st);
}
}
}
}
}classTest{publicstaticvoidtest(){
TestScorets=newTestScore();
ts[“张三”,”三年级”,”二班”]=”23″;
ts[“李四”,”三年级”,”二班”]=”54″;
ts[“王二”,”三年级”,”二班”]=”66″;
ts[“麻子”,”三年级”,”二班”]=”89″;
ts[“王朝”,”三年级”,”二班”]=”100″;
ts[“马汉”,”三年级”,”二班”]=”5″;
ts[“老王”,”三年级”,”二班”]=””;
Console.WriteLine(“查看存入的数据：”);
Console.WriteLine($”共存入了：{ts.ArrList.Count}组数据”);
Console.WriteLine();//不运用索引器，直接拜访实例中的容器foreach(Studentsints.ArrList)
{
Console.WriteLine(s.ToString());
}
Console.WriteLine();
Console.WriteLine(ts[“张三”,”三年级”,”二班”]);
Console.WriteLine(ts[“李四”,”三年级”,”二班”]);
Console.WriteLine(ts[“王二”,”三年级”,”二班”]);
Console.WriteLine(ts[“麻子”,”三年级”,”二班”]);
Console.WriteLine(ts[“王朝”,”三年级”,”二班”]);
Console.WriteLine(ts[“马汉”,”三年级”,”二班”]);
Console.WriteLine(ts[“老王”,”三年级”,”二班”]);
Console.ReadLine();
}
}
一起二维数组中多个参数的完结办法，同样也支撑二维数组
publicstring[,]sampleStrArr=newstring[10,10];publicstringthis[intx,inty]
{get{returnsampleStrArr[x,y];}set{sampleStrArr[x,y]=value;}
}publicstaticvoidtest(){
SampleIndxerit=newSampleIndxer();
it[0,0]=”测验数据0,0″;
it[0,1]=”测验数据0,1″;
it[1,1]=”测验数据1,1″;
it[1,2]=”测验数据1,2″;
it[3,3]=”测验数据3,3″;
Console.WriteLine(“it[0,0]:”+it[0,0]);
Console.WriteLine(“it[0,1]:”+it[0,1]);
Console.WriteLine(“it[1,1]:”+it[1,1]);
Console.WriteLine(“it[1,2]:”+it[1,2]);
Console.WriteLine(“it[3,3]:”+it[3,3]);
Console.ReadLine();
}
索引器的重载
前面说过，索引器相当于一个办法，他们同样都支撑重载。与办法不同的是，索引器没有独立的名称，只能经过返回值的不同和参数的不同来区分不同的签名，从而完结重载。
classVariableLengthIndexer{privateDictionary<string,int>dic=newDictionary<string,int>();//经过Key，查找Valuepublicintthis[strings]
{get{returndic[s];}
}//经过Value查找Keypublicstringthis[intnum]
{get{returndic.Where(x=>x.Value==num).Last().Key;}
}//经过Value查找Key，增加无效参数num1演示重载publicstringthis[intnum,intnum1]
{get{returndic.Where(x=>x.Value==num).Last().Key;}
}publicvoidAdd(stringkey,intvalue){if(dic.ContainsKey(key))
{
dic[key]=value;
}else{
dic.Add(key,value);
}
}
}classTest{publicstaticvoidtest(){//泛型索引器测验VariableLengthIndexerit=newVariableLengthIndexer();
it.Add(“测验数据1”,1);
it.Add(“测验数据2”,2);
it.Add(“测验数据3”,3);
it.Add(“测验数据4”,4);//经过Key查找ValueConsole.WriteLine(“经过Key查找Value”);
Console.WriteLine(“Key:测验数据1,Value:”+it[“测验数据1”]);
Console.WriteLine(“Key:测验数据2,Value:”+it[“测验数据2”]);
Console.WriteLine(“Key:测验数据3,Value:”+it[“测验数据3”]);
Console.WriteLine(“Key:测验数据4,Value:”+it[“测验数据4”]);//经过Value查找KeyConsole.WriteLine(“经过Value查找Key”);
Console.WriteLine(“Value:1,Key:”+it[1]);
Console.WriteLine(“Value:2,Key:”+it[2]);
Console.WriteLine(“Value:3,Key:”+it[3]);
Console.WriteLine(“Value:4,Key:”+it[4]);//经过Value查找Key，并增加无效参数传入Console.WriteLine(“经过Value查找Key，并增加无效参数传入”);
Console.WriteLine(“Value:1,Key:”+it[1,1]);
Console.WriteLine(“Value:2,Key:”+it[2,2]);
Console.WriteLine(“Value:3,Key:”+it[3,3]);
Console.WriteLine(“Value:4,Key:”+it[4,4]);
Console.ReadLine();
}
}