Well Yes - the feature which stands out is the StackTrace property. This provides a call stack which records where the exception was thrown from. For example, the following code:

using System;

class CApp
{
public static void Main()
{
try
{
f();
}
ca tch( Exception e )
{
Console.WriteLine( "System.Exception stack trace = \n{0}", e.StackTrace );
}
}

static void f()
{
throw new Exception( "f went pear-shaped" );
}
}
produces this output:
System.Exception stack trace =
at CApp.f()
at CApp.Main()

Note, however, that this stack trace was produced from a debug build. A release build may optimise away some of the method calls which could mean that the call stack isn't quite what you expect.

For more information, Please visit the site-
http://www.developeriq. com/a rticles/2008/apr/28/advance-to pics- net-interview-part2/

Answered by Raksha , an ibibo Master, at 8:20 AM on June 17, 2008

well,Yes - the feature which stands out is the StackTrace property. This provides a call stack which records where the exception was thrown from. For example, the following code: using System; class CApp { public static void Main() { try { f(); } catch( Exception e ) { Console.WriteLine( "System.Exception stack trace = \n{0}", e.StackTrace ); } } static void f() { throw new Exception( "f went pear-shaped" ); } } Note, however, that this stack trace was produced from a debug build.


using System;

class CApp
{
public static void Main()
{
try
{
f();
}
ca tch( Exception e )
{
Console.WriteLine( "System.Exception stack trace = \n{0}", e.StackTrace );
}
}

static void f()
{
throw new Exception( "f went pear-shaped" );
}
}
produces this output:
System.Exception stack trace =
at CApp.f()
at CApp.Main()

Note, however, that this stack trace was produced from a debug build. A release build may optimise away some of the method calls which could mean that the call stack isn't quite what you expect.

For more information, Please visit the site-
http://www.developeriq. com/a rticles/2008/apr/28/advance-to pics- net-interview-part2/

Answered by raj u , an ibibo Master, at 1:07 PM on June 04, 2008

Hi,

Well Yes - the feature which stands out is the StackTrace property. This provides a call stack which records where the exception was thrown from. For example, the following code:

using System;

class CApp
{
public static void Main()
{
try
{
f();
}
ca tch( Exception e )
{
Console.WriteLine( "System.Exception stack trace = \n{0}", e.StackTrace );
}
}

static void f()
{
throw new Exception( "f went pear-shaped" );
}
}
produces this output:
System.Exception stack trace =
at CApp.f()
at CApp.Main()

Note, however, that this stack trace was produced from a debug build. A release build may optimise away some of the method calls which could mean that the call stack isn't quite what you expect.

For more information, Please visit the site-
http://www.developeriq. com/a rticles/2008/apr/28/advance-to pics- net-interview-part2/

Answered by Romi , an ibibo Master, at 6:26 PM on June 03, 2008

well , I am feeling HAPPY to answer your question , I would like to suggest you to access the source site if it's available , for more information.
Yes - the feature which stands out is the StackTrace property. This provides a call stack which records where the exception was thrown from. For example, the following code: using System; class CApp { public static void Main() { try { f(); } catch( Exception e ) { Console.WriteLine( "System.Exception stack trace = \n{0}", e.StackTrace ); } } static void f() { throw new Exception( "f went pear-shaped" ); } } Note, however, that this stack trace was produced from a debug build.


using System;

class CApp
{
public static void Main()
{
try
{
f();
}
ca tch( Exception e )
{
Console.WriteLine( "System.Exception stack trace = \n{0}", e.StackTrace );
}
}

static void f()
{
throw new Exception( "f went pear-shaped" );
}
}
produces this output:
System.Exception stack trace =
at CApp.f()
at CApp.Main()

Note, however, that this stack trace was produced from a debug build. A release build may optimise away some of the method calls which could mean that the call stack isn't quite what you expect.


For more information , please do visit source site:
http://www.developeriq. com/a rticles/2008/apr/28/advance-to pics- net-interview-part2/

Hope it will help you out.

Answered by Uttam , an ibibo Master, at 9:00 PM on June 02, 2008

Hi,

Well Yes - the feature which stands out is the StackTrace property. This provides a call stack which records where the exception was thrown from. For example, the following code:

using System;

class CApp
{
public static void Main()
{
try
{
f();
}
catch( Exception e )
{
Console.WriteLine( "System.Exception stack trace = \n{0}", e.StackTrace );
}
}

static void f()
{
throw new Exception( "f went pear-shaped" );
}
}
produces this output:
System.Exception stack trace =
at CApp.f()
at CApp.Main()

Note, however, that this stack trace was produced from a debug build. A release build may optimise away some of the method calls which could mean that the call stack isn't quite what you expect.

For more information, Please visit the site-
http://www.developeriq.com/a rticles/2008/apr/28/advance-topics- net-interview-part2/

Answered by Ajay Pal , an ibibo Master, at 2:53 PM on June 02, 2008

well,Yes - the feature which stands out is the StackTrace property. This provides a call stack which records where the exception was thrown from. For example, the following code: using System; class CApp { public static void Main() { try { f(); } catch( Exception e ) { Console.WriteLine( "System.Exception stack trace = \n{0}", e.StackTrace ); } } static void f() { throw new Exception( "f went pear-shaped" ); } } Note, however, that this stack trace was produced from a debug build.


using System;

class CApp
{
public static void Main()
{
try
{
f();
}
ca tch( Exception e )
{
Console.WriteLine( "System.Exception stack trace = \n{0}", e.StackTrace );
}
}

static void f()
{
throw new Exception( "f went pear-shaped" );
}
}
produces this output:
System.Exception stack trace =
at CApp.f()
at CApp.Main()

Note, however, that this stack trace was produced from a debug build. A release build may optimise away some of the method calls which could mean that the call stack isn't quite what you expect.

For more information, Please visit the site-
http://www.developeriq. com/a rticles/2008/apr/28/advance-to pics- net-interview-part2/

Answered by Saurabh , an ibibo Master, at 8:57 AM on June 02, 2008

Yes - the feature which stands out is the StackTrace property. This provides a call stack which records where the exception was thrown from. For example, the following code: using System; class CApp { public static void Main() { try { f(); } catch( Exception e ) { Console.WriteLine( "System.Exception stack trace = \n{0}", e.StackTrace ); } } static void f() { throw new Exception( "f went pear-shaped" ); } } Note, however, that this stack trace was produced from a debug build.

Answered by Ram Singh , an ibibo Master, at 6:59 AM on June 02, 2008

Yes - the feature which stands out is the StackTrace property. This provides a call stack which records where the exception was thrown from. For example, the following code: using System; class CApp { public static void Main() { try { f(); } catch( Exception e ) { Console.WriteLine( "System.Exception stack trace = \n{0}", e.StackTrace ); } } static void f() { throw new Exception( "f went pear-shaped" ); } } Note, however, that this stack trace was produced from a debug build.

Answered by Anju Singh , an ibibo Master, at 6:10 AM on June 02, 2008

Well Radhe, Yes - the feature which stands out is the StackTrace property. This provides a call stack which records where the exception was thrown from. For example, the following code:

using System;

class CApp
{
public static void Main()
{
try
{
f();
}
ca tch( Exception e )
{
Console.WriteLine( "System.Exception stack trace = \n{0}", e.StackTrace );
}
}

static void f()
{
throw new Exception( "f went pear-shaped" );
}
}
produces this output:
System.Exception stack trace =
at CApp.f()
at CApp.Main()

Note, however, that this stack trace was produced from a debug build. A release build may optimise away some of the method calls which could mean that the call stack isn't quite what you expect.

For more information, Please visit the site-
http://www.developeriq. com/a rticles/2008/apr/28/advance-to pics- net-interview-part2/

Answered by satyaiitk , an ibibo Master, at 12:26 AM on June 02, 2008

Yes - the feature which stands out is the StackTrace property. This provides a call stack which records where the exception was thrown from. For example, the following code:

using System;

class CApp
{
public static void Main()
{
try
{
f();
}
catch( Exception e )
{
Console.WriteLine( "System.Exception stack trace = \n{0}", e.StackTrace );
}
}

static void f()
{
throw new Exception( "f went pear-shaped" );
}
}
produces this output:
System.Exception stack trace =
at CApp.f()
at CApp.Main()

Note, however, that this stack trace was produced from a debug build. A release build may optimise away some of the method calls which could mean that the call stack isn't quite what you expect.

For more information, Please visit the site-
http://www.developeriq.com/a rticles/2008/apr/28/advance-topics- net-interview-part2/

Answered by Nagendra , an ibibo Master, at 10:02 AM on May 31, 2008