private static void GenerateBindingRedirects(ProjectContext runtimeContext, string outputPath, LibraryExporter exporter)
{
var appConfigNames = new[] { "app.config", "App.config" };
XDocument baseAppConfig = null;
foreach (var appConfigName in appConfigNames)
{
var baseAppConfigPath = Path.Combine(runtimeContext.ProjectDirectory, appConfigName);
if (File.Exists(baseAppConfigPath))
{
using (var fileStream = File.OpenRead(baseAppConfigPath))
{
baseAppConfig = XDocument.Load(fileStream);
break;
}
}
}
var generator = new BindingRedirectGenerator();
var appConfig = generator.Generate(exporter.GetAllExports(), baseAppConfig);
if (appConfig != null)
{
var path = Path.Combine(outputPath, runtimeContext.ProjectFile.Name + ".exe.config");
using (var stream = File.Create(path))
{
appConfig.Save(stream);
}
}
}
private static void GenerateBindingRedirects(this ProjectContext context, LibraryExporter exporter, string outputPath)
{
var existingConfig = new DirectoryInfo(context.ProjectDirectory)
.EnumerateFiles()
.FirstOrDefault(f => f.Name.Equals("app.config", StringComparison.OrdinalIgnoreCase));
XDocument baseAppConfig = null;
if (existingConfig != null)
{
using (var fileStream = File.OpenRead(existingConfig.FullName))
{
baseAppConfig = XDocument.Load(fileStream);
}
}
var appConfig = exporter.GetAllExports().GenerateBindingRedirects(baseAppConfig);
if (appConfig == null)
{
return;
}
var path = Path.Combine(outputPath, context.ProjectFile.Name + ".exe.config");
using (var stream = File.Create(path))
{
appConfig.Save(stream);
}
}
public void WriteDeps(LibraryExporter exporter)
{
var path = Path.Combine(_runtimeOutputPath, _context.ProjectFile.Name + FileNameSuffixes.Deps);
CreateDirectoryIfNotExists(path);
File.WriteAllLines(path, exporter
.GetDependencies(LibraryType.Package)
.SelectMany(GenerateLines));
var compilerOptions = _context.ResolveCompilationOptions(_configuration);
var includeCompile = compilerOptions.PreserveCompilationContext == true;
var exports = exporter.GetAllExports().ToArray();
var dependencyContext = new DependencyContextBuilder().Build(
compilerOptions: includeCompile? compilerOptions: null,
compilationExports: includeCompile ? exports : null,
runtimeExports: exports,
portable: string.IsNullOrEmpty(_context.RuntimeIdentifier),
target: _context.TargetFramework,
runtime: _context.RuntimeIdentifier ?? string.Empty);
var writer = new DependencyContextWriter();
var depsJsonFile = Path.Combine(_runtimeOutputPath, _context.ProjectFile.Name + FileNameSuffixes.DepsJson);
using (var fileStream = File.Create(depsJsonFile))
{
writer.Write(dependencyContext, fileStream);
}
}
private static void EmitHost(ProjectContext runtimeContext, string outputPath, LibraryExporter exporter)
{
// Write the Host information file (basically a simplified form of the lock file)
var lines = new List <string>();
foreach (var export in exporter.GetAllExports())
{
if (export.Library == runtimeContext.RootProject)
{
continue;
}
if (export.Library is ProjectDescription)
{
// Copy project dependencies to the output folder
CopyFiles(export.RuntimeAssemblies, outputPath);
CopyFiles(export.NativeLibraries, outputPath);
}
else
{
lines.AddRange(GenerateLines(export, export.RuntimeAssemblies, "runtime"));
lines.AddRange(GenerateLines(export, export.NativeLibraries, "native"));
}
}
File.WriteAllLines(Path.Combine(outputPath, runtimeContext.ProjectFile.Name + ".deps"), lines);
// Copy the host in
CopyHost(Path.Combine(outputPath, runtimeContext.ProjectFile.Name + Constants.ExeSuffix));
}
private void GenerateBindingRedirects(LibraryExporter exporter)
{
var outputName = _outputPaths.RuntimeFiles.Assembly;
var configFile = outputName + Constants.ConfigSuffix;
var existingConfig = new DirectoryInfo(_context.ProjectDirectory)
.EnumerateFiles()
.FirstOrDefault(f => f.Name.Equals("app.config", StringComparison.OrdinalIgnoreCase));
if (existingConfig != null)
{
File.Copy(existingConfig.FullName, configFile, true);
}
List <string> configFiles = new List <string>();
configFiles.Add(configFile);
foreach (var export in exporter.GetDependencies())
{
var dependencyExecutables = export.RuntimeAssemblyGroups.GetDefaultAssets()
.Where(asset => asset.FileName.ToLower().EndsWith(FileNameSuffixes.DotNet.Exe))
.Select(asset => Path.Combine(_runtimeOutputPath, asset.FileName));
foreach (var executable in dependencyExecutables)
{
configFile = executable + Constants.ConfigSuffix;
configFiles.Add(configFile);
}
}
exporter.GetAllExports().GenerateBindingRedirects(configFiles);
}
public void GenerateBindingRedirects(LibraryExporter exporter, string configuration)
{
var outputName = _calculator.GetAssemblyPath(configuration);
var existingConfig = new DirectoryInfo(_context.ProjectDirectory)
.EnumerateFiles()
.FirstOrDefault(f => f.Name.Equals("app.config", StringComparison.OrdinalIgnoreCase));
XDocument baseAppConfig = null;
if (existingConfig != null)
{
using (var fileStream = File.OpenRead(existingConfig.FullName))
{
baseAppConfig = XDocument.Load(fileStream);
}
}
var appConfig = exporter.GetAllExports().GenerateBindingRedirects(baseAppConfig);
if (appConfig == null)
{
return;
}
var path = outputName + ".config";
using (var stream = File.Create(path))
{
appConfig.Save(stream);
}
}
public static DependencyContext FromLibraryExporter(LibraryExporter libraryExporter, string target, string runtime)
{
var dependencies = libraryExporter.GetAllExports();
return(new DependencyContext(target, runtime,
GetLibraries(dependencies, export => export.CompilationAssemblies),
GetLibraries(dependencies, export => export.RuntimeAssemblies)));
}
internal static void CopyProjectDependenciesTo(this LibraryExporter exporter, string path, params ProjectDescription[] except)
{
exporter.GetAllExports()
.Where(e => !except.Contains(e.Library))
.Where(e => e.Library is ProjectDescription)
.SelectMany(e => e.NativeLibraries.Union(e.RuntimeAssemblies))
.CopyTo(path);
}
public void LibraryExporter_TestGetAllExports()
{
_libraryExporter = new LibraryExporter(_projectContext, _applicationInfo);
var exports = _libraryExporter.GetAllExports();
Assert.True(exports.Any(), "No exports found");
Assert.True(exports.First().Library.Identity.Type.Value == "Project");
Assert.True(exports.First().Library.Identity.Name == "ModelTypesLocatorTestClassLibrary");
Assert.True(exports.Where(_ => _.Library.Identity.Name == "Microsoft.Extensions.CodeGenerators.Mvc").Any());
}
static GenFuTagHelper()
{
//TODO: Review with James. This stuff used to be wired up via DI but is not anymore.
// It was also very slow so I had to put it in a static constructor. Doing this for every tag helper instance was too slow.
var projectContext = ProjectContext.CreateContextForEachFramework(Directory.GetCurrentDirectory(), null, new[] { PlatformServices.Default.Application.RuntimeFramework.FullName }).First();
ApplicationInfo appInfo = new ApplicationInfo("TagHelperSamples.GenFu", PlatformServices.Default.Application.ApplicationBasePath);
ILibraryExporter exporter = new LibraryExporter(projectContext, appInfo);
_references = new List<MetadataReference>();
var exports = exporter.GetAllExports();
var metaDataRefs = exports.SelectMany(x => x.GetMetadataReferences()).ToList();
foreach (var reference in metaDataRefs)
{
_references.Add(reference);
}
}
private void VerifyCoreClrPresenceInPackageGraph()
{
var isCoreClrPresent = _exporter
.GetAllExports()
.SelectMany(e => e.NativeLibraryGroups)
.SelectMany(g => g.Assets)
.Select(a => a.FileName)
.Where(f => Constants.LibCoreClrBinaryNames.Contains(f))
.Any();
// coreclr should be present for standalone apps
if (!isCoreClrPresent)
{
throw new InvalidOperationException("Expected coreclr library not found in package graph. Please try running dotnet restore again.");
}
}
private void WriteDepsFileAndCopyProjectDependencies(LibraryExporter exporter)
{
// When called this way we don't need to filter exports, so we pass the same list to both.
var exports = exporter.GetAllExports().ToList();
WriteConfigurationFiles(exports, exports, includeDevConfig: true);
var projectExports = exporter.GetAllProjectTypeDependencies();
CopyAssemblies(projectExports);
CopyAssets(projectExports);
var packageExports = exporter.GetDependencies(LibraryType.Package);
CopyAssets(packageExports);
}
private void WriteRuntimeConfig(LibraryExporter exporter)
{
if (!_context.TargetFramework.IsDesktop())
{
// TODO: Suppress this file if there's nothing to write? RuntimeOutputFiles would have to be updated
// in order to prevent breaking incremental compilation...
var json = new JObject();
var runtimeOptions = new JObject();
json.Add("runtimeOptions", runtimeOptions);
var redistPackage = _context.RootProject.Dependencies
.Where(r => r.Type.Equals(LibraryDependencyType.Platform))
.ToList();
if (redistPackage.Count > 0)
{
if (redistPackage.Count > 1)
{
throw new InvalidOperationException("Multiple packages with type: \"platform\" were specified!");
}
var packageName = redistPackage.Single().Name;
var redistExport = exporter.GetAllExports()
.FirstOrDefault(e => e.Library.Identity.Name.Equals(packageName));
if (redistExport == null)
{
throw new InvalidOperationException($"Platform package '{packageName}' was not present in the graph.");
}
else
{
var framework = new JObject(
new JProperty("name", redistExport.Library.Identity.Name),
new JProperty("version", redistExport.Library.Identity.Version.ToNormalizedString()));
runtimeOptions.Add("framework", framework);
}
}
var runtimeConfigJsonFile =
Path.Combine(_runtimeOutputPath, _compilerOptions.OutputName + FileNameSuffixes.RuntimeConfigJson);
using (var writer = new JsonTextWriter(new StreamWriter(File.Create(runtimeConfigJsonFile))))
{
writer.Formatting = Formatting.Indented;
json.WriteTo(writer);
}
}
}
static GenFuTagHelper()
{
//TODO: Review with James. This stuff used to be wired up via DI but is not anymore.
// It was also very slow so I had to put it in a static constructor. Doing this for every tag helper instance was too slow.
var projectContext = ProjectContext.CreateContextForEachFramework(Directory.GetCurrentDirectory(), null, new[] { PlatformServices.Default.Application.RuntimeFramework.FullName }).First();
ApplicationInfo appInfo = new ApplicationInfo("TagHelperSamples.GenFu", PlatformServices.Default.Application.ApplicationBasePath);
ILibraryExporter exporter = new LibraryExporter(projectContext, appInfo);
_references = new List <MetadataReference>();
var exports = exporter.GetAllExports();
var metaDataRefs = exports.SelectMany(x => x.GetMetadataReferences()).ToList();
foreach (var reference in metaDataRefs)
{
_references.Add(reference);
}
}
public static DependencyContext Build(CommonCompilerOptions compilerOptions, LibraryExporter libraryExporter, string configuration, NuGetFramework target, string runtime)
{
var dependencies = libraryExporter.GetAllExports().Where(export => export.Library.Framework.Equals(target)).ToList();
// Sometimes we have package and reference assembly with the same name (System.Runtime for example) thats why we
// deduplicating them prefering reference assembly
var dependencyLookup = dependencies
.OrderBy(export => export.Library.Identity.Type == LibraryType.ReferenceAssembly)
.GroupBy(export => export.Library.Identity.Name)
.Select(exports => exports.First())
.Select(export => new Dependency(export.Library.Identity.Name, export.Library.Identity.Version.ToString()))
.ToDictionary(dependency => dependency.Name);
return(new DependencyContext(target.DotNetFrameworkName, runtime,
GetCompilationOptions(compilerOptions),
GetLibraries(dependencies, dependencyLookup, target, configuration, export => export.CompilationAssemblies),
GetLibraries(dependencies, dependencyLookup, target, configuration, export => export.RuntimeAssemblies)));
}
private void WriteDepsFileAndCopyProjectDependencies(LibraryExporter exporter)
{
var exports = exporter.GetAllExports().ToList();
var exportsLookup = exports.ToDictionary(e => e.Library.Identity.Name, StringComparer.OrdinalIgnoreCase);
var platformExclusionList = _context.GetPlatformExclusionList(exportsLookup);
var filteredExports = exports.FilterExports(platformExclusionList);
WriteConfigurationFiles(exports, filteredExports, exports, includeDevConfig: true);
var projectExports = exporter.GetAllProjectTypeDependencies();
CopyAssemblies(projectExports);
CopyAssets(projectExports);
var packageExports = exporter.GetDependencies(LibraryType.Package);
CopyAssets(packageExports);
}
public void CommonUtilities_TestGetAssemblyFromCompilation()
{
LibraryExporter exporter = new LibraryExporter(_projectContext, _applicationInfo);
LibraryManager manager = new LibraryManager(_projectContext);
IEnumerable <MetadataReference> references = exporter.GetAllExports().SelectMany(export => export.GetMetadataReferences());
string code = @"using System;
namespace Sample {
public class SampleClass
{
}
}";
Compilation compilation = GetCompilation(code, Path.GetRandomFileName(), references);
CompilationResult result = CommonUtilities.GetAssemblyFromCompilation(loadContext, compilation);
Assert.True(result.Success);
Assert.True(result.Assembly.DefinedTypes.Where(_ => _.Name == "SampleClass").Any());
}
private void ShowDependencyInformation(IReport report)
{
// Make lookup for actual package dependency assemblies
var projectExport = _libraryExporter.GetAllExports(_project.Name);
if (projectExport == null)
{
return;
}
var metadataFileRefs = projectExport.MetadataReferences
.OfType <IMetadataFileReference>();
foreach (var library in _libraryManager.GetLibraryDescriptions())
{
if (!library.Resolved)
{
if (library.Identity.Name != ImplicitRuntimePackageConstants.ImplicitRuntimePackageId)
{
report.WriteLine(" Unable to resolve dependency {0}", library.Identity.ToString().Red().Bold());
report.WriteLine();
}
continue;
}
report.WriteLine(" Using {0} dependency {1}", library.Type, library.Identity);
report.WriteLine(" Source: {0}", HighlightFile(library.Path));
if (library.Type == LibraryTypes.Package)
{
// TODO: temporarily use prefix to tell whether an assembly belongs to a package
// Should expose LibraryName from IMetadataReference later for more efficient lookup
var libraryPath = NormalizeDirectoryPath(library.Path);
var packageAssemblies = metadataFileRefs.Where(x => Path.GetFullPath(x.Path).StartsWith(libraryPath));
foreach (var assembly in packageAssemblies)
{
var relativeAssemblyPath = PathUtility.GetRelativePath(
libraryPath,
Path.GetFullPath(assembly.Path));
report.WriteLine(" File: {0}", relativeAssemblyPath.Bold());
}
}
report.WriteLine();
}
}
public void WriteDeps(LibraryExporter exporter)
{
Directory.CreateDirectory(_runtimeOutputPath);
var includeCompile = _compilerOptions.PreserveCompilationContext == true;
var exports = exporter.GetAllExports().ToArray();
var dependencyContext = new DependencyContextBuilder().Build(
compilerOptions: includeCompile ? _compilerOptions : null,
compilationExports: includeCompile ? exports : null,
runtimeExports: exports,
portable: string.IsNullOrEmpty(_context.RuntimeIdentifier),
target: _context.TargetFramework,
runtime: _context.RuntimeIdentifier ?? string.Empty);
var writer = new DependencyContextWriter();
var depsJsonFilePath = Path.Combine(_runtimeOutputPath, _compilerOptions.OutputName + FileNameSuffixes.DepsJson);
using (var fileStream = File.Create(depsJsonFilePath))
{
writer.Write(dependencyContext, fileStream);
}
}
public CompileResult Compile()
{
var result = new CompileResult();
//var assemblyPath = Path.GetDirectoryName(typeof(object).GetTypeInfo().Assembly.Location);
var assemblyName = Guid.NewGuid().ToString();
this.Source = CleanSource(this.Source);
var syntaxTrees = CSharpSyntaxTree.ParseText(this.Source);
// build references up
var references = new List <MetadataReference>();
//typeof(object).GetTypeInfo().Assembly.GetName().Name
var export = LibraryExporter.GetAllExports("GenFu.Web");
foreach (var reference in export.MetadataReferences.Where(r => r.Name == "System.Runtime"))
{
references.Add(reference.ConvertMetadataReference(MetadataReferenceExtensions.CreateAssemblyMetadata));
}
// set up compilation
var compilation = CSharpCompilation.Create(assemblyName)
.WithOptions(new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary))
.AddReferences(references)
.AddSyntaxTrees(syntaxTrees);
// build the assembly
Assembly assembly = null;
using (var stream = new MemoryStream())
{
// this is broked...
EmitResult compileResult = compilation.Emit(stream);
// we get here, with diagnostic errors (check compileResult.Diagnostics)
if (compileResult.Success)
{
stream.Position = 0;
assembly = Accessor.Default.LoadStream(stream, null);
}
else
{
result.IsValid = false;
result.Errors = compileResult.Diagnostics.Select(d => d.ToString());
}
}
if (assembly != null)
{
// iterate over the types in the assembly
var types = assembly.GetExportedTypes();
if (types.Length == 1)
{
_compiledType = types[0];
result.IsValid = true;
}
if (types.Length > 1)
{
result.IsValid = false;
result.Errors = new[] { "We currently only support a single type through this website. Install GenFu in your own project to generate data for multiple types." };
}
}
_isCompiled = result.IsValid;
return(result);
}
