private MetadataReference GetMetadataReference(string assetPath)
{
var extension = Path.GetExtension(assetPath);
string path = assetPath;
if (string.IsNullOrEmpty(extension) || !ValidExtensions.Any(e => e.Equals(extension, StringComparison.OrdinalIgnoreCase)))
{
foreach (var ext in ValidExtensions)
{
path = assetPath + ext;
if (File.Exists(path))
{
break;
}
}
}
AssemblyMetadata assemblyMetadata = null;
if (!_cache.TryGetValue(path, out assemblyMetadata))
{
if (File.Exists(path))
{
using (var stream = File.OpenRead(path))
{
var moduleMetadata = ModuleMetadata.CreateFromStream(stream, PEStreamOptions.PrefetchMetadata);
assemblyMetadata = AssemblyMetadata.Create(moduleMetadata);
_cache[path] = assemblyMetadata;
}
}
}
return(assemblyMetadata?.GetReference());
}
private static CSharpCompilation InstrumentProject(CSharpCompilation compiler, AssemblyMetadata interops, Workspace workspace)
{
compiler = compiler.AddReferences(interops.GetReference());
var oldToNew = compiler.SyntaxTrees.AsParallel().WithDegreeOfParallelism(8).Where(IsNotGeneratedCode).Select(t => InstrumentTree(t, workspace));
foreach (KeyValuePair <SyntaxTree, SyntaxTree> oldAndNew in oldToNew)
{
compiler = compiler.ReplaceSyntaxTree(oldAndNew.Key, oldAndNew.Value);
Debug.Assert(oldAndNew.Value.GetText().ToString() != "{}");
}
return(compiler);
}
private static CSharpCompilation FixProject(IEnumerable <Document> documents, CSharpCompilation compiler, AssemblyMetadata interops)
{
compiler = compiler.AddReferences(interops.GetReference());
var oldToNew = documents.AsParallel().WithDegreeOfParallelism(8).Select(FixDocument);
foreach (KeyValuePair <SyntaxTree, SyntaxTree> oldAndNew in oldToNew)
{
compiler = compiler.ReplaceSyntaxTree(oldAndNew.Key, oldAndNew.Value);
Debug.Assert(oldAndNew.Value.GetText().ToString() != "{}");
}
return(compiler);
}
private static MetadataReference CreateMetadataReference(string path)
{
using (FileStream stream = File.OpenRead(path))
{
ModuleMetadata moduleMetadata = ModuleMetadata
.CreateFromStream(stream, PEStreamOptions.PrefetchMetadata);
AssemblyMetadata assemblyMetadata =
AssemblyMetadata.Create(moduleMetadata);
return(assemblyMetadata.GetReference(filePath: path));
}
}
private MemoryStream CreateAndCompileToStream(string templateSource, RazorEngineCompilationOptions options)
{
templateSource = this.WriteDirectives(templateSource, options);
RazorProjectEngine engine = RazorProjectEngine.Create(
RazorConfiguration.Default,
RazorProjectFileSystem.Create(@"."),
(builder) =>
{
builder.SetNamespace(options.TemplateNamespace);
});
string fileName = Path.GetRandomFileName();
RazorSourceDocument document = RazorSourceDocument.Create(templateSource, fileName);
RazorCodeDocument codeDocument = engine.Process(
document,
null,
new List <RazorSourceDocument>(),
new List <TagHelperDescriptor>());
RazorCSharpDocument razorCSharpDocument = codeDocument.GetCSharpDocument();
SyntaxTree syntaxTree = CSharpSyntaxTree.ParseText(razorCSharpDocument.GeneratedCode);
CSharpCompilation compilation = CSharpCompilation.Create(
fileName,
new[]
{
syntaxTree
},
options.ReferencedAssemblies
.Select(ass =>
{
#if NETSTANDARD2_0
return(MetadataReference.CreateFromFile(ass.Location));
#else
unsafe
{
ass.TryGetRawMetadata(out byte *blob, out int length);
ModuleMetadata moduleMetadata = ModuleMetadata.CreateFromMetadata((IntPtr)blob, length);
AssemblyMetadata assemblyMetadata = AssemblyMetadata.Create(moduleMetadata);
PortableExecutableReference metadataReference = assemblyMetadata.GetReference();
return(metadataReference);
}
#endif
})
.Concat(options.MetadataReferences)
.ToList(),
new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
MemoryStream memoryStream = new MemoryStream();
EmitResult emitResult = compilation.Emit(memoryStream);
if (!emitResult.Success)
{
RazorEngineCompilationException exception = new RazorEngineCompilationException()
{
Errors = emitResult.Diagnostics.ToList(),
GeneratedCode = razorCSharpDocument.GeneratedCode
};
throw exception;
}
memoryStream.Position = 0;
return(memoryStream);
}
/// <summary>
/// Use Roslyn to create an assembly.
/// </summary>
/// <param name="fn">File to compile. Also used for assembly name.</param>
/// <returns></returns>
public bool Compile(string fn)
{
CompiledAssembly = null;
Errors.Clear();
string sc = File.ReadAllText(fn);
string newAssyName = Path.GetFileNameWithoutExtension(fn);
// Assemble references.
var mr = new List <MetadataReference>();
// Remarks:
// Performance considerations:
// It is recommended to use Microsoft.CodeAnalysis.AssemblyMetadata.CreateFromFile(System.String)
// API when creating multiple references to the same assembly. Reusing Microsoft.CodeAnalysis.AssemblyMetadata
// object allows for sharing data across these references.
//var myAssy = Assembly.GetExecutingAssembly();
//var refAssys = myAssy.GetReferencedAssemblies();
// Add reference to almost everything we have loaded now.
var loadedAssemblies = AppDomain.CurrentDomain.GetAssemblies();
List <string> ignore = new List <string> {
"Dex9.exe", "Microsoft.CodeAnalysis.dll", "Microsoft.CodeAnalysis.CSharp.dll"
};
foreach (var lassy in loadedAssemblies)
{
string loc = lassy.Location;
if (ignore.TrueForAll(i => !loc.Contains(i)))
{
Debug.WriteLine(loc);
AssemblyMetadata amd = AssemblyMetadata.CreateFromFile(loc);
mr.Add(amd.GetReference());
}
}
// Parse the source.
SyntaxTree syntaxTree = CSharpSyntaxTree.ParseText(sc);
CSharpCompilationOptions opts = new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary);
CSharpCompilation compilation = CSharpCompilation.Create(newAssyName, new[] { syntaxTree }, mr, opts);
// Compile the source.
using (var memoryStream = new MemoryStream())
{
var result = compilation.Emit(memoryStream);
if (result.Success)
{
memoryStream.Seek(0, SeekOrigin.Begin);
CompiledAssembly = Assembly.Load(memoryStream.ToArray());
}
else
{
foreach (var diag in result.Diagnostics)
{
Errors.Add(FormatDiagnostic(diag, fn));
}
}
}
return(Errors.Count == 0 && CompiledAssembly != null);
}