Accessing the CALL STACK

[Yahoo]

I have a programming issue where I need to know the whole history of the
call stack to ensure it was never within a given method (specifically my own
method). I am hooking into the XmlDocument nodechanged event, I need to from
this event call modify a different node in this xmldocument, thus without
somekind of check we will be off in an infinite loop. Currently I am using
the System.Diagnost ics classes but feel its not right to use these classes
like this. I would expect a master call stack to be kepted in the threading
class (or even reflections) but i dont see it. Is there a better way?
private bool IsFromUs()

{

StackTrace stackTrace = new StackTrace();

StackFrame stackFrame;

MethodBase stackFrameMetho d;

string typeName;

//find the first system.xml method, this always exists

int position=0;

for(int x = position; x<stackTrace.Fr ameCount; x++)

{

stackFrame = stackTrace.GetF rame(x);

stackFrameMetho d = stackFrame.GetM ethod();

typeName = stackFrameMetho d.ReflectedType .FullName;
if (typeName.Start sWith("System.X ml"))

{

position = x;

break;

}

}

//now determine if we were the cause of this notification

for(int x = position; x<stackTrace.Fr ameCount; x++)

{

stackFrame = stackTrace.GetF rame(x);

stackFrameMetho d = stackFrame.GetM ethod();

typeName = stackFrameMetho d.ReflectedType .FullName;
if (typeName.Start sWith("RuleEngi ne"))

return true;

}

return false;

}

[Nicholas Paldino [.NET/C# MVP]]

The StackTrace/StackFrame class is the way that you would access call
stack information. There really isn't another way.

However, you shouldn't be doing this. Getting the call stack is
expensive, not to mention the fact that you should implement better logic to
determine if you are re-entering your own function.

Hope this helps.
--
- Nicholas Paldino [.NET/C# MVP]
- mv*@spam.guard. caspershouse.co m

"Yahoo" <jo************ ***@yahoo.com> wrote in message
news:Uz******** ********@newssv r12.news.prodig y.com...

I have a programming issue where I need to know the whole history of the
call stack to ensure it was never within a given method (specifically my
own method). I am hooking into the XmlDocument nodechanged event, I need to
from this event call modify a different node in this xmldocument, thus
without somekind of check we will be off in an infinite loop. Currently I
am using the System.Diagnost ics classes but feel its not right to use these
classes like this. I would expect a master call stack to be kepted in the
threading class (or even reflections) but i dont see it. Is there a better
way?
private bool IsFromUs()

{

StackTrace stackTrace = new StackTrace();

StackFrame stackFrame;

MethodBase stackFrameMetho d;

string typeName;

//find the first system.xml method, this always exists

int position=0;

for(int x = position; x<stackTrace.Fr ameCount; x++)

{

stackFrame = stackTrace.GetF rame(x);

stackFrameMetho d = stackFrame.GetM ethod();

typeName = stackFrameMetho d.ReflectedType .FullName;
if (typeName.Start sWith("System.X ml"))

{

position = x;

break;

}

}

//now determine if we were the cause of this notification

for(int x = position; x<stackTrace.Fr ameCount; x++)

{

stackFrame = stackTrace.GetF rame(x);

stackFrameMetho d = stackFrame.GetM ethod();

typeName = stackFrameMetho d.ReflectedType .FullName;
if (typeName.Start sWith("RuleEngi ne"))

return true;

}

return false;

}

[Yahoo]

I know its a real performance hit, but thats ok for now. Before this i was
implementing a balking design pattern where I was cheking the status on the
nodechanged but that was causing other problems. Thanks for the quick
response.
"Nicholas Paldino [.NET/C# MVP]" <mv*@spam.guard .caspershouse.c om> wrote in
message news:uS******** *****@TK2MSFTNG P10.phx.gbl...

The StackTrace/StackFrame class is the way that you would access call
stack information. There really isn't another way.

However, you shouldn't be doing this. Getting the call stack is
expensive, not to mention the fact that you should implement better logic
to determine if you are re-entering your own function.

Hope this helps.
--
- Nicholas Paldino [.NET/C# MVP]
- mv*@spam.guard. caspershouse.co m

"Yahoo" <jo************ ***@yahoo.com> wrote in message
news:Uz******** ********@newssv r12.news.prodig y.com...

I have a programming issue where I need to know the whole history of the
call stack to ensure it was never within a given method (specifically my
own method). I am hooking into the XmlDocument nodechanged event, I need
to from this event call modify a different node in this xmldocument, thus
without somekind of check we will be off in an infinite loop. Currently I
am using the System.Diagnost ics classes but feel its not right to use
these classes like this. I would expect a master call stack to be kepted
in the threading class (or even reflections) but i dont see it. Is there a
better way?
private bool IsFromUs()

{

StackTrace stackTrace = new StackTrace();

StackFrame stackFrame;

MethodBase stackFrameMetho d;

string typeName;

//find the first system.xml method, this always exists

int position=0;

for(int x = position; x<stackTrace.Fr ameCount; x++)

{

stackFrame = stackTrace.GetF rame(x);

stackFrameMetho d = stackFrame.GetM ethod();

typeName = stackFrameMetho d.ReflectedType .FullName;
if (typeName.Start sWith("System.X ml"))

{

position = x;

break;

}

}

//now determine if we were the cause of this notification

for(int x = position; x<stackTrace.Fr ameCount; x++)

{

stackFrame = stackTrace.GetF rame(x);

stackFrameMetho d = stackFrame.GetM ethod();

typeName = stackFrameMetho d.ReflectedType .FullName;
if (typeName.Start sWith("RuleEngi ne"))

return true;

}

return false;

}

[Marcus Andrén]

On Thu, 27 Oct 2005 17:59:16 GMT, "Yahoo"
<jo************ ***@yahoo.com> wrote:

I have a programming issue where I need to know the whole history of the
call stack to ensure it was never within a given method (specifically my own
method). I am hooking into the XmlDocument nodechanged event, I need to from
this event call modify a different node in this xmldocument, thus without
somekind of check we will be off in an infinite loop. Currently I am using
the System.Diagnost ics classes but feel its not right to use these classes
like this. I would expect a master call stack to be kepted in the threading
class (or even reflections) but i dont see it. Is there a better way?

Wouldn't the following code work:

// Each thread gets its own isMethodActive variable. So the method can
// be called on several threads at once.
[ThreadStatic]
static bool isMethodActive= false;

public void Method()
{
if (isMethodActive )
return; //Method is already called. Exit to avoid infinite loop.
isMethodActive= true;
try
{
/* Do recursive call here */
}
finally
{
isMethodActive= false;
}
}

--
Marcus Andrén

[Yahoo]

I might be mistaken but i dont thing this would work becuase the
isMethodActive is static, other instances of the object who should be
allowed access would be restricted. it would probably work as an instance
variable with a proxy design pattern where outside calls in the proxy would
set the ismethodactive to true, internal calls that then trigger the
nodechange could then be ignored. I dont think it would be thread safe since
another thread could be denied when it shouldnt be.
"Marcus Andrén" <a@b.c> wrote in message
news:fq******** *************** *********@4ax.c om...

On Thu, 27 Oct 2005 17:59:16 GMT, "Yahoo"
<jo************ ***@yahoo.com> wrote:

I have a programming issue where I need to know the whole history of the
call stack to ensure it was never within a given method (specifically my
own
method). I am hooking into the XmlDocument nodechanged event, I need to
from
this event call modify a different node in this xmldocument, thus without
somekind of check we will be off in an infinite loop. Currently I am using
the System.Diagnost ics classes but feel its not right to use these classes
like this. I would expect a master call stack to be kepted in the
threading
class (or even reflections) but i dont see it. Is there a better way?

Wouldn't the following code work:

// Each thread gets its own isMethodActive variable. So the method can
// be called on several threads at once.
[ThreadStatic]
static bool isMethodActive= false;

public void Method()
{
if (isMethodActive )
return; //Method is already called. Exit to avoid infinite loop.
isMethodActive= true;
try
{
/* Do recursive call here */
}
finally
{
isMethodActive= false;
}
}

--
Marcus Andrén

[Marcus Andrén]

On Thu, 27 Oct 2005 19:25:09 GMT, "Yahoo"
<jo************ ***@yahoo.com> wrote:

I might be mistaken but i dont thing this would work becuase the
isMethodActi ve is static, other instances of the object who should be
allowed access would be restricted. it would probably work as an instance
variable with a proxy design pattern where outside calls in the proxy would
set the ismethodactive to true, internal calls that then trigger the
nodechange could then be ignored. I dont think it would be thread safe since
another thread could be denied when it shouldnt be.

True. If you want to allow the method to be called once for each
instance, just remove the static declaration.

If you need it to be threadsafe, replace the static boolean with a
static Hashtable and add/remove 'this'. It is still much better than
trying to look in the stacktrace.

--
Marcus Andrén

[Yahoo]

Thats hashtable idea sounds good, I will try that. Thanks.

"Marcus Andrén" <a@b.c> wrote in message
news:7m******** *************** *********@4ax.c om...

On Thu, 27 Oct 2005 19:25:09 GMT, "Yahoo"
<jo************ ***@yahoo.com> wrote:

I might be mistaken but i dont thing this would work becuase the
isMethodActiv e is static, other instances of the object who should be
allowed access would be restricted. it would probably work as an instance
variable with a proxy design pattern where outside calls in the proxy
would
set the ismethodactive to true, internal calls that then trigger the
nodechange could then be ignored. I dont think it would be thread safe
since
another thread could be denied when it shouldnt be.

True. If you want to allow the method to be called once for each
instance, just remove the static declaration.

If you need it to be threadsafe, replace the static boolean with a
static Hashtable and add/remove 'this'. It is still much better than
trying to look in the stacktrace.

--
Marcus Andrén

[Jon Skeet [C# MVP]]

Yahoo <jo************ ***@yahoo.com> wrote:

I might be mistaken but i dont thing this would work becuase the
isMethodActive is static, other instances of the object who should be
allowed access would be restricted.

You missed the fact that it's marked with the ThreadStatic attribute.
That means there's basically one variable per thread, which is exactly
what you want.

--
Jon Skeet - <sk***@pobox.co m>
http://www.pobox.com/~skeet Blog: http://www.msmvps.com/jon.skeet
If replying to the group, please do not mail me too

[Daniel Jin]

in addition to the ThreadStatic idea, you can also dettach from the event on
entering the handler, and re-attach before exit.

"Yahoo" wrote:

I have a programming issue where I need to know the whole history of the
call stack to ensure it was never within a given method (specifically my own
method). I am hooking into the XmlDocument nodechanged event, I need to from
this event call modify a different node in this xmldocument, thus without
somekind of check we will be off in an infinite loop. Currently I am using
the System.Diagnost ics classes but feel its not right to use these classes
like this. I would expect a master call stack to be kepted in the threading
class (or even reflections) but i dont see it. Is there a better way?
private bool IsFromUs()

{

StackTrace stackTrace = new StackTrace();

StackFrame stackFrame;

MethodBase stackFrameMetho d;

string typeName;

//find the first system.xml method, this always exists

int position=0;

for(int x = position; x<stackTrace.Fr ameCount; x++)

{

stackFrame = stackTrace.GetF rame(x);

stackFrameMetho d = stackFrame.GetM ethod();

typeName = stackFrameMetho d.ReflectedType .FullName;
if (typeName.Start sWith("System.X ml"))

{

position = x;

break;

}

}

//now determine if we were the cause of this notification

for(int x = position; x<stackTrace.Fr ameCount; x++)

{

stackFrame = stackTrace.GetF rame(x);

stackFrameMetho d = stackFrame.GetM ethod();

typeName = stackFrameMetho d.ReflectedType .FullName;
if (typeName.Start sWith("RuleEngi ne"))

return true;

}

return false;

}

[Yahoo]

Tried this and had problems. Issue is the client could...

client->myobjmethod1->myobjectmethod 2

or they could

client->myobjectmethod 2

So in the second method you wouldnt want to add them back in if myobjmethod1
called it cuz that would mess it up for the rest of mymethod1.
"Daniel Jin" <Da*******@disc ussions.microso ft.com> wrote in message
news:3B******** *************** ***********@mic rosoft.com...

in addition to the ThreadStatic idea, you can also dettach from the event
on
entering the handler, and re-attach before exit.

"Yahoo" wrote:

I have a programming issue where I need to know the whole history of the
call stack to ensure it was never within a given method (specifically my
own
method). I am hooking into the XmlDocument nodechanged event, I need to
from
this event call modify a different node in this xmldocument, thus without
somekind of check we will be off in an infinite loop. Currently I am
using
the System.Diagnost ics classes but feel its not right to use these
classes
like this. I would expect a master call stack to be kepted in the
threading
class (or even reflections) but i dont see it. Is there a better way?
private bool IsFromUs()

{

StackTrace stackTrace = new StackTrace();

StackFrame stackFrame;

MethodBase stackFrameMetho d;

string typeName;

//find the first system.xml method, this always exists

int position=0;

for(int x = position; x<stackTrace.Fr ameCount; x++)

{

stackFrame = stackTrace.GetF rame(x);

stackFrameMetho d = stackFrame.GetM ethod();

typeName = stackFrameMetho d.ReflectedType .FullName;
if (typeName.Start sWith("System.X ml"))

{

position = x;

break;

}

}

//now determine if we were the cause of this notification

for(int x = position; x<stackTrace.Fr ameCount; x++)

{

stackFrame = stackTrace.GetF rame(x);

stackFrameMetho d = stackFrame.GetM ethod();

typeName = stackFrameMetho d.ReflectedType .FullName;
if (typeName.Start sWith("RuleEngi ne"))

return true;

}

return false;

}