public async Task <bool> Equals(IVisualStudioProjectFile x, IVisualStudioProjectFile y, IMessageSink messageSink)
{
var areEqual = true;
var generateDocumentationFileAreEqual = await this.CompareSettable(x.GenerateDocumentationFile, y.GenerateDocumentationFile, messageSink, nameof(x.GenerateDocumentationFile));
areEqual &= generateDocumentationFileAreEqual;
var isPackableAreEqual = await this.CompareSettable(x.IsPackable, y.IsPackable, messageSink, nameof(x.IsPackable));
areEqual &= isPackableAreEqual;
var languageVersionAreEqual = await this.CompareSettable(x.LanguageVersion, y.LanguageVersion, messageSink, nameof(x.LanguageVersion));
areEqual &= languageVersionAreEqual;
var noWarnAreEqual = await this.CompareSettable(x.NoWarn, y.NoWarn, messageSink, nameof(x.NoWarn));
areEqual &= noWarnAreEqual;
var outputTypeAreEqual = await this.CompareSettable(x.OutputType, y.OutputType, messageSink, nameof(x.OutputType));
areEqual &= outputTypeAreEqual;
var sdkAreEqual = await this.CompareSettable(x.SDK, y.SDK, messageSink, nameof(x.SDK));
areEqual &= sdkAreEqual;
var targetFrameworkAreEqual = await this.CompareSettable(x.TargetFramework, y.TargetFramework, messageSink, nameof(x.TargetFramework));
areEqual &= targetFrameworkAreEqual;
var packageReferenceComparisonMessageRepository = new InMemoryMessageRepository();
var packageReferencesEqual = await x.PackageReferences.SequenceEqualAsync(y.PackageReferences, DefaultIPackageReferenceEqualityComparer.Instance, this.NowUtcProvider, packageReferenceComparisonMessageRepository, false);
if (!packageReferencesEqual)
{
await messageSink.AddErrorMessageAsync(this.NowUtcProvider, "Package references not equal.");
await messageSink.CopyFromAsync(packageReferenceComparisonMessageRepository);
}
areEqual &= packageReferencesEqual;
var projectReferenceComparisonMessageRepository = new InMemoryMessageRepository();
var projectReferencesEqual = await x.ProjectReferences.SequenceEqualAsync(y.ProjectReferences, DefaultProjectReferenceEqualityComparer.Instance, this.NowUtcProvider, projectReferenceComparisonMessageRepository);
if (!projectReferencesEqual)
{
await messageSink.AddErrorMessageAsync(this.NowUtcProvider, "Project references not equal.");
await messageSink.CopyFromAsync(packageReferenceComparisonMessageRepository);
}
areEqual &= projectReferencesEqual;
return(areEqual);
}
public static List <string> GetDependencyProjectFilePaths(this IVisualStudioProjectFile visualStudioProjectFile)
{
var dependencyProjectFilePaths = visualStudioProjectFile.ProjectReferences
.Select(x => x.ProjectFilePath)
.ToList();
return(dependencyProjectFilePaths);
}
public static void ClearProjectReferences(this IVisualStudioProjectFile visualStudioProjectFile)
{
var projectReferences = visualStudioProjectFile.ProjectReferences.ToList();
foreach (var projectReference in projectReferences)
{
visualStudioProjectFile.RemoveProjectReference(projectReference);
}
}
public static IPackageReference GetPackageReference(this IVisualStudioProjectFile visualStudioProjectFile, string name, string versionString)
{
var hasPackageReference = visualStudioProjectFile.HasPackageReference(name, versionString, out var packageReference);
if (!hasPackageReference)
{
throw new InvalidOperationException($"Project file does not have package reference:\nName: {name}, Version: {versionString}.");
}
return(packageReference);
}
public static void CloneProjectReferencesFrom(this IVisualStudioProjectFile visualStudioProjectFile, IVisualStudioProjectFile source)
{
visualStudioProjectFile.ClearProjectReferences();
var projectReferences = source.ProjectReferences.ToList();
foreach (var projectReference in projectReferences)
{
visualStudioProjectFile.AddNewProjectReferenceFrom(projectReference);
}
}
public static IProjectReference GetProjectReference(this IVisualStudioProjectFile visualStudioProjectFile, string projectFilePath)
{
var hasProjectReference = visualStudioProjectFile.HasProjectReference(projectFilePath, out var projectReference);
if (!hasProjectReference)
{
throw new InvalidOperationException($"Project file does not have project reference:\n${projectFilePath}.");
}
return(projectReference);
}
public static bool RemoveProjectReference(this IVisualStudioProjectFile visualStudioProjectFile, string projectFilePath)
{
var hasProjectReference = visualStudioProjectFile.HasProjectReference(projectFilePath, out var projectReference);
if (!hasProjectReference)
{
return(false);
}
visualStudioProjectFile.RemoveProjectReference(projectReference);
return(true);
}
public static bool RemovePackageReference(this IVisualStudioProjectFile visualStudioProjectFile, string name)
{
var hasPackageReference = visualStudioProjectFile.HasPackageReference(name, out var packageReference);
if (!hasPackageReference)
{
return(false);
}
visualStudioProjectFile.RemovePackageReference(packageReference);
return(true);
}
public Task CopySourceToDestinationAsync(IVisualStudioProjectFile source, IVisualStudioProjectFile destination)
{
destination.GenerateDocumentationFile = source.GenerateDocumentationFile;
destination.IsPackable = source.IsPackable;
destination.LanguageVersion = source.LanguageVersion;
destination.NoWarn = source.NoWarn;
destination.OutputType = source.OutputType;
destination.SDK = source.SDK;
destination.TargetFramework = source.TargetFramework;
destination.ClonePackageReferencesFrom(source);
destination.CloneProjectReferencesFrom(source);
return(Task.CompletedTask);
}
private static async Task AccumulateDependencyProjectFilePathsRecursive(this IVisualStudioProjectFile visualStudioProjectFile, IVisualStudioProjectFileSerializer visualStudioProjectFileSerializer, HashSet <string> pathAccumulator)
{
var dependencyProjectFilePaths = visualStudioProjectFile.GetDependencyProjectFilePaths();
foreach (var projectFilePath in dependencyProjectFilePaths)
{
// Avoid deserializing the same project file multiple times by testing whether the project file has been visited or not.
if (!pathAccumulator.Contains(projectFilePath))
{
pathAccumulator.Add(projectFilePath);
var projectFile = await visualStudioProjectFileSerializer.DeserializeAsync(projectFilePath);
await projectFile.AccumulateDependencyProjectFilePathsRecursive(visualStudioProjectFileSerializer, pathAccumulator);
}
}
}
public async Task SerializeAsync(string actualfilePath, string asFilePath, IVisualStudioProjectFile visualStudioProjectFile, bool overwrite = true)
{
var isXDocumentVisualStudioProjectFile = visualStudioProjectFile is XDocumentVisualStudioProjectFile;
XDocumentVisualStudioProjectFile xDocumentVisualStudioProjectFile;
if (isXDocumentVisualStudioProjectFile)
{
xDocumentVisualStudioProjectFile = visualStudioProjectFile as XDocumentVisualStudioProjectFile;
}
else
{
// If not, create a new XDocument Visual Studio Project File instance, then transform it into the input instance.
xDocumentVisualStudioProjectFile = XDocumentVisualStudioProjectFile.New();
await this.VisualStudioProjectFileTransformer.CopySourceToDestinationAsync(visualStudioProjectFile, xDocumentVisualStudioProjectFile);
}
await this.AsFilePathXDocumentVisualStudioProjectFileSerializer.SerializeAsync(actualfilePath, asFilePath, xDocumentVisualStudioProjectFile, overwrite);
}
public static bool HasPackageReference(this IVisualStudioProjectFile visualStudioProjectFile, string name, string versionString, out IPackageReference packageReference)
{
var hasPackageReferenceByName = visualStudioProjectFile.HasPackageReference(name, out packageReference);
if (!hasPackageReferenceByName)
{
return(false);
}
var versionStringMatches = packageReference.VersionString == versionString;
if (versionStringMatches)
{
return(true);
}
else
{
packageReference = PackageReferenceHelper.None;
return(false);
}
}
public async Task <List <string> > GetProjectReferenceFilePathsRecursive(IVisualStudioProjectFile visualStudioProjectFile)
{
var projectReferenceFilePaths = await visualStudioProjectFile.GetDependencyProjectFilePathsRecursive(this.VisualStudioProjectFileSerializer);
return(projectReferenceFilePaths);
}
public Task <List <string> > GetProjectReferenceFilePaths(IVisualStudioProjectFile visualStudioProjectFile)
{
var projectReferenceFilePaths = visualStudioProjectFile.GetDependencyProjectFilePaths();
return(Task.FromResult(projectReferenceFilePaths));
}
public static async Task <List <string> > GetDependencyProjectFilePathsRecursive(this IVisualStudioProjectFile visualStudioProjectFile, IVisualStudioProjectFileSerializer visualStudioProjectFileSerializer)
{
var pathAccumulator = new HashSet <string>();
await visualStudioProjectFile.AccumulateDependencyProjectFilePathsRecursive(visualStudioProjectFileSerializer, pathAccumulator);
var dependencyProjectFilePaths = pathAccumulator
.OrderBy(x => x)
.ToList();
return(dependencyProjectFilePaths);
}
public static bool HasPackageReference(this IVisualStudioProjectFile visualStudioProjectFile, string name)
{
var hasPackageReference = visualStudioProjectFile.HasPackageReference(name, out _);
return(hasPackageReference);
}
/// <summary>
/// Method name indicates that we clone the package reference, instead of adding the actual instance.
/// </summary>
public static void AddNewPackageReferenceFrom(this IVisualStudioProjectFile visualStudioProjectFile, IPackageReference packageReference)
{
visualStudioProjectFile.AddPackageReference(packageReference.Name, packageReference.VersionString);
}
public static bool HasProjectReference(this IVisualStudioProjectFile visualStudioProjectFile, string projectFilePath)
{
var hasProjectReference = visualStudioProjectFile.HasProjectReference(projectFilePath, out _);
return(hasProjectReference);
}
/// <summary>
/// Method name indicates that we clone the project reference, instead of adding the actual instance.
/// </summary>
public static void AddNewProjectReferenceFrom(this IVisualStudioProjectFile visualStudioProjectFile, IProjectReference projectReference)
{
visualStudioProjectFile.AddProjectReference(projectReference.ProjectFilePath);
}
