public EmitResult EmitAssembly( CSharpCompilation compilation, EmitOptions emitOptions, string assemblyPath, ResourceDescription[] resources) { EmitResult emitResult; using (var assemblyStream = new MemoryStream()) { using (var pdbStream = new MemoryStream()) { emitResult = compilation.Emit( assemblyStream, pdbStream, manifestResources: resources, options: emitOptions); if (emitResult.Success) { Directory.CreateDirectory(Path.GetDirectoryName(assemblyPath)); var pdbPath = Path.ChangeExtension(assemblyPath, ".pdb"); assemblyStream.Position = 0; pdbStream.Position = 0; // Avoid writing to disk unless the compilation is successful. using (var assemblyFileStream = File.OpenWrite(assemblyPath)) { assemblyStream.CopyTo(assemblyFileStream); } using (var pdbFileStream = File.OpenWrite(pdbPath)) { pdbStream.CopyTo(pdbFileStream); } } } } return(emitResult); }
public static void Create() { SyntaxTree syntaxTree = CSharpSyntaxTree.ParseText(@" using System; namespace RoslynCompileSample1 { public class Writer { public void Write(string message) { Console.WriteLine(message); } } public class Writer1 { public void Write(string message) { Console.WriteLine(message); } } }"); string assemblyName = Path.GetRandomFileName(); var references = AppDomain.CurrentDomain.GetAssemblies().Where(x => x.Location != "").Select(x => MetadataReference.CreateFromFile(x.Location)); CSharpCompilation compilation = CSharpCompilation.Create( assemblyName, syntaxTrees: new[] { syntaxTree }, references: references, options: new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)); using (var ms = new MemoryStream()) { EmitResult result = compilation.Emit(ms); if (result.Success) { ms.Seek(0, SeekOrigin.Begin); assembly = Assembly.Load(ms.ToArray()); } } }
/// <summary> /// Compile internal source code into memory array /// </summary> /// <param name="sourceCodes">Source codes of library</param> /// <returns>Byte array from compiled binary dll assembly</returns> private static byte[] BuildAssemblyFromSources(string[] sourceCodes) { string assemblyName = Path.GetRandomFileName(); CSharpCompilation compilation = CSharpCompilation.Create( assemblyName, syntaxTrees: sourceCodes.Select(code => CSharpSyntaxTree.ParseText(text: code)), references: new MetadataReference[] { CorlibReference, SystemCoreReference, CSharpSymbolsReference, CodeAnalysisReference, DapperReference }, options: new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)); // Emit the image of this assembly byte[] image = null; using (var ms = new MemoryStream()) { var emitResult = compilation.Emit(ms); if (!emitResult.Success) { StringBuilder diagnosticMessages = new StringBuilder(BuildFailMessage + "\r\n"); IEnumerable <Diagnostic> failures = emitResult.Diagnostics.Where(diagnostic => diagnostic.IsWarningAsError || diagnostic.Severity == DiagnosticSeverity.Error); foreach (Diagnostic diagnostic in failures) { diagnosticMessages.Append(string.Format("{0}: {1} \r\n", diagnostic.Id, diagnostic.GetMessage())); } throw new ArgumentException(diagnosticMessages.ToString()); } image = ms.ToArray(); } return(image); }
/// <summary> /// Compile the roslyn AST /// </summary> /// <returns>Either the compiled bytes of the program, or a list of error messages</returns> private static Stream CreateAssembly(CSharpCompilation compilation) { var ms = new MemoryStream(); EmitResult emmitted = compilation.Emit(ms); if (!emmitted.Success) { // create error messages var errors = emmitted.Diagnostics .Where(diagnostic => diagnostic.IsWarningAsError || diagnostic.Severity == DiagnosticSeverity.Error) .Select(diagnostic => $"{diagnostic.Id}: {diagnostic.GetMessage()}"); throw new Exception(string.Join(Environment.NewLine, errors)); } // load the program and run it ms.Seek(0, SeekOrigin.Begin); return(ms); }
/// <summary> /// Compiles code into a binary. /// </summary> /// <param name="outputPath">Output path for the compilation.</param> /// <param name="assemblyPaths">Paths to assemblies to reference.</param> /// <param name="sources">Source code to compile.</param> /// <param name="generateExecutable">Whether to generate an executable or a dynamically linked library.</param> /// <returns>Results for the compilation.</returns> public CodeCompileResults CompileSources(string outputPath, IEnumerable <string> assemblyPaths, IEnumerable <string> sources, bool generateExecutable) { var parseOptions = CSharpParseOptions.Default.WithPreprocessorSymbols(PreprocessorSymbol); IEnumerable <SyntaxTree> syntaxTrees = sources.Select(source => SyntaxFactory.ParseSyntaxTree(source, parseOptions)); IEnumerable <MetadataReference> references = assemblyPaths.Select(path => MetadataReference.CreateFromFile(path)); var compilationOptions = new CSharpCompilationOptions(generateExecutable ? OutputKind.ConsoleApplication : OutputKind.DynamicallyLinkedLibrary); CSharpCompilation compilation = CSharpCompilation.Create("NetPrintsOutput") .WithOptions(compilationOptions) .AddReferences(references) .AddSyntaxTrees(syntaxTrees); EmitResult emitResult = compilation.Emit(outputPath); IEnumerable <string> errors = emitResult.Diagnostics .Where(d => d.Severity == DiagnosticSeverity.Error) .Select(d => d.GetMessage()); return(new CodeCompileResults(emitResult.Success, errors, emitResult.Success ? outputPath : null)); }
private static Stream GetInMemoryAssemblyStreamForCode([NotNull] string code, [NotNull][ItemNotNull] params MetadataReference[] references) { SyntaxTree tree = CSharpSyntaxTree.ParseText(code); CSharpCompilation compilation = CSharpCompilation .Create("TempAssembly", new[] { tree }) .WithOptions(new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)); PortableExecutableReference msCorLib = MetadataReference.CreateFromFile(typeof(object).Assembly.Location); compilation = compilation.AddReferences(msCorLib); compilation = compilation.AddReferences(references); var stream = new MemoryStream(); EmitResult emitResult = compilation.Emit(stream); ValidateCompileErrors(emitResult); return(stream); }
private static Assembly StreamAssemblyInMemory(CSharpCompilation cSharpCompilation) { Assembly dynamicAssembly; using (var memoryStream = new MemoryStream()) { var result = cSharpCompilation.Emit(memoryStream); if (!result.Success) { string errorMessage = (string.Join(Environment.NewLine, result.Diagnostics)); throw new Exception(errorMessage); } else { memoryStream.Seek(0, SeekOrigin.Begin); dynamicAssembly = Assembly.Load(memoryStream.ToArray()); } } return(dynamicAssembly); }
/// <summary> /// 使用内存流进行脚本编译 /// </summary> /// <param name="sourceContent">脚本内容</param> /// <param name="errorAction">发生错误执行委托</param> /// <returns></returns> public (Assembly Assembly, ImmutableArray <Diagnostic> Errors, CSharpCompilation Compilation) StreamComplier() { lock (Domain) { //创建语言编译 CSharpCompilation compilation = CSharpCompilation.Create( AssemblyName, options: new CSharpCompilationOptions( outputKind: OutputKind.DynamicallyLinkedLibrary, optimizationLevel: OptimizationLevel.Release, allowUnsafe: true), syntaxTrees: SyntaxInfos.Trees, references: References); //编译并生成程序集 MemoryStream stream = new MemoryStream(); var complieResult = compilation.Emit(stream); if (complieResult.Success) { return(_domain.Handler(stream), default, compilation);
private CSharpCompilation CompileManagedClasses(CSharpCompilation compilation) { var syntaxTrees = new List <SyntaxTree>(); NativeCefApiTypes.AddFilesToSyntaxTrees(syntaxTrees, Path.Combine(_basePath, "Managed", "Types")); AddPrivateInterfaceFilesToSyntaxTrees(syntaxTrees, Path.Combine(_basePath, "Managed", "Internal")); syntaxTrees.Add(SyntaxFactory.ParseSyntaxTree(SourceText.From(File.ReadAllText(Path.Combine(_basePath, "..", "CefTypes", "CefBaseRefCounted.cs"))))); syntaxTrees.Add(SyntaxFactory.ParseSyntaxTree(SourceText.From(File.ReadAllText(Path.Combine(_basePath, "..", "CefTypes", "CefBaseScoped.cs"))))); syntaxTrees.Add(SyntaxFactory.ParseSyntaxTree(SourceText.From(File.ReadAllText(Path.Combine(_basePath, "..", "CefTypes", "CefColor.cs"))))); syntaxTrees.Add(SyntaxFactory.ParseSyntaxTree(SourceText.From(File.ReadAllText(Path.Combine(_basePath, "..", "CefTypes", "CefStringList.cs"))))); syntaxTrees.Add(SyntaxFactory.ParseSyntaxTree(SourceText.From(File.ReadAllText(Path.Combine(_basePath, "..", "CefTypes", "CefStringMap.cs"))))); syntaxTrees.Add(SyntaxFactory.ParseSyntaxTree(SourceText.From(File.ReadAllText(Path.Combine(_basePath, "..", "CefString.cs"))))); syntaxTrees.Add(SyntaxFactory.ParseSyntaxTree(SourceText.From(File.ReadAllText(Path.Combine(_basePath, "..", "CefStructure.cs"))))); syntaxTrees.Add(SyntaxFactory.ParseSyntaxTree(SourceText.From(File.ReadAllText(Path.Combine(_basePath, "..", "CefTypes", "CApi", "cef_string_t.cs"))))); syntaxTrees.Add(SyntaxFactory.ParseSyntaxTree(SourceText.From(File.ReadAllText(Path.Combine(_basePath, "..", "Unsafe", "RefCountedWrapperStruct.cs"))))); syntaxTrees.Add(SyntaxFactory.ParseSyntaxTree(SourceText.From(File.ReadAllText(Path.Combine(_basePath, "..", "Unsafe", "CefWrapperType.cs"))))); syntaxTrees.Add(SyntaxFactory.ParseSyntaxTree(SourceText.From("namespace System { static class Ext111 { public static void InitBlock(this IntPtr startAddress, byte value, int size) { } } }"))); syntaxTrees.Add(SyntaxFactory.ParseSyntaxTree(SourceText.From("using CefNet.CApi; namespace CefNet { public unsafe class CefWindowInfo { public cef_window_info_t* GetNativeInstance() { return null; } public static CefWindowInfo Wrap(cef_window_info_t* p) { return null; } } }"))); syntaxTrees.Add(SyntaxFactory.ParseSyntaxTree(SourceText.From("namespace CefNet { public class InvalidCefObjectException : System.Exception { } }"))); syntaxTrees.Add(SyntaxFactory.ParseSyntaxTree(SourceText.From("namespace CefNet { public class CefApi { public static bool UseUnsafeImplementation; } }"))); syntaxTrees.Add(SyntaxFactory.ParseSyntaxTree(SourceText.From("using CefNet.CApi; namespace CefNet { public class CefStringMultimap { cef_string_multimap_t a; public static implicit operator cef_string_multimap_t(CefStringMultimap a) { return a.a; } } }"))); compilation = compilation.AddSyntaxTrees(syntaxTrees); using (var ms = new MemoryStream()) { EmitResult emitResult = compilation.Emit(ms); if (!emitResult.Success) { foreach (var diag in emitResult.Diagnostics) { Console.WriteLine(diag); } Debugger.Break(); Environment.Exit(-1); } } return(compilation); }
private (RollbackProcessResult, EmitResult, int) TryCompilation( Stream ms, Stream symbolStream, CSharpCompilation compilation, EmitResult previousEmitResult, bool lastAttempt, bool devMode, int retryCount) { RollbackProcessResult rollbackProcessResult = null; if (previousEmitResult != null) { // remove broken mutations rollbackProcessResult = _rollbackProcess.Start(compilation, previousEmitResult.Diagnostics, lastAttempt, devMode); compilation = rollbackProcessResult.Compilation; } // reset the memoryStream ms.SetLength(0); symbolStream?.SetLength(0); _logger.LogDebug($"Trying compilation for the {ReadableNumber(retryCount)} time."); var emitOptions = symbolStream == null ? null : new EmitOptions(false, DebugInformationFormat.PortablePdb, $"{AssemblyName}.pdb"); var emitResult = compilation.Emit( ms, symbolStream, manifestResources: _input.ProjectInfo.ProjectUnderTestAnalyzerResult.Resources, win32Resources: compilation.CreateDefaultWin32Resources( true, // Important! false, null, null), options: emitOptions); LogEmitResult(emitResult); return(rollbackProcessResult, emitResult, ++retryCount); }
private static bool CreateTestApplication(string fileName) { SyntaxTree syntaxTree = CSharpSyntaxTree.ParseText(@" using System; using Microsoft.ApplicationInsights; using Microsoft.ApplicationInsights.DataContracts; using Microsoft.ApplicationInsights.Extensibility; class ActivityTest { static void Main(string[] args) { var config = new TelemetryConfiguration(); config.TelemetryInitializers.Add(new OperationCorrelationTelemetryInitializer()); var tc = new TelemetryClient(config); using (var requestOperation = tc.StartOperation<RequestTelemetry>(""request"", args[0])) { using (var dependencyOperation = tc.StartOperation<DependencyTelemetry>(""dependency"", args[0])) { Console.Write(dependencyOperation.Telemetry.Id); tc.TrackTrace(""Hello World!""); } } } }"); MetadataReference[] references = new[] { MetadataReference.CreateFromFile(typeof(object).Assembly.Location), MetadataReference.CreateFromFile(typeof(TelemetryClient).Assembly.Location) }; CSharpCompilation compilation = CSharpCompilation.Create( "ActivityTest", syntaxTrees: new[] { syntaxTree }, references: references, options: new CSharpCompilationOptions(OutputKind.ConsoleApplication)); return(compilation.Emit(fileName).Success); }
public static Assembly BuildAssembly(this CSharpCompilation compilation) { //Emit to stream var ms = new MemoryStream(); var emitResult = compilation.Emit(ms); if (!emitResult.Success) { IEnumerable <Diagnostic> failures = emitResult.Diagnostics.Where(diagnostic => diagnostic.IsWarningAsError || diagnostic.Severity == DiagnosticSeverity.Error); foreach (Diagnostic diagnostic in failures) { Console.Error.WriteLine("{0}: {1}", diagnostic.Id, diagnostic.GetMessage()); } throw new NotSupportedException($"Compilation did not succeed : {failures.Count()} errors."); } return(Assembly.Load(ms.ToArray())); }
private static Assembly CompileRoslyn(String codeToCompile) { string assemblyFileName = "gen" + Guid.NewGuid().ToString().Replace("-", "") + ".dll"; SyntaxTree syntaxTree = CSharpSyntaxTree.ParseText(codeToCompile); MetadataReference[] references = new MetadataReference[] { MetadataReference.CreateFromFile(typeof(object).Assembly.Location), //MetadataReference.CreateFromFile(Path.Combine(Path.GetDirectoryName(typeof(object).Assembly.Location), "System.dll")), }; CSharpCompilation compilation = CSharpCompilation.Create(assemblyFileName, syntaxTrees: new[] { syntaxTree }, references: references, options: new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary) ); using (var ms = new MemoryStream()) { EmitResult result = compilation.Emit(ms); if (!result.Success) { IEnumerable <Diagnostic> failures = result.Diagnostics.Where(diagnostic => diagnostic.IsWarningAsError || diagnostic.Severity == DiagnosticSeverity.Error); foreach (Diagnostic diagnostic in failures) { Console.Error.WriteLine("{0}: {1}", diagnostic.Id, diagnostic.GetMessage()); } return(null); } else { ms.Seek(0, SeekOrigin.Begin); return(Assembly.Load(ms.ToArray())); } } }
/// <summary> /// Generates an assembly from a <see cref="SyntaxTree"/> list and a /// list of <see cref="MetadataReference"/> required reference assemblies. /// <para> /// Caution: this method is not protected by the <see cref="WeakAssemblyNameResolver"/>. /// It should be done, if necessary, by the caller. /// </para> /// </summary> /// <param name="compileOptions">Compilation options.</param> /// <param name="trees">The syntax trees.</param> /// <param name="assemblyPath">The full final assembly path (including the .dll extension).</param> /// <param name="allReferences">Optional list of assemblies' references.</param> /// <param name="loader">Optional loader function to load the final emitted assembly.</param> /// <returns>Encapsulation of the result.</returns> static public GenerateResult Generate( CSharpCompilationOptions?compileOptions, IReadOnlyList <SyntaxTree> trees, string assemblyPath, IEnumerable <MetadataReference>?allReferences = null, Func <string, Assembly>?loader = null) { if (assemblyPath == null) { throw new ArgumentNullException(nameof(assemblyPath)); } try { var option = (compileOptions ?? DefaultCompilationOptions).WithAssemblyIdentityComparer(DesktopAssemblyIdentityComparer.Default); CSharpCompilation compilation = CSharpCompilation.Create( Path.GetFileNameWithoutExtension(assemblyPath), trees, allReferences, option); var r = compilation.Emit(assemblyPath); if (r.Success && loader != null) { try { return(new GenerateResult(null, trees, r, loader(assemblyPath), null, null)); } catch (Exception ex) { return(new GenerateResult(null, trees, r, null, ex, null)); } } return(new GenerateResult(null, trees, r, null, null, null)); } catch (Exception ex) { return(new GenerateResult(ex, Array.Empty <SyntaxTree>(), null, null, null, null)); } }
protected override EmitResult _Compile(string name, List <MetadataReference> references, string[] imports, string code, ref MemoryStream ms) { Info("Generating C# Code for script compilation for script element {0}", new object[] { id }); StringBuilder sbUsing = new StringBuilder(); foreach (string str in imports) { sbUsing.AppendFormat("using {0};\n", str); } string ccode = string.Format((_IsCondition ? _CODE_BASE_CONDITION_TEMPLATE : (_IsTimerEvent ? _CODE_BASE_TIMER_EVENT_TEMPLATE : _CODE_BASE_SCRIPT_TEMPLATE)), new object[] { sbUsing.ToString(), _ClassName, _FunctionName, code }); List <SyntaxTree> tress = new List <SyntaxTree>(); tress.Add(SyntaxFactory.SyntaxTree(CSharpSyntaxTree.ParseText(ccode).GetRoot())); CSharpCompilation comp = CSharpCompilation.Create(name, tress, references, new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)); return(comp.Emit(ms)); }
private void PrepareAssemblyCompileIfNecessary() { if (null != _codeAssembly) { return; } SyntaxTree syntaxTree = CSharpSyntaxTree.ParseText(CustomTypeDecoder); string assemblyName = Path.GetRandomFileName(); var refPaths = new[] { typeof(object).GetTypeInfo().Assembly.Location, typeof(Console).GetTypeInfo().Assembly.Location, Path.Combine(Path.GetDirectoryName(typeof(GCSettings).GetTypeInfo().Assembly.Location), "System.Runtime.dll") }; MetadataReference[] references = refPaths.Select(r => MetadataReference.CreateFromFile(r)).ToArray(); CSharpCompilation compilation = CSharpCompilation.Create( assemblyName, new[] { syntaxTree }, references, new CSharpCompilationOptions(outputKind: OutputKind.DynamicallyLinkedLibrary, allowUnsafe: true)); _compiledCode = new MemoryStream(); EmitResult result = compilation.Emit(_compiledCode); if (!result.Success) { foreach (var d in result.Diagnostics) { TraceLine(TraceType.Err, "Compiling customer trace renderer failed"); TraceLine(TraceType.Err, d.ToString()); TraceLine(TraceType.Err, "--------------------------------------------"); TraceLine(TraceType.Err, CustomTypeDecoder); } throw new Exception("Unable to compile type converters"); } _codeAssembly = Assembly.Load(_compiledCode.GetBuffer()); }
internal static CodeGenerationResult BuildGeneratedCode(CodeGenerationResult result, string assemblyName, MetadataReference[] references) { var st = CSharpSyntaxTree.ParseText(result.Code); var fileName = assemblyName; var options = new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary); CSharpCompilation compilation = CSharpCompilation.Create( fileName, syntaxTrees: new[] { st }, references: references, options: options); result.AssemblyBytes = new MemoryStream(); EmitResult emitted = compilation.Emit(result.AssemblyBytes); if (!emitted.Success) { result.Errors = new List <string>(); IEnumerable <Diagnostic> failures = emitted.Diagnostics.Where(diagnostic => diagnostic.IsWarningAsError || diagnostic.Severity == DiagnosticSeverity.Error); foreach (Diagnostic diagnostic in failures) { result.Errors.Add(string.Format("{0}: {1}", diagnostic.Id, diagnostic.GetMessage())); } } else { result.AssemblyBytes.Seek(0, SeekOrigin.Begin); result.Assembly = Assembly.Load(result.AssemblyBytes.ToArray()); result.AssemblyBytes.Seek(0, SeekOrigin.Begin); } result.AssemblyName = fileName + ".dll"; return(result); }
public Type[] GeneraterProxyService() { var assemblys = AppDomain.CurrentDomain.GetAssemblies().Where(o => o.IsDynamic == false); List <SyntaxTree> syntaxTrees = new List <SyntaxTree>(); var interfaces = GeneraterProxyInterface().ToList(); foreach (var interfacetype in interfaces) { syntaxTrees.AddIfNotContains(GetProxyClassSyntaxTree(interfacetype.Item1, interfacetype.Item2)); } var references = new List <PortableExecutableReference>(); foreach (var item in assemblys) { if (item.Location != "") { var reference = MetadataReference.CreateFromFile(item.Location); references.Add(reference); } } //stream.Seek(0, SeekOrigin.Begin); references.Add(MetadataReference.CreateFromFile(typeof(IService <>).GetTypeInfo().Assembly.Location)); references.Add(MetadataReference.CreateFromFile(typeof(ServiceBase <>).GetTypeInfo().Assembly.Location)); references.Add(MetadataReference.CreateFromFile(interfaces.First().Item2.GetTypeInfo().Assembly.Location)); references.Add(MetadataReference.CreateFromFile(Path.Combine(dynamicProxysPath, "InterfaceProxys.dll"))); CSharpCompilation compilation = CSharpCompilation.Create("Capgemini.Caf.ClassProxys", syntaxTrees, references, new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)); using (var ms = new MemoryStream()) { EmitResult result = compilation.Emit(Path.Combine(dynamicProxysPath, "ClassProxys.dll")); if (result.Success) { ms.Seek(0, SeekOrigin.Begin); _dynamicAssembly = assemblyLoadContext.LoadFromAssemblyPath(Path.Combine(dynamicProxysPath, "ClassProxys.dll")); return(_dynamicAssembly.GetTypes());//.ExportedTypes.ToArray(); } } return(new Type[] {}); }
public static Assembly BuildAssembly(this CSharpCompilation compilation, string filename = null) { Console.WriteLine("Compilation starting for tree"); Console.Error.WriteLine(compilation.SyntaxTrees[0].ToString()); //Emit to stream Stream stream = new MemoryStream(); if (filename != null) { stream = File.Create(filename); } var emitResult = compilation.Emit(stream); if (!emitResult.Success) { IEnumerable <Diagnostic> failures = emitResult.Diagnostics.Where(diagnostic => diagnostic.IsWarningAsError || diagnostic.Severity == DiagnosticSeverity.Error); foreach (Diagnostic diagnostic in failures) { Console.Error.WriteLine("{0}: {1}", diagnostic.Id, diagnostic.GetMessage()); } throw new NotSupportedException($"Compilation did not succeed : {failures.Count()} errors."); } Console.WriteLine("Compilation succeeded"); if (filename != null) { filename = (stream as FileStream).Name; stream.Close(); return(Assembly.LoadFile(filename)); } return(Assembly.Load((stream as MemoryStream).ToArray())); }
public DiagnosticAssembly(DiagnosticEngine engine, string assemblyName, CSharpCompilation compilation) { this.engine = engine; this.assemblyName = assemblyName; this.engine.UpdateLog($"Script compilation into assembly {assemblyName}."); this.dllStream = new MemoryStream(); this.pdbStream = new MemoryStream(); var emitResult = compilation.Emit(this.dllStream, this.pdbStream); if (!emitResult.Success) { var x = emitResult.Diagnostics; this.engine.UpdateLog($"Script compilation failed: {string.Join(Environment.NewLine, x.Select(d => d.ToString()))}."); } else { this.engine.UpdateLog("Script compilation succeeded."); this.dllStream.Seek(0, SeekOrigin.Begin); this.assembly = Assembly.Load(this.dllStream.ToArray()); this.engine.UpdateLog("Dynamic assembly loaded."); } }
private static Microsoft.CodeAnalysis.Emit.EmitResult Compile(string code, string fileName) { var roslynTree = CSharpSyntaxTree.ParseText(code); var dotnetCoreDirectory = System.Runtime.InteropServices.RuntimeEnvironment.GetRuntimeDirectory(); // Path.GetDirectoryName(typeof(System.Object).GetTypeInfo().Assembly.Location); var references = Assembly.GetExecutingAssembly().GetAllReferencesPaths().ToList(); references.Add(Path.Combine(dotnetCoreDirectory, "mscorlib.dll")); references.Add(Path.Combine(dotnetCoreDirectory, "netstandard.dll")); references.Add(Path.Combine(dotnetCoreDirectory, "System.Collections.Immutable.dll")); references.Add(Path.Combine(dotnetCoreDirectory, "System.Linq.dll")); references.Add(Path.Combine(dotnetCoreDirectory, "System.Private.Uri.dll")); references.Add(Path.Combine(dotnetCoreDirectory, "System.Private.CoreLib.dll")); references.Add(Path.Combine(dotnetCoreDirectory, "System.Runtime.dll")); references.Add(Path.Combine(dotnetCoreDirectory, "System.Runtime.Extensions.dll")); references.Add(Path.Combine(dotnetCoreDirectory, "System.Runtime.InteropServices.dll")); references.Add(Path.Combine(dotnetCoreDirectory, "System.Reflection.Metadata.dll")); var metadataReferences = references.Select(x => MetadataReference.CreateFromFile(x)).ToArray(); var options = new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary); CSharpCompilation compilation = CSharpCompilation.Create("assemblyName", new[] { roslynTree }, metadataReferences, options); return(compilation.Emit(fileName)); }
private static Assembly Compile(string migration) { string dotnetDir = Path.GetDirectoryName(typeof(object).Assembly.Location); Assert.IsNotNull(dotnetDir, "Cannot find base directory of the .NET runtime."); MetadataReference[] references = { MetadataReference.CreateFromFile(typeof(object).Assembly.Location), // System MetadataReference.CreateFromFile(typeof(Enumerable).Assembly.Location), // System.Linq MetadataReference.CreateFromFile(typeof(GeneratedCodeAttribute).Assembly.Location), MetadataReference.CreateFromFile(typeof(DbType).Assembly.Location), // System.Data MetadataReference.CreateFromFile(typeof(ExportAttribute).Assembly.Location), // System.Composition MetadataReference.CreateFromFile(typeof(IDatabase).Assembly.Location), // MigSharp MetadataReference.CreateFromFile(Path.Combine(dotnetDir, "System.Runtime.dll")), MetadataReference.CreateFromFile(Assembly.Load("netstandard, Version=2.0.0.0").Location) // see: https://stackoverflow.com/questions/46421686/how-to-write-a-roslyn-analyzer-that-references-a-dotnet-standard-2-0-project }; string assemblyName = Path.GetRandomFileName(); SyntaxTree syntaxTree = CSharpSyntaxTree.ParseText(migration); CSharpCompilation compilation = CSharpCompilation.Create(assemblyName, new[] { syntaxTree }, references, new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)); using (var ms = new MemoryStream()) { EmitResult result = compilation.Emit(ms); List <string> compilationErrors = new List <string>(); foreach (Diagnostic diagnostic in result.Diagnostics.Where(diagnostic => diagnostic.IsWarningAsError || diagnostic.Severity == DiagnosticSeverity.Error)) { compilationErrors.Add(diagnostic.Id + ": " + diagnostic.GetMessage()); } CollectionAssert.IsEmpty(compilationErrors, "Could not compile migration."); // this nicely outputs the compilation errors at the top of the output Assert.IsTrue(result.Success, "Could not compile migration."); ms.Seek(0, SeekOrigin.Begin); return(Assembly.Load(ms.ToArray())); } }
private void Compile(MemoryStream ms, SyntaxTree syntaxTree, Script script) { string assemblyName = Path.GetRandomFileName(); MetadataReference[] references = new MetadataReference[] { MetadataReference.CreateFromFile(typeof(object).Assembly.Location), MetadataReference.CreateFromFile(typeof(Enumerable).Assembly.Location) }; CSharpCompilation compilation = CSharpCompilation.Create( assemblyName, syntaxTrees: new[] { syntaxTree }, references: references, options: new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)); Console.WriteLine("Compiling..."); Stopwatch stopWatch = new Stopwatch(); stopWatch.Start(); EmitResult result = compilation.Emit(ms); stopWatch.Stop(); Console.WriteLine("Compile complete. (" + stopWatch.ElapsedMilliseconds + "ms)"); script.LastCompilationTime = DateTime.UtcNow; if (!result.Success) { script.AbortProcessing = true; IEnumerable <Diagnostic> failures = result.Diagnostics.Where(diagnostic => diagnostic.IsWarningAsError || diagnostic.Severity == DiagnosticSeverity.Error); foreach (Diagnostic diagnostic in failures) { Console.Error.WriteLine("{0}: {1}", diagnostic.Id, diagnostic.GetMessage()); } } }
private void Save() { if (Options.FullCompile) { var bindingsAssemblyPath = bindingCompiler.OutputFileName; bindingCompiler.SaveAssembly(); Program.WriteInfo("bindings saved to " + bindingsAssemblyPath); compilation = compilation.AddReferences(MetadataReference.CreateFromFile(Path.GetFullPath(bindingsAssemblyPath))); var compiledViewsFileName = Path.Combine(Options.OutputPath, Options.AssemblyName + ".dll"); //Directory.CreateDirectory("outputCS"); //int i = 0; //foreach (var tree in compilation.SyntaxTrees) //{ // File.WriteAllText($"outputCS/file{i++}.cs", tree.GetRoot().NormalizeWhitespace().ToString()); //} var result = compilation.Emit(compiledViewsFileName); if (!result.Success) { throw new Exception("compilation failed"); } Program.WriteInfo("views saved to " + compiledViewsFileName); } }
private static ContractCompilationResult Compile(IEnumerable <SyntaxTree> syntaxTrees) { // @TODO - Use OptimizationLevel.Release once we switch to injecting compiler options CSharpCompilation compilation = CSharpCompilation.Create( AssemblyName, syntaxTrees, GetReferences(), new CSharpCompilationOptions( OutputKind.DynamicallyLinkedLibrary, checkOverflow: true)); using (var dllStream = new MemoryStream()) { EmitResult emitResult = compilation.Emit(dllStream); if (!emitResult.Success) { return(ContractCompilationResult.Failed(emitResult.Diagnostics)); } return(ContractCompilationResult.Succeeded(dllStream.ToArray())); } }
private void CompileSourceCode() { SyntaxTree tree = CSharpSyntaxTree.ParseText(sourceCode, new CSharpParseOptions(LanguageVersion.CSharp5)); IEnumerable <MetadataReference> assemblyReferences = references.Select(x => MetadataReference.CreateFromFile(x.Location)); CSharpCompilation compilation = CSharpCompilation.Create(outputAssemblyFileName, options: new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary), syntaxTrees: new[] { tree }, references: assemblyReferences); ImmutableArray <Diagnostic> compilerDiagnostics = compilation.GetDiagnostics(CancellationToken.None); ValidateCompilerDiagnostics(compilerDiagnostics); using (FileStream assemblyStream = File.Create(outputAssemblyFileName)) { EmitResult compileResult = compilation.Emit(assemblyStream); Assert.True(compileResult.Success, string.Format("Test Assembly Generation failed due to: {0}\r\n\r\nin:\r\n{1}", string.Join("\r\n", compileResult.Diagnostics), sourceCode)); } }
public static void Compile() { string source = ""; string assembly = "test.exe"; var syntaxTree = CSharpSyntaxTree.ParseText(source); CSharpCompilation compilation = CSharpCompilation.Create( assembly, new[] { syntaxTree }, new[] { MetadataReference.CreateFromFile(typeof(object).Assembly.Location) }, new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)); using (var dllStream = new MemoryStream()) using (var pdbStream = new MemoryStream()) { var emitResult = compilation.Emit(dllStream, pdbStream); if (!emitResult.Success) { // emitResult.Diagnostics } } }
private static byte[] CompileAssembly(CSharpCompilation compiler) { byte[] instrumentedAssembly; MemoryStream stream = new MemoryStream(); EmitResult result = compiler.Emit(stream); if (IsMarginalSuccess(result)) { instrumentedAssembly = stream.ToArray(); } else { string errors = ""; foreach (var resultDiagnostic in result.Diagnostics) { errors += resultDiagnostic.ToString(); errors += "\r\n"; } throw new Exception("Failed to instrument " + compiler.AssemblyName + ": " + errors); } return(instrumentedAssembly); }
private EmitResult EmitAssembly( CSharpCompilation compilation, string assemblyPath, ResourceDescription[] resources) { Directory.CreateDirectory(Path.GetDirectoryName(assemblyPath)); EmitResult emitResult; using (var assemblyStream = File.OpenWrite(assemblyPath)) { using (var pdbStream = File.OpenWrite(Path.ChangeExtension(assemblyPath, ".pdb"))) { emitResult = compilation.Emit( assemblyStream, pdbStream, manifestResources: resources, options: MvcServiceProvider.Compiler.EmitOptions); } } return(emitResult); }
private static Assembly Compile(SyntaxTree syntaxTree) { string assemblyName = "HotChocolate.Resolvers.CodeGeneration" + $"._{Guid.NewGuid().ToString("N")}.dll"; CSharpCompilation compilation = CSharpCompilation.Create( assemblyName, new SyntaxTree[] { syntaxTree }, ResolveReferences(), _options); using (MemoryStream stream = new MemoryStream()) { EmitResult result = compilation.Emit(stream); if (result.Success) { stream.Position = 0; return(Assembly.Load(stream.ToArray())); } // TODO : EXCEPTION throw new Exception(string.Join(Environment.NewLine, result.Diagnostics.Select(t => t.ToString()))); } }
internal void VerifyAssemblyTable( CSharpCompilation compilation, Action<AssemblyDefinition> verifier, string strData = null, byte[] blobData = null, Guid guidData = default(Guid), string uddData = null) { var stream = new MemoryStream(); Assert.True(compilation.Emit(stream).Success); stream.Position = 0; using (var metadata = ModuleMetadata.CreateFromImageStream(stream)) { var peReader = metadata.MetadataReader; AssemblyDefinition row = peReader.GetAssemblyDefinition(); if (verifier != null) verifier(row); // Locale // temp if (strData != null) { Assert.Equal(strData, peReader.GetString(row.Culture)); } // PublicKey //Assert.Equal((uint)0, row.PublicKey); } }
// In VB use AssertTheseErrors format for expected diagnostics! private static void VerifyEmitDiagnostics( CSharpCompilation compilation, bool metadataOnlyShouldSucceed, DiagnosticDescription[] expectedFullBuildDiagnostics, DiagnosticDescription[] expectedMetadataOnlyDiagnostics = null) { using (var executableStream = new MemoryStream()) { var result = compilation.Emit(executableStream); Assert.False(result.Success); result.Diagnostics.Verify(expectedFullBuildDiagnostics); } using (var executableStream = new MemoryStream()) { var result = compilation.Emit(executableStream, options: new EmitOptions(metadataOnly: true)); if (metadataOnlyShouldSucceed) { Assert.True(result.Success); result.Diagnostics.Verify(); } else { Assert.False(result.Success); result.Diagnostics.Verify(expectedMetadataOnlyDiagnostics ?? expectedFullBuildDiagnostics); } } }