For the following class, what methods would be included i

Noe Torres

public class CallStack
{
  public void Test()
  {
   try
   {
    this.A();
   }
   catch( Exception e )
   {
    Console.WriteLine( e.StackTrace );
   }
  }

  protected void A()
  {
   this.B();
  }

  protected void B()
  {
   try
   {
    this.C();
   }
   catch( Exception /*e*/ )
   {
    throw;
   }
  }

  protected void C()
  {
   this.D();
  }

  protected void D()
  {
   try
   {
    this.E();
   }
   catch( Exception e )
   {
    throw e;
   }
  }

  protected void E()
  {
   this.Throw();
  }

  protected void Throw()
  {
   throw new Exception( "An Exception occurred" );
  }
}

2 Replies

Know the answer? Post it — somebody with the same question will find it here.

Vulpes13y ago
If you're asking which methods will appear in the stack trace when the exception is propagated back (and finally caught) in the Test method, then the answer is:

D
B
Test

The methods A, C, E and Throw will all be 'inlined' (i.e they will be eliminated by including their code in the method which calls them) and so are superfluous.

This can be seen by changing the code as follows which produces exactly the same output:

using System;

public class CallStack
{
public void Test()
{
try
{
this.B();
}
catch( Exception e )
{
Console.WriteLine( e.StackTrace );
}
}

protected void B()
{
try
{
this.D();
}
catch( Exception /*e*/ )
{
throw;
}
}

protected void D()
{
try
{
throw new Exception( "An Exception occurred" );
}
catch( Exception e )
{
throw e;
}
}
}

class Program
{
static void Main()
{
CallStack cs = new CallStack();
cs.Test();
Console.ReadKey();
}
}
Abhishek Sur13y ago
First of all during the call, it creates all the Calls in CallStack. So initially it will have :
Throw =>E=>D=>C=>B=>A=>Test
in stack until the exception is thrown.

When exception is thrown, it moves to D(), which has throw e.
Now throw e removes the CallStack present on the exception object until now and creates a new stack. So when it reaches B, it will have only :
D=>C=>B=>A=>Test
Thereby removing the rest of the stack that has been kept track from down the whole call stack.

Finally, it gets throw which does not create a new Exception object but rather it throws the existing.

Remember, Throw ex does not preserve CallStack but Throw does. Exception.StackTrace is mutable.