DLR Hosting and related stuff... : ScriptRuntime

DLR Hosting API : How to create a ScriptRuntime object without using App.Config files using language specific hosting API

seshadripv — Mon, 15 Sep 2008 02:39:00 GMT

This previous post demonstrates the use of App.Config files to create script runtimes to host dynamic languages in an application. It is also possible to create runtimes without using a config file.

The API to create a runtime and a python engine without using a config file is

ScriptRuntime runtime = IronPython.Hosting.Python.CreateRuntime();

A reference to the IronPython assemblies – IronPython.dll and IronPython.Modules.dll are needed for this call to work. The previous sample already has the proper references in place and this call would automatically work in that project.

DLR Hosting Sample : Simple dlr host using the new App.Config based ScriptRuntime creation

seshadripv — Thu, 11 Sep 2008 20:58:00 GMT

Due to the recent changes to the DLR Hosting API, dlr hosts now have to use the App.Config file to configure the languages they intend to use in the application. It’s probably a little bit more complex than before to get started on Hosting the DLR after this change.

The attached self contained sample(for VS 2008) addresses this and tries to make it easier to ‘get started’. The sample is a very simple console application that -

1) Hosts the dlr

2) Uses the ScriptRuntimeSetup.ReadConfiguration() and the ScriptRuntime constructor to create the runtime based on the entries in the App.Config file

3) Creates 2 language engines – one for IronPython and 1 for IronRuby

4) Creates a variable in IronPython and prints the value in C#.

The sample contains a pre configured App.Config file. You should be able to just extract the files locally and build the sample and execute it. The dlr and language binaries are also included (in the ‘lib’ folder). Note that these post IronPython V2 beta4 binaries are for demo purposes only and come with no warranty or support.

DLR Hosting API : latest version of the spec is available online (includes changes to runtime initialization)

seshadripv — Mon, 08 Sep 2008 00:32:00 GMT

The latest version of the Hosting API spec is available here. The most recent source code drop to the IronPython codeplex site conforms to this spec (except for some open bugs).

The biggest change this spec introduces to the beta4 binaries is the way the hosting runtime is initialized.

Prior to this update, the hosting runtime is initialized by creating a new ScriptRuntime object. Now, a typical runtime initialization involves 2 things.

A quick 5 min how-to on the new initialization is as follows

1) Setting up entries in the application’s config file. Here is a sample config file

<?xml version="1.0" encoding="utf-8" ?>

<section name="microsoft.scripting"

type="Microsoft.Scripting.Hosting.Configuration.Section, Microsoft.Scripting, Version=1.0.0.5000, Culture=neutral, publicKeyToken=31bf3856ad364e35"

requirePermission="false" />

</configSections>

<microsoft.scripting>

<language names="IronPython,Python,py"

extensions=".py"

displayName="IronPython 2.0 Beta"

type="IronPython.Runtime.PythonContext,IronPython, Version=2.0.0.5000, Culture=neutral, publicKeyToken=31bf3856ad364e35" />

<language names="IronRuby;Ruby,rb"

extensions=".rb"

displayName="IronRuby 1.0 Alpha"

type="IronRuby.Runtime.RubyContext, IronRuby, Version=1.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"/>

</languages>

</microsoft.scripting>

</configuration>

2) Calling the following methods

ScriptRuntimeSetup srs = ScriptRuntimeSetup.ReadConfiguration();

ScriptRuntime runtime = new ScriptRuntime(srs);

4 different ways to execute IronPython code using the DLR Hosting API

seshadripv — Tue, 29 Jul 2008 06:55:00 GMT

The Hosting API offers 4 different sets of methods to execute a script. These methods provide hosts - managed application in C#, VB and other .NET languages - with powerful, convenient and versatile ways to execute scripts from the DLR languages like IronPython, IronRuby etc. ( Though the title mentions just IronPython, this post applies to others like IronRuby, ToyScript etc as well)

I have put together a short summary of these methods and the types that define them. The descriptions found here are shortened versions of the descriptions found in the Hosting API spec. Please refer to the same for more specific details about the type and the method.

The types that define these method families are ScriptRuntime, ScriptScope, ScriptSource and CompiledCode.

ScriptRuntime

This class is the starting point for hosting. ScriptRuntime represents global script state. This includes referenced assemblies, a "global object" (ScriptRuntime.Globals), "published" scopes (scopes bound to a name on Globals), available language engines, etc.

public ScriptScope ExecuteFile(string path);

This method executes the source identified in the path argument and returns the new ScriptScope in which the source executed. ExecuteFile determines the language engine to use from the path's extension and the ScriptRuntime's configuration, comparing extensions case-insensitively.

The path is an absolute pathname or a filename that naturally resolves with standard .NET BCL file open calls.

ScriptScope

This class represents a namespace essentially. Hosts can bind variable names in ScriptScopes, fetch variable values, etc. Hosts can execute code within scopes for distinct name bindings.

public object Execute(string code);

public T Execute<T>(string code);

These methods return objects that result from executing code in the string argument.

ScriptSource

ScriptSource represents source code and offers a variety of ways to execute or compile the source. You can get ScriptSources from factory methods on ScriptEngine, and ScriptSources are tied to the engine that created them.

public object Execute(ScriptScope scope);

public ObjectHandle ExecuteAndWrap(ScriptScope scope);

public T Execute<T>(ScriptScope scope);

public int ExecuteProgram();

These methods execute the source code and return the result. All but one method executes the code in the specified ScriptScope.

CompiledCode

CompiledCode represents code that has been compiled to execute repeatedly without having to compile it each time, and it represents the default ScriptScope the code runs in. You can also execute the code in any ScriptScope if you need it to execute in a clean scope each time, or you want to accumulate side effects from the code in another scope.

public object Execute() { }

public object Execute(ScriptScope scope) { }

public ObjectHandle ExecuteAndWrap() { }

public ObjectHandle ExecuteAndWrap(ScriptScope scope) { }

public T Execute<T>() { }

public T Execute<T>(ScriptScope scope) { }

Unlike the ScriptSource’s execute methods, these do not compile the code again.

A few of these methods can be found in the samples from the earlier blog posts. For more details and documentation about these methods and types please refer to the Hosting API spec.

How to create IronPython objects of types defined in C#

seshadripv — Thu, 24 Jul 2008 05:45:00 GMT

The DLR Hosting API lets the hosted script instantiate objects of types defined in the hosting C# / VB module. This post describes how to do that using the appropriate methods from the API. Here are the simple steps -

1) Load the assembly containing the type in to the ScriptRuntime object

ScriptRuntime runtime = ScriptRuntime.Create();

runtime.LoadAssembly( Assembly.GetAssembly( typeof( n1.MyType1)));

2) Import the namespace/type inside the script

from n1 import *

3) Create an object of the type and invoke members

n=MyType1()

print n.Name

Here’s the full sample

using System.Scripting;

using Microsoft.Scripting.Hosting;

using System.Reflection;

namespace n1 {

public class MyType1 {

public string Name { get; set; }

public MyType1() {

Name = "MyType1";

}

public class Program {

static void Main(string[] args) {

string code = @"from n1 import *

n=MyType1()

print n.Name";

ScriptRuntime runtime = ScriptRuntime.Create();

runtime.LoadAssembly( Assembly.GetAssembly( typeof( n1.MyType1)));

ScriptEngine eng = runtime.GetEngine("py");

ScriptScope scope = eng.GetEngine("py").CreateScope();

ScriptSource src = eng.CreateScriptSourceFromString( code, SourceCodeKind.Statements);

src.Execute(scope);

}