public async Task ComposableAssembliesLazyLoadedWhenQueried()
{
SkipOnMono();
var catalog = TestUtilities.EmptyCatalog.AddParts(
await TestUtilities.V2Discovery.CreatePartsAsync(typeof(ExternalExport), typeof(YetAnotherExport)));
var catalogCache = await this.SaveCatalogAsync(catalog);
var configuration = CompositionConfiguration.Create(catalog);
var compositionCache = await this.SaveConfigurationAsync(configuration);
// Use a sub-appdomain so we can monitor which assemblies get loaded by our composition engine.
var appDomain = AppDomain.CreateDomain("Composition Test sub-domain", null, AppDomain.CurrentDomain.SetupInformation);
try
{
var driver = (AppDomainTestDriver)appDomain.CreateInstanceAndUnwrap(typeof(AppDomainTestDriver).Assembly.FullName, typeof(AppDomainTestDriver).FullName);
driver.Initialize(this.cacheManager.GetType(), compositionCache, catalogCache);
driver.TestExternalExport(typeof(ExternalExport).Assembly.Location);
driver.TestYetAnotherExport(typeof(YetAnotherExport).Assembly.Location);
}
finally
{
AppDomain.Unload(appDomain);
}
}
private static IExportProviderFactory CreateRemoteHostExportProviderFactory()
{
var configuration = CompositionConfiguration.Create(ExportProviderCache.GetOrCreateAssemblyCatalog(RoslynServices.RemoteHostAssemblies).WithCompositionService());
var runtimeComposition = RuntimeComposition.CreateRuntimeComposition(configuration);
return(runtimeComposition.CreateExportProviderFactory());
}
static GenericAnalyzerTest()
{
string codeAnalysisTestVersion =
typeof(Compilation).Assembly.GetName().Version.Major switch
{
1 => "1.2.1",
2 => "2.8.2",
3 => "3.3.1",
_ => throw new InvalidOperationException("Unknown version."),
};
ReferenceAssemblies = ReferenceAssemblies.Default.AddPackages(ImmutableArray.Create(
new PackageIdentity("Microsoft.CodeAnalysis.CSharp", codeAnalysisTestVersion),
new PackageIdentity("System.ValueTuple", "4.5.0")));
ExportProviderFactory = new Lazy <IExportProviderFactory>(
() =>
{
var discovery = new AttributedPartDiscovery(Resolver.DefaultInstance, isNonPublicSupported: true);
var parts = Task.Run(() => discovery.CreatePartsAsync(MefHostServices.DefaultAssemblies)).GetAwaiter().GetResult();
var catalog = ComposableCatalog.Create(Resolver.DefaultInstance).AddParts(parts);
var configuration = CompositionConfiguration.Create(catalog);
var runtimeComposition = RuntimeComposition.CreateRuntimeComposition(configuration);
return(runtimeComposition.CreateExportProviderFactory());
},
LazyThreadSafetyMode.ExecutionAndPublication);
}
private static async Task <IContainer> CreateContainerV3Async(ComposableCatalog catalog, CompositionEngines options, ITestOutputHelper output)
{
Requires.NotNull(catalog, nameof(catalog));
Requires.NotNull(output, nameof(output));
var catalogWithCompositionService = catalog
#if DESKTOP
.WithCompositionService()
#endif
;
var configuration = CompositionConfiguration.Create(catalogWithCompositionService);
if (!options.HasFlag(CompositionEngines.V3AllowConfigurationWithErrors))
{
configuration.ThrowOnErrors();
}
#if DGML
string dgmlFile = System.IO.Path.GetTempFileName() + ".dgml";
configuration.CreateDgml().Save(dgmlFile);
output.WriteLine("DGML saved to: " + dgmlFile);
#endif
var container = await configuration.CreateContainerAsync(output);
return(new V3ContainerWrapper(container, configuration));
}
static async Task <ExportProvider> CreateExportProviderAsync(CancellationToken cancellationToken = default(CancellationToken))
{
var discovery = new AttributedPartDiscovery(Resolver.DefaultInstance);
var parts = await discovery.CreatePartsAsync(Assembly.GetExecutingAssembly(), cancellationToken);
var catalog = ComposableCatalog.Create(Resolver.DefaultInstance)
.AddParts(parts);
var composition = CompositionConfiguration.Create(catalog);
composition.CreateDgml().Save("mefgraph.dgml");
if (!composition.CompositionErrors.IsEmpty)
{
foreach (var error in composition.CompositionErrors.Peek())
{
Console.Error.WriteLine(error.Message);
foreach (var part in error.Parts)
{
Console.Error.WriteLine(" " + part.Definition.Type.FullName);
}
}
}
composition.ThrowOnErrors();
var exportProviderFactory = composition.CreateExportProviderFactory();
return(exportProviderFactory.CreateExportProvider());
}
async Task InitializeInstanceAsync()
{
ComposableCatalog catalog = ComposableCatalog.Create(StandardResolver)
.WithCompositionService()
.WithDesktopSupport();
var assemblies = new HashSet <Assembly> ();
ReadAssembliesFromAddins(assemblies, "/MonoDevelop/Ide/TypeService/PlatformMefHostServices");
ReadAssembliesFromAddins(assemblies, "/MonoDevelop/Ide/TypeService/MefHostServices");
ReadAssembliesFromAddins(assemblies, "/MonoDevelop/Ide/Composition");
// spawn discovery tasks in parallel for each assembly
var tasks = new List <Task <DiscoveredParts> > (assemblies.Count);
foreach (var assembly in assemblies)
{
var task = Task.Run(() => Discovery.CreatePartsAsync(assembly));
tasks.Add(task);
}
foreach (var task in tasks)
{
catalog = catalog.AddParts(await task);
}
var discoveryErrors = catalog.DiscoveredParts.DiscoveryErrors;
if (!discoveryErrors.IsEmpty)
{
foreach (var error in discoveryErrors)
{
LoggingService.LogInfo("MEF discovery error", error);
}
// throw new ApplicationException ("MEF discovery errors");
}
CompositionConfiguration configuration = CompositionConfiguration.Create(catalog);
if (!configuration.CompositionErrors.IsEmpty)
{
// capture the errors in an array for easier debugging
var errors = configuration.CompositionErrors.SelectMany(e => e).ToArray();
foreach (var error in errors)
{
LoggingService.LogInfo("MEF composition error: " + error.Message);
}
// For now while we're still transitioning to VSMEF it's useful to work
// even if the composition has some errors. TODO: re-enable this.
//configuration.ThrowOnErrors ();
}
RuntimeComposition = RuntimeComposition.CreateRuntimeComposition(configuration);
ExportProviderFactory = RuntimeComposition.CreateExportProviderFactory();
ExportProvider = ExportProviderFactory.CreateExportProvider();
HostServices = MefV1HostServices.Create(ExportProvider.AsExportProvider());
ExportProviderV1 = NetFxAdapters.AsExportProvider(ExportProvider);
}
public async Task CatalogGetInputAssembliesDoesNotLoadLazyExports()
{
SkipOnMono();
var catalog = TestUtilities.EmptyCatalog.AddParts(
await TestUtilities.V2Discovery.CreatePartsAsync(typeof(ExternalExportWithExternalMetadataType), typeof(ExternalExportWithExternalMetadataTypeArray), typeof(ExternalExportWithExternalMetadataEnum32)));
var catalogCache = await this.SaveCatalogAsync(catalog);
var configuration = CompositionConfiguration.Create(catalog);
var compositionCache = await this.SaveConfigurationAsync(configuration);
var appDomain = AppDomain.CreateDomain("Composition Test sub-domain", null, AppDomain.CurrentDomain.SetupInformation);
try
{
var driver = (AppDomainTestDriver)appDomain.CreateInstanceAndUnwrap(typeof(AppDomainTestDriver).Assembly.FullName, typeof(AppDomainTestDriver).FullName);
driver.Initialize(this.cacheManager.GetType(), compositionCache, catalogCache);
// GetInputAssemblies should not load the YetAnotherExport assembly or the CustomEnum assembly (both in AppDomainTests2)
driver.TestGetInputAssembliesDoesNotLoadLazyExport(typeof(YetAnotherExport).Assembly.Location);
}
finally
{
AppDomain.Unload(appDomain);
}
}
private static IExportProviderFactory CreateExportProviderFactory(ComposableCatalog catalog)
{
var configuration = CompositionConfiguration.Create(catalog);
var runtimeComposition = RuntimeComposition.CreateRuntimeComposition(configuration);
return(runtimeComposition.CreateExportProviderFactory());
}
public static ExportProvider CreateExportProvider(ComposableCatalog catalog)
{
var configuration = CompositionConfiguration.Create(catalog.WithDesktopSupport().WithCompositionService());
var runtimeComposition = RuntimeComposition.CreateRuntimeComposition(configuration);
return(runtimeComposition.CreateExportProviderFactory().CreateExportProvider());
}
public void ExceptionIsSerializable()
{
var discovery = TestUtilities.V2Discovery;
var catalog = TestUtilities.EmptyCatalog.AddParts(new[] { discovery.CreatePart(typeof(Tree)) });
var configuration = CompositionConfiguration.Create(catalog);
CompositionFailedException exception = null;
try
{
configuration.ThrowOnErrors();
Assert.True(false, "Expected exception not thrown.");
}
catch (CompositionFailedException ex)
{
exception = ex;
}
var formatter = new BinaryFormatter();
var ms = new MemoryStream();
formatter.Serialize(ms, exception);
ms.Position = 0;
var actual = (CompositionFailedException)formatter.Deserialize(ms);
Assert.Equal(exception.Message, actual.Message);
Assert.NotNull(actual.Errors);
Assert.False(actual.Errors.IsEmpty);
Assert.Equal(1, actual.Errors.Peek().Count);
Assert.Equal(exception.Errors.Peek().Single().Message, actual.Errors.Peek().Single().Message);
}
public void MissingRequiredImport()
{
var catalog = TestUtilities.EmptyCatalog.AddParts(new[] { TestUtilities.V2Discovery.CreatePart(typeof(RequiredImportMissing)) });
var configuration = CompositionConfiguration.Create(catalog);
Assert.Throws <CompositionFailedException>(() => configuration.ThrowOnErrors());
}
public void TestEmptyPartsThrowsException()
{
var configuration = CompositionConfiguration.Create(TestUtilities.EmptyCatalog);
var validComposition = RuntimeComposition.CreateRuntimeComposition(configuration);
Assert.Throws <ArgumentException>(() => RuntimeComposition.CreateRuntimeComposition(Enumerable.Empty <RuntimeComposition.RuntimePart>(), validComposition.MetadataViewsAndProviders, Resolver.DefaultInstance));
}
public async Task Initialize()
{
if (_initialized)
{
return;
}
var discovery = PartDiscovery.Combine(new AttributedPartDiscoveryV1(Resolver.DefaultInstance));
var catalog = ComposableCatalog.Create(Resolver.DefaultInstance)
.AddParts(await discovery.CreatePartsAsync(Assembly.GetExecutingAssembly()))
.AddParts(await discovery.CreatePartsAsync(Assembly.GetCallingAssembly()))
.AddParts(await discovery.CreatePartsAsync(Assembly.GetEntryAssembly()))
.AddParts(await discovery.CreatePartsAsync(_directoryCatalog.Assemblies))
.WithCompositionService(); // Makes an ICompositionService export available to MEF parts to import
// Assemble the parts into a valid graph.
var config = CompositionConfiguration.Create(catalog);
// Prepare an ExportProvider factory based on this graph.
Factory = config.CreateExportProviderFactory();
// Create an export provider, which represents a unique container of values.
ExportProvider = Factory.CreateExportProvider();
CompositionService = ExportProvider.GetExportedValue <ICompositionService>();
_initialized = true;
}
public void TestEmptyMetadataViewProviderThrowsException()
{
var configuration = CompositionConfiguration.Create(TestUtilities.EmptyCatalog);
var validComposition = RuntimeComposition.CreateRuntimeComposition(configuration);
Assert.Throws <ArgumentException>(() => RuntimeComposition.CreateRuntimeComposition(validComposition.Parts, ImmutableDictionary <TypeRef, RuntimeComposition.RuntimeExport> .Empty, Resolver.DefaultInstance));
}
internal static async Task <ExportProvider> CreateContainerAsync(ITestOutputHelper output, params Type[] parts)
{
var catalog = EmptyCatalog.AddParts(await V2Discovery.CreatePartsAsync(parts));
var configuration = await CompositionConfiguration.Create(catalog)
.CreateContainerAsync(output);
return(configuration);
}
private static IExportProviderFactory CreateExportProviderFactory(ComposableCatalog catalog)
{
var configuration = CompositionConfiguration.Create(catalog.WithCompositionService());
var runtimeComposition = RuntimeComposition.CreateRuntimeComposition(configuration);
var exportProviderFactory = runtimeComposition.CreateExportProviderFactory();
return(new SingleExportProviderFactory(catalog, exportProviderFactory));
}
public override void PrepareBasic()
{
var catalog = RegisterBasicAsync().GetAwaiter().GetResult();
this.container = CompositionConfiguration.Create(catalog)
.CreateExportProviderFactory()
.CreateExportProvider();
}
private static IFaultReportingExportProviderFactory CreateExportProviderFactory(IEnumerable <ComposablePartDefinition> parts)
{
var catalog = TestUtilities.EmptyCatalog.AddParts(parts);
var configuration = CompositionConfiguration.Create(catalog);
var runtimeComposition = RuntimeComposition.CreateRuntimeComposition(configuration);
return(runtimeComposition.CreateExportProviderFactory() as IFaultReportingExportProviderFactory);
}
/// <summary>
/// Creates a factory for <see cref="ExportProvider"/> containers with a
/// backing catalog that contains all the parts being tested.
/// </summary>
/// <returns>A task whose result is the <see cref="IExportProviderFactory"/>.</returns>
private async Task <IExportProviderFactory> CreateExportProviderFactoryAsync()
{
ComposableCatalog catalog = await this.CreateProductCatalogAsync().ConfigureAwait(false);
var configuration = CompositionConfiguration.Create(catalog);
IExportProviderFactory exportProviderFactory = configuration.CreateExportProviderFactory();
return(exportProviderFactory);
}
internal static async Task <CompositionConfiguration> CreateConfigurationAsync(CompositionEngines attributesDiscovery, params Type[] parts)
{
PartDiscovery discovery = GetDiscoveryService(attributesDiscovery);
var assemblyParts = await discovery.CreatePartsAsync(parts);
var catalog = EmptyCatalog.AddParts(assemblyParts);
return(CompositionConfiguration.Create(catalog));
}
public static IExportProviderFactory CreateExportProviderFactory(ComposableCatalog catalog, bool isRemoteHostComposition)
{
var scope = isRemoteHostComposition ? _remoteCompositionScope : _localCompositionScope;
var configuration = CompositionConfiguration.Create(catalog.WithCompositionService());
var runtimeComposition = RuntimeComposition.CreateRuntimeComposition(configuration);
var exportProviderFactory = runtimeComposition.CreateExportProviderFactory();
return(new SingleExportProviderFactory(scope, catalog, configuration, exportProviderFactory));
}
private static async Task InitializeMef()
{
// Cannot show MessageBox here, because WPF would crash with a XamlParseException
// Remember and show exceptions in text output, once MainWindow is properly initialized
try
{
// Set up VS MEF. For now, only do MEF1 part discovery, since that was in use before.
// To support both MEF1 and MEF2 parts, just change this to:
// var discovery = PartDiscovery.Combine(new AttributedPartDiscoveryV1(Resolver.DefaultInstance),
// new AttributedPartDiscovery(Resolver.DefaultInstance));
var discovery = new AttributedPartDiscoveryV1(Resolver.DefaultInstance);
var catalog = ComposableCatalog.Create(Resolver.DefaultInstance);
var pluginDir = Path.GetDirectoryName(typeof(App).Module.FullyQualifiedName);
if (pluginDir != null)
{
foreach (var plugin in Directory.GetFiles(pluginDir, "*.Plugin.dll"))
{
var name = Path.GetFileNameWithoutExtension(plugin);
try
{
var asm = Assembly.Load(name);
var parts = await discovery.CreatePartsAsync(asm);
catalog = catalog.AddParts(parts);
}
catch (Exception ex)
{
StartupExceptions.Add(new ExceptionData {
Exception = ex, PluginName = name
});
}
}
}
// Add the built-in parts
var createdParts = await discovery.CreatePartsAsync(Assembly.GetExecutingAssembly());
catalog = catalog.AddParts(createdParts);
// If/When the project switches to .NET Standard/Core, this will be needed to allow metadata interfaces (as opposed
// to metadata classes). When running on .NET Framework, it's automatic.
// catalog.WithDesktopSupport();
// If/When any part needs to import ICompositionService, this will be needed:
// catalog.WithCompositionService();
var config = CompositionConfiguration.Create(catalog);
ExportProviderFactory = config.CreateExportProviderFactory();
ExportProvider = ExportProviderFactory.CreateExportProvider();
// This throws exceptions for composition failures. Alternatively, the configuration's CompositionErrors property
// could be used to log the errors directly. Used at the end so that it does not prevent the export provider setup.
config.ThrowOnErrors();
}
catch (Exception ex)
{
StartupExceptions.Add(new ExceptionData {
Exception = ex
});
}
}
private ExportProvider CreateCompositionContainer()
{
var catalog = CachedInfo.Catalog.AddInstance(() => this);
var configuration = CompositionConfiguration.Create(catalog);
var runtimeConfiguration = RuntimeComposition.CreateRuntimeComposition(configuration);
var exportProviderFactory = runtimeConfiguration.CreateExportProviderFactory();
return(exportProviderFactory.CreateExportProvider());
}
public void TestEmptyCatalogTest()
{
var configuration = CompositionConfiguration.Create(TestUtilities.EmptyCatalog);
var composition = RuntimeComposition.CreateRuntimeComposition(configuration);
var factory = composition.CreateExportProviderFactory();
var provider = factory.CreateExportProvider();
var exports = provider.GetExports <IDisposable>();
Assert.Empty(exports);
}
public static ExportProvider CreateExportProvider(ComposableCatalog catalog)
{
// make sure we enable this for all unit tests
AsynchronousOperationListenerProvider.Enable(true);
var configuration = CompositionConfiguration.Create(catalog.WithDesktopSupport().WithCompositionService());
var runtimeComposition = RuntimeComposition.CreateRuntimeComposition(configuration);
return(runtimeComposition.CreateExportProviderFactory().CreateExportProvider());
}
public async Task ValidMultiplePaths()
{
var catalog = TestUtilities.EmptyCatalog.AddParts(await TestUtilities.V2Discovery.CreatePartsAsync(
typeof(ValidMultiplePathRoot),
typeof(ValidMultiplePathTrail1),
typeof(ValidMultiplePathTrail2),
typeof(ValidMultiplePathCommonImport)));
CompositionConfiguration.Create(catalog);
}
private static async Task <IExportProviderFactory> CreateExportProviderFactoryAsync(ImmutableArray <Assembly> assemblies)
{
var discovery = new AttributedPartDiscovery(Resolver.DefaultInstance, isNonPublicSupported: true);
var parts = await discovery.CreatePartsAsync(assemblies);
var catalog = ComposableCatalog.Create(Resolver.DefaultInstance).AddParts(parts);
var configuration = CompositionConfiguration.Create(catalog);
var runtimeComposition = RuntimeComposition.CreateRuntimeComposition(configuration);
return(runtimeComposition.CreateExportProviderFactory());
}
public override bool Execute()
{
var resolver = Resolver.DefaultInstance;
var discovery = PartDiscovery.Combine(new AttributedPartDiscoveryV1(resolver), new AttributedPartDiscovery(resolver, isNonPublicSupported: true));
this.CancellationToken.ThrowIfCancellationRequested();
var parts = discovery.CreatePartsAsync(this.CatalogAssemblies.Select(item => item.ItemSpec)).GetAwaiter().GetResult();
foreach (var error in parts.DiscoveryErrors)
{
this.Log.LogWarningFromException(error);
}
this.CancellationToken.ThrowIfCancellationRequested();
var catalog = ComposableCatalog.Create(resolver)
.AddParts(parts.Parts);
this.CancellationToken.ThrowIfCancellationRequested();
var configuration = CompositionConfiguration.Create(catalog);
if (!string.IsNullOrEmpty(this.DgmlOutputPath))
{
configuration.CreateDgml().Save(this.DgmlOutputPath);
}
this.CancellationToken.ThrowIfCancellationRequested();
if (!configuration.CompositionErrors.IsEmpty)
{
foreach (var error in configuration.CompositionErrors.Peek())
{
this.Log.LogError(error.Message);
}
return(false);
}
this.CancellationToken.ThrowIfCancellationRequested();
string cachePath = Path.GetFullPath(this.CompositionCacheFile);
this.Log.LogMessage("Producing IoC container \"{0}\"", cachePath);
using (var cacheStream = File.Open(cachePath, FileMode.Create))
{
this.CancellationToken.ThrowIfCancellationRequested();
var runtime = RuntimeComposition.CreateRuntimeComposition(configuration);
this.CancellationToken.ThrowIfCancellationRequested();
var runtimeCache = new CachedComposition();
runtimeCache.SaveAsync(runtime, cacheStream, this.CancellationToken).GetAwaiter().GetResult();
}
return(!this.Log.HasLoggedErrors);
}
public override void Prepare()
{
var simpleCatalogTask = RegisterBasicAsync();
var expandedParts = Task.WhenAll(
RegisterPropertyInjectionAsync(),
RegisterMultipleAsync()).GetAwaiter().GetResult();
var catalog = expandedParts.Aggregate(simpleCatalogTask.GetAwaiter().GetResult(), (cat, discoveredParts) => cat.AddParts(discoveredParts));
this.container = CompositionConfiguration.Create(catalog)
.CreateExportProviderFactory()
.CreateExportProvider();
}
private static ExportProvider CreateExportProvider(string applicationDataFolder)
{
var stopwatch = Stopwatch.StartNew();
var file = new FileInfo(Application.ExecutablePath);
FileInfo[] plugins =
Directory.Exists(Path.Combine(file.Directory.FullName, "Plugins"))
? new DirectoryInfo(Path.Combine(file.Directory.FullName, "Plugins")).GetFiles("*.dll")
: new FileInfo[] { };
var pluginFiles = plugins;
var cacheFile = Path.Combine(applicationDataFolder ?? "ignored", "Plugins", "composition.cache");
IExportProviderFactory exportProviderFactory;
if (applicationDataFolder != null && File.Exists(cacheFile))
{
using (var cacheStream = File.OpenRead(cacheFile))
{
exportProviderFactory = ThreadHelper.JoinableTaskFactory.Run(() => new CachedComposition().LoadExportProviderFactoryAsync(cacheStream, Resolver.DefaultInstance));
}
}
else
{
var assemblies = pluginFiles.Select(assemblyFile => TryLoadAssembly(assemblyFile)).Where(assembly => assembly != null).ToArray();
var discovery = PartDiscovery.Combine(
new AttributedPartDiscoveryV1(Resolver.DefaultInstance),
new AttributedPartDiscovery(Resolver.DefaultInstance, isNonPublicSupported: true));
var parts = ThreadHelper.JoinableTaskFactory.Run(() => discovery.CreatePartsAsync(assemblies));
var catalog = ComposableCatalog.Create(Resolver.DefaultInstance).AddParts(parts);
var configuration = CompositionConfiguration.Create(catalog.WithCompositionService());
var runtimeComposition = RuntimeComposition.CreateRuntimeComposition(configuration);
if (applicationDataFolder != null)
{
#if false // Composition caching currently disabled
Directory.CreateDirectory(Path.Combine(applicationDataFolder, "Plugins"));
using (var cacheStream = File.OpenWrite(cacheFile))
{
ThreadHelper.JoinableTaskFactory.Run(() => new CachedComposition().SaveAsync(runtimeComposition, cacheStream));
}
#endif
}
exportProviderFactory = runtimeComposition.CreateExportProviderFactory();
}
return(exportProviderFactory.CreateExportProvider());
}
