Using Indexers in C#

來源:互聯網
上載者:User
An indexer enables you to use an index on an object to obtain values stored within the object. In essence this enables you to treat an object like an array.

An indexer is also similar to a property. As with properties, you use get and set when defining an indexer. Unlike properties, you are not obtaining a specific data member; rather, you are obtaining a value from the object itself. When you define a property, you define a property name. With indexers, instead of creating a name as you do with properties, you use the this keyword, which refers to the object instance and thus the object name is used. The format for defining an indexer is

public dataType this[int index]
{
    get
    {
         // Do whatever you want...
         return aValue;
    }
    set
    {
         // Do whatever you want
         // Generally you should set a value within the class
         // based on the index and the value they assign.
    }
}    

Creating an indexer enables you to use bracket notation ([]) with an object to set and get a value from an object. As you can see in the format shown earlier, you state the dataType that will be set and returned by the indexer. In the get section, you return a value that is of dataType. In the set block, you will be able to something with a value of dataType. As with properties and member functions, you can use the value keyword. This is the value passed as the argument to the set routine. Listing 1 presents a simple example of using an indexer.

Listing 1. Using an Indexer

1:  //  indx2.cs - Using an indexer
2:  //--------------------------------------------------
3:  
4:  using System;
5:  
6:  public class SpellingList
7:  {
8:      protected string[] words = new string[size];
9:      static public int size = 10;
10:  
11:      public SpellingList()
12:      {
13:          for (int x = 0; x < size; x++ )
14:              words[x] = String.Format("Word{0}", x);
15:      }
16:  
17:      public string this[int index]
18:      {
19:          get
20:          {
21:              string tmp;
22:  
23:              if( index >= 0 && index <= size-1 )
24:                 tmp = words[index];
25:              else
26:                 tmp = "";
27:  
28:              return ( tmp );
29:          }
30:          set
31:          {
32:              if( index >= 0 && index <= size-1 )
33:                words[index] = value;
34:          }
35:      }
36:  }
37:  
38:  public class TestApp
39:  {
40:     public static void Main()
41:     {
42:        SpellingList myList = new SpellingList();
43:  
44:        myList[3] = "=====";
45:        myList[4] = "Brad";
46:        myList[5] = "was";
47:        myList[6] = "Here!";
48:        myList[7] = "=====";
49:  
50:        for ( int x = 0; x < SpellingList.size; x++ )
51:            Console.WriteLine(myList[x]);
52:     }
53:  }

The output from this listing is:

Word0
Word1
Word2
=====
Brad
was
Here!
=====
Word8
Word9

This listing creates an indexer to be used with the SpellingList class. The SpellingList class contains an array of strings called words that can be used to store a list of words. This list is set to the size of the variable declared in line 9.

Lines 11 to 15 contain a constructor for SpellingList that sets initial values into each element of the array. You could just as easily have requested the words from the reader or read them from a file. This constructor assigns the string value Word## to each of the elements in the array, where ## is the element number of the array.

Jumping down to the TestApp class in lines 38 to 53, you see how the SpellingList class is going to be used. In line 42, the SpellingList class is used to instantiate the myList object that will hold the words. Line 42 also causes the constructor to be executed. This initializes the Word## values. Lines 44 to 48 then change some of these values.

If you think back to how you worked with arrays, you should be saying, "wait a minute" as you look at lines 44 to 48. To access the value of one of the words, you would normally have to access the data member within the object. When using arrays as a data member, you learned that you would assign a value to the fourth element as

MyList.words[3] = "=====";

Line 44, however, is accessing the fourth element within the object, which has been set to be the fourth element in the words array.

An indexer has been created for the SpellingList class in lines 17 to 35. This indexer enables you to access the elements within the words array using just the object name.

Line 17 is the defining line for the indexer. You know this is an indexer rather than a property because the this keyword is used instead of a name. Additionally, this is given an index (called index). The indexer will return a string value.

Lines 19 to 29 contain the get portion of the indexer. The get block returns a value based on the index. In this class, this value is an element from the words array. You can return any value you want. The value should, however, make sense. In line 23, a check is done to make sure the index value is valid. If you don't check the value of the index, you risk having an exception thrown. In this listing, if the index is out of the range, a null value is returned (line 26). If the index is valid, the value stored in the words array at the index location will be returned.

The set portion of the indexer is in lines 30 to 34. This block can be used to set information within the object. As with properties, the value keyword contains the value being assigned. In this code, the index value is again checked to make sure it is valid. If it is, a word in the words array will be updated at the index location with the value assigned.

Looking again at the test class, you see that the set indexer block is used to assign values in lines 44 to 48. For line 44, the set indexer block will be called with value equal to ===== and will be passed with an index value of 3. In line 45, value will be Brad and the index is 4. In line 51, the get indexer block is called with an index value of x. The value returned will be the string value returned by the get indexer block.

There are times to use indexers and there are times to not use them. You should use indexers when it makes your code more readable and easier to understand. For example, you can create a stack that can have items placed on it and taken off of it. Using an indexer, you could access items within the stack without needing to remove items.



相關文章

聯繫我們

該頁面正文內容均來源於網絡整理,並不代表阿里雲官方的觀點,該頁面所提到的產品和服務也與阿里云無關,如果該頁面內容對您造成了困擾,歡迎寫郵件給我們,收到郵件我們將在5個工作日內處理。

如果您發現本社區中有涉嫌抄襲的內容,歡迎發送郵件至: info-contact@alibabacloud.com 進行舉報並提供相關證據,工作人員會在 5 個工作天內聯絡您,一經查實,本站將立刻刪除涉嫌侵權內容。

A Free Trial That Lets You Build Big!

Start building with 50+ products and up to 12 months usage for Elastic Compute Service

  • Sales Support

    1 on 1 presale consultation

  • After-Sales Support

    24/7 Technical Support 6 Free Tickets per Quarter Faster Response

  • Alibaba Cloud offers highly flexible support services tailored to meet your exact needs.