Eval code and AppDomains

[Joe Fallon]

I have some complex logic which is fairly simply to build up into a string.
I needed a way to Eval this string and return a Boolean result.
This code works fine to achieve that goal.

My question is what happens to the dynamically created assembly when the
method is done running? Does GC take care of it?
Or is it stuck in RAM until the ASP.Net process is recycled?

This code executes pretty frequently (maybe 4 times per transaction) and I
am concerned that I could be eating up RAM and not releasing it in my
ASP.Net application.
I would hate to have code like this bring down the web server just because I
didn't clean it up correctly.

I took a quick look with Task Manager but when the code ran there was no new
process created. Is that because it is running inside the ASP.Net process?

I have seen a couple of posts that mention creating a separate appdomain to
handle this type of issue.
Is there some complete sample code somewhere that shows how to do this
without accidentally re-loading the dynamic assembly into the ASP.Net
process?

Thanks in advance for any help.

--
Joe Fallon



============================================================================
====
My web page calls the dynamic assembly code like this: where sbCode is the
complex Boolean logic in String format.

Dim objEval As New EvalProvider
Dim objResult As Object = objEval.Eval(sbCode.ToString)

============================================================================
====
Dynamic Assembly code:
============================================================================
====
Imports Microsoft.VisualBasic
Imports System
Imports System.Text
Imports System.CodeDom.Compiler
Imports System.Reflection
Imports System.IO

Namespace myNamespace

''' <summary>
''' Think about this: Your application does a lot of business logic, some
of which requires complicated logical strings of code
''' that may change over time to meet certain business conditions or
metadata. Wouldn't it be great if you could pull the most
''' current string of code to be run out of your database based on certain
stored procedure input parameters, and be sure it's run
''' and you get back the desired result? In fact, the returned string of
code may even be dynamically created based on some of the
''' input parameters from the sproc itself.
''' </summary>
'''
''' <remarks>
''' http://www.eggheadcafe.com/articles/20030908.asp
''' </remarks>

Public Class EvalProvider

Public Function Eval(ByVal vbCode As String) As Object
Dim c As VBCodeProvider = New VBCodeProvider
Dim icc As ICodeCompiler = c.CreateCompiler()
Dim cp As CompilerParameters = New CompilerParameters

'Note: this list much match the list of Imports in the sb.Append
below!!
cp.ReferencedAssemblies.Add("system.dll")
cp.ReferencedAssemblies.Add("system.data.dll")
cp.ReferencedAssemblies.Add("system.xml.dll")

cp.CompilerOptions = "/t:library"
cp.GenerateInMemory = True

Dim sb As StringBuilder = New StringBuilder("")
sb.Append("Imports System" & vbCrLf)
sb.Append("Imports System.Data" & vbCrLf)
sb.Append("Imports System.Xml" & vbCrLf)
sb.Append("Namespace myNamespace " & vbCrLf)
sb.Append("Class myDynamicLib " & vbCrLf)
sb.Append("public function EvalCode() as Object " & vbCrLf)
sb.Append(vbCode & vbCrLf)
sb.Append("End Function " & vbCrLf)
sb.Append("End Class " & vbCrLf)
sb.Append("End Namespace" & vbCrLf)

'to debug your eval string uncomment this line
'Debug.WriteLine(sb.ToString())

Dim cr As CompilerResults = icc.CompileAssemblyFromSource(cp,
sb.ToString())
Dim a As System.Reflection.Assembly = cr.CompiledAssembly
Dim o As Object
Dim mi As MethodInfo
o = a.CreateInstance("myNamespace.myDynamicLib ")
Dim t As Type = o.GetType()
mi = t.GetMethod("EvalCode")
Dim s As Object
s = mi.Invoke(o, Nothing)
Return s

End Function

End Class

End Namespace
============================================================================
====

 

[Scott Allen]

Hi Joe:

Once an assembly is loaded it can't be removed, unfortunately the GC can't
help there.
The code runs inside the same process as you asp.net app so you won't see
a new process appear.

The only true way to get rid of the assembly and reclaim memory is to use
a new appdomain as you pointed out.
There is good article here: http://www.west-wind.com/presentations/dynamicCode/DynamicCode.htm

I'd also have some concern with performance if you need to scale this up
to a large number of users. Crossing app domains and generating these assemblies
can chew up CPU and memory if you need to do this 4 times per request.

 

[Cor Ligthert]

Joe,

Without looking to deep or trying, would I set the class you use in a
component.

Cor

 

[Joe Fallon]

Scott,
That was 4 times per transaction which is a single page in a large site. It
is not every hit.

I think I have seen that article - I will read it closely. I use Rick's
stuff in other areas.

Do you know of any other way to Eval a String to get a Boolean result other
than dynamically generating the assembly as shown below?

Do you know if Eval will be a built-in function in ver 2.0 of the .Net
framework?

Thanks.

 

[Jay B. Harlow [MVP - Outlook]]

Joe,

This code executes pretty frequently (maybe 4 times per transaction) and I
am concerned that I could be eating up RAM and not releasing it in my
ASP.Net application.

Concern! Are you creating a dynamic assembly 4 times per transaction? Isn't
that in itself causing a performance issue?

I would consider keeping a Hashtable matching code snippets (the vbCode
parameter) to the compiled Assembly. I would only create the compiled
assembly if it was not previous registered in my Hashtable. The caveat is
you would need to ensure the code is thread safe...

My other concern is if you compile the same snippet 4 times you actually
wind up with 4 "identical" yet individual compiled assemblies...

My question is what happens to the dynamically created assembly when the
method is done running?

I would expect the assembly to remain in the current AppDomain until that
AppDomain is unloaded, You might be able to handle the
AppDomain.AssemblyLoad & AppDomain.DomainUnload events to monitor its
lifetime.

Notice there is no AppDomain.AssemblyUnload event, as you cannot unload
assemblies from an AppDomain without unloading the entire AppDomain.

Or is it stuck in RAM until the ASP.Net process is recycled?

Based on how other assemblies work with an AppDomain that is correct.

Is there some complete sample code somewhere that shows how to do this
without accidentally re-loading the dynamic assembly into the ASP.Net
process?

I don't have a specific link to a complete sample, however you should be
able to create a "EvalProvider" AppDomain, load & instantiate "EvalProvider"
class & assembly in this second AppDomain, when you call EvalProvider.Eval
it should run in this second AppDomain.

The following might get you started:

http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dncscol/html/csharp05162002.asp

Its C#, however it should be easily converted to VB.NET, post if you need
help.

One last item: The other major advantage of running the snippets
(EvalProvider.Eval) in its own AddDomain is that you can "lock down"
(security wise/permission wise) that AppDomain so that the snippet cannot do
stuff its not suppose to. Depending on who is writing the snippets this can
be a good thing

Hope this helps
Jay

 

[Joe Fallon]

Jay,
Thanks for your input. You have helped me a lot in the past. I really
appreciate it.

0. BTW this dynamic assembly code only runs on a single page in a large web
site when a user enters a complex transaction. So I am not overly concerned
about it scaling (yet) since this will be a small percentage of the total
hits on the site.

1. Do you know of any other way to Eval a String to get a Boolean result
other
than dynamically generating the assembly as shown below?

e.g. If I have a string such as "1=1" and I try to Cbool it I will get an
error.
Cbool("1=1") - error!

But Cbool(1=1) will return True. (Note that this is not a string!)

So the all the dynamic assembly does is execute my string and return T/F.

This is the core of the dynamic code which is executed:
Dim boolResult As Boolean = Cbool((1=1))
Return boolResult
Notice how my original string is now represented as something that will
evaluate correctly.

So, if there is some other way to get the same result I would like to know
about it.

FYI - I have some complex rules that become simple to code as a long Boolean
string which when evaluated returns T/F which is the only result I really
need. When I tried coding these complex rules without building up a string
it quickly got unmanageable. There was a huge advantage to building a string
in the code. But now Evaling the string with a dynamic asembly seems to be
an issue.

2. Do you know if Eval will be a built-in function in ver 2.0 of the .Net
framework?

3. Good point about the Hashtable. If it stored both the string and the
result then it could act as a cache and dramatically reduce the dynamic
assembly creation by simply retrieving the result for each matching string
that has been previously computed. I think there would be a large number of
matches since the rules would not change that frequently and so the strings
would tend to be repeated for each transaction type.

4. The hashtable resolves the point about compiling the same snippet 4 times
and creating 4 identical asemblies.
The original idea was to create the dynamic assembly and just "throw it
away" when it Eval(uated) the snippet.
But as I read more about it I learned you can't unload an assembly and so I
became concerned that I would be needlessly wasting memory. As I understand
it, ASP.Net monitors its AppDomain for "memory pressure" among other things
and will tear it down and build a new one automatically. I guess my dynamic
asemblies would just cause it to do this more frequently. Agree?

5. Rick Strahl's article showed how to create a separate appdomain. I
downloaded his code and got it working within the current appdomain but it
failed when trying to create a new one. Interestingly, he was working on the
exact same issue today and had MS Support on the line for 2 hours until the
figured out the problem. Sounds like the same problem I was having with his
code so I am hoping I can get it working tomorrow. This is a very tricky
issue. Lots of people talk about it but Rick was the only one who tried to
abstract the problem and create a class that shows how to do it. MS should
do this since they are the ones who know what works and what doesn't. The
documentation is a bit sketchy and without MS Support help Rick wouldn't
have solved it either since there were no errors returned from the code.

6. Good point on the security of a separate AppDomain.

7. I was considering setting a variable (count of hashtable?) that would
count the number of times I dynamically executed a snippet. When it exceeded
a certain threshhold I planned to tear down the separate AppDomain and start
over. Agree?

8. Since I am running in ASP.Net I would like to use the Cache to store the
hashtable. But the problem is the dynamic eval code is not in my code behind
pages. It is in my Business Object tier and that does not know anything
about the ASP.Net Cache. Any recommendations on how to store this hashtable
in my BO tier so that I will always have access to it?

Thanks!

 

[Scott Allen]

Hi Joe, if you want to eval things like "1=1" or "6+4 > 3" then I
suggest using the Eval method in the JScript.NET libraries.

i.e:

Microsoft.JScript.Vsa.VsaEngine jEngine =
Microsoft.JScript.Vsa.VsaEngine.CreateEngine();

return Microsoft.JScript.Eval.JScriptEvaluate("1=1", jEngine);

I have another example here, where the eval code is made into a
dynamic assembly and cached:
http://www.odetocode.com/Code/80.aspx

HTH,

 

[Joe Fallon]

Scott,
Very interesting!
I will take a close look at it.
Thanks!

 

[Joe Fallon]

Scott,
I added references to Microsoft.Jscript and Microsoft.VSA to my project and
then
I tried this simple example which failed with an Illegal assignment error.

Any ideas?

Dim x As Object = CObj("1=1")

Dim jEngine As Microsoft.JScript.Vsa.VsaEngine =
Microsoft.JScript.Vsa.VsaEngine.CreateEngine()

Dim objResult As Object = Microsoft.JScript.Eval.JScriptEvaluate(x, jEngine)


--- Stack Trace ---
eval code: Line 1 - Error: Illegal assignment

 

[Joe Fallon]

Dim x As Object = CObj("1==1")

Dim jEngine As Microsoft.JScript.Vsa.VsaEngine =
Microsoft.JScript.Vsa.VsaEngine.CreateEngine()

Dim objResult As Object = Microsoft.JScript.Eval.JScriptEvaluate(x, jEngine)

This worked and gave a result of True.

I guess jscript uses a double equal sign for equal and a single equal sign
to assign a value.

Being a VB coder I was not aware of this.

I learned something new today.

This looks quite useful.I will probably try to implement it now that my
quick tests show it works.

Thanks!

 

[Scott Allen]

Yes, the tricky part now is writing the JScript correctly to be
evaluated

 

[Joe Fallon]

Scott,
Thanks!
This was exactly what I was looking for.

I was able to implement it successfully. It does exactly what I need it to
do.
Now I don't have to worry about separate AppDomains and dynamically creating
an assembly multiple times.

I simply added 2 references to my Class Library project.
1. Microsoft.JScript
2. Microsoft.VSA

Then I added these 2 lines of code:

Dim jEngine As Microsoft.JScript.Vsa.VsaEngine =
Microsoft.JScript.Vsa.VsaEngine.CreateEngine()
Dim objResult As Object =
Microsoft.JScript.Eval.JScriptEvaluate(sbCode.ToString, jEngine)
If CBool(objResult) = True Then
...

sbCode is the Stringbuilder that builds up the complex expressions.

====================================================================

On a side note:
I read you article but I think I am missing something.
What is wrong with the technique I am using above?
Why did you talk about deploying assemblies and then come up with a dynamic
assembly (which at least is only created once)?
Doesn't the dynamic assembly require the same references as I added?

I would appreciate it if you could clarify this as I would like to "put this
to bed".

 

[Joe Fallon]

LOL.

A quick jscript tutorial showed me what the various operators are so the
code changes from VB to Jscript were real simple.

= is ==
<> is !=
OR is ||
AND is &&

Could you take a look at my other post and answer my questions about your
article?
Thanks.

 

[Jay B. Harlow [MVP - Outlook]]

Joe,

1. Do you know of any other way to Eval a String to get a Boolean result

JavaScript as Scott shows in the microsoft.public.dotnet.framework.aspnet
newsgroup (not sure how this (languages.vb) newsgroup got left off that half
of this thread).

Alternatively you could use a computed column in a DataTable, if your data
is not already in a DataTable this may not work very well... The Expresssion
syntax in the DataSet OM is closer to VB, then JavaScripts, however with
limits.

http://msdn.microsoft.com/library/d...fsystemdatadatacolumnclassexpressiontopic.asp

2. Do you know if Eval will be a built-in function in ver 2.0 of the .Net
framework?

Not that I know of

8. Since I am running in ASP.Net I would like to use the Cache to store
the

I have not looked at it a lot, there is the Caching Application Block
http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dnpag/html/cachingblock.asp.

I normally simply keep the values in a Shared variables, however there is no
getting ride of old one...

Hope this helps
Jay

 

[Scott Allen]

Cool!! So all your questions are answered??

 

[Joe Fallon]

Jay,
Thanks for the advice.
I have gone with Scott's solution and am very pleased with it.
--
Joe Fallon

Joe,

1. Do you know of any other way to Eval a String to get a Boolean result

JavaScript as Scott shows in the microsoft.public.dotnet.framework.aspnet
newsgroup (not sure how this (languages.vb) newsgroup got left off that half
of this thread).

Alternatively you could use a computed column in a DataTable, if your data
is not already in a DataTable this may not work very well... The Expresssion
syntax in the DataSet OM is closer to VB, then JavaScripts, however with
limits.

http://msdn.microsoft.com/library/d...fsystemdatadatacolumnclassexpressiontopic.asp

2. Do you know if Eval will be a built-in function in ver 2.0 of the ..Net
framework?

Not that I know of

8. Since I am running in ASP.Net I would like to use the Cache to store
the

I have not looked at it a lot, there is the Caching Application Block
http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dnpag/html/cachingblock.asp.

I normally simply keep the values in a Shared variables, however there is no
getting ride of old one...

Hope this helps
Jay

 

[Joe Fallon]

Hey Scott,
No. I left you a bunch of questions at the bottom of my last message that
all referred to your article.

Just for my peace of mind - can you could address them?

I read your article but I wonder if I am missing something.
1. Is there anything wrong with the technique I am using above?

2. Why did you talk about deploying assemblies and then come up with a
dynamic
assembly (which at least is only created once)?

3. Doesn't the dynamic assembly require the same references as I added?
What is the advantage to it over the technique I used of adding references
to my project and adding 2 lines of code?

 

[Scott Allen]

No problem - I'm in the middle of reverting back to my trusty old
newsreader but I've lost track of several threads!

1) No - nothing I can see, although I'd test the performance to see if
the created engine needs cached.

2) At the time I thought I needed a JScript project to do the Eval,
and I didn't want to add an extra project to a solution just to do an
eval.

3) Yes - the dynamic assembly requires the same references. I think
your approach is better being it is the simpler of the two. I imagine
they perform comparably.

 

[Joe Fallon]

Scott,
Thanks for all your help on this.
Good tip on caching the engine since it will get called regularly.