Script.NET - AbsoluteAstronomy.com

Script.NET or S# is a metaprogramming

Metaprogramming

Metaprogramming is the writing of computer programs that write or manipulate other programs as their data, or that do part of the work at compile time that would otherwise be done at runtime...

language that provides scripting functionality in Microsoft .NET applications, allowing runtime execution of custom functionality, similar to VBA

VBA

VBA can mean:* Virtual backup appliance, a virtual machine used to back up other virtual machines* Visual Basic for Applications, the application edition of Microsoft's Visual Basic programming language...

in Microsoft Office

Microsoft Office

Microsoft Office is a non-free commercial office suite of inter-related desktop applications, servers and services for the Microsoft Windows and Mac OS X operating systems, introduced by Microsoft in August 1, 1989. Initially a marketing term for a bundled set of applications, the first version of...

applications. The syntax of Script.NET is similar to JavaScript

JavaScript

JavaScript is a prototype-based scripting language that is dynamic, weakly typed and has first-class functions. It is a multi-paradigm language, supporting object-oriented, imperative, and functional programming styles....

. It is designed to be simple and efficient scripting language allowing to customize .NET applications. The language has a true runtime interpreter, and it is executed without generating additional in-memory assemblies.

Script.NET is an open-source project.

Metaprogramming features

Script.NET has a special quotation operator <[ program ]> which returns AST

Abstract syntax tree

In computer science, an abstract syntax tree , or just syntax tree, is a tree representation of the abstract syntactic structure of source code written in a programming language. Each node of the tree denotes a construct occurring in the source code. The syntax is 'abstract' in the sense that it...

of a given program. Additionally, the AST of the current program may be accessed with the prog object.

Here is an example:

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

The <[ ... ]> operator and prog objects allow Script.NET to generate new scripts or modify existing scripts at runtime.

Generalized objects

Script.NET includes so-called "Mutantic Framework" which introduces a special kind of "meta" objects for controlling objects of any type. It is composed of a set of classes, on top of which is the "DataMutant" class. It implements several principles of mutant object:

Definition

A 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) are pragmatically conditional.

There is a special operator := called Mutantic or Generalized assignment. Its purpose is to assign values of DataMutant fields to corresponding fields of an object of any type.

Example. Creation and Usage of MObject:

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

Bubble sort function

a=[17, 0, 5, 3,1, 2, 55];
for (i=0; i < a.Length; i=i+1)
for (j=i+1; j < a.Length; j=j+1)
if (a[i] > a[j] )
{
temp = a[i];
a[i] = a[j];
a[j] = temp;
}

s = 'Results:';
for (i=0; i < a.Length; i++)
s = s + ',' + a[i];

MessageBox.Show(s);

RSS Reader

a = new XmlDocument;
a.Load('http://www.codeplex.com/scriptdotnet/Project/ProjectRss.aspx');

MessageBox.Show('CodePlex Script.NET RSS::');
foreach (n in a.SelectNodes('/rss/channel/item/title'))
MessageBox.Show(n.InnerText);

Stack

Stack limited to 10 elements using Design by contract

Design by contract

Design by contract , also known as programming by contract and design-by-contract programming, is an approach to designing computer software...

feature

function Push(item)
[
//Limit to 10 items
pre(me.Count < 10 );
post;
invariant;
]
{
//me is mutated object,
//stack in this case
me.Push(item);
}

function Pop
[//Check emptiness
pre(me.Count > 0);
post;
invariant;
]
{
return me.Pop;
}

stack = new Stack<|int|>;

//Create Mutant
//1. Set Functions, override stack.Push
mObject=[Push->Push,PopCheck->Pop];
//2. Capture object
mObject.Mutate(stack);

for (i=0; i<5; i++)
mObject.Push(i);

Console.WriteLine((string)mObject.PopCheck);

External links

The source of this article is wikipedia, the free encyclopedia. The text of this article is licensed under the GFDL.