Monday, November 15, 2010

C# - Position based indexers vs. Value based Indexer

Introduction


We all know that Array is nothing but sequential memory locations in which data are stored. Let us say the size of continues memory location is 80 KB and size of one unit of data is 2 KB. The statement implies that we have an array of 40 data in a sequential memory location. The below picture shows the above explanation:
Memory Blocks


For Example, Consider the below Array:

Department dpt = new Department[40];

If we assume the size required to store each department is 2 KB, we have 40-space block of size 2 KB is allocated to accommodate 40 department objects. Also, note that 40 objects are allocated in sequential order. So, how do we get the object at the third memory block? We do use the below statement:
Dpt[2]. What is [2] represents here? It says to take the object from the third memory block. So here, each memory blocks are referred by the Indexed location. So the notation [] is what called Indexer.

In this article, we will see how we can implement a Simple position based Indexer for our collection class. In the next article, we will explore, how we can implement Value based index.

The Product Class


Consider the below specified simple class which represents the product for a retail shop. It has two private data members a constructor and a public method to retrieve the product name.

//001: Product Class.
public class Product
{
 private int ProductId;
 private string ProductName;

 public Product(int id, string Name)
 {
    ProductId = id;
    ProductName = Name;
 }

 public string GetProdName()
 {
    return ProductName;
 }
}


The SuperMarket Class


As Every Super market have a collection of products, this class is going to have a collection of a product object. The members of this class is shown below:

//002: SuperMarket has collection of products. It implements Indexers.
public class SuperMarketX
{
            //002_1: Declaration
            private int pos;
            private Product[] Products;

“Pos” is to iterate through the Products collection. OK, you may get the idea now. SuperMarket is user defined (defined by us now) collection of Products.

The constructor of this class will take an array of products as a parameter and assigns it to the private member Products.  Note, that for this article, I am allocating fixed space 1000 and each space has null reference initially. We will replace the null reference with the passed in the array of objects. Below is the code for the Constructor:

//002_2: Constructor
public SuperMarketX(string shopname, params Product[] products)
{
            //002_2.1: Allocate the Space required
            this.Products = new Product[1000];
            pos = 0;

            //002_2.2: first set null to all the elements
            for (int i=0; i< 1000; i++)
                        Products[i] = null;

            //002_2.3: Assign the Array by taking the references from incoming array.
            //                                            The reference will replace the previous null assignment
            foreach (Product prd in products)
            {
                        Products[pos] = prd;
                        pos++;
            }
            this.shopname = shopname;
}

We have overridden the ToString() method to get the entire product in comma-separated format. The method implementation is shown below:

//004: Override the ToString to display all the Product Names as Comma Separated List
public override string ToString()
{
            string returnval = "";
            foreach (Product p in Products )
            {
                        if ( p != null )
                                    returnval = returnval + "," + p.GetProdName();
            }
            //Cut the leading "," and return
            return returnval.Substring(1, returnval.Length-1 );
}

[A] Simple Position based Indexer for SuperMarket Class


The indexer implemented just like the overloaded functions. To implement the [] notation follow the below Syntax:

public <ReturnType> this[<datatype> index]
Ex:
public Product this[int index]

Get an integer index from the caller give back a Product.


The Implementation Skeleton on the Simple Indexer is shown below:


In our case, we will implement the Index for the Supermarket. So using the Positional Index, a product will be retrieved. The way the index implemented will give a null reference to the caller when the index is out of Range Say below 0 or above 1000[This is the Maximum product supported by the super market].  Below is the function implementation:

//003: The Use of Indexer. Positional Indexer
public Product this[int index]
{
            get
            {
                        //003_1: Retrieve value based on positional index
                        if (index >= Products.Length || index < 0 )
                        {
                                    return null;
                        }
                        return Products[index];
            }
            set
            {
                        //003_2: Set the value based on the positional index
                        if (index >= Products.Length )
                        {
                                    return;
                        }
                        Products[index] = value ;
            }
}


Indexer Usage

Have a look at the below Code:

//Client 001: First Let us create an array to hold 6 Products.
Product[] theProdArray = new Product[6];

//Client 002: Create 6 individual Product and store it in the array
theProdArray[0] = new Product(1001, "Beer");
theProdArray[1] = new Product(1002, "Soda");
theProdArray[2] = new Product(1003, "Tea");
theProdArray[3] = new Product(1004, "Coffee");
theProdArray[4] = new Product(1005, "Apple");
theProdArray[5] = new Product(1006, "Grapes");

//Client 003: Super Market that holds six product collection
SuperMarketX market = new SuperMarketX("Z Stores", theProdArray);
Console.WriteLine("Product Available in Super Market: " + market );

//Client 004: Use the Simple Indexer to Assign the value
market[15] = new Product(1015, "Orange");
Console.WriteLine("Product Available in Super Market: " + market );

//Client 005: Use the Simple Indexer to retrieve the value
Product prod = market[5];
Console.WriteLine("The product retrieved is: " + prod.GetProdName() );

Blow is the Explanation

  1. Client 001: Creates the Array 6 Product.
  2. Client 002: Populates the product array. [ In real world Array will be populated from Database ]
  3. Client 003: SuperMarket is created with 6 New Products. Note that out supermarket capacity is 1000.
  4. Client 004: Uses the Indexer to add a new product to the Products collection. market[15] = new Product(1015, "Orange"); Will call the indexer with index = 15. new Product(1015, "Orange"); will be referred to the set portion of the Indexer using the  value  keyword.
  5. Client 005: Product prod = market[5]; SuperMarket Object accessed with Indexer [5]. We will move to get a portion of the Indexer and indexer returns Product at the position offset 5. The return object reference is assigned to prod.


[B] Simple Value based Indexer for SuperMarket Class


The previous indexer locates the memory block based on the Index by calculating the offset, as it knows the size of the memory block.  Now we will implement value-based index; that is we will get the product based on the ProductId value. I will walk through the changes done on the Classes.

1) The product class changed to have a setter method for ProductName, and a getter method for ProductId and an overridden method for ToString just to print Product Name. Below are the Changes:

public override string ToString()
{
            return ProductName;
}

public int GetProductId()
{
            return ProductId;
}

public void SetProductName(string newName)
{         
            ProductName = newName;
}


2) In the SuperMarketX class, a variable called numeric_index_mode is declared. This variable is used to decide the Indexer is referred in Positional Mode or in Value mode.

public int numeric_index_mode; //0-Position based index. 1-Value based Index.

Inside the constructor, indexer mode is initialized to 0. That means SuperMarket class by default treats the Indexer as Positional indexer and retrieves the product based on the positional offset calculated.

numeric_index_mode = 0;

3) A public function is implemented to retrieve the Positional index for the passed-in Product Id. Note, that the product id is unique for this Value based Index. The function will iterate through the Products in the SuperMarket and return when Product Id matched. It will return –1 when match not occurred. Below is the new function implemented to support the value-based index:

//005: Supporting function for value based Index
public int GetProduct(int Productid)
{
 for (int i = 0; i < Products.Length; i++)
 {
  Product p = Products[i];
  if ( p != null )
  {
   int prodid = p.GetProductId();
   if (prodid == Productid)
    return i;
  }
 }
    return -1;
}

Now let's go and change the Indexer.

1) First, in the get portion of the Indexer, wrap the existing code with an if construct. That is; when the Mode = 0, go with positional Index. It holds true for Set portion of the Indexer also. Below is the Change:

get
{
 //003_1: Retrieve Product based on positional index
 if (numeric_index_mode == 0)
 {
  if (index >= Products.Length || index < 0 )
  {
     return null;
  }
  return Products[index];
 }


set
{
 //003_2: Set the value based on the positional index
 if (numeric_index_mode == 0 )
 {
  if (index >= Products.Length )
  {
     return;
  }
  Products[index] = value ;
    }
}

2) If we are in Value mode, In the Get part of the indexer first get the positional index for the given product id. Once we have the positional index, we are ready to make a recursive call to same indexer routine. Make sure to set the indexer mode to 0 as we need to access the indexer to get the product based on the indexed position. Once we have the Product, reset index mode back to 1; that reset indexer mode to value based on the client code would expect that. Below is the Code for "Get" portion:

//003_2: Retrieve Product based on the Unique product Id
if(numeric_index_mode == 1)
{
 int idx = GetProduct(index);
 if (idx == -1)
  return null;
 else
 {
  //Key statement to avoid invalid recursion
  numeric_index_mode = 0;
  Product ret_Product = this[idx]; //Recursive call to Indexer
  numeric_index_mode = 1; //Reset it back to user preference
  return ret_Product;
 }
}

3) Set portion of the Indexer also changed in the same way. I hope further explanation not required:

//003_3: Set the value based on the Id Passed in.
if(numeric_index_mode == 1)
{
 int idx = GetProduct(index);
 if (idx == -1)
  return ;
 else
 {
  //Key statement to avoid invalid recursion
  numeric_index_mode = 0;
  Products[idx] = value;
  numeric_index_mode = 1; //Reset it back to user preference
 }
}

Usage of Value based indexer


Code below explains how do we switch from Position based indexer to Value based indexer, use value based indexer and go back to default indexer mode. The commented code is self-explanatory. Hence no more explanation. Dot.

//=====> Value based Index     <=======
//Now we will operate on the Value based Index
market.numeric_index_mode = 1;
//Client 006: Display name of the product whose product id is 1005
Console.WriteLine("Name of the Product represented by Id 1005 is: {0}", market[1016]);

//Client 007: The aim is Replace the Product Soda with Iced Soda and maintain same product id. The Id of Soda is 1002.
if (market[1002] != null )
{
 market[1002].SetProductName("Iced Soda");
 Console.WriteLine("Product Available in Super Market: " + market );
}

//Client 008: Remove Tea and Add French Coffee. Note the Object in the Indexed location will be changed.
//Note: Here check for the null is not required. Kind of Modify on fail Add
market[1003] = new Product(1007, "French Coffee");
Console.WriteLine("Product Available in Super Market: " + market );

//======> Reset back to Standard Positional Index    <=================
market.numeric_index_mode = 0;

Closing Notes


1) You can implement string value based indexer also. The skeleton is:

public Product this[string ProductName]
{
Set{}
Get{}
}

2) As our positional based index takes the index as an integer, we introduced numeric_index_mode. If I implement string-based index the mode switching is not required. The alternate implementation for the Value-based product id is to convert the product id into a string and use the string-based index.


Attachments


Indexer_src: Source code for the indexer.
Indexer_exe: Executable for Indexer. Run it in the command prompt. Map the output with the below client code:

class ProgramEntry
{
 [STAThread]
 static void Main(string[] args)
 {
  //Client 001: First Let us create an array to hold 6 Products.
  Product[] theProdArray = new Product[6];

  //Client 002: Create 6 individual Product and store it in the array
  theProdArray[0] = new Product(1001, "Beer");
  theProdArray[1] = new Product(1002, "Soda");
  theProdArray[2] = new Product(1003, "Tea");
  theProdArray[3] = new Product(1004, "Coffee");
  theProdArray[4] = new Product(1005, "Apple");
  theProdArray[5] = new Product(1006, "Grapes");

  //Client 003: Super Market that holds six product collection
  SuperMarketX market = new SuperMarketX("Z Stores", theProdArray);
  Console.WriteLine("Product Available in Super Market: " + market );

  //Client 004: Use the Simple Indexer to Assign the value
  market[15] = new Product(1015, "Orange");
  Console.WriteLine("Product Available in Super Market: " + market );

  //Client 005: Use the Simple Indexer to retrieve the value
  Product prod = market[5];
  Console.WriteLine("The product retrieved is: " + prod.GetProdName() );

  //=====> Value based Index     <=======
  //Now we will operate on the Value based Index
  market.numeric_index_mode = 1;
  //Client 006: Display name of the product whose product id is 1005
  Console.WriteLine("Name of the Product represented by Id 1005 is: {0}", market[1016]);

  //Client 007: The aim is Replace the Product Soda with Iced Soda and maintains same product id. The Id of Soda is 1002.
  if (market[1002] != null )
  {
     market[1002].SetProductName("Iced Soda");
     Console.WriteLine("Product Available in Super Market: " + market );
  }

  //Client 008: Remove Tea and Add French Coffee. Note the Object in the Indexed location will be changed.
  //Note: Here check for the null is not required. Kind of Modify on fail Add
  market[1003] = new Product(1007, "French Coffee");
  Console.WriteLine("Product Available in Super Market: " + market );

  //======> Reset back to Standard Positional Index    <=================
  market.numeric_index_mode = 0;
  //Dot
 }
}

Source Code: Download

No comments:

Post a Comment

Leave your comment(s) here.

Like this site? Tell it to your Firend :)