public AbstractCommandHandlerTestState(
XElement workspaceElement,
ComposableCatalog extraParts = null,
bool useMinimumCatalog = false,
string workspaceKind = null)
: this(workspaceElement, GetExportProvider(useMinimumCatalog, extraParts), workspaceKind)
{
}
public async Task CreateFromTypesOmitsNonParts(PartDiscovery discovery)
{
var catalog = ComposableCatalog.Create(discovery.Resolver).AddParts(
await discovery.CreatePartsAsync(typeof(NonExportingType), typeof(ExportingType)));
Assert.Equal(1, catalog.Parts.Count);
Assert.Equal(typeof(ExportingType), catalog.Parts.Single().Type);
}
private static ComposableCatalog CreateCatalog(ImmutableArray <Assembly> assemblies)
{
var resolver = new Resolver(SimpleAssemblyLoader.Instance);
var discovery = new AttributedPartDiscovery(resolver, isNonPublicSupported: true);
var parts = Task.Run(async() => await discovery.CreatePartsAsync(assemblies).ConfigureAwait(false)).GetAwaiter().GetResult();
return(ComposableCatalog.Create(resolver).AddParts(parts));
}
public static ComposableCatalog CreateTypeCatalog(IEnumerable <Type> types)
{
// If we run CreatePartsAsync on the test thread we may deadlock since it'll schedule stuff back
// on the thread.
var parts = Task.Run(async() => await s_partDiscovery.CreatePartsAsync(types).ConfigureAwait(false)).Result;
return(ComposableCatalog.Create(parts));
}
static VisualStudioTestExportProvider()
{
PartCatalog =
TestExportProvider.EntireAssemblyCatalogWithCSharpAndVisualBasic.WithParts(
MinimalTestExportProvider.CreateAssemblyCatalog(typeof(CSharpCodeModelService).Assembly));
ExportProvider = MinimalTestExportProvider.CreateExportProvider(PartCatalog);
}
public AbstractCommandHandlerTestState(
XElement workspaceElement,
IList <Type> excludedTypes = null,
ComposableCatalog extraParts = null,
string workspaceKind = null)
: this(workspaceElement, GetExportProvider(excludedTypes, extraParts), workspaceKind)
{
}
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 static ComposableCatalog CreateAssemblyCatalog(IEnumerable <Assembly> assemblies)
{
// If we run CreatePartsAsync on the test thread we may deadlock since it'll schedule stuff back
// on the thread.
var parts = Task.Run(async() => await s_partDiscovery.CreatePartsAsync(assemblies).ConfigureAwait(false)).Result;
return(ComposableCatalog.Create(Resolver.DefaultInstance).AddParts(parts));
}
static VisualStudioTestExportProvider()
{
PartCatalog =
TestExportProvider.EntireAssemblyCatalogWithCSharpAndVisualBasic.WithParts(
MinimalTestExportProvider.CreateAssemblyCatalog(typeof(CSharpCodeModelService).Assembly));
ExportProvider = MinimalTestExportProvider.CreateExportProvider(PartCatalog);
}
private static async Task <ComposableCatalog> RegisterBasicAsync()
{
var parts = await Task.WhenAll(
RegisterDummiesAsync(),
RegisterStandardAsync(),
RegisterComplexObjectAsync());
return(parts.Aggregate(ComposableCatalog.Create(Resolver.DefaultInstance), (catalog, discoveredParts) => catalog.AddParts(discoveredParts)));
}
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));
}
/// <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);
}
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
});
}
}
/// <summary>
/// Scrambles the MVID and metadata tokens in the catalog to simulate a cache that was
/// created then invalidated due to an assembly that was recompiled, such that its MVID and metadata tokens changed.
/// This should effectively force "slow reflection" to be used automatically, and verify metadata tokens are ignored.
/// </summary>
/// <param name="catalog">The catalog to scramble.</param>
/// <returns>The scrambled catalog.</returns>
internal static ComposableCatalog SimulateRecompiledAssembly(ComposableCatalog catalog)
{
Requires.NotNull(catalog, nameof(catalog));
var scrambler = new CatalogScrambler(TestUtilities.Resolver);
var scrambledCatalog = ComposableCatalog.Create(scrambler.resolver)
.AddParts(new DiscoveredParts(catalog.Parts.Select(scrambler.Scramble), catalog.DiscoveredParts.DiscoveryErrors));
return(scrambledCatalog);
}
public static ComposableCatalog CreateTypeCatalog(IEnumerable <Type> types, Resolver resolver = null)
{
var discovery = resolver == null ? s_partDiscovery : CreatePartDiscovery(resolver);
// If we run CreatePartsAsync on the test thread we may deadlock since it'll schedule stuff back
// on the thread.
var parts = Task.Run(async() => await discovery.CreatePartsAsync(types).ConfigureAwait(false)).Result;
return(ComposableCatalog.Create(resolver ?? Resolver.DefaultInstance).AddParts(parts));
}
private async Task <Stream> SaveCatalogAsync(ComposableCatalog catalog)
{
Requires.NotNull(catalog, nameof(catalog));
var ms = new MemoryStream();
await new CachedCatalog().SaveAsync(catalog, ms);
ms.Position = 0;
return(ms);
}
internal static void SetEnabled_OnlyUseExportProviderAttributeCanCall(bool value)
{
_enabled = value;
if (!_enabled)
{
_currentExportProvider = null;
_expectedCatalog = null;
_expectedProviderForCatalog = null;
}
}
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());
}
/// <summary>
/// Creates a catalog with all the assemblies from the application .exe's directory.
/// </summary>
/// <returns>A task whose result is the <see cref="ComposableCatalog"/>.</returns>
private async Task <ComposableCatalog> CreateProductCatalogAsync()
{
var assemblyNames = GetAssemblyNames();
var assemblies = assemblyNames.Select(Assembly.LoadFrom);
var discoveredParts = await this.discoverer.CreatePartsAsync(assemblies);
var catalog = ComposableCatalog.Create(Resolver.DefaultInstance)
.AddParts(discoveredParts);
return(catalog);
}
async Task WriteMefCache(RuntimeComposition runtimeComposition, ComposableCatalog catalog, CachedComposition cacheManager)
{
using (var timer = Counters.CompositionSave.BeginTiming()) {
WriteMefCacheControl(catalog, timer);
// Serialize the MEF cache.
using (var stream = File.Open(MefCacheFile, FileMode.Create)) {
await cacheManager.SaveAsync(runtimeComposition, stream);
}
}
}
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)
{
throw new ApplicationException($"MEF catalog scanning errors encountered.\n{string.Join ("\n", discoveryErrors)}");
}
CompositionConfiguration configuration = CompositionConfiguration.Create(catalog);
if (!configuration.CompositionErrors.IsEmpty)
{
// capture the errors in an array for easier debugging
var errors = configuration.CompositionErrors.ToArray();
// 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.
//var messages = errors.SelectMany (e => e).Select (e => e.Message);
//var text = string.Join (Environment.NewLine, messages);
//Xwt.Clipboard.SetText (text);
//configuration.ThrowOnErrors ();
}
RuntimeComposition = RuntimeComposition.CreateRuntimeComposition(configuration);
ExportProviderFactory = RuntimeComposition.CreateExportProviderFactory();
ExportProvider = ExportProviderFactory.CreateExportProvider();
HostServices = MefV1HostServices.Create(ExportProvider.AsExportProvider());
ExportProviderV1 = NetFxAdapters.AsExportProvider(ExportProvider);
}
public static ComposableCatalog AddTypesFromAssembly(this ComposableCatalog composableCatalog, string assemblyName, params string[] typeNames)
{
var assembly = GetLoadedAssembly(assemblyName, AppDomain.CurrentDomain.GetAssemblies());
foreach (var typeName in typeNames)
{
var type = assembly.GetType(typeName) ?? throw new AssertFailedException($@"Type {typeName} can't be found in assembly {assemblyName}.");
composableCatalog = composableCatalog.AddType(type);
}
return(composableCatalog);
}
/// <summary>
/// Creates a <see cref="ComposableCatalog"/> derived from <paramref name="catalog"/>, but with all exported
/// parts assignable to any type in <paramref name="types"/> removed from the catalog.
/// </summary>
public static ComposableCatalog WithoutPartsOfTypes(this ComposableCatalog catalog, IEnumerable <Type> types)
{
var parts = catalog.Parts.Where(composablePartDefinition => !IsExcludedPart(composablePartDefinition));
return(ComposableCatalog.Create(Resolver.DefaultInstance).AddParts(parts));
bool IsExcludedPart(ComposablePartDefinition part)
{
return(types.Any(excludedType => excludedType.IsAssignableFrom(part.Type)));
}
}
/// <summary>
/// Creates a catalog containing the MEF parts we want to test.
/// </summary>
/// <returns>A task whose result is the <see cref="ComposableCatalog"/>.</returns>
private async Task <ComposableCatalog> CreateProductCatalogAsync()
{
IEnumerable <Assembly> assemblies = this.catalogAssemblyNames.Select(Assembly.Load);
DiscoveredParts discoveredParts = await this.discoverer.CreatePartsAsync(assemblies).ConfigureAwait(false);
ComposableCatalog catalog = ComposableCatalog.Create(Resolver.DefaultInstance)
.AddParts(discoveredParts)
.WithCompositionService();
return(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 async Task AddCatalog_MergesErrors()
{
var discovery = TestUtilities.V2Discovery;
var emptyCatalog = ComposableCatalog.Create(discovery.Resolver);
var result1 = emptyCatalog.AddParts(await discovery.CreatePartsAsync(new[] { "Foo\\DoesNotExist.dll" }));
var result2 = emptyCatalog.AddParts(await discovery.CreatePartsAsync(new[] { "Foo\\DoesNotExist2.dll" }));
var mergedCatalog = result1.AddCatalog(result2);
Assert.Equal(result1.DiscoveredParts.DiscoveryErrors.Count + result2.DiscoveredParts.DiscoveryErrors.Count, mergedCatalog.DiscoveredParts.DiscoveryErrors.Count);
Assert.NotEqual(0, mergedCatalog.DiscoveredParts.DiscoveryErrors.Count); // the test is ineffective otherwise.
}
public static ComposableCatalog CreateTypeCatalog(IEnumerable <Type> types, Resolver?resolver = null)
{
var discovery = resolver == null ? _partDiscovery : CreatePartDiscovery(resolver);
// If we run CreatePartsAsync on the test thread we may deadlock since it'll schedule stuff back
// on the thread.
#pragma warning disable VSTHRD002 // Avoid problematic synchronous waits
var parts = Task.Run(async() => await discovery.CreatePartsAsync(types).ConfigureAwait(false)).Result;
#pragma warning restore VSTHRD002 // Avoid problematic synchronous waits
return(ComposableCatalog.Create(resolver ?? Resolver.DefaultInstance).AddParts(parts));
}
public SingleExportProviderFactory(
Scope scope,
ComposableCatalog catalog,
CompositionConfiguration configuration,
IExportProviderFactory exportProviderFactory
)
{
_scope = scope;
_catalog = catalog;
_configuration = configuration;
_exportProviderFactory = exportProviderFactory;
}
public static IExportProviderFactory GetOrCreateExportProviderFactory(ComposableCatalog catalog)
{
if (catalog == s_defaultHostCatalog)
{
return(s_defaultHostExportProviderFactory);
}
else if (catalog == s_remoteHostCatalog)
{
return(s_remoteHostExportProviderFactory);
}
return(CreateExportProviderFactory(catalog));
}
private static ExportProvider GetExportProvider(bool useMinimumCatalog, ComposableCatalog extraParts)
{
var baseCatalog = useMinimumCatalog
? TestExportProvider.MinimumCatalogWithCSharpAndVisualBasic
: TestExportProvider.EntireAssemblyCatalogWithCSharpAndVisualBasic;
if (extraParts == null)
{
return(MinimalTestExportProvider.CreateExportProvider(baseCatalog));
}
return(MinimalTestExportProvider.CreateExportProvider(baseCatalog.WithParts(extraParts)));
}
public static ComposableCatalog WithParts(this ComposableCatalog @this, ComposableCatalog catalog)
{
return @this.AddParts(catalog.DiscoveredParts);
}
public static ExportProvider CreateExportProvider(ComposableCatalog catalog)
{
var configuration = CompositionConfiguration.Create(catalog.WithDesktopSupport().WithCompositionService());
var runtimeComposition = RuntimeComposition.CreateRuntimeComposition(configuration);
return runtimeComposition.CreateExportProviderFactory().CreateExportProvider();
}
