static void Main(string[] args)
{
ScriptState <object> hScriptState = null;
ScriptOptions hOptions = ScriptOptions.Default;
hOptions = hOptions.AddReferences(typeof(System.Object).Assembly, typeof(System.Linq.Enumerable).Assembly);
hOptions = hOptions.AddImports("System");
hOptions = hOptions.AddImports("System.Linq");
hOptions = hOptions.AddImports("System.Collections.Generic");
hScriptState = CSharpScript.RunAsync("using System.IO;", hOptions).Result;
while (true)
{
try
{
string sCmdLine = Console.ReadLine();
hScriptState = hScriptState.ContinueWithAsync(sCmdLine).Result;
}
catch (AggregateException hEx)
{
hEx.InnerExceptions.ToList().ForEach(e => Console.WriteLine(e.Message));
}
catch (Exception hEx)
{
Console.WriteLine(hEx.Message);
}
}
}
static void Main(string[] args)
{
ScriptState <object> hScriptState = null;
ScriptOptions hOptions = ScriptOptions.Default;
hOptions = hOptions.AddReferences(typeof(System.Object).Assembly, typeof(System.Linq.Enumerable).Assembly);
hOptions = hOptions.AddImports("System");
hOptions = hOptions.AddImports("System.Linq");
hOptions = hOptions.AddImports("System.Collections.Generic");
while (true)
{
try
{
string sCmdLine = Console.ReadLine();
if (hScriptState == null)
{
hScriptState = CSharpScript.RunAsync(sCmdLine, hOptions).Result;
}
else
{
hScriptState = hScriptState.ContinueWithAsync(sCmdLine).Result;
}
}
catch (Exception hEx)
{
Console.WriteLine(hEx.Message);
}
}
}
public static async void main2()
{
ScriptOptions op = ScriptOptions.Default;
var mscorlib = typeof(System.Object).Assembly;
var systemCore = typeof(System.Linq.Enumerable).Assembly;
op = op.AddReferences(mscorlib, systemCore);
op = op.AddImports("System");
//op = op.AddImports( "System.Linq" );
//op = op.AddImports( "System.Collections.Generic" );
var emgucvimg = typeof(Emgu.CV.Image <Gray, byte>).Assembly;
var emgucvstr = typeof(Emgu.CV.Structure.Gray).Assembly;
op = op.AddReferences(emgucvimg);
op = op.AddImports("Emgu.CV.Image");
op = op.AddImports("Emgu.CV.Structure");
var state = await CSharpScript.RunAsync(@"var x = ""E:\Temp\al.png"" ; ", op);
//state = await state.ContinueWithAsync( "var y = new Image<Gray,byte>(x); " );
var x = state.GetVariable("x");
Console.WriteLine(x.Value);
//var y = state.GetVariable("y");
//var img = (Image<Gray,byte>)y.Value;
Console.ReadLine();
}
public static object Execute(string code)
{
ScriptOptions scriptOptions = ScriptOptions.Default;
var mscorlib = typeof(System.Object).GetTypeInfo().Assembly;
var systemCore = typeof(System.Linq.Enumerable).GetTypeInfo().Assembly;
scriptOptions = scriptOptions.AddReferences(mscorlib, systemCore);
scriptOptions = scriptOptions.AddImports("System");
scriptOptions = scriptOptions.AddImports("System.Linq");
scriptOptions = scriptOptions.AddImports("System.Collections.Generic");
CancellationTokenSource cts = new CancellationTokenSource(StaticVariable.RUN_MILL);
Script script = CSharpScript.Create(code, scriptOptions);
var task = script.RunAsync(cancellationToken: cts.Token);
if (!task.Wait(StaticVariable.RUN_MILL))
{
cts.Cancel();
return("exec long time");
}
else
{
return(task.Result.ReturnValue);
}
//var endState = script.RunAsync().Result;
//return endState.ReturnValue;
}
private void _Init()
{
DefaultScriptOptions ??= ScriptOptions.Default;
DefaultScriptOptions = DefaultScriptOptions
.AddImports("System")
.AddReferences(typeof(DotNetConsole).Assembly);
}
protected void RunScript(string script, params string[] imports)
{
try
{
ScriptOptions options = ScriptOptions.Default;
options = options.WithReferences("System");
options = options.AddImports(imports);
var result = CSharpScript.EvaluateAsync(script, options);
if (result?.Result != null)
{
Console.WriteLine(result.Result.ToString());
}
}
catch (CompilationErrorException ex)
{
Console.BackgroundColor = ConsoleColor.Red;
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine(ex.Message);
Console.ResetColor();
}
catch (Exception ex)
{
Console.BackgroundColor = ConsoleColor.Black;
Console.ForegroundColor = ConsoleColor.Cyan;
Console.WriteLine(ex.Message + ": " + ex.StackTrace);
Console.ResetColor();
}
}
private void _Init(IConsole console)
{
DefaultScriptOptions ??= ScriptOptions.Default;
DefaultScriptOptions = DefaultScriptOptions
.AddImports("System")
.AddReferences(console.GetType().Assembly);
}
protected override ValidationResult IsValid(object value, ValidationContext validationContext)
{
ScriptOptions options = ScriptOptions.Default;
options = options.AddReferences(validationContext.ObjectType.Assembly);
options = options.AddImports(
"System.Collections.Generic",
"System",
validationContext.ObjectType.Namespace
);
var param = Lambda.Split("=>").FirstOrDefault();
if (!param.Trim().Contains(" "))
{
Lambda = Lambda.Replace(param, $"( dynamic {param} )");
}
var function = CSharpScript.EvaluateAsync <Func <dynamic, bool> >(Lambda, options).Result;
return(function(validationContext.ObjectInstance)
? ValidationResult.Success
: new ValidationResult(ErrorMessage));
}
async static Task Main(string[] args)
{
var result = await CSharpScript.EvaluateAsync("1 + 2");
Console.WriteLine(result); // 1 + 2 sarà valutato come 3
double d = await CSharpScript.EvaluateAsync <double>("5/(3-1)*3.5");
Console.WriteLine(d); // 7
var sum = await CSharpScript.EvaluateAsync("int x=1; int y=2; int z=x+y; z");
Console.WriteLine(sum); // 3
try
{
await CSharpScript.EvaluateAsync("1+a");
}
catch (CompilationErrorException e)
{
Console.WriteLine(string.Join(Environment.NewLine, e.Diagnostics)); //stampa gli errori di compilazione
}
var state = await CSharpScript.RunAsync("int x=0;int y=x+1; y");
ScriptVariable y = state.Variables.First(sv => sv.Name == "y");
var returnVal = state.ReturnValue;
ScriptOptions scriptOptions = ScriptOptions.Default;
var systemCore = typeof(System.Linq.Enumerable).Assembly;
//Aggiunge riferimento
scriptOptions = scriptOptions.AddReferences(systemCore);
//Aggiunge namespaces
scriptOptions = scriptOptions.AddImports("System");
scriptOptions = scriptOptions.AddImports("System.Linq");
scriptOptions = scriptOptions.AddImports("System.Collections.Generic");
var state1 = await CSharpScript.RunAsync(@"var list = new List<int>(){1,2,3,4,5};", scriptOptions);
state1 = await state1.ContinueWithAsync("var sum = list.Sum();");
var sum1 = state1.Variables.FirstOrDefault(v => v.Name == "sum");
Console.WriteLine($"sum={sum1.Value}");
}
public static object Execute(string code)
{
ScriptOptions scriptOptions = ScriptOptions.Default;
var mscorlib = typeof(System.Object).GetTypeInfo().Assembly;
var systemCore = typeof(System.Linq.Enumerable).GetTypeInfo().Assembly;
scriptOptions = scriptOptions.AddReferences(mscorlib, systemCore);
scriptOptions = scriptOptions.AddImports("System");
scriptOptions = scriptOptions.AddImports("System.Linq");
scriptOptions = scriptOptions.AddImports("System.Collections.Generic");
Script script = CSharpScript.Create(code, scriptOptions);
var endState = script.RunAsync().Result;
return(endState.ReturnValue);
}
private ScriptOptions AddSystemImports(ScriptOptions scriptOptions)
{
return(scriptOptions
.AddImports("System")
.AddImports("System.Linq")
.AddImports("System.Environment")
.AddImports("System.IO")
.AddImports("System.Collections.Generic"));
}
/// <summary>
/// Initializes Roslyn script options with all the required assemblies, references, and external dependencies.
/// </summary>
private void Initialize()
{
if (this.scriptCache.TryGetValue(ParentScriptCode, out this.parentScript))
{
// The parentScript is already initialized.
this.ParentScriptTask = Task.CompletedTask;
return;
}
this.ParentScriptTask = Task.Run(async() =>
{
ScriptOptions scriptOptions = ScriptOptions.Default;
#if NET462
// MissingResolver improvement not available in NetStandard. Only add to Net 462.
scriptOptions = ScriptOptions.Default.WithMetadataResolver(new MissingResolver());
#endif
// Add references to required assemblies.
Assembly mscorlib = typeof(object).Assembly;
Assembly systemCore = typeof(System.Linq.Enumerable).Assembly;
Assembly cSharpAssembly = typeof(Microsoft.CSharp.RuntimeBinder.CSharpArgumentInfo).Assembly;
scriptOptions = scriptOptions.AddReferences(mscorlib, systemCore, cSharpAssembly);
// Add required namespaces.
scriptOptions = scriptOptions.AddImports(
"System",
"System.Threading.Tasks");
string systemCoreAssemblyName = mscorlib.GetName().Name;
// Add external dependencies.
if (this.dependencies != null)
{
foreach (Type type in this.dependencies)
{
string fullAssemblyName = type.Assembly.GetName().Name;
// While adding the reference again is okay, we can not AddImports for systemCoreAssembly.
if (fullAssemblyName == systemCoreAssemblyName)
{
continue;
}
scriptOptions = scriptOptions.AddReferences(type.Assembly).AddImports(type.Namespace);
}
}
// Create the parentScript and add it to scriptCache. Execute the parentScript so Roslyn is primed to evaluate further expressions.
this.parentScript = this.scriptCache.GetOrAdd(
ParentScriptCode,
(key) => CSharpScript.Create <object>(ParentScriptCode, scriptOptions, typeof(CodeGenInputParams)));
await this.parentScript.RunAsync(this.parameters).ConfigureAwait(false);
});
}
public static async void UseScriptOptions()
{
ScriptOptions scriptOptions = ScriptOptions.Default;
var systemCore = typeof(System.Linq.Enumerable).Assembly;
//Aggiunge riferimento
scriptOptions = scriptOptions.AddReferences(systemCore);
//Aggiunge namespaces
scriptOptions = scriptOptions.AddImports("System");
scriptOptions = scriptOptions.AddImports("System.Linq");
scriptOptions = scriptOptions.AddImports("System.Collections.Generic");
var state = await CSharpScript.RunAsync(@"var list = new List<int>(){1,2,3,4,5};", scriptOptions);
state = await state.ContinueWithAsync("var sum = list.Sum();");
var sum = state.Variables.FirstOrDefault(v => v.Name == "sum");
Console.WriteLine(sum.Value);
}
public void Compile(Core.Models.Script item)
{
Throw.IfNull(item);
ScriptOptions scriptOptions = ScriptOptions.Default;
// Add reference to mscorlib
var mscorlib = typeof(object).GetTypeInfo().Assembly;
var systemCore = typeof(System.Linq.Enumerable).GetTypeInfo().Assembly;
var dicom = typeof(Dicom.DicomAgeString).GetTypeInfo().Assembly;
var assemblies = new[] { mscorlib, systemCore, dicom };
scriptOptions = scriptOptions.AddReferences(assemblies);
List <Assembly> referenceAssemblies = new List <Assembly>();
foreach (var referenceString in item.references)
{
referenceAssemblies.Add(Type.GetType(referenceString).Assembly);
}
scriptOptions.AddReferences(referenceAssemblies);
scriptOptions.AddImports(item.imports);
scriptOptions = scriptOptions.AddReferences(typeof(Enumerable).Assembly).AddImports("System.Linq", "System");
scriptOptions = scriptOptions.AddReferences(typeof(DicomTag).Assembly).AddImports("Dicom");
scriptOptions = scriptOptions.AddReferences(typeof(Logger).Assembly).AddImports("LifeImageLite");
using var interactiveLoader = new InteractiveAssemblyLoader();
foreach (var reference in referenceAssemblies)
{
interactiveLoader.RegisterDependency(reference);
}
item.script = CSharpScript.Create <RoutedItem>(item.source, options: scriptOptions, globalsType: typeof(RoutedItem), assemblyLoader: interactiveLoader);
try
{
item.script.Compile();
}
catch (CompilationErrorException e)
{
item.errors = $"{e.Message} {e.StackTrace}";
_logger.Log(LogLevel.Warning, $"{e.Message} {e.StackTrace}");
}
catch (System.IO.FileLoadException e)
{
item.errors = $"{e.Message} {e.StackTrace}";
_logger.Log(LogLevel.Warning, $"{e.Message} {e.StackTrace}");
}
}
private ScriptOptions ConstructParseOptions()
{
ScriptOptions parseOptions = ScriptOptions.Default
.AddReferences(typeof(object).GetTypeInfo().Assembly)
.AddReferences(typeof(IQueuedTaskToken).GetTypeInfo().Assembly)
.AddReferences(typeof(System.Linq.Enumerable).GetTypeInfo().Assembly);
foreach (string import in mImports)
{
parseOptions = parseOptions.AddImports(import);
}
return(parseOptions);
}
static async void MapToQuery(string intent, string entity)
{
//https://gist.github.com/amazedsaint/3828951
//https://github.com/dotnet/roslyn/wiki/Scripting-API-Samples
//https://www.jayway.com/2015/05/09/using-roslyn-to-build-a-simple-c-interactive-script-engine/
//https://blogs.msdn.microsoft.com/csharpfaq/2011/12/02/introduction-to-the-roslyn-scripting-api/
//http://source.roslyn.codeplex.com/#Microsoft.CodeAnalysis.CSharp.Scripting.UnitTests/ScriptTests.cs
//http://daveaglick.com/posts/compiler-platform-scripting
//https://blogs.msdn.microsoft.com/cdndevs/2015/12/01/adding-c-scripting-to-your-development-arsenal-part-1/
//https://www.snip2code.com/Snippet/761385/Test-Roslyn-Scripting-API--It-s-cool!/
//http://www.amazedsaint.com/2014/04/csharp6test-creating-tiny-roslyn-app-to.html
//https://joshvarty.wordpress.com/
var scriptPath = $@"IntentMapper\{intent}.csx";
var code = System.IO.File.ReadAllText(scriptPath);
ScriptOptions scriptOptions = ScriptOptions.Default;
//Add reference to Assembly
var luis = typeof(Luis.LuisToDBQueryMapper).Assembly;
scriptOptions = scriptOptions.AddReferences(luis);
//Add reference to NameSpaces
scriptOptions = scriptOptions.AddImports("System.Collections.Generic");
scriptOptions = scriptOptions.AddImports("System.Linq");
scriptOptions = scriptOptions.AddImports("Luis");
var returnValue = await CSharpScript.EvaluateAsync <string>(code, scriptOptions, new ScriptParameters()
{
intentToSearch = intent, entityToSearch = entity
});
dbQuery = returnValue;
}
/// <summary>
/// Instanciate Expression Evaluation
/// </summary>
/// <param name="Type">Model type (Required for precompile)</param>
/// <param name="Expression">Expression string (Required for precompile)</param>
/// <param name="references">Script references</param>
/// <param name="namespaces">Script namespaces</param>
public Evaluate(Type Type = null, string Expression = null, List <Assembly> references = null, List <string> namespaces = null)
{
// Add References
if (references == null)
{
_scriptOptions = _scriptOptions.AddReferences(typeof(System.Object).GetTypeInfo().Assembly, typeof(System.Linq.Enumerable).GetTypeInfo().Assembly);
}
else
{
_scriptOptions = _scriptOptions.AddReferences(references.ToArray());
}
// Add namespaces
if (namespaces == null)
{
// Default namespaces
_scriptOptions = _scriptOptions.AddImports("System");
_scriptOptions = _scriptOptions.AddImports("System.Linq");
_scriptOptions = _scriptOptions.AddImports("System.Collections.Generic");
}
else
{
foreach (var n in namespaces)
{
_scriptOptions = _scriptOptions.AddImports(n);
}
}
// Precompile
if (Type != null && Expression != null)
{
_script = CSharpScript.Create(Expression, _scriptOptions, Type);
_script.Compile();
_preCompiled = true;
}
}
static void Main(string[] args)
{
ScriptOptions option = ScriptOptions.Default;
List <Assembly> assemblys = new List <Assembly>
{
typeof(object).GetTypeInfo().Assembly,
typeof(System.Linq.Enumerable).GetTypeInfo().Assembly,
typeof(System.Windows.Forms.Application).GetTypeInfo().Assembly,
typeof(SOA.SOAApp).GetTypeInfo().Assembly
};
List <string> namespaces = new List <string>
{
"System",
"System.IO",
"System.Collections.Generic",
"System.Windows.Forms",
"System.Drawing",
"System.Drawing.Imaging",
"SOA",
"SOA.Extension"
};
foreach (Assembly assemble in assemblys)
{
option = option.WithReferences(assemble);
}
foreach (string name in namespaces)
{
option = option.AddImports(name);
}
//string path = Path.Combine(Directory.GetParent(Directory.GetCurrentDirectory()).Parent.FullName, "sample.csx");
//string path = "C:/Users/adunstudio/Desktop/SOA/SOA/Sample/1_sample_keyboard.csx"; // keyboad
//string path = "C:/Users/adunstudio/Desktop/SOA/SOA/Sample/2_sample_mouse.csx"; // mouse
//string path = "C:/Users/adunstudio/Desktop/SOA/SOA/Sample/3_sample_capture.csx"; // capture
string path = "C:/Users/adunstudio/Desktop/SOA/SOA/Sample/4_sample_clip.csx"; // Clip
var app = new SOAApp();
Console.WriteLine("Program Start...");
CSharpScript.RunAsync(File.ReadAllText(path), option, app).Wait();
app.Run();
}
public async Task <TranspileResult> RunAsync(string code)
{
var result = new TranspileResult();
if (string.IsNullOrEmpty(code))
{
return(result);
}
Stopwatch watch = new Stopwatch();
watch.Start();
try
{
ScriptOptions scriptOptions = ScriptOptions.Default;
scriptOptions = scriptOptions.AddReferences(References);
scriptOptions = scriptOptions.AddImports("System");
var resultCode = this.GenerateTranspiledCode(code);
if (resultCode == null)
{
watch.Stop();
result.TimeElapsed = watch.Elapsed.ToString();
return(result);
}
var outputStrBuilder = new StringBuilder();
using (var writer = new StringWriter(outputStrBuilder))
{
Console.SetOut(writer);
var scriptState = await CSharpScript.RunAsync(resultCode, scriptOptions);
result.output = outputStrBuilder.ToString();
}
}
catch (Exception ex)
{
result.output = ex.Message;
}
finally
{
watch.Stop();
result.TimeElapsed = watch.Elapsed.ToString();
}
return(result);
}
private static async Task <ScriptState <T> > ExecuteScript <T>(string script)
{
ScriptOptions scriptOptions = ScriptOptions.Default;
scriptOptions = scriptOptions.AddImports("System");
Console.WriteLine("Execute Script:");
Console.WriteLine(script);
try
{
return(await CSharpScript.RunAsync <T>(script, scriptOptions));
}
catch (Exception ex)
{
Console.WriteLine("=> " + ex.Message);
return(null);
}
}
private ScriptOptions AddDefaultImports(ScriptOptions scriptOptions)
{
var workingDir = AppContext.BaseDirectory;
return(scriptOptions.AddImports(new [] {
"System",
"System.IO",
"System.Collections.Generic",
"System.Console",
"System.Diagnostics",
"System.Dynamic",
"System.Linq",
"System.Linq.Expressions",
"System.Text",
"System.Threading.Tasks"
}).WithSourceResolver(new SourceFileResolver(ImmutableArray <string> .Empty, workingDir))
.WithMetadataResolver(new NuGetMetadataReferenceResolver(ScriptMetadataResolver.Default.WithBaseDirectory(workingDir)))
.WithEmitDebugInformation(true)
.WithFileEncoding(Encoding.UTF8));
}
protected void RunScript(string code, params string[] imports)
{
try
{
ScriptOptions options = ScriptOptions.Default;
options = options.WithReferences("System");
options = options.WithReferences(Assembly.GetAssembly(this.GetType()));
options = options.AddImports(imports);
if (Script == null)
{
Script = CSharpScript.Create("", options, Globals.GetType());
}
Script script = Script.ContinueWith(code, options);
ScriptState state = State == null?script.RunAsync(Globals, ExceptionHandler).Result : script.RunFromAsync(State, ExceptionHandler).Result;
if (state.Exception != null)
{
ExceptionHandler(state.Exception);
return;
}
if (state.ReturnValue != null)
{
Console.WriteLine("Returned: " + state.ReturnValue);
}
Script = script;
State = state;
}
catch (CompilationErrorException ex)
{
ExceptionHandler(ex);
}
catch (Exception ex)
{
ExceptionHandler(ex);
}
}
protected override ScriptOptions CreateScriptOptions(ScriptOptions options)
{
var rspFile = GetResponseFile("CSharpInteractive.rsp");
if (rspFile == null)
{
return(options);
}
this.replEditor.OutputPrintLine(string.Format(dnSpy_Scripting_Roslyn_Resources.LoadingContextFromFile, Path.GetFileName(rspFile)));
foreach (var t in ResponseFileReader.Read(rspFile))
{
if (t.Item1 == "/r")
{
Debug.Assert(t.Item3.Length == 0);
if (t.Item3.Length != 0)
{
continue;
}
options = options.AddReferences(t.Item2);
}
else if (t.Item1 == "/u")
{
Debug.Assert(t.Item3.Length == 0);
if (t.Item3.Length != 0)
{
continue;
}
options = options.AddImports(t.Item2);
}
else
{
Debug.Fail(string.Format("Unknown option: '{0}'", t.Item1));
}
}
return(options);
}
public ScriptResult Execute(string code, string[] scriptArgs, AssemblyReferences references, IEnumerable <string> namespaces, ScriptPackSession scriptPackSession)
{
if (scriptPackSession == null)
{
throw new ArgumentNullException("scriptPackSession");
}
if (references == null)
{
throw new ArgumentNullException("references");
}
_log.Debug("Starting to create execution components");
_log.Debug("Creating script host");
var executionReferences = new AssemblyReferences(references.Assemblies, references.Paths);
executionReferences.Union(scriptPackSession.References);
ScriptResult scriptResult;
SessionState <ScriptState> sessionState;
var isFirstExecution = !scriptPackSession.State.ContainsKey(SessionKey);
if (isFirstExecution)
{
var host = _scriptHostFactory.CreateScriptHost(new ScriptPackManager(scriptPackSession.Contexts), scriptArgs);
ScriptLibraryWrapper.SetHost(host);
_log.Debug("Creating session");
var hostType = host.GetType();
Loader.RegisterDependency(hostType.GetTypeInfo().Assembly);
//ScriptOptions = ScriptOptions.AddReferences(typeof(Console).GetTypeInfo().Assembly);
ScriptOptions = ScriptOptions.AddReferences(typeof(Object).GetTypeInfo().Assembly);
var allNamespaces = namespaces.Union(scriptPackSession.Namespaces).Distinct();
foreach (var reference in executionReferences.Paths)
{
_log.DebugFormat("Adding reference to {0}", reference);
ScriptOptions = ScriptOptions.AddReferences(reference);
}
foreach (var assembly in executionReferences.Assemblies)
{
_log.DebugFormat("Adding reference to {0}", assembly.FullName);
ScriptOptions = ScriptOptions.AddReferences(assembly);
}
foreach (var @namespace in allNamespaces)
{
_log.DebugFormat("Importing namespace {0}", @namespace);
ScriptOptions = ScriptOptions.AddImports(@namespace);
}
sessionState = new SessionState <ScriptState> {
References = executionReferences, Namespaces = new HashSet <string>(allNamespaces)
};
scriptPackSession.State[SessionKey] = sessionState;
scriptResult = Execute(code, host, sessionState);
}
else
{
_log.Debug("Reusing existing session");
sessionState = (SessionState <ScriptState>)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.Paths)
{
_log.DebugFormat("Adding reference to {0}", reference);
ScriptOptions = ScriptOptions.AddReferences(reference);
sessionState.References = sessionState.References.Union(new[] { reference });
}
foreach (var assembly in newReferences.Assemblies)
{
_log.DebugFormat("Adding reference to {0}", assembly.FullName);
ScriptOptions = ScriptOptions.AddReferences(assembly);
sessionState.References = sessionState.References.Union(new[] { assembly });
}
var newNamespaces = namespaces.Except(sessionState.Namespaces);
foreach (var @namespace in newNamespaces)
{
_log.DebugFormat("Importing namespace {0}", @namespace);
ScriptOptions = ScriptOptions.AddImports(@namespace);
sessionState.Namespaces.Add(@namespace);
}
if (string.IsNullOrWhiteSpace(code))
{
return(ScriptResult.Empty);
}
scriptResult = Execute(code, sessionState.Session, sessionState);
}
return(scriptResult);
//todo handle namespace failures
//https://github.com/dotnet/roslyn/issues/1012
}
public static void Execute(string sourceCode, object globals, List <Type> assembly_references, List <string> imports)
{
ScriptOptions options = ScriptOptions.Default;
assembly_references.ForEach(refrence =>
{
options = options.AddReferences(new List <Assembly>()
{
refrence?.Assembly
});
});
options.AddImports(imports);
var add_hashtag_start = sourceCode.Insert(0, "#");
var add_hashtag_end = add_hashtag_start.Insert(add_hashtag_start.Length, "\n#");
var start_sourceCode = add_hashtag_end;
var new_sourceCode = "";
var split_by_hastag = start_sourceCode.Split('#').ToList();
foreach (var hastag_split in split_by_hastag)
{
if (hastag_split is "")
{
continue;
}
var newLine_split_code = hastag_split.Split('\n').ToList();
for (int i = 0; i < newLine_split_code.Count; i++)
{
if (newLine_split_code.Contains(";"))
{
new_sourceCode += newLine_split_code;
continue;
}
if (newLine_split_code[i] == "") //IGNORE EMPTY STRINGS -> ""
{
continue;
}
if (newLine_split_code[i].StartsWith("//")) //IGNORE STRINGS THAT START WITH "//"
{
new_sourceCode += newLine_split_code[i];
continue;
}
if (newLine_split_code[i].Contains(" class ")) //IGNORE CLASS DECLARATIONS -> class
{
new_sourceCode += newLine_split_code[i];
continue;
}
if (newLine_split_code[i].Contains("get") || newLine_split_code[i].Contains("set"))
{
var needs_format = newLine_split_code[i];
var scopeOperator_split = newLine_split_code[i].Split('{', '}');
foreach (var split in scopeOperator_split)
{
if (split == "")
{
continue;
}
if (split.Contains("return"))
{
var proptery_return = split.Insert(split.Length, ";");
needs_format = needs_format.Replace(split, proptery_return);
continue;
}
if (split.Contains("="))
{
var proptery_assignment = split.Insert(split.Length, ";");
needs_format = needs_format.Replace(split, proptery_assignment);
continue;
}
if (split.Contains("get") && split.Contains("set"))
{
var auto_proptery_get = "get;";
var auto_propter_set = "set;";
needs_format = needs_format.Replace("get", auto_proptery_get);
needs_format = needs_format.Replace("set", auto_propter_set);
continue;
}
}
new_sourceCode += needs_format;
continue;
}
if (newLine_split_code[i].Contains("{") || newLine_split_code[i].Contains("}")) //IGNORE SCOPE OPERATORS -> { }
{
new_sourceCode += newLine_split_code[i];
continue;
}
else
{
var next_line = newLine_split_code[i + 1];
if (next_line != null)
{
if (next_line.Contains("{"))
{
new_sourceCode += newLine_split_code[i];
continue;
}
else
{
var needs_format = newLine_split_code[i];
needs_format = needs_format.Insert(needs_format.Length, ";");
new_sourceCode += needs_format;
continue;
}
}
}
}
}
CSharpScript.RunAsync(new_sourceCode, options, globals);
}
private static Expression <Func <ICellAccessor, Action> > ConstructVisitNodeAction(ExpressionSyntax traverseAction)
{
/***********************************************
* Syntax: (VISITNODE)
*
* 1. VisitNode(FanoutSearch.Action action, IEnumerable<string> select = null)
* 2. VisitNode(Expression<Func<ICellAccessor, FanoutSearch.Action>> action, IEnumerable<string> select = null)
*
* The select part is handled by the caller.
***********************************************/
var action_expr = TryGet <MemberAccessExpressionSyntax>(traverseAction);
var lambda_expression = TryGet <LambdaExpressionSyntax>(traverseAction);
Expression <Func <ICellAccessor, Action> > ret = null;
if (action_expr != null)
{
// Action enum
var id_expr = Get <IdentifierNameSyntax>(action_expr.Expression);
if (id_expr.ToString() != s_LIKQ_Action)
{
goto throw_badtype;
}
Action result_action;
ThrowIf(!Enum.TryParse(action_expr.Name.ToString(), out result_action), "Invalid traverse action", action_expr);
return(ExpressionBuilder.WrapAction(result_action));
}
else
{
if (lambda_expression == null)
{
goto throw_badtype;
}
// FanoutSearch.Action is ambiguous with with System.Action
var action_visitor = new FanoutSearchActionRewritter();
lambda_expression = action_visitor.Visit(lambda_expression) as LambdaExpressionSyntax;
ScriptOptions scriptOptions = ScriptOptions.Default;
var mscorlib = typeof(System.Object).Assembly;
var systemCore = typeof(System.Linq.Enumerable).Assembly;
var expression = typeof(Expression).Assembly;
var fanout = typeof(FanoutSearchModule).Assembly;
var trinity = typeof(Trinity.Global).Assembly;
scriptOptions = scriptOptions.AddReferences(mscorlib, systemCore, expression, fanout, trinity);
scriptOptions = scriptOptions.AddImports(
"System",
"System.Linq",
"System.Linq.Expressions",
"System.Collections.Generic",
"FanoutSearch",
"FanoutSearch.LIKQ",
"Trinity",
"Trinity.Storage");
try
{
// Allocate a cancellation token source, which signals after our timeout setting (if we do have timeout setting)
CancellationToken cancel_token = default(CancellationToken);
if (FanoutSearchModule._QueryTimeoutEnabled())
{
checked
{
cancel_token = new CancellationTokenSource((int)FanoutSearchModule.GetQueryTimeout()).Token;
}
}
// It is guaranteed that the lambda_expression is really a lambda.
// Evaluating a lambda and expecting an expression tree to be obtained now.
using (var eval_task = CSharpScript.EvaluateAsync <Expression <Func <ICellAccessor, Action> > >(lambda_expression.ToString(), scriptOptions, cancellationToken: cancel_token))
{
eval_task.Wait(cancel_token);
ret = eval_task.Result;
}
}
catch (ArithmeticException) { /* that's a fault not an error */ throw; }
catch { /*swallow roslyn scripting engine exceptions.*/ }
ThrowIf(null == ret, "Invalid lambda expression.", traverseAction);
return(ret);
}
throw_badtype:
ThrowIf(true, "Expecting an argument of type FanoutSearch.Action, or a lambda expression.", traverseAction);
return(null);//not going to happen
}
