OK. Here's my current assignment -- I need to write a formula parser
which is *fast*, as the formulas will need to be interpreted (acting
on new variables each pass) roughly a few zillion times during
operation. The formulas must be able to include some custom-designed
functions (such as 'the average of the last 10 values in a
user-specified field of a table') as well as standard math functions.
Further, the formulas must be able to reference other formulas, i.e.

Formula 1=a*b+c, named "FirstValue"
Formula 2=FirstValue+5

The program will then feed a,b,and c into the formula many, many,
times, so you see the advantage of turning the formula into something
like:

MyCustomRoutine (float a, float b, float c)
(
    return (a*b+c)+5;
}

(Ignore my crappy pseudocode, please)

There will be many of these, called at different times and for
different reasons. It is imperative the formula parser be powerful and
flexible.

My idea was to have the formula parser actually emit Intermediate
Language code and compile the results into a DLL. Then, the main
program would simply call the dynamically-created formulas to apply to
the data, so that the formulas do not need to be parsed each and every
time. Since the formulas will only need minor editing once written by
the user, there's an advantage to parse and compile, as opposed to
creating the IL code each time the program is run.

So here's question one: Where do I find massive quantities of info on
IL? I've made some initial progress using "Expert .Net Programming" by
Simon Robinson, but that's just a beginning. I need to learn a lot,
fast. Websites, other books, lost papyrus scrolls...

Question two, and, my GOD, is this a stupid question -- how do I (or
CAN I?) do a #using when writing dynamically generated code? For
example, if I have a class that includes the more complex functions,
such as moving average, I want to be able to have my
dynamically-generated code call the Moving Average function in my main
program code. You may laugh at the silliness of this now, but none of
the simple examples of dynamically generated code seem to include this
functionality.

Question three, the transcendentally stupid question -- is there a
reason not to use basic string functions to write my routined as
standard C# source code text files, then pass that text file to the
appropriate CodeDOM routines, instead of learning IL and messing with
ILConstructor.Emit()? I have looked at the various CodeDom functions
to emit code, but if my code is relatively simple, can I eliminate the
middleman and just spit out the ready-to-compile source file via
normal string manipulation?

Thanks for your patience with these questions.
*----------------------------------------------------*
Evolution doesn't take prisoners:Lizard
"I've heard of this thing men call 'empathy', but I've never
once been afflicted with it, thanks the Gods." Bruno The Bandit
http://www.mrlizard.com