/// <summary>
/// Attaches error handling to a block so that if it throws an unhandled exception,
/// the error will be reported to the user.
/// </summary>
/// <param name="faultHandlerService">
/// The <see cref="IProjectFaultHostHandler"/> that should handle the fault.
/// </param>
/// <param name="block">
/// The block to attach error handling to.
/// </param>
/// <param name="project">
/// The project related to the failure, if applicable. Can be <see langword="null"/>.
/// </param>
/// <param name="severity">
/// The severity of the failure.
/// </param>
public static Task RegisterFaultHandler(
this IProjectFaultHandlerService faultHandlerService,
IDataflowBlock block,
UnconfiguredProject?project,
ProjectFaultSeverity severity = ProjectFaultSeverity.Recoverable)
{
Requires.NotNull(faultHandlerService, nameof(faultHandlerService));
Requires.NotNull(block, nameof(block));
return(block.Completion.ContinueWith(_ =>
{
var dataSourceException = new AggregateException(
string.Format(
CultureInfo.CurrentCulture,
Resources.DataFlowFaults,
block.ToString(),
block.Completion.Exception),
block.Completion.Exception);
try
{
throw dataSourceException;
}
catch (AggregateException ex)
{
dataSourceException = ex;
}
return faultHandlerService.ReportFaultAsync(dataSourceException, project, severity);
},
CancellationToken.None,
TaskContinuationOptions.OnlyOnFaulted,
TaskScheduler.Default));
}
/// <summary>
/// Obtains the <see cref="UnconfiguredProject"/> for <paramref name="vsHierarchy"/>,
/// optionally testing whether it has a capability match to <paramref name="appliesToExpression"/>.
/// </summary>
/// <param name="projectService">The project service to invoke this method on.</param>
/// <param name="vsHierarchy">The VS hierarchy object, which must represent a CPS project.</param>
/// <param name="appliesToExpression">An optional project capability match expression to filter out non-matching projects.</param>
/// <returns>
/// The CPS <see cref="UnconfiguredProject"/> for the given hierarchy node, matching any (optional)
/// capability expression, or <see langword="null"/> if no suitable project exists.
/// </returns>
public static UnconfiguredProject?GetUnconfiguredProject(this IProjectService projectService, IVsHierarchy vsHierarchy, string?appliesToExpression = null)
{
// We need IProjectService2.GetLoadedProject.
if (projectService is IProjectService2 projectService2)
{
vsHierarchy.GetCanonicalName((uint)VSITEMID.Root, out string?projectFilePath);
// Ensure we have a path.
if (!Strings.IsNullOrEmpty(projectFilePath))
{
UnconfiguredProject?unconfiguredProject = projectService2.GetLoadedProject(projectFilePath);
// Ensure CPS knows a project having that path.
if (unconfiguredProject is not null)
{
// If capabilites were requested, match them.
if (appliesToExpression is null || unconfiguredProject.Capabilities.AppliesTo(appliesToExpression))
{
// Found a matching project.
return(unconfiguredProject);
}
}
}
}
return(null);
}
private static PackageRestoreDataSource CreateInitializedInstance(UnconfiguredProject?project = null, IPackageRestoreUnconfiguredInputDataSource?dataSource = null, IVsSolutionRestoreService3?solutionRestoreService = null)
{
var instance = CreateInstance(project, dataSource, solutionRestoreService);
instance.LoadAsync();
return(instance);
}
private PackageRestoreInitiatorInstance CreateInstance(UnconfiguredProject?project = null, IPackageRestoreUnconfiguredInputDataSource?dataSource = null, IVsSolutionRestoreService3?solutionRestoreService = null)
{
project ??= UnconfiguredProjectFactory.Create();
dataSource ??= IPackageRestoreUnconfiguredInputDataSourceFactory.Create();
IProjectThreadingService threadingService = IProjectThreadingServiceFactory.Create();
IProjectAsynchronousTasksService projectAsynchronousTasksService = IProjectAsynchronousTasksServiceFactory.Create();
solutionRestoreService ??= IVsSolutionRestoreServiceFactory.Create();
IProjectLogger logger = IProjectLoggerFactory.Create();
return(new PackageRestoreInitiatorInstance(project, dataSource, threadingService, projectAsynchronousTasksService, solutionRestoreService, logger));
}
/// <summary>
/// Returns the export for the given project without having to go to the
/// UI thread. This is the preferred method for getting access to project specific
/// exports
/// </summary>
public T?GetExport <T>(string projectFilePath) where T : class
{
if (string.IsNullOrEmpty(projectFilePath))
{
throw new ArgumentNullException(nameof(projectFilePath));
}
IProjectService projectService = _projectServiceAccessor.GetProjectService();
UnconfiguredProject?project = projectService?.LoadedUnconfiguredProjects
.FirstOrDefault(x => x.FullPath.Equals(projectFilePath, StringComparison.OrdinalIgnoreCase));
return(project?.Services.ExportProvider.GetExportedValueOrDefault <T>());
}
private static PackageRestoreDataSource CreateInstance(UnconfiguredProject?project = null, IPackageRestoreUnconfiguredInputDataSource?dataSource = null, IVsSolutionRestoreService3?solutionRestoreService = null)
{
project ??= UnconfiguredProjectFactory.Create(IProjectThreadingServiceFactory.Create());
dataSource ??= IPackageRestoreUnconfiguredInputDataSourceFactory.Create();
IProjectAsynchronousTasksService projectAsynchronousTasksService = IProjectAsynchronousTasksServiceFactory.Create();
solutionRestoreService ??= IVsSolutionRestoreServiceFactory.Create();
IProjectLogger logger = IProjectLoggerFactory.Create();
IFileSystem fileSystem = IFileSystemFactory.Create();
var projectDependentFileChangeNotificationService = IProjectDependentFileChangeNotificationServiceFactory.Create();
return(new PackageRestoreDataSource(
project,
dataSource,
projectAsynchronousTasksService,
solutionRestoreService,
fileSystem,
logger,
projectDependentFileChangeNotificationService));
}
private PackageRestoreDataSource CreateInstance(UnconfiguredProject?project = null, IPackageRestoreUnconfiguredInputDataSource?dataSource = null, IVsSolutionRestoreService3?solutionRestoreService = null)
{
project ??= UnconfiguredProjectFactory.Create(IProjectThreadingServiceFactory.Create());
dataSource ??= IPackageRestoreUnconfiguredInputDataSourceFactory.Create();
IProjectAsynchronousTasksService projectAsynchronousTasksService = IProjectAsynchronousTasksServiceFactory.Create();
solutionRestoreService ??= IVsSolutionRestoreServiceFactory.Create();
IProjectLogger logger = IProjectLoggerFactory.Create();
IFileSystem fileSystem = IFileSystemFactory.Create();
var hintService = new Lazy <IProjectChangeHintSubmissionService>(() => IProjectChangeHintSubmissionServiceFactory.Create());
var projectAccessor = IProjectAccessorFactory.Create();
return(new PackageRestoreDataSource(
project,
dataSource,
projectAsynchronousTasksService,
solutionRestoreService,
fileSystem,
hintService,
projectAccessor,
logger));
}
private static PackageRestoreDataSource CreateInstance(UnconfiguredProject?project = null, IPackageRestoreUnconfiguredInputDataSource?dataSource = null, IVsSolutionRestoreService3?solutionRestoreService = null)
{
project ??= UnconfiguredProjectFactory.CreateWithActiveConfiguredProjectProvider(IProjectThreadingServiceFactory.Create());
dataSource ??= IPackageRestoreUnconfiguredInputDataSourceFactory.Create();
IProjectAsynchronousTasksService projectAsynchronousTasksService = IProjectAsynchronousTasksServiceFactory.Create();
solutionRestoreService ??= IVsSolutionRestoreServiceFactory.Create();
IProjectDiagnosticOutputService logger = IProjectDiagnosticOutputServiceFactory.Create();
IFileSystem fileSystem = IFileSystemFactory.Create();
var vsSolutionRestoreService4 = IVsSolutionRestoreService4Factory.ImplementRegisterRestoreInfoSourceAsync();
var sharedJoinableTaskCollection = new PackageRestoreSharedJoinableTaskCollection(IProjectThreadingServiceFactory.Create());
return(new PackageRestoreDataSourceMocked(
project,
dataSource,
projectAsynchronousTasksService,
solutionRestoreService,
fileSystem,
logger,
vsSolutionRestoreService4,
sharedJoinableTaskCollection));
}
private static ActiveConfiguredProjectsProvider CreateInstance(IUnconfiguredProjectServices?services = null, UnconfiguredProject?project = null, IEnumerable <IActiveConfiguredProjectsDimensionProvider>?dimensionProviders = null)
{
services ??= IUnconfiguredProjectServicesFactory.Create();
project ??= UnconfiguredProjectFactory.Create();
var provider = new ActiveConfiguredProjectsProvider(services, project);
if (dimensionProviders != null)
{
foreach (var dimensionProvider in dimensionProviders)
{
provider.DimensionProviders.Add(dimensionProvider, appliesTo: ProjectCapability.AlwaysAvailable);
}
}
return(provider);
}
private static PhysicalProjectTreeStorage CreateInstance(IProjectTreeService?treeService = null, IProjectTreeProvider?treeProvider = null, IFileSystem?fileSystem = null, IFolderManager?folderManager = null, UnconfiguredProject?project = null)
{
treeService ??= IProjectTreeServiceFactory.Create(ProjectTreeParser.Parse("Root"));
treeProvider ??= IProjectTreeProviderFactory.Create();
fileSystem ??= IFileSystemFactory.Create();
folderManager ??= IFolderManagerFactory.Create();
project ??= UnconfiguredProjectFactory.Create();
return(new PhysicalProjectTreeStorage(new Lazy <IProjectTreeService>(() => treeService),
new Lazy <IProjectTreeProvider>(() => treeProvider),
new Lazy <IFileSystem>(() => fileSystem),
ActiveConfiguredProjectFactory.ImplementValue(() => folderManager),
project));
}