why are some IronPython dlls generated with a DLRCachedCode class inside?

Question

when I compile some .py codefiles with no class definitions into dlls , the compiled dll is created with a "DRLCachedCode" class inside. Why is that?

Answer 1

When you compile IronPython code it doesn't get compiled to normal .NET code where you'd have a class at the IL level for each class you have at the source level. Instead it gets compiled into the same form that we compile to internally using the DLR.

For user code this is just a bunch of executable methods. There's one method for each module, function definition, and class definition. When the module code runs it executes against a dictionary. Depending on what you do in the module the .NET method may publish into the dictionary a:

• PythonType for new-style classes

• An OldClass for old-style classes

• A PythonFunction object for function definitions

• Any values that you assign to (e.g. Foo=42)

• Any side effects of doing exec w/o providing a dictionary (e.g. exec "x=42")

• etc...

The final piece of the puzzle is where is this dictionary stored and how do you get at it? The dictionary is stored in a PythonModule object and we create it when the user imports the pre-compiled module and then we execute the module against it. Therefore this code is only available via Python's import statement (or the extension method on ScriptEngine "ImportModule" which is exposed via IronPython.Hosting.Python class).

So all of the layout of the code is considered an internal implementation detail which we reserve the right to change at any point in time.

Finally the name DLRCachedCode comes because the DLR (outer layer) saves this code for us. Multiple languages can actually be saved into a single DLL if someone really wanted to.