public bool TryParseGeneratedFilePath(
string filePath,
[NotNullWhen(true)] out ProjectId?projectId,
[NotNullWhen(true)] out string?generatorTypeName,
[NotNullWhen(true)] out string?generatedSourceHintName)
{
if (!filePath.StartsWith(_temporaryDirectory))
{
projectId = null;
generatorTypeName = null;
generatedSourceHintName = null;
return(false);
}
string fileName = Path.GetFileName(filePath);
string[] parts = fileName.Split(new[] { '_' }, count: 3);
generatorTypeName = parts[1];
generatedSourceHintName = parts[2];
projectId = ProjectId.CreateFromSerialized(Guid.Parse(new FileInfo(filePath).Directory.Name));
return(true);
}
public static ProjectId DeserializeProjectId(ObjectReader reader, CancellationToken cancellationToken)
{
var guid = new Guid(reader.ReadArray <byte>());
var debugName = reader.ReadString();
return(ProjectId.CreateFromSerialized(guid, debugName));
}
private (Project project, ISymbol symbol) TryResolveSymbolInCurrentSolution(
Workspace workspace,
string symbolKey
)
{
if (
!Properties.TryGetValue(
MetadataSymbolOriginatingProjectIdGuid,
out var projectIdGuid
)
|| !Properties.TryGetValue(
MetadataSymbolOriginatingProjectIdDebugName,
out var projectDebugName
)
)
{
return (null, null);
}
var project = workspace.CurrentSolution.GetProject(
ProjectId.CreateFromSerialized(Guid.Parse(projectIdGuid), projectDebugName)
);
if (project == null)
{
return (null, null);
}
var compilation = project
.GetCompilationAsync(CancellationToken.None)
.WaitAndGetResult(CancellationToken.None);
var symbol = SymbolKey.ResolveString(symbolKey, compilation).Symbol;
return (project, symbol);
}
/// <summary>
/// Adds a result to an existing Roslyn workspace.
/// </summary>
/// <param name="analyzerResult">The results from building a Buildalyzer project analyzer.</param>
/// <param name="workspace">A Roslyn workspace.</param>
/// <param name="addProjectReferences">
/// <c>true</c> to add projects to the workspace for project references that exist in the same <see cref="AnalyzerManager"/>.
/// If <c>true</c> this will trigger (re)building all referenced projects. Directly add <see cref="AnalyzerResult"/> instances instead if you already have them available.
/// </param>
/// <returns>The newly added Roslyn project, or <c>null</c> if the project couldn't be added to the workspace.</returns>
public static Project AddToWorkspace(this IAnalyzerResult analyzerResult, Workspace workspace, bool addProjectReferences = false)
{
if (analyzerResult == null)
{
throw new ArgumentNullException(nameof(analyzerResult));
}
if (workspace == null)
{
throw new ArgumentNullException(nameof(workspace));
}
// Get or create an ID for this project
ProjectId projectId = ProjectId.CreateFromSerialized(analyzerResult.ProjectGuid);
// Cache the project references
analyzerResult.Manager.WorkspaceProjectReferences[projectId.Id] = analyzerResult.ProjectReferences.ToArray();
// Create and add the project, but only if it's a support Roslyn project type
ProjectInfo projectInfo = GetProjectInfo(analyzerResult, workspace, projectId);
if (projectInfo is null)
{
// Something went wrong (maybe not a support project type), so don't add this project
return(null);
}
Solution solution = workspace.CurrentSolution.AddProject(projectInfo);
// Check if this project is referenced by any other projects in the workspace
foreach (Project existingProject in solution.Projects.ToArray())
{
if (!existingProject.Id.Equals(projectId) &&
analyzerResult.Manager.WorkspaceProjectReferences.TryGetValue(existingProject.Id.Id, out string[] existingReferences) &&
public ProjectId?Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
try
{
if (reader.TryReadNil())
{
return(null);
}
Contract.ThrowIfFalse(reader.ReadArrayHeader() == 2);
var id = GuidFormatter.Instance.Deserialize(ref reader, options);
var debugName = reader.ReadString();
var previousId = _previousProjectId;
if (previousId is not null && previousId.Id == id && previousId.DebugName == debugName)
{
return(previousId);
}
var currentId = ProjectId.CreateFromSerialized(id, debugName);
_previousProjectId = currentId;
return(currentId);
}
catch (Exception e) when(e is not MessagePackSerializationException)
{
throw new MessagePackSerializationException(e.Message, e);
}
}
public void ProjectSnapshotHandleJsonConverter_Serialization_CanKindaRoundTrip()
{
// Arrange
var snapshot = new ProjectSnapshotHandle(
"Test.csproj",
new ProjectSystemRazorConfiguration(
RazorLanguageVersion.Version_1_1,
"Test",
new[]
{
new ProjectSystemRazorExtension("Test-Extension1"),
new ProjectSystemRazorExtension("Test-Extension2"),
}),
ProjectId.CreateFromSerialized(Guid.NewGuid(), "Test"));
// Act
var json = JsonConvert.SerializeObject(snapshot, Converters);
var obj = JsonConvert.DeserializeObject <ProjectSnapshotHandle>(json, Converters);
// Assert
Assert.Equal(snapshot.FilePath, obj.FilePath);
Assert.Equal(snapshot.Configuration.ConfigurationName, obj.Configuration.ConfigurationName);
Assert.Collection(
snapshot.Configuration.Extensions.OrderBy(e => e.ExtensionName),
e => Assert.Equal("Test-Extension1", e.ExtensionName),
e => Assert.Equal("Test-Extension2", e.ExtensionName));
Assert.Equal(snapshot.Configuration.LanguageVersion, obj.Configuration.LanguageVersion);
Assert.Equal(snapshot.WorkspaceProjectId.Id, obj.WorkspaceProjectId.Id);
}
public async Task TrackChangesAsync(CancellationToken cancellationToken)
{
var guids = await _callbackService.InvokeAsync <List <Guid> >(
_owner,
nameof(ICodeLensContext.GetDocumentId),
new object[] { Descriptor.ProjectGuid, Descriptor.FilePath },
cancellationToken).ConfigureAwait(false);
if (guids == null)
{
return;
}
var documentId = DocumentId.CreateFromSerialized(
ProjectId.CreateFromSerialized(guids[0], Descriptor.ProjectGuid.ToString()),
guids[1],
Descriptor.FilePath);
if (documentId == null)
{
return;
}
// this asks Roslyn OOP to start track workspace changes and call back Invalidate on this type when there is one.
// each data point owns 1 connection which is alive while data point is alive. and all communication is done through
// that connection
await _endPoint.InvokeAsync(
nameof(IRemoteCodeLensReferencesService.TrackCodeLensAsync),
new object[] { documentId },
cancellationToken).ConfigureAwait(false);
}
public static SupportedPlatformData GetSupportedPlatforms(
CompletionItem item,
Workspace workspace
)
{
if (
item.Properties.TryGetValue("InvalidProjects", out var invalidProjects) &&
item.Properties.TryGetValue("CandidateProjects", out var candidateProjects)
)
{
return(new SupportedPlatformData(
invalidProjects
.Split(projectSeperators)
.Select(s => ProjectId.CreateFromSerialized(Guid.Parse(s)))
.ToList(),
candidateProjects
.Split(projectSeperators)
.Select(s => ProjectId.CreateFromSerialized(Guid.Parse(s)))
.ToList(),
workspace
));
}
return(null);
}
/// <summary>
/// Adds a result to an existing Roslyn workspace.
/// </summary>
/// <param name="analyzerResult">The results from building a Buildalyzer project analyzer.</param>
/// <param name="workspace">A Roslyn workspace.</param>
/// <param name="addProjectReferences">
/// <c>true</c> to add projects to the workspace for project references that exist in the same <see cref="AnalyzerManager"/>.
/// If <c>true</c> this will trigger (re)building all referenced projects. Directly add <see cref="AnalyzerResult"/> instances instead if you already have them available.
/// </param>
/// <returns>The newly added Roslyn project.</returns>
public static Project AddToWorkspace(this AnalyzerResult analyzerResult, Workspace workspace, bool addProjectReferences = false)
{
if (analyzerResult == null)
{
throw new ArgumentNullException(nameof(analyzerResult));
}
if (workspace == null)
{
throw new ArgumentNullException(nameof(workspace));
}
// Get or create an ID for this project
ProjectId projectId = ProjectId.CreateFromSerialized(analyzerResult.ProjectGuid);
// Cache the project references
_projectReferences.AddOrUpdate(projectId, _ => analyzerResult.ProjectReferences.ToArray(), (_, __) => analyzerResult.ProjectReferences.ToArray());
// Create and add the project
ProjectInfo projectInfo = GetProjectInfo(analyzerResult, workspace, projectId);
Solution solution = workspace.CurrentSolution.AddProject(projectInfo);
// Check if this project is referenced by any other projects in the workspace
foreach (Project existingProject in solution.Projects.ToArray())
{
if (!existingProject.Id.Equals(projectId) &&
_projectReferences.TryGetValue(existingProject.Id, out string[] existingReferences) &&
public async Task <LSP.CompletionItem> HandleRequestAsync(LSP.CompletionItem completionItem, RequestContext context, CancellationToken cancellationToken)
{
if (!(completionItem.Data is CompletionResolveData data))
{
data = ((JToken)completionItem.Data).ToObject <CompletionResolveData>();
}
var documentId = DocumentId.CreateFromSerialized(ProjectId.CreateFromSerialized(data.ProjectGuid), data.DocumentGuid);
var document = context.Solution.GetAdditionalDocument(documentId);
if (document == null)
{
return(completionItem);
}
int offset = await document.GetPositionFromLinePositionAsync(ProtocolConversions.PositionToLinePosition(data.Position), cancellationToken).ConfigureAwait(false);
var completionService = document.Project.LanguageServices.GetRequiredService <IXamlCompletionService>();
var symbol = await completionService.GetSymbolAsync(new XamlCompletionContext(document, offset), completionItem.Label, cancellationToken : cancellationToken).ConfigureAwait(false);
if (symbol == null)
{
return(completionItem);
}
var description = await symbol.GetDescriptionAsync(document, offset, cancellationToken).ConfigureAwait(false);
var vsCompletionItem = CloneVSCompletionItem(completionItem);
vsCompletionItem.Description = new ClassifiedTextElement(description.Select(tp => new ClassifiedTextRun(tp.Tag.ToClassificationTypeName(), tp.Text)));
return(vsCompletionItem);
}
public bool TryParseGeneratedFilePath(
string filePath,
[NotNullWhen(true)] out ProjectId?projectId,
[NotNullWhen(true)] out string?generatorTypeName,
[NotNullWhen(true)] out string?generatorAssemblyName,
[NotNullWhen(true)] out string?generatedSourceHintName)
{
if (!filePath.StartsWith(_temporaryDirectory))
{
projectId = null;
generatorTypeName = null;
generatorAssemblyName = null;
generatedSourceHintName = null;
return(false);
}
var fileInfo = new FileInfo(filePath);
var generatorDir = fileInfo.Directory;
var assemblyDir = generatorDir.Parent;
var projectDir = assemblyDir.Parent;
generatorTypeName = generatorDir.Name;
generatorAssemblyName = assemblyDir.Name;
generatedSourceHintName = fileInfo.Name;
projectId = ProjectId.CreateFromSerialized(Guid.Parse(projectDir.Name));
return(true);
}
private void LoadSolution(string path)
{
Logger.Log("loading solution: " + path);
string dir = Path.GetDirectoryName(path);
SolutionId solutionId = SolutionId.CreateNewId();
VersionStamp version = VersionStamp.Create();
SolutionInfo solutionInfo = SolutionInfo.Create(solutionId, version, path);
solution = workspace.AddSolution(solutionInfo);
using (FileStream file = File.OpenRead(path))
{
using StreamReader reader = new StreamReader(file);
while (reader.EndOfStream == false)
{
string line = reader.ReadLine();
if (line.StartsWith("Project"))
{
string pattern = @"^Project\(""\{.+?\}""\) = ""(\w+?)"", ""(.+?)"", ""\{(.+?)\}""";
Match match = Regex.Match(line, pattern);
string projectName = match.Groups[1].Value;
string projectPath = Path.Combine(dir, match.Groups[2].Value);
string projectGuid = match.Groups[3].Value;
LoadProject(projectName, projectPath, ProjectId.CreateFromSerialized(Guid.Parse(projectGuid)));
}
}
}
Logger.Log("");
}
public void when_reading_project_then_can_retrieve_info()
{
var props = new Dictionary <string, string>
{
{ "Foo", "Bar" },
{ "CurrentSolutionConfigurationContents",
$@"<CurrentSolutionConfigurationContents xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
<SolutionConfiguration xmlns=''>
<ProjectConfiguration Project='{{F1DB354D-8DB4-476C-9308-08CDC0E411F7}}' AbsolutePath='{ModuleInitializer.BaseDirectory}\Content\CsLibrary\CsLibrary.csproj' BuildProjectInSolution='True'>Debug|AnyCPU</ProjectConfiguration>
<ProjectConfiguration Project='{{3EDE89EC-A461-4E2C-BE95-05F63B96926C}}' AbsolutePath='{ModuleInitializer.BaseDirectory}\Content\PclLibrary\PclLibrary.csproj' BuildProjectInSolution='True'>Debug|AnyCPU</ProjectConfiguration>
</SolutionConfiguration>
</CurrentSolutionConfigurationContents>" }
};
var xml = ProjectReader.Read(Path.Combine(ModuleInitializer.BaseDirectory, @"Content\CsLibrary\CsLibrary.csproj"), props);
var msbuildProject = xml.ToDynamic();
var info = ProjectInfo.Create(
ProjectId.CreateFromSerialized(new Guid((string)msbuildProject["Id"])),
VersionStamp.Default,
(string)msbuildProject["Name"],
(string)msbuildProject["AssemblyName"],
(string)msbuildProject["Language"],
(string)msbuildProject["FilePath"],
outputFilePath: (string)msbuildProject["OutputFilePath"],
projectReferences: ((XElement)msbuildProject.ProjectReferences).Elements("Project").Select(e => new ProjectReference(ProjectId.CreateFromSerialized(new Guid(e.Attribute("Id").Value)))),
metadataReferences: ((XElement)msbuildProject.MetadataReferences).Elements("FilePath").Select(e => MetadataReference.CreateFromFile(e.Value)));
}
public Task <GeneratedDocument> GenerateDocumentAsync(Guid projectIdBytes, string projectDebugName, string filePath, string text, CancellationToken cancellationToken = default(CancellationToken))
{
var projectId = ProjectId.CreateFromSerialized(projectIdBytes, projectDebugName);
var engine = RazorEngine.Create();
RazorSourceDocument source;
using (var stream = new MemoryStream())
{
var bytes = Encoding.UTF8.GetBytes(text);
stream.Write(bytes, 0, bytes.Length);
stream.Seek(0L, SeekOrigin.Begin);
source = RazorSourceDocument.ReadFrom(stream, filePath, Encoding.UTF8);
}
var code = RazorCodeDocument.Create(source);
engine.Process(code);
var csharp = code.GetCSharpDocument();
if (csharp == null)
{
throw new InvalidOperationException();
}
return(Task.FromResult(new GeneratedDocument()
{
Text = csharp.GeneratedCode,
}));
}
public async Task Init(SolutionModel solutionModel)
{
IList <ProjectInfo> projectInfos = new List <ProjectInfo>(solutionModel.Projects.Count);
foreach (var projectModel in solutionModel.Projects)
{
var projectId = ProjectId.CreateFromSerialized(projectModel.Id);
var documentInfos = new List <DocumentInfo>(projectModel.Documents.Count);
var projectReferences = new List <ProjectReference>(projectModel.ProjectToProjectReferences.Count);
var metadataReferences = new List <MetadataReference>(projectModel.ProjectAssemblyReferences.Count);
foreach (var documentModel in projectModel.Documents)
{
documentInfos.Add(DocumentInfo.Create(DocumentId.CreateNewId(projectId), documentModel.Name, null, SourceCodeKind.Regular, null, documentModel.Path));
}
foreach (var projectReference in projectModel.ProjectToProjectReferences)
{
projectReferences.Add(new ProjectReference(ProjectId.CreateFromSerialized(projectReference.Id)));
}
foreach (var projectAssemblyReference in projectModel.ProjectAssemblyReferences)
{
metadataReferences.Add(MetadataReference.CreateFromFile(projectAssemblyReference.LibraryPath));
}
var projectInfo = ProjectInfo.Create(projectId, VersionStamp.Default, projectModel.Name,
projectModel.AssemblyName, LanguageNames.CSharp, projectModel.FilePath, null, null, null,
documentInfos, projectReferences, metadataReferences, null);
projectInfos.Add(projectInfo);
}
_adhocWorkspace.AddSolution(SolutionInfo.Create(SolutionId.CreateFromSerialized(solutionModel.Id),
VersionStamp.Default, solutionModel.FilePath, projectInfos));
}
public static ProjectId ProjectContextToProjectId(ProjectContext projectContext)
{
var delimiter = projectContext.Id.IndexOf('|');
return(ProjectId.CreateFromSerialized(
Guid.Parse(projectContext.Id.Substring(0, delimiter)),
debugName: projectContext.Id.Substring(delimiter + 1)));
}
/// <summary>
/// Adds a project to an existing Roslyn workspace.
/// </summary>
/// <param name="analyzer">The Buildalyzer project analyzer.</param>
/// <param name="workspace">A Roslyn workspace.</param>
/// <param name="addProjectReferences">
/// <c>true</c> to add projects to the workspace for project references that exist in the same
/// <see cref="AnalyzerManager" />.
/// </param>
/// <returns>The newly added Roslyn project.</returns>
public static Project AddToWorkspace(this ProjectAnalyzer analyzer, AdhocWorkspace workspace, bool addProjectReferences = false)
{
if (analyzer == null)
{
throw new ArgumentNullException(nameof(analyzer));
}
if (workspace == null)
{
throw new ArgumentNullException(nameof(workspace));
}
// Get or create an ID for this project
var projectGuid = analyzer.CompiledProject?.GetPropertyValue("ProjectGuid");
var projectId = !string.IsNullOrEmpty(projectGuid) &&
Guid.TryParse(analyzer.CompiledProject?.GetPropertyValue("ProjectGuid"), out var projectIdGuid)
? ProjectId.CreateFromSerialized(projectIdGuid)
: ProjectId.CreateNewId();
// Create and add the project
var projectInfo = GetProjectInfo(analyzer, workspace, projectId);
var solution = workspace.CurrentSolution.AddProject(projectInfo);
// Check if this project is referenced by any other projects in the workspace
foreach (var existingProject in solution.Projects.ToArray())
{
if (!existingProject.Id.Equals(projectId) &&
analyzer.Manager.Projects.TryGetValue(existingProject.FilePath, out var existingAnalyzer) &&
(existingAnalyzer.GetProjectReferences()?.Contains(analyzer.ProjectFilePath) ?? false))
{
// Add the reference to the existing project
var projectReference = new ProjectReference(projectId);
solution = solution.AddProjectReference(existingProject.Id, projectReference);
}
}
// Apply solution changes
if (!workspace.TryApplyChanges(solution))
{
throw new InvalidOperationException("Could not apply workspace solution changes");
}
// Add any project references not already added
if (addProjectReferences)
{
foreach (var referencedAnalyzer in GetReferencedAnalyzerProjects(analyzer))
{
// Check if the workspace contains the project inside the loop since adding one might also add this one due to transitive references
if (!workspace.CurrentSolution.Projects.Any(x => x.FilePath == referencedAnalyzer.ProjectFilePath))
{
AddToWorkspace(referencedAnalyzer, workspace, addProjectReferences);
}
}
}
// Find and return this project
return(workspace.CurrentSolution.GetProject(projectId));
}
public Task <IEnumerable <DirectiveDescriptor> > GetDirectivesAsync(Guid projectIdBytes, string projectDebugName, CancellationToken cancellationToken = default(CancellationToken))
{
var projectId = ProjectId.CreateFromSerialized(projectIdBytes, projectDebugName);
var engine = RazorEngine.Create();
var directives = engine.Features.OfType <IRazorDirectiveFeature>().FirstOrDefault()?.Directives;
return(Task.FromResult(directives ?? Enumerable.Empty <DirectiveDescriptor>()));
}
public async Task <TagHelperResolutionResult> GetTagHelpersAsync(Guid projectIdBytes, string projectDebugName, CancellationToken cancellationToken = default(CancellationToken))
{
var projectId = ProjectId.CreateFromSerialized(projectIdBytes, projectDebugName);
var solution = await GetSolutionAsync(cancellationToken).ConfigureAwait(false);
var project = solution.GetProject(projectId);
var resolver = new DefaultTagHelperResolver(designTime: true);
var result = await resolver.GetTagHelpersAsync(project, cancellationToken).ConfigureAwait(false);
return(result);
}
internal static DocumentId?CreateDocIdFromEquivalenceKey(this FixAllContext fixAllContext)
{
var split = fixAllContext.CodeActionEquivalenceKey.Split(SemicolonSplit, StringSplitOptions.RemoveEmptyEntries);
if (split.Length == 3 &&
string.Equals(split[0], ApiDocEquivalenceKeyPrefix, StringComparison.Ordinal) &&
Guid.TryParse(split[1], out var projectGuid) && projectGuid != Guid.Empty &&
Guid.TryParse(split[2], out var docGuid) && docGuid != Guid.Empty)
{
var projectId = ProjectId.CreateFromSerialized(projectGuid);
return(DocumentId.CreateFromSerialized(projectId, docGuid));
}
return(null);
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
if (reader.TokenType != JsonToken.StartObject)
{
return(null);
}
var obj = JObject.Load(reader);
var filePath = obj[nameof(ProjectSnapshotHandle.FilePath)].Value <string>();
var configuration = obj[nameof(ProjectSnapshotHandle.Configuration)].ToObject <RazorConfiguration>(serializer);
var id = obj[nameof(ProjectSnapshotHandle.WorkspaceProjectId)].Value <string>();
var workspaceProjectId = id == null ? null : ProjectId.CreateFromSerialized(Guid.Parse(id));
return(new ProjectSnapshotHandle(filePath, configuration, workspaceProjectId));
}
public override async Task <CompletionChange> GetChangeAsync(Document document, CompletionItem item, char?commitKey = default(char?), CancellationToken cancellationToken = default(CancellationToken))
{
var projectIdGuid = item.Properties[ProjectGuidKey];
var projectId = ProjectId.CreateFromSerialized(new System.Guid(projectIdGuid));
var project = document.Project.Solution.GetProject(projectId);
var assemblyName = item.DisplayText;
var publicKey = await GetPublicKeyOfProjectAsync(project, cancellationToken).ConfigureAwait(false);
if (!string.IsNullOrEmpty(publicKey))
{
assemblyName += $", PublicKey={ publicKey }";
}
var textChange = new TextChange(item.Span, assemblyName);
return(CompletionChange.Create(textChange));
}
public async Task <LSP.CompletionItem> HandleRequestAsync(LSP.CompletionItem completionItem, RequestContext context, CancellationToken cancellationToken)
{
Contract.ThrowIfNull(context.Solution);
if (completionItem is not VSInternalCompletionItem vsCompletionItem)
{
return(completionItem);
}
CompletionResolveData?data;
if (completionItem.Data is JToken token)
{
data = token.ToObject <CompletionResolveData>();
Assumes.Present(data);
}
else
{
return(completionItem);
}
var documentId = DocumentId.CreateFromSerialized(ProjectId.CreateFromSerialized(data.ProjectGuid), data.DocumentGuid);
var document = context.Solution.GetDocument(documentId) ?? context.Solution.GetAdditionalDocument(documentId);
if (document == null)
{
return(completionItem);
}
var offset = await document.GetPositionFromLinePositionAsync(ProtocolConversions.PositionToLinePosition(data.Position), cancellationToken).ConfigureAwait(false);
var completionService = document.Project.LanguageServices.GetRequiredService <IXamlCompletionService>();
var symbol = await completionService.GetSymbolAsync(new XamlCompletionContext(document, offset), completionItem.Label, cancellationToken : cancellationToken).ConfigureAwait(false);
if (symbol == null)
{
return(completionItem);
}
var options = _globalOptions.GetSymbolDescriptionOptions(document.Project.Language);
var description = await symbol.GetDescriptionAsync(document, options, cancellationToken).ConfigureAwait(false);
vsCompletionItem.Description = new ClassifiedTextElement(description.Select(tp => new ClassifiedTextRun(tp.Tag.ToClassificationTypeName(), tp.Text)));
return(vsCompletionItem);
}
public ProjectId?Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
try
{
if (reader.TryReadNil())
{
return(null);
}
Contract.ThrowIfFalse(reader.ReadArrayHeader() == 2);
var id = GuidFormatter.Instance.Deserialize(ref reader, options);
var debugName = reader.ReadString();
return(ProjectId.CreateFromSerialized(id, debugName));
}
catch (Exception e) when(e is not MessagePackSerializationException)
{
throw new MessagePackSerializationException(e.Message, e);
}
}
public void Write()
{
var log = new TraceLog(5, "log");
var projectId = ProjectId.CreateFromSerialized(
Guid.Parse("5E40F37C-5AB3-495E-A3F2-4A244D177674")
);
var diagnostic = Diagnostic.Create(
EditAndContinueDiagnosticDescriptors.GetDescriptor(
EditAndContinueErrorCode.ErrorReadingFile
),
Location.None,
"file",
"error"
);
log.Write("a");
log.Write("b {0} {1} {2}", 1, "x", 3);
log.Write("c");
log.Write(
"d str={0} projectId={1} summary={2} diagnostic=`{3}`",
(string)null,
projectId,
ProjectAnalysisSummary.RudeEdits,
diagnostic
);
log.Write("e");
log.Write("f");
AssertEx.Equal(
new[]
{
"f",
"b 1 x 3",
"c",
$"d str=<null> projectId=1324595798 summary=RudeEdits diagnostic=`{diagnostic.ToString()}`",
"e"
},
log.GetTestAccessor().Entries.Select(e => e.GetDebuggerDisplay())
);
}
public KordueneWorkspace(SlnFile sln) : this()
{
SlnFile = sln;
var guidSection = sln.Sections.GetSection("ExtensibilityGlobals", SlnSectionType.PostProcess);
var id = SolutionId.CreateFromSerialized(new Guid(guidSection.Properties.GetValue("SolutionGuid")));
var solution = this.CreateSolution(SolutionInfo.Create(id, VersionStamp.Default, sln.FullPath));
foreach (var item in sln.Projects)
{
var proj = ProjectInfo.Create(ProjectId.CreateFromSerialized(new Guid(item.Id)), VersionStamp.Default, item.Name, item.Name, LanguageNames.CSharp, Path.Combine(sln.BaseDirectory, item.FilePath));
proj = AddProjectDocuments(proj);
proj = AddDefaultReferences(proj);
solution = solution.AddProject(proj);
}
var configs = sln.Sections.GetSection("SolutionConfigurationPlatforms");
Configurations.Clear();
foreach (var item in configs.Properties)
{
var configPlat = item.Value.Split("|");
if (!Configurations.Contains(configPlat[0].Replace(" ", string.Empty)))
{
Configurations.Add(configPlat[0]);
}
if (!Platforms.Contains(configPlat[1].Replace(" ", string.Empty)))
{
Platforms.Add(configPlat[1].Replace(" ", string.Empty));
}
}
this.SetCurrentSolution(solution);
LoadProjectSymbols();
}
public async Task <EmitResult> EmitAsync(
Guid guid,
string debugName,
string outputFilePath,
string win32ResourcesPath,
ImmutableArray <ResourceDescription> manifestResources,
EmitOptions options,
string runtimeReferencePath,
byte[] solutionChecksum)
{
var projectId = ProjectId.CreateFromSerialized(guid, debugName);
var solution = await RoslynServices.SolutionService.GetSolutionAsync(new Checksum(solutionChecksum), CancellationToken).ConfigureAwait(false);
var project = solution.GetProject(projectId);
return(await project.EmitAsync(
outputFilePath,
win32ResourcesPath,
manifestResources,
options,
runtimeReferencePath,
CancellationToken).ConfigureAwait(false));
}
private IEnumerable <(string, ProjectIdInfo)> GetProjectPathsAndIdsFromSolution(string solutionFilePath)
{
_logger.LogInformation($"Detecting projects in '{solutionFilePath}'.");
var solutionFile = SolutionFile.ParseFile(solutionFilePath);
var processedProjects = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
var result = new List <(string, ProjectIdInfo)>();
foreach (var project in solutionFile.Projects)
{
if (project.IsNotSupported)
{
continue;
}
// Solution files are assumed to contain relative paths to project files with Windows-style slashes.
var projectFilePath = project.RelativePath.Replace('\\', Path.DirectorySeparatorChar);
projectFilePath = Path.Combine(_environment.TargetDirectory, projectFilePath);
projectFilePath = Path.GetFullPath(projectFilePath);
// Have we seen this project? If so, move on.
if (processedProjects.Contains(projectFilePath))
{
continue;
}
if (string.Equals(Path.GetExtension(projectFilePath), ".csproj", StringComparison.OrdinalIgnoreCase))
{
var projectIdInfo = new ProjectIdInfo(ProjectId.CreateFromSerialized(new Guid(project.ProjectGuid)), true);
result.Add((projectFilePath, projectIdInfo));
}
processedProjects.Add(projectFilePath);
}
return(result);
}
public ProjectId Rehydrate()
{
return(ProjectId.CreateFromSerialized(Id, DebugName));
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
var(id, debugName) = ReadFromJsonObject(reader);
return(ProjectId.CreateFromSerialized(id, debugName));
}
