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 }