1:
2:
3:
4:

WriteLine('Initialisierung...');
LoadAssembly('mscorlib.dll');
LoadAssembly('System.dll');
WriteLine('Fertig.');					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:

Public Shared Sub InitScriptEngine()
  'Registriert bei der Script-Engine eingei Must-Have-Datentypen und Funktionen, wie Wertetypen und die Methode WriteLine
  ScriptLib.Init()

  'Registriert einen eigenen Datentypen
  ScriptLib.AddScriptObject(GetType(TMyTestObject))

  'Wollen wir auch globale Methoden hinzufügen, so müssen dieser als Shared markiert sein
  ScriptLib.AddScriptObject(GetType(TMyGlobalScriptMethods))

  'Hiermit wird der Script-Engine mitgeteilt, dass sie diese Typen nach globalen Methoden durchsuchen soll.
  'Dieser Funktion könnte noch etwas vereinfacht werden, in dem sie nur noch den Typ als System.Type erwartet
  ScriptLib.AddStaticMethodType(ScriptLib.GetScriptObjectClass("TMyGlobalScriptMethods"))

  'Ganz wichtig: ScriptLib.InitParams()! Damit werden bei allen registrierten Typen die Parameter ausgelesen und mit vorhandenen
  'registrierten Datentypen in Verbindung gebracht, damit zur Laufzeit fast keine Listen mehr abgefragt werden müssen.
  ScriptLib.InitParams()
End Sub

Friend Shared Function ExecuteScript(ByVal Source As String) As Boolean
  'TCodeCompiler ist nur eine Hilfsklasse um bequem die Tokens zu generieren, Variablen zu deklarieren und den Code zu generieren.
  Dim Compiler As New TCodeCompiler()

  'Tokens sind die kleinste Logische Quelltexteinheit, wie z.b. Literals, Schlüsselwörter etc.
  'Somit brauchen bei der Kompilierung keine String-Operationen mehr durchgeführt werden
  Dim Tokens() As TCodeToken = Compiler.GetTokens(Source)

  'Zur Kompilierung als auch zur Laufzeit wird eine Output-Klasse benötigt, in der alle Meldungen wandern.
  'Bei bedarf einfach von TScriptOutput erben und die Funktion "InternalWrite" überschreiben.
  Dim Output As New TScriptOutputConsole

  'Generiert aus den Tokens nun einen ausführbaren Code(für den Interperter bzw. ScriptContext)
  Dim Code As TScriptCode = Compiler.CreateCode(Tokens, Output)

  'Bei fehlgeschlagener Kompilierung kann das Script nicht gestartet werden
  If Compiler.HasError Then
    Console.WriteLine("Kompilierung fehlgeschlagen")
    Return False
  End If

  'Erzeugen vom Script-Kontext bzw. des "Interperters", welche den Code ausführt.
  Dim Context As New TScriptContext(Code, Output)

  'Die Init-Methode kopiert die deklarierten Variabeln vom Code in einen neuen, lokalen Variabel-Speicher
  Context.Init()

  'Zeit in Milisekunden, wie lange das Script maximal laufen darf. 0=Endlos.
  Context.ScriptTimeout = 0

  'Führt das Script aus.
  Context.Execute()

  Return True
End Function

Public Class TScriptOutputConsole
  Inherits TScriptOutput

  Protected Overrides Sub InternalWrite(ByVal msg As String)
    Console.Write(msg)
  End Sub

End Class					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:

namespace LarneTest;

interface

uses
  enobis.utils.Scripting.*;

type
  ConsoleApp = class
  public
    class method Main;
  end;
  
  ScriptOutputConsole = class(TScriptOutput)
  protected
    method InternalWrite(msg : String); override;
  end;
  
  MyTestObject = class
  private
  public
    property MyVal : String;
  end;


implementation

class method ConsoleApp.Main;
begin
  ScriptLib.Init;
  ScriptLib.AddScriptObject(typeof(MyTestObject));  
  ScriptLib.InitParams;
  
  var source := 'Var myObj as New MyTestObject();'+
                'myObj.MyVal = ''foo'';'+
                'WriteLine(myObj.MyVal);';
  
  var compiler := new TCodeCompiler;
  var tokens := compiler.GetTokens(source);
  var output := new ScriptOutputConsole;
  var code := compiler.CreateCode(tokens, output);
  
  if code.HasError then
  begin
    Console.WriteLine('Fehler!');
    Console.Readline;   
    exit;  
  end;
  
  var context := new TScriptContext(code, output);
  context.Init;
  context.ScriptTimeout := 0;
  context.Execute;
  Console.ReadLine;
end;

method ScriptOutputConsole.InternalWrite(msg : String); 
begin
  Console.Write(msg);
end;

end.					

1:

type myDelegate = method InternalWrite(msg : String);					

1:
2:
3:

Var myObj as New MyTestObject();
myObj.MyVal = 'foo';
myObj.DoOutput(myDelegate(WriteLine));					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:

  MyTestObject = class
  private
  public
    property MyVal : String;
    method DoOuptut(outMethod : myDelegate);
  end;

{...}
method MyTestObject.DoOuptut(outMethod : myDelegate);
begin
  outMethod(myVal);
end;					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:

Public Class TMyClass

  Public Function GetFileSize(ByVal Path As String) As Integer
    Return New IO.FileInfo(Path).Length
  End Function

  Public Sub QuitHost()
    Environment.Exit(0)
  End Sub

  Public Function GetWebPage(ByVal url As String) As String
    Dim wc As New Net.WebClient
    Try
      Return System.Text.Encoding.Default.GetString(wc.DownloadData(url))
    Finally
      wc.Dispose()
    End Try
  End Function

End Class

ScriptLib.AddScriptObject(GetType(TMyClass))					

1:
2:
3:
4:

var obj as new TMyClass();
WriteLine(obj.GetWebPage('http://www.google.de'));
WriteLine(obj.GetFileSize('C:\boot.ini'));
obj.QuitHost(); // :-P					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:

'Label-Klasse registrieren
ScriptLib.AddScriptObject(GetType(Label))

'Lokale Script-Variabel vor der Kompilierung vor-definieren
Dim Compiler As TCodeCompiler
'{...}
Compiler.DefinedVariables.Declare("MyLabel", GetType(Label))

'Lokale Script-Variabel setzen
Dim Context As TScriptContext
'{...}
Context.Init()
Context.GlobalVarStorage.Set("MyLabel", MyForm.Label1, Context.Output)					

1:

MyLabel.Text = 'huhu';					

1:

  ScriptLib.RegisterType(typeof(List<String>));					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:

  SomeInterface = interface
    property foo : String read write;
    
  end;
  
  SomeClass = class(SomeInterface)
  private
  public    
    method DoSomething;
    property foo : String;
  end;					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:

  ScriptLib.Init;
  ScriptLib.RegisterType(typeof(SomeInterface));
  ScriptLib.InitParameters;
  
  var source := textBox1.Text;  
  var compiler := new TCodeCompiler;
  
  var aSomeClass := new SomeClass;
  compiler.DefinedVariables.Declare('ASomeClass', typeof(SomeInterface));  
  
  var tokens := compiler.GetTokens(source);
  var output := new ScriptOutputConsole;
  output.aTextBox := textBox2;
  var code := compiler.CreateCode(tokens, output);
  
  if code.HasError then
  begin
    MessageBox.Show('Fehler!');    
    exit;  
  end;
  
  var context := new TScriptContext(code, output);
  context.Init;
  context.ScriptTimeout := 0;
  context.GlobalVarStorage.Set('ASomeClass', aSomeClass, context.Output);
  context.Execute;					

1:

ASomeClass.foo := 'bar';