protected virtual NPath CompileCSharpAssemblyWithRoslyn(CompilerOptions options) { var languageVersion = LanguageVersion.Default; var compilationOptions = new CSharpCompilationOptions( outputKind: options.OutputPath.FileName.EndsWith(".exe") ? OutputKind.ConsoleApplication : OutputKind.DynamicallyLinkedLibrary, assemblyIdentityComparer: DesktopAssemblyIdentityComparer.Default ); // Default debug info format for the current platform. DebugInformationFormat debugType = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? DebugInformationFormat.Pdb : DebugInformationFormat.PortablePdb; bool emitPdb = false; if (options.AdditionalArguments != null) { foreach (var option in options.AdditionalArguments) { switch (option) { case "/unsafe": compilationOptions = compilationOptions.WithAllowUnsafe(true); break; case "/optimize+": compilationOptions = compilationOptions.WithOptimizationLevel(OptimizationLevel.Release); break; case "/optimize-": compilationOptions = compilationOptions.WithOptimizationLevel(OptimizationLevel.Debug); break; case "/debug:full": case "/debug:pdbonly": // Use platform's default debug info. This behavior is the same as csc. emitPdb = true; break; case "/debug:portable": emitPdb = true; debugType = DebugInformationFormat.PortablePdb; break; case "/debug:embedded": emitPdb = true; debugType = DebugInformationFormat.Embedded; break; case "/langversion:7.3": languageVersion = LanguageVersion.CSharp7_3; break; default: var splitIndex = option.IndexOf(":"); if (splitIndex != -1 && option[..splitIndex] == "/main") { var mainTypeName = option[(splitIndex + 1)..];
static byte[] GetILDLL(string srccode, bool Optimization = false) { byte[] dll = null; byte[] pdb = null; var ast = Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.ParseText(srccode); var op = new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary); if (Optimization) { op = op.WithOptimizationLevel(OptimizationLevel.Release); } var comp = CSharpCompilation.Create("aaa.dll", new[] { ast }, new[] { MetadataReference.CreateFromFile(typeof(object).Assembly.Location), }, op); using (var streamDll = new MemoryStream()) { using (var streamPdb = new MemoryStream()) { var result = comp.Emit(streamDll, streamPdb); if (!result.Success) { foreach (var d in result.Diagnostics) { Console.WriteLine(d.ToString()); } throw new Exception("build error."); } dll = streamDll.ToArray(); pdb = streamPdb.ToArray(); return(dll); } } }
public void _TestCompilationOptions() { var tree = CSharpSyntaxTree.ParseText(@" using System;using Xunit; public class MyClass { public static void Main() { //DebugLogger.Instance.WriteLine(""Hello World!""); //DebugLogger.Instance.ReadLine(); } }"); //We first have to choose what kind of output we're creating: DLL, .exe etc. var options = new CSharpCompilationOptions(OutputKind.ConsoleApplication); options = options.WithAllowUnsafe(true); //Allow unsafe code; options = options.WithOptimizationLevel(OptimizationLevel.Release); //Set optimization level options = options.WithPlatform(Platform.X64); //Set platform var mscorlib = MetadataReference.CreateFromFile(typeof(object).Assembly.Location); var compilation = CSharpCompilation.Create("MyCompilation", syntaxTrees: new[] { tree }, references: new[] { mscorlib }, options: options); //Pass options to compilation }
public async Task <ScriptsCompileResult> Build(GameProject gameProject, FileInfo mainScript, bool releaseMode) { string scriptsPath = mainScript.DirectoryName; _compilationOptions = _compilationOptions.WithSourceReferenceResolver( new SourceFileResolver(ImmutableArray <string> .Empty, scriptsPath)); if (releaseMode) { _compilationOptions = _compilationOptions.WithOptimizationLevel(OptimizationLevel.Release); } if (!releaseMode && mainScript.LastWriteTime < _lastBuildTime) { return(new ScriptsCompileResult()); } string scriptCode = File.ReadAllText(mainScript.FullName); ScriptsCompileResult result = await Task.Run(() => GenerateGameAssembly(scriptCode)); if (result.Errors == null) { _lastBuildTime = DateTime.Now; } return(result); }
private static Assembly CreateAssembly(string sourceCode, bool debug) { lineOffset = CalculateLineOffset(sourceCode); exceptionMsg = null; errors = null; string assemblyName = Path.GetRandomFileName(); IEnumerable <SyntaxTree> syntaxTree = new[] { CSharpSyntaxTree.ParseText(sourceCode, options: debug ? parseOptions.WithPreprocessorSymbols("DEBUG") : parseOptions) }; CSharpCompilation compilation = CSharpCompilation.Create( assemblyName, syntaxTree, references, compilationOptions.WithOptimizationLevel(debug ? OptimizationLevel.Debug : OptimizationLevel.Release)); using (MemoryStream ms = new MemoryStream()) { EmitResult result = compilation.Emit(ms); errors = result.Diagnostics.Where(ErrorFilter); if (!result.Success) { return(null); } AssemblyLoadContext loadContext = new AssemblyLoadContext(null, true); ms.Seek(0, SeekOrigin.Begin); Assembly assembly = loadContext.LoadFromStream(ms); return(assembly); } }
private EmitResult CompileAndBuild(string outputFileName, string sourceCode, BuildConfiguration buildConfiguration) { var referenceBasePath = $@"c:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\{buildConfiguration.TargetFramework}\"; var template = File.ReadAllText(@"C:\Workspace\Sharpbench\src\BenchmarkHost\EntryPoint.cs"); var generatedSourceCode = template.Replace("/*CODE_PLACEHOLDER*/", sourceCode); var syntaxTree = CSharpSyntaxTree.ParseText(generatedSourceCode); var options = new CSharpCompilationOptions(OutputKind.ConsoleApplication); if (buildConfiguration.Optimization == Optimization.Debug) { options.WithOptimizationLevel(OptimizationLevel.Debug); } else if (buildConfiguration.Optimization == Optimization.Release) { options.WithOptimizationLevel(OptimizationLevel.Release); } else { throw new ArgumentOutOfRangeException(nameof(buildConfiguration.Optimization)); } if (buildConfiguration.Platform == Platform.X86) { options.WithPlatform(Microsoft.CodeAnalysis.Platform.X86); } else if (buildConfiguration.Platform == Platform.X64) { options.WithPlatform(Microsoft.CodeAnalysis.Platform.X64); } var references = new MetadataReference[] { MetadataReference.CreateFromFile(Path.Combine(referenceBasePath, "mscorlib.dll")), MetadataReference.CreateFromFile(Path.Combine(referenceBasePath, "System.dll")), MetadataReference.CreateFromFile(Path.Combine(referenceBasePath, "System.Xml.dll")), }; var compilation = CSharpCompilation.Create("GeneratedAssembly", new[] { syntaxTree }, options: options, references: references); var emitResult = compilation.Emit(outputFileName); return(emitResult); }
private static void ConfigureRazor(RazorViewEngineOptions razorOptions, IApplicationEnvironment applicationEnvironment, IHostingEnvironment hostingEnvironment) { razorOptions.FileProviders.Add(new PhysicalFileProvider(applicationEnvironment.ApplicationBasePath)); var parseOptions = new CSharpParseOptions(LanguageVersion.CSharp6); var compilationOptions = new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary); if (hostingEnvironment.IsDevelopment()) { razorOptions.ParseOptions = parseOptions.WithPreprocessorSymbols("DEBUG"); razorOptions.CompilationOptions = compilationOptions.WithOptimizationLevel(OptimizationLevel.Debug); } else { razorOptions.ParseOptions = parseOptions.WithPreprocessorSymbols("RELEASE"); razorOptions.CompilationOptions = compilationOptions.WithOptimizationLevel(OptimizationLevel.Release); } }
protected virtual CSharpCompilationOptions GetCompilationOptions() { var csharpCompilationOptions = new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary); // Disable 1702 until roslyn turns this off by default csharpCompilationOptions = csharpCompilationOptions.WithSpecificDiagnosticOptions( new Dictionary <string, ReportDiagnostic> { { "CS1701", ReportDiagnostic.Suppress }, // Binding redirects { "CS1702", ReportDiagnostic.Suppress }, { "CS1705", ReportDiagnostic.Suppress } }); return(csharpCompilationOptions.WithOptimizationLevel(OptimizationLevel.Release)); }
private static CSharpCompilationOptions GetCompilationOptions( IWebHostEnvironment hostingEnvironment, DependencyContextCompilationOptions dependencyContextOptions) { var csharpCompilationOptions = new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary); // Disable 1702 until roslyn turns this off by default csharpCompilationOptions = csharpCompilationOptions.WithSpecificDiagnosticOptions( new Dictionary <string, ReportDiagnostic> { { "CS1701", ReportDiagnostic.Suppress }, // Binding redirects { "CS1702", ReportDiagnostic.Suppress }, { "CS1705", ReportDiagnostic.Suppress } }); if (dependencyContextOptions.AllowUnsafe.HasValue) { csharpCompilationOptions = csharpCompilationOptions.WithAllowUnsafe( dependencyContextOptions.AllowUnsafe.Value); } OptimizationLevel optimizationLevel; if (dependencyContextOptions.Optimize.HasValue) { optimizationLevel = dependencyContextOptions.Optimize.Value ? OptimizationLevel.Release : OptimizationLevel.Debug; } else { optimizationLevel = hostingEnvironment.IsDevelopment() ? OptimizationLevel.Debug : OptimizationLevel.Release; } csharpCompilationOptions = csharpCompilationOptions.WithOptimizationLevel(optimizationLevel); if (dependencyContextOptions.WarningsAsErrors.HasValue) { var reportDiagnostic = dependencyContextOptions.WarningsAsErrors.Value ? ReportDiagnostic.Error : ReportDiagnostic.Default; csharpCompilationOptions = csharpCompilationOptions.WithGeneralDiagnosticOption(reportDiagnostic); } return(csharpCompilationOptions); }
public void EmittingConsoleApplication() { var text = "Hello Roslyn!"; var tree = CSharpSyntaxTree.ParseText($@" using System; using System.Diagnostics; public class MyClass {{ public static void Main() {{ Console.WriteLine(""{text}""); }} }}"); var options = new CSharpCompilationOptions(OutputKind.ConsoleApplication); options = options.WithOptimizationLevel(OptimizationLevel.Release); //Set optimization level options = options.WithPlatform(Platform.X86); //Set platform var mscorlib = MetadataReference.CreateFromFile(typeof(object).Assembly.Location); var compilation = CSharpCompilation.Create("MyCompilation", syntaxTrees: new[] { tree }, references: new[] { mscorlib }, options: options); //Emit to stream using (var ms = new MemoryStream()) { var emitResult = compilation.Emit(ms); //Load into currently running assembly. Normally we'd probably //want to do this in an AppDomain var ourAssembly = Assembly.Load(ms.ToArray()); var type = ourAssembly.GetType("MyClass"); //Invokes our main method and writes "Hello World" :) type.InvokeMember("Main", BindingFlags.Default | BindingFlags.InvokeMethod, null, null, null); } }
private static void CompileToCSharp(SyntaxTree tree) { var mscorlib = MetadataReference.CreateFromFile(typeof(object).Assembly.Location); var ethSharp = MetadataReference.CreateFromFile(typeof(UInt256).Assembly.Location); var options = new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary); options = options.WithAllowUnsafe(true); //Allow unsafe code; options = options.WithOptimizationLevel(OptimizationLevel.Release); //Set optimization level options = options.WithPlatform(Platform.X64); var compilation = CSharpCompilation.Create("MyCompilation", syntaxTrees: new[] { tree }, references: new[] { mscorlib, ethSharp }, options: options); var emitResult = compilation.Emit("output.dll", "output.pdb"); //If our compilation failed, we can discover exactly why. if (!emitResult.Success) { foreach (var diagnostic in emitResult.Diagnostics) { Console.WriteLine(diagnostic.ToString()); } } }
public HostBuildData Create(HostBuildOptions options) { var parseOptions = new CSharpParseOptions(languageVersion: LanguageVersion.CSharp6, documentationMode: DocumentationMode.Parse); var compilationOptions = new CSharpCompilationOptions( OutputKind.ConsoleApplication, xmlReferenceResolver: new XmlFileResolver(options.ProjectDirectory), sourceReferenceResolver: new SourceFileResolver(ImmutableArray<string>.Empty, options.ProjectDirectory), metadataReferenceResolver: new AssemblyReferenceResolver( new MetadataFileReferenceResolver(ImmutableArray<string>.Empty, options.ProjectDirectory), MetadataFileReferenceProvider.Default), strongNameProvider: new DesktopStrongNameProvider(ImmutableArray.Create(options.ProjectDirectory, options.OutputDirectory)), assemblyIdentityComparer: DesktopAssemblyIdentityComparer.Default); var warnings = new List<KeyValuePair<string, ReportDiagnostic>>(options.Warnings); if (options.OutputKind.HasValue) { var kind = options.OutputKind.Value; compilationOptions = compilationOptions.WithOutputKind(kind); if (compilationOptions.Platform == Platform.AnyCpu32BitPreferred && (kind == OutputKind.DynamicallyLinkedLibrary || kind == OutputKind.NetModule || kind == OutputKind.WindowsRuntimeMetadata)) { compilationOptions = compilationOptions.WithPlatform(Platform.AnyCpu); } } if (!string.IsNullOrEmpty(options.DefineConstants)) { IEnumerable<Diagnostic> diagnostics; parseOptions = parseOptions.WithPreprocessorSymbols(CSharpCommandLineParser.ParseConditionalCompilationSymbols(options.DefineConstants, out diagnostics)); } if (options.DocumentationFile != null) { parseOptions = parseOptions.WithDocumentationMode(!string.IsNullOrEmpty(options.DocumentationFile) ? DocumentationMode.Diagnose : DocumentationMode.Parse); } if (options.LanguageVersion != null) { var languageVersion = CompilationOptionsConversion.GetLanguageVersion(options.LanguageVersion); if (languageVersion.HasValue) { parseOptions = parseOptions.WithLanguageVersion(languageVersion.Value); } } if (!string.IsNullOrEmpty(options.PlatformWith32BitPreference)) { Platform platform; if (Enum.TryParse<Platform>(options.PlatformWith32BitPreference, true, out platform)) { if (platform == Platform.AnyCpu && compilationOptions.OutputKind != OutputKind.DynamicallyLinkedLibrary && compilationOptions.OutputKind != OutputKind.NetModule && compilationOptions.OutputKind != OutputKind.WindowsRuntimeMetadata) { platform = Platform.AnyCpu32BitPreferred; } compilationOptions = compilationOptions.WithPlatform(platform); } } if (options.AllowUnsafeBlocks.HasValue) { compilationOptions = compilationOptions.WithAllowUnsafe(options.AllowUnsafeBlocks.Value); } if (options.CheckForOverflowUnderflow.HasValue) { compilationOptions = compilationOptions.WithOverflowChecks(options.CheckForOverflowUnderflow.Value); } if (options.DelaySign != null) { bool delaySignExplicitlySet = options.DelaySign.Item1; bool delaySign = options.DelaySign.Item2; compilationOptions = compilationOptions.WithDelaySign(delaySignExplicitlySet ? delaySign : (bool?)null); } if (!string.IsNullOrEmpty(options.ApplicationConfiguration)) { var appConfigPath = FileUtilities.ResolveRelativePath(options.ApplicationConfiguration, options.ProjectDirectory); try { using (var appConfigStream = PortableShim.FileStream.Create(appConfigPath, PortableShim.FileMode.Open, PortableShim.FileAccess.Read)) { compilationOptions = compilationOptions.WithAssemblyIdentityComparer(DesktopAssemblyIdentityComparer.LoadFromXml(appConfigStream)); } } catch (Exception) { } } if (!string.IsNullOrEmpty(options.KeyContainer)) { compilationOptions = compilationOptions.WithCryptoKeyContainer(options.KeyContainer); } if (!string.IsNullOrEmpty(options.KeyFile)) { var fullPath = FileUtilities.ResolveRelativePath(options.KeyFile, options.ProjectDirectory); compilationOptions = compilationOptions.WithCryptoKeyFile(fullPath); } if (!string.IsNullOrEmpty(options.MainEntryPoint)) { compilationOptions = compilationOptions.WithMainTypeName(options.MainEntryPoint); } if (!string.IsNullOrEmpty(options.ModuleAssemblyName)) { compilationOptions = compilationOptions.WithModuleName(options.ModuleAssemblyName); } if (options.Optimize.HasValue) { compilationOptions = compilationOptions.WithOptimizationLevel(options.Optimize.Value ? OptimizationLevel.Release : OptimizationLevel.Debug); } if (!string.IsNullOrEmpty(options.Platform)) { Platform plat; if (Enum.TryParse<Platform>(options.Platform, ignoreCase: true, result: out plat)) { compilationOptions = compilationOptions.WithPlatform(plat); } } // Get options from the ruleset file, if any. if (!string.IsNullOrEmpty(options.RuleSetFile)) { var fullPath = FileUtilities.ResolveRelativePath(options.RuleSetFile, options.ProjectDirectory); Dictionary<string, ReportDiagnostic> specificDiagnosticOptions; var generalDiagnosticOption = RuleSet.GetDiagnosticOptionsFromRulesetFile(fullPath, out specificDiagnosticOptions); compilationOptions = compilationOptions.WithGeneralDiagnosticOption(generalDiagnosticOption); warnings.AddRange(specificDiagnosticOptions); } if (options.WarningsAsErrors.HasValue) { compilationOptions = compilationOptions.WithGeneralDiagnosticOption(options.WarningsAsErrors.Value ? ReportDiagnostic.Error : ReportDiagnostic.Default); } if (options.WarningLevel.HasValue) { compilationOptions = compilationOptions.WithWarningLevel(options.WarningLevel.Value); } compilationOptions = compilationOptions.WithSpecificDiagnosticOptions(warnings); return new HostBuildData( parseOptions, compilationOptions); }
public override async Task <CodeCompilerResult> CompileFile( CodeCompilerArguments arguments, TextWriter log, CancellationToken token) { var references = new List <MetadataReference> (); foreach (var assemblyReference in AssemblyResolver.GetResolvedReferences(runtime, arguments.AssemblyReferences)) { references.Add(MetadataReference.CreateFromFile(assemblyReference)); try { Assembly.LoadFrom(assemblyReference); } catch (Exception) { } } var syntaxTrees = new List <SyntaxTree> (); foreach (var sourceFile in arguments.SourceFiles) { using var stream = File.OpenRead(sourceFile); var sourceText = SourceText.From(stream, Encoding.UTF8, canBeEmbedded: true); syntaxTrees.Add(CSharpSyntaxTree.ParseText(sourceText, path: sourceFile)); } var compilationoptions = new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary); if (arguments.Debug) { compilationoptions = compilationoptions.WithOptimizationLevel(OptimizationLevel.Debug); } var compilation = CSharpCompilation.Create( "GeneratedTextTransformation", syntaxTrees, references, compilationoptions ); EmitOptions emitOptions = null; List <EmbeddedText> embeddedTexts = null; string pdbPath = null; if (arguments.Debug) { pdbPath = Path.ChangeExtension(arguments.OutputPath, "pdb"); embeddedTexts = syntaxTrees.Where(st => !string.IsNullOrEmpty(st.FilePath)).Select(st => EmbeddedText.FromSource(st.FilePath, st.GetText())).ToList(); emitOptions = new EmitOptions(debugInformationFormat: DebugInformationFormat.PortablePdb, pdbFilePath: pdbPath); } EmitResult result; using var fs = File.OpenWrite(arguments.OutputPath); { if (pdbPath != null) { using var pdb = File.OpenWrite(pdbPath); result = compilation.Emit(fs, pdbStream: pdb, options: emitOptions, embeddedTexts: embeddedTexts); } else { result = compilation.Emit(fs, options: emitOptions, embeddedTexts: embeddedTexts); } } if (result.Success) { return(new CodeCompilerResult { Output = new List <string> (), Success = true, Errors = new List <CodeCompilerError> () }); } var failures = result.Diagnostics.Where(x => x.IsWarningAsError || x.Severity == DiagnosticSeverity.Error); var errors = failures.Select(x => { var location = x.Location.GetMappedLineSpan(); var startLinePosition = location.StartLinePosition; var endLinePosition = location.EndLinePosition; return(new CodeCompilerError { Message = x.GetMessage(), Column = startLinePosition.Character, Line = startLinePosition.Line, EndLine = endLinePosition.Line, EndColumn = endLinePosition.Character, IsError = x.Severity == DiagnosticSeverity.Error, Origin = location.Path }); }).ToList(); return(new CodeCompilerResult { Success = false, Output = new List <string> (), Errors = errors }); }
private static (string outputFile, CSharpCompilationOptions compilationOptions, CSharpParseOptions parseOptions) ParseArguments(IEnumerable <string> args) { var arguments = new Dictionary <string, string>(); var compilationOptions = new CSharpCompilationOptions(OutputKind.ConsoleApplication); compilationOptions = compilationOptions.WithAssemblyIdentityComparer(DesktopAssemblyIdentityComparer.Default); string outputFile = ""; var specificDiagnosticOptions = new Dictionary <string, ReportDiagnostic>() { // Ensure that specific warnings about assembly references are always suppressed. { "CS1701", ReportDiagnostic.Suppress }, { "CS1702", ReportDiagnostic.Suppress }, { "CS1705", ReportDiagnostic.Suppress } }; compilationOptions = compilationOptions.WithSpecificDiagnosticOptions(specificDiagnosticOptions); var parseOptions = new CSharpParseOptions(); foreach (var arg in args) { var argParts = arg.Split(':'); var argument = argParts[0].Replace("+", "").Replace("/", ""); var value = ""; if (argParts.Count() > 1) { value = argParts[1]; } switch (argument) { case "target": compilationOptions = compilationOptions.WithOutputKind(ParseTarget(value)); break; case "unsafe": compilationOptions = compilationOptions.WithAllowUnsafe(true); break; case "nowarn": var warnings = value.Split(','); if (warnings.Count() > 0) { compilationOptions = compilationOptions.WithSpecificDiagnosticOptions(warnings.Select(s => new KeyValuePair <string, ReportDiagnostic>(!s.StartsWith("CS") ? $"CS{s}" : s, ReportDiagnostic.Suppress))); } break; case "define": var defines = value.Split(';'); if (defines.Count() > 0) { parseOptions = parseOptions.WithPreprocessorSymbols(defines); } break; case "optimize": compilationOptions = compilationOptions.WithOptimizationLevel(OptimizationLevel.Release); break; case "platform": compilationOptions = compilationOptions.WithPlatform(ParsePlatform(value)); break; case "out": outputFile = value; break; } } return(outputFile, compilationOptions, parseOptions); }
private static IActionResult Roslyn(string code, string responseMessage) { //Based on Josh Varty and Damir code var tree = CSharpSyntaxTree.ParseText(@" using System; namespace ConsoleApp1 { public class Program { static void Main(string[] args) { Console.WriteLine(""" + code + @"""); //Console.ReadLine(); } } } "); var assemblyPath = Path.ChangeExtension("output", "exe"); File.WriteAllText( Path.ChangeExtension(assemblyPath, "runtimeconfig.json"), GenerateRuntimeConfig() ); var dotNetCoreDir = Path.GetDirectoryName(typeof(object).GetTypeInfo().Assembly.Location); var mscorlib = MetadataReference.CreateFromFile(typeof(object).Assembly.Location); var console = MetadataReference.CreateFromFile(typeof(Console).GetTypeInfo().Assembly.Location); var myruntime = MetadataReference.CreateFromFile(Path.Combine(dotNetCoreDir, "System.Runtime.dll")); //We first have to choose what kind of output we're creating: DLL, .exe etc. var options = new CSharpCompilationOptions(OutputKind.ConsoleApplication); options = options.WithAllowUnsafe(true); //Allow unsafe code; options = options.WithOptimizationLevel(OptimizationLevel.Debug); //Set optimization level options = options.WithPlatform(Platform.X64); //Set platform var compilation = CSharpCompilation.Create("MyCompilation", syntaxTrees: new[] { tree }, references: new[] { mscorlib, console, myruntime }, options: options); //Emitting to file is available through an extension method in the Microsoft.CodeAnalysis namespace var emitResult = compilation.Emit(assemblyPath); Process process = new Process(); process.StartInfo.FileName = "dotnet"; process.StartInfo.Arguments = assemblyPath; // Note the /c command (*) //process.StartInfo.UseShellExecute = false; process.StartInfo.RedirectStandardOutput = true; process.StartInfo.RedirectStandardError = true; process.Start(); //* Read the output (or the error) string output = process.StandardOutput.ReadToEnd(); //Console.WriteLine(output); string err = process.StandardError.ReadToEnd(); //Console.WriteLine(err); process.WaitForExit(); return(new OkObjectResult(output + err)); }
protected virtual NPath CompileCSharpAssemblyWithRoslyn(CompilerOptions options) { var languageVersion = LanguageVersion.Default; var compilationOptions = new CSharpCompilationOptions( outputKind: options.OutputPath.FileName.EndsWith(".exe") ? OutputKind.ConsoleApplication : OutputKind.DynamicallyLinkedLibrary, assemblyIdentityComparer: DesktopAssemblyIdentityComparer.Default ); // Default debug info format for the current platform. DebugInformationFormat debugType = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? DebugInformationFormat.Pdb : DebugInformationFormat.PortablePdb; bool emitPdb = false; if (options.AdditionalArguments != null) { foreach (var option in options.AdditionalArguments) { switch (option) { case "/unsafe": compilationOptions = compilationOptions.WithAllowUnsafe(true); break; case "/optimize+": compilationOptions = compilationOptions.WithOptimizationLevel(OptimizationLevel.Release); break; case "/debug:full": case "/debug:pdbonly": // Use platform's default debug info. This behavior is the same as csc. emitPdb = true; break; case "/debug:portable": emitPdb = true; debugType = DebugInformationFormat.PortablePdb; break; case "/debug:embedded": emitPdb = true; debugType = DebugInformationFormat.Embedded; break; case "/langversion:7.3": languageVersion = LanguageVersion.CSharp7_3; break; } } } var parseOptions = new CSharpParseOptions(preprocessorSymbols: options.Defines, languageVersion: languageVersion); var emitOptions = new EmitOptions(debugInformationFormat: debugType); var pdbPath = (!emitPdb || debugType == DebugInformationFormat.Embedded) ? null : options.OutputPath.ChangeExtension(".pdb").ToString(); var syntaxTrees = options.SourceFiles.Select(p => CSharpSyntaxTree.ParseText( text: p.ReadAllText(), options: parseOptions ) ); var compilation = CSharpCompilation.Create( assemblyName: options.OutputPath.FileNameWithoutExtension, syntaxTrees: syntaxTrees, references: options.References.Select(r => MetadataReference.CreateFromFile(r)), options: compilationOptions ); var manifestResources = options.Resources.Select(r => { var fullPath = r.ToString(); return(new ResourceDescription( resourceName: Path.GetFileName(fullPath), dataProvider: () => new FileStream(fullPath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite), isPublic: true )); }); EmitResult result; using (var outputStream = File.Create(options.OutputPath.ToString())) using (var pdbStream = (pdbPath == null ? null : File.Create(pdbPath))) { result = compilation.Emit( peStream: outputStream, pdbStream: pdbStream, manifestResources: manifestResources, options: emitOptions ); } var errors = new StringBuilder(); if (result.Success) { return(options.OutputPath); } foreach (var diagnostic in result.Diagnostics) { errors.AppendLine(diagnostic.ToString()); } throw new Exception("Roslyn compilation errors: " + errors); }
internal RoslynGenerate() { var tree = CSharpSyntaxTree.ParseText(@" using System; namespace ConsoleApp1 { public class Program { static void Main(string[] args) { //Console.WriteLine(""); //Console.ReadLine(); } } } "); ParameterExpression value = Expression.Parameter(typeof(int), "value"); // Creating an expression to hold a local variable. ParameterExpression result = Expression.Parameter(typeof(int), "result"); // Creating a label to jump to from a loop. LabelTarget label = Expression.Label(typeof(int)); // Creating a method body. BlockExpression block = Expression.Block( // Adding a local variable. new[] { result }, // Assigning a constant to a local variable: result = 1 Expression.Assign(result, Expression.Constant(1)), // Adding a loop. Expression.Loop( // Adding a conditional block into the loop. Expression.IfThenElse( // Condition: value > 1 Expression.GreaterThan(value, Expression.Constant(1)), // If true: result *= value -- Expression.MultiplyAssign(result, Expression.PostDecrementAssign(value)), // If false, exit the loop and go to the label. Expression.Break(label, result) ), // Label to jump to. label ) ); var dotNetCoreDir = Path.GetDirectoryName(typeof(object).GetTypeInfo().Assembly.Location); var mscorlib = MetadataReference.CreateFromFile(typeof(object).Assembly.Location); var console = MetadataReference.CreateFromFile(typeof(Console).GetTypeInfo().Assembly.Location); var myruntime = MetadataReference.CreateFromFile(Path.Combine(dotNetCoreDir, "System.Runtime.dll")); var options = new CSharpCompilationOptions(OutputKind.ConsoleApplication); options = options.WithAllowUnsafe(true); options = options.WithOptimizationLevel(OptimizationLevel.Debug); options = options.WithPlatform(Platform.X64); var compilation = CSharpCompilation.Create("MyCompilation", syntaxTrees: new[] { tree }, references: new[] { mscorlib, console, myruntime }, options: options); /* * CallSiteBinder binder = new DynamicMetaObjectBinder(); * * ConstantExpression[] arguments = new[] { Expression.Constant(5), Expression.Constant(2) }; * DynamicExpression exp = Expression.Dynamic( * binder, * typeof(object), * arguments); * * var compiled = Expression.Lambda<Func<object>>(exp).Compile(); * var result = compiled(); */ }
private CompilerResults CompileWithRoslyn(List <string> filenames, List <string> sources, ICollection <Assembly> referencedAssemblies) { #if ROSLYN CompilerResults cr; CSharpCompilationOptions options = new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary); EmitOptions emitOptions = new EmitOptions(); if (includeDebugInformation) { // Embedded option doesn't seem to work // Explanation of options: https://github.com/dotnet/designs/blob/master/accepted/diagnostics/debugging-with-symbols-and-sources.md emitOptions = emitOptions.WithDebugInformationFormat(DebugInformationFormat.PortablePdb); } else { emitOptions = emitOptions.WithDebugInformationFormat(DebugInformationFormat.Embedded); } if (optimizeCode) { options = options.WithOptimizationLevel(OptimizationLevel.Release); } // If running on the Mono VM, disable all warnings in the generated // code because these are treated as errors by the Mono compiler. if (runningOnMono) { options = options.WithWarningLevel(0); } List <MetadataReference> references = new List <MetadataReference>(); foreach (Assembly assembly in referencedAssemblies) { try { references.Add(MetadataReference.CreateFromFile(assembly.Location)); } catch (NotSupportedException) { // do nothing - this assembly does not have a location e.g. it is in memory } catch (Exception e) { Console.WriteLine("Warning, could not add location for assembly: " + assembly); Console.WriteLine(e); } } // we must only add references to assemblies that are actually referenced by the code -- not all the assemblies in memory during model compilation (that could be a much larger set) SyntaxTree[] trees; if (!writeSourceFiles) { // Note: Without source files, the debugger cannot step into generated code, even if a pdb is generated. // Theoretically, it should be possible to embed the source into the pdb. trees = sources.Select(s => CSharpSyntaxTree.ParseText(s, encoding: Encoding.UTF8)).ToArray(); } else { trees = filenames.Select(fn => CSharpSyntaxTree.ParseText(File.ReadAllText(fn), null, fn, Encoding.UTF8)).ToArray(); } string targetAssemblyPath = ""; string pdbPath = ""; string targetAssemblyName; if (!generateInMemory) { targetAssemblyPath = Path.ChangeExtension(filenames[0], ".dll"); try { if (File.Exists(targetAssemblyPath)) { File.Delete(targetAssemblyPath); } } catch { for (int i = 0; ; i++) { targetAssemblyPath = Path.ChangeExtension(Path.ChangeExtension(filenames[0], null) + DateTime.Now.Millisecond, ".dll"); try { if (File.Exists(targetAssemblyPath)) { File.Delete(targetAssemblyPath); } break; } catch { } } } targetAssemblyName = Path.GetFileNameWithoutExtension(targetAssemblyPath); pdbPath = Path.ChangeExtension(targetAssemblyPath, ".pdb"); emitOptions = emitOptions.WithPdbFilePath(pdbPath); } else { targetAssemblyName = Guid.NewGuid().ToString(); // Empty names are not allowed } Compilation compilation = CSharpCompilation.Create(targetAssemblyName, trees, references, options); Assembly resultAssembly = null; EmitResult result; using (Stream assemblyStream = generateInMemory ? (Stream) new MemoryStream() : File.Create(targetAssemblyPath)) { using (Stream pdbStream = generateInMemory ? (Stream) new MemoryStream() : File.Create(pdbPath)) { if (emitOptions.DebugInformationFormat == DebugInformationFormat.Embedded) { result = compilation.Emit(assemblyStream, options: emitOptions); } else { result = compilation.Emit(assemblyStream, pdbStream, options: emitOptions); } if (result.Success) { // TODO: allow compiled assemblies to be unloaded assemblyStream.Seek(0, SeekOrigin.Begin); var asmBin = new BinaryReader(assemblyStream).ReadBytes((int)assemblyStream.Length); if (emitOptions.DebugInformationFormat == DebugInformationFormat.Embedded) { resultAssembly = Assembly.Load(asmBin); } else { pdbStream.Seek(0, SeekOrigin.Begin); var pdbBin = new BinaryReader(pdbStream).ReadBytes((int)pdbStream.Length); resultAssembly = Assembly.Load(asmBin, pdbBin); } } } } cr = new CompilerResults(resultAssembly, result.Success, result.Diagnostics.Where(d => d.Severity == DiagnosticSeverity.Error).Select(d => d.ToString()).ToList()); return(cr); #else throw new NotSupportedException("This assembly was compiled without Roslyn support. To use Roslyn, recompile with the ROSLYN compiler flag."); #endif }