C# Indexers

An indexer allows an instance of a class or struct to be indexed as an array. If the user will define an indexer for a class, then the class will behave like a virtual array. Array access operator i.e ([ ]) is used to access the instance of the class which uses an indexer. A user can retrieve or set the indexed value without pointing an instance or a type member. Indexers are almost similar to the Properties. The main difference between Indexers and Properties is that the accessors of the Indexers will take parameters.

In the above syntax:

  • access_modifier: It can be public, private, protected or internal.
  • return_type: It can be any valid C# type.
  • this: It is the keyword which points to the object of the current class.
  • argument_list: This specifies the parameter list of the indexer.
  • get{ } and set { }: These are the accessors.

// C# program to illustrate the Indexer
using System;

// class declaration
class IndexerCreation 
{

// class members
private string[] val = new string[3]; 
// Indexer declaration
// public - access modifier
// string - the return type of the Indexer
// this - is the keyword having a parameters list
public string this[int index] 
{

// get Accessor
// retrieving the values 
// stored in val[] array
// of strings
get
{

return val[index];
}

// set Accessor
// setting the value at 
// passed index of val
set
{

// value keyword is used
// to define the value 
// being assigned by the
// set indexer. 
val[index] = value;
}
}
}

// Driver Class
class main {
// Main Method
public static void Main() {
// creating an object of parent class which
// acts as primary address for using Indexer
IndexerCreation ic = new IndexerCreation();

// Inserting values in ic[]
// Here we are using the object
// of class as an array
ic[0] = "C";
ic[1] = "CPP";
ic[2] = "CSHARP";

Console.Write("Printing values stored in objects used as arrays\n");
// printing values 
Console.WriteLine("First value = {0}", ic[0]);
Console.WriteLine("Second value = {0}", ic[1]);
Console.WriteLine("Third value = {0}", ic[2]);
}
}

Comments

Post a Comment

Popular posts from this blog

C# | Association, Aggregation and Composition

Image
Association, Aggregation, and Composition are terms that represent relationships among objects. They are very basic stuff of Object-Oriented Programming. Association Association is a relationship among the objects. Association is "*a*" relationship among objects. In Association, the relationship among the objects determines what an object instance can cause another to perform an action on its behalf. We can also say that an association defines the multiplicity among the objects. We can define a one-to-one, one-to-many, many-to-one and many-to-many relationship among objects. Association is a more general term to define a relationship among objects. Association means that an object "uses" another object. For example, Managers and Employees, multiple employees may be associated with a single manager and a single employee may be associated with multiple managers. Aggregation Aggregation is a special type of Association. Aggregation is "*the*" relationship amo...
Read more

Throw vs Throw ex in C#

In C#, the   "throw"   keyword is used to throw an exception when an error occurs in your code. However, there are two variations of the   "throw"   statement:   "throw"   and   "throw ex" . We will look at the distinctions between   "throw"   and   "throw ex"   in C# in this article. In C#, the  "throw"  keyword is used to declare an exception. When an exception is thrown, the code that can handle it uses a catch block to capture it. The  "throw"  keyword is typically used to throw a new exception object, which can be created using the  "new"  keyword. For example, look at the below code: C# Code: try    {        // Some code that could potentially throw an exception    }   catch  (Exception ex)   {        // Handle the exception  ...
Read more

String[] args in C#

String[] args is a parameter of the Main method that represents the command-line arguments passed to the application when it is executed1. For example, if you run your application like this: MyApp.exe arg1 arg2 arg3 The args array will contain three strings: "arg1", "arg2", and "arg3". You can use the args array to access the command-line arguments and perform different actions based on them. For example, you can write a program that copies a file from one location to another by passing the source and destination paths as arguments1. Here is a simple example of how to use String[] args in C#: public   class Program  {       static void Main(string[] args)     {          Console.WriteLine("Number of arguments: " + args.Length);          foreach (string arg in args)         {             Console.WriteLine("Argument: " + arg);       ...
Read more