Archives for November 2015

In every application there are a sequence of method calls.A method may call second method which may call the third method.
This sequence of method calls is known as the call stack.In .NET this call stack is represented by the StackTrace class.

We can access the StackTrace information for understanding the execution of the program and for other debugging purposes.
In the following program method Method1 calls Method2 which calls Method3.

class StackTraceDemo
{
public void Method1()
{
Console.WriteLine("Method1");
Method2();
}

public void Method2()
{
Console.WriteLine("Method2");
Method3();
}

public void Method3()
{
Console.WriteLine("Method3");
}

}

We are calling the method Method1 from the Main() method as

static void Main(string[] args)
{
StackTraceDemo obj = new StackTraceDemo();
obj.Method1();

Console.ReadLine();
}

On executing the above program we get the following output

We were able to identify the sequnce of method calls from the Console.WriteLine() methods.But using the Console.WriteLine() statements might not be always possible.So we use the StackTrace class for debuging the application.StackTrace class in C# represents a stack of method calls.To access a specific method call we can use the StackFrame class.

So if we comment the Console.WriteLine() methods in the above example and use the stack trace class we will be able to get detailed information about the method calls

class StackTraceDemo
{
public void Method1()
{
//Console.WriteLine("Method1");
Method2();
}

public void Method2()
{
// Console.WriteLine("Method2");
Method3();
}

public void Method3()
{
//Console.WriteLine("Method3");

StackTrace stackTrace = new StackTrace(); // get call stack
StackFrame[] stackFrames = stackTrace.GetFrames(); // get method calls (frames)

// write call stack method names
foreach (StackFrame stackFrame in stackFrames)
{
Console.WriteLine(stackFrame.GetMethod().Name); // write method name
}
}

}

class Program
{
static void Main(string[] args)
{
StackTraceDemo obj = new StackTraceDemo();
obj.Method1();

Console.ReadLine();
}
}

We get a similar output when we use the StackTrace to print the sequence of method calls.

Follow on:

The dynamic type was introduced in C# 4.0. It’s a new type like other data types such as int or double.The difference between dynamic type and other types is that dynamic type variable is not type checked by the compiler.So any value can be assigned to a dynamic type variable.

If we declare a variable of type dynamic as

dynamic strObj = "hello";
dynamic intObj = 1;

as you can see above values of type string and int are assigned to a dynamic variable.
But the main advantage of dynamic type is that the compiler will not check if the operations performed by a dynamic type variable are valid or not.So if we write the following statement our program will compile successfully.

strObj.NewMethod();

Even though the method NewMethod() is not defined by the string type still our code just compiles.Though at run time error will be thrown as NewMethod() doesn’t exist in the string type.

Use of dynamic type

If we are calling an API which is implemented in different language then by using the dynamic type we can easily call the API from our .NET code.
For example the data types used in java or python differs from the data types used in .NET.So if we are not using dynamic type then we need to cast the arguments to and from the object type to the actual .NET data type.By using the dynamic type in C# 4.0 we can avoid type type casting by using the dynamic type as API method arguments.

Some of the important points about dynamic type are:

• dynamic types should be used only when necessary.As dynamic type variable are not type checked by the compiler so it increases the chances of runtime exceptions in our application.
• It provides advantage over using objects for storing different types as type casting is not required.
• The dynamic language runtime or DLR is an API introduced in .NET Framework 4 which provides the ability to use dynamic type.
• The dynamic type in C# 4.0 can be assigned different types of values.For example the variable strObj is assigned the value “hello” and the reassigned the integer value 1.

dynamic strObj = "hello";
strObj = 1;

 

Follow on: