467,161 Members | 880 Online
Bytes | Developer Community
Ask Question

Home New Posts Topics Members FAQ

Post your question to a community of 467,161 developers. It's quick & easy.

Eval code and AppDomains

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
================================================== ==========================
====

Nov 19 '05 #1
  • viewed: 2724
Share:
18 Replies
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/presentatio...ynamicCode.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.

--
Scott
http://www.OdeToCode.com/blogs/scott/
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.

================================================== ====================
======
====
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
================================================== ====================
====== ====

Nov 19 '05 #2
Joe,

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

Cor
Nov 19 '05 #3
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.
--
Joe Fallon

"Scott Allen" <sc***@nospam.OdeToCode.com> wrote in message
news:59*********************@msnews.microsoft.com. ..
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/presentatio...ynamicCode.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.

--
Scott
http://www.OdeToCode.com/blogs/scott/
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.

================================================== ====================
======
====
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
================================================== ====================
====== ====


Nov 19 '05 #4
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/de...rp05162002.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" <jf******@nospamtwcny.rr.com> wrote in message
news:%2***************@TK2MSFTNGP11.phx.gbl...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
================================================== ==========================
====


Nov 19 '05 #5
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!
--
Joe Fallon

"Jay B. Harlow [MVP - Outlook]" <Ja************@msn.com> wrote in message
news:%2****************@TK2MSFTNGP11.phx.gbl...
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/de...rp05162002.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" <jf******@nospamtwcny.rr.com> wrote in message
news:%2***************@TK2MSFTNGP11.phx.gbl...
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
================================================== ==========================
====



Nov 19 '05 #6
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,

--
Scott
http://www.OdeToCode.com/blogs/scott/

On Wed, 26 Jan 2005 09:38:59 -0500, "Joe Fallon"
<jf******@nospamtwcny.rr.com> wrote:
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.


Nov 19 '05 #7
Scott,
Very interesting!
I will take a close look at it.
Thanks!
--
Joe Fallon
Access MVP
"Scott Allen" <sc***@nospam.odetocode.com> wrote in message
news:cf********************************@4ax.com...
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,

--
Scott
http://www.OdeToCode.com/blogs/scott/

On Wed, 26 Jan 2005 09:38:59 -0500, "Joe Fallon"
<jf******@nospamtwcny.rr.com> wrote:
Scott,
That was 4 times per transaction which is a single page in a large site. Itis 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 otherthan 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.

Nov 19 '05 #8
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

"Scott Allen" <sc***@nospam.odetocode.com> wrote in message
news:cf********************************@4ax.com...
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,

--
Scott
http://www.OdeToCode.com/blogs/scott/

On Wed, 26 Jan 2005 09:38:59 -0500, "Joe Fallon"
<jf******@nospamtwcny.rr.com> wrote:
Scott,
That was 4 times per transaction which is a single page in a large site. Itis 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 otherthan 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.

Nov 19 '05 #9
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!
--
Joe Fallon

"Joe Fallon" <jf******@nospamtwcny.rr.com> wrote in message
news:#d**************@TK2MSFTNGP09.phx.gbl...
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

"Scott Allen" <sc***@nospam.odetocode.com> wrote in message
news:cf********************************@4ax.com...
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,

--
Scott
http://www.OdeToCode.com/blogs/scott/

On Wed, 26 Jan 2005 09:38:59 -0500, "Joe Fallon"
<jf******@nospamtwcny.rr.com> wrote:
Scott,
That was 4 times per transaction which is a single page in a large
site.
Itis 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 otherthan 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.


Nov 19 '05 #10
Yes, the tricky part now is writing the JScript correctly to be
evaluated :)

--
Scott
http://www.OdeToCode.com/blogs/scott/

On Thu, 27 Jan 2005 10:50:04 -0500, "Joe Fallon"
<jf******@nospamtwcny.rr.com> wrote:
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!


Nov 19 '05 #11
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.ToSt ring, 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

"Joe Fallon" <jf******@nospamtwcny.rr.com> wrote in message
news:uu**************@TK2MSFTNGP14.phx.gbl...
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!
--
Joe Fallon

"Joe Fallon" <jf******@nospamtwcny.rr.com> wrote in message
news:#d**************@TK2MSFTNGP09.phx.gbl...
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

"Scott Allen" <sc***@nospam.odetocode.com> wrote in message
news:cf********************************@4ax.com...
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,

--
Scott
http://www.OdeToCode.com/blogs/scott/

On Wed, 26 Jan 2005 09:38:59 -0500, "Joe Fallon"
<jf******@nospamtwcny.rr.com> wrote:

>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.



Nov 19 '05 #12
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.

--
Joe Fallon
"Scott Allen" <sc***@nospam.odetocode.com> wrote in message
news:i5********************************@4ax.com...
Yes, the tricky part now is writing the JScript correctly to be
evaluated :)

--
Scott
http://www.OdeToCode.com/blogs/scott/

On Thu, 27 Jan 2005 10:50:04 -0500, "Joe Fallon"
<jf******@nospamtwcny.rr.com> wrote:
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 signto 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!

Nov 19 '05 #13
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/de...ssiontopic.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/de...chingblock.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" <jf******@nospamtwcny.rr.com> wrote in message
news:eO**************@TK2MSFTNGP09.phx.gbl... 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!
--
Joe Fallon

"Jay B. Harlow [MVP - Outlook]" <Ja************@msn.com> wrote in message
news:%2****************@TK2MSFTNGP11.phx.gbl...
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/de...rp05162002.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" <jf******@nospamtwcny.rr.com> wrote in message
news:%2***************@TK2MSFTNGP11.phx.gbl...
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
================================================== ==========================
====




Nov 19 '05 #14
Cool!! So all your questions are answered??

--
Scott
http://www.OdeToCode.com/blogs/scott/

On Thu, 27 Jan 2005 14:18:43 -0500, "Joe Fallon"
<jf******@nospamtwcny.rr.com> wrote:
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.ToS tring, 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".


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

"Jay B. Harlow [MVP - Outlook]" <Ja************@msn.com> wrote in message
news:ua**************@TK2MSFTNGP15.phx.gbl...
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/de...ssiontopic.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/de...chingblock.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" <jf******@nospamtwcny.rr.com> wrote in message
news:eO**************@TK2MSFTNGP09.phx.gbl...
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!
--
Joe Fallon

"Jay B. Harlow [MVP - Outlook]" <Ja************@msn.com> wrote in message news:%2****************@TK2MSFTNGP11.phx.gbl...
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/de...rp05162002.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" <jf******@nospamtwcny.rr.com> wrote in message
news:%2***************@TK2MSFTNGP11.phx.gbl...
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
================================================== ========================== ====




Nov 19 '05 #16
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?
--
Joe Fallon

"Scott Allen" <sc***@nospam.odetocode.com> wrote in message
news:1t********************************@4ax.com...
Cool!! So all your questions are answered??

--
Scott
http://www.OdeToCode.com/blogs/scott/

On Thu, 27 Jan 2005 14:18:43 -0500, "Joe Fallon"
<jf******@nospamtwcny.rr.com> wrote:
Scott,
Thanks!
This was exactly what I was looking for.

I was able to implement it successfully. It does exactly what I need it todo.
Now I don't have to worry about separate AppDomains and dynamically creatingan 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.ToS tring, 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 dynamicassembly (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 thisto bed".

Nov 19 '05 #17
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.

--
Scott
http://www.OdeToCode.com/blogs/scott/
On Fri, 28 Jan 2005 17:29:27 -0500, "Joe Fallon"
<jf******@nospamtwcny.rr.com> wrote:
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?


Nov 19 '05 #18
Scott,
Thanks for all your help on this.
Good tip on caching the engine since it will get called regularly.
--
Joe Fallon

"Scott Allen" <sc***@nospam.odetocode.com> wrote in message
news:7v********************************@4ax.com...
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.

--
Scott
http://www.OdeToCode.com/blogs/scott/
On Fri, 28 Jan 2005 17:29:27 -0500, "Joe Fallon"
<jf******@nospamtwcny.rr.com> wrote:
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?

Nov 19 '05 #19

This discussion thread is closed

Replies have been disabled for this discussion.

Similar topics

6 posts views Thread by Joe Fallon | last post: by
8 posts views Thread by George Meng | last post: by
1 post views Thread by billr | last post: by
8 posts views Thread by Fred Mertz | last post: by
3 posts views Thread by | last post: by
By using this site, you agree to our Privacy Policy and Terms of Use.