C# - Dynamic Language Runtime in Desktop-Applikation einbinden

using System;
using System.CodeDom;
using Microsoft.Scripting;
using Microsoft.Scripting.Hosting;
using Microsoft.Scripting.Runtime;

/* App.Config für die DLR
 <?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <configSections>
	  <section name="microsoft.scripting" 
			   type="Microsoft.Scripting.Hosting.Configuration.Section, Microsoft.Scripting, Version=0.9.6.20, Culture=neutral, PublicKeyToken=31bf3856ad364e35"
			   requirePermission="false" />
  </configSections>
  <microsoft.scripting>
    <languages>
      <language names="IronPython;Python;py" 
    	        extensions=".py" 
                displayName="IronPython 2.6"
                type="IronPython.Runtime.PythonContext, IronPython, Version=2.6.0.20, Culture=neutral, PublicKeyToken=31bf3856ad364e35" />
      <language names="IronRuby;Ruby;rb" 
    	        extensions=".rb"
                displayName="IronRuby 0.9"
                type="IronRuby.Runtime.RubyContext, IronRuby, Version=0.9.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" />
    </languages>
    <options>
      <set language='Ruby' option='LibraryPaths' value='.\lib\IronRuby;.\lib\ruby\site_ruby\1.8;.\lib\ruby\site_ruby;.\lib\ruby\1.8'/>
    </options>
  </microsoft.scripting>
</configuration>
*/

namespace DLR_hosting
{
	static class Program
	{
		/// <summary>
		/// The main entry point for the application.
		/// </summary>
		[STAThread]
		static void Main ()
		{
			// Die DLR muss in der App.Config eingerichtet werden. Hier sind auch
			// die zur Verfügung stehenden Sprach-Engines a la IronPython, IronRuby, IronScheme ...
			ScriptRuntime runtime = ScriptRuntime.CreateFromConfiguration ();
			
			// Alternativ kann auch direkt über die Engine initialisiert werden, dann muss aber
			// die Assembly in der die Engine steckt referenziert werden.
			//ScriptRuntime runtime = IronPython.Hosting.Python.CreateRuntime ();
			
			ScriptEngine pythonEngine	= runtime.GetEngine ( "IronPython" );
			// Die anderen Engines funktionieren im Moment nicht, da der aktuelle Stand nocht nicht 
			// auf der neuesten DLR basiert.
			//ScriptEngine rubyEngine		= runtime.GetEngine ( "IronRuby" );			
			//ScriptEngine luaEngine		= runtime.GetEngine ( "IronLua" );
			//ScriptEngine schemeEngine		= runtime.GetEngine ( "IronScheme" );
			
			// Einen Gültigkeitsbereich für Code in der Runtime anlegen.
			// Das ist jetzt unser globaler Namespace für unseren Host.
			ScriptScope baseScope = runtime.CreateScope ();			 

			// Jetzt registrieren wir unsere Instanzen, die wir im Script bearbeiten
			// wollen für die ScriptEngine in unserem "globalen Namespace" baseScope.
			// Dann können wir ...
			MyClass myClass = new MyClass ();
			baseScope.SetVariable ( "MyClassInstance", myClass );
			
			// ... uns einen eigenen dynamische UserScope definieren
			var userSymbols = new DynamicSymbolDictionary ( baseScope );
			ScriptScope useScope = pythonEngine.CreateScope ( userSymbols );

			// ... und Code ausführen der unsere C# Instanzen verändert.
			// 1. aus einer Zeichenkette
			var scriptSourceFromString = pythonEngine.CreateScriptSourceFromString(
				"MyClassInstance.MyPropertyInt = 3\nprint MyClassInstance.MyPropertyInt",
				SourceCodeKind.Statements);

			// 2. aus einer Datei
			var scriptSourceFromFile = pythonEngine.CreateScriptSourceFromFile ( @"test.py" );

			// 3. aus einem Provider (wird wohl eher von den einzelnen Scriptimplementierungen verwendet)
			//TODO: Provider erstellen.
			//StreamContentProvider scp;
			//TextContentProvider tcp;
			//var scriptSourceFromStreamProvider = pythonEngine.CreateScriptSource ( scp );
			//var scriptSourceFromTextProvider   = pythonEngine.CreateScriptSource ( tcp );

			// 4. aus dem CodeDom (eingeschränkt)
			//CodeObject codeObject;
			//TODO: codeObject erzeugen.
			//var scriptSourceFromCodeDom = pythonEngine.CreateScriptSource( codeObject);
		}
	}

	public class DynamicSymbolDictionary : CustomSymbolDictionary
	{
		private ScriptScope superScope;

		public DynamicSymbolDictionary ( ScriptScope superScope )
			: base ()			
		{
			this.superScope = superScope;
		}

		/// <summary>
		/// Try to set the extra value and return true if the specified key was found in the
		/// list of extra values.
		/// </summary>
		/// <param name="key"></param>
		/// <param name="value"></param>
		/// <returns></returns>
		protected override bool TrySetExtraValue ( SymbolId key, object value )
		{
			return false;
		}

		/// <summary>
		/// Gets a list of the extra keys that are cached by the the optimized implementation
		/// of the module.
		/// </summary>
		/// <returns></returns>
		public override SymbolId[] GetExtraKeys ()
		{
			return null;
		}

		/// <summary>
		/// Try to get the extra value and returns true if the specified key was found in the
		/// list of extra values.  Returns true even if the value is Uninitialized.
		/// This function is called every time a script uses a variable.
		/// </summary>
		/// <param name="key"></param>
		/// <param name="value"></param>
		/// <returns></returns>
		protected override bool TryGetExtraValue ( SymbolId key, out object value )
		{
			// if the variable is located in the super-scope we return this one. 
			// we achive scope-chaining with this technique.
			if ( superScope.TryGetVariable ( SymbolTable.IdToString ( key ), out value ) )
			{
				return true;
			}
			
			value = null;
			return false;
		}
	}
}