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);
}
private ScriptHelper()
{
engine = new ScriptEngine();
engine.AddReference("System");
engine.AddReference("System.Core");
engine.AddReference(typeof(MailMessage).Assembly);
engine.AddReference(typeof(ScriptContext).Assembly);
}
public ScriptExecutor()
{
_engine = new ScriptEngine();
_engine.AddReference("System");
_engine.AddReference(this.GetType().Assembly.Location);
_engine.AddReference(Environment.CurrentDirectory + "\\WebDriver.dll");
_engine.AddReference(Environment.CurrentDirectory + "\\WebDriver.Support.dll");
_engine.ImportNamespace("System");
_engine.ImportNamespace("OpenQA.Selenium");
_engine.ImportNamespace("WebScriptRunner");
_engine.ImportNamespace("WebScriptRunner.Core");
}
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 ChartScriptEngine()
{
engine = new ScriptEngine();
new[]
{
typeof(System.ComponentModel.Component).Assembly,
typeof(int).Assembly,
typeof(HttpContext).Assembly,
typeof(Color).Assembly,
typeof(Chart).Assembly,
typeof(IEnumerable <>).Assembly,
typeof(IQueryable).Assembly
}.ToList().ForEach(asm => engine.AddReference(asm));
new[]
{
"System",
"System.Web",
"System.Drawing",
"System.Linq",
"System.Collections",
"System.Collections.Generic",
"System.Web.UI.DataVisualization.Charting"
}.ToList().ForEach(ns => engine.ImportNamespace(ns));
}
public RoslynScriptEngine(IScriptHostFactory scriptHostFactory, ILog logger)
{
_scriptEngine = new ScriptEngine();
_scriptEngine.AddReference(typeof(ScriptExecutor).Assembly);
_scriptHostFactory = scriptHostFactory;
_logger = logger;
}
static RoslynExecutor()
{
ScriptEngine = new ScriptEngine();
// Anything in here, anyone (ie, jac) can run code from
Assemblies = new[]
{
typeof(Type).Assembly,
typeof(ICollection).Assembly,
typeof(IEnumerable <>).Assembly,
typeof(IQueryable).Assembly,
typeof(IRCExtensions).Assembly,
};
Namespaces = new string[]
{
"System",
"System.Collections",
"System.Collections.Generic",
"System.Linq",
"ChickenSalad.IRC.Common",
};
foreach (var assembly in Assemblies)
{
ScriptEngine.AddReference(assembly);
}
}
public static Session CreateSession()
{
// TODO IMM HI: we have to create script engine every time because otherwise we get "Duplicate type name within an assembly" exception when using anonymous types in string-expressions; see if we can do something about this
var scriptEngine = new ScriptEngine();
scriptEngine.AddReference("System.Core");
var stackTrace = new StackTrace();
StackFrame[] stackFrames = stackTrace.GetFrames() ?? new StackFrame[0];
var processedAssemblies = new HashSet <string>();
foreach (StackFrame stackFrame in stackFrames)
{
string assemblyName = stackFrame.GetMethod().ReflectedType.Assembly.FullName;
if (processedAssemblies.Contains(assemblyName))
{
continue;
}
// ReSharper disable EmptyGeneralCatchClause
try
{
scriptEngine.AddReference(Assembly.Load(assemblyName));
}
catch
{
// do nothing
}
finally
{
processedAssemblies.Add(assemblyName);
}
// ReSharper restore EmptyGeneralCatchClause
}
Session session = scriptEngine.CreateSession();
session.ImportNamespace("System");
session.ImportNamespace("System.Collections.Generic");
session.ImportNamespace("System.Linq");
return(session);
}
private static ScriptEngine ConfigureScriptEngine(ScriptInfo scriptInfo, Assembly modelAssembly)
{
var scriptEngine = new ScriptEngine();
scriptEngine.AddReference(modelAssembly);
scriptInfo.Assemblies.ToList().ForEach(scriptEngine.AddReference);
scriptInfo.Namespaces.ToList().ForEach(scriptEngine.ImportNamespace);
return(scriptEngine);
}
private static Type GetType(string type)
{
var engine = new ScriptEngine();
new[] { "System" }
.ToList().ForEach(r => engine.AddReference(r));
new[] { "System", "System.Collections.Generic" }
.ToList().ForEach(ns => engine.ImportNamespace(ns));
return(engine
.CreateSession()
.Execute <Type>("typeof(" + type + ")"));
}
/// <summary> Default constructor. </summary>
public CSharpProvider()
{
_engine = new ScriptEngine();
_engine.AddReference("System");
_engine.AddReference("System.Core");
_engine.AddReference("System.Data");
_engine.AddReference("System.Xml");
_engine.AddReference("System.Xml.Linq");
_engine.AddReference(typeof(CSharpProvider).Assembly.Location);
_engine.AddReference(typeof(NullObject).Assembly.Location);
}
private static Session CreateSession(Debugger currentDebugger, bool getOldSession)
{
//CSScript = script;
//var s = new CommonScriptEngine();
if (getOldSession && Session != null)
{
return(Session);
}
var asm = System.Reflection.Assembly.GetExecutingAssembly();
var csharpEngine = new ScriptEngine(null, null);
//csharpEngine.AddReference("System.Diagnostics");
csharpEngine.ImportNamespace("System");
csharpEngine.ImportNamespace("System.Collections.Generic");
//csharpEngine.ImportNamespace("System.Linq");
csharpEngine.ImportNamespace("System.Text");
csharpEngine.ImportNamespace("System.IO");
//csharpEngine.ImportNamespace("System.Diagnostics");
csharpEngine.SetReferenceSearchPaths(asm.Location);
csharpEngine.AddReference(typeof(System.Diagnostics.Debug).Assembly);
csharpEngine.AddReference(typeof(System.Dynamic.DynamicObject).Assembly);
csharpEngine.AddReference(asm);
csharpEngine.ImportNamespace("ExtCS.Debugger");
Session = csharpEngine.CreateSession(currentDebugger);
return(Session);
}
public object Evaluate(IEnumerable <string> variableDeclarations, string formula)
{
var engine = new ScriptEngine();
engine.AddReference("System");
var usings = "using System;";
var init = string.Join("", variableDeclarations);
var code = usings + Environment.NewLine + init + Environment.NewLine + formula;
var session = engine.CreateSession();
return(session.Execute(code));
}
private ScriptEngine InitEngine()
{
var engine = new ScriptEngine();
engine.AddReference("System");
var currentDirectory = Environment.CurrentDirectory;
var bin = Path.Combine(currentDirectory, "bin");
engine.BaseDirectory = bin;
if (!Directory.Exists(bin))
{
Directory.CreateDirectory(bin);
}
return(engine);
}
public static ScriptEngine GetScriptEngine()
{
var scriptEngine = new ScriptEngine();
foreach (var typeInAssembly in _assemblyTypes)
{
scriptEngine.AddReference(typeInAssembly.Assembly);
}
var namespaces = _assemblyTypes.Select(t => t.Namespace).Distinct();
foreach (var ns in namespaces)
{
scriptEngine.ImportNamespace(ns);
}
return(scriptEngine);
}
private static Type GetType(string type)
{
CommonScriptEngine engine = new ScriptEngine();
string[] defaultReferences = new string[] { "System" };
string[] defaultNamespaces = new string[] { "System", "System.Collections.Generic" };
foreach (var reference in defaultReferences)
{
engine.AddReference(reference);
}
foreach (var nameSpace in defaultNamespaces)
{
engine.ImportNamespace(nameSpace);
}
var session = engine.CreateSession();
var result = session.Execute("Type foo(){return typeof(" + type + ");}foo();");
return(result as Type);
}
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>
/// Load all useful references
/// </summary>
public void ScriptEngineLoadAssemblies(ScriptEngine engine, string localAssembly)
{
//GAC Assemblies
var systemCoreReference = MetadataReference.CreateAssemblyReference("System.Core");
var systemReference = MetadataReference.CreateAssemblyReference("System");
var systemComponentModel = MetadataReference.CreateAssemblyReference("System.ComponentModel");
var systemComponentModelComposition =
MetadataReference.CreateAssemblyReference("System.ComponentModel.Composition");
var systemIO = MetadataReference.CreateAssemblyReference("System.IO");
var systemLinq = MetadataReference.CreateAssemblyReference("System.Linq");
var systemReflection = MetadataReference.CreateAssemblyReference("System.Runtime.Serialization");
var systemServiceModel = MetadataReference.CreateAssemblyReference("System.ServiceModel");
var systemWindows = MetadataReference.CreateAssemblyReference("System.Windows");
//Custom Assemblies
Assembly wpfAssembly = Assembly.GetAssembly(typeof(AdminConsoleViewModel));
Assembly caliburnMicro = Assembly.GetAssembly(typeof(Conductor <IScreen> .Collection.OneActive));
engine.AddReference(systemCoreReference);
engine.AddReference(systemReference);
engine.AddReference(systemComponentModel);
engine.AddReference(systemComponentModelComposition);
engine.AddReference(systemIO);
engine.AddReference(systemLinq);
engine.AddReference(systemReflection);
engine.AddReference(systemServiceModel);
engine.AddReference(systemWindows);
engine.AddReference(wpfAssembly.Location);
engine.AddReference(caliburnMicro.Location);
engine.AddReference(localAssembly);
}
private void loadScriptEngine()
{
engine = new ScriptEngine();
engine.AddReference(typeof(System.Linq.Enumerable).Assembly.Location);
engine.AddReference(typeof(Url).Assembly.Location);
engine.AddReference(typeof(JObject).Assembly.Location);
engine.AddReference(typeof(XElement).Assembly.Location);
engine.AddReference(typeof(UIElement).Assembly.Location);
engine.AddReference(typeof(DependencyObject).Assembly.Location);
engine.AddReference(typeof(FrameworkElement).Assembly.Location);
engine.AddReference(typeof(MethodInfo).Assembly.Location);
engine.AddReference(typeof(System.Drawing.Color).Assembly.Location);
engine.AddReference(typeof(ILScene).Assembly.Location);
//engine.AddReference(typeof(FunctionLibrary).Assembly.Location);
///Untested
//engine.AddReference(typeof(Uri).Assembly.Location);
//engine.AddReference(typeof(XmlAttribute).Assembly.Location);
engine.AddReference(new MetadataFileReference(@"C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.5\System.dll"));
engine.AddReference(new MetadataFileReference(@"C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.5\System.Xml.dll"));
engine.AddReference(new MetadataFileReference(@"C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.5\System.Xaml.dll"));
engine.ImportNamespace("System");
engine.ImportNamespace("System.Reflection");
engine.ImportNamespace("System.Windows");
engine.ImportNamespace("System.Collections.Generic");
engine.ImportNamespace("System.Linq");
engine.ImportNamespace("System.Text");
engine.ImportNamespace("System.Diagnostics");
engine.ImportNamespace("Newtonsoft.Json.Linq");
engine.ImportNamespace("System.Xml.Linq");
engine.ImportNamespace("Workbench.Lib");
/*
* using ILNumerics;
* using ILNumerics.Drawing;
* using ILNumerics.Drawing.Plotting;
*/
engine.ImportNamespace("ILNumerics");
engine.ImportNamespace("ILNumerics.Drawing");
engine.ImportNamespace("ILNumerics.Drawing.Plotting");
session = engine.CreateSession(this);
}
public ScriptResult Execute(string code, string[] scriptArgs, AssemblyReferences references, IEnumerable <string> namespaces, ScriptPackSession scriptPackSession)
{
Guard.AgainstNullArgument("scriptPackSession", scriptPackSession);
Guard.AgainstNullArgument("references", references);
Logger.Debug("Starting to create execution components");
Logger.Debug("Creating script host");
var executionReferences = new AssemblyReferences(references.PathReferences, references.Assemblies);
executionReferences.PathReferences.UnionWith(scriptPackSession.References);
SessionState <Session> sessionState;
if (!scriptPackSession.State.ContainsKey(SessionKey))
{
var host = _scriptHostFactory.CreateScriptHost(new ScriptPackManager(scriptPackSession.Contexts), scriptArgs);
Logger.Debug("Creating session");
var hostType = host.GetType();
ScriptEngine.AddReference(hostType.Assembly);
var session = ScriptEngine.CreateSession(host, hostType);
var allNamespaces = namespaces.Union(scriptPackSession.Namespaces).Distinct();
foreach (var reference in executionReferences.PathReferences)
{
Logger.DebugFormat("Adding reference to {0}", reference);
session.AddReference(reference);
}
foreach (var assembly in executionReferences.Assemblies)
{
Logger.DebugFormat("Adding reference to {0}", assembly.FullName);
session.AddReference(assembly);
}
foreach (var @namespace in allNamespaces)
{
Logger.DebugFormat("Importing namespace {0}", @namespace);
session.ImportNamespace(@namespace);
}
sessionState = new SessionState <Session> {
References = executionReferences, Session = session, Namespaces = new HashSet <string>(allNamespaces)
};
scriptPackSession.State[SessionKey] = sessionState;
}
else
{
Logger.Debug("Reusing existing session");
sessionState = (SessionState <Session>)scriptPackSession.State[SessionKey];
if (sessionState.References == null)
{
sessionState.References = new AssemblyReferences();
}
if (sessionState.Namespaces == null)
{
sessionState.Namespaces = new HashSet <string>();
}
var newReferences = executionReferences.Except(sessionState.References);
foreach (var reference in newReferences.PathReferences)
{
Logger.DebugFormat("Adding reference to {0}", reference);
sessionState.Session.AddReference(reference);
sessionState.References.PathReferences.Add(reference);
}
foreach (var assembly in newReferences.Assemblies)
{
Logger.DebugFormat("Adding reference to {0}", assembly.FullName);
sessionState.Session.AddReference(assembly);
sessionState.References.Assemblies.Add(assembly);
}
var newNamespaces = namespaces.Except(sessionState.Namespaces);
foreach (var @namespace in newNamespaces)
{
Logger.DebugFormat("Importing namespace {0}", @namespace);
sessionState.Session.ImportNamespace(@namespace);
sessionState.Namespaces.Add(@namespace);
}
}
Logger.Debug("Starting execution");
var result = Execute(code, sessionState.Session);
Logger.Debug("Finished execution");
return(result);
}
public void AddReference(Assembly assembly)
{
_engine.AddReference(assembly);
}
public ScriptResult Execute(string code, string[] scriptArgs, AssemblyReferences references, IEnumerable <string> namespaces, ScriptPackSession scriptPackSession)
{
Guard.AgainstNullArgument("scriptPackSession", scriptPackSession);
Guard.AgainstNullArgument("references", references);
Logger.Debug("Starting to create execution components");
Logger.Debug("Creating script host");
var executionReferences = new AssemblyReferences(references.PathReferences, references.Assemblies);
executionReferences.PathReferences.UnionWith(scriptPackSession.References);
SessionState <Session> sessionState;
var isFirstExecution = !scriptPackSession.State.ContainsKey(SessionKey);
if (isFirstExecution)
{
code = code.DefineTrace();
var host = _scriptHostFactory.CreateScriptHost(new ScriptPackManager(scriptPackSession.Contexts), scriptArgs);
Logger.Debug("Creating session");
var hostType = host.GetType();
ScriptEngine.AddReference(hostType.Assembly);
var session = ScriptEngine.CreateSession(host, hostType);
var allNamespaces = namespaces.Union(scriptPackSession.Namespaces).Distinct();
foreach (var reference in executionReferences.PathReferences)
{
Logger.DebugFormat("Adding reference to {0}", reference);
session.AddReference(reference);
}
foreach (var assembly in executionReferences.Assemblies)
{
Logger.DebugFormat("Adding reference to {0}", assembly.FullName);
session.AddReference(assembly);
}
foreach (var @namespace in allNamespaces)
{
Logger.DebugFormat("Importing namespace {0}", @namespace);
session.ImportNamespace(@namespace);
}
sessionState = new SessionState <Session> {
References = executionReferences, Session = session, Namespaces = new HashSet <string>(allNamespaces)
};
scriptPackSession.State[SessionKey] = sessionState;
}
else
{
Logger.Debug("Reusing existing session");
sessionState = (SessionState <Session>)scriptPackSession.State[SessionKey];
if (sessionState.References == null)
{
sessionState.References = new AssemblyReferences();
}
if (sessionState.Namespaces == null)
{
sessionState.Namespaces = new HashSet <string>();
}
var newReferences = executionReferences.Except(sessionState.References);
foreach (var reference in newReferences.PathReferences)
{
Logger.DebugFormat("Adding reference to {0}", reference);
sessionState.Session.AddReference(reference);
sessionState.References.PathReferences.Add(reference);
}
foreach (var assembly in newReferences.Assemblies)
{
Logger.DebugFormat("Adding reference to {0}", assembly.FullName);
sessionState.Session.AddReference(assembly);
sessionState.References.Assemblies.Add(assembly);
}
var newNamespaces = namespaces.Except(sessionState.Namespaces);
foreach (var @namespace in newNamespaces)
{
Logger.DebugFormat("Importing namespace {0}", @namespace);
sessionState.Session.ImportNamespace(@namespace);
sessionState.Namespaces.Add(@namespace);
}
}
Logger.Debug("Starting execution");
var result = Execute(code, sessionState.Session);
if (result.InvalidNamespaces.Any())
{
var pendingNamespacesField = sessionState.Session.GetType().GetField("pendingNamespaces", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic);
if (pendingNamespacesField != null)
{
var pendingNamespacesValue = (ReadOnlyArray <string>)pendingNamespacesField.GetValue(sessionState.Session);
//no need to check this for null as ReadOnlyArray is a value type
if (pendingNamespacesValue.Any())
{
var fixedNamespaces = pendingNamespacesValue.ToList();
foreach (var @namespace in result.InvalidNamespaces)
{
sessionState.Namespaces.Remove(@namespace);
fixedNamespaces.Remove(@namespace);
}
pendingNamespacesField.SetValue(sessionState.Session, ReadOnlyArray <string> .CreateFrom <string>(fixedNamespaces));
}
}
}
Logger.Debug("Finished execution");
return(result);
}
