"{char}{char}" -> "\u{((int)c).ToString("x4")}"
"((" -> "\u0028"
var code = @"using System;
public class Script : MarshalByRefObjectWithInfiniteLifetime
{
public void Hello(string greeting)
{
Console.WriteLine(greeting);
}
}";
using (var helper = new AsmHelper(CSScript.CompileCode(code), null, deleteOnExit: true))
{
IScript script = helper.CreateAndAlignToInterface<IScript>("*");
script.Hello("Hi there...");
}
asmHelper.AlignToInterface(asmHelper.CreateObject(typeName))
var scriptHelper = new AsmHelper(scriptAsmFile, null, true);
scriptHelper.RemoteObject.ExtendLifeFromMinutes(30);
GetStaticMethod("Calc.Sum", 0, 0)
GetStaticMethod("Calc.Sum", 0, 0)
GetMethod(instance, "Sum", 0, 0)
You can pass any integer as the second and third parameter because it will be used only to obtain the
information about the parameter type (in this case System.Int32).
GetMethod(instance, "Sum", 0, 0)
You can pass any integer as the second and third parameter because it will be used only to obtain the
information about the parameter type (in this case System.Int32).
This is an extremely light way of getting Reflection information of a given object. Object can be either local one or a TransparentProxy of the object instantiated in a remote AppDomain.
using (var helper = new AsmHelper(CSScript.CompileCode(code), null, true))
{
var script = helper.CreateObject("Script"); //script code has 'class Script' declared
foreach (string info in helper.GetMembersOf(script))
Debug.WriteLine(info);
}
class Script
{
public void SayHello(string greeting)
{
...
if(testingWithMono)
CSScript.EvaluatorConfig.Engine = EvaluatorEngine.Mono;
else
CSScript.EvaluatorConfig.Engine = EvaluatorEngine.Roslyn;
var sub = CSScript.Evaluator
.LoadDelegate<Func<int, int, int>>(
@"int Sub(int a, int b) {
return a - b;
}");
// called from the script code
var asm_hash = Assembly.GetExecutingAssembly().GetHashCode();
var script_location = Environment.GetEnvironmentVariable(\"location:\" + asm_hash);
var Product = CSScript.LoadDelegate<Func<int, int, int>>(
@"int Product(int a, int b)
{
return a * b;
}");
int result = Product(3, 2);
var SayHello = CSScript.CreateAction(@"void SayHello(string greeting)
{
Console.WriteLine(greeting);
}");
SayHello("Hello World!");
var product = CSScript.CreateFunc<intgt;(@"int Product(int a, int b)
{
return a * b;
}");
int result = product(3, 4);
var Product = CSScript.LoadDelegate<Func<int, int, int>>(
@"int Product(int a, int b)
{
return a * b;
}");
int result = Product(3, 2);
var SayHello = CSScript.CreateAction(@"void SayHello(string greeting)
{
Console.WriteLine(greeting);
}");
SayHello("Hello World!");
var product = CSScript.CreateFunc<intgt;(@"int Product(int a, int b)
{
return a * b;
}");
int result = product(3, 4);
CSScript.LoadMethod(
@"using System.Windows.Forms;
public static void SayHello(string greeting)
{
MessageBoxSayHello(greeting);
ConsoleSayHello(greeting);
}
public static void MessageBoxSayHello(string greeting)
{
MessageBox.Show(greeting);
}
public static void ConsoleSayHello(string greeting)
{
Console.WriteLine(greeting);
}");
Assembly asm = CSScript.CodeDomEvaluator
.CompileCode(@"using System;
public class Script
{
public int Sum(int a, int b)
{
return a+b;
}
}");
dynamic script = asm.CreateObject("*");
var result = script.Sum(7, 3);
dynamic script = CSScript.CodeDomEvaluator
.CompileMethod(@"int Sum(int a, int b)
{
return a+b;
}")
.CreateObject("*");
var result = script.Sum(7, 3);
var log = CSScript.CodeDomEvaluator
.CreateDelegate(@"void Log(string message)
{
Console.WriteLine(message);
}");
log("Test message");
var product = CSScript.CodeDomEvaluator
.CreateDelegate<int>(@"int Product(int a, int b)
{
return a * b;
}");
int result = product(3, 2);
dynamic script = CSScript.CodeDomEvaluator
.LoadCode(@"using System;
public class Script
{
public int Sum(int a, int b)
{
return a+b;
}
}");
int result = script.Sum(1, 2);
public interface ICalc
{
int Sum(int a, int b);
}
....
ICalc calc = CSScript.CodeDomEvaluator
.LoadCode<ICalc>(@"using System;
public class Script
{
public int Sum(int a, int b)
{
return a+b;
}
}");
int result = calc.Sum(1, 2);
var Product = CSScript.CodeDomEvaluator
.LoadDelegate<Func<int, int, int>>(
@"int Product(int a, int b)
{
return a * b;
}");
int result = Product(3, 2);
dynamic script = CSScript.CodeDomEvaluator
.LoadFile("calc.cs");
int result = script.Sum(1, 2);
public interface ICalc
{
int Sum(int a, int b);
}
....
ICalc calc = CSScript.CodeDomEvaluator
.LoadFile<ICalc>("calc.cs");
int result = calc.Sum(1, 2);
dynamic script = CSScript.CodeDomEvaluator
.LoadMethod(@"int Product(int a, int b)
{
return a * b;
}");
int result = script.Product(3, 2);
public interface ICalc
{
int Sum(int a, int b);
int Div(int a, int b);
}
....
ICalc script = CSScript.CodeDomEvaluator
.LoadMethod<ICalc>(@"public int Sum(int a, int b)
{
return a + b;
}
public int Div(int a, int b)
{
return a/b;
}");
int result = script.Div(15, 3);
Assembly asm = CSScript.RoslynEvaluator
.CompileCode(@"using System;
public class Script
{
public int Sum(int a, int b)
{
return a+b;
}
}");
dynamic script = asm.CreateObject("*");
var result = script.Sum(7, 3);
dynamic script = CSScript.RoslynEvaluator
.CompileMethod(@"int Sum(int a, int b)
{
return a+b;
}")
.CreateObject("*");
var result = script.Sum(7, 3);
var log = CSScript.RoslynEvaluator
.CreateDelegate(@"void Log(string message)
{
Console.WriteLine(message);
}");
log("Test message");
var product = CSScript.RoslynEvaluator
.CreateDelegate<int>(@"int Product(int a, int b)
{
return a * b;
}");
int result = product(3, 2);
dynamic script = CSScript.RoslynEvaluator
.LoadCode(@"using System;
public class Script
{
public int Sum(int a, int b)
{
return a+b;
}
}");
int result = script.Sum(1, 2);
public interface ICalc
{
int Sum(int a, int b);
}
....
ICalc calc = CSScript.RoslynEvaluator
.LoadCode<ICalc>(@"using System;
public class Script
{
public int Sum(int a, int b)
{
return a+b;
}
}");
int result = calc.Sum(1, 2);
var Product = CSScript.RoslynEvaluator
.LoadDelegate<Func<int, int, int>>(
@"int Product(int a, int b)
{
return a * b;
}");
int result = Product(3, 2);
dynamic script = CSScript.RoslynEvaluator
.LoadFile("calc.cs");
int result = script.Sum(1, 2);
public interface ICalc
{
int Sum(int a, int b);
}
....
ICalc calc = CSScript.Evaluator
.LoadFile<ICalc>("calc.cs");
int result = calc.Sum(1, 2);
dynamic script = CSScript.RoslynEvaluator
.LoadMethod(@"int Product(int a, int b)
{
return a * b;
}");
int result = script.Product(3, 2);
public interface ICalc
{
int Sum(int a, int b);
int Div(int a, int b);
}
....
ICalc script = CSScript.RoslynEvaluator
.LoadMethod<ICalc>(@"public int Sum(int a, int b)
{
return a + b;
}
public int Div(int a, int b)
{
return a/b;
}");
int result = script.Div(15, 3);
var script = CSScript.Evaluator
.LoadMethodRemotely<ICalc>(
@"public int Sum(int a, int b)
{
return a+b;
}
public int Sub(int a, int b)
{
return a-b;
}");
int result = script.Sum(15, 3));
// after the next line call the remote domain with loaded script will be unloaded
script.UnloadOwnerDomain();
// duck-typed proxy; must use CodeDomEvaluator
var script = CSScript.CodeDomEvaluator
.LoadCodeRemotely<ICalc>(
@"using System;
public class Calc : MarshalByRefObject
{
public int Sum(int a, int b)
{
return a + b;
}
}");
// ordinary type casted proxy
var script2 = CSScript.Evaluator
.LoadCodeRemotely<ICalc>(
@"using System;
public class Calc : MarshalByRefObject : ICalc
{
public int Sum(int a, int b)
{
return a + b;
}
}");
int result = script.Sum(15, 3);
// after the next line call the remote domain with loaded script will be unloaded
script.UnloadOwnerDomain();
var log = CSScript.Evaluator
.CreateDelegateRemotely(
@"void Log(string message)
{
Console.WriteLine(message);
}");
log("Test message");
log.UnloadOwnerDomain();
var product = CSScript.Evaluator
.CreateDelegateRemotely<int>(
@"int Product(int a, int b)
{
return a * b;
}");
int result = product(3, 2);
product.UnloadOwnerDomain();
async void button1_Click(object sender, EventArgs e)
{
Assembly script = await CSScript.Evaluator
.CompileCodeAsync(
@"using System;
public class Calc
{
public int Sum(int a, int b)
{
return a+b;
}
}");
dynamic calc = script.CreateObject("*");
textBox1.Text = calc.Sum(3, 2).ToString();
}
async void button1_Click(object sender, EventArgs e)
{
Assembly script = await CSScript.Evaluator
.CompileMethodAsync(
@"int Sum(int a, int b)
{
return a+b;
}");
dynamic calc = script.CreateObject("*");
textBox1.Text = calc.Sum(3, 7).ToString();
}
async void button1_Click(object sender, EventArgs e)
{
var product = await CSScript.Evaluator
.CreateDelegateAsync<int>(
@"int Product(int a, int b)
{
return a * b;
}");
textBox1.Text = product(3, 2).ToString();
}
async void button1_Click(object sender, EventArgs e)
{
var log = await CSScript.Evaluator
.CreateDelegateAsync(
@"void Log(string message)
{
Console.WriteLine(message);
}");
log("Test message");
}
async void button1_Click(object sender, EventArgs e)
{
dynamic calc = await CSScript.Evaluator
.LoadCodeAsync(
@"using System;
public class Script
{
public int Sum(int a, int b)
{
return a+b;
}
}");
textBox1.Text = calc.Sum(1, 2).ToString();
}
async void button1_Click(object sender, EventArgs e)
{
ICalc calc = await CSScript.Evaluator
.LoadCodeAsync<ICalc>(
@"using System;
public class Script
{
public int Sum(int a, int b)
{
return a+b;
}
}");
textBox1.Text = calc.Sum(1, 2).ToString();
}
async void button1_Click(object sender, EventArgs e)
{
ICalc script = await CSScript.Evaluator
.LoadFileAsync<ICalc>("calc.cs");
textBox1.Text = script.Sum(1, 2).ToString();
}
async void button1_Click(object sender, EventArgs e)
{
dynamic script = await CSScript.Evaluator
.LoadFileAsync("calc.cs");
textBox1.Text = script.Sum(1, 2).ToString();
}
async void button1_Click(object sender, EventArgs e)
{
ICalc script = await CSScript.Evaluator
.LoadMethodAsync<ICalc>(
@"public int Sum(int a, int b)
{
return a + b;
}
public int Div(int a, int b)
{
return a/b;
}");
textBox1.Text = script.Div(15, 3).ToString();
}
async void button1_Click(object sender, EventArgs e)
{
ICalc script = await CSScript.Evaluator
.LoadMethodAsync<ICalc>(
@"public int Sum(int a, int b)
{
return a + b;
}
public int Div(int a, int b)
{
return a/b;
}");
textBox1.Text = script.Div(15, 3).ToString();
}
async void button1_Click(object sender, EventArgs e)
{
var product = await CSScript.Evaluator
.LoadDelegateAsync<Func<int, int, int>>(
@"int Product(int a, int b)
{
return a * b;
}");
textBox1.Text = product(3, 2).ToString();
}
Assembly asm = CSScript.Evaluator
.CompileCode(@"using System;
public class Script
{
public int Sum(int a, int b)
{
return a+b;
}
}");
dynamic script = asm.CreateObject("*");
var result = script.Sum(7, 3);
dynamic script = CSScript.Evaluator
.CompileCode(@"int Sum(int a, int b)
{
return a+b;
}")
.CreateObject("*");
var result = script.Sum(7, 3);
var log = CSScript.Evaluator
.CreateDelegate(@"void Log(string message)
{
Console.WriteLine(message);
}");
log("Test message");
var product = CSScript.Evaluator
.CreateDelegate<int>(@"int Product(int a, int b)
{
return a * b;
}");
int result = product(3, 2);
dynamic script = CSScript.Evaluator
.LoadCode(@"using System;
public class Script
{
public int Sum(int a, int b)
{
return a+b;
}
}");
int result = script.Sum(1, 2);
public interface ICalc
{
int Sum(int a, int b);
}
....
ICalc calc = CSScript.Evaluator
.LoadCode<ICalc>(@"using System;
public class Script
{
public int Sum(int a, int b)
{
return a+b;
}
}");
int result = calc.Sum(1, 2);
var Product = CSScript.Evaluator
.LoadDelegate<Func<int, int, int>>(
@"int Product(int a, int b)
{
return a * b;
}");
int result = Product(3, 2);
dynamic script = CSScript.Evaluator
.LoadFile("calc.cs");
int result = script.Sum(1, 2);
public interface ICalc
{
int Sum(int a, int b);
}
....
ICalc calc = CSScript.Evaluator
.LoadFile<ICalc>("calc.cs");
int result = calc.Sum(1, 2);
dynamic script = CSScript.Evaluator
.LoadMethod(@"int Product(int a, int b)
{
return a * b;
}");
int result = script.Product(3, 2);
public interface ICalc
{
int Sum(int a, int b);
int Div(int a, int b);
}
....
ICalc script = CSScript.Evaluator
.LoadMethod<ICalc>(@"public int Sum(int a, int b)
{
return a + b;
}
public int Div(int a, int b)
{
return a/b;
}");
int result = script.Div(15, 3);
var eval1 = CSScript.Evaluator.Clone();
var eval2 = CSScript.Evaluator.Clone();
var sub = eval1.LoadDelegate<Func<int, int, int>>(
@"int Sub(int a, int b) {
return a - b;
}");
var sum = eval2.LoadDelegate<Func<int, int, int>>(
@"int Sub(int a, int b) {
return a + b;
}");
var result = sum(7, sub(4,2));
var count = new Ref<int>(1);
Action<Ref<int>> increment =
arg =>
{
arg.Value += 1;
};
increment(count);
using (SimpleAsmProbing.For(@"E:\Dev\Libs", @"E:\Dev\Packages"))
{
dynamic script = CSScript.Load(script_file)
.CreateObject("Script");
script.Print();
}
AppDomain.CurrentDomain
.Clone()
.Execute(Job)
.Unload();
...
void Job()
{
var script = CSScript.LoadMethod("some C# script code")
.GetStaticMethod();
script();
};
AppDomain remote = AppDomain.CurrentDomain.Clone();
remote.Execute(() =>
{
var Sum = CSScript.BuildEval(@"func(float a, float b) {
return a + b;
}");
var Average = CSScript.BuildEval(@"func(float a, float b) {
return (a + b)/2;
}");
Console.WriteLine("Sum = {0}\nAverage={1}", Sum(1f, 2f), Average(1f, 2f));
});
remote.Unload();
var remoteDomain = AppDomain.CurrentDomain.Clone();
remoteDomain.Execute(Job)
remoteDomain.Unload();
...
void Job()
{
var script = CSScript.LoadMethod("some C# script code")
.GetStaticMethod();
script();
}
var foo = new Ref<string>("foo");
AppDomain.CurrentDomain
.Clone()
.Execute(context =>
{
context.Value = "FOO";
},
context:foo)
.Unload();
Note that the example is using
AppDomain.CurrentDomain
.Clone()
.Execute(action)
.Unload();
Sandbox.With(SecurityPermissionFlag.Execution)
.Execute(() =>
{
//call sandboxed actions
});
var eval1 = CSScript.MonoEvaluator.Clone();
var eval2 = CSScript.MonoEvaluator.Clone();
var sub = eval1.LoadDelegate<Func<int, int, int>>(
@"int Sub(int a, int b) {
return a - b;
}");
var sum = eval2.LoadDelegate<Func<int, int, int>>(
@"int Sub(int a, int b) {
return a + b;
}");
var result = sum(7, sub(4,2));
MonoEvaluator.CreateCompilerSettings = () => new CompilerSettings {Unsafe = true };
dynamic script = CSScript.MonoEvaluator
.LoadCode(@"using System;
public class Script
{
public int Sum(int a, int b)
{
return a+b;
}
}");
int result = script.Sum(1, 2);
dynamic script = CSScript.MonoEvaluator
.LoadFile("calc.cs");
int result = script.Sum(1, 2);
public interface ICalc
{
int Sum(int a, int b);
}
....
ICalc calc = CSScript.MonoEvaluator
.LoadCode<ICalc>(@"using System;
public class Script
{
public int Sum(int a, int b)
{
return a+b;
}
}");
int result = calc.Sum(1, 2);
public interface ICalc
{
int Sum(int a, int b);
}
....
ICalc calc = CSScript.MonoEvaluator
.LoadFile<ICalc>("calc.cs");
int result = calc.Sum(1, 2);
dynamic script = CSScript.MonoEvaluator
.LoadMethod(@"int Product(int a, int b)
{
return a * b;
}");
int result = script.Product(3, 2);
public interface ICalc
{
int Sum(int a, int b);
int Div(int a, int b);
}
....
ICalc script = CSScript.MonoEvaluator
.LoadMethod<ICalc>(@"public int Sum(int a, int b)
{
return a + b;
}
public int Div(int a, int b)
{
return a/b;
}");
int result = script.Div(15, 3);
var log = CSScript.MonoEvaluator
.CreateDelegate(@"void Log(string message)
{
Console.WriteLine(message);
}");
log("Test message");
var product = CSScript.MonoEvaluator
.CreateDelegate<int>(@"int Product(int a, int b)
{
return a * b;
}");
int result = product(3, 2);
var Product = CSScript.MonoEvaluator
.LoadDelegate<Func<int, int, int>>(
@"int Product(int a, int b)
{
return a * b;
}");
int result = Product(3, 2);
dynamic script = CSScript.MonoEvaluator
.CompileMethod(@"int Sum(int a, int b)
{
return a+b;
}")
.CreateObject("*");
var result = script.Sum(7, 3);
Assembly asm = CSScript.MonoEvaluator
.CompileCode(@"using System;
public class Script
{
public int Sum(int a, int b)
{
return a+b;
}
}");
dynamic script = asm.CreateObject("*");
var result = script.Sum(7, 3);
string upperCaseText = (string)CSScript.MonoEvaluator.Evaluate("\"Hello\".ToUpper();");
int sum = (int)CSScript.MonoEvaluator.Evaluate("1+2;");
CSScript.MonoEvaluator.Run("using System;");
CSScript.MonoEvaluator.Run("Console.WriteLine(\"Hello World!\");");
//application
class Program
{
static void Main()
{
Assembly.GetExecutingAssembly()
.SingletonExecute(main,
()=>MessageBox.Show("Another instance is already running."));
}
static void main()
{
//business logic
}
}
//script
var script = @"using System.Reflection;
public static void DoWork()
{
Assembly.GetExecutingAssembly()
.SingletonExecute(() =>
{
//business logic;
},
() => Console.WriteLine(""another instance of 'script' is being executed""));
}";
var DoWork = CSScript.LoadMethod(script).GetStaticMethod();
Task.Run(DoWork);
Task.Run(DoWork);
Task.Run(DoWork);