protected TestContext <IAssemblyLoadContext> SetupAssemblyLoadContext()
{
var nativeUnloader = this.mockRepository.Create <INativeAssemblyUnloader>();
var pluginDependencyResolver = this.mockRepository.Create <IPluginDependencyResolver>();
var assemblyLoadStrategy = this.mockRepository.Create <IAssemblyLoadStrategy>();
var pluginDependencyContext = this.mockRepository.Create <IPluginDependencyContext>();
var resolver = this.mockRepository.Create <IAssemblyDependencyResolver>();
var fileSystemUtility = this.mockRepository.Create <IFileSystemUtilities>();
var runtimeDefaultAssemblyLoadContext = this.mockRepository.Create <IRuntimeDefaultAssemblyContext>();
var pluginDependencyContextProvider = this.mockRepository.Create <IPluginDependencyContextProvider>();
var loadContext = new DefaultAssemblyLoadContext(
() => nativeUnloader.Object,
() => pluginDependencyResolver.Object,
() => assemblyLoadStrategy.Object,
(s) => resolver.Object,
() => fileSystemUtility.Object,
() => runtimeDefaultAssemblyLoadContext.Object,
() => pluginDependencyContextProvider.Object);
return(new TestContext <IAssemblyLoadContext>(loadContext,
nativeUnloader,
pluginDependencyResolver,
assemblyLoadStrategy,
pluginDependencyContext,
resolver,
fileSystemUtility,
runtimeDefaultAssemblyLoadContext,
pluginDependencyContextProvider
));
}
public Compilation.CompilationResult Compile(string content)
{
var loader = new DefaultAssemblyLoadContext();
var projectContext = CreateProjectContext(null);
var libraryExporter = projectContext.CreateExporter("Debug");
var syntaxTrees = new[] { CSharpSyntaxTree.ParseText(content) };
var exports = libraryExporter.GetAllExports();
var references = GetMetadataReferences(exports);
var assemblyName = Path.GetRandomFileName();
var compilation = CSharpCompilation.Create(assemblyName,
options: new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary),
syntaxTrees: syntaxTrees,
references: references);
var result = CommonUtilities.GetAssemblyFromCompilation(loader, compilation);
if (result.Success)
{
var type = result.Assembly.GetExportedTypes()
.First();
return(Templating.Compilation.CompilationResult.Successful(string.Empty, type));
}
else
{
return(Templating.Compilation.CompilationResult.Failed(content, result.ErrorMessages));
}
}
public void DefaultAssemblyLoadContext_Test()
{
var assemblyName = "Microsoft.Extensions.CodeGeneration.Sources.Test";
_defaultAssemblyLoadContext = new DefaultAssemblyLoadContext();
Assembly assembly = _defaultAssemblyLoadContext.LoadFromName(new AssemblyName(assemblyName));
Assert.NotNull(assembly);
Assert.True(assembly.DefinedTypes.Where(_ => _.Name == "DefaultAssemblyLoadContextTests").Any());
}
internal async Task <int> Execute(Action <IEnumerable <FileSystemChangeInformation> > simModeAction = null)
{
var loadContext = new DefaultAssemblyLoadContext();
var codeGenAssemblyProvider = new CodeGenerationAssemblyProvider(_projectInformation, loadContext);
var componentRegistry = new ComponentRegistry(codeGenAssemblyProvider, _logger);
AddFrameworkServices(componentRegistry, _projectInformation);
AddServicesFromComponents(componentRegistry);
var codeGenCommand = componentRegistry.OfType <CodeGenCommand>();
var exitCode = await codeGenCommand.Execute(_codeGenerationContext, _codeGenArguments[0]);
return(0);
}
private ICompilationService GetCompilationService()
{
ProjectContext context = CreateProjectContext(null);
var applicationInfo = new ApplicationInfo("", context.ProjectDirectory);
ICodeGenAssemblyLoadContext loader = new DefaultAssemblyLoadContext();
IApplicationInfo _applicationInfo;
#if RELEASE
_applicationInfo = new ApplicationInfo("ModelTypesLocatorTestClassLibrary", Directory.GetCurrentDirectory(), "Release");
#else
_applicationInfo = new ApplicationInfo("ModelTypesLocatorTestClassLibrary", Directory.GetCurrentDirectory(), "Debug");
#endif
ILibraryExporter libExporter = new LibraryExporter(context, _applicationInfo);
return(new RoslynCompilationService(applicationInfo, loader, libExporter));
}
public override void Process(TagHelperContext context, TagHelperOutput output)
{
try
{
ICodeGenAssemblyLoadContext accessor = new DefaultAssemblyLoadContext();
var syntaxTrees = CSharpSyntaxTree.ParseText($"public class Fake {{ public {PropertyType.FullName} {PropertyName} {{ get; set; }} }} ");
var assemblyName = Guid.NewGuid().ToString();
var compilation = CSharpCompilation.Create(assemblyName)
.WithOptions(new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary))
.AddReferences(_references)
.AddSyntaxTrees(syntaxTrees);
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.LoadStream(stream, null);
}
}
// iterate over the types in the assembly
var types = assembly?.GetExportedTypes();
if (types?.Length == 1)
{
Type fooness = types[0];
var result = A.New(fooness);
var propValue = result.GetType().GetProperty(PropertyName).GetValue(result, null).ToString();
output.Content.SetContent(propValue);
}
}
catch (Exception ex)
{
output.Content.SetContent("Whoops");
}
}
public override void Process(TagHelperContext context, TagHelperOutput output)
{
try
{
ICodeGenAssemblyLoadContext accessor = new DefaultAssemblyLoadContext();
var syntaxTrees = CSharpSyntaxTree.ParseText($"public class Fake {{ public {PropertyType.FullName} {PropertyName} {{ get; set; }} }} ");
var assemblyName = Guid.NewGuid().ToString();
var compilation = CSharpCompilation.Create(assemblyName)
.WithOptions(new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary))
.AddReferences(_references)
.AddSyntaxTrees(syntaxTrees);
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.LoadStream(stream, null);
}
}
// iterate over the types in the assembly
var types = assembly?.GetExportedTypes();
if (types?.Length == 1)
{
Type fooness = types[0];
var result = A.New(fooness);
var propValue = result.GetType().GetProperty(PropertyName).GetValue(result, null).ToString();
output.Content.SetContent(propValue);
}
}
catch (Exception ex)
{
output.Content.SetContent("Whoops");
}
}
public void SupportFileLocationForExistingLayoutFileTest(bool leadTilde, bool leadSeparator, string[] existingLayoutFileParts, string[] expectedSupportFileLocationParts, string[] expectedLayoutFileParts)
{
string expectedSupportFileLocation;
string expectedLayoutFile;
if (expectedSupportFileLocationParts.Length > 0)
{
expectedSupportFileLocation = Path.Combine(expectedSupportFileLocationParts);
}
else
{
expectedSupportFileLocation = IdentityGeneratorTemplateModelBuilder._DefaultSupportLocation;
}
if (expectedLayoutFileParts.Length > 0)
{
expectedLayoutFile = Path.Combine(expectedLayoutFileParts);
}
else
{
expectedLayoutFile = Path.Combine(IdentityGeneratorTemplateModelBuilder._DefaultSupportLocation, IdentityGeneratorTemplateModelBuilder._LayoutFileName);
}
expectedLayoutFile = expectedLayoutFile.Replace("\\", "/");
string existingLayoutFile = string.Empty;
if (leadTilde)
{
existingLayoutFile += "~";
}
if (leadSeparator)
{
existingLayoutFile += Path.DirectorySeparatorChar;
}
if (existingLayoutFileParts.Length > 0)
{
existingLayoutFile = existingLayoutFile + Path.Combine(existingLayoutFileParts);
}
IdentityGeneratorCommandLineModel commandLineModel = new IdentityGeneratorCommandLineModel();
commandLineModel.Layout = existingLayoutFile;
IApplicationInfo applicationInfo = new ApplicationInfo("test", LayoutFileLocationTestProjectBasePath);
CommonProjectContext context = new CommonProjectContext();
context.ProjectFullPath = LayoutFileLocationTestProjectBasePath;
context.ProjectName = "TestProject";
context.AssemblyName = "TestAssembly";
context.CompilationItems = new List <string>();
context.CompilationAssemblies = new List <ResolvedReference>();
Workspace workspace = new RoslynWorkspace(context);
ICodeGenAssemblyLoadContext assemblyLoadContext = new DefaultAssemblyLoadContext();
IFileSystem mockFileSystem = new MockFileSystem();
ILogger logger = new ConsoleLogger();
IdentityGeneratorTemplateModelBuilder modelBuilder = new IdentityGeneratorTemplateModelBuilder(commandLineModel, applicationInfo, context, workspace, assemblyLoadContext, mockFileSystem, logger);
modelBuilder.DetermineSupportFileLocation(out string supportFileLocation, out string layoutFile);
Assert.Equal(expectedSupportFileLocation, supportFileLocation);
Assert.Equal(expectedLayoutFile, layoutFile);
}
