public async Task CreateInMemoryImport()
{
if (_unloadCancellationToken.IsCancellationRequested)
{
return;
}
using (var access = await _projectLockService.WriteLockAsync(_unloadCancellationToken)) {
// A bit odd but we have to "check it out" prior to creating it to avoid some of the validations in chk CPS
await access.CheckoutAsync(_inMemoryImportFullPath);
// Now either open or create the in-memory file. Normally Create will happen, but in
// a scenario where your project had previously failed to load for some reason, need to TryOpen
// to avoid a new reason for a project load failure
_inMemoryImport = ProjectRootElement.TryOpen(_inMemoryImportFullPath, access.ProjectCollection);
if (_inMemoryImport != null)
{
// The file already exists. Scrape it out so we don’t add duplicate items.
_inMemoryImport.RemoveAllChildren();
}
else
{
// The project didn’t already exist, so create it, and then mark the evaluated project dirty
// so that MSBuild will notice. This step isn’t necessary if the project was already in memory.
_inMemoryImport = CreateEmptyMsBuildProject(_inMemoryImportFullPath, access.ProjectCollection);
// Note that we actually need to mark every project evaluation dirty that is already loaded.
await ReevaluateLoadedConfiguredProjects(_unloadCancellationToken, access);
}
_filesItemGroup = _inMemoryImport.AddItemGroup();
_directoriesItemGroup = _inMemoryImport.AddItemGroup();
_temporaryAddedItemGroup = _inMemoryImport.AddItemGroup();
}
}
private bool TryWriteProjectsFile(ProjectCollection projectCollection, FileInfo projectsFile)
{
Log.LogMessageFromText($"Generating file '{projectsFile.FullName}'", MessageImportance.Low);
Directory.CreateDirectory(projectsFile.DirectoryName);
ProjectRootElement rootElement = ProjectRootElement.Create(projectsFile.FullName);
ProjectItemGroupElement projectFileItemGroup = rootElement.AddItemGroup();
ProjectItemGroupElement traversalFileItemGroup = rootElement.AddItemGroup();
foreach (Project project in projectCollection.LoadedProjects)
{
if (String.Equals(project.GetPropertyValue("IsTraversal"), "true", StringComparison.OrdinalIgnoreCase))
{
traversalFileItemGroup.AddItem("TraversalFile", project.FullPath);
}
else
{
projectFileItemGroup.AddItem("ProjectFile", project.FullPath);
}
}
rootElement.Save();
return(true);
}
public virtual ProjectRootElement Construct()
{
// Workaround for https://github.com/dotnet/msbuild/issues/2554 when using Microsoft.Build.Construction.ProjectRootElement.Create
var msbuildExePathVarName = "MSBUILD_EXE_PATH";
if (!Builder.UseDotNet && !TestEnvironment.IsWindows)
{
Environment.SetEnvironmentVariable(msbuildExePathVarName, typeof(DotNetXamarinProject).Assembly.Location);
}
ProjectRootElement root = null;
try {
root = ProjectRootElement.Create();
} finally {
if (!Builder.UseDotNet && !TestEnvironment.IsWindows)
{
Environment.SetEnvironmentVariable(msbuildExePathVarName, null);
}
}
if (Packages.Any())
{
root.AddItemGroup().AddItem(BuildActions.None, "packages.config");
}
foreach (var pkg in Packages.Where(p => p.AutoAddReferences))
{
foreach (var reference in pkg.References)
{
if (!References.Any(r => r.Include == reference.Include))
{
References.Add(reference);
}
}
}
foreach (var pg in PropertyGroups)
{
pg.AddElement(root);
}
foreach (var ig in ItemGroupList)
{
var ige = root.AddItemGroup();
foreach (var i in ig)
{
if (i.Deleted)
{
continue;
}
ige.AddItem(i.BuildAction, i.Include(), i.Metadata);
}
}
root.FullPath = ProjectName + Language.DefaultProjectExtension;
return(root);
}
public void ProjectFinishedGenerating(Project project)
{
string PERSISTANCE_FOLDER = "Persistance";
ProjectItem modelsFolder = Utils.GetProjectItemFolder(project, PERSISTANCE_FOLDER)
.FirstOrDefault();
List <string> projectNames = Utils.GetProjectNameFromDTE(project);
if (projectNames.Count() > 0)
{
frmAddProjectsRef addPrjRef = new frmAddProjectsRef(projectNames);
System.Windows.Forms.DialogResult settingResult = addPrjRef.ShowDialog();
IEnumerable <string> selectedProjectNames = frmAddProjectsRef.GetSelectCheckListBox.SelectedItems.OfType <string>().ToArray();
ProjectRootElement projectRoot = ProjectRootElement.Open(project.FullName);
foreach (var selectedPrjName in selectedProjectNames)
{
if (selectedPrjName != project.Name)
{
ProjectItemGroupElement projectGroup01 = projectRoot.AddItemGroup();
projectGroup01.AddItem("ProjectReference", $"..\\{selectedPrjName}\\{selectedPrjName}.csproj");
}
}
projectRoot.Save();
}
// 2020/10/12 後修正為最後才產生 ApplicationDbContext 物件
Utils.CreateDbContextFromSourceTables(project, modelsFolder, projectNames);
}
private void AddDefaultItemsToProject(
SerializableMigrationDefaultsInfo defaults,
ProjectRootElement project,
Dictionary <string, ProjectItemGroupElement> defaultsItemGroups)
{
foreach (var itemInfo in defaults.Items)
{
ProjectItemGroupElement itemGroup;
var parentCondition = itemInfo.ParentCondition ?? string.Empty;
if (!defaultsItemGroups.TryGetValue(parentCondition, out itemGroup))
{
itemGroup = project.AddItemGroup();
itemGroup.Label = c_DefaultsProjectElementContainerLabel;
itemGroup.Condition = parentCondition;
defaultsItemGroups[parentCondition] = itemGroup;
}
var item = itemGroup.AddItem(itemInfo.ItemType, itemInfo.Include);
item.Exclude = itemInfo.Exclude;
item.Remove = itemInfo.Remove;
item.Condition = itemInfo.Condition;
}
}
public void FindItems()
{
ProjectRootElement projectRootElement = ProjectRootElement.Create();
ProjectItemGroupElement itemGroup = projectRootElement.AddItemGroup();
itemGroup.AddItem(AnalyzerItemsPredictor.AnalyzerItemName, "Foo.dll");
itemGroup.AddItem(AnalyzerItemsPredictor.AnalyzerItemName, "Bar.dll");
itemGroup.AddItem(AnalyzerItemsPredictor.AnalyzerItemName, "Baz.dll");
ProjectInstance projectInstance = TestHelpers.CreateProjectInstanceFromRootElement(projectRootElement);
var expectedInputFiles = new[]
{
new PredictedItem("Foo.dll", nameof(AnalyzerItemsPredictor)),
new PredictedItem("Bar.dll", nameof(AnalyzerItemsPredictor)),
new PredictedItem("Baz.dll", nameof(AnalyzerItemsPredictor)),
};
new AnalyzerItemsPredictor()
.GetProjectPredictions(projectInstance)
.AssertPredictions(
projectInstance,
expectedInputFiles,
null,
null,
null);
}
private void MigrateProjectJsonProjectDependency(
Project project,
NuGetFramework framework,
HashSet <string> migratedXProjDependencyNames,
SlnFile solutionFile,
ProjectRootElement outputMSBuildProject)
{
var projectDependencies = _projectDependencyFinder.ResolveAllProjectDependenciesForFramework(
new ProjectDependency(project.Name, project.ProjectFilePath, false),
framework,
migratedXProjDependencyNames,
solutionFile);
var projectDependencyTransformResults =
projectDependencies.Select(p =>
p.Hoisted ?
HoistedDependencyTransform.Transform(p) :
ProjectDependencyTransform.Transform(p));
if (projectDependencyTransformResults.Any())
{
AddProjectDependenciesToNewItemGroup(
outputMSBuildProject.AddItemGroup(),
projectDependencyTransformResults,
framework);
}
HoistFrameworkAssembliesForProjectDependencies(projectDependencies, outputMSBuildProject);
}
private ProjectRootElement CreateProject()
{
Microsoft.Build.Evaluation.Project project = null;
try
{
project = Microsoft.Expression.Project.Build.BuildManager.GetProject(DocumentReference.Create(this.originalProjectFilePath));
}
catch (ArgumentException argumentException)
{
}
ProjectRootElement projectRootElement = ProjectRootElement.Create();
projectRootElement.ToolsVersion = "4.0";
this.AddBuildProperties(projectRootElement, project);
projectRootElement.AddItemGroup();
projectRootElement.AddPropertyGroup();
projectRootElement.AddProperty("IntermediateOutputPath", Microsoft.Expression.Framework.Documents.PathHelper.GetDirectoryNameOrRoot(this.xamlPath));
this.AddAssemblyReferences(projectRootElement, project);
this.AddImports(projectRootElement, project);
if (!this.IsSilverlightApplication(project))
{
this.AddWpfImports(projectRootElement);
}
projectRootElement.AddItem("Page", this.xamlPath);
string str = Microsoft.Expression.Framework.Documents.PathHelper.ResolveCombinedPath(Microsoft.Expression.Framework.Documents.PathHelper.GetDirectoryNameOrRoot(this.xamlPath), "MarkupCompileAssembly.proj");
projectRootElement.Save(str);
return(projectRootElement);
}
private static void ReferenceProject(ProjectRootElement referenced, ProjectRootElement referencing)
{
//get project references
const string itemType = "ProjectReference";
var references = referencing.ItemGroups.FirstOrDefault(g => g.Items.All(i => i.ItemType == itemType)) ??
referencing.AddItemGroup();
var referencedPath = new Uri(referenced.FullPath, UriKind.Absolute);
var referencingPathString = (Path.GetDirectoryName(referencing.FullPath) ?? "") +
Path.DirectorySeparatorChar;
var referencingPath = new Uri(referencingPathString, UriKind.Absolute);
var relPath = referencingPath.MakeRelativeUri(referencedPath).ToString();
//check if it is not there already
if (references.Children.Any(c =>
{
var itemElement = c as ProjectItemElement;
return(itemElement != null && itemElement.Include == relPath);
}))
{
return;
}
references.AddItem(itemType, relPath, new[]
{
new KeyValuePair <string, string>("Project", GetProjectId(referenced)),
new KeyValuePair <string, string>("Name", Path.GetFileNameWithoutExtension(referenced.FullPath))
});
}
private static ProjectInstance CreateTestProjectInstance(string fileName, bool hasProjectReferences = true, bool isEnabled = true)
{
ProjectRootElement projectRootElement = ProjectRootElement.Create($@"ServiceFabricApp\{fileName}");
// These are generally set in Microsoft.VisualStudio.Azure.Fabric.Application.targets
ProjectPropertyGroupElement propertyGroup = projectRootElement.AddPropertyGroup();
propertyGroup.AddProperty(ServiceFabricServiceManifestPredictor.ApplicationPackageRootFolderPropertyName, "ApplicationPackageRoot");
propertyGroup.AddProperty(ServiceFabricServiceManifestPredictor.ServicePackageRootFolderPropertyName, "PackageRoot");
if (isEnabled)
{
propertyGroup.AddProperty(ServiceFabricServiceManifestPredictor.UpdateServiceFabricApplicationManifestEnabledPropertyName, "true");
}
if (hasProjectReferences)
{
ProjectItemGroupElement itemGroup = projectRootElement.AddItemGroup();
itemGroup.AddItem(ServiceFabricServiceManifestPredictor.ProjectReferenceItemName, @"..\Service1\Service1.csproj");
itemGroup.AddItem(ServiceFabricServiceManifestPredictor.ProjectReferenceItemName, @"..\Service2\Service2.csproj");
}
// Extra service manifests, and some extraneous files too
Directory.CreateDirectory(@"ServiceFabricApp\ApplicationPackageRoot");
File.WriteAllText($@"ServiceFabricApp\ApplicationPackageRoot\{ServiceFabricServiceManifestPredictor.ServiceManifestFileName}", "SomeContent"); // Not in a subdir, should not get picked up
File.WriteAllText($@"ServiceFabricApp\ApplicationPackageRoot\extraneous.txt", "SomeContent");
Directory.CreateDirectory(@"ServiceFabricApp\ApplicationPackageRoot\Foo");
File.WriteAllText($@"ServiceFabricApp\ApplicationPackageRoot\Foo\{ServiceFabricServiceManifestPredictor.ServiceManifestFileName}", "SomeContent");
File.WriteAllText($@"ServiceFabricApp\ApplicationPackageRoot\Foo\extraneous.txt", "SomeContent");
Directory.CreateDirectory(@"ServiceFabricApp\ApplicationPackageRoot\Bar");
File.WriteAllText($@"ServiceFabricApp\ApplicationPackageRoot\Bar\{ServiceFabricServiceManifestPredictor.ServiceManifestFileName}", "SomeContent");
File.WriteAllText($@"ServiceFabricApp\ApplicationPackageRoot\Bar\extraneous.txt", "SomeContent");
return(TestHelpers.CreateProjectInstanceFromRootElement(projectRootElement));
}
private void ReplaceReferences(ProjectRootElement project, List <PackageIdentity> packages, ProjectRootElement packagesProps)
{
HashSet <PackageIdentity> allPackages = new HashSet <PackageIdentity>(packages);
Dictionary <ProjectItemElement, PackageIdentity> itemsToReplace = new Dictionary <ProjectItemElement, PackageIdentity>();
foreach (ProjectItemElement itemElement in project.Items.Where(i => i.ItemType.Equals("Reference")))
{
foreach (PackageIdentity packageIdentity in packages)
{
Regex regex = AssemblyReferenceRegularExpressions[packageIdentity];
ProjectMetadataElement metadatum = itemElement.Metadata.FirstOrDefault(i => i.Name.Equals("HintPath"));
if (metadatum != null && regex.IsMatch(metadatum.Value))
{
itemsToReplace.Add(itemElement, packageIdentity);
allPackages.Remove(packageIdentity);
}
}
}
List <PackageIdentity> packagesAdded = new List <PackageIdentity>();
ProjectItemElement firstPackageRef = project.Items.FirstOrDefault(i => i.ItemType.Equals("PackageReference"));
ProjectItemGroupElement packageRefsGroup;
if (firstPackageRef == null)
{
packageRefsGroup = project.AddItemGroup();
}
else
{
packageRefsGroup = (ProjectItemGroupElement)firstPackageRef.Parent;
}
foreach (KeyValuePair <ProjectItemElement, PackageIdentity> pair in itemsToReplace)
{
if (!packagesAdded.Contains(pair.Value))
{
ProjectItemElement item = project.CreateItemElement("PackageReference", pair.Value.Id);
packageRefsGroup.AddItem("PackageReference", pair.Value.Id);
SetPackageVersion(item, pair.Value.Version, packagesProps);
packagesAdded.Add(pair.Value);
}
pair.Key.Parent.RemoveChild(pair.Key);
}
foreach (PackageIdentity package in allPackages)
{
ProjectItemElement item = packageRefsGroup.AddItem("PackageReference", package.Id);
SetPackageVersion(item, package.Version, packagesProps);
}
}
private void MigrateDependencies(
Project project,
ProjectRootElement output,
NuGetFramework framework,
IEnumerable <ProjectLibraryDependency> dependencies,
ProjectRootElement xproj,
SlnFile solutionFile,
ProjectItemGroupElement itemGroup = null)
{
var projectDependencies = new HashSet <string>(GetAllProjectReferenceNames(project, framework, xproj, solutionFile));
var packageDependencies = dependencies.Where(d => !projectDependencies.Contains(d.Name)).ToList();
string condition = framework?.GetMSBuildCondition() ?? "";
itemGroup = itemGroup
?? output.ItemGroups.FirstOrDefault(i => i.Condition == condition)
?? output.AddItemGroup();
itemGroup.Condition = condition;
AutoInjectImplicitProjectJsonAssemblyReferences(framework, packageDependencies);
foreach (var packageDependency in packageDependencies)
{
MigrationTrace.Instance.WriteLine(packageDependency.Name);
AddItemTransform <PackageDependencyInfo> transform;
if (packageDependency.LibraryRange.TypeConstraint == LibraryDependencyTarget.Reference)
{
transform = FrameworkDependencyTransform;
}
else
{
transform = PackageDependencyInfoTransform();
if (packageDependency.Type.Equals(LibraryDependencyType.Build))
{
transform = transform.WithMetadata("PrivateAssets", "All");
}
else if (packageDependency.SuppressParent != LibraryIncludeFlagUtils.DefaultSuppressParent)
{
var metadataValue = ReadLibraryIncludeFlags(packageDependency.SuppressParent);
transform = transform.WithMetadata("PrivateAssets", metadataValue);
}
if (packageDependency.IncludeType != LibraryIncludeFlags.All)
{
var metadataValue = ReadLibraryIncludeFlags(packageDependency.IncludeType);
transform = transform.WithMetadata("IncludeAssets", metadataValue);
}
}
_transformApplicator.Execute(
transform.Transform(ToPackageDependencyInfo(
packageDependency,
PackageConstants.ProjectDependencyPackages)),
itemGroup,
mergeExisting: true);
}
}
private static void AddItems(ProjectRootElement elem, string groupName, params string[] items)
{
var group = elem.AddItemGroup();
foreach (var item in items)
{
group.AddItem(groupName, item);
}
}
private static ProjectInstance CreateTestProjectInstance(string fileName)
{
ProjectRootElement projectRootElement = ProjectRootElement.Create(fileName);
ProjectItemGroupElement itemGroup = projectRootElement.AddItemGroup();
itemGroup.AddItem(AzureCloudServicePredictor.ServiceDefinitionItemName, "ServiceDefinition.csdef");
itemGroup.AddItem(AzureCloudServicePredictor.ServiceConfigurationItemName, "ServiceConfiguration.Local.cscfg");
itemGroup.AddItem(AzureCloudServicePredictor.ServiceConfigurationItemName, "ServiceConfiguration.Prod.cscfg");
return(TestHelpers.CreateProjectInstanceFromRootElement(projectRootElement));
}
public static ProjectRootElement AddPackageVersion(this ProjectRootElement element, string packageName,
string version)
{
var itemGroup = element.ItemGroups.FirstOrDefault() ?? element.AddItemGroup();
var item = itemGroup.AddItem("PackageVersion", packageName);
item.AddMetadata("Version", version, expressAsAttribute: true);
return(element);
}
private void UpdateCSProjectFolders(ProjectRootElement projectRoot)
{
var deletePhysicalName = projectRoot.FullPath; //deleteItem.Properties.Item("FullPath");
string fullPath = deletePhysicalName;
string projectPath = Path.GetDirectoryName(fullPath);
ProjectItemGroupElement group01 = null;
if (Directory.Exists(Path.Combine(projectPath, "Models")))
{
group01 = group01 ?? projectRoot.AddItemGroup();
group01.AddItem("Folder", @"Models\");
}
if (Directory.Exists(Path.Combine(projectPath, "Views")))
{
group01 = group01 ?? projectRoot.AddItemGroup();
group01.AddItem("Folder", @"Views\");
}
}
public void Generate(string outputPath, string propertyVersionNamePrefix, string propertyPathNamePrefix, PackageRestoreData restoreData)
{
// Delete an existing file in case there are no properties generated and we don't end up saving the file
//
if (File.Exists(outputPath))
{
Retry(() => File.Delete(outputPath), TimeSpan.FromMilliseconds(500));
}
ProjectRootElement project = ProjectRootElement.Create();
ProjectPropertyGroupElement propertyGroup = project.AddPropertyGroup();
propertyGroup.SetProperty("MSBuildAllProjects", "$(MSBuildAllProjects);$(MSBuildThisFileFullPath)");
ProjectItemGroupElement itemGroup = project.AddItemGroup();
bool anyPropertiesCreated = false;
foreach (string packageConfigPath in _packageConfigPaths)
{
_logger.LogMessage(MessageImportance.Low, $"Parsing '{packageConfigPath}'");
IEnumerable <PackageIdentityWithPath> parsedPackages = null;
INuGetPackageConfigParser configParser = null;
// A bug in nuget sometimes causes "NuGet.Configuration.NuGetConfigurationException: Unexpected failure reading NuGet.Config." when multiple instances are running in parrallel such as in the quickbuild scenario.
Retry(() => configParser = _configParsersLazy.Value.FirstOrDefault(i => i.TryGetPackages(packageConfigPath, restoreData, out parsedPackages)), TimeSpan.FromMilliseconds(1000));
if (configParser != null && parsedPackages != null)
{
anyPropertiesCreated = true;
foreach (PackageIdentityWithPath packageInfo in parsedPackages)
{
propertyGroup.SetProperty($"{propertyPathNamePrefix}{packageInfo.Id.Replace(".", "_")}", $"{packageInfo.FullPath}");
propertyGroup.SetProperty($"{propertyVersionNamePrefix}{packageInfo.Id.Replace(".", "_")}", $"{packageInfo.Version.ToString()}");
// Consider adding item metadata of packageid and version for ease of consumption of this property.
itemGroup.AddItem("CBTNuGetPackageDir", packageInfo.FullPath);
}
}
}
// Don't save the file if no properties were created. In Visual Studio design time builds, this can be called multiple times until there are finally
// properties that can be created. If we generate an empty file, it won't get regenerated once there are properties to create.
//
if (anyPropertiesCreated)
{
Retry(() => project.Save(outputPath), TimeSpan.FromMilliseconds(500));
}
}
private static Project CreateTestProject(params string[] compileItemIncludes)
{
ProjectRootElement projectRootElement = ProjectRootElement.Create();
ProjectItemGroupElement itemGroup = projectRootElement.AddItemGroup();
foreach (string compileItemInclude in compileItemIncludes)
{
itemGroup.AddItem("Compile", compileItemInclude);
}
return(TestHelpers.CreateProjectFromRootElement(projectRootElement));
}
private static ProjectInstance CreateTestProjectInstance(IEnumerable <string> availableItemNames, params Tuple <string, string>[] itemNamesAndValues)
{
ProjectRootElement projectRootElement = ProjectRootElement.Create();
// Add Items.
ProjectItemGroupElement itemGroup = projectRootElement.AddItemGroup();
foreach (Tuple <string, string> itemNameAndValue in itemNamesAndValues)
{
itemGroup.AddItem(itemNameAndValue.Item1, itemNameAndValue.Item2);
}
// Add AvailableItemName items referring to the item names we'll add soon.
ProjectItemGroupElement namesItemGroup = projectRootElement.AddItemGroup();
foreach (string availableItemName in availableItemNames)
{
namesItemGroup.AddItem(AvailableItemNameItemsPredictor.AvailableItemName, availableItemName);
}
return(TestHelpers.CreateProjectInstanceFromRootElement(projectRootElement));
}
/// <summary>
/// Adds the item group containting the ProjectConfiguration items to a new project.
/// </summary>
void AddProjectConfigurationsItemGroup()
{
ProjectRootElement file = MSBuildProjectFile;
ProjectItemGroupElement configItemGroup = file.AddItemGroup();
configItemGroup.Label = "ProjectConfigurations";
foreach (var target in new [] { new ConfigurationAndPlatform("Debug", "Win32"), new ConfigurationAndPlatform("Release", "Win32") })
{
ProjectItemElement prjConfiguration = configItemGroup.AddItem("ProjectConfiguration", target.ToString());
prjConfiguration.AddMetadata("Configuration", target.Configuration);
prjConfiguration.AddMetadata("Platform", target.Platform);
}
}
static void AddItems(ProjectRootElement elem, string groupName, params string[] items)
{
ProjectItemGroupElement group = elem.AddItemGroup();
foreach (var item in items)
{
ProjectItemElement projItem = group.AddItem(groupName, item);
//if (groupName == "Compile")
//{
// projItem.AddMetadata("Link", item);
//}
}
}
/// <summary>
/// Adds the item group containting the ProjectConfiguration items to a new project.
/// </summary>
void AddProjectConfigurationsItemGroup()
{
ProjectRootElement file = MSBuildProjectFile;
ProjectItemGroupElement configItemGroup = file.AddItemGroup();
configItemGroup.Label = "ProjectConfigurations";
foreach (string target in new string[] { "Debug|Win32", "Release|Win32" })
{
ProjectItemElement prjConfiguration = configItemGroup.AddItem("ProjectConfiguration", target);
prjConfiguration.AddMetadata("Configuration", GetConfigurationNameFromKey(target));
prjConfiguration.AddMetadata("Platform", GetPlatformNameFromKey(target));
}
}
public void SetCondition()
{
ProjectRootElement project = ProjectRootElement.Create();
project.AddItemGroup();
Helpers.ClearDirtyFlag(project);
ProjectItemGroupElement itemGroup = Helpers.GetFirst(project.ItemGroups);
itemGroup.Condition = "c";
Assert.AreEqual("c", itemGroup.Condition);
Assert.AreEqual(true, project.HasUnsavedChanges);
}
public void SetLabel()
{
ProjectRootElement project = ProjectRootElement.Create();
project.AddItemGroup();
Helpers.ClearDirtyFlag(project);
ProjectItemGroupElement itemGroup = Helpers.GetFirst(project.ItemGroups);
itemGroup.Label = "c";
Assert.Equal("c", itemGroup.Label);
Assert.True(project.HasUnsavedChanges);
}
public RepositoryProject(string repositoryRoot)
{
_doc = ProjectRootElement.Create(NewProjectFileOptions.None);
var import = _doc.CreateImportElement(@"$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props");
var propGroup = _doc.AddPropertyGroup();
if (repositoryRoot[repositoryRoot.Length - 1] != '\\')
{
repositoryRoot += '\\';
}
propGroup.AddProperty("RepositoryRoot", repositoryRoot);
_doc.AddItemGroup();
_doc.PrependChild(import);
_doc.AddImport(@"$(MSBuildToolsPath)\Microsoft.Common.targets");
}
private string GenerateBootstrapper(string manifestFile, string applicationName, string applicationUrl, params string[] prerequisites)
{
// root element
ProjectRootElement xml = ProjectRootElement.Create();
xml.ToolsVersion = "4.0";
xml.DefaultTargets = "BuildBootstrapper";
// build properties
var propertyGroup = xml.AddPropertyGroup();
propertyGroup.AddProperty("TargetFrameworkVersion", "v4.5");
propertyGroup.AddProperty("VisualStudioVersion", "11.0");
// prerequisites (product codes of each required package, e.g. ".NETFramework,Version=v4.5")
var itemGroup = xml.AddItemGroup();
foreach (string productCode in prerequisites)
{
itemGroup.AddItem("BootstrapperFile", productCode);
}
// target
var target = xml.AddTarget("BuildBootstrapper");
var task = target.AddTask("GenerateBootstrapper");
task.SetParameter("ApplicationFile", Path.GetFileName(manifestFile));
task.SetParameter("ApplicationName", applicationName);
task.SetParameter("ApplicationUrl", applicationUrl);
task.SetParameter("BootstrapperItems", "@(BootstrapperFile)");
task.SetParameter("OutputPath", Path.GetDirectoryName(manifestFile));
task.SetParameter("Path", @"C:\Program Files (x86)\Microsoft SDKs\Windows\v8.0A\Bootstrapper"); // replace with actual path
var proj = new ProjectInstance(xml);
var req = new BuildRequestData(proj, new string[] { "BuildBootstrapper" });
var parameters = new BuildParameters();
// optional logging of the build process
var logger = new FileLogger();
Uri codeBase = new Uri(Assembly.GetEntryAssembly().CodeBase);
logger.Parameters = "logfile=" + Path.Combine(Path.GetDirectoryName(codeBase.LocalPath), "msbuild.log");
parameters.Loggers = new ILogger[] { logger };
// build the bootstrapper executable (setup.exe)
var result = BuildManager.DefaultBuildManager.Build(parameters, req);
if (result.OverallResult == BuildResultCode.Failure)
{
throw new InvalidOperationException("MSBuild task failed!", result.Exception);
}
// return path to the built setup.exe
return(Path.Combine(Path.GetDirectoryName(manifestFile), "setup.exe"));
}
private void MigrateDependencies(
Project project,
ProjectRootElement output,
NuGetFramework framework,
IEnumerable <ProjectLibraryDependency> dependencies,
ProjectRootElement xproj)
{
var projectDependencies = new HashSet <string>(GetAllProjectReferenceNames(project, framework, xproj));
var packageDependencies = dependencies.Where(d => !projectDependencies.Contains(d.Name));
string condition = framework?.GetMSBuildCondition() ?? "";
var itemGroup = output.ItemGroups.FirstOrDefault(i => i.Condition == condition)
?? output.AddItemGroup();
itemGroup.Condition = condition;
foreach (var packageDependency in packageDependencies)
{
MigrationTrace.Instance.WriteLine(packageDependency.Name);
AddItemTransform <ProjectLibraryDependency> transform;
if (packageDependency.LibraryRange.TypeConstraint == LibraryDependencyTarget.Reference)
{
transform = FrameworkDependencyTransform;
}
else
{
transform = PackageDependencyTransform();
if (packageDependency.Type == LibraryDependencyType.Build)
{
transform = transform.WithMetadata("PrivateAssets", "all");
}
else if (packageDependency.SuppressParent != LibraryIncludeFlagUtils.DefaultSuppressParent)
{
var metadataValue = ReadLibraryIncludeFlags(packageDependency.SuppressParent);
transform = transform.WithMetadata("PrivateAssets", metadataValue);
}
if (packageDependency.IncludeType != LibraryIncludeFlags.All)
{
var metadataValue = ReadLibraryIncludeFlags(packageDependency.IncludeType);
transform = transform.WithMetadata("IncludeAssets", metadataValue);
}
}
_transformApplicator.Execute(transform.Transform(packageDependency), itemGroup);
}
}
public void SettingItemUpdateDirties()
{
ProjectRootElement project = ProjectRootElement.Create();
ProjectItemElement item = project.AddItemGroup().AddItem("i", "i1");
item.Include = null;
Helpers.ClearDirtyFlag(project);
Assert.False(project.HasUnsavedChanges);
item.Update = "i2";
Assert.Equal("i2", item.Update);
Assert.True(project.HasUnsavedChanges);
}
private void MigrateTools(
Project project,
ProjectRootElement output)
{
if (project.Tools == null || !project.Tools.Any())
{
return;
}
var itemGroup = output.AddItemGroup();
foreach (var tool in project.Tools)
{
_transformApplicator.Execute(ToolTransform.Transform(tool), itemGroup, mergeExisting: true);
}
}
public GivenThatIWantToMigrateAssemblyInfo()
{
var projectDirectory =
TestAssetsManager.CreateTestInstance("AppWithAssemblyInfo").Path;
var projectContext =
ProjectContext.Create(projectDirectory, FrameworkConstants.CommonFrameworks.NetCoreApp10);
_mockProject = ProjectRootElement.Create();
var testSettings = MigrationSettings.CreateMigrationSettingsTestHook(projectDirectory, projectDirectory, _mockProject, null);
var testInputs = new MigrationRuleInputs(
new[] { projectContext },
_mockProject,
_mockProject.AddItemGroup(),
_mockProject.AddPropertyGroup());
new MigrateAssemblyInfoRule().Apply(testSettings, testInputs);
}