Helpful Keywords

1. __arglist

Lets start with __arglist. __arglist is used to send parameters to a method. Generally we used to send parameters to a function by having a list of arguments specified in the method head. If we want to pass a new set of arguments we need to have Method Overloading. Even when we want to send any number of arguments we might use param array.

Now why should we use __arglist. In case of each of these methods, the problems are :

1. If we use Method Overloading, we might have to add new methods whenever a new set of argument list is thought to be sent.
2. If we use param array we need to have same type of arguments or need to have param array of objects.


__arglist releaves each of those. It can send any no of argument to a function. It might be of any type and we can parse each argument easily using simple steps.

Lets have a look at the Code :


public int paramLength(__arglist)
{
ArgIterator iterator = new ArgIterator(__arglist);
return iterator.GetRemainingCount();
}


Now if I call the function using this statement

int x = this.paramLength(__arglist(49,34,54,6,"Manimoy")); // returns 5


5 will be returned to the variable x. It is because we send 5 arguments to the method. We can access each methods using :


TypedReference tf = iterator.GetNextArg();
TypedReference.ToObject(tf)

On each call to GetNextArg, the GetRemainingCount will decrease by one until it wipes out each objects set to the iterator.

2. __refvalue


Another interesting keyword you can use instead is __refvalue. It is used to fetch the value from a reference object. You can use this to get the actual object from TypedReference object.

It takes 2 arguments, first one is the object of TypedReference and the Type in which to cast. Take a look on the line below :


int tfValue = __refvalue(tf, int);

On the execution of the line tfValue will be assigned to the value of the integer where tf is pointing.

3. __makeref


Another undocumented keyword is __makeref which will give the TypedReference object from the object itself. This is just the reverse to __refvalue. Take a look at the code below :


string name = "Ayan";
TypedReference tf = __makeref(name);
4. __reftype

__reftype is used to get Type object from a TypedReference. Have a look at the code below to understand the use :


Type t = __reftype(tf);
if(t.ToString().equals("System.String"))
string str = __refvalue(t,string);

Note : Though I found these keywords in all the versions of C#, yet I dont use it in production environment. There is no sureity of these keywords to be there in future version of C#, so use it in your own risk.


Documented Yet Uncommon


In this section, I am going to discuss some of the uncommon documented keywords which is not needed very often while we do programs. Let us discuss the most common one here in this section.
1. Yield

Yield is a keyword introduced in .NET 2.0, is used to yield a list of return statements in the form of IEnumerable. The block which yields IEnumerable is commonly called as iterator block. In the code below, I have created a list of few names and returned the list of all of them which has lenght less than 5 until it reaches yield break statement for a length <12


List< string < lst = new List< string <();
lst.Add("Abhishek");
lst.Add("Abhijit");
lst.Add("Manimoy");
lst.Add("Raj");
lst.Add("Ayan");
lst.Add("MacMillanRojer");
lst.Add("Rizzuto");
foreach (string x in lst)
{
if (x.Length < 12) // Breaks on MacMillanRojer
yield break;
else if (x.Length < 5) // Only returns those which are having length <5
yield return x;
else continue;
}


Actually the yield return x will evaluate each elements and creates the enumerable of all the elements that satisfies the condition(length <5).
The break statement will terminate the loop and return the existing Enumerable created.

2. Fixed

Another uncommon keyword is Fixed which can only be used in Unsafe C# code blocks. Fixed statement sets the pointer to be in a fixed memory address so that, it will not be moved to anywhere even if Garbage Collection Thread is invoked. Let us have a look at the code below:


int[] a = new int[] { 1, 2, 3 };
fixed (int* pt = a)
{
int* c = pt;
MessageBox.Show("Value : " + *c);
// This will fix the variable totally so that it will
// not be moved when Garbage collector is invoked.
}

Here, the Pointer c is be assigned the same location as pt.

Fixed often comes at a cost. It is actually hampers the normal process of Garbage collection. Thus if is good to avoid fixed statement if not actually needed.

3 Checked / Unchecked


Another keyword called checked which is used to control arithmetic overflow context. Checked keyword throws StackOverflowException when an arithmetic operation overflows the necessary size.

Take a look at the code :


int x = int.MaxValue;
int y = int.MaxValue;
int z = checked(x + y);

The above statement throws StackOverflowException when x+y is invoked. The checked is used to check the overflow in arithmetic calculations and throw exception accordingly. z is assinged to 0 when StackOverflowException occurs.

We might use unchecked keyword when we dont need to throw exception.


int x = int.MaxValue;
int y = int.MaxValue;
int z = unchecked(x + y);

Through execution of above code the value of z will be assinged to -2.
4. Volatile


Volatile keyword is used to define a variable which is to be modified across multiple threads without invoking lock statements. Volatile variables are not subject to compiler optimization and thus we will get the most updated value of the variable all the time. See the example below :

public volatile int i;
Thread th = new Thread(new ThreadStart(VolatileInvoke));
th.Start();
Thread.Sleep(5000); //Holds current Thread for 5 seconds.
MessageBox.Show("Value of i : " + i);
th.Abort();

private void VolatileInvoke()
{
while (true)
{
i++;
}
}

The thread is started and will increment the volatile integer value by 1 until it is aborted by the main thread.

Note : Volatile types dont have Thread optimization.
5. StackAlloc


It is also used with unsafe C# code which allocates memory dynamically from stack. stackalloc is used to aquire memory quickly when it is very essential to get a large amount of memory. We can declare an array like this :


int* array = stackalloc new int[1000]
The memory is available as soon as the statement is invoked.

6. Global ::


It is very handy when local namespace hides global namespace. Suppose we have created a class named System in our project. C# allowes to do that. But the problem is that whenever I want to call System that is defined in the global space, we unable to do that without using global::. Let us see the example below :


internal class System
{
internal class Array :IEnumerable
{
public int Length
{
get{return 1000}
}
#region IEnumerable Members
public IEnumerator GetEnumerator()
{
Debug.Write("This is Dummy Array");
this.GetEnumerator();
}

#endregion
}
}

Now if you want to call System.Array it will call the one defined locally. To call global System we need to use global::System

It is always better to use global:: when you are sure of calling the global namespace. This ensures your code to work even in this sort of weird situations.

7. Namespace Alias


Namespace alias are used when you want to shorten a long namespace. To do that :


using Abhishek = System.Drawing;
public class X
{
public X()
{
Abhishek.Graphics g = this.CreateGraphics();
}
}

Here in the header we made an alias Abhishek of System.Drawing. Thus within the code if we refer to Abhishek, it will be same as referring to System.Drawing.

8. extern alias

Most of us while working with C# have used external control sets. There may come a situation when we want to add 2 versions of dlls in the same application with same Fully Qualified Namespaces. In such cases we need extern alias feature to refer to two different assemblies.
For example:

Suppose we add an assembly x10.dll (V1) which have a class called Y.
We add x20.dll(V2) where we may want to use Class Y.

First of all, to reference the fully qualified assembly we need to declare an alias in command line. /r:XV1=X10.dll

/r:XV2=X20.dll

Now to reference that we use


extern alias XV1;
extern alias XV2;
9. ?? (Null coalescing operator)

Null coalescing operator is used to work with null values. It is introduced in 2.0. See the following :


MyClass x = null;
x = x ?? new MyClass();

?? means if x has null value it will call new MyClass() otherwise it will assing the existing x.

10. @variables


Generally C# doesnt allow to create variables in the same name as keywords. But there is a way out to this. We can define variable with same name as keywords using @.
Suppose we define

int @int = 10;

That means a variable with name int is declared and assigned a value 10 in it.

11. Readonly


readonly is a keyword present in C# which is used to create variables that will not change throughout the program. The variable declared as readonly will be assigned its value only once and it will remain the same value throughout the execution of the object.

To declare a variable as readonly :

public readonly int readonlyvariable = 20;

This will instruct the program to make the variable 20 and any further re-assign to the variable is not permitted.

12 Difference between Const & readonly ?

readonly is almost similar to const keyword. The only difference is that const variables are defined in compile time, while readonly variables are defined at runtime during initialisation. You can assing readonly variables from within constructors, so based on the constructor call you may assign readonly values differently.


public readonly int readsecond;
public Documented()
{
readsecond = DateTime.Now.Second;
}
Here the readsecond will assign values differently based on the object initialisation, which is impossible in case of const.

13 Default

Sometimes default keywords comes very handy when working with generic objects. It returns the default value when the object is not initialised. For example, we all know integers are initialised to 0 if not given any value. Characters are Empty when not given any value, objects are null when not assigned any value.

These values are assigned based on default keyword.
Thus if we write :

int x = default(int);//will be assigned to 0
will be same as
int x;

In case of Generic object when the type is undefined, we can use default to assign specific value to the object. Let us look at the sample :


public T GetDefault< T <()
{
return default(T);
}
The function returns default value for each individual types sent. Thus


int defx = this.GetDefault< int <(); //will assign 0
char defy = this.GetDefault< char <(); // will assign empty
object defz = this.GetDefault< object <(); // will assign null
Thus we can use default keyword to get the default assignments to the object very easily.

14. Nullable Types

Nullable types of C# can handle nulls even being premitive data types. Each nullable types are derived from System.Nullable. We can define nullables like this :

int? nullableint = null;

Thus nullableint will be assigned to null.

If you access nullable variables, you will get 2 properties.

HasValue which returns false if null is assigned to the variable, and Value which returns the actual value of the variable. You can also use GetValueOrDefault function of each nullable type object to get the default value when null is assigned to the variable.