public void ProjectSnapshotHandleProxy_RoundTripsProperly()
{
// Arrange
var tagHelpers = new[]
{
TagHelperDescriptorBuilder.Create("TestTagHelper", "TestAssembly").Build(),
TagHelperDescriptorBuilder.Create("TestTagHelper2", "TestAssembly2").Build(),
};
var projectWorkspaceState = new ProjectWorkspaceState(tagHelpers);
var expectedConfiguration = RazorConfiguration.Default;
var expectedRootNamespace = "project";
var handle = new ProjectSnapshotHandleProxy(new Uri("vsls://some/path/project.csproj"), RazorConfiguration.Default, expectedRootNamespace, projectWorkspaceState);
var converterCollection = new JsonConverterCollection();
converterCollection.RegisterRazorLiveShareConverters();
var converters = converterCollection.ToArray();
var serializedHandle = JsonConvert.SerializeObject(handle, converters);
// Act
var deserializedHandle = JsonConvert.DeserializeObject <ProjectSnapshotHandleProxy>(serializedHandle, converters);
// Assert
Assert.Equal("vsls://some/path/project.csproj", deserializedHandle.FilePath.ToString());
Assert.Equal(projectWorkspaceState, deserializedHandle.ProjectWorkspaceState);
Assert.Equal(expectedConfiguration.ConfigurationName, deserializedHandle.Configuration.ConfigurationName);
Assert.Equal(expectedConfiguration.Extensions.Count, deserializedHandle.Configuration.Extensions.Count);
Assert.Equal(expectedConfiguration.LanguageVersion, deserializedHandle.Configuration.LanguageVersion);
Assert.Equal(expectedRootNamespace, deserializedHandle.RootNamespace);
}
public async Task ProjectAdded_PublishesToCorrectFilePathAsync()
{
// Arrange
var serializationSuccessful = false;
var expectedConfigurationFilePath = "/path/to/obj/bin/Debug/project.razor.json";
var publisher = new TestDefaultRazorProjectChangePublisher(
ProjectConfigurationFilePathStore,
_razorLogger,
onSerializeToFile: (snapshot, configurationFilePath) =>
{
Assert.Equal(expectedConfigurationFilePath, configurationFilePath);
serializationSuccessful = true;
})
{
_active = true,
};
publisher.Initialize(ProjectSnapshotManager);
var projectFilePath = "/path/to/project.csproj";
var hostProject = new HostProject(projectFilePath, RazorConfiguration.Default, "TestRootNamespace");
ProjectConfigurationFilePathStore.Set(hostProject.FilePath, expectedConfigurationFilePath);
var projectWorkspaceState = new ProjectWorkspaceState(Array.Empty <TagHelperDescriptor>(), CodeAnalysis.CSharp.LanguageVersion.Default);
// Act
await RunOnDispatcherThreadAsync(() =>
{
ProjectSnapshotManager.ProjectAdded(hostProject);
ProjectSnapshotManager.ProjectWorkspaceStateChanged(projectFilePath, projectWorkspaceState);
}).ConfigureAwait(false);
// Assert
Assert.True(serializationSuccessful);
}
public DefaultProjectWorkspaceStateGeneratorTest()
{
var tagHelperResolver = new TestTagHelperResolver();
tagHelperResolver.TagHelpers.Add(TagHelperDescriptorBuilder.Create("ResolvableTagHelper", "TestAssembly").Build());
ResolvableTagHelpers = tagHelperResolver.TagHelpers;
var languageServices = new List <ILanguageService>()
{
tagHelperResolver
};
var testServices = TestServices.Create(languageServices);
Workspace = TestWorkspace.Create(testServices);
var projectId = ProjectId.CreateNewId("Test");
var solution = Workspace.CurrentSolution.AddProject(ProjectInfo.Create(
projectId,
VersionStamp.Default,
"Test",
"Test",
LanguageNames.CSharp,
TestProjectData.SomeProject.FilePath));
WorkspaceProject = solution.GetProject(projectId);
ProjectSnapshot = new DefaultProjectSnapshot(ProjectState.Create(Workspace.Services, TestProjectData.SomeProject));
ProjectWorkspaceStateWithTagHelpers = new ProjectWorkspaceState(new[]
{
TagHelperDescriptorBuilder.Create("TestTagHelper", "TestAssembly").Build(),
});
}
public async Task ProjectAdded_DoesNotFireWhenNotReadyAsync()
{
// Arrange
var serializationSuccessful = false;
var expectedConfigurationFilePath = @"C:\path\to\obj\bin\Debug\project.razor.json";
var publisher = new TestProjectRazorJsonPublisher(
ProjectConfigurationFilePathStore,
onSerializeToFile: (snapshot, configurationFilePath) =>
{
Assert.Equal(expectedConfigurationFilePath, configurationFilePath);
serializationSuccessful = true;
},
shouldSerialize: false)
{
_active = true,
};
publisher.Initialize(ProjectSnapshotManager);
var projectFilePath = @"C:\path\to\project.csproj";
var hostProject = new HostProject(projectFilePath, RazorConfiguration.Default, "TestRootNamespace");
ProjectConfigurationFilePathStore.Set(hostProject.FilePath, expectedConfigurationFilePath);
var projectWorkspaceState = new ProjectWorkspaceState(Array.Empty <TagHelperDescriptor>(), CodeAnalysis.CSharp.LanguageVersion.Default);
// Act
await RunOnDispatcherThreadAsync(() =>
{
ProjectSnapshotManager.ProjectAdded(hostProject);
ProjectSnapshotManager.ProjectWorkspaceStateChanged(projectFilePath, projectWorkspaceState);
}).ConfigureAwait(false);
// Assert
Assert.False(serializationSuccessful);
}
public DefaultProjectSnapshotManagerProxyTest()
{
var joinableTaskContext = new JoinableTaskContextNode(new JoinableTaskContext());
JoinableTaskFactory = new JoinableTaskFactory(joinableTaskContext.Context);
Workspace = TestWorkspace.Create();
var projectWorkspaceState1 = new ProjectWorkspaceState(new[]
{
TagHelperDescriptorBuilder.Create("test1", "TestAssembly1").Build(),
});
ProjectSnapshot1 = new DefaultProjectSnapshot(
ProjectState.Create(
Workspace.Services,
new HostProject("/host/path/to/project1.csproj", RazorConfiguration.Default, "project1"),
projectWorkspaceState1));
var projectWorkspaceState2 = new ProjectWorkspaceState(new[]
{
TagHelperDescriptorBuilder.Create("test2", "TestAssembly2").Build(),
});
ProjectSnapshot2 = new DefaultProjectSnapshot(
ProjectState.Create(
Workspace.Services,
new HostProject("/host/path/to/project2.csproj", RazorConfiguration.Default, "project2"),
projectWorkspaceState2));
}
public static TestProjectSnapshot Create(
string filePath,
string[] documentFilePaths,
RazorConfiguration configuration,
ProjectWorkspaceState projectWorkspaceState)
{
var workspaceServices = new List <IWorkspaceService>()
{
new TestProjectSnapshotProjectEngineFactory(),
};
var languageServices = new List <ILanguageService>();
var hostServices = TestServices.Create(workspaceServices, languageServices);
var workspace = TestWorkspace.Create(hostServices);
var hostProject = new HostProject(filePath, configuration, "TestRootNamespace");
var state = ProjectState.Create(workspace.Services, hostProject);
foreach (var documentFilePath in documentFilePaths)
{
var hostDocument = new HostDocument(documentFilePath, documentFilePath);
state = state.WithAddedHostDocument(hostDocument, () => Task.FromResult(TextAndVersion.Create(SourceText.From(string.Empty), VersionStamp.Default)));
}
if (projectWorkspaceState != null)
{
state = state.WithProjectWorkspaceState(projectWorkspaceState);
}
var testProject = new TestProjectSnapshot(state);
return(testProject);
}
private ProjectSnapshotHandleProxy ConvertToProxy(ProjectSnapshot project)
{
var projectWorkspaceState = new ProjectWorkspaceState(project.TagHelpers);
var projectFilePath = _session.ConvertLocalPathToSharedUri(project.FilePath);
var projectHandleProxy = new ProjectSnapshotHandleProxy(projectFilePath, project.Configuration, project.RootNamespace, projectWorkspaceState);
return(projectHandleProxy);
}
protected OmniSharpProjectSnapshot CreateProjectSnapshot(string projectFilePath, string[] documentFilePaths)
{
var projectWorkspaceState = new ProjectWorkspaceState(ImmutableArray <TagHelperDescriptor> .Empty, CodeAnalysis.CSharp.LanguageVersion.Default);
var projectSnapshot = _createWithDocumentsTestProjectSnapshotMethod.Invoke(null, new object[] { projectFilePath, documentFilePaths, projectWorkspaceState });
var omniSharpProjectSnapshot = (OmniSharpProjectSnapshot)_omniSharpSnapshotConstructor.Invoke(new[] { projectSnapshot });
return(omniSharpProjectSnapshot);
}
public override void UpdateProject(
string filePath,
RazorConfiguration configuration,
string rootNamespace,
ProjectWorkspaceState projectWorkspaceState,
IReadOnlyList <DocumentSnapshotHandle> documents)
{
_foregroundDispatcher.AssertForegroundThread();
var normalizedPath = _filePathNormalizer.Normalize(filePath);
var project = (DefaultProjectSnapshot)_projectSnapshotManagerAccessor.Instance.GetLoadedProject(normalizedPath);
if (project == null)
{
// Never tracked the project to begin with, noop.
_logger.LogInformation($"Failed to update untracked project '{filePath}'.");
return;
}
UpdateProjectDocuments(documents, project.FilePath);
if (!projectWorkspaceState.Equals(ProjectWorkspaceState.Default))
{
_logger.LogInformation($"Updating project '{filePath}' TagHelpers ({projectWorkspaceState.TagHelpers.Count}) and C# Language Version ({projectWorkspaceState.CSharpLanguageVersion}).");
}
_projectSnapshotManagerAccessor.Instance.ProjectWorkspaceStateChanged(project.FilePath, projectWorkspaceState);
var currentHostProject = project.HostProject;
var currentConfiguration = currentHostProject.Configuration;
if (currentConfiguration.ConfigurationName == configuration?.ConfigurationName &&
currentHostProject.RootNamespace == rootNamespace)
{
_logger.LogTrace($"Updating project '{filePath}'. The project is already using configuration '{configuration.ConfigurationName}' and root namespace '{rootNamespace}'.");
return;
}
if (configuration == null)
{
configuration = RazorDefaults.Configuration;
_logger.LogInformation($"Updating project '{filePath}' to use Razor's default configuration ('{configuration.ConfigurationName}')'.");
}
else if (currentConfiguration.ConfigurationName != configuration.ConfigurationName)
{
_logger.LogInformation($"Updating project '{filePath}' to Razor configuration '{configuration.ConfigurationName}' with language version '{configuration.LanguageVersion}'.");
}
if (currentHostProject.RootNamespace != rootNamespace)
{
_logger.LogInformation($"Updating project '{filePath}''s root namespace to '{rootNamespace}'.");
}
var hostProject = new HostProject(project.FilePath, configuration, rootNamespace);
_projectSnapshotManagerAccessor.Instance.ProjectConfigurationChanged(hostProject);
}
public ProjectSnapshotSynchronizationServiceTest()
{
var joinableTaskContext = new JoinableTaskContextNode(new JoinableTaskContext());
JoinableTaskFactory = new JoinableTaskFactory(joinableTaskContext.Context);
SessionContext = new TestCollaborationSession(isHost: false);
ProjectSnapshotManager = new TestProjectSnapshotManager(Workspace);
ProjectWorkspaceStateWithTagHelpers = new ProjectWorkspaceState(new[]
{
TagHelperDescriptorBuilder.Create("TestTagHelper", "TestAssembly").Build()
});
}
public SerializationTest()
{
var languageVersion = RazorLanguageVersion.Experimental;
var extensions = new RazorExtension[]
{
new SerializedRazorExtension("TestExtension"),
};
Configuration = RazorConfiguration.Create(languageVersion, "Custom", extensions);
ProjectWorkspaceState = new ProjectWorkspaceState(new[]
{
TagHelperDescriptorBuilder.Create("Test", "TestAssembly").Build(),
},
LanguageVersion.LatestMajor);
var converterCollection = new JsonConverterCollection();
converterCollection.RegisterRazorConverters();
Converters = converterCollection.ToArray();
}
public ProjectSnapshotSynchronizationServiceTest()
{
var joinableTaskContext = new JoinableTaskContextNode(new JoinableTaskContext());
JoinableTaskFactory = new JoinableTaskFactory(joinableTaskContext.Context);
var collabSession = new TestCollaborationSession(isHost: false);
SessionAccessor = Mock.Of <LiveShareSessionAccessor>(accessor => accessor.IsGuestSessionActive == true && accessor.Session == collabSession);
ProjectSnapshotManager = new TestProjectSnapshotManager(Workspace);
ProjectWorkspaceStateWithTagHelpers = new ProjectWorkspaceState(new[]
{
TagHelperDescriptorBuilder.Create("TestTagHelper", "TestAssembly").Build()
});
}
public void UpdateProject_UpdatesProjectWorkspaceState()
{
// Arrange
var projectManager = TestProjectSnapshotManager.Create(Dispatcher);
var hostProject = new HostProject("/path/to/project.csproj", RazorConfiguration.Default, "TestRootNamespace");
projectManager.ProjectAdded(hostProject);
var projectService = CreateProjectService(Mock.Of <ProjectResolver>(), projectManager);
var projectWorkspaceState = new ProjectWorkspaceState(Array.Empty <TagHelperDescriptor>(), LanguageVersion.LatestMajor);
// Act
projectService.UpdateProject(hostProject.FilePath, hostProject.Configuration, hostProject.RootNamespace, projectWorkspaceState, EmptyDocuments);
// Assert
var project = projectManager.GetLoadedProject(hostProject.FilePath);
Assert.Same(projectWorkspaceState, project.ProjectWorkspaceState);
}
public ProjectSnapshotHandleProxy(
Uri filePath,
RazorConfiguration configuration,
ProjectWorkspaceState projectWorkspaceState)
{
if (filePath == null)
{
throw new ArgumentNullException(nameof(filePath));
}
if (configuration == null)
{
throw new ArgumentNullException(nameof(configuration));
}
FilePath = filePath;
Configuration = configuration;
ProjectWorkspaceState = projectWorkspaceState;
}
public void ProjectChanged_ProcessesNotifications_AndGoesBackToSleep()
{
// Arrange
var projectManager = TestProjectSnapshotManager.Create(Dispatcher);
projectManager.ProjectAdded(HostProject1);
projectManager.ProjectAdded(HostProject2);
projectManager.DocumentAdded(HostProject1, Documents[0], null);
projectManager.DocumentOpened(HostProject1.FilePath, Documents[0].FilePath, SourceText.From(string.Empty));
projectManager.AllowNotifyListeners = true;
var queue = new TestOpenDocumentGenerator(Dispatcher)
{
Delay = TimeSpan.FromMilliseconds(1),
BlockBackgroundWorkStart = new ManualResetEventSlim(initialState: false),
NotifyBackgroundWorkStarting = new ManualResetEventSlim(initialState: false),
BlockBackgroundWorkCompleting = new ManualResetEventSlim(initialState: false),
NotifyBackgroundWorkCompleted = new ManualResetEventSlim(initialState: false),
};
queue.Initialize(projectManager);
var newWorkspaceState = new ProjectWorkspaceState(Array.Empty <TagHelperDescriptor>(), LanguageVersion.CSharp7_3);
// Act & Assert
projectManager.ProjectWorkspaceStateChanged(HostProject1.FilePath, newWorkspaceState);
Assert.True(queue.IsScheduledOrRunning, "Queue should be scheduled during Enqueue");
Assert.True(queue.HasPendingNotifications, "Queue should have a notification created during Enqueue");
// Allow the background work to proceed.
queue.BlockBackgroundWorkStart.Set();
queue.BlockBackgroundWorkCompleting.Set();
Assert.True(queue.NotifyBackgroundWorkCompleted.Wait(TimeSpan.FromSeconds(3)));
Assert.False(queue.IsScheduledOrRunning, "Queue should not have restarted");
Assert.False(queue.HasPendingNotifications, "Queue should have processed all notifications");
}
public async Task ProjectAdded_DoesNotFireWhenNotReadyAsync()
{
// Arrange
var serializationSuccessful = false;
var expectedConfigurationFilePath = "/path/to/obj/bin/Debug/project.razor.json";
var publisher = new TestDefaultRazorProjectChangePublisher(
ProjectConfigurationFilePathStore,
RazorLogger,
onSerializeToFile: (snapshot, configurationFilePath) =>
{
Assert.Equal(expectedConfigurationFilePath, configurationFilePath);
serializationSuccessful = true;
},
shouldSerialize: false)
{
_active = true,
};
publisher.Initialize(ProjectSnapshotManager);
var projectFilePath = "/path/to/project.csproj";
var hostProject = new HostProject(projectFilePath, RazorConfiguration.Default, "TestRootNamespace");
ProjectConfigurationFilePathStore.Set(hostProject.FilePath, expectedConfigurationFilePath);
var projectWorkspaceState = new ProjectWorkspaceState(Array.Empty <TagHelperDescriptor>(), CodeAnalysis.CSharp.LanguageVersion.Default);
// Act
await RunOnForegroundAsync(() =>
{
ProjectSnapshotManager.ProjectAdded(hostProject);
ProjectSnapshotManager.ProjectWorkspaceStateChanged(projectFilePath, projectWorkspaceState);
}).ConfigureAwait(false);
// Assert
var kvp = Assert.Single(publisher._deferredPublishTasks);
await kvp.Value.ConfigureAwait(false);
Assert.False(serializationSuccessful);
}
private DocumentSnapshot CreateRazorDocumentSnapshot(RazorProjectEngine projectEngine, TestRazorProjectItem item, string rootNamespaceName, IReadOnlyList <TagHelperDescriptor> tagHelpers)
{
var codeDocument = projectEngine.ProcessDesignTime(item);
var namespaceNode = (NamespaceDeclarationIntermediateNode)codeDocument
.GetDocumentIntermediateNode()
.FindDescendantNodes <IntermediateNode>()
.FirstOrDefault(n => n is NamespaceDeclarationIntermediateNode);
namespaceNode.Content = rootNamespaceName;
var sourceText = SourceText.From(new string(item.Content));
var projectWorkspaceState = new ProjectWorkspaceState(tagHelpers, LanguageVersion.Default);
var projectSnapshot = TestProjectSnapshot.Create("C:/project.csproj", projectWorkspaceState);
var documentSnapshot = Mock.Of <DocumentSnapshot>(d =>
d.GetGeneratedOutputAsync() == Task.FromResult(codeDocument) &&
d.FilePath == item.FilePath &&
d.FileKind == FileKinds.Component &&
d.GetTextAsync() == Task.FromResult(sourceText) &&
d.Project == projectSnapshot, MockBehavior.Strict);
return(documentSnapshot);
}
public FullProjectSnapshotHandle(
string filePath,
RazorConfiguration configuration,
string rootNamespace,
ProjectWorkspaceState projectWorkspaceState,
IReadOnlyList <DocumentSnapshotHandle> documents)
{
if (filePath == null)
{
throw new ArgumentNullException(nameof(filePath));
}
if (documents == null)
{
throw new ArgumentNullException(nameof(documents));
}
FilePath = filePath;
Configuration = configuration;
RootNamespace = rootNamespace;
ProjectWorkspaceState = projectWorkspaceState;
Documents = documents;
}
public async Task ProjectAdded_PublishesToCorrectFilePathAsync()
{
// Arrange
var snapshotManager = CreateProjectSnapshotManager(allowNotifyListeners: true);
var serializationSuccessful = false;
var expectedPublishFilePath = "/path/to/obj/bin/Debug/project.razor.json";
var publisher = new TestDefaultRazorProjectChangePublisher(
JoinableTaskContext,
RazorLogger,
onSerializeToFile: (snapshot, publishFilePath) =>
{
Assert.Equal(expectedPublishFilePath, publishFilePath);
serializationSuccessful = true;
});
publisher.Initialize(snapshotManager);
var projectFilePath = "/path/to/project.csproj";
var hostProject = new HostProject(projectFilePath, RazorConfiguration.Default, "TestRootNamespace");
publisher.SetPublishFilePath(hostProject.FilePath, expectedPublishFilePath);
var projectWorkspaceState = new ProjectWorkspaceState(Array.Empty <TagHelperDescriptor>(), CodeAnalysis.CSharp.LanguageVersion.Default);
// Act
await RunOnForegroundAsync(() =>
{
snapshotManager.ProjectAdded(hostProject);
snapshotManager.ProjectWorkspaceStateChanged(projectFilePath, projectWorkspaceState);
}).ConfigureAwait(false);
// Assert
var kvp = Assert.Single(publisher._deferredPublishTasks);
await kvp.Value.ConfigureAwait(false);
Assert.True(serializationSuccessful);
}
internal static ProjectSnapshot CreateProjectSnapshot(string projectFilePath, ProjectWorkspaceState projectWorkspaceState = null, string[] documentFilePaths = null)
{
if (documentFilePaths is null)
{
documentFilePaths = Array.Empty <string>();
}
var testProjectSnapshot = TestProjectSnapshot.Create(projectFilePath, documentFilePaths, projectWorkspaceState);
return(testProjectSnapshot);
}
public abstract void ProjectWorkspaceStateChanged(string projectFilePath, ProjectWorkspaceState projectWorkspaceState);
public abstract void UpdateProject(
string filePath,
RazorConfiguration configuration,
string rootNamespace,
ProjectWorkspaceState projectWorkspaceState,
IReadOnlyList <DocumentSnapshotHandle> documents);
public static TestProjectSnapshot Create(string filePath, string[] documentFilePaths, ProjectWorkspaceState projectWorkspaceState = null) => Create(filePath, documentFilePaths, RazorConfiguration.Default, projectWorkspaceState);
public static TestProjectSnapshot Create(string filePath, ProjectWorkspaceState projectWorkspaceState = null) => Create(filePath, Array.Empty <string>(), projectWorkspaceState);
internal ProjectSnapshot CreateProjectSnapshot(string projectFilePath, ProjectWorkspaceState projectWorkspaceState = null)
{
var testProjectSnapshot = TestProjectSnapshot.Create(projectFilePath, projectWorkspaceState);
return(testProjectSnapshot);
}
private void ReportWorkspaceStateChange(string projectFilePath, ProjectWorkspaceState workspaceStateChange)
{
_foregroundDispatcher.AssertForegroundThread();
_projectManager.ProjectWorkspaceStateChanged(projectFilePath, workspaceStateChange);
}
public override void ProjectWorkspaceStateChanged(string projectFilePath, ProjectWorkspaceState projectWorkspaceState)
{
InternalProjectSnapshotManager.ProjectWorkspaceStateChanged(projectFilePath, projectWorkspaceState);
}
public static TestProjectSnapshot Create(string filePath, ProjectWorkspaceState projectWorkspaceState = null) => Create(filePath, new string[0], projectWorkspaceState);
private async Task UpdateWorkspaceStateAsync(Project workspaceProject, ProjectSnapshot projectSnapshot, CancellationToken cancellationToken)
{
try
{
_foregroundDispatcher.AssertBackgroundThread();
OnStartingBackgroundWork();
if (cancellationToken.IsCancellationRequested)
{
// Silently cancel, we're the only ones creating these tasks.
return;
}
var workspaceState = ProjectWorkspaceState.Default;
try
{
if (workspaceProject != null)
{
var tagHelperResolutionResult = await _tagHelperResolver.GetTagHelpersAsync(workspaceProject, projectSnapshot, cancellationToken);
workspaceState = new ProjectWorkspaceState(tagHelperResolutionResult.Descriptors);
}
}
catch (Exception ex)
{
await Task.Factory.StartNew(
() => _projectManager.ReportError(ex, projectSnapshot),
CancellationToken.None, // Don't allow errors to be cancelled
TaskCreationOptions.None,
_foregroundDispatcher.ForegroundScheduler).ConfigureAwait(false);
return;
}
if (cancellationToken.IsCancellationRequested)
{
// Silently cancel, we're the only ones creating these tasks.
return;
}
await Task.Factory.StartNew(
() =>
{
if (cancellationToken.IsCancellationRequested)
{
return;
}
ReportWorkspaceStateChange(projectSnapshot.FilePath, workspaceState);
},
cancellationToken,
TaskCreationOptions.None,
_foregroundDispatcher.ForegroundScheduler).ConfigureAwait(false);
}
catch (Exception ex)
{
// This is something totally unexpected, let's just send it over to the project manager.
await Task.Factory.StartNew(
() => _projectManager.ReportError(ex),
CancellationToken.None, // Don't allow errors to be cancelled
TaskCreationOptions.None,
_foregroundDispatcher.ForegroundScheduler).ConfigureAwait(false);
}
OnBackgroundWorkCompleted();
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
if (reader.TokenType != JsonToken.StartObject)
{
return(null);
}
string serializationFormat = null;
string filePath = null;
RazorConfiguration configuration = null;
string rootNamespace = null;
ProjectWorkspaceState projectWorkspaceState = null;
DocumentSnapshotHandle[] documents = null;
reader.ReadProperties(propertyName =>
{
switch (propertyName)
{
case SerializationFormatPropertyName:
if (reader.Read())
{
serializationFormat = (string)reader.Value;
}
break;
case nameof(FullProjectSnapshotHandle.FilePath):
if (reader.Read())
{
filePath = (string)reader.Value;
}
break;
case nameof(FullProjectSnapshotHandle.Configuration):
if (reader.Read())
{
configuration = RazorConfigurationJsonConverter.Instance.ReadJson(reader, objectType, existingValue, serializer) as RazorConfiguration;
}
break;
case nameof(FullProjectSnapshotHandle.RootNamespace):
if (reader.Read())
{
rootNamespace = (string)reader.Value;
}
break;
case nameof(FullProjectSnapshotHandle.ProjectWorkspaceState):
if (reader.Read())
{
projectWorkspaceState = serializer.Deserialize <ProjectWorkspaceState>(reader);
}
break;
case nameof(FullProjectSnapshotHandle.Documents):
if (reader.Read())
{
documents = serializer.Deserialize <DocumentSnapshotHandle[]>(reader);
}
break;
}
});
// We need to add a serialization format to the project response to indicate that this version of the code is compatible with what's being serialized.
// This scenario typically happens when a user has an incompatible serialized project snapshot but is using the latest Razor bits.
if (string.IsNullOrEmpty(serializationFormat) || serializationFormat != ProjectSerializationFormat.Version)
{
// Unknown serialization format.
return(null);
}
return(new FullProjectSnapshotHandle(filePath, configuration, rootNamespace, projectWorkspaceState, documents));
}
