public FallbackRazorProjectHost(
IUnconfiguredProjectCommonServices commonServices,
[Import(typeof(VisualStudioWorkspace))] Workspace workspace,
ProjectConfigurationFilePathStore projectConfigurationFilePathStore)
: base(commonServices, workspace, projectConfigurationFilePathStore)
{
}
public RazorProjectHostBase(
IUnconfiguredProjectCommonServices commonServices,
[Import(typeof(VisualStudioWorkspace))] Workspace workspace,
ProjectSnapshotManagerDispatcher projectSnapshotManagerDispatcher,
ProjectConfigurationFilePathStore projectConfigurationFilePathStore)
: base(commonServices.ThreadingService.JoinableTaskContext)
{
if (commonServices is null)
{
throw new ArgumentNullException(nameof(commonServices));
}
if (workspace is null)
{
throw new ArgumentNullException(nameof(workspace));
}
if (projectSnapshotManagerDispatcher is null)
{
throw new ArgumentNullException(nameof(projectSnapshotManagerDispatcher));
}
CommonServices = commonServices;
_workspace = workspace;
_projectSnapshotManagerDispatcher = projectSnapshotManagerDispatcher;
_lock = new AsyncSemaphore(initialCount: 1);
_currentDocuments = new Dictionary <string, HostDocument>(FilePathComparer.Instance);
ProjectConfigurationFilePathStore = projectConfigurationFilePathStore;
}
internal FallbackRazorProjectHost(
IUnconfiguredProjectCommonServices commonServices,
Workspace workspace,
ProjectConfigurationFilePathStore projectConfigurationFilePathStore,
ProjectSnapshotManagerBase projectManager)
: base(commonServices, workspace, projectConfigurationFilePathStore, projectManager)
{
}
public DefaultRazorProjectHost(
IUnconfiguredProjectCommonServices commonServices,
[Import(typeof(VisualStudioWorkspace))] Workspace workspace,
ProjectSnapshotManagerDispatcher projectSnapshotManagerDispatcher,
ProjectConfigurationFilePathStore projectConfigurationFilePathStore)
: base(commonServices, workspace, projectSnapshotManagerDispatcher, projectConfigurationFilePathStore)
{
}
internal DefaultWindowsRazorProjectHost(
IUnconfiguredProjectCommonServices commonServices,
Workspace workspace,
ProjectSnapshotManagerDispatcher projectSnapshotManagerDispatcher,
ProjectConfigurationFilePathStore projectConfigurationFilePathStore,
ProjectSnapshotManagerBase projectManager)
: base(commonServices, workspace, projectSnapshotManagerDispatcher, projectConfigurationFilePathStore, projectManager)
{
}
public DefaultWindowsRazorProjectHost(
IUnconfiguredProjectCommonServices commonServices,
[Import(typeof(VisualStudioWorkspace))] Workspace workspace,
ProjectSnapshotManagerDispatcher projectSnapshotManagerDispatcher,
ProjectConfigurationFilePathStore projectConfigurationFilePathStore,
VSLanguageServerFeatureOptions languageServerFeatureOptions)
: base(commonServices, workspace, projectSnapshotManagerDispatcher, projectConfigurationFilePathStore)
{
_languageServerFeatureOptions = languageServerFeatureOptions;
}
internal async Task OnProjectChangedAsync(IProjectVersionedValue <IProjectSubscriptionUpdate> update)
{
if (IsDisposing || IsDisposed)
{
return;
}
await CommonServices.TasksService.LoadedProjectAsync(async() => await ExecuteWithLockAsync(async() =>
{
if (TryGetConfiguration(update.Value.CurrentState, out var configuration))
{
TryGetRootNamespace(update.Value.CurrentState, out var rootNamespace);
// We need to deal with the case where the project was uninitialized, but now
// is valid for Razor. In that case we might have previously seen all of the documents
// but ignored them because the project wasn't active.
//
// So what we do to deal with this, is that we 'remove' all changed and removed items
// and then we 'add' all current items. This allows minimal churn to the PSM, but still
// makes us up to date.
var documents = GetCurrentDocuments(update.Value);
var changedDocuments = GetChangedAndRemovedDocuments(update.Value);
await UpdateAsync(() =>
{
var hostProject = new HostProject(CommonServices.UnconfiguredProject.FullPath, configuration, rootNamespace);
if (TryGetIntermediateOutputPath(update.Value.CurrentState, out var intermediatePath))
{
var projectConfigurationFile = Path.Combine(intermediatePath, _languageServerFeatureOptions.ProjectConfigurationFileName);
ProjectConfigurationFilePathStore.Set(hostProject.FilePath, projectConfigurationFile);
}
UpdateProjectUnsafe(hostProject);
for (var i = 0; i < changedDocuments.Length; i++)
{
RemoveDocumentUnsafe(changedDocuments[i]);
}
for (var i = 0; i < documents.Length; i++)
{
AddDocumentUnsafe(documents[i]);
}
}, CancellationToken.None).ConfigureAwait(false);
}
else
{
// Ok we can't find a configuration. Let's assume this project isn't using Razor then.
await UpdateAsync(UninitializeProjectUnsafe, CancellationToken.None).ConfigureAwait(false);
}
}).ConfigureAwait(false), registerFaultHandler : true);
}
// Internal for testing
protected RazorProjectHostBase(
IUnconfiguredProjectCommonServices commonServices,
Workspace workspace,
ProjectConfigurationFilePathStore projectConfigurationFilePathStore,
ProjectSnapshotManagerBase projectManager)
: this(commonServices, workspace, projectConfigurationFilePathStore)
{
if (projectManager == null)
{
throw new ArgumentNullException(nameof(projectManager));
}
_projectManager = projectManager;
}
// Internal for testing
internal async Task OnProjectChangedAsync(IProjectVersionedValue <IProjectSubscriptionUpdate> update)
{
if (IsDisposing || IsDisposed)
{
return;
}
await CommonServices.TasksService.LoadedProjectAsync(async() => await ExecuteWithLockAsync(async() =>
{
string mvcReferenceFullPath = null;
if (update.Value.CurrentState.ContainsKey(ResolvedCompilationReference.SchemaName))
{
var references = update.Value.CurrentState[ResolvedCompilationReference.SchemaName].Items;
foreach (var reference in references)
{
if (reference.Key.EndsWith(MvcAssemblyFileName, StringComparison.OrdinalIgnoreCase))
{
mvcReferenceFullPath = reference.Key;
break;
}
}
}
if (mvcReferenceFullPath == null)
{
// Ok we can't find an MVC version. Let's assume this project isn't using Razor then.
await UpdateAsync(UninitializeProjectUnsafe, CancellationToken.None).ConfigureAwait(false);
return;
}
var version = GetAssemblyVersion(mvcReferenceFullPath);
if (version == null)
{
// Ok we can't find an MVC version. Let's assume this project isn't using Razor then.
await UpdateAsync(UninitializeProjectUnsafe, CancellationToken.None).ConfigureAwait(false);
return;
}
// We need to deal with the case where the project was uninitialized, but now
// is valid for Razor. In that case we might have previously seen all of the documents
// but ignored them because the project wasn't active.
//
// So what we do to deal with this, is that we 'remove' all changed and removed items
// and then we 'add' all current items. This allows minimal churn to the PSM, but still
// makes us up-to-date.
var documents = GetCurrentDocuments(update.Value);
var changedDocuments = GetChangedAndRemovedDocuments(update.Value);
await UpdateAsync(() =>
{
var configuration = FallbackRazorConfiguration.SelectConfiguration(version);
var hostProject = new HostProject(CommonServices.UnconfiguredProject.FullPath, configuration, rootNamespace: null);
if (TryGetIntermediateOutputPath(update.Value.CurrentState, out var intermediatePath))
{
var projectRazorJson = Path.Combine(intermediatePath, "project.razor.json");
ProjectConfigurationFilePathStore.Set(hostProject.FilePath, projectRazorJson);
}
UpdateProjectUnsafe(hostProject);
for (var i = 0; i < changedDocuments.Length; i++)
{
RemoveDocumentUnsafe(changedDocuments[i]);
}
for (var i = 0; i < documents.Length; i++)
{
AddDocumentUnsafe(documents[i]);
}
}, CancellationToken.None).ConfigureAwait(false);
}).ConfigureAwait(false), registerFaultHandler : true);
}
