void CheckItCompiles(string code, string extension = "")
{
var assemblyName = System.IO.Path.GetRandomFileName();
var references = new MetadataReference[]
{
MetadataReference.CreateFromFile(typeof(object).Assembly.Location),
MetadataReference.CreateFromFile(typeof(Enumerable).Assembly.Location),
MetadataReference.CreateFromFile(typeof(ImmutableArray).Assembly.Location),
MetadataReference.CreateFromFile(typeof(ValueTuple <int, int>).Assembly.Location),
MetadataReference.CreateFromFile(Assembly.Load(new AssemblyName("netstandard")).Location),
MetadataReference.CreateFromFile(Assembly.Load(new AssemblyName("System.Runtime")).Location),
};
references = references.Concat(ExprCS.MetadataContext.GetReferencedPaths().Select(p => MetadataReference.CreateFromFile(p))).ToArray();
CSharpParseOptions options = new CSharpParseOptions(LanguageVersion.Latest);
var compilation = CSharpCompilation.Create(
assemblyName,
syntaxTrees: new[] {
CSharpSyntaxTree.ParseText(code, options),
CSharpSyntaxTree.ParseText(ImplicitlyIncludedCode, options),
CSharpSyntaxTree.ParseText(extension, options)
},
references: references,
options: new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
var ms = new System.IO.MemoryStream();
var result = compilation.Emit(ms);
// var errors = CSharpScript.Create<int>(code, options: ScriptOptions.Default., assemblyLoader: new InteractiveAssemblyLoader()).Compile();
Assert.True(result.Success, $"Compilation of generated code failed:\n" + string.Join("\n", result.Diagnostics) + "\n\n" + code);
}
private static IEnumerable <MetadataReference> GetAssemblyReferences()
{
var references = new MetadataReference[]
{
MetadataReference.CreateFromFile(typeof(object).GetTypeInfo().Assembly.Location),
MetadataReference.CreateFromFile(Path.Combine(typeof(object).GetTypeInfo().Assembly.Location, "..", "mscorlib.dll")),
MetadataReference.CreateFromFile(Path.Combine(typeof(object).GetTypeInfo().Assembly.Location, "..", "System.Runtime.dll")),
MetadataReference.CreateFromFile(Path.Combine(typeof(object).GetTypeInfo().Assembly.Location, "..", "System.Collections.dll")),
MetadataReference.CreateFromFile(Path.Combine(typeof(object).GetTypeInfo().Assembly.Location, "..", "System.Xml.ReaderWriter.dll")),
MetadataReference.CreateFromFile(Path.Combine(typeof(object).GetTypeInfo().Assembly.Location, "..", "System.Xml.dll")),
MetadataReference.CreateFromFile(Path.Combine(typeof(object).GetTypeInfo().Assembly.Location, "..", "System.Text.RegularExpressions.dll")),
MetadataReference.CreateFromFile(typeof(Enumerable).GetTypeInfo().Assembly.Location),
MetadataReference.CreateFromFile(typeof(XElement).GetTypeInfo().Assembly.Location),
MetadataReference.CreateFromFile(typeof(System.CodeDom.Compiler.GeneratedCodeAttribute).GetTypeInfo().Assembly.Location)
};
if (File.Exists(Path.Combine(typeof(object).GetTypeInfo().Assembly.Location, "..", "System.Private.Xml.dll")))
{
references = references
.Concat(new[] { MetadataReference.CreateFromFile(Path.Combine(typeof(object).GetTypeInfo().Assembly.Location, "..", "System.Private.Xml.dll")) })
.ToArray();
}
return(references);
}
private static CSharpCompilation CreateCompilation(string cmdLine, params CSharpSyntaxTree[] sources)
{
MetadataReference[] refs = new MetadataReference[]
{
MetadataReference.CreateFromFile(typeof(object).Assembly.Location),
MetadataReference.CreateFromFile(typeof(Enumerable).Assembly.Location)
};
var args = CSharpCommandLineParser.SplitCommandLineIntoArguments(cmdLine, false);
var cmdParser = new CSharpCommandLineParser();
var parsedArgs = cmdParser.Parse(args, ".", null);
if (sources.Contains(VulcanRuntime))
{
sources = sources.Where(s => s != VulcanRuntime).ToArray();
refs = refs.Concat(new[] { LoadVulcanRuntime() }).ToArray();
}
return(CSharpCompilation.Create(
System.IO.Path.GetRandomFileName(),
syntaxTrees: sources,
references: refs,
options: parsedArgs.CompilationOptions.WithOutputKind(OutputKind.DynamicallyLinkedLibrary)
));
}
private Compilation CompileScript(Microsoft.CodeAnalysis.SyntaxTree tree, OptimizationLevel level)
{
var references = new MetadataReference[] {
MetadataReference.CreateFromFile(typeof(Object).Assembly.Location),
MetadataReference.CreateFromFile(typeof(Console).Assembly.Location),
MetadataReference.CreateFromFile(typeof(Enumerable).Assembly.Location),
};
var all = references.Concat(GetReferences());
var usings = GetUsings();
var options = ScriptOptions.Default
.WithImports(usings)
.WithReferences(references);
var script = CSharpScript.Create(tree.ToString(), options);
var com = script.GetCompilation();
if (level == OptimizationLevel.Release)
{
SetReleaseOptimizationLevel(com);
}
return(com);
}
/// <summary>Gets a list of assembly names that are needed for compiling.</summary>
/// <param name="referencedAssemblies"></param>
/// <param name="modelName">Name of model.</param>
private IEnumerable <MetadataReference> GetReferenceAssemblies(IEnumerable <MetadataReference> referencedAssemblies, string modelName)
{
string runtimePath = Path.GetDirectoryName(typeof(object).Assembly.Location);
IEnumerable <MetadataReference> references = new MetadataReference[]
{
MetadataReference.CreateFromFile(typeof(object).Assembly.Location),
MetadataReference.CreateFromFile(Path.Join(runtimePath, "netstandard.dll")),
MetadataReference.CreateFromFile(Path.Join(runtimePath, "mscorlib.dll")),
MetadataReference.CreateFromFile(Path.Join(runtimePath, "System.dll")),
MetadataReference.CreateFromFile(Path.Join(runtimePath, "System.Collections.dll")),
MetadataReference.CreateFromFile(Path.Join(runtimePath, "System.Linq.dll")),
MetadataReference.CreateFromFile(Path.Join(runtimePath, "System.Runtime.dll")),
MetadataReference.CreateFromFile(Path.Join(runtimePath, "System.Core.dll")),
MetadataReference.CreateFromFile(Path.Join(runtimePath, "System.Data.dll")),
MetadataReference.CreateFromFile(Path.Join(runtimePath, "System.Xml.dll")),
MetadataReference.CreateFromFile(Path.Join(runtimePath, "System.Xml.ReaderWriter.dll")),
MetadataReference.CreateFromFile(Path.Join(runtimePath, "System.Private.Xml.dll")),
MetadataReference.CreateFromFile(typeof(MathUtilities).Assembly.Location),
MetadataReference.CreateFromFile(typeof(IModel).Assembly.Location),
MetadataReference.CreateFromFile(typeof(APSIM.Shared.Documentation.CodeDocumentation).Assembly.Location),
MetadataReference.CreateFromFile(typeof(MathNet.Numerics.Fit).Assembly.Location),
MetadataReference.CreateFromFile(typeof(Newtonsoft.Json.JsonIgnoreAttribute).Assembly.Location),
MetadataReference.CreateFromFile(typeof(System.Drawing.Color).Assembly.Location),
MetadataReference.CreateFromFile(typeof(System.Data.DataTable).Assembly.Location),
MetadataReference.CreateFromFile(typeof(System.ComponentModel.TypeConverter).Assembly.Location),
MetadataReference.CreateFromFile(typeof(Console).Assembly.Location),
MetadataReference.CreateFromFile(typeof(System.IO.File).Assembly.Location),
MetadataReference.CreateFromFile(typeof(System.IO.Pipes.PipeStream).Assembly.Location),
};
if (previousCompilations != null)
{
references = references.Concat(previousCompilations.Where(p => !p.ModelFullPath.Contains($".{modelName}"))
.Select(p => p.Reference));
}
if (referencedAssemblies != null)
{
references = references.Concat(referencedAssemblies);
}
return(references.Where(r => r != null));
}
/// <summary>
/// returns a collection of MetaDataReference objects needed to compile the proxy
/// this includes some standard references, the TInterface, and any types utilized by the TInterface methods
/// </summary>
/// <typeparam name="TInterface">the service contract to be used</typeparam>
/// <returns>array of MetadataReference objects</returns>
private static MetadataReference[] GetMetadataReferences <TInterface>()
{
try
{
var netstandardAsm = AppDomain.CurrentDomain.GetAssemblies().Single(a => a.GetName().Name == "netstandard");
var runtimeAsm = AppDomain.CurrentDomain.GetAssemblies().Single(a => a.GetName().Name == "System.Runtime");
var collectionsAsm = AppDomain.CurrentDomain.GetAssemblies().Single(a => a.GetName().Name == "System.Collections");
var svcModelAsm = AppDomain.CurrentDomain.GetAssemblies().Single(a => a.GetName().Name == "System.Private.ServiceModel");
// these are the standard metadata references
var standardMetadataReferences =
new MetadataReference[]
{
MetadataReference.CreateFromFile(netstandardAsm.Location),
MetadataReference.CreateFromFile(runtimeAsm.Location),
MetadataReference.CreateFromFile(collectionsAsm.Location),
MetadataReference.CreateFromFile(svcModelAsm.Location),
//MetadataReference.CreateFromFile(typeof(System.Object).Assembly.Location),
//MetadataReference.CreateFromFile(typeof(Enumerable).Assembly.Location),
// MetadataReference.CreateFromFile(typeof(ChannelFactory).Assembly.Location),
// MetadataReference.CreateFromFile(typeof(DataContractAttribute).Assembly.Location),
MetadataReference.CreateFromFile(typeof(TInterface).Assembly.Location),
};
// these are the return types (and generic descendants) used by methods on TInterface
var returnTypes =
typeof(TInterface)
.GetMethods()
.Select(mi => mi.ReturnType)
.SelectMany(GetDescendentGenericArguments);
// these are the parameter types (and generic descendants) used by methods on TInterface
var parameterTypes =
typeof(TInterface)
.GetMethods()
.SelectMany(mi => mi.GetParameters())
.Select(pi => pi.ParameterType)
.SelectMany(GetDescendentGenericArguments);
// now get the MetadataReferences for all of the above
var interfaceMetadataReferences =
returnTypes
.Concat(parameterTypes)
.Select(tp => MetadataReference.CreateFromFile(tp.Assembly.Location));
// and combine the standard and interface metadata, remove duplicates, and turn to array
return(standardMetadataReferences.Concat(interfaceMetadataReferences).Distinct().ToArray());
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
throw;
}
}
private Compilation CompileCSharp(Microsoft.CodeAnalysis.SyntaxTree tree, OptimizationLevel level)
{
var references = new MetadataReference[] {
MetadataReference.CreateFromFile(typeof(Object).Assembly.Location),
MetadataReference.CreateFromFile(typeof(Console).Assembly.Location),
};
var all = references.Concat(GetReferences());
var com = CSharpCompilation.Create(
"Hello",
syntaxTrees: new[] { tree },
references: all,
options: new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)
.WithOptimizationLevel(level)
);
return(com);
}
// a utility method that creates Roslyn compilation
// for the passed code.
// The compilation references the collection of
// passed "references" arguments plus
// the mscore library (which is required for the basic
// functionality).
private static CSharpCompilation CreateCompilationWithMscorlib
(
string assemblyOrModuleName,
string code,
CSharpCompilationOptions compilerOptions = null,
IEnumerable <MetadataReference> references = null)
{
// create the syntax tree
SyntaxTree syntaxTree = SyntaxFactory.ParseSyntaxTree(code, null, "");
// get the reference to mscore library
MetadataReference mscoreLibReference =
AssemblyMetadata
.CreateFromFile(typeof(string).Assembly.Location)
.GetReference();
// create the allReferences collection consisting of
// mscore reference and all the references passed to the method
IEnumerable <MetadataReference> allReferences =
new MetadataReference[] { mscoreLibReference };
if (references != null)
{
allReferences = allReferences.Concat(references);
}
// create and return the compilation
CSharpCompilation compilation = CSharpCompilation.Create
(
assemblyOrModuleName,
new[] { syntaxTree },
options: compilerOptions,
references: allReferences
);
return(compilation);
}
private static CSharpCompilation CreateCompilationWithMscorlib(string assemblyName, string code, CSharpCompilationOptions compilerOptions = null, IEnumerable <MetadataReference> references = null)
{
SourceText sourceText = SourceText.From(code, Encoding.UTF8);
SyntaxTree syntaxTree = SyntaxFactory.ParseSyntaxTree(sourceText, null, "");
MetadataReference mscoreLibReference = AssemblyMetadata.CreateFromFile(typeof(string).Assembly.Location).GetReference();
IEnumerable <MetadataReference> allReferences = new MetadataReference[] { mscoreLibReference };
if (references != null)
{
allReferences = allReferences.Concat(references);
}
CSharpCompilation compilation = CSharpCompilation.Create
(
assemblyName,
new[] { syntaxTree },
options: compilerOptions,
references: allReferences
);
return(compilation);
}
public void PortableLibrary()
{
var mscorlibPP7 = AssemblyMetadata.CreateFromImage(ProprietaryTestResources.NetFX.ReferenceAssemblies_PortableProfile7.mscorlib).GetReference(display: "mscorlib, PP7");
var systemRuntimePP7 = AssemblyMetadata.CreateFromImage(ProprietaryTestResources.NetFX.ReferenceAssemblies_PortableProfile7.System_Runtime).GetReference(display: "System.Runtime, PP7");
var systemRuntimeFacade = AssemblyMetadata.CreateFromImage(ProprietaryTestResources.NetFX.ReferenceAssemblies_V45_Facades.System_Runtime).GetReference(display: "System.Runtime, facade");
var plSource = @"public class C {}";
var pl = CreateCompilation(plSource, new[] { mscorlibPP7, systemRuntimePP7 });
var mainRefs = new MetadataReference[]
{
new CSharpCompilationReference(pl),
MetadataReference.CreateFromImage(ProprietaryTestResources.NetFX.ReferenceAssemblies_V45.mscorlib)
};
var mainSource = @"public class D : C { }";
// w/o facades:
var main = CreateCompilation(mainSource, mainRefs, options: TestOptions.ReleaseDll);
main.VerifyDiagnostics(
// (1,18): error CS0012: The type 'System.Object' is defined in an assembly that is not referenced. You must add a reference to assembly 'System.Runtime, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a'.
Diagnostic(ErrorCode.ERR_NoTypeDef, "C").WithArguments("System.Object", "System.Runtime, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a"));
// facade specified:
main = CreateCompilation(mainSource, mainRefs.Concat(new[] { systemRuntimeFacade }));
main.VerifyDiagnostics();
}
public void PortableLibrary()
{
var mscorlibPP7 = new MetadataImageReference(ProprietaryTestResources.NetFX.ReferenceAssemblies_PortableProfile7.mscorlib, display: "mscorlib, PP7");
var systemRuntimePP7 = new MetadataImageReference(ProprietaryTestResources.NetFX.ReferenceAssemblies_PortableProfile7.System_Runtime, display: "System.Runtime, PP7");
var plSource = @"public class C {}";
var pl = CreateCompilation(plSource, new[] { mscorlibPP7, systemRuntimePP7 });
var dir = Temp.CreateDirectory();
var mscorlibFile = dir.CreateFile("mscorlib.dll").WriteAllBytes(ProprietaryTestResources.NetFX.ReferenceAssemblies_V45.mscorlib);
var mainRefs = new MetadataReference[]
{
new CSharpCompilationReference(pl),
new MetadataFileReference(mscorlibFile.Path, MetadataReferenceProperties.Assembly)
};
var mainSource = @"public class D : C { }";
// w/o facades:
var main = CreateCompilation(mainSource, mainRefs);
main.VerifyDiagnostics(
// (1,18): error CS0012: The type 'System.Object' is defined in an assembly that is not referenced. You must add a reference to assembly 'System.Runtime, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a'.
Diagnostic(ErrorCode.ERR_NoTypeDef, "C").WithArguments("System.Object", "System.Runtime, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a"));
// empty facades directory:
main.VerifyDiagnostics(
// (1,18): error CS0012: The type 'System.Object' is defined in an assembly that is not referenced. You must add a reference to assembly 'System.Runtime, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a'.
Diagnostic(ErrorCode.ERR_NoTypeDef, "C").WithArguments("System.Object", "System.Runtime, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a"));
// System.Runtime facade present:
var facades = dir.CreateDirectory("Facades");
var systemRuntimeFacade = facades.CreateFile("System.Runtime.dll").WriteAllBytes(ProprietaryTestResources.NetFX.ReferenceAssemblies_V45_Facades.System_Runtime);
main = CreateCompilation(mainSource, mainRefs);
main.VerifyDiagnostics();
var expectedReferences = new string[]
{
"System.Runtime, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a",
pl.AssemblyName + ", Version=0.0.0.0, Culture=neutral, PublicKeyToken=null",
"mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"
};
AssertEx.Equal(expectedReferences, main.ReferencedAssemblyNames.Select(n => n.GetDisplayName()));
AssertEx.Equal(expectedReferences, main.GetBoundReferenceManager().ReferencedAssembliesMap.Values.Select(ra => ra.Symbol.Identity.GetDisplayName()));
// facade explicitly specified:
main = CreateCompilation(mainSource, mainRefs.Concat(new[] { new MetadataFileReference(systemRuntimeFacade.Path, MetadataReferenceProperties.Assembly) }));
main.VerifyDiagnostics();
}
internal static AssemblySymbol[] GetSymbolsForReferences(MetadataReference[] mrefs, Compilation[] compilations)
{
return GetSymbolsForReferences(
mrefs: mrefs.Concat(compilations.Select(c => c.ToMetadataReference())).ToArray());
}
