UnCommon C# keywords - A Look

 This is really a weird topic to start with. But still I would like to give you an insight on some of the uncommon things that you may not have noticed while doing programming. I have framed them in 2 sections.

1st one for Undocumented Keywords, which you will not find anywhere, not even in MSDN Documentation, which are not listed to intellesense menu in visual studio.
2nd one for Documented Keywords which are uncommon or just being introduced to C#. Documented keywords which are uncommon can be found over MSDN.I have also made a sample application where I have given some demonstration of each of the topics mentioned here in this article. If you want to test these, please download the sample application from here :





Undocumented Keywords
Let us discuss some of the undocumented keywords that I found. If you know any keyword other than this please let me know :

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 reveals 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 surety 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 length 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 OverflowException 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 OverflowException 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 OverflowException 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 assigned to -2.

4. Volatile

Volatile keyword is used to define a variable which is to be modified across multiple threads without invoking lock statements(Although we do lock them most of the times). 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 acquire memory quickly when it is very essential memory quickly. We can use the advantage of Fast accessible memory when we use it from Stack. We can declare an array like this :

int* array = stackalloc new int[1000]  

The memory is available as soon as the statement is invoked.

Note: You should always keep in mind, stackalloc memory is very limited. It is by default 1MB for each thread. So if we need huge amount of memory(more than 1MB) we have to rely back to our original Heap memory structure.

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");
                return base.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/Class Alias

We use using to define Alias. There are 2 types of Alias:

1. 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.

Class Alias:

You can also make use of using statement to define reference to a single class. Say if I write
using Abhishek=System.Drawing.Bitmap;
Abhisek will hold the class Bitmap. We can create Object of Abhishek, access static functions directly.

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

Thus Abhishek will be pointing to native Graphics object rather than the entire namespace.

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 assign the existing x.

10. @variables

Generally C# doesn't 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 object initialization. You can assign 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 initialization, 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 initialized. For example, we all know integers are initialized 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 null('\0')
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 primitive 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.

Conclusion

This concludes most of the keywords. My intention is to give you a brief knowledge about them and how to use them. Please feel free to comment.

You can try out the sample application from here


Thank you for reading.