private async Task <RunCodeActionResponse> RunRefactoringsAsync(string source, string identifier, bool wantsChanges = false)
{
var request = CreateRunCodeActionRequest(source, identifier, wantsChanges);
_host = _host ?? TestHelpers.CreatePluginHost(new[] { typeof(RoslynCodeActionProvider).GetTypeInfo().Assembly, typeof(NRefactoryCodeActionProvider).GetTypeInfo().Assembly, typeof(GetCodeActionsService).GetTypeInfo().Assembly });
_workspace = _workspace ?? await TestHelpers.CreateSimpleWorkspace(_host, request.Buffer, bufferPath);
var controller = new RunCodeActionService(_workspace, new ICodeActionProvider[] { new RoslynCodeActionProvider(), new NRefactoryCodeActionProvider() }, new FakeLoggerFactory());
var response = await controller.Handle(request);
return(response);
}
public static void Initialize(
IServiceProvider serviceProvider,
CompositionHost compositionHost,
IConfiguration configuration,
ILogger logger)
{
var workspace = compositionHost.GetExport <OmniSharpWorkspace>();
var options = serviceProvider.GetRequiredService <IOptionsMonitor <OmniSharpOptions> >();
var projectEventForwarder = compositionHost.GetExport <ProjectEventForwarder>();
projectEventForwarder.Initialize();
var projectSystems = compositionHost.GetExports <Lazy <IProjectSystem, ProjectSystemMetadata> >();
var ps = projectSystems.Select(n => n.Value);
var orderedProjectSystems = ExtensionOrderer.GetOrderedOrUnorderedList <IProjectSystem, ExportProjectSystemAttribute>(ps, eps => eps.Name);
foreach (var projectSystem in orderedProjectSystems)
{
try
{
var projectConfiguration = configuration.GetSection(projectSystem.Key);
var enabledProjectFlag = projectConfiguration.GetValue("enabled", defaultValue: projectSystem.EnabledByDefault);
if (enabledProjectFlag)
{
projectSystem.Initalize(projectConfiguration);
}
else
{
logger.LogInformation($"Project system '{projectSystem.GetType().FullName}' is disabled in the configuration.");
}
}
catch (Exception e)
{
var message = $"The project system '{projectSystem.GetType().FullName}' threw exception during initialization.";
// if a project system throws an unhandled exception it should not crash the entire server
logger.LogError(e, message);
}
}
ProvideWorkspaceOptions(compositionHost, workspace, options, logger);
// Mark the workspace as initialized
workspace.Initialized = true;
// when configuration options change
// run workspace options providers automatically
options.OnChange(o =>
{
ProvideWorkspaceOptions(compositionHost, workspace, options, logger);
});
logger.LogInformation("Configuration finished.");
}
private async Task <IEnumerable <OmniSharpCodeAction> > FindRefactoringsAsync(string source)
{
var request = CreateGetCodeActionsRequest(source);
_host = _host ?? TestHelpers.CreatePluginHost(new[] { typeof(RoslynCodeActionProvider).GetTypeInfo().Assembly, typeof(NRefactoryCodeActionProvider).GetTypeInfo().Assembly, typeof(GetCodeActionsService).GetTypeInfo().Assembly });
_workspace = _workspace ?? await TestHelpers.CreateSimpleWorkspace(_host, request.Buffer, bufferPath);
var controller = new GetCodeActionsService(_workspace, new ICodeActionProvider[] { new RoslynCodeActionProvider(), new NRefactoryCodeActionProvider() }, new FakeLoggerFactory());
var response = await controller.Handle(request);
return(response.CodeActions);
}
protected override void OnInitialize()
{
base.OnInitialize();
Context = UnitTestSynchronizationContext.Create();
var configuration = new ContainerConfiguration()
.WithAssembly(typeof(ShellViewModel).GetTypeInfo().Assembly)
.WithAssembly(typeof(ApplicationsTest).GetTypeInfo().Assembly);
Container = configuration.CreateContainer();
}
public async static Task <OmnisharpWorkspace> CreateSimpleWorkspace(CompositionHost _host, Dictionary <string, string> sourceFiles)
{
var host = _host ?? CreatePluginHost(new[] { typeof(CodeCheckService).GetTypeInfo().Assembly });
var workspace = host.GetExport <OmnisharpWorkspace>();
await AddProjectToWorkspace(workspace, "project.json", new[] { "dnx451", "dnxcore50" }, sourceFiles);
await Task.Delay(50);
return(workspace);
}
private static ICciDifferenceWriter GetDifferenceWriter(TextWriter writer, IDifferenceFilter filter)
{
CompositionHost container = GetCompositionHost();
Func <IDifferenceRuleMetadata, bool> ruleFilter =
delegate(IDifferenceRuleMetadata ruleMetadata)
{
if (ruleMetadata.OptionalRule && !s_enforceOptionalRules)
{
return(false);
}
if (ruleMetadata.MdilServicingRule && !s_mdil)
{
return(false);
}
return(true);
};
if (s_mdil && s_excludeNonBrowsable)
{
Trace.TraceWarning("Enforcing MDIL servicing rules and exclusion of non-browsable types are both enabled, but they are not compatible so non-browsable types will not be excluded.");
}
MappingSettings settings = new MappingSettings();
settings.Comparers = GetComparers();
settings.Filter = GetCciFilter(s_mdil, s_excludeNonBrowsable);
settings.DiffFilter = GetDiffFilter(settings.Filter);
settings.DiffFactory = new ElementDifferenceFactory(container, ruleFilter);
settings.GroupByAssembly = s_groupByAssembly;
settings.IncludeForwardedTypes = true;
if (filter == null)
{
filter = new DifferenceFilter <IncompatibleDifference>();
}
ICciDifferenceWriter diffWriter = new DifferenceWriter(writer, settings, filter);
ExportCciSettings.StaticSettings = settings.TypeComparer;
ExportCciSettings.StaticOperands = new DifferenceOperands()
{
Contract = s_contractOperand,
Implementation = s_implementationOperand,
};
ExportCciSettings.StaticAttributeFilter = new AttributeFilter(s_excludeAttributesList);
// Always compose the diff writer to allow it to import or provide exports
container.SatisfyImports(diffWriter);
return(diffWriter);
}
private static IMarkdownTokenRewriter InitMarkdownStyle(CompositionHost host, string baseDir, string templateDir)
{
try
{
return(MarkdownValidatorBuilder.Create(host, baseDir, templateDir).CreateRewriter());
}
catch (Exception ex)
{
Logger.LogWarning($"Fail to init markdown style, details:{Environment.NewLine}{ex.ToString()}");
}
return(null);
}
public override void Prepare()
{
var config = new ContainerConfiguration();
RegisterBasic(config);
RegisterPropertyInjection(config);
RegisterMultiple(config);
RegisterOpenGeneric(config);
this.container = config.CreateContainer();
}
private OmniSharpTestHost(
TestServiceProvider serviceProvider,
ILoggerFactory loggerFactory,
OmniSharpWorkspace workspace,
CompositionHost compositionHost)
{
_serviceProvider = serviceProvider;
_compositionHost = compositionHost;
this.LoggerFactory = loggerFactory;
this.Workspace = workspace;
}
internal void InitializeMef()
{
if (ExportProvider != null)
{
return;
}
var configuration = new ContainerConfiguration()
.WithAssembly(typeof(MefHost).Assembly) // this assembly
.WithAssembly(typeof(Constants).Assembly); // PaZword.Core
ExportProvider = configuration.CreateContainer();
}
/// <summary>
/// The application's main entry point.
/// </summary>
/// <remarks>
/// This method creates an instance of the <see cref="ContainerConfiguration" />
/// class, setting it up to include all "exports" defined in the current assembly,
/// and uses it to obtain an instance of the <see cref="CompositionHost" /> class,
/// the Managed Extensibility Framework "container", which can be used to directly
/// request individual exports.
///
/// Subsequently, it requests the implementation of the <see cref="IDependency" />
/// interface, upon which it calls its <see cref="IDependency.SaySomething" />
/// method, which does the actual heavy lifting - it prints 'Hello, world!' to the
/// console.
///
/// Please note that the approach taken here assumes that exactly one "official",
/// production implementation of the <see cref="IDependency" /> interface exists.
/// The <see cref="CompositionContext.GetExport{TExport}" /> method would throw an
/// exception if that wasn't the case. If you want to allow multiple exports
/// (i.e., implementations) of a single interface, you should use the
/// <see cref="CompositionContext.GetExports{TExport}" /> (plural) method instead.
/// </remarks>
public static void Main()
{
var configuration = new ContainerConfiguration();
configuration.WithAssembly(typeof(Program).Assembly);
using (CompositionHost container = configuration.CreateContainer())
{
IDependency dependency = container.GetExport <IDependency>();
dependency.SaySomething();
}
Console.ReadLine();
}
private void Solution_Opened()
{
using (PerformanceTracer.Start("DTE event: Solution opened"))
{
ReloadSolution();
var resourceManager = CompositionHost.GetExportedValue <ResourceManager>();
resourceManager.ProjectFileSaved -= ResourceManager_ProjectFileSaved;
resourceManager.ProjectFileSaved += ResourceManager_ProjectFileSaved;
}
}
public static void Init()
{
try
{
lock (_sync)
{
if (IsInitialized)
{
Dispose();
}
_logger.LogInformation("MEFLoader.Init start");
var startTime = DateTime.UtcNow;
var rules = new ConventionBuilder();
var assemblyList = new List <Assembly>();
if (!MEFSkip.Skip)
{
assemblies.ToList().ForEach(a =>
{
var assembly = Assembly.LoadFile(a);
assemblyList.Add(assembly);
var sharedExports = assembly.GetTypes()
.Where(type => type.GetCustomAttribute <SharedPolicyCreationAttribute>(true) is SharedPolicyCreationAttribute policy && policy.Shared).ToList();
foreach (var item in sharedExports)
{
rules.ForTypesDerivedFrom(item).Shared();
}
var debug = assembly.GetTypes().Where(t => t.GetCustomAttribute <ExportAttribute>(true) is ExportAttribute export);
foreach (var t in debug)
{
_logger.LogInformation(t.FullName);
}
_logger.LogInformation($"Added types from {a} to the assembly list.");
});
}
_compositionHost = new ContainerConfiguration().WithAssemblies(assemblyList, rules).CreateContainer();
_logger.LogInformation($"MEF Init Time (in ms): {DateTime.UtcNow - startTime}");
}
}
catch (ReflectionTypeLoadException ex)
{
ex.LoaderExceptions.ToList().ForEach(e =>
{
_logger.LogError($"---: {e.Message}");
e.InnerException.ActIfNotNull(() => _logger.LogError(e.InnerException.ToJsonString()));
});
}
}
public static void Initialize(IServiceProvider serviceProvider, CompositionHost compositionHost)
{
var loggerFactory = serviceProvider.GetRequiredService <ILoggerFactory>();
var logger = loggerFactory.CreateLogger <WorkspaceInitializer>();
var workspace = compositionHost.GetExport <OmniSharpWorkspace>();
var options = serviceProvider.GetRequiredService <IOptionsMonitor <OmniSharpOptions> >();
var configuration = serviceProvider.GetRequiredService <IConfigurationRoot>();
var omnisharpEnvironment = serviceProvider.GetRequiredService <IOmniSharpEnvironment>();
var projectEventForwarder = compositionHost.GetExport <ProjectEventForwarder>();
projectEventForwarder.Initialize();
var projectSystems = compositionHost.GetExports <IProjectSystem>();
foreach (var projectSystem in projectSystems)
{
try
{
var projectConfiguration = configuration.GetSection(projectSystem.Key);
var enabledProjectFlag = projectConfiguration.GetValue("enabled", defaultValue: projectSystem.EnabledByDefault);
if (enabledProjectFlag)
{
projectSystem.Initalize(projectConfiguration);
}
else
{
logger.LogInformation($"Project system '{projectSystem.GetType().FullName}' is disabled in the configuration.");
}
}
catch (Exception e)
{
var message = $"The project system '{projectSystem.GetType().FullName}' threw exception during initialization.";
// if a project system throws an unhandled exception it should not crash the entire server
logger.LogError(e, message);
}
}
ProvideWorkspaceOptions(compositionHost, workspace, options, logger, omnisharpEnvironment);
// Mark the workspace as initialized
workspace.Initialized = true;
// when configuration options change
// run workspace options providers automatically
options.OnChange(o =>
{
ProvideWorkspaceOptions(compositionHost, workspace, options, logger, omnisharpEnvironment);
});
logger.LogInformation("Configuration finished.");
}
public override void Prepare()
{
var config = new ContainerConfiguration();
RegisterDummies(config);
RegisterStandard(config);
RegisterComplexObject(config);
RegisterPropertyInjection(config);
RegisterMultiple(config);
RegisterOpenGeneric(config);
this.container = config.CreateContainer();
}
public PostProcessorsManager(CompositionHost container, ImmutableArray <string> postProcessorNames)
{
if (container == null)
{
throw new ArgumentNullException(nameof(container));
}
if (postProcessorNames == null)
{
throw new ArgumentNullException(nameof(postProcessorNames));
}
_postProcessors = GetPostProcessor(container, postProcessorNames);
_postProcessorsHandler = new PostProcessorsHandler();
}
private OmniSharpTestHost(
IServiceProvider serviceProvider,
CompositionHost compositionHost,
string originalCreatorToTrackDownMissedDisposes)
{
_serviceProvider = serviceProvider;
_compositionHost = compositionHost;
this.Workspace = compositionHost.GetExport <OmniSharpWorkspace>();
this.LoggerFactory = _serviceProvider.GetRequiredService <ILoggerFactory>();
this.Logger = this.LoggerFactory.CreateLogger <OmniSharpTestHost>();
_originalCreatorToTrackDownMissedDisposes = originalCreatorToTrackDownMissedDisposes;
}
public RoslynHost()
{
compositionContext = CreateCompositionContext();
// Create MEF host services
hostServices = MefHostServices.Create(compositionContext);
// Create default workspace
workspace = new RoslynWorkspace(this);
workspace.EnableDiagnostics(DiagnosticOptions.Semantic | DiagnosticOptions.Syntax);
GetService <IDiagnosticService>().DiagnosticsUpdated += OnDiagnosticsUpdated;
}
/// <summary>
/// Creates a new MefServiceProvider that uses the given MEF container to resolve dependencies
/// </summary>
public MefServiceProvider(CompositionHost container)
: base(new Export <CompositionContext>(container, container.Dispose), null, null)
{
if (container == null)
{
throw new ArgumentNullException(nameof(container));
}
var factoryContract = new CompositionContract(typeof(ExportFactory <CompositionContext>), null, new Dictionary <string, object> {
{ "SharingBoundaryNames", new[] { nameof(ServiceLifetime.Scoped) } }
});
_requestScopeFactory = (ExportFactory <CompositionContext>)container.GetExport(factoryContract);
}
public static MefHostServices Create(IEnumerable <Assembly> assemblies)
{
if (assemblies == null)
{
throw new ArgumentNullException(nameof(assemblies));
}
ContainerConfiguration compositionConfiguration = new ContainerConfiguration().WithAssemblies(assemblies);
CompositionHost container = compositionConfiguration.CreateContainer();
return(new MefHostServices(container));
}
public void Import(CompositionHost host)
{
foreach (T factory in host.GetExports <T>())
{
T existing;
if (!_factories.TryGetValue(factory.Name, out existing))
{
_factories.Add(factory.Name, factory);
}
}
OnImport(host);
}
public void BindExportType()
{
Assembly currAss = Assembly.GetExecutingAssembly();
ContainerConfiguration config = new ContainerConfiguration().WithAssembly(currAss);
using (CompositionHost host = config.CreateContainer())
{
IPlayer p1 = host.GetExport <IPlayer>("gen_pl");
IPlayer p2 = host.GetExport <IPlayer>("pro_pl");
p1.PlayTracks();
p2.PlayTracks();
}
}
static CompositionContainer()
{
var currentAssembly = typeof(CompositionContainer).GetTypeInfo().Assembly;
var configuration = new ContainerConfiguration()
.WithAssemblies(new[]
{
currentAssembly,
typeof(Drawing).GetTypeInfo().Assembly, // BCad.Core.dll
typeof(DxfFileHandler).GetTypeInfo().Assembly // BCad.FileHandlers.dll
});
Container = configuration.CreateContainer();
}
/// <summary>
/// Construct a <see cref="StandaloneDependencyResolver"/> for the provided
/// root composition scope.
/// </summary>
/// <param name="rootCompositionScope">The scope to provide application-level services to
/// the program.</param>
public StandaloneDependencyResolver(CompositionHost rootCompositionScope)
: base(new Export <CompositionContext>(rootCompositionScope, rootCompositionScope.Dispose))
{
if (rootCompositionScope == null)
{
throw new ArgumentNullException();
}
var factoryContract = new CompositionContract(typeof(ExportFactory <CompositionContext>), null, new Dictionary <string, object> {
{ "SharingBoundaryNames", new[] { Boundaries.HttpRequest, Boundaries.DataConsistency, Boundaries.UserIdentity } }
});
_requestScopeFactory = (ExportFactory <CompositionContext>)rootCompositionScope.GetExport(factoryContract);
}
private void TextEditorContextMenuCommand_BeforeQueryStatus([CanBeNull] object sender, [CanBeNull] EventArgs e)
{
if (!(sender is OleMenuCommand menuCommand))
{
return;
}
using (CompositionHost.GetExportedValue <PerformanceTracer>().Start("Can move to resource"))
{
menuCommand.Text = Resources.MoveToResource;
menuCommand.Visible = CompositionHost.GetExportedValue <IRefactorings>().CanMoveToResource(Dte.ActiveDocument);
}
}
protected override void Configure()
{
container = CompositionHost.Initialize(
new AggregateCatalog(AssemblySource.Instance.Select(x => new AssemblyCatalog(x)).OfType <ComposablePartCatalog>()));
var batch = new CompositionBatch();
batch.AddExportedValue <IWindowManager>(new WindowManager());
batch.AddExportedValue <IEventAggregator>(new EventAggregator());
batch.AddExportedValue(container);
container.Compose(batch);
}
private IEnumerable <ResourceEntity> GetSelectedResourceEntities([CanBeNull] string fileName)
{
if (string.IsNullOrEmpty(fileName))
{
return(Enumerable.Empty <ResourceEntity>());
}
var resourceEntities = CompositionHost.GetExportedValue <ResourceManager>().ResourceEntities;
return(resourceEntities
.Where(entity => ContainsFile(entity, fileName) || ContainsChildOfWinFormsDesignerItem(entity, fileName))
.ToArray());
}
/// <summary>
/// Gets enumeration of plugins to be loaded into the WordPress.
/// </summary>
/// <param name="host">Instance of <see cref="CompositionHost"/> providing exported parts.</param>
/// <param name="provider">Service provider for dependency injection.</param>
/// <returns>Enumeration of plugin instances.</returns>
public static IEnumerable <IWpPlugin> /*!!*/ GetPlugins(CompositionHost host, IServiceProvider provider)
{
// import providers from composition host:
IEnumerable <IWpPluginProvider> providers = host != null
? GetProviders(host)
: Enumerable.Empty <IWpPluginProvider>();
// hardcode our internal plugin:
providers = new[] { new Internal.PluginsProvider() }.Concat(providers);
// create plugins:
return(providers.SelectMany(p => p.GetPlugins(provider)));
}
public T GetProviderService <T>() where T : class, IProviderService
{
if (_host == null)
{
_host = RegisterServices();
}
InitializeProvidersCache();
var type = typeof(T);
return((T)_providersCache[type.Name]);
}
protected override IServiceLocator CreateContainer()
{
var catalog = new AggregateCatalog(SelectAssemblies().Select(x => new AssemblyCatalog(x)).OfType <ComposablePartCatalog>());
container = CompositionHost.Initialize(catalog);
var batch = new CompositionBatch();
batch.AddExportedValue(catalog);
container.Compose(batch);
return(new MEFAdapter(container));
}
