DLR Hosting and related stuff... : HowTo

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);

DLR Hosting API : How to create ScriptScopes using backing symbol dictionaries to implement dynamic variable lookup

seshadripv — Sat, 16 Aug 2008 06:04:00 GMT

The factory methods used to create a ScriptScope object have overloads that take a 'IAttributeCollection' object to create the scope using the collection as a backing store. This feature is very useful and any app that needs non trivial Hosting would mostly use this feature.

The easiest way to implement the IAttributeCollection interface is to implement the CustomSymbolDictionary defined in the the Hosting API. Once this is done, all variable access by a script executing in the context of this scope will result in a call to the set or get methods that were overriden.

You can do some interesting things like chaining of scopes, inspecting variable values upon script access, value validation etc using this symbol dictionary implementation.

The following example uses a custom symbol dictionary to chain scopes to create a pseudo hierarchy.

using System;

using Microsoft.Scripting;

using Microsoft.Scripting.Hosting;

using Microsoft.Scripting.Runtime;

namespace ScopeOps {

public class ScopeHiererchy {

public static void Main() {

ScriptEngine eng = new ScriptRuntime().GetEngine("py");

ScriptScope baseScope = eng.CreateScope();

var dict = new DynamicLookupDictionary(baseScope);

//set variables in the base scope.

baseScope.SetVariable("base_int", 100);

baseScope.SetVariable("base_string", "from base");

ScriptScope useScope = eng.CreateScope(dict);

var src = eng.CreateScriptSourceFromString(

"print base_int\nprint base_string",

SourceCodeKind.Statements);

//'useScope' doesn't have the variables accessed by the script yet.

//The overriden 'get' method dynamically looks up the variable in the base scope.

src.Execute(useScope);

}

internal class DynamicLookupDictionary : CustomSymbolDictionary {

private ScriptScope _baseScope;

public DynamicLookupDictionary(ScriptScope baseScope):base() {

_baseScope = baseScope;

}

//This method would be invoked whenever a script executing in the context of this scope

//accesses a variable

protected override bool TryGetExtraValue(SymbolId key, out object value) {

//If the variable is part of the base scope, return that value - this effectively

//creates a 'scope chain'

if (_baseScope.TryGetVariable(SymbolTable.IdToString(key), out value)) {

return true;

}

value = null;

return false;

}

public override SymbolId[] GetExtraKeys() {

return null;

}

protected override bool TrySetExtraValue(SymbolId key, object value) {

return false;

}