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);
}
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);
}
internal InteractiveWindowTestHost(ExportProvider exportProvider)
{
_exportProvider = exportProvider.AsExportProvider();
Evaluator = new TestInteractiveEvaluator();
Window = _exportProvider.GetExport <IInteractiveWindowFactoryService>().Value.CreateWindow(Evaluator);
Window.InitializeAsync().Wait();
}
private RoslynVisualStudioWorkspace(
ExportProvider exportProvider,
[ImportMany] IEnumerable <Lazy <IStreamingFindUsagesPresenter> > streamingPresenters,
[ImportMany] IEnumerable <IDocumentOptionsProviderFactory> documentOptionsProviderFactories)
: base(exportProvider.AsExportProvider())
{
_streamingPresenters = streamingPresenters;
foreach (var providerFactory in documentOptionsProviderFactories)
{
Services.GetRequiredService <IOptionService>().RegisterDocumentOptionsProvider(providerFactory.Create(this));
}
}
public TestWorkspace(ExportProvider exportProvider, string workspaceKind = null, bool disablePartialSolutions = true)
: base(MefV1HostServices.Create(exportProvider.AsExportProvider()), workspaceKind ?? WorkspaceKind.Test)
{
ResetThreadAffinity();
this.TestHookPartialSolutionsDisabled = disablePartialSolutions;
this.ExportProvider = exportProvider;
this.Projects = new List <TestHostProject>();
this.Documents = new List <TestHostDocument>();
this.AdditionalDocuments = new List <TestHostDocument>();
this.ProjectionDocuments = new List <TestHostDocument>();
this.CanApplyChangeDocument = true;
}
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;
}
}
public TestWorkspace(ExportProvider exportProvider, string workspaceKind = null, bool disablePartialSolutions = true)
: base(MefV1HostServices.Create(exportProvider.AsExportProvider()), workspaceKind ?? WorkspaceKind.Test)
{
this.TestHookPartialSolutionsDisabled = disablePartialSolutions;
this.ExportProvider = exportProvider;
this.Projects = new List <TestHostProject>();
this.Documents = new List <TestHostDocument>();
this.AdditionalDocuments = new List <TestHostDocument>();
this.ProjectionDocuments = new List <TestHostDocument>();
this.CanApplyChangeDocument = true;
_backgroundCompiler = new BackgroundCompiler(this);
_backgroundParser = new BackgroundParser(this);
_backgroundParser.Start();
_metadataAsSourceFileService = exportProvider.GetExportedValues <IMetadataAsSourceFileService>().FirstOrDefault();
}
public ComponentModel(ExportProvider exportProvider, MefV1.ICompositionService compositionService)
{
_exportProvider = exportProvider;
DefaultExportProvider = exportProvider.AsExportProvider();
DefaultCompositionService = compositionService;
}
public static HostServices CreateHostServices(ExportProvider exportProvider = null)
{
exportProvider = exportProvider ?? CreateMinimalExportProvider();
return(MefV1HostServices.Create(exportProvider.AsExportProvider()));
}
public static HostServices CreateHostServices(ExportProvider exportProvider = null)
{
exportProvider = exportProvider ?? CreateMinimalExportProvider();
return MefV1HostServices.Create(exportProvider.AsExportProvider());
}
public ExportProviderMefHostServices(ExportProvider exportProvider)
: base(new ContainerConfiguration().CreateContainer())
{
_mefV1HostServices = MefV1HostServices.Create(exportProvider.AsExportProvider());
}
