Script.NET a language for embedding scripting functionality into CLR Applications

Boolean = True | False
Object = null
String constants must be in '' brackets, example: s='Hello';

Examples of variables:
X, x1, name_of_var.
Variables may be used in expressions, statements. The type information is computed in run-time.

Example:

if (x>0) y = y + 1 ; else y = y – 1;
if (x>0) message = 'X is positive';

Example:

sum=0;
for(i=0; i<10; i++) sum = sum + a[i];

Foreach ... in ...

foreach (Identifier in Expression) Statement

The result of Expression calculation must implement IEnumerable. Expression evaluates only once, before loop starts.

While ...

while (Expression) Statement

Switch

Break, Continue

Has usual meaning, may be used only inside the loop

Return

Used only inside function call

Functions

function (id1, id2, ... , idn) {
Statement }

The function is creates local context during execution.

Reserved functions

event – assign event to windows forms control
eval – evaluates value of an expression
clear – clears all variables in context

Script Context

Script Context is an object stores run-time information: variables and import types. Using Script Context you can add .NET objects to use in the script.

There are a number of functions:

• Get the value of variable with name id within Context:
  public object Lookup(string id)
• Add .NET object to the Script context with specified name
  public void AddObject(string name, object value)
• Add .NET type to the script context to use it in new expressions
  public void AddType(string name, Type value)
• Add build in object, which means you can invoke its Methods without specifying the name.
  public void AddBuildInObject (object object)
  
  Example:
  In C# code (look example above)
  AddBuildInObject(typeof(Math))
  
  
  In Script.NET
  a = Pow(2,3); //Will call Math.Pow(2,3);
• Removes build-in object
  public void RemoveBuildInObject (object object)
• Gets the static field value
  public object GetStaticValue(string FullName)
  
  Example:
  x = Context.GetStaticValue( 'double.NaN' );

Using .NET objects from Script.NET

  
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using ScriptDotNet;

namespace Test
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {

             Script s = Script.Compile(@"form.Text = 'Hello World'; 
               MessageBox.Show('Hi'); 
               b = new Button()  ");

            s.AddObject("form", this);
            s.AddType("Button", typeof(Button));
            s.AddType("MessageBox", typeof(MessageBox));
            s.AddBuildInObject(typeof(Math));

            s.Execute();            
        }
    }
}
   

Script.NET in .NET Applications

All you need to start working with Script .NET is to add reference to ScriptDotNet.dll,

 
using ScriptDotNet;
...
Script s = Script.Compile(
                 "MessageBox.Show('Hello .NET! This is Script .NET');");
s.AddType("MessageBox", typeof(MessageBox));
s.Execute();            
 
 

Script Test

Script Test is the application for testing Script.NET programs. You can use it to execute any scripting program and to observe results in Script Context.

Mutantic Framework

Mutantic Framework introduces a special kind of "meta" objects for working with objects of any type.

Definition: Mutant is a special object which could have all properties (fields, methods, etc), and may be converted to any type (or assigned to object of any type). The semantics of such conversion (or assignment) is pragmatically conditional, i.e. depends on user needs.

Example. Creation and Usage of MObject:

// Create Data Mutant Object
a = [ Text -> 'Hello from Mutant' ];
// Set Additional Fields
a.Top = 0;
a.Left = 0;
// Set corresponding fields of Windows Form object
// (Mutantic Assignment)
form := a;

Meta Programming

Script .NET has a special quotation operator: <[ program ]> which returns AST of a given program. The AST of the current program may be accessed with prog object.

Here is an example: Modification of current script

//Create an AST for MessageBox.Show('Hello'); program
ast = <[ MessageBox.Show('Hello'); ]>;
//Add this AST at the and of the current program
prog.AppendAst(ast);
MessageBox.Show(prog.Code());

The <[ ... ]> operator and prog object allows Script.NET to generate new scripts or modify existing script at the run-time.

Alternative Solutions:

• Java Script ActiveX control via COM interface
• Lua via API
• Python.NET native integration

External Links

• Project on CodePlex
• Project on HomePage