public MainWindow()
{
_scriptEngine = new ScriptEngine();
_session = _scriptEngine.CreateSession();
_scriptEngine.CreateSession();
_defaultNamespaces = new[] {"System"};
foreach (string defaultNamespace in _defaultNamespaces)
//_session.ImportNamespace(defaultNamespace);
InitializeComponent();
Loaded += MainWindowsLoaded;
}
/// <summary>
/// This Method is a javascript callable method.
/// </summary>
/// <param name="e">A parameter from javascript.</param>
/// <param name="y">A callback to javascript.</param>
public void WebMethod2(string e, Action<string> y)
{
// http://blog.filipekberg.se/tag/roslyn/
var engine = new ScriptEngine();
var session = engine.CreateSession();
//error: Attempt by method 'Roslyn.Compilers.ReadOnlyArray`1_ReadOnlyList_<GetEnumerator>d__d<T>.MoveNext()' to
// access field 'Roslyn.Compilers.ReadOnlyArray`1+ReadOnlyList<System.__Canon>.array' failed.
// replace NestedPrivate!
try
{
Console.WriteLine(e);
var result = session.Execute(e);
// Send it back to the caller.
y("output: " + result);
}
catch (Exception ex)
{
y("error: " + ex.Message);
}
}
public void SimpleEvaluationUsingScriptEngine()
{
ScriptEngine engine = new ScriptEngine();
Session session = engine.CreateSession();
int result = session.Execute<int>("1 + 2");
Assert.AreEqual(3, result);
}
public ScriptingHost(dynamic context)
{
// Create the script engine
_engine = new ScriptEngine();
// Let us use engine’s Addreference for
// adding some common assemblies
new[]
{
typeof (Type).Assembly,
typeof (ICollection).Assembly,
typeof (ListDictionary).Assembly,
typeof (Console).Assembly,
typeof (ScriptingHost).Assembly,
typeof (IEnumerable<>).Assembly,
typeof (IQueryable).Assembly,
typeof (DataSet).Assembly,
GetType().Assembly
}.ToList().ForEach(asm => _engine.
AddReference(asm));
//Import common namespaces
new[]
{
"System", "System.Linq",
"System.Collections",
"System.Collections.Generic"
}.ToList().ForEach(ns => _engine.
ImportNamespace(ns));
_session = _engine.CreateSession(context);
}
public void Execute(string script, IEnumerable<string> paths, IEnumerable<IScriptcsRecipe> recipes)
{
var engine = new ScriptEngine();
engine.AddReference("System");
engine.AddReference("System.Core");
var bin = _fileSystem.CurrentDirectory + @"\bin";
engine.BaseDirectory = bin;
if (!_fileSystem.DirectoryExists(bin))
_fileSystem.CreateDirectory(bin);
foreach (var file in paths)
{
var destFile = bin + @"\" + Path.GetFileName(file);
var sourceFileLastWriteTime = _fileSystem.GetLastWriteTime(file);
var destFileLastWriteTime = _fileSystem.GetLastWriteTime(destFile);
if (sourceFileLastWriteTime != destFileLastWriteTime)
_fileSystem.Copy(file, destFile,true);
engine.AddReference(destFile);
}
var session = engine.CreateSession();
var csx = _fileSystem.ReadFile(_fileSystem.CurrentDirectory + @"\" + script);
session.Execute(csx);
}
public HttpResponseMessage Post([FromBody] Code code)
{
var scriptEngine = new ScriptEngine();
Session session = scriptEngine.CreateSession();
session.AddReference("System");
session.AddReference("System.Core");
if (code.Buffer != null)
{
code.Buffer = code.Buffer.Where(x => x.EndsWith(";")).ToList();
code.Buffer.Add(code.CurrentCode);
}
else
code.Buffer = new List<string> { code.CurrentCode };
var toExecute = string.Join(" ", code.Buffer);
try
{
var result = session.Execute(toExecute);
return Request.CreateResponse(HttpStatusCode.OK,
result == null
? new Code { Success = true, Message = string.Empty, Buffer = code.Buffer }
: new Code { Success = true, Message = result.ToString(), Buffer = code.Buffer });
}
catch (CompilationErrorException errorException)
{
return Request.CreateResponse(HttpStatusCode.OK, new Code { Success = false, Message = errorException.Message, Buffer = code.Buffer });
}
}
public void Run()
{
var hostObject = new HostObject();
Console.WriteLine("Value is {0}", hostObject.Value);
Console.WriteLine("Enter code. Type exit to quit");
var engine = new ScriptEngine();
var session = engine.CreateSession( hostObject, hostObject.GetType());
session.AddReference(hostObject.GetType().Assembly);
string code = string.Empty;
while (true)
{
code = Console.ReadLine();
if (code == "exit")
{
break;
}
try
{
session.Execute(code);
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
Console.WriteLine("Value is {0}", hostObject.Value);
Console.ReadLine();
}
static void Main(string[] args)
{
if (args.Length != 1)
{
Console.WriteLine("Usage: node.cs <filepath>");
return;
}
try
{
using (StreamReader sr = new StreamReader(args[0]))
{
string code = sr.ReadToEnd();
var engine = new ScriptEngine();
engine.AddReference("System");
var session = engine.CreateSession();
session.Execute("using System;");
session.Execute(code);
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
static void Main(string[] args)
{
var se = new ScriptEngine();
var session = se.CreateSession();
var result = session.Execute("20 + 30");
Console.WriteLine(result);
Console.ReadKey(true);
}
public MainWindow()
{
InitializeComponent();
var scriptEngine = new ScriptEngine();
_session = scriptEngine.CreateSession();
_session.AddReference("System");
_session.AddReference("System.Core");
Loaded += MainWindowsLoaded;
}
public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
{
var engine = new ScriptEngine();
var session = engine.CreateSession();
// Note that we use session.Execute<T> to get a delegate
Func<string, object> f = session.Execute<Func<string, object>>(parameter.ToString());
return f(value.ToString());
}
public void UsingSessionsForMultipleEvaluations()
{
ScriptEngine engine = new ScriptEngine();
Session session = engine.CreateSession();
session.Execute("int i = 21;");
int answer = session.Execute<int>("i * 2");
Assert.AreEqual(42, answer);
}
public ScriptHost(Profile profile, CategoryController category_controller, MainWindowViewModel vm)
{
script_engine = new ScriptEngine();
script_session = script_engine.CreateSession(this);
script_session.AddReference("System");
script_session.AddReference(GetType().Assembly.Location);
Profile = profile;
ViewModel = vm;
CategoryController = category_controller;
}
public static bool Brainfuck(this string src, out string code, out string result)
{
var sb = new StringBuilder();
sb.AppendLine(@"var ptr = 0;");
sb.AppendLine(@"var buffer = new char[30000];");
sb.AppendLine(@"var sb = new StringBuilder();");
foreach (var c in src) {
switch (c) {
case '>':
sb.AppendLine(@"++ptr;");
break;
case '<':
sb.AppendLine(@"--ptr;");
break;
case '+':
sb.AppendLine(@"buffer[ptr] = (char)(buffer[ptr] + 1);");
break;
case '-':
sb.AppendLine(@"buffer[ptr] = (char)(buffer[ptr] - 1);");
break;
case '.':
sb.AppendLine(@"sb.Append(buffer[ptr]);");
break;
case ',':
//not supported
//sb.AppendLine(@"buffer[ptr] = (char)Console.Read();");
break;
case '[':
sb.AppendLine(@"while(buffer[ptr] != 0) {");
break;
case ']':
sb.AppendLine(@"}");
break;
default:
break;
}
}
sb.AppendLine(@"sb.ToString();");
code = sb.ToString();
//run
var engine = new ScriptEngine();
engine.ImportNamespace("System");
engine.ImportNamespace("System.Text");
var session = engine.CreateSession();
try {
result = session.Execute<string>(code);
} catch(Exception ex) {
result = ex.ToString();
return false;
}
return true;
}
protected DapperTemplateViaRoslyn(string name, string sql )
{
//var lexer = new TypeSqlLexer(new ANTLRStringStream(sql));
// //var lexer2 = new TypeSqlLexer(new ANTLRStringStream(sql));
// //var commonTokenStream = new CommonTokenStream(lexer2);
// var rewriteTokenStream = new TokenRewriteStream(lexer);
//var parser = new TypeSqlParser(rewriteTokenStream);
//var parseResult = parser.sql();
//var ast = (CommonTree) parseResult.Tree;
// var nodeStream = new CommonTreeNodeStream(ast);
// var rawSqlOutput = new RawSqlTransform(nodeStream);
// nodeStream.TokenStream = rewriteTokenStream;
// rawSqlOutput.sql();
// string rawSql = rewriteTokenStream.ToString();
// //parser = new TypeSqlParser(commonTokenStream);
// //parseResult = parser.sql();
// //ast = (CommonTree)parseResult.Tree;
// //nodeStream = new CommonTreeNodeStream(ast) {TokenStream = rewriteTokenStream};
// lexer.Reset();
// rewriteTokenStream.Reset();
// parser.Reset();
// nodeStream.Reset();
// var daoTransform = new DaoTransform(nodeStream){TemplateGroup = new StringTemplateGroup(
// new StreamReader(new FileStream(@"..\..\..\TypeSql\Parsing\DapperDao.stg", FileMode.Open)),
// typeof (TemplateLexer))};
// var template = daoTransform.sql(name, rawSql).Template;
// string src = template.ToString();
//var parseResult = Parser.Parse(sql);
//var template = new DapperDaoTemplate(name, parseResult);
//var transformedTemplate = template.TransformText();
var compileResult = TypeSqlCompiler.Compile(sql, name);
var engine = new ScriptEngine();
Session = engine.CreateSession();
Session.AddReference("System");
Session.AddReference("System.Core");
Session.AddReference(typeof(DapperDao<>).Assembly);
Session.AddReference(typeof(IDbConnection).Assembly);
Session.AddReference(this.GetType().Assembly);
Session.AddReference("System.Configuration");
Session.Execute("using System.Linq;");
Session.Execute("using System.Data.SqlClient;");
Session.Execute("using System.Data.Common;");
Session.Execute("using System.Configuration;");
Session.Execute(compileResult.Dao);
}
public ScriptEngineInstance()
{
var engine = new ScriptEngine();
References = new List<string>();
foreach (var metadataReference in engine.GetReferences())
{
References.Add(metadataReference.Display);
}
Session = engine.CreateSession();
}
public SecureRoslynWrapper()
{
new PermissionSet(PermissionState.Unrestricted).Assert();
Engine = new ScriptEngine();
foreach (var assembly in references)
Engine.AddReference(assembly);
foreach (var name in namespaces)
Engine.ImportNamespace(name);
Session = Engine.CreateSession();
CodeAccessPermission.RevertAssert();
}
public RoslynBasedCompilerTest(string name, string sql)
{
var compileResult = TypeSqlCompiler.Compile(sql, name);
var engine = new ScriptEngine();
Session = engine.CreateSession();
Session.AddReference("System.Core");
Session.AddReference(typeof(DapperDao<>).Assembly);
Session.AddReference(typeof(IDbConnection).Assembly);
Session.Execute("using System.Linq;");
Session.Execute(compileResult.Dao);
}
static void Main(string[] args)
{
string arg = args.Length > 0 ? string.Join(" ", args) : String.Empty;
var engine = new ScriptEngine();
var session = engine.CreateSession();
session.ImportNamespace("System");
double lastResult = 0;
Regex powReplacer = new Regex(@"(\d*\.\d+|\d+)\s*\^\s*(\d*\.\d+|\d+)"); // ex: 4^5 is replaced with Math.Pow(4, 5)
Regex doubleInsertion = new Regex(@"(?<NUMBER>\d*\.\d+|\d+)"); // for convenience, force all numerical values to evaluate as doubles
string scriptline;
while (true)
{
try
{
if (string.IsNullOrWhiteSpace(arg))
{
Console.Write("> ");
arg = Console.ReadLine().Trim(); // wait for input from user
}
if (!string.IsNullOrWhiteSpace(arg))
{
if (arg.Equals("quit", StringComparison.OrdinalIgnoreCase)) break;
else if (arg.Equals("cls", StringComparison.OrdinalIgnoreCase)) Console.Clear();
else
{
scriptline = (arg.StartsWith("*", StringComparison.OrdinalIgnoreCase) || arg.StartsWith("/", StringComparison.OrdinalIgnoreCase) ||
arg.StartsWith("-", StringComparison.OrdinalIgnoreCase) || arg.StartsWith("+", StringComparison.OrdinalIgnoreCase) || arg.StartsWith("^", StringComparison.OrdinalIgnoreCase))
? string.Concat(lastResult, arg) : arg;
scriptline = powReplacer.Replace(scriptline, new MatchEvaluator(delegate(Match m) { return "Math.Pow(" + m.Groups[1] + ", " + m.Groups[2] + ")"; }));
scriptline = doubleInsertion.Replace(scriptline, "${NUMBER}d"); //string.Format(@"System.Console.WriteLine({0});", arg);
lastResult = Convert.ToDouble(session.Execute(scriptline));
Console.WriteLine(lastResult);
}
}
}
catch (Exception)
{
Console.WriteLine(Environment.NewLine + "Could not evaluate expression");
}
arg = string.Empty;
}
}
public Func<string, IList<string>, Action<IAppBuilder>> Create(Func<string, IList<string>, Action<IAppBuilder>> nextLoader)
{
return (name, errors) =>
{
string extension = Path.GetExtension(name);
if (string.Equals(".csx", extension, StringComparison.OrdinalIgnoreCase) && File.Exists(name))
{
return app =>
{
var engine = new ScriptEngine();
Session session = engine.CreateSession(new HostObject(app));
session.AddReference(typeof(IAppBuilder).Assembly);
session.AddReference(typeof(HostObject).Assembly);
session.ExecuteFile(name);
};
}
return nextLoader(name, errors);
};
}
static void Main(string[] args)
{
var scriptEngine = new ScriptEngine();
scriptEngine.AddReference("System");
WritePromptLine();
var code = new Code();
var session = scriptEngine.CreateSession();
session.Execute("");
while (!code.IsExit)
{
try
{
AddCodeLine(code);
if (code.IsExit) break;
var result = session.Execute(code.Text);
Console.WriteLine(result);
code.ClearNonLocalDeclarationLines();
}
catch (CompilationErrorException compilationErrorException)
{
Console.WriteLine(compilationErrorException.Message);
code.Clear();
}
finally
{
WritePromptLine();
}
}
Console.WriteLine("bye");
}
static void Main(string[] args)
{
{
var engine = new ScriptEngine();
var session = engine.CreateSession();
session.Execute(@"var a = 42;");
session.Execute(@"System.Console.WriteLine(a);");
}
{
// Interacting with host application
var hostObject = new HostObject();
var engine = new ScriptEngine();
//Let us use engine's Addreference for adding the required assemblies
new[]
{
typeof (Console).Assembly,
typeof (HostObject).Assembly,
typeof (IEnumerable<>).Assembly,
typeof (IQueryable).Assembly
}.ToList().ForEach(asm => engine.AddReference(asm));
new[]
{
"System", "System.Linq",
"System.Collections",
"System.Collections.Generic"
}.ToList().ForEach(ns => engine.ImportNamespace(ns));
var session = engine.CreateSession(hostObject);
session.Execute(@"Value = 156;");
session.Execute(@"System.Console.WriteLine(Value);");
}
}
/// <summary>
/// This Method is a javascript callable method.
/// </summary>
/// <param name="e">A parameter from javascript.</param>
/// <param name="y">A callback to javascript.</param>
public void WebMethod2(string e, Action<string> y)
{
// http://blog.filipekberg.se/tag/roslyn/
var engine = new ScriptEngine();
var session = engine.CreateSession();
try
{
Console.WriteLine(e);
var result = session.Execute(e);
// Send it back to the caller.
y("output: " + result);
}
catch (Exception ex)
{
y("error: " + ex.Message);
}
}
public void Run()
{
Console.WriteLine("Enter code. Type exit to quit");
var engine = new ScriptEngine();
var session = engine.CreateSession();
string code = string.Empty;
while (true)
{
code = Console.ReadLine();
if (code == "exit")
{
break;
}
try
{
session.Execute(code);
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
}
public BuildResults Run(string buildScript, int logLevel, bool fullRebuild)
{
var context = new BuildContext();
AppDomain.CurrentDomain.AssemblyResolve += (o, e) => Resolver(context, e);
var log = new BuildLog();
// if we weren't given a build script, try to find one in the current directory
string scriptPath = buildScript;
if (string.IsNullOrEmpty(scriptPath) || !File.Exists(scriptPath))
{
var file = Path.GetDirectoryName(Directory.GetCurrentDirectory());
if (File.Exists(file + ".csx"))
scriptPath = file + ".csx";
else if (File.Exists(file + ".cs"))
scriptPath = file + ".cs";
else if (File.Exists("build.csx"))
scriptPath = "build.csx";
else if (File.Exists("build.cs"))
scriptPath = "build.cs";
else
{
log.Error("Could not find or open build script.");
return null;
}
}
scriptPath = Path.GetFullPath(scriptPath);
Directory.SetCurrentDirectory(Path.GetDirectoryName(scriptPath));
// create the script engine
string historyPath = Path.Combine(DataDirectory, Murmur.Hash(scriptPath, 144) + "_history.dat");
context.Initialize(historyPath, fullRebuild, log);
var scriptEngine = new ScriptEngine();
var session = scriptEngine.CreateSession(context);
// load plugins and assemblies
session.AddReference(typeof(BuildContext).Assembly);
session.AddReference(typeof(Enumerable).Assembly);
session.AddReference(typeof(HashSet<>).Assembly);
session.AddReference(typeof(ISet<>).Assembly);
var code = File.ReadAllText(scriptPath);
var buildResults = new BuildResults();
// import default namespaces
session.ImportNamespace(typeof(BuildContext).Namespace);
foreach (var n in Namespaces)
session.ImportNamespace(n);
try
{
// run the script
var startTime = DateTime.Now;
log.Write("Running build script ({0})", scriptPath);
log.Write("Build started at {0}", startTime);
log.Write("-----------------------------------------------");
log.Write("");
session.ExecuteFile(scriptPath);
context.WaitAll();
context.Finished();
log.Write("");
log.Write("-----------------------------------------------");
log.Write("Build finished ({0:N2} seconds)", (DateTime.Now - startTime).TotalSeconds);
log.Write(
context.Stats.Failed > 0 ? ConsoleColor.Red : (ConsoleColor?)null,
"{0} succeeded, {1} failed, {2} up-to-date",
context.Stats.Succeeded,
context.Stats.Failed,
context.Stats.Skipped
);
}
catch (CompilationErrorException e)
{
foreach (var error in e.Diagnostics)
{
var position = error.Location.GetLineSpan(true);
log.Error("({0}) {1}", position.StartLinePosition, error.Info.GetMessage());
}
return null;
}
buildResults.ShouldRunAgain = context.ShouldRunAgain;
buildResults.ProbedPaths = context.ProbedPaths.Select(p => Path.GetFullPath(p)).ToList();
buildResults.LoadedPlugins = context.Env.ReferencePaths.Select(t => Path.GetFullPath(t.Item1)).ToList();
return buildResults;
}
public void ShouldAddNewReferencesIfTheyAreProvided()
{
var scriptHostFactory = new Mock<IScriptHostFactory>();
scriptHostFactory.Setup(f => f.CreateScriptHost(It.IsAny<IScriptPackManager>(), It.IsAny<string[]>())).Returns((IScriptPackManager p, string[] q) => new ScriptHost(p, q));
var code = "var a = 0;";
var engine = CreateTestScriptEngine(scriptHostFactory: scriptHostFactory);
var scriptPackSession = new ScriptPackSession(new List<IScriptPack>());
var roslynEngine = new ScriptEngine();
var session = new SessionState<Session> { Session = roslynEngine.CreateSession()};
scriptPackSession.State[RoslynScriptEngine.SessionKey] = session;
engine.Execute(code, new string[0], new[] {"System"}, Enumerable.Empty<string>(), scriptPackSession);
((SessionState<Session>)scriptPackSession.State[RoslynScriptEngine.SessionKey]).References.Count().ShouldEqual(1);
}
public void ShouldReuseExistingSessionIfProvided()
{
var scriptHostFactory = new Mock<IScriptHostFactory>();
scriptHostFactory.Setup(f => f.CreateScriptHost(It.IsAny<IScriptPackManager>(), It.IsAny<string[]>())).Returns((IScriptPackManager p, string[] q) => new ScriptHost(p, q));
var code = "var a = 0;";
var engine = CreateTestScriptEngine(scriptHostFactory: scriptHostFactory);
var scriptPackSession = new ScriptPackSession(new List<IScriptPack>());
var roslynEngine = new ScriptEngine();
var session = new SessionState<Session> {Session = roslynEngine.CreateSession()};
scriptPackSession.State[RoslynScriptEngine.SessionKey] = session;
engine.Execute(code, new string[0], Enumerable.Empty<string>(), Enumerable.Empty<string>(), scriptPackSession);
engine.Session.ShouldEqual(session.Session);
}
public void ShouldReturnReturnValueIfCodeExecutionReturnsValue()
{
var scriptHostFactory = new Mock<IScriptHostFactory>();
scriptHostFactory.Setup(f => f.CreateScriptHost(It.IsAny<IScriptPackManager>(), It.IsAny<string[]>())).Returns((IScriptPackManager p, string[] q) => new ScriptHost(p, q));
var code = "\"Hello\" //this should return \"Hello\"";
var engine = CreateScriptEngine(scriptHostFactory: scriptHostFactory);
var scriptPackSession = new ScriptPackSession(new List<IScriptPack>());
var roslynEngine = new ScriptEngine();
var session = new SessionState<Session> { Session = roslynEngine.CreateSession() };
scriptPackSession.State[RoslynScriptEngine.SessionKey] = session;
var result = engine.Execute(code, new string[0], new[] { "System" }, Enumerable.Empty<string>(), scriptPackSession);
result.ReturnValue.ShouldEqual("Hello");
}
public void ShouldReturnExecuteExceptionIfCodeExecutionThrowsException()
{
var scriptHostFactory = new Mock<IScriptHostFactory>();
scriptHostFactory.Setup(f => f.CreateScriptHost(It.IsAny<IScriptPackManager>(), It.IsAny<string[]>())).Returns((IScriptPackManager p, string[] q) => new ScriptHost(p, q));
var code = "throw new System.Exception(); //this should throw an Exception";
var engine = CreateScriptEngine(scriptHostFactory: scriptHostFactory);
var scriptPackSession = new ScriptPackSession(new List<IScriptPack>());
var roslynEngine = new ScriptEngine();
var session = new SessionState<Session> { Session = roslynEngine.CreateSession() };
scriptPackSession.State[RoslynScriptEngine.SessionKey] = session;
var result = engine.Execute(code, new string[0], new[] { "System" }, Enumerable.Empty<string>(), scriptPackSession);
result.ExecuteException.ShouldNotBeNull();
}
public void ShouldReturnAScriptResult()
{
var scriptHostFactory = new Mock<IScriptHostFactory>();
scriptHostFactory.Setup(f => f.CreateScriptHost(It.IsAny<IScriptPackManager>(), It.IsAny<string[]>())).Returns((IScriptPackManager p, string[] q) => new ScriptHost(p, q));
var code = "";
var engine = CreateTestScriptEngine(scriptHostFactory: scriptHostFactory);
var scriptPackSession = new ScriptPackSession(new List<IScriptPack>());
var roslynEngine = new ScriptEngine();
var session = new SessionState<Session> { Session = roslynEngine.CreateSession() };
scriptPackSession.State[RoslynScriptEngine.SessionKey] = session;
var result = engine.Execute(code, new string[0], new[] { "System" }, Enumerable.Empty<string>(), scriptPackSession);
Assert.IsType<ScriptResult>(result);
}
