public static ExportProvider CreateExportProvider(ComposableCatalog catalog)
{
var configuration = CompositionConfiguration.Create(catalog.WithDesktopSupport().WithCompositionService());
var runtimeComposition = RuntimeComposition.CreateRuntimeComposition(configuration);
return(runtimeComposition.CreateExportProviderFactory().CreateExportProvider());
}
async Task InitializeInstanceAsync()
{
var assemblies = ReadAssembliesFromAddins();
var caching = new Caching(assemblies);
// Try to use cached MEF data
if (cacheEnabled && caching.CanUse())
{
RuntimeComposition = await TryCreateRuntimeCompositionFromCache(caching);
}
// Otherwise fallback to runtime discovery.
if (RuntimeComposition == null)
{
RuntimeComposition = await CreateRuntimeCompositionFromDiscovery(caching);
CachedComposition cacheManager = new CachedComposition();
caching.Write(RuntimeComposition, cacheManager).Ignore();
}
ExportProviderFactory = RuntimeComposition.CreateExportProviderFactory();
ExportProvider = ExportProviderFactory.CreateExportProvider();
HostServices = MefV1HostServices.Create(ExportProvider.AsExportProvider());
ExportProviderV1 = NetFxAdapters.AsExportProvider(ExportProvider);
}
private static IExportProviderFactory CreateRemoteHostExportProviderFactory()
{
var configuration = CompositionConfiguration.Create(ExportProviderCache.GetOrCreateAssemblyCatalog(RoslynServices.RemoteHostAssemblies).WithCompositionService());
var runtimeComposition = RuntimeComposition.CreateRuntimeComposition(configuration);
return(runtimeComposition.CreateExportProviderFactory());
}
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));
}
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);
}
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));
}
private static IExportProviderFactory CreateExportProviderFactory(ComposableCatalog catalog)
{
var configuration = CompositionConfiguration.Create(catalog);
var runtimeComposition = RuntimeComposition.CreateRuntimeComposition(configuration);
return(runtimeComposition.CreateExportProviderFactory());
}
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);
}
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);
}
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 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));
}
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());
}
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());
}
async Task WriteMefCache(RuntimeComposition runtimeComposition, CachedComposition cacheManager)
{
using (var timer = Counters.CompositionSave.BeginTiming()) {
WriteMefCacheControl(timer);
// Serialize the MEF cache.
using (var stream = File.Open(MefCacheFile, FileMode.Create)) {
await cacheManager.SaveAsync(runtimeComposition, stream);
}
}
}
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);
}
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());
}
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());
}
async Task InitializeInstanceAsync()
{
var timings = new Dictionary <string, long> ();
var metadata = new CompositionLoadMetadata(timings);
using (var timer = Counters.CompositionLoad.BeginTiming(metadata)) {
var fullTimer = System.Diagnostics.Stopwatch.StartNew();
var stepTimer = System.Diagnostics.Stopwatch.StartNew();
var mefAssemblies = ReadAssembliesFromAddins(timer);
timings ["ReadFromAddins"] = stepTimer.ElapsedMilliseconds;
stepTimer.Restart();
var caching = new Caching(mefAssemblies);
// Try to use cached MEF data
var canUse = metadata.ValidCache = caching.CanUse();
if (canUse)
{
LoggingService.LogInfo("Creating MEF composition from cache");
RuntimeComposition = await TryCreateRuntimeCompositionFromCache(caching);
}
timings ["LoadFromCache"] = stepTimer.ElapsedMilliseconds;
stepTimer.Restart();
// Otherwise fallback to runtime discovery.
if (RuntimeComposition == null)
{
LoggingService.LogInfo("Creating MEF composition from runtime");
var(runtimeComposition, catalog) = await CreateRuntimeCompositionFromDiscovery(caching, timer);
RuntimeComposition = runtimeComposition;
CachedComposition cacheManager = new CachedComposition();
caching.Write(RuntimeComposition, catalog, cacheManager).Ignore();
}
timings ["LoadRuntimeComposition"] = stepTimer.ElapsedMilliseconds;
stepTimer.Restart();
ExportProviderFactory = RuntimeComposition.CreateExportProviderFactory();
ExportProvider = ExportProviderFactory.CreateExportProvider();
HostServices = MefV1HostServices.Create(ExportProvider.AsExportProvider());
ExportProviderV1 = NetFxAdapters.AsExportProvider(ExportProvider);
timings ["CreateServices"] = stepTimer.ElapsedMilliseconds;
metadata.Duration = fullTimer.ElapsedMilliseconds;
}
}
static CodeFixProviderDiscovery()
{
_exportProviderFactory = new Lazy <IExportProviderFactory>(
() =>
{
var discovery = new AttributedPartDiscovery(Resolver.DefaultInstance, isNonPublicSupported: true);
var parts = Task.Run(() => discovery.CreatePartsAsync(typeof(SystemConsoleToAnsiConsoleFix).Assembly)).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);
}
static AbstractFormatterTest()
{
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);
}
internal static async Task <(RuntimeComposition, ComposableCatalog)> CreateRuntimeCompositionFromDiscovery(Caching caching, ITimeTracker timer = null)
{
var parts = await Discovery.CreatePartsAsync(caching.MefAssemblies);
timer?.Trace("Composition parts discovered");
ComposableCatalog catalog = ComposableCatalog.Create(StandardResolver)
.WithCompositionService()
.AddParts(parts);
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 ();
}
timer?.Trace("Composition configured");
var runtimeComposition = RuntimeComposition.CreateRuntimeComposition(configuration);
timer?.Trace("Composition created");
return(runtimeComposition, catalog);
}
/// <inheritdoc cref="Microsoft.CodeAnalysis.Testing.AnalyzerTest{IVerifier}"/>>
static DiagnosticAnalyzerRunner()
{
ExportProviderFactory = new Lazy <IExportProviderFactory>(
() =>
{
var discovery = new AttributedPartDiscovery(Resolver.DefaultInstance, true);
var parts = Task.Run(() => discovery.CreatePartsAsync(MefHostServices.DefaultAssemblies))
.GetAwaiter().GetResult();
var catalog = ComposableCatalog.Create(Resolver.DefaultInstance).AddParts(parts)
.WithDocumentTextDifferencingService();
var configuration = CompositionConfiguration.Create(catalog);
var runtimeComposition = RuntimeComposition.CreateRuntimeComposition(configuration);
return(runtimeComposition.CreateExportProviderFactory());
},
LazyThreadSafetyMode.ExecutionAndPublication
);
}
internal Task Write(RuntimeComposition runtimeComposition, CachedComposition cacheManager)
{
return(Runtime.RunInMainThread(async() => {
IdeApp.Exiting += IdeApp_Exiting;
saveTask = Task.Run(async() => {
try {
await WriteMefCache(runtimeComposition, cacheManager);
} catch (Exception ex) {
LoggingService.LogError("Failed to write MEF cache", ex);
}
});
await saveTask;
IdeApp.Exiting -= IdeApp_Exiting;
saveTask = null;
}));
}
internal Task Write(RuntimeComposition runtimeComposition, ComposableCatalog catalog, CachedComposition cacheManager)
{
return(Runtime.RunInMainThread(async() => {
IdeApp.Exiting += IdeApp_Exiting;
saveTask = Task.Run(async() => {
try {
await WriteMefCache(runtimeComposition, catalog, cacheManager);
} catch (Exception ex) {
exceptionHandler.HandleException("Failed to write MEF cache", ex);
}
});
await saveTask;
IdeApp.Exiting -= IdeApp_Exiting;
saveTask = null;
}));
}
internal static async Task <ExportProvider> CreateContainerAsync(this CompositionConfiguration configuration, ITestOutputHelper output)
{
Requires.NotNull(configuration, nameof(configuration));
Requires.NotNull(output, nameof(output));
var runtimeComposition = RuntimeComposition.CreateRuntimeComposition(configuration);
// Round-trip serialization to make sure the result is equivalent.
var cacheManager = new CachedComposition();
var ms = new MemoryStream();
await cacheManager.SaveAsync(runtimeComposition, ms);
output.WriteLine("Cache file size: {0}", ms.Length);
ms.Position = 0;
var deserializedRuntimeComposition = await cacheManager.LoadRuntimeCompositionAsync(ms, Resolver);
Assert.Equal(runtimeComposition, deserializedRuntimeComposition);
return(runtimeComposition.CreateExportProviderFactory().CreateExportProvider());
}
async Task InitializeInstanceAsync(ITimeTracker <CompositionLoadMetadata> timer, HashSet <Assembly> mefAssemblies)
{
var metadata = timer.Metadata;
var fullTimer = System.Diagnostics.Stopwatch.StartNew();
var stepTimer = System.Diagnostics.Stopwatch.StartNew();
var caching = new Caching(mefAssemblies, new IdeRuntimeCompositionExceptionHandler());
// Try to use cached MEF data
using (timer) {
var canUse = metadata.ValidCache = caching.CanUse();
if (canUse)
{
LoggingService.LogInfo("Creating MEF composition from cache");
RuntimeComposition = await TryCreateRuntimeCompositionFromCache(caching);
}
metadata.Timings ["LoadFromCache"] = stepTimer.ElapsedMilliseconds;
stepTimer.Restart();
// Otherwise fallback to runtime discovery.
if (RuntimeComposition == null)
{
LoggingService.LogInfo("Creating MEF composition from runtime");
var(runtimeComposition, catalog) = await CreateRuntimeCompositionFromDiscovery(caching, timer);
RuntimeComposition = runtimeComposition;
CachedComposition cacheManager = new CachedComposition();
caching.Write(RuntimeComposition, catalog, cacheManager).Ignore();
}
metadata.Timings ["LoadRuntimeComposition"] = stepTimer.ElapsedMilliseconds;
stepTimer.Restart();
ExportProviderFactory = RuntimeComposition.CreateExportProviderFactory();
ExportProvider = ExportProviderFactory.CreateExportProvider();
HostServices = Microsoft.VisualStudio.LanguageServices.VisualStudioMefHostServices.Create(ExportProvider);
metadata.Timings ["CreateServices"] = stepTimer.ElapsedMilliseconds;
metadata.Duration = fullTimer.ElapsedMilliseconds;
}
}
internal Task Write(RuntimeComposition runtimeComposition, ComposableCatalog catalog, CachedComposition cacheManager)
{
return(Runtime.RunInMainThread(async() => {
IdeApp.Exiting += IdeApp_Exiting;
saveTask = Task.Run(async() => {
try {
cachingFaultInjector?.FaultWritingComposition();
await WriteMefCache(runtimeComposition, catalog, cacheManager);
} catch (Exception ex) {
DeleteFiles();
Runtime.RunInMainThread(() => {
exceptionHandler.HandleException("Failed to write MEF cache", ex);
}).Ignore();
}
});
await saveTask;
IdeApp.Exiting -= IdeApp_Exiting;
saveTask = Task.CompletedTask;
}));
}
private static IExportProviderFactory CreateEditorExportProviderFactory()
{
AssemblyLoader.EnsureLoaded(
"Microsoft.VisualStudio.VsInteractiveWindow",
"Microsoft.VisualStudio.Editor.Implementation",
"Microsoft.VisualStudio.Platform.VSEditor",
"Microsoft.PythonTools.VSInterpreters");
var catalog = MefCatalogFactory.CreateAssembliesCatalog(
"Microsoft.VisualStudio.CoreUtility",
"Microsoft.VisualStudio.Text.Data",
"Microsoft.VisualStudio.Text.Logic",
"Microsoft.VisualStudio.Text.UI",
"Microsoft.VisualStudio.Text.UI.Wpf",
"Microsoft.VisualStudio.InteractiveWindow",
"Microsoft.VisualStudio.VsInteractiveWindow",
"Microsoft.VisualStudio.Editor",
"Microsoft.VisualStudio.Language.Intellisense",
"Microsoft.VisualStudio.Platform.VSEditor",
"Microsoft.PythonTools",
"Microsoft.PythonTools.VSInterpreters")
.WithCompositionService()
.WithServiceProvider()
.AddJoinableTaskContext()
.AddType <MockTextUndoHistoryRegistry>()
.AddTypesFromAssembly("Microsoft.VisualStudio.Editor.Implementation",
"Microsoft.VisualStudio.Editor.Implementation.LoggingServiceInternal",
"Microsoft.VisualStudio.Editor.Implementation.PeekResultFactory",
"Microsoft.VisualStudio.Editor.Implementation.TipManager",
"Microsoft.VisualStudio.Editor.Implementation.VisualStudioWaitIndicator",
"Microsoft.VisualStudio.Editor.Implementation.VsEditorAdaptersFactoryService");
var configuration = CompositionConfiguration.Create(catalog);
var runtimeConfiguration = RuntimeComposition.CreateRuntimeComposition(configuration);
return(runtimeConfiguration.CreateExportProviderFactory());
}
public override bool Execute()
{
if (Environment.GetEnvironmentVariable("CreateCompositionTaskDebug") == "1")
{
Debugger.Launch();
}
this.catalogAssemblyPaths.AddRange(this.CatalogAssemblies.Select(this.GetMEFAssemblyFullPath));
AppDomain.CurrentDomain.AssemblyResolve += this.CurrentDomain_AssemblyResolve;
try
{
var loadableAssemblies = this.catalogAssemblyPaths
.Concat(this.ReferenceAssemblies.Select(i => i.GetMetadata("FullPath")) ?? Enumerable.Empty <string>());
var resolver = new Resolver(new AssemblyLoader(loadableAssemblies));
var discovery = PartDiscovery.Combine(
new AttributedPartDiscoveryV1(resolver),
new AttributedPartDiscovery(resolver, isNonPublicSupported: true));
this.CancellationToken.ThrowIfCancellationRequested();
var parts = discovery.CreatePartsAsync(this.catalogAssemblyPaths).GetAwaiter().GetResult();
var catalog = ComposableCatalog.Create(resolver)
.AddParts(parts);
this.LogLines(this.GetLogFilePath("CatalogAssemblies"), this.GetCatalogAssembliesLines(catalog), this.CancellationToken);
string catalogErrorFilePath = this.GetLogFilePath("CatalogErrors");
if (catalog.DiscoveredParts.DiscoveryErrors.IsEmpty)
{
File.Delete(catalogErrorFilePath);
}
else
{
this.LogLines(catalogErrorFilePath, GetCatalogErrorLines(catalog), this.CancellationToken);
foreach (var error in catalog.DiscoveredParts.DiscoveryErrors)
{
string message = error.GetUserMessage();
if (this.ContinueOnDiscoveryErrors)
{
this.LogWarning(DiscoveryErrorCode, message);
}
else
{
this.Log.LogError(null, DiscoveryErrorCode, null, null, 0, 0, 0, 0, message);
}
}
if (!this.ContinueOnDiscoveryErrors)
{
return(false);
}
}
this.CancellationToken.ThrowIfCancellationRequested();
var configuration = CompositionConfiguration.Create(catalog);
if (!string.IsNullOrEmpty(this.DgmlOutputPath))
{
configuration.CreateDgml().Save(this.DgmlOutputPath);
this.writtenFiles.Add(this.DgmlOutputPath);
}
this.CancellationToken.ThrowIfCancellationRequested();
string compositionLogPath = this.GetLogFilePath("CompositionErrors");
if (configuration.CompositionErrors.IsEmpty)
{
File.Delete(compositionLogPath);
}
else
{
this.LogLines(compositionLogPath, GetCompositionErrorLines(configuration), this.CancellationToken);
foreach (var error in configuration.CompositionErrors.Peek())
{
if (this.ContinueOnCompositionErrors)
{
this.LogWarning(CompositionErrorCode, error.Message);
}
else
{
this.Log.LogError(null, CompositionErrorCode, null, null, 0, 0, 0, 0, error.Message);
}
}
if (!this.ContinueOnCompositionErrors)
{
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();
}
this.writtenFiles.Add(cachePath);
return(!this.Log.HasLoggedErrors);
}
finally
{
AppDomain.CurrentDomain.AssemblyResolve -= this.CurrentDomain_AssemblyResolve;
this.FileWrites = this.writtenFiles.Select(f => new TaskItem(f)).ToArray();
}
}
