Indexers
These are near
similar to Properties that are used for providing access to an array outside of
the class. Once an Indexer is defined on a class the object of that class will
work like an array providing access to the values of array i.e. defined inside
it.
- Add a class
IndexerDemo.cs and write the following:
|
using System;
namespace oopsProject
{
public class IndexerDemo
{
//Private array
declaretion
string[] arr;
public IndexerDemo(int size)
{
// initializing array with
a size
arr = new string[size];
// Assigning the default
value to array
for (int i
= 0; i < size; i++)
arr[i] = "empty";
}
// defining an indexer to
access the array out of the class
public string
this[int
index]
{
get { return
arr[index]; }
set { arr[index] = value; }
}
}
}
|
- Add a class
TestIndexer.cs and write the following:
|
using System;
namespace oopsProject
{
class TestIndexer
{
static void
{
IndexerDemo obj = new IndexerDemo(6);
for (int i
= 0; i < 6; i++) ;
Console.Write(obj[i] +" ");
Console.WriteLine();
obj[1] = "red"; obj[3] = "blue"; obj[5] = "green";
for (int i
= 0; i < 6; i++) ;
Console.Write( obj[i] + " ");
Console.ReadLine();
}
public static
int i { get; set; }
}
}
|
Delegates
- These are similar to function pointers, which are avilabel in our traditional languages like C and C++ which provides an option to invoke a function with them, which will be faster in execution.
- These function pointers are provided under .net languages in a form of Delegates which can be referred as pointer to the method.
- Invocation of a method can be done in Two different ways
- We can invoke a method directly using object of the class.
- We can invoke a method without object of a class using a Delegate, which is faster in execution when compared with first process.
Note – A Delegate is also a type (Reference type).
Using Delegates: - To use a delegate adopt blow process.
Step 1:
Delegate Declearetion
Here we need to declare a delegate for
invoking the method where IO parameters for the Delegate should matched with IO
parameters of Method it has to call.
Syntax –
|
[<modifiers>] delegate <void |type> <name>
[<param def’s>]
|
Eg 1 :-
|
public void Add (int x, int y)
{
Console.WriteLine(x +y);
}
public delegate void AddDel( int x,
int y);
|
Eg 2 :-
|
public string SayHello (string name)
{
return “Hello “ + name;
}
public delegate string SayDel(string
name);
|
Step 2:
Creating Object of Delegate
As a delegate is also a type, to
consume it we need to create object of it. While creating the object we need to
pass the method as a parameter to its constructor, which we want to call using
the delegate.
|
AddDel ad = new AddDel(Add);
SayDel sd = new SayDel(SayHello);
|
Step 3:
Invoking the Delegate to Execute the Method
Now we can call the delegate for any number of times so that the method gets
executed, where each delegate uses a separate Stack to execute the method for
any number of times.
|
ad (100,50) ; ad (1046,54) ; ad
(237,265) ;
sd (“xxx”); sd (“yyy”); sd (“zzz”);
|
Note – A delegate can be declared either
within a namespace or within a class also.
- Add a class DelClass.cs
and write the following:
|
using System;
namespace oopsProject
{
class DelClass
{
public string
SayHello(String name)
{
return "Hello " + name;
}
public delegate
string SayDel(string name);
static void
{
DelClass obj = new DelClass();
SayDel sd = new SayDel(obj.SayHello);
Console.WriteLine(sd("prabhu"));
Console.WriteLine(sd("nitya"));
Console.WriteLine(sd("choure"));
Console.ReadLine();
}
}
}
|
Delegetes are of two types
1. Uni-cast or Single-Cast delegates
2. Multi- Cast delegates
- If a delegate is used for invoking only a single method, it is
a single cast delegate.
- If we can use a delegate for invoking more than one method
also i.e. a multi-cast delegate, but if we want to invoke multiple methods
using a single delegate then all the method should have the same io parameters.
- Add a class
MultiDel.cs and write the following:
|
using System;
namespace oopsProject
{
class MultiDel
{
public void
Add(int x, int y)
{
Console.WriteLine("Add : " + (x + y));
}
public void
sub(int x, int y)
{
Console.WriteLine("sub : " + (x - y));
}
public void
mul(int x, int y)
{
Console.WriteLine("mul : " + (x * y));
}
public void
div(int x, int y)
{
Console.WriteLine("div : " + (x / y));
}
static void
{
MultiDel obj = new MultiDel();
Math m = new Math(obj.Add);
m += obj.sub; m += obj.mul; m += obj.div;
m(100, 50);
Console.WriteLine();
m(1844, 5230);
Console.WriteLine();
m -= obj.mul;
m(1023, 523);
Console.WriteLine();
Console.ReadLine();
}
}
}
|
Note – The advantage with multicast delegate
is, a single delegate call will execute all the method that is bound to it at a
time.
0 Comments