ItemSpec

Instance\ProjectItemInstance.cs (2)

291string ITaskItem.ItemSpec 894public string ItemSpec

TaskParameter.cs (1)

BackEnd\TaskRegistry_Tests.cs (1)

2268public string ItemSpec { get; set; }

BackEnd\TaskThatReturnsDictionaryTaskItem.cs (1)

44public string ItemSpec { get => $"{nameof(MinimalDictionaryTaskItem)}spec"; set => throw new NotImplementedException(); }

MockTask.cs (1)

428public string ItemSpec { get; set; }

TaskThatReturnsMinimalItem.cs (1)

30public string ItemSpec { get => $"{nameof(MinimalTaskItem)}spec"; set => throw new NotImplementedException(); }

TaskItemData.cs (1)

21public string ItemSpec { get; set; }

TestUtilities\SimpleTaskItem.cs (1)

14public string ItemSpec { get; set; }

GenerateBindingRedirects_Tests.cs (1)

388string ITaskItem.ItemSpec { get; set; }

TaskItem.cs (1)

157public string ItemSpec

TaskParameter.cs (1)

771public string ItemSpec

TaskParameter.cs (1)

771public string ItemSpec

BackEnd\Components\RequestBuilder\IntrinsicTasks\MSBuild.cs (1)

691outputItemFromTarget.ItemSpec = Path.Combine(projectDirectory[i], outputItemFromTarget.ItemSpec);

Instance\ProjectInstance_Tests.cs (1)

759Helpers.VerifyAssertThrowsInvalidOperation(delegate () { ((ITaskItem2)Helpers.GetFirst(instance.Items)).ItemSpec = "x"; });

ManagedCompiler.cs (4)

852OutputAssembly.ItemSpec += ".dll"; 856OutputAssembly.ItemSpec += ".netmodule"; 860OutputAssembly.ItemSpec += ".exe"; 1082item.ItemSpec = Utilities.GetFullPathNoThrow(item.ItemSpec);

AssemblyDependency\ResolveAssemblyReference.cs (1)

ConvertToAbsolutePath.cs (1)

64path.ItemSpec = EscapingUtilities.Escape(path.GetMetadata("FullPath"));

ListOperators\FindUnderPath.cs (1)

100item.ItemSpec = EscapingUtilities.Escape(fullPath);

MSBuild.cs (1)

639outputItemFromTarget.ItemSpec = Path.Combine(projectDirectory[i], outputItemFromTarget.ItemSpec);

AssignLinkMetadata_Tests.cs (1)

47item.ItemSpec = "|||";

GenerateBindingRedirects_Tests.cs (1)

382((ITaskItem)this).ItemSpec = assemblyName;

PrepareForReadyToRunCompilation.cs (8)

158using (FileStream fs = new FileStream(file.ItemSpec, FileMode.Open, FileAccess.Read)) 233MainAssembly.SetMetadata(MetadataKeys.RelativePath, Path.GetFileName(MainAssembly.ItemSpec)); 240r2rCompilationEntry.ItemSpec = r2rCompositeInputList[0].ItemSpec; 358if (!file.ItemSpec.EndsWith(".dll", StringComparison.OrdinalIgnoreCase) && !file.ItemSpec.EndsWith(".exe", StringComparison.OrdinalIgnoreCase)) 364using (FileStream fs = new FileStream(file.ItemSpec, FileMode.Open, FileAccess.Read)) 387bool excludeFromR2R = (exclusionSet != null && exclusionSet.Contains(Path.GetFileName(file.ItemSpec))); 388bool excludeFromComposite = (r2rCompositeExclusionSet != null && r2rCompositeExclusionSet.Contains(Path.GetFileName(file.ItemSpec))) || excludeFromR2R;

RunReadyToRunCompiler.cs (12)

65return Crossgen2Tool.ItemSpec; 67return CrossgenTool.ItemSpec; 104if (!File.Exists(Crossgen2Tool.ItemSpec)) 106Log.LogError(Strings.Crossgen2ToolExecutableNotFound, Crossgen2Tool.ItemSpec); 152if (!File.Exists(CrossgenTool.ItemSpec)) 154Log.LogError(Strings.CrossgenToolExecutableNotFound, CrossgenTool.ItemSpec); 168_outputR2RImage = CompilationEntry.ItemSpec; 194_inputAssembly = CompilationEntry.ItemSpec; 232if (IsPdbCompilation && string.Equals(Path.GetFileName(reference.ItemSpec), Path.GetFileName(_outputR2RImage), StringComparison.OrdinalIgnoreCase)) 253return $"\"{Crossgen2Tool.ItemSpec}\""; 343result.AppendLine($"-m:\"{mibc.ItemSpec}\""); 371result.AppendLine(reference.ItemSpec);

CombineLinkerXmlFiles.cs (1)

32 XDocument subFile = XDocument.Load (linkerXmlFile.ItemSpec);

ComputeManagedAssemblies.cs (1)

29 .Where (f => Utils.IsManagedAssembly (f.ItemSpec))

CreateRuntimeRootDescriptorFile.cs (7)

102 var namespaceFilePath = NamespaceFilePath.ItemSpec; 108 var mscorlibFilePath = MscorlibFilePath.ItemSpec; 114 var cortypeFilePath = CortypeFilePath.ItemSpec; 120 var rexcepFilePath = RexcepFilePath.ItemSpec; 128 var iLLinkTrimXmlFilePath = ILLinkTrimXmlFilePath.ItemSpec; 142 OutputXml (iLLinkTrimXmlFilePath, RuntimeRootDescriptorFilePath.ItemSpec); 486 defineConstants.Add (item.ItemSpec.Trim ());

LinkTask.cs (9)

312 args.Append ("-x ").AppendLine (Quote (rootFile.ItemSpec)); 316 args.Append ("-a ").Append (Quote (assemblyItem.ItemSpec)); 353 var assemblyPath = assembly.ItemSpec; 406 var assemblyPath = assembly.ItemSpec; 424 args.Append ("-out ").AppendLine (Quote (OutputDirectory.ItemSpec)); 464 var key = customData.ItemSpec; 474 var feature = featureSetting.ItemSpec; 484 args.Append ("--keep-metadata ").AppendLine (Quote (metadata.ItemSpec)); 496 var stepPath = customStep.ItemSpec;

GenerateFileVersionProps.cs (2)

59var fileName = Path.GetFileName(file.ItemSpec); 110.Select(p => p.Value.File.ItemSpec)

RegenerateDownloadTable.cs (4)

78$"| Platform |{string.Concat(Branches.Select(p => $" {p.ItemSpec} |"))}", 122return $"| **{platform.ItemSpec}**{parenthetical} |{cells}"; 130Log.LogError($"Branch '{branch.ItemSpec}' has no Abbr metadata."); 136Log.LogError($"Platform '{platform.ItemSpec}' has no Abbr metadata.");

StaticFileRegeneration\RegenerateThirdPartyNotices.cs (2)

54string repo = item.ItemSpec; 56?? throw new ArgumentException($"{item.ItemSpec} specifies no Branch.");

BackEnd\Components\RequestBuilder\IntrinsicTasks\ItemGroupLoggingHelper.cs (1)

190sb.Append(item.ItemSpec);

BackEnd\Components\RequestBuilder\IntrinsicTasks\MSBuild.cs (9)

317string projectPath = FileUtilities.AttemptToShortenPath(project.ItemSpec); 347Log.LogErrorWithCodeFromResources("MSBuild.ProjectUpgradeNeededToVcxProj", project.ItemSpec); 385Log.LogMessageFromResources(MessageImportance.High, "MSBuild.ProjectFileNotFoundMessage", project.ItemSpec); 390Log.LogErrorWithCodeFromResources("MSBuild.ProjectFileNotFound", project.ItemSpec); 553string projectPath = FileUtilities.AttemptToShortenPath(projects[i].ItemSpec); 555projectNames[i] = projects[i].ItemSpec; 691outputItemFromTarget.ItemSpec = Path.Combine(projectDirectory[i], outputItemFromTarget.ItemSpec); 695log.LogWarningWithCodeFromResources(null, projects[i].ItemSpec, 0, 0, 0, 0, "MSBuild.CannotRebaseOutputItemPath", outputItemFromTarget.ItemSpec, e.Message);

BackEnd\Components\RequestBuilder\TaskBuilder.cs (1)

1044var normalizedMSBuildProject = FileUtilities.NormalizePath(msbuildProject.ItemSpec);

BackEnd\TaskExecutionHost\TaskExecutionHost.cs (2)

1413newItem = new ProjectItemInstance(_projectInstance, outputTargetName, EscapingUtilities.Escape(output.ItemSpec), parameterLocationEscaped); 1469joinedOutputs.Append(EscapingUtilities.Escape(output.ItemSpec));

BuildCheck\OM\ParsedItemsCheckData.cs (1)

100yield return taskItem.ItemSpec;

Logging\BaseConsoleLogger.cs (3)

112((ITaskItem)a).ItemSpec, 113((ITaskItem)b).ItemSpec, 623ITaskItem taskItem => taskItem.ItemSpec,

Logging\BinaryLogger\BuildEventArgsWriter.cs (3)

1036if (item is ITaskItem taskItem && !string.IsNullOrEmpty(taskItem.ItemSpec)) 1038EmbedFile.Invoke(taskItem.ItemSpec); 1049WriteDeduplicatedString(item.ItemSpec);

Logging\ParallelLogger\ParallelConsoleLogger.cs (2)

610ITaskItem taskItem => taskItem.ItemSpec, // ProjectItemInstance 894WriteMessageAligned(ResourceUtilities.FormatResourceStringStripCodeAndKeyword("TargetOutputItem", item.ItemSpec), false);

Logging\SerialConsoleLogger.cs (1)

394WriteLinePretty(ResourceUtilities.FormatResourceStringIgnoreCodeAndKeyword("TargetOutputItem", item.ItemSpec));

LogMessagePacketBase.cs (1)

1153writer.Write(taskItem.ItemSpec);

TaskParameter.cs (2)

317escapedItemSpec = EscapingUtilities.Escape(copyFrom.ItemSpec); 421escapedItemSpec = EscapingUtilities.Escape(wrappedItem.ItemSpec);

TaskInvocationAnalysisDataTests.cs (2)

150((ITaskItem)listValue[0]!).ItemSpec.ShouldBe("item1"); 151((ITaskItem)listValue[1]!).ItemSpec.ShouldBe("item2");

Instance\ProjectItemInstance_Tests.cs (3)

330Assert.Equal(item.EvaluatedInclude, taskItem.ItemSpec); 355Assert.Equal("esca ped;item", taskItem.ItemSpec); 362Assert.Equal("esca ped;item", taskItem.ItemSpec);

BackEnd\BuildManager_Tests.cs (5)

454Assert.True(int.TryParse(item[2].ItemSpec, out int processId), $"Process ID passed from the 'test' target is not a valid integer (actual is '{item[2].ItemSpec}')"); 3725Assert.Equal("InitialValue", results.ResultsByTarget["BuildOther"].Items.First().ItemSpec); 3747Assert.Equal(newPropertyValue, results.ResultsByTarget["Foo"].Items.First().ItemSpec); 3811string.Join(";", result.ResultsByTarget["MainTarget"].Items.Select(i => i.ItemSpec)));

BackEnd\MSBuild_Tests.cs (5)

1810Assert.Equal("|a", targetOutputs["Build"].Items[0].ItemSpec); 1811Assert.Equal("A|b", targetOutputs["Build"].Items[1].ItemSpec); 1812Assert.Equal("B|c", targetOutputs["Build"].Items[2].ItemSpec); 1813Assert.Equal("C|d", targetOutputs["Build"].Items[3].ItemSpec); 1814Assert.Equal("D|", targetOutputs["Build"].Items[4].ItemSpec);

BackEnd\SdkResultOutOfProc_Tests.cs (3)

190int.TryParse(item[0].ItemSpec, out int processId) 191.ShouldBeTrue($"Process ID passed from the 'test' target is not a valid integer (actual is '{item[0].ItemSpec}')"); 202.Select(i => i.ItemSpec)

BackEnd\TargetEntry_Tests.cs (4)

386Assert.Equal("foo.o", results.Items[0].ItemSpec); 406Assert.Equal("testProject.proj", results.Items[0].ItemSpec); 737Assert.Equal("item1", outputListB[0].ItemSpec); 749Assert.Equal("item2", outputListC[0].ItemSpec);

BackEnd\TargetResult_Tests.cs (1)

43Assert.Equal(item.ItemSpec, result.Items[0].ItemSpec);

BackEnd\TaskExecutionHost_Tests.cs (6)

866ValidateOutputProperty("ItemOutput", _oneItem[0].ItemSpec); 886ValidateOutputProperty("ItemArrayOutput", String.Concat(_twoItems[0].ItemSpec, ";", _twoItems[1].ItemSpec)); 1381Assert.Equal(value, actualItem.ItemSpec); 1409Assert.Equal(value, actualItems[0].ItemSpec); 1444Assert.Equal(expectedItems[i], actualItems[i].ItemSpec);

BackEnd\TaskHostConfiguration_Tests.cs (2)

771Assert.Equal(x.ItemSpec, y.ItemSpec);

BackEnd\TranslationHelpers.cs (1)

203sb.Append(taskItem.ItemSpec);

BuildEventArgsSerialization_Tests.cs (1)

1203return i.ItemSpec + string.Join(";", i.CloneCustomMetadata().Keys.OfType<string>().Select(k => i.GetMetadata(k)));

Construction\SolutionProjectGenerator_Tests.cs (5)

1279if (item.ItemSpec.EndsWith("ClassLibrary1.csproj")) 1283else if (item.ItemSpec.EndsWith("MainApp.metaproj")) 1287else if (item.ItemSpec == "Debug|Mixed Platforms") 1293else if (item.ItemSpec == "Release|Any CPU") 1301Assert.Fail("Unexpected project seen:" + item.ItemSpec);

EscapingInProjects_Tests.cs (1)

58Log.LogMessageFromText("Received TaskItemParam: " + TaskItemParam.ItemSpec, MessageImportance.High);

FixPathOnUnix_Tests.cs (1)

67Log.LogMessage($"Item: {item.ItemSpec}");

Graph\IsolateProjects_Tests.cs (1)

365declaredReferenceBuildResults[0]["DeclaredReferenceTarget"].Items[0].ItemSpec.ShouldBe("Foo.cs");

Graph\ResultCacheBasedBuilds_Tests.cs (4)

142.ItemSpec.ShouldBe("1"); 173resultFromCachedBuild.ResultsByTarget["Build"].Items.First().ItemSpec.ShouldBe("1"); 363rootNodeBuildResult.ResultsByTarget["Build"].Items.Select(i => i.ItemSpec).ToArray().ShouldBe(expectedOutput[rootNode]); 482var actualOutput = result.ResultsByTarget["Build"].Items.Select(i => i.ItemSpec).ToArray();

ProjectCache\ProjectCacheTests.cs (1)

864itemResult.ItemSpec.ShouldBe(GetProjectNumber(projectPath).ToString());

TaskParameter_Tests.cs (22)

TestComparers\TaskItemComparer.cs (2)

41if (x.ItemSpec != y.ItemSpec)

IItemData.cs (1)

63EvaluatedInclude = ti.ItemSpec;

TaskItemData.cs (1)

36ItemSpec = original.ItemSpec;

TaskParameterEventArgs.cs (1)

214writer.Write(taskItem.ItemSpec);

CommandLineBuilderExtension.cs (1)

248AppendSwitchIfNotNull(switchName, parameter.ItemSpec);

Csc.cs (7)

274commandLine.AppendSwitchIfNotNull("@", response.ItemSpec); 357appendGlobalReference(reference.ItemSpec); 389reference.ItemSpec, 397appendGlobalReference(reference.ItemSpec); 404commandLine.AppendSwitchAliased(switchName, trimmedAlias, reference.ItemSpec); 422commandLine.AppendSwitchForceQuoted(switchName, reference.ItemSpec); 426commandLine.AppendSwitchIfNotNull(switchName, reference.ItemSpec);

GenerateMSBuildEditorConfig.cs (6)

22/// <see cref="PropertyItems"/> is expected to be a list of items whose <see cref="ITaskItem.ItemSpec"/> is the property name 27/// <see cref="MetadataItems"/> is expected to be a list of items whose <see cref="ITaskItem.ItemSpec"/> represents a file in the 34/// header will be the full path of the item (generated via its<see cref="ITaskItem.ItemSpec"/>), and each section will have a 76.Append(prop.ItemSpec) 109return string.IsNullOrEmpty(FileName.ItemSpec) ? true : WriteMSBuildEditorConfig(); 116var targetFileName = FileName.ItemSpec;

InteractiveCompiler.cs (2)

212commandLine.AppendSwitchIfNotNull("@", response.ItemSpec); 230commandLine.AppendSwitchIfNotNull("@", scriptResponse.ItemSpec);

ManagedCompiler.cs (8)

844OutputAssembly = new TaskItem(Path.GetFileNameWithoutExtension(Sources[0].ItemSpec)); 959commandLine.AppendSwitchIfNotNull("/analyzer:", analyzer.ItemSpec); 972commandLine.AppendSwitchIfNotNull("/additionalfile:", additionalFile.ItemSpec); 991commandLine.AppendSwitchIfNotNull("/embed:", embeddedFile.ItemSpec); 1005commandLine.AppendSwitchIfNotNull("/analyzerconfig:", analyzerConfigFile.ItemSpec); 1082item.ItemSpec = Utilities.GetFullPathNoThrow(item.ItemSpec); 1150if (!File.Exists(reference.ItemSpec)) 1153Log.LogErrorWithCodeFromResources("General_ReferenceDoesNotExist", reference.ItemSpec);

MapSourceRoots.cs (7)

99if (!EndsWithDirectorySeparator(sourceRoot.ItemSpec)) 101Log.LogErrorFromResources("MapSourceRoots.PathMustEndWithSlashOrBackslash", Names.SourceRoot, sourceRoot.ItemSpec); 104if (rootByItemSpec.TryGetValue(sourceRoot.ItemSpec, out var existingRoot)) 111rootByItemSpec.Add(sourceRoot.ItemSpec, sourceRoot); 130string localPath = root.ItemSpec; 190root.SetMetadata(Names.MappedPath, root.ItemSpec); 214Log.LogWarningFromResources("MapSourceRoots.ContainsDuplicate", Names.SourceRoot, left.ItemSpec, metadataName, leftValue, rightValue);

Utilities.cs (1)

53item.ItemSpec, itemMetadataName, metadataValue, "bool");

Vbc.cs (3)

279MovePdbFileIfNecessary(OutputAssembly?.ItemSpec); 549commandLine.AppendSwitchIfNotNull("@", response.ItemSpec); 854CheckHostObjectSupport(param = nameof(OutputAssembly), vbcHostObject.SetOutputAssembly(OutputAssembly?.ItemSpec));

MapSourceRootTests.cs (15)

TestUtilities\MSBuildUtil.cs (2)

25taskItem.Setup(x => x.ItemSpec).Returns(fileName); 32taskItem.Setup(x => x.ItemSpec).Returns(fileName);

TestUtilities\TaskTestUtil.cs (1)

26Assert.Equal(expected, task.GenerateCommandLineArgsTaskItems(rsp).Select(x => x.ItemSpec));

AddToWin32Manifest.cs (5)

92if (string.IsNullOrEmpty(ApplicationManifest.ItemSpec) || !File.Exists(ApplicationManifest?.ItemSpec)) 94Log.LogErrorWithCodeFromResources(null, ApplicationManifest?.ItemSpec, 0, 0, 0, 0, "AddToWin32Manifest.SpecifiedApplicationManifestCanNotBeFound"); 98return ApplicationManifest!.ItemSpec; 138SaveManifest(document, Path.GetFileName(ApplicationManifest?.ItemSpec) ?? DefaultManifestName);

AssemblyDependency\GenerateBindingRedirects.cs (5)

108var outputExists = FileSystems.Default.FileExists(OutputAppConfigFile.ItemSpec); 137Log.LogMessageFromResources(MessageImportance.Low, "GenerateBindingRedirects.CreatingBindingRedirectionFile", OutputAppConfigFile.ItemSpec); 138using (var stream = FileUtilities.OpenWrite(OutputAppConfigFile.ItemSpec, false)) 340using (XmlReader xr = XmlReader.Create(File.OpenRead(appConfigItem.ItemSpec), xrs)) 366var redirectStr = redirect.ItemSpec;

AssemblyDependency\Reference.cs (1)

152string itemSpec = sourceItem.ItemSpec;

AssemblyDependency\ReferenceTable.cs (15)

AssemblyDependency\ResolveAssemblyReference.cs (13)

1369log.AppendLine().Append(Strings.TwelveSpaces).Append(sourceItem.ItemSpec); 1474Log.LogMessage(importance, indent + item.ItemSpec); 1486Log.LogMessage(importance, indent + item.ItemSpec); 1871Log.LogMessage(importance, Strings.RequiredBy, dependee.ItemSpec); 2598if (fileExists(item.ItemSpec) && !Reference.IsFrameworkFile(item.ItemSpec, _targetFrameworkDirectories)) 2602assemblyName = getAssemblyName(item.ItemSpec); 2765Log.LogErrorWithCodeFromResources("ResolveAssemblyReference.FrameworkDirectoryOnProfiles", item.ItemSpec); 2834string fileName = subsetItems.ItemSpec; 3056tableMap[installedAssemblyTable.ItemSpec] = new AssemblyTableInfo(installedAssemblyTable.ItemSpec, frameworkDirectory); 3113Log.LogMessageFromResources(MessageImportance.Normal, "ResolveAssemblyReference.IgnoringBecauseNonEmptySubtype", assembly.ItemSpec, subType); 3117Log.LogWarningWithCodeFromResources("ResolveAssemblyReference.FailedToResolveReferenceBecauseHigherTargetFramework", assembly.ItemSpec, assembly.GetMetadata(ItemMetadataNames.targetFramework));

AssemblyDependency\TaskItemSpecFilenameComparer.cs (2)

55string xItemSpec = x.ItemSpec; 56string yItemSpec = y.ItemSpec;

AssignCulture.cs (3)

155AssignedFiles[i].ItemSpec, 181AssignedFiles[i].ItemSpec); 185Log.LogErrorWithCodeFromResources("AssignCulture.CannotExtractCulture", Files[i].ItemSpec, e.Message);

AssignProjectConfiguration.cs (2)

204Log.LogMessageFromResources(MessageImportance.Low, "AssignProjectConfiguration.ProjectConfigurationResolutionSuccess", projectRef.ItemSpec, resolvedReference.GetMetadata(attrFullConfiguration)); 235Log.LogMessageFromResources(MessageImportance.Low, "AssignProjectConfiguration.ProjectConfigurationUnresolved", projectRef.ItemSpec);

AssignTargetPath.cs (5)

91!Path.IsPathRooted(Files[i].ItemSpec) && 93!Files[i].ItemSpec.Contains("." + Path.DirectorySeparatorChar) && 101targetPath = Files[i].ItemSpec; 107string itemSpecFullFileNamePath = Path.GetFullPath(Files[i].ItemSpec); 117targetPath = Path.GetFileName(Files[i].ItemSpec);

CombinePath.cs (1)

70combinedPath.ItemSpec = Path.Combine(BasePath, path.ItemSpec);

CombineTargetFrameworkInfoProperties.cs (1)

54root.Add(new XElement(item.ItemSpec, item.GetMetadata("Value")));

CombineXmlElements.cs (1)

40root.Add(XElement.Parse(item.ItemSpec));

CommandLineBuilderExtension.cs (1)

245AppendSwitchIfNotNull(switchName, parameter.ItemSpec);

ConvertToAbsolutePath.cs (1)

56if (!Path.IsPathRooted(path.ItemSpec))

Copy.cs (23)

472string destPath = DestinationFiles[i].ItemSpec; 476if (String.Equals(originalSource, SourceFiles[i].ItemSpec, StringComparison.OrdinalIgnoreCase)) 485if (DoCopyIfNecessary(new FileState(SourceFiles[i].ItemSpec), new FileState(DestinationFiles[i].ItemSpec), copyFile)) 487filesActuallyCopied[destPath] = SourceFiles[i].ItemSpec; 550string destPath = destItem.ItemSpec; 578string sourcePath = sourceItem.ItemSpec; 581MSBuildEventSource.Log.CopyUpToDateStart(destItem.ItemSpec); 585SourceFiles[partition[partitionIndex - 1]].ItemSpec, 591new FileState(sourceItem.ItemSpec), 592new FileState(destItem.ItemSpec), 605MSBuildEventSource.Log.CopyUpToDateStop(destItem.ItemSpec, true); 728() => Path.Combine(DestinationFolder.ItemSpec, Path.GetFileName(SourceFiles[i].ItemSpec)), 729SourceFiles[i].ItemSpec, 730DestinationFolder.ItemSpec, 754string src = FileUtilities.NormalizePath(sourceFolder.ItemSpec); 763sourceFolder.ItemSpec, 764DestinationFolder.ItemSpec, 772() => Path.Combine(DestinationFolder.ItemSpec, srcName, file), 773sourceFolder.ItemSpec, 774DestinationFolder.ItemSpec, 957if (DestinationFolder != null && FileSystems.Default.FileExists(DestinationFolder.ItemSpec))

CreateItem.cs (8)

108(!excludeItems.ContainsKey(i.ItemSpec))) 156if (FileMatcher.HasWildcards(i.ItemSpec)) 158FileMatcher.Default.GetFileSpecInfo(i.ItemSpec, out string directoryPart, out string wildcardPart, out string filenamePart, out bool needsRecursion, out bool isLegalFileSpec); 164EscapingUtilities.UnescapeAll(i.ItemSpec), 174EscapingUtilities.UnescapeAll(i.ItemSpec), 181(files, action, _) = FileMatcher.Default.GetFiles(null /* use current directory */, i.ItemSpec); 188FileMatcher.Result match = FileMatcher.Default.FileMatch(i.ItemSpec, file); 221uniqueItems[item.ItemSpec] = String.Empty;

CreateManifestResourceName.cs (3)

146string fileName = resourceFile.ItemSpec; 210itemSpecToTaskitem[resourceFile.ItemSpec] = resourceFile; 245Log.LogErrorWithCodeFromResources("CreateManifestResourceName.Error", resourceFile.ItemSpec, e.Message);

Delete.cs (11)

118while (!deletedFilesSet.Contains(file.ItemSpec)) 122if (FileSystems.Default.FileExists(file.ItemSpec)) 126Log.LogWarningFromResources("Delete.DeletingFile", file.ItemSpec); 131Log.LogMessageFromResources(MessageImportance.Normal, "Delete.DeletingFile", file.ItemSpec); 134File.Delete(file.ItemSpec); 138Log.LogMessageFromResources(MessageImportance.Low, "Delete.SkippingNonexistentFile", file.ItemSpec); 145deletedFilesSet.Add(file.ItemSpec); 149string lockedFileMessage = LockCheck.GetLockedFileMessage(file?.ItemSpec ?? string.Empty); 162deletedFilesSet.Add(file.ItemSpec); 182Log.LogWarningWithCodeFromResources("Delete.Error", file.ItemSpec, e.Message, lockedFileMessage); 186Log.LogErrorWithCodeFromResources("Delete.Error", file.ItemSpec, e.Message, lockedFileMessage);

DownloadFile.cs (3)

178DirectoryInfo destinationDirectory = Directory.CreateDirectory(DestinationFolder.ItemSpec); 324filename = !String.IsNullOrWhiteSpace(DestinationFileName?.ItemSpec) 325? DestinationFileName.ItemSpec // Get the file name from what the user specified

FileIO\GetFileHash.cs (3)

88if (!FileSystems.Default.FileExists(file.ItemSpec)) 90Log.LogErrorWithCodeFromResources("FileHash.FileNotFound", file.ItemSpec); 94var hash = ComputeHash(algorithmFactory, file.ItemSpec, _cancellationTokenSource.Token);

FileIO\ReadLinesFromFile.cs (3)

41if (FileSystems.Default.FileExists(File.ItemSpec)) 45string[] textLines = System.IO.File.ReadAllLines(File.ItemSpec); 69Log.LogErrorWithCodeFromResources("ReadLinesFromFile.ErrorOrWarning", File.ItemSpec, e.Message);

FileIO\WriteLinesToFile.cs (14)

79buffer.AppendLine(line.ItemSpec); 99var directoryPath = Path.GetDirectoryName(FileUtilities.NormalizePath(File.ItemSpec)); 111if (FileUtilities.FileExistsNoThrow(File.ItemSpec)) 113string existingContents = System.IO.File.ReadAllText(File.ItemSpec); 118Log.LogMessageFromResources(MessageImportance.Low, "WriteLinesToFile.SkippingUnchangedFile", File.ItemSpec); 119MSBuildEventSource.Log.WriteLinesToFileUpToDateStop(File.ItemSpec, true); 124Log.LogErrorWithCodeFromResources("WriteLinesToFile.ErrorReadingFile", File.ItemSpec); 132Log.LogMessageFromResources(MessageImportance.Low, "WriteLinesToFile.ErrorReadingFile", File.ItemSpec); 134MSBuildEventSource.Log.WriteLinesToFileUpToDateStop(File.ItemSpec, false); 137System.IO.File.WriteAllText(File.ItemSpec, contentsAsString, encoding); 143Log.LogMessageFromResources(MessageImportance.Normal, "WriteLinesToFile.UnusedWriteOnlyWhenDifferent", File.ItemSpec); 147System.IO.File.AppendAllText(File.ItemSpec, buffer.ToString(), encoding); 152string lockedFileMessage = LockCheck.GetLockedFileMessage(File.ItemSpec); 153Log.LogErrorWithCodeFromResources("WriteLinesToFile.ErrorOrWarning", File.ItemSpec, e.Message, lockedFileMessage);

FindAppConfigFile.cs (5)

124string filename = (matchWholeItemSpec ? item.ItemSpec : Path.GetFileName(item.ItemSpec)); 133AppConfigFile.SetMetadata("OriginalItemSpec", item.ItemSpec); 137Log.LogMessageFromResources(MessageImportance.Low, "FindInList.Found", AppConfigFile.ItemSpec); 145Log.LogMessageFromResources(MessageImportance.Low, "FindInList.InvalidPath", item.ItemSpec, ex.Message);

FindInList.cs (2)

107var path = FileUtilities.FixFilePath(item.ItemSpec); 121Log.LogMessageFromResources(MessageImportance.Low, "FindInList.InvalidPath", item.ItemSpec, ex.Message);

FindInvalidProjectReferences.cs (1)

87string referenceIdentity = item.ItemSpec;

GenerateApplicationManifest.cs (11)

234name = Path.GetFileName(item.ItemSpec); 237if (!file.ImportComComponent(item.ItemSpec, manifest.OutputMessages, name)) 258Extension = item.ItemSpec, 272if (!String.IsNullOrEmpty(ConfigFile?.ItemSpec)) 277if (!String.IsNullOrEmpty(IconFile?.ItemSpec)) 282if (!String.IsNullOrEmpty(TrustInfoFile?.ItemSpec)) 285manifest.TrustInfo.Read(TrustInfoFile.ItemSpec); 445if (String.IsNullOrEmpty(InputManifest?.ItemSpec) || String.CompareOrdinal(InputManifest.ItemSpec, "NoManifest") == 0) 452using (Stream s = File.Open(InputManifest.ItemSpec, FileMode.Open, FileAccess.Read, FileShare.Read)) 479Log.LogErrorWithCodeFromResources("GenerateManifest.ReadInputManifestFailed", InputManifest.ItemSpec, ex.Message);

GenerateLauncher.cs (2)

67string entryPointFileName = Path.GetFileName(EntryPoint.ItemSpec); 101OutputEntryPoint = new TaskItem(Path.Combine(Path.GetDirectoryName(EntryPoint.ItemSpec), results.KeyFile));

GenerateManifestBase.cs (21)

88AssemblyIdentity = AssemblyIdentity.FromAssemblyName(item.ItemSpec), 121assembly = _manifest.AssemblyReferences.Add(item.ItemSpec); 126AssemblyIdentity identity = AssemblyIdentity.FromAssemblyName(item.ItemSpec); 134assembly = new AssemblyReference(item.ItemSpec); 152AssemblyReference assembly = _manifest.AssemblyReferences.Add(item.ItemSpec); 160FileReference file = _manifest.FileReferences.Add(item.ItemSpec); 338targetPath = BaseReference.GetDefaultTargetPath(item.ItemSpec); 373Log.LogWarningWithCodeFromResources("GenerateManifest.InvalidItemValue", "AssemblyType", item.ItemSpec); 377Log.LogWarningWithCodeFromResources("GenerateManifest.InvalidItemValue", "AssemblyType", item.ItemSpec); 404Log.LogWarningWithCodeFromResources("GenerateManifest.InvalidItemValue", "DependencyType", item.ItemSpec); 408Log.LogWarningWithCodeFromResources("GenerateManifest.InvalidItemValue", "DependencyType", item.ItemSpec); 418return OutputManifest.ItemSpec; 436if (String.IsNullOrEmpty(InputManifest?.ItemSpec)) 455_manifest = ManifestReader.ReadManifest(manifestType.Name, InputManifest.ItemSpec, true); 459Log.LogErrorWithCodeFromResources("GenerateManifest.ReadInputManifestFailed", InputManifest.ItemSpec, ex.Message); 485if (!String.IsNullOrEmpty(EntryPoint?.ItemSpec)) 593string manifestFileName = Path.GetFileName(OutputManifest.ItemSpec); 618ManifestWriter.WriteManifest(_manifest, OutputManifest.ItemSpec, TargetFrameworkVersion); 622string lockedFileMessage = LockCheck.GetLockedFileMessage(OutputManifest.ItemSpec); 623Log.LogErrorWithCodeFromResources("GenerateManifest.WriteOutputManifestFailed", OutputManifest.ItemSpec, ex.Message, lockedFileMessage); 629Util.WriteLog(String.Format(CultureInfo.CurrentCulture, "Total time to generate manifest '{1}': t={0}", Environment.TickCount - _startTime, Path.GetFileName(OutputManifest.ItemSpec)));

GenerateResource.cs (17)

582[inputFiles[i].ItemSpec, outputFiles[i].ItemSpec], 587commandLineBuilder.AppendFileNameIfNotNull(inputFiles[i].ItemSpec); 670if (item.ItemSpec.EndsWith(".dll", StringComparison.OrdinalIgnoreCase)) 672if (item.ItemSpec.EndsWith(".resources.dll", StringComparison.OrdinalIgnoreCase)) 761if (IsDangerous(source.ItemSpec)) 763Log.LogErrorWithCodeFromResources("GenerateResource.MOTW", source.ItemSpec); 1475Log.LogErrorWithCodeFromResources("GenerateResource.DuplicateOutputFilenames", item.ItemSpec); 1481Log.LogErrorWithCodeFromResources("GenerateResource.InvalidFilename", item.ItemSpec, e.Message); 1712DateTime time = NativeMethodsShared.GetLastWriteFileUtcTime(input.ItemSpec); 1717_newestUncorrelatedInput = input.ItemSpec; 1726_newestUncorrelatedInput = input.ItemSpec; 2445string outputSpec = _extractResWFiles ? resWOutputDirectory : _outFiles[i].ItemSpec; 2446if (!ProcessFile(_inFiles[i].ItemSpec, outputSpec)) 2531if (assemblyFile.ItemSpec != null && FileSystems.Default.FileExists(assemblyFile.ItemSpec)) 2547_assemblyNames[i] = new AssemblyNameExtension(Path.GetFileNameWithoutExtension(assemblyFile.ItemSpec));

GetAssemblyIdentity.cs (3)

64an = AssemblyName.GetAssemblyName(item.ItemSpec); 68Log.LogErrorWithCodeFromResources("GetAssemblyIdentity.CouldNotGetAssemblyName", item.ItemSpec, e.Message); 73Log.LogErrorWithCodeFromResources("GetAssemblyIdentity.CouldNotGetAssemblyName", item.ItemSpec, e.Message);

GetCompatiblePlatform.cs (2)

64string? buildProjectReferenceAs = PlatformNegotiation.GetNearestPlatform(projectReferenceOverridePlatformNegotiationMetadata, referencedProjectPlatform, projectReferencePlatformsMetadata, projectReferenceLookupTableMetadata, PlatformLookupTable, AssignedProjectsWithPlatform[i].ItemSpec, CurrentProjectPlatform, Log); 67Log.LogMessageFromResources(MessageImportance.Low, "GetCompatiblePlatform.DisplayChosenPlatform", AssignedProjectsWithPlatform[i].ItemSpec, buildProjectReferenceAs);

GetSDKReferenceFiles.cs (21)

Hash.cs (2)

81string itemSpec = IgnoreCase ? ItemsToHash[i].ItemSpec.ToUpperInvariant() : ItemsToHash[i].ItemSpec;

InstalledSDKResolver.cs (1)

56string sdkDirectory = resolvedSDK.ItemSpec;

LC.cs (4)

146commandLine.AppendSwitchIfNotNull("/target:", LicenseTarget.ItemSpec); 150commandLine.AppendSwitchIfNotNull("/complist:", item.ItemSpec); 159commandLine.AppendSwitchIfNotNull("/i:", item.ItemSpec); 166string outputPath = LicenseTarget.ItemSpec + ".licenses";

ListOperators\FindUnderPath.cs (5)

62System.IO.Path.GetFullPath(FileUtilities.FixFilePath(Path.ItemSpec))); 68"FindUnderPath.InvalidParameter", "Path", Path.ItemSpec, e.Message); 74Log.LogMessageFromResources(MessageImportance.Low, "FindUnderPath.ComparisonPath", Path.ItemSpec); 83System.IO.Path.GetFullPath(FileUtilities.FixFilePath(item.ItemSpec))); 88"FindUnderPath.InvalidParameter", "Files", item.ItemSpec, e.Message);

ListOperators\RemoveDuplicates.cs (1)

53if (alreadySeen.Add(item.ItemSpec))

MakeDir.cs (8)

54if (directory.ItemSpec.Length > 0) 59if (!directoriesSet.Contains(directory.ItemSpec)) 62if (!FileUtilities.DirectoryExistsNoThrow(directory.ItemSpec)) 66Log.LogErrorFromResources("MakeDir.Comment", directory.ItemSpec); 71Log.LogMessageFromResources(MessageImportance.Normal, "MakeDir.Comment", directory.ItemSpec); 73Directory.CreateDirectory(FileUtilities.FixFilePath(directory.ItemSpec)); 82Log.LogErrorWithCodeFromResources("MakeDir.Error", directory.ItemSpec, e.Message); 86directoriesSet.Add(directory.ItemSpec);

ManifestUtil\Util.cs (7)

432if (String.IsNullOrEmpty(item.ItemSpec)) 438var id = new AssemblyIdentity(item.ItemSpec); 445key = Path.GetFullPath(item.ItemSpec).ToUpperInvariant(); 623if (item1.ItemSpec == null || item2.ItemSpec == null) 628return String.Compare(item1.ItemSpec, item2.ItemSpec, StringComparison.Ordinal);

MetadataConversionUtilities.cs (1)

46throw new ArgumentException(ResourceUtilities.FormatResourceStringStripCodeAndKeyword("General.InvalidAttributeMetadata", item.ItemSpec, itemMetadataName, metadataValue, "bool"), e);

Move.cs (6)

133destinationFile = Path.Combine(DestinationFolder.ItemSpec, Path.GetFileName(SourceFiles[i].ItemSpec)); 137Log.LogErrorWithCodeFromResources("Move.Error", SourceFiles[i].ItemSpec, DestinationFolder.ItemSpec, e.Message, string.Empty); 155string sourceFile = SourceFiles[i].ItemSpec; 156string destinationFile = DestinationFiles[i].ItemSpec;

MSBuild.cs (9)

282string projectPath = FileUtilities.AttemptToShortenPath(project.ItemSpec); 312Log.LogErrorWithCodeFromResources("MSBuild.ProjectUpgradeNeededToVcxProj", project.ItemSpec); 348Log.LogMessageFromResources(MessageImportance.High, "MSBuild.ProjectFileNotFoundMessage", project.ItemSpec); 353Log.LogErrorWithCodeFromResources("MSBuild.ProjectFileNotFound", project.ItemSpec); 509string projectPath = FileUtilities.AttemptToShortenPath(projects[i].ItemSpec); 511projectNames[i] = projects[i].ItemSpec; 639outputItemFromTarget.ItemSpec = Path.Combine(projectDirectory[i], outputItemFromTarget.ItemSpec); 643log.LogWarningWithCodeFromResources(null, projects[i].ItemSpec, 0, 0, 0, 0, "MSBuild.CannotRebaseOutputItemPath", outputItemFromTarget.ItemSpec, e.Message);

RemoveDir.cs (8)

56if (string.IsNullOrEmpty(directory.ItemSpec)) 64if (FileSystems.Default.DirectoryExists(directory.ItemSpec)) 68Log.LogErrorFromResources("RemoveDir.Removing", directory.ItemSpec); 73Log.LogMessageFromResources(MessageImportance.Normal, "RemoveDir.Removing", directory.ItemSpec); 84currentSuccess = RemoveReadOnlyAttributeRecursively(new DirectoryInfo(directory.ItemSpec)); 102Log.LogMessageFromResources(MessageImportance.Normal, "RemoveDir.SkippingNonexistentDirectory", directory.ItemSpec); 123Directory.Delete(directory.ItemSpec, true); 137Log.LogErrorWithCodeFromResources("RemoveDir.Error", directory.ItemSpec, e.Message);

RequiresFramework35SP1Assembly.cs (2)

154|| string.Equals(candidateFile.ItemSpec, Constants.NET35SP1AssemblyIdentity[0], StringComparison.OrdinalIgnoreCase) 155|| string.Equals(candidateFile.ItemSpec, Constants.NET35ClientAssemblyIdentity[0], StringComparison.OrdinalIgnoreCase)))

ResolveManifestFiles.cs (22)

176_runtimePackAssets = RuntimePackAssets.ToDictionary(p => p.ItemSpec, StringComparer.OrdinalIgnoreCase); 259ITaskItem outputItem = new TaskItem(item.ItemSpec); 282ITaskItem outputItem = new TaskItem(item.ItemSpec); 286targetPath = Path.GetFileName(item.ItemSpec); 323ITaskItem outputItem = new TaskItem(item.ItemSpec); 347string[] pathSegments = PathUtil.GetPathSegments(item.ItemSpec); 349Debug.Assert(!String.IsNullOrEmpty(itemCulture), String.Format(CultureInfo.CurrentCulture, "Satellite item '{0}' is missing expected attribute '{1}'", item.ItemSpec, "Culture")); 364targetPath = Path.GetFileName(item.ItemSpec); 399AssemblyIdentity identity = AssemblyIdentity.FromManagedAssembly(item.ItemSpec); 505var outputAssembliesMap = outputAssemblies.ToDictionary(p => Path.GetFullPath(p.ItemSpec), StringComparer.OrdinalIgnoreCase); 517string key = Path.GetFullPath(item.ItemSpec); 579string fileExtension = Path.GetExtension(entry.item.ItemSpec); 667var outputEntryPoint = new TaskItem(entryPoint.ItemSpec); 730Log.LogWarningWithCodeFromResources("GenerateManifest.InvalidItemValue", "FileType", item.ItemSpec); 745_runtimePackAssets.TryGetValue(item.ItemSpec, out _)) 755AssemblyIdentity identity = AssemblyIdentity.FromManagedAssembly(item.ItemSpec); 756if (item.ItemSpec.EndsWith(".dll") && identity == null && !isDotNetCore) 804this.key = item.ItemSpec?.ToLowerInvariant(); 855fusionName = Path.Combine(destSubDir, Path.GetFileNameWithoutExtension(item.ItemSpec)); 859fusionName = Path.GetFileNameWithoutExtension(item.ItemSpec); 908AssemblyIdentity identity = AssemblyIdentity.FromManagedAssembly(item.ItemSpec); 919AssemblyIdentity identity = AssemblyIdentity.FromManagedAssembly(item.ItemSpec);

ResolveNonMSBuildProjectOutput.cs (7)

100Log.LogMessageFromResources(MessageImportance.Low, "ResolveNonMSBuildProjectOutput.ProjectReferenceResolutionStarting", projectRef.ItemSpec); 105if (resolvedPath.ItemSpec.Length > 0) 115GetAssemblyName(resolvedPath.ItemSpec); 124Log.LogMessageFromResources(MessageImportance.Low, "ResolveNonMSBuildProjectOutput.ProjectReferenceResolutionSuccess", projectRef.ItemSpec, resolvedPath.ItemSpec); 130Log.LogWarningWithCodeFromResources("ResolveNonMSBuildProjectOutput.ProjectReferenceResolutionFailure", projectRef.ItemSpec); 139Log.LogMessageFromResources(MessageImportance.Low, "ResolveNonMSBuildProjectOutput.ProjectReferenceUnresolved", projectRef.ItemSpec);

ResolveProjectBase.cs (2)

92Log.LogErrorWithCodeFromResources("General.MissingOrUnknownProjectReferenceAttribute", reference.ItemSpec, missingAttribute); 97Log.LogWarningWithCodeFromResources("General.MissingOrUnknownProjectReferenceAttribute", reference.ItemSpec, missingAttribute);

ResolveSDKReference.cs (8)

288if (ParseSDKReference(runtimeDependencyOnlyItem.ItemSpec, out string dependencyName, out string dependencyVersion)) 300string installLocation = installedsdk.ItemSpec; 560bool splitSuccessful = ParseSDKReference(referenceItem.ItemSpec, out string sdkSimpleName, out string rawSdkVersion); 564LogErrorOrWarning(new Tuple<string, object[]>("ResolveSDKReference.SDKReferenceIncorrectFormat", [referenceItem.ItemSpec])); 599Log.LogMessageFromResources(MessageImportance.Low, "ResolveSDKReference.SearchingForSDK", reference.ReferenceItem.ItemSpec); 616LogErrorOrWarning(new Tuple<string, object[]>("ResolveSDKReference.CouldNotResolveSDK", [reference.ReferenceItem.ItemSpec])); 915ResolvedPath = FileUtilities.EnsureTrailingSlash(sdk.ItemSpec); 1019AddResolutionErrorOrWarning("ResolveSDKReference.ErrorResolvingSDK", ReferenceItem.ItemSpec, ResourceUtilities.FormatResourceStringStripCodeAndKeyword("ResolveSDKReference.ErrorReadingManifest", _sdkManifestPath, _sdkManifest.ReadErrorMessage));

RoslynCodeTaskFactory\RoslynCodeTaskFactoryCompilers.cs (1)

103commandLine.AppendSwitchIfNotNull(ReferenceSwitch, reference.ItemSpec);

SignFile.cs (1)

56SigningTarget.ItemSpec,

Touch.cs (1)

94string path = FileUtilities.FixFilePath(file.ItemSpec);

Unzip.cs (6)

90destinationDirectory = Directory.CreateDirectory(DestinationFolder.ItemSpec); 94Log.LogErrorWithCodeFromResources("Unzip.ErrorCouldNotCreateDestinationDirectory", DestinationFolder.ItemSpec, e.Message); 109if (!FileSystems.Default.FileExists(sourceFile.ItemSpec)) 111Log.LogErrorWithCodeFromResources("Unzip.ErrorFileDoesNotExist", sourceFile.ItemSpec); 117using (FileStream stream = new FileStream(sourceFile.ItemSpec, FileMode.Open, FileAccess.Read, FileShare.Read, bufferSize: 0x1000, useAsync: false)) 143Log.LogErrorWithCodeFromResources("Unzip.ErrorCouldNotOpenFile", sourceFile.ItemSpec, e.Message);

WriteCodeFragment.cs (9)

109if (OutputFile != null && OutputDirectory != null && !Path.IsPathRooted(OutputFile.ItemSpec)) 111OutputFile = new TaskItem(Path.Combine(OutputDirectory.ItemSpec, OutputFile.ItemSpec)); 114OutputFile ??= new TaskItem(FileUtilities.GetTemporaryFile(OutputDirectory.ItemSpec, null, extension)); 116FileUtilities.EnsureDirectoryExists(Path.GetDirectoryName(OutputFile.ItemSpec)); 118File.WriteAllText(OutputFile.ItemSpec, code); // Overwrites file if it already exists (and can be overwritten) 122string itemSpec = OutputFile?.ItemSpec ?? String.Empty; 128Log.LogMessageFromResources(MessageImportance.Low, "WriteCodeFragment.GeneratedFile", OutputFile.ItemSpec); 254var attribute = new CodeAttributeDeclaration(new CodeTypeReference(attributeItem.ItemSpec));

XmlPeek.cs (2)

89Log.LogErrorWithCodeFromResources("XmlPeekPoke.InputFileError", XmlInputPath.ItemSpec, e.Message); 248_data = xmlInputPath.ItemSpec;

XmlPoke.cs (6)

66using (FileStream fs = new FileStream(XmlInputPath.ItemSpec, FileMode.Open, FileAccess.Read, FileShare.ReadWrite)) 77Log.LogErrorWithCodeFromResources("XmlPeekPoke.InputFileError", XmlInputPath.ItemSpec, e.Message); 127iter.Current.InnerXml = Value.ItemSpec; 128Log.LogMessageFromResources(MessageImportance.Low, "XmlPoke.Replaced", iter.Current.Name, Value.ItemSpec); 132Log.LogErrorWithCodeFromResources("XmlPoke.PokeError", Value.ItemSpec, e.Message); 142using (Stream stream = File.Create(XmlInputPath.ItemSpec))

XslTransformation.cs (4)

169using (XmlWriter xmlWriter = XmlWriter.Create(_outputPaths[i].ItemSpec, xslct.OutputSettings)) 289_data[i] = xmlFile[i].ItemSpec; 395_data = xsltFile.ItemSpec; 405_data = xsltCompiledDll.ItemSpec;

ZipDirectory.cs (2)

41DirectoryInfo sourceDirectory = new DirectoryInfo(SourceDirectory.ItemSpec); 49FileInfo destinationFile = new FileInfo(DestinationFile.ItemSpec);

AssemblyDependency\ResolveAssemblyReferenceTestFixture.cs (4)

2955if (String.Equals(item.ItemSpec, spec, StringComparison.OrdinalIgnoreCase)) 3051Assert.Equal(loadModeResolvedFiles[i].ItemSpec, t.ResolvedFiles[i].ItemSpec); 3095Assert.Equal(cache, t.FilesWritten[0].ItemSpec);

AssignCulture_Tests.cs (26)

AssignLinkMetadata_Tests.cs (4)

77Assert.Equal(item.ItemSpec, t.OutputItems[0].ItemSpec); 104Assert.Equal(item2.ItemSpec, t.OutputItems[0].ItemSpec);

AssignTargetPath_Tests.cs (1)

29t.AssignedFiles[0].ItemSpec.ShouldBe(NativeMethodsShared.IsWindows ? @"c:\bin2\abc.efg" : "/bin2/abc.efg");

ConvertToAbsolutePath_Tests.cs (3)

44Assert.EndsWith(testFile.FullName, t.AbsolutePaths[0].ItemSpec); 76Assert.EndsWith(testFile.FullName, t.AbsolutePaths[0].ItemSpec); 106Assert.Equal(testFile.FullName, t.AbsolutePaths[0].ItemSpec);

Copy_Tests.cs (26)

CreateCSharpManifestResourceName_Tests.cs (12)

375Assert.Equal(@"CustomToolTest.SR1", resourceNames[0].ItemSpec); 404t.ManifestResourceNames[0].ItemSpec.ShouldBe("MyStuff.Namespace.Class", "Expecting to find the namespace & class name from SR1.cs"); 444t.ManifestResourceNames[0].ItemSpec.ShouldBe(ResourceFileName, "Expecting to find the namespace & class name from SR1.cs"); 477t.ManifestResourceNames[0].ItemSpec.ShouldBe("MyStuff.Namespace.Class", "Expecting to find the namespace & class name from SR1.cs"); 511t.ManifestResourceNames[0].ItemSpec.ShouldBe("SR1", "Expected only the file name."); 542t.ManifestResourceNames[0].ItemSpec.ShouldBe("MyStuff2.Namespace.Class2", "Expected the namespace & class of SR2."); 576t.ManifestResourceNames[0].ItemSpec.ShouldBe("SR1", "Expected only the file name."); 613t.ManifestResourceNames[0].ItemSpec.ShouldBe("MyStuff.Namespace.Class.de", "Expected Namespace.Class.Culture"); 808Assert.Equal(@"strings.resx", resourceFiles[0].ItemSpec); 834Assert.Equal(@"pic.bmp", resourceFiles[0].ItemSpec); 860Assert.Equal(@"pic.bmp", resourceFiles[0].ItemSpec); 885Assert.Equal(@"strings.resx", resourceFiles[0].ItemSpec);

CreateItem_Tests.cs (3)

83Assert.Equal("MyFile.txt", t.Include[0].ItemSpec); 101Assert.Equal(t.Include[0].ItemSpec, t.Include[0].ItemSpec);

Delete_Tests.cs (1)

39Assert.Equal("MyFiles.nonexistent", t.DeletedFiles[0].ItemSpec);

DownloadFile_Tests.cs (3)

83downloadFile.DownloadedFile.ItemSpec.ShouldBe(file.FullName); 128downloadFile.DownloadedFile.ItemSpec.ShouldBe(file.FullName); 162downloadFile.DownloadedFile.ItemSpec.ShouldBe(file.FullName);

Exec_Tests.cs (1)

1048exec.ConsoleOutput[0].ItemSpec.ShouldBe(lineWithLeadingWhitespace);

FindAppConfigFile_Tests.cs (5)

25Assert.Equal("app.config", f.AppConfigFile.ItemSpec); 38Assert.Equal("app.config", f.AppConfigFile.ItemSpec); 51Assert.Equal(FileUtilities.FixFilePath("foo\\app.config"), f.AppConfigFile.ItemSpec); 77Assert.Equal(FileUtilities.FixFilePath(@"foo\\app.config"), f.AppConfigFile.ItemSpec); 94Assert.Equal("app.config", f.AppConfigFile.ItemSpec);

FindInList_Tests.cs (6)

25Assert.Equal("A.CS", f.ItemFound.ItemSpec); 37Assert.Equal("a.cs", f.ItemFound.ItemSpec); 64Assert.Equal("a.cs", f.ItemFound.ItemSpec); 84Assert.Equal("a.cs", f.ItemFound.ItemSpec); 120Assert.Equal(FileUtilities.FixFilePath(@"c:\foo\a.cs"), f.ItemFound.ItemSpec); 135Assert.Equal(FileUtilities.FixFilePath(@"foo\a.cs"), f.ItemFound.ItemSpec);

FindInvalidProjectReferences_Tests.cs (2)

58Assert.Equal("proj3.proj", t.InvalidReferences[0].ItemSpec); 59Assert.Equal("proj4.proj", t.InvalidReferences[1].ItemSpec);

FindUnderPath_Tests.cs (6)

35Assert.Equal(FileUtilities.FixFilePath(@"C:\MyProject\File1.txt"), t.InPath[0].ItemSpec); 36Assert.Equal(FileUtilities.FixFilePath(@"C:\SomeoneElsesProject\File2.txt"), t.OutOfPath[0].ItemSpec); 111Assert.Equal(testFile.FullName, t.InPath[0].ItemSpec); 113t.OutOfPath[0].ItemSpec); 133Assert.Equal(testFile.Name, t.InPath[0].ItemSpec); 135t.OutOfPath[0].ItemSpec);

GetInstalledSDKLocations_Tests.cs (2)

339extensionSDKs.Add(item.GetMetadata("SDKName"), item.ItemSpec); 413extensionSDKs.Add(item.GetMetadata("SDKName"), item.ItemSpec);

GetSDKReference_Tests.cs (94)

MakeDir_Tests.cs (8)

44Assert.Equal(dir, t.DirectoriesCreated[0].ItemSpec); 51Assert.Equal(dir, t.DirectoriesCreated[0].ItemSpec); 95Assert.Equal(dir2, t.DirectoriesCreated[1].ItemSpec); 103Assert.Equal(dir2, t.DirectoriesCreated[2].ItemSpec); 106Assert.Equal(dir, t.DirectoriesCreated[0].ItemSpec); 147Assert.Equal(dir, t.DirectoriesCreated[0].ItemSpec); 158Assert.Equal(dir, t.DirectoriesCreated[0].ItemSpec); 215Assert.Equal(dir, t.DirectoriesCreated[0].ItemSpec);

Move_Tests.cs (13)

MSBuild_Tests.cs (5)

1348Assert.Equal("|a", msbuildTask.TargetOutputs[0].ItemSpec); 1349Assert.Equal("A|b", msbuildTask.TargetOutputs[1].ItemSpec); 1350Assert.Equal("B|c", msbuildTask.TargetOutputs[2].ItemSpec); 1351Assert.Equal("C|d", msbuildTask.TargetOutputs[3].ItemSpec); 1352Assert.Equal("D|", msbuildTask.TargetOutputs[4].ItemSpec);

ReadLinesFromFile_Tests.cs (12)

47Assert.Equal("Line1", r.Lines[0].ItemSpec); 56Assert.Equal("Line1", r.Lines[0].ItemSpec); 57Assert.Equal("Line2", r.Lines[1].ItemSpec); 58Assert.Equal("Line3", r.Lines[2].ItemSpec); 94Assert.Equal("Line1_%3b_", r.Lines[0].ItemSpec); 103Assert.Equal("Line1_%3b_", r.Lines[0].ItemSpec); 104Assert.Equal("Line2", r.Lines[1].ItemSpec); 105Assert.Equal("Line3", r.Lines[2].ItemSpec); 139Assert.Equal("My special character is \u00C3", r.Lines[0].ItemSpec); 199Assert.Equal("Line1", r.Lines[0].ItemSpec); 200Assert.Equal("Line2", r.Lines[1].ItemSpec); 201Assert.Equal("Line3", r.Lines[2].ItemSpec);

RemoveDir_Tests.cs (2)

43t.RemovedDirectories[0].ItemSpec.ShouldBe("MyNonExistentDirectory"); 44Directory.Exists(t.RemovedDirectories[0].ItemSpec).ShouldBeFalse();

RemoveDuplicates_Tests.cs (11)

ResolveNonMSBuildProjectOutput_Tests.cs (3)

119Assert.Equal(resolvedPath.ItemSpec, expectedPath); 200unresolvedOutputs[rvpo.UnresolvedProjectReferences[i].ItemSpec] = rvpo.UnresolvedProjectReferences[i]; 206resolvedOutputs[rvpo.ResolvedOutputPaths[i].ItemSpec] = rvpo.ResolvedOutputPaths[i];

ResolveSDKReference_Tests.cs (64)

ResourceHandling\GenerateResource_Tests.cs (290)

WriteCodeFragment_Tests.cs (36)

WriteLinesToFile_Tests.cs (5)

43Assert.False(File.Exists(a.File.ItemSpec)); 70Assert.Equal("\uBDEA", r.Lines[0].ItemSpec); 91Assert.NotEqual("\uBDEA", r.Lines[0].ItemSpec); 120r.Lines[0].ItemSpec.ShouldBe("File contents1"); 203r.Lines[0].ItemSpec.ShouldBe("File contents1");

XmlPeek_Tests.cs (7)

81Assert.Equal(p.Result[i].ItemSpec, results[i]); 110Assert.Equal(p.Result[i].ItemSpec, results[i]); 139Assert.Equal(p.Result[i].ItemSpec, results[i]); 161Assert.Equal(p.Result[i].ItemSpec, results[i]); 181Assert.Equal(p.Result[i].ItemSpec, results[i]); 198Assert.Equal(xmlInputPath, p.XmlInputPath.ItemSpec); 358Assert.Equal(["abcdefg", "a$(d)fg", "a$(d.f)"], p.Result.Select(x => x.ItemSpec));

XslTransformation_Tests.cs (3)

376using (StreamReader sr = new StreamReader(t.OutputPaths[0].ItemSpec)) 413using (StreamReader sr = new StreamReader(t.OutputPaths[0].ItemSpec)) 888using (StreamReader sr = new StreamReader(t.OutputPaths[0].ItemSpec))

ObjectModelHelpers.cs (7)

364expectedItemSpecs.Append(expectedItem.ItemSpec); 376actualItemSpecs.Append(actualItem.ItemSpec); 391if (expectedItems[expectedItemIndex].ItemSpec == actualItem.ItemSpec) 421string.Format("Item '{0}' does not have expected metadata '{1}'.", actualItem.ItemSpec, metadataName)); 425string.Format("Item '{0}' has unexpected metadata {1}={2}.", actualItem.ItemSpec, metadataName, actualMetadataValue)); 445Assert.Fail(string.Format("Item '{0}' was expected but not returned.", expectedItem.ItemSpec));

CommandLineBuilder.cs (8)

385VerifyThrowNoEmbeddedDoubleQuotes(string.Empty, fileItem.ItemSpec); 387AppendFileNameIfNotNull(fileItem.ItemSpec); 447VerifyThrowNoEmbeddedDoubleQuotes(string.Empty, fileItems[i].ItemSpec); 461AppendFileNameWithQuoting(fileItems[i].ItemSpec); 551AppendSwitchIfNotNull(switchName, parameter.ItemSpec); 617AppendTextWithQuoting(parameter.ItemSpec); 663AppendSwitchUnquotedIfNotNull(switchName, parameter.ItemSpec); 727AppendTextUnquoted(parameter.ItemSpec);

TaskItem.cs (1)

132_itemSpec = EscapingUtilities.Escape(sourceItem.ItemSpec);

TrackedDependencies\TrackedDependencies.cs (5)

37if (FileMatcher.HasWildcards(item.ItemSpec)) 40string directoryName = Path.GetDirectoryName(item.ItemSpec); 41string searchPattern = Path.GetFileName(item.ItemSpec); 52files = FileMatcher.Default.GetFiles(null, item.ItemSpec).FileList; 81if (!FileUtilities.FileExistsNoThrow(item.ItemSpec))

MSBuild\ProjectFile\CommandLineArgumentReader.cs (2)

117return GetAbsolutePath(documentItem.ItemSpec); 221var trimmed = item.ItemSpec.Trim();

MSBuild\ProjectFile\ProjectFile.cs (6)

225.Select(item => item.ItemSpec) 241=> !Path.GetFileName(item.ItemSpec).StartsWith("TemporaryGeneratedFile_", StringComparison.Ordinal); 274var filePath = documentItem.ItemSpec; 295=> GetAbsolutePathRelativeToProject(documentItem.ItemSpec); 318return !_documents.ContainsKey(GetAbsolutePathRelativeToProject(documentItem.ItemSpec)); 331var filePath = documentItem.ItemSpec;

src\DownloadFile.cs (2)

80var uri = uriConfig.ItemSpec; 101Log.LogError($"Download from all targets failed. List of attempted targets: {string.Join(", ", Uris.Select(m => m.ItemSpec))}");

src\GenerateChecksums.cs (5)

30Log.LogError($"Metadata 'DestinationPath' is missing for item '{item.ItemSpec}'."); 34if (!File.Exists(item.ItemSpec)) 36Log.LogError($"The file '{item.ItemSpec}' does not exist."); 40Log.LogMessage(MessageImportance.High, $"Generating checksum for '{item.ItemSpec}' into '{destinationPath}'..."); 42using (FileStream stream = File.OpenRead(item.ItemSpec))

src\GenerateSourcePackageSourceLinkTargetsFile.cs (1)

50var itemSpec = sourceRoot.ItemSpec;

src\GetAssemblyFullName.cs (1)

29var assemblyPath = string.IsNullOrEmpty(PathMetadata) ? item.ItemSpec : item.GetMetadata(PathMetadata);

src\GroupItemsBy.cs (1)

77group item by item.ItemSpec

src\SaveItems.cs (1)

42project.AddItem(ItemName, item.ItemSpec, metadataPairs);

GroupItemsByTests.cs (1)

38}, task.GroupedItems.Select(i => $"{i.ItemSpec}: {string.Join(" ", inspectMetadata.Select(m => $"{m}='{i.GetMetadata(m)}'"))}"));

src\BlobArtifactModelFactory.cs (1)

39_log.LogError($"Missing 'RelativeBlobPath' property on blob {item.ItemSpec}");

src\BlobFeedAction.cs (5)

82string fileName = Path.GetFileName(item.ItemSpec); 94$"Item '{item.ItemSpec}' RelativeBlobPath contains virtual directory " + 114if (!await blobUtils.IsFileIdenticalToBlobAsync(item.ItemSpec, relativeBlobPath)) 129new FileStream(item.ItemSpec, FileMode.Open, FileAccess.Read, FileShare.Read)) 132await blobUtils.UploadBlockBlobAsync(item.ItemSpec, relativeBlobPath, stream);

src\BuildModelFactory.cs (3)

161var isSymbolsPackage = GeneralUtils.IsSymbolPackage(artifact.ItemSpec); 163if (artifact.ItemSpec.EndsWith(".nupkg", StringComparison.OrdinalIgnoreCase) && !isSymbolsPackage) 171string fileName = Path.GetFileName(artifact.ItemSpec);

src\common\UploadToAzure.cs (5)

94throw new Exception(string.Format("Metadata 'RelativeBlobPath' is missing for item '{0}'.", item.ItemSpec)); 97if (!File.Exists(item.ItemSpec)) 99throw new Exception(string.Format("The file '{0}' does not exist.", item.ItemSpec)); 108if (await blobReference.IsFileIdenticalToBlobAsync(item.ItemSpec)) 119using (Stream localFileStream = File.OpenRead(item.ItemSpec))

src\ConfigureInputFeed.cs (1)

38nugetConfigBody += $"<add key=\"inputFeed{i}\" value=\"{ EnableFeeds[i].ItemSpec }\" />{Environment.NewLine}";

src\model\SetupTargetFeedConfigV3.cs (3)

62FeedKeys = feedKeys.ToImmutableDictionary(i => i.ItemSpec, i => i.GetMetadata("Key")); 63FeedSasUris = feedSasUris.ToImmutableDictionary(i => i.ItemSpec, i => ConvertFromBase64(i.GetMetadata("Base64Uri"))); 64FeedOverrides = feedOverrides.ToImmutableDictionary(i => i.ItemSpec, i => i.GetMetadata("Replacement"));

src\PackageArtifactModelFactory.cs (2)

30_log.LogMessage($"Creating NupkgInfo based on '{item.ItemSpec}'"); 32NupkgInfo info = _nupkgInfoFactory.CreateNupkgInfo(item.ItemSpec);

src\PushToBuildStorage.cs (9)

152if (!fileSystem.FileExists(blobItem.ItemSpec)) 154Log.LogError($"Could not find file {blobItem.ItemSpec}."); 164.Where(i => i.ItemSpec.EndsWith("symbols.nupkg")) 167string fileName = Path.GetFileName(i.ItemSpec); 194if (!fileSystem.FileExists(packagePath.ItemSpec)) 196Log.LogError($"Could not find file {packagePath.ItemSpec}."); 205if (!fileSystem.FileExists(blobItem.ItemSpec)) 207Log.LogError($"Could not find file {blobItem.ItemSpec}."); 261string path = item.ItemSpec;

src\SigningInformationModelFactory.cs (5)

54var fileName = Path.GetFileName(itemToSign.ItemSpec); 68parsedStrongNameSignInfo.Add(new StrongNameSignInfoModel { Include = Path.GetFileName(signInfo.ItemSpec), CertificateName = attributes["CertificateName"], PublicKeyToken = attributes["PublicKeyToken"] }); 76var fileSignInfoModel = new FileSignInfoModel { Include = Path.GetFileName(signInfo.ItemSpec), CertificateName = attributes["CertificateName"] }; 96parsedFileExtensionSignInfoModel.Add(new FileExtensionSignInfoModel { Include = signInfo.ItemSpec, CertificateName = attributes["CertificateName"] }); 104parsedCertificatesSignInfoModel.Add(new CertificatesSignInfoModel { Include = signInfo.ItemSpec, DualSigningAllowed = bool.Parse(attributes["DualSigningAllowed"]) });

src\CreateControlFile.cs (2)

55string dependencyItem = depend.ItemSpec; 74writer.WriteLine($"{property.ItemSpec}: {property.GetMetadata("Value")}");

src\CreateDebPackage.cs (2)

36using Stream controlFile = File.OpenRead(ControlFile.ItemSpec); 38using Stream dataFile = File.OpenRead(DataFile.ItemSpec);

src\CreateLightCommandPackageDrop.cs (1)

75commandString.Append($" -sice:{siceItem.ItemSpec}");

src\CreateMD5SumsFile.cs (2)

38using FileStream fileStream = File.OpenRead(file.ItemSpec); 41string relativePath = file.ItemSpec.Substring(RootDirectory.Length).TrimStart(Path.DirectorySeparatorChar);

src\CreateRpmPackage.cs (6)

96builder.AddRequiredCapability(require.ItemSpec, require.GetMetadata("Version")); 101builder.AddConflict(conflict.ItemSpec); 106builder.AddChangelogLine(Packager, changelogLine.ItemSpec); 112HashSet<string> ownedDirectories = new(OwnedDirectories.Select(d => d.ItemSpec)); 116builder.AddScript(script.GetMetadata("Kind"), File.ReadAllText(script.ItemSpec)); 121Dictionary<string, string> filePathToKind = RawPayloadFileKinds.Select(k => k.ItemSpec.Split(':')).ToDictionary(k => k[0], k => k[1].Trim());

src\CreateWixCommandPackageDropBase.cs (9)

106commandString.Append($" -loc {Path.GetFileName(locItem.ItemSpec)}"); 113commandString.Append($" -ext {wixExtension.ItemSpec}"); 120commandString.Append($" {Path.GetFileName(wixSrcFile.ItemSpec)}"); 144string newWixSrcFilePath = Path.Combine(packageDropOutputFolder, Path.GetFileName(wixSrcFile.ItemSpec)); 145File.Copy(wixSrcFile.ItemSpec, newWixSrcFilePath, true); 147string wixSrcFileExtension = Path.GetExtension(wixSrcFile.ItemSpec); 176var destinationPath = Path.Combine(packageDropOutputFolder, Path.GetFileName(locItem.ItemSpec)); 177File.Copy(locItem.ItemSpec, destinationPath, true); 292var possiblePath = Path.Combine(additionalBasePath.ItemSpec, oldPath);

src\GenerateJsonObjectString.cs (2)

43foreach (var group in Properties.GroupBy(item => item.ItemSpec)) 139Log.LogError($"Item '{item.ItemSpec}' has no String or Object value.");

src\StabilizeWixFileId.cs (4)

63Log.LogError($"{nameof(FileElementToStabilize)} {file.ItemSpec} has null/empty ReplacementId metadata."); 73?.EndsWith(file.ItemSpec, StringComparison.OrdinalIgnoreCase) == true) 79$"Expected 1 match for '{file.ItemSpec}', found {matchingFileElements.Length}: " + 94$"Setting '{file.ItemSpec}' Id to '{replacement}' for File with Source " +

ApplyBaseLine.cs (4)

65if (!baseLineVersions.TryGetValue(baseLinePackage.ItemSpec, out versions)) 67baseLineVersions[baseLinePackage.ItemSpec] = versions = new SortedSet<Version>(); 82if (baseLineVersions.TryGetValue(dependency.ItemSpec, out dependencyBaseLineVersions)) 112string packageId = dependency.ItemSpec;

ApplyMetaPackages.cs (3)

65if (!suppressMetaPackages.TryGetValue(metapackage.ItemSpec, out var value)) 68suppressMetaPackages.Add(metapackage.ItemSpec, value); 96var metaPackage = index.MetaPackages.GetMetaPackageId(originalDependency.ItemSpec);

ApplyPreReleaseSuffix.cs (2)

77string packageId = originalPackage.ItemSpec; 122string stablePackageId = stablePackage.ItemSpec;

CreateTrimDependencyGroups.cs (1)

182public TaskItemPackageDependency(ITaskItem item) : base(item.ItemSpec, TryParseVersionRange(item.GetMetadata("Version")))

FilterUnknownPackages.cs (3)

46var baseLinePackageIds = new HashSet<string>(BaseLinePackages.NullAsEmpty().Select(b => b.ItemSpec)); 52!dependency.ItemSpec.StartsWith("System.Private") || // only apply filtering to System.Private dependencies 53isKnownPackage(dependency.ItemSpec)

GenerateNuSpec.cs (4)

274orderby fr.ItemSpec, StringComparer.Ordinal 275select new FrameworkAssemblyReference(fr.ItemSpec, new[] { fr.GetTargetFramework() }) 301Id = d.ItemSpec, 335File = r.ItemSpec,

GeneratePackageReport.cs (4)

208fx = FrameworkUtilities.ParseNormalized(framework.ItemSpec); 212Log.LogError($"Could not parse Framework {framework.ItemSpec}. {ex}"); 218Log.LogError($"Did not recognize {framework.ItemSpec} as valid Framework."); 309Log.LogError($"Could not parse File {file.ItemSpec}. {ex}");

GenerateRuntimeDependencies.cs (9)

85Log.LogMessage(LogImportance.Low, "Aliasing {0} -> {1}", alias, dependency.ItemSpec); 86packageAliases[alias] = dependency.ItemSpec; 98Log.LogMessage(LogImportance.Low, "Skipping dependencies {0} since they don't have a TargetRuntime.", String.Join(", ", runtimeGroup.Select(d => d.ItemSpec))); 102if (runtimeGroup.Any(d => d.ItemSpec == c_emptyDependency)) 115var dependencyGroups = targetPackageGroup.GroupBy(d => d.ItemSpec); 156Log.LogWarning("Dependency {0} specified TargetPackageAlias {1} but no package was found defining this alias.", dependency.ItemSpec, targetPackageAlias); 165Log.LogMessage(LogImportance.Low, "Dependency {0} has no parent so will assume {1}.", dependency.ItemSpec, PackageId); 179Log.LogWarning("Dependency {0} has no version", dependency.ItemSpec); 184Log.LogError("Dependency {0} has invalid version {1}", dependency.ItemSpec, dependencyVersionString);

GetApplicableAssetsFromPackages.cs (4)

108Log.LogMessage($"Resolved compile assets from {compileFx.ToString()}: {String.Join(";", CompileAssets.Select(c => c.ItemSpec))}"); 132Log.LogMessage($"Resolved runtime assets from {runtimeFx.ToString()}: {String.Join(";", RuntimeAssets.Select(r => r.ItemSpec))}"); 169Log.LogError($"Could not parse File {file.ItemSpec}. {ex}"); 210var pdbItem = new TaskItem(Path.ChangeExtension(packageItem.OriginalItem.ItemSpec, ".pdb"));

GetAssemblyReferences.cs (3)

50if (!File.Exists(assemblyItem.ItemSpec)) 52Log.LogError($"File {assemblyItem.ItemSpec} does not exist, ensure you have built libraries before building the package."); 56using (PEReader peReader = new PEReader(new FileStream(assemblyItem.ItemSpec, FileMode.Open, FileAccess.Read, FileShare.Delete | FileShare.Read)))

GetLastStablePackage.cs (3)

80var packageId = latestPackage.ItemSpec; 95var packageId = stablePackage.ItemSpec; 136var packageId = latestPackage.ItemSpec;

GetLayoutFiles.cs (1)

46i => NuGetFramework.Parse(i.ItemSpec),

GetMinimumNETStandard.cs (1)

31var minNETStandard = Frameworks.Select(fx => NuGetFramework.Parse(fx.ItemSpec))

GetPackageDestination.cs (2)

83var packageTargetFrameworks = PackageTargetFrameworks.NullAsEmpty().Where(p => !String.IsNullOrEmpty(p.ItemSpec)); 86var packageFx = NuGetFramework.Parse(packageTargetFramework.ItemSpec);

GetPackageFromModule.cs (2)

54modulesToPackages.Add(modulePackage.ItemSpec, modulePackage.GetMetadata("Package")); 62string moduleName = moduleReferenced.ItemSpec;

HarvestPackage.cs (7)

149_packageFolders.Add(runtimePackage.ItemSpec, LocatePackageFolder(runtimePackage.ItemSpec, runtimePackage.GetMetadata("Version"))); 184fx = FrameworkUtilities.ParseNormalized(framework.ItemSpec); 188Log.LogError($"Could not parse Framework {framework.ItemSpec}. {ex}"); 194Log.LogError($"Did not recognize {framework.ItemSpec} as valid Framework."); 233var supportedFramework = new TaskItem(framework.ItemSpec); 522_pathsToInclude = PathsToInclude.NullAsEmpty().ToDictionary(i => NormalizePath(i.ItemSpec), i=> i, StringComparer.OrdinalIgnoreCase);

NuGetPack.cs (4)

191return nuspecProperties == null ? null : NuspecPropertyStringProvider.GetNuspecPropertyProviderFunction(nuspecProperties.Select(p => p.ItemSpec).ToArray()); 370? _libPackageExcludes.Concat(AdditionalLibPackageExcludes?.Select(item => item.ItemSpec) ?? Enumerable.Empty<string>()) 371: LibPackageExcludes.Select(item => item.ItemSpec); 380.Concat(AdditionalSymbolPackageExcludes?.Select(item => item.ItemSpec) ?? Enumerable.Empty<string>());

PromoteDependencies.cs (1)

108Id = item.ItemSpec;

SplitDependenciesBySupport.cs (1)

68Name = originalItem.ItemSpec;

SplitReferences.cs (4)

71string referenceName = reference.ItemSpec; 108if (collection.TryGetValue(item.ItemSpec, out existingItem)) 115collection[item.ItemSpec] = item; 120collection[item.ItemSpec] = item;

UpdatePackageIndex.cs (4)

97_packageIdsToInclude = new HashSet<string>(PackageIds.Select(i => i.ItemSpec), StringComparer.OrdinalIgnoreCase); 135var info = GetOrCreatePackageInfo(index, baselinePackage.ItemSpec); 146var info = GetOrCreatePackageInfo(index, stablePackage.ItemSpec); 158index.ModulesToPackages[moduleToPackage.ItemSpec] = package;

ValidateHarvestVersionIsLatestForRelease.cs (1)

29Parallel.ForEach(PackageReports, (reportPath) => ValidateHarvestVersionForReport(reportPath.ItemSpec));

ValidatePackage.cs (12)

363AllSupportedFrameworks = _frameworks.Values.Where(fx => fx.SupportedVersion != null).Select(fx => fx.ToItem()).OrderBy(i => i.ItemSpec).ToArray(); 383Log.LogError($"PackageIndex from {String.Join(", ", PackageIndexes.Select(i => i.ItemSpec))} is missing an entry for package {PackageId}. Please run /t:UpdatePackageIndex on this project to commit an update."); 400Log.LogError($"PackageIndex from {String.Join(", ", PackageIndexes.Select(i => i.ItemSpec))} is missing an assembly version entry for {fileVersion} for package {PackageId}. Please run /t:UpdatePackageIndex on this project to commit an update."); 407Log.LogError($"PackageIndex from {String.Join(", ", PackageIndexes.Select(i => i.ItemSpec))} indicates that assembly version {fileVersion} is contained in non-stable package version {packageVersion} which differs from this package version {thisPackageVersion}."); 417Log.LogError($"PackageIndex from {String.Join(", ", PackageIndexes.Select(i => i.ItemSpec))} is has an assembly version entry(s) for {String.Join(", ", orphanedAssemblyVersions)} which are no longer in package {PackageId}. Please run /t:UpdatePackageIndex on this project to commit an update."); 430Log.LogError($"PackageIndex from {String.Join(", ", PackageIndexes.Select(i => i.ItemSpec))} is missing an baseline entry(s) for native module {PackageId}. Please run /t:UpdatePackageIndex on this project to commit an update."); 441Log.LogError($"PackageIndex from {String.Join(", ", PackageIndexes.Select(i => i.ItemSpec))} is missing ModulesToPackages entry(s) for {String.Join(", ", missingModuleNames)} to package {PackageId}. Please add a an entry for the appropriate package."); 463fx = FrameworkUtilities.ParseNormalized(framework.ItemSpec); 467Log.LogError($"Could not parse Framework {framework.ItemSpec}. {ex}"); 473Log.LogError($"Did not recognize {framework.ItemSpec} as valid Framework."); 500string fxString = supportedFramework.ItemSpec; 531Log.LogError($"Could not parse Version {version} on SupportedFramework item {supportedFramework.ItemSpec}. {ex}");

ValidationTask.cs (1)

106AddSuppression(suppression.ItemSpec, suppression.GetMetadata("Value"));

ApplyBaseLineTests.cs (4)

48item.ItemSpec.Should().Be("System.Runtime"); 77item.ItemSpec.Should().Be("System.Runtime"); 105item.ItemSpec.Should().Be("System.Runtime"); 134item.ItemSpec.Should().Be("System.Banana");

CreateTrimDependencyGroupsTests.cs (5)

231f.ItemSpec.Equals("System.Collections.Immutable", StringComparison.OrdinalIgnoreCase)) 237f.ItemSpec.Equals("System.Collections.Immutable", StringComparison.OrdinalIgnoreCase)) 243f.ItemSpec.Equals("System.Collections.Immutable", StringComparison.OrdinalIgnoreCase)) 249f.ItemSpec.Equals("System.Collections.Immutable", StringComparison.OrdinalIgnoreCase)) 362task.TrimmedDependencies.Should().OnlyContain(d => d.ItemSpec == "System.Collections.Immutable");

GetLastStablePackageTests.cs (6)

47item.ItemSpec.Should().Be("StableVersionTest"); 75item.ItemSpec.Should().Be("StableVersionTest"); 102item.ItemSpec.Should().Be("StableVersionTest"); 152item.ItemSpec.Should().Be("StableVersionTest"); 180item.ItemSpec.Should().Be("StableVersionTest"); 207item.ItemSpec.Should().Be("StableVersionTest");

ChooseBestP2PTargetFrameworkTask.cs (1)

107Log.LogError(string.Format(CultureInfo.CurrentCulture, "Project '{0}' targets '{1}'. It cannot be referenced by a project that targets '{2}{3}'.", project.ItemSpec, referencedProjectFrameworkString, projectNuGetFramework.DotNetFrameworkName, projectNuGetFramework.HasPlatform ? "-" + projectNuGetFramework.DotNetPlatformName : string.Empty));

ChooseBestTargetFrameworksTask.cs (2)

36NuGetFramework framework = NuGetFramework.ParseFolder(buildTargetFramework.ItemSpec); 38if (bestTargetFramework != null && (!Distinct || !bestTargetFrameworkList.Any(b => b.ItemSpec == bestTargetFramework)))

Vsix\GetPkgDefAssemblyDependencyGuid.cs (1)

45var value = string.IsNullOrEmpty(InputMetadata) ? item.ItemSpec : item.GetMetadata(InputMetadata);

Msi\MsiBase.wix.cs (2)

217SuppressIces = iceSuppressions == null ? null : string.Join(";", iceSuppressions.Select(i => i.ItemSpec)) 246string msiJsonPath = MsiProperties.Create(msi.ItemSpec);

StringExtensions.cs (1)

46str = str.Replace(item.ItemSpec, item.GetMetadata(Metadata.Replacement));

Swix\MsiSwixProject.wix.cs (3)

104return Path.Combine(relativePath, Path.GetFileName(_msi.ItemSpec)); 112FileInfo fileInfo = new(_msi.ItemSpec); 146msiWriter.WriteLine($" SystemDrive={MsiUtils.GetInstallSize(_msi.ItemSpec)}");

Swix\SwixComponent.cs (1)

158ITaskItem? resourceItem = componentResources?.Where(r => string.Equals(r.ItemSpec, workload.Id)).FirstOrDefault();

WorkloadManifestPackage.wix.cs (1)

78base(package.ItemSpec, destinationBaseDirectory, shortNames, log)

WorkloadSetPackage.wix.cs (1)

52base(package.ItemSpec, destinationBaseDirectory, shortNames, log)

CreateVisualStudioWorkloadSetTests.cs (6)

53MsiUtils.GetAllRegistryKeys(msi.ItemSpec).Should().Contain(r => 60Assert.False(MsiUtils.HasTable(msi.ItemSpec, "Upgrade")); 63DirectoryRow versionDir = MsiUtils.GetAllDirectories(msi.ItemSpec).FirstOrDefault(d => string.Equals(d.Directory, "WorkloadSetVersionDir")); 68ITaskItem workloadSetSwixItem = createWorkloadSetTask.SwixProjects.Where(s => s.ItemSpec.Contains(@"Microsoft.NET.Workloads.9.0.100.9.0.100-baseline.1.23464.1\x64")).FirstOrDefault(); 71string msiSwr = File.ReadAllText(Path.Combine(Path.GetDirectoryName(workloadSetSwixItem.ItemSpec), "msi.swr")); 82string packageGroupSwr = File.ReadAllText(Path.Combine(Path.GetDirectoryName(workloadSetPackageGroupSwixItem.ItemSpec), "packageGroup.swr"));

CreateVisualStudioWorkloadTests.cs (20)

76ITaskItem manifestMsiItem = createWorkloadTask.Msis.Where(m => m.ItemSpec.ToLowerInvariant().Contains("d96ba8044ad35589f97716ecbf2732fb-x64.msi")).FirstOrDefault(); 81Assert.Equal("{C4F269D9-6B65-36C5-9556-75B78EFE9EDA}", MsiUtils.GetProperty(manifestMsiItem.ItemSpec, MsiProperty.UpgradeCode)); 84Assert.Equal("6.33.28", MsiUtils.GetProperty(manifestMsiItem.ItemSpec, MsiProperty.ProductVersion)); 85Assert.Equal("Microsoft.NET.Workload.Emscripten,6.0.200,x64", MsiUtils.GetProviderKeyName(manifestMsiItem.ItemSpec)); 89using SummaryInfo si = new(manifestMsiItem.ItemSpec, enableWrite: false); 97i => i.ItemSpec.Contains("microsoft.net.sdk.emscripten.5.6.swixproj")).ItemSpec), "component.swr")); 102i => i.ItemSpec.Contains("microsoft.net.sdk.emscripten.pre.5.6.swixproj")).ItemSpec), "component.swr")); 143ITaskItem pythonPackSwixItem = createWorkloadTask.SwixProjects.Where(s => s.ItemSpec.Contains(@"Microsoft.Emscripten.Python.6.0.4\x64")).FirstOrDefault(); 144string packMsiSwr = File.ReadAllText(Path.Combine(Path.GetDirectoryName(pythonPackSwixItem.ItemSpec), "msi.swr")); 153Assert.All(swixComponentProjects, c => Assert.True(c.ItemSpec.Contains(".pre.") && c.GetMetadata(Metadata.IsPreview) == "true" || 154!c.ItemSpec.Contains(".pre.") && c.GetMetadata(Metadata.IsPreview) == "false")); 212ITaskItem manifestMsiItem = createWorkloadTask.Msis.Where(m => m.ItemSpec.ToLowerInvariant().Contains("d96ba8044ad35589f97716ecbf2732fb-arm64.msi")).FirstOrDefault(); 217Assert.Equal("{CBA7CF4A-F3C9-3B75-8F1F-0D08AF7CD7BE}", MsiUtils.GetProperty(manifestMsiItem.ItemSpec, MsiProperty.UpgradeCode)); 220Assert.Equal("6.33.28", MsiUtils.GetProperty(manifestMsiItem.ItemSpec, MsiProperty.ProductVersion)); 221Assert.Equal("Microsoft.NET.Workload.Emscripten,6.0.200,arm64", MsiUtils.GetProviderKeyName(manifestMsiItem.ItemSpec)); 225using SummaryInfo si = new(manifestMsiItem.ItemSpec, enableWrite: false); 232i => i.ItemSpec.Contains("microsoft.net.sdk.emscripten.5.6.swixproj")).ItemSpec), "component.swr"));

SwixPackageGroupTests.cs (1)

37string packageGroupSwr = File.ReadAllText(Path.Combine(Path.GetDirectoryName(packageGroupItem.ItemSpec), "packageGroup.swr"));

src\CreateAkaMSLinks.cs (1)

59string shortUrl = link.ItemSpec;

GenAPITask.cs (1)

415Filter = new DocIdIncludeListFilter(c.ItemSpec) { IncludeForwardedTypes = FollowTypeForwards }

GenPartialFacadeSource.cs (2)

43ReferencePaths?.Select(item => item.ItemSpec).ToArray(), 45CompileFiles?.Select(item => item.ItemSpec).ToArray(),

GenPartialFacadeSourceGenerator.cs (1)

72string key = item.ItemSpec;

NotSupportedAssemblyGenerator.cs (1)

54string sourceFile = item.ItemSpec;

FindDotNetCliPackage.cs (9)

155"sdk" => $"{feed.ItemSpec}/Sdk/{version}/dotnet-sdk-{effectiveVersion}-{Runtime}.{extension}{sasToken}", 157$"{feed.ItemSpec}/aspnetcore/Runtime/{version}/aspnetcore-runtime-{effectiveVersion}-{Runtime}.{extension}{sasToken}", 158_ => $"{feed.ItemSpec}/Runtime/{version}/dotnet-runtime-{effectiveVersion}-{Runtime}.{extension}{sasToken}" 187"sdk" => await GetMatchingProductVersionTxtContents($"{feed.ItemSpec}/Sdk/{version}", "sdk-productVersion.txt", sasToken), 188"aspnetcore-runtime" => await GetMatchingProductVersionTxtContents($"{feed.ItemSpec}/aspnetcore/Runtime/{version}", "aspnetcore-productVersion.txt", sasToken), 189_ => await GetMatchingProductVersionTxtContents($"{feed.ItemSpec}/Runtime/{version}", "runtime-productVersion.txt", sasToken) 329"sdk" => $"{feed.ItemSpec}/Sdk/{Channel}/latest.version", 330"aspnetcore-runtime" => $"{feed.ItemSpec}/aspnetcore/Runtime/{Channel}/latest.version", 331_ => $"{feed.ItemSpec}/Runtime/{Channel}/latest.version"

TaskItemExtensions.cs (1)

22log.LogError(FailureCategory.Build, $"Item '{item.ItemSpec}' missing required metadata '{key}'.");

XharnessTaskBase.cs (3)

190return (item.ItemSpec, appPathMetadata); 194return (fileSystem.GetFileNameWithoutExtension(item.ItemSpec), item.ItemSpec);

CreateXHarnessAndroidWorkItemsTests.cs (1)

225mockBundle.SetupGet(x => x.ItemSpec).Returns(itemSpec);

CreateXHarnessAppleWorkItemsTests.cs (1)

287mockBundle.SetupGet(x => x.ItemSpec).Returns(itemSpec);

GetCompatiblePackageTargetFrameworks.cs (1)

49TestProjects = testProjects.Where(tfm => tfm.ItemSpec != "").ToArray();

VerifyClosure.cs (1)

133var name = ignoredReference.ItemSpec;

VerifyTypes.cs (1)

131ignoredTypes.Add(ignoredType.ItemSpec);

src\CreateFrameworkListFile.cs (8)

64?.Select(item => new XAttribute(item.ItemSpec, item.GetMetadata("Value"))) 71item => item.ItemSpec, 84Filename = Path.GetFileName(item.ItemSpec), 86AssemblyName = FileUtilities.GetAssemblyName(item.ItemSpec), 87FileVersion = FileUtilities.GetFileVersion(item.ItemSpec), 91IsResourceFile = item.ItemSpec 98.GroupBy(f => f.Item.ItemSpec) 196Log.LogError($"No public key token found for assembly {f.Item.ItemSpec}");

src\GeneratePlatformManifestEntriesFromFileList.cs (1)

30Name = file.ItemSpec,

src\GeneratePlatformManifestEntriesFromTemplate.cs (7)

32var files = Files.ToLookup(file => Path.GetFileName(file.ItemSpec)).ToDictionary(l => l.Key, l=> l.First()); 35if (files.TryGetValue(entryTemplate.ItemSpec, out ITaskItem existingFile)) 41Name = entryTemplate.ItemSpec, 42AssemblyVersion = FileUtilities.GetAssemblyName(existingFile.ItemSpec)?.Version.ToString() ?? string.Empty, 43FileVersion = FileUtilities.GetFileVersion(existingFile.ItemSpec)?.ToString() ?? string.Empty 50var entryTemplateExtension = Path.GetExtension(entryTemplate.ItemSpec); 75Name = entryTemplate.ItemSpec,

src\GenerateSharedFrameworkDepsFile.cs (1)

61string filePath = file.ItemSpec;

src\Microsoft.DotNet.PackageTesting\VerifyClosure.cs (1)

133var name = ignoredReference.ItemSpec;

src\Microsoft.DotNet.PackageTesting\VerifyTypes.cs (1)

131ignoredTypes.Add(ignoredType.ItemSpec);

src\ValidateFileVersions.cs (2)

30var fileName = Path.GetFileName(file.ItemSpec); 79.Select(p => p.Value.File.ItemSpec)

SignCheckTask.cs (1)

114foreach (var checkFile in InputFiles.Select(s => s.ItemSpec).ToArray())

src\Configuration.cs (4)

135_wixPacks = _itemsToSign.Where(w => WixPackInfo.IsWixPack(w.ItemSpec))?.Select(s => new WixPackInfo(s.ItemSpec)).ToList(); 146string fullPath = itemToSign.ItemSpec; 470.Where(d => d.ItemSpec == signInfo.Certificate &&

src\SignToolTask.cs (6)

280ItemsToSkipStrongNameCheck?.Select(i => i.ItemSpec).ToArray(), 326if (!Path.IsPathRooted(itemToSign.ItemSpec)) 332var directoryParts = Path.GetFullPath(Path.GetDirectoryName(itemToSign.ItemSpec)).Split(separators); 374var extension = item.ItemSpec; 422var strongName = item.ItemSpec; 478var fileName = item.ItemSpec;

SignToolTests.cs (1)

2036{ "31bf3856ad364e35", new List<SignInfo>{ new SignInfo(dualCertificates.First().ItemSpec, null) } }

src\UsageReport\WriteUsageReports.cs (2)

173var content = File.ReadAllText(item.ItemSpec); 176Path = item.ItemSpec,

BaseDependenciesTask.cs (12)

92yield return new ProjectJsonUpdater(ProjectJsonFiles.Select(item => item.ItemSpec)); 176$"Unsupported updater '{step.ItemSpec}': UpdaterType '{type}'."); 213info.ItemSpec, 224info.ItemSpec, 233$"Unsupported DependencyInfo '{info.ItemSpec}': DependencyType '{type}'."); 298$"{step.ItemSpec} without {ReplacementSubstituteOldMetadataName}. " + 330$"On '{step.ItemSpec}', did not find 'ElementName', 'Regex', or 'MSBuildSdkName' metadata."); 387return BuildInfo.Get(item.ItemSpec, rawUrl); 401item.ItemSpec, 413item.ItemSpec, 428Name = item.ItemSpec, 445$"On '{item.ItemSpec}', did not find required '{name}' metadata.");

LocalUpdatePublishedVersions.cs (1)

68ShippedNuGetPackage.Select(i => i.ItemSpec),

SubmitPullRequest.cs (1)

109body += PullRequestCreator.NotificationString(NotifyGitHubUsers.Select(item => item.ItemSpec));

UpdatePublishedVersions.cs (1)

46ShippedNuGetPackage.Select(item => item.ItemSpec),

UpdateToRemoteDependencies.cs (1)

89$"{item.ItemSpec}{CurrentRefMetadataName}",

Tasks\EnsureAllResourcesTranslated.cs (1)

24string sourceDocumentPath = item.GetMetadataOrDefault(MetadataKey.SourceDocumentPath, item.ItemSpec);

Tasks\GatherXlf.cs (5)

34string sourceDocumentPath = source.GetMetadataOrDefault(MetadataKey.SourceDocumentPath, source.ItemSpec); 40xlf.SetMetadata(MetadataKey.XlfSource, source.ItemSpec); 58translatedFileName = Path.GetFileNameWithoutExtension(source.ItemSpec); 62string sourceDocumentPath = source.GetMetadataOrDefault(MetadataKey.SourceDocumentPath, source.ItemSpec); 63string extension = Path.GetExtension(source.ItemSpec);

Tasks\SortXlf.cs (1)

22string sourceDocumentPath = item.GetMetadataOrDefault(MetadataKey.SourceDocumentPath, item.ItemSpec);

Tasks\TransformTemplates.cs (4)

63string templateName = Path.GetFileNameWithoutExtension(template.ItemSpec); 73string cultureSpecificTemplateFile = Path.Combine(localizedTemplateDirectory, Path.GetFileName(template.ItemSpec)); 104Path.GetFileNameWithoutExtension(unstructuredResource.ItemSpec), 107Path.GetExtension(unstructuredResource.ItemSpec));

Tasks\TranslateSource.cs (2)

24XlfDocument xlfDocument = XlfTask.LoadXlfDocument(XlfFile.ItemSpec); 30Log.LogErrorInFile(XlfFile.ItemSpec, validationError.LineNumber, validationError.Message);

Tasks\UpdateXlf.cs (2)

31string sourcePath = item.ItemSpec; 32string sourceDocumentPath = item.GetMetadataOrDefault(MetadataKey.SourceDocumentPath, item.ItemSpec);

GetOpenApiReferenceMetadata.cs (1)

66Log.LogError(Resources.FormatInvalidEmptyMetadataValue("CodeGenerator", type, item.ItemSpec));

MetadataSerializer.cs (1)

72EscapeValue(item.ItemSpec, builder);

GetCurrentOpenApiReferenceTest.cs (1)

44Assert.Equal(expectedIdentity, output.ItemSpec);

GetOpenApiReferenceMetadataTest.cs (9)

53Assert.Equal(identity, output.ItemSpec); 111Assert.Equal(identity, output.ItemSpec); 169Assert.Equal(identity, output.ItemSpec); 227Assert.Equal(identity, output.ItemSpec); 377Assert.Equal(identity, output.ItemSpec); 440Assert.Equal(identity, output.ItemSpec); 540Assert.Equal(identity12, output.ItemSpec); 552Assert.Equal(identity12, output.ItemSpec); 564Assert.Equal(identity3, output.ItemSpec);

MetadataSerializerTest.cs (9)

126Assert.Equal(identity, item.ItemSpec); 152Assert.Equal(identity, item.ItemSpec); 167Assert.Equal(value, item.ItemSpec); 250input.SetupGet(i => i.ItemSpec).Returns(identity).Verifiable(); 263input.VerifyGet(i => i.ItemSpec, Times.Once); 277input.SetupGet(i => i.ItemSpec).Returns(identity).Verifiable(); 287input.VerifyGet(i => i.ItemSpec, Times.Once); 300input.SetupGet(i => i.ItemSpec).Returns(value).Verifiable(); 310input.VerifyGet(i => i.ItemSpec, Times.Once);

UpdateRuntimeIdentifierGraph.cs (2)

38if (runtimes.ContainsKey(rid.ItemSpec)) 44runtimes.Add(rid.ItemSpec, new JObject(new JProperty("#import", new JArray(importedRids))));

TaskParameter.cs (2)

317escapedItemSpec = EscapingUtilities.Escape(copyFrom.ItemSpec); 421escapedItemSpec = EscapingUtilities.Escape(wrappedItem.ItemSpec);

TerminalLogger\TerminalLogger.cs (1)

762project.OutputPath = output.ItemSpec.AsMemory();

TaskParameter.cs (2)

317escapedItemSpec = EscapingUtilities.Escape(copyFrom.ItemSpec); 421escapedItemSpec = EscapingUtilities.Escape(wrappedItem.ItemSpec);

ShowItems.cs (1)

42Log.LogMessage(item.ItemSpec);

Microsoft\Build\Tasks\Windows\FileClassifier.cs (1)

307ItemSpec = inputItem.ItemSpec,

Microsoft\Build\Tasks\Windows\GenerateTemporaryTargetAssembly.cs (3)

197TemporaryAssemblyForLocalTypeReference = targetOutputs[CompileTargetName][0].ItemSpec; 312TemporaryAssemblyForLocalTypeReference = targetOutputs[CompileTargetName][0].ItemSpec; 742attrInclude.Value = pItem.ItemSpec;

Microsoft\Build\Tasks\Windows\MarkupCompilePass1.cs (7)

409return SplashScreen[0].ItemSpec.ToLowerInvariant(); 954_applicationFile = TaskHelper.CreateFullFilePath(ApplicationMarkup[0].ItemSpec, SourceDir); 1036bValidItem = IsValidInputFile(inputItem.ItemSpec); 1138refpath = References[i].ItemSpec; 1478GetGeneratedFiles(inputXamlItemList[i].ItemSpec, out genLangFilePath, out bamlFile); 1546string xamlInputFullPath = TaskHelper.CreateFullFilePath(inputXamlItem.ItemSpec, SourceDir); 1680string xamlRelativeFilePath = GetResolvedFilePath(xamlItem.ItemSpec, ref tempDir);

Microsoft\Build\Tasks\Windows\MarkupCompilePass2.cs (1)

615refpath = References[i].ItemSpec;

Microsoft\Build\Tasks\Windows\MergeLocalizationDirectives.cs (1)

82using (StreamReader locStreamReader = new StreamReader(item.ItemSpec))

Microsoft\Build\Tasks\Windows\ResourcesGenerator.cs (4)

182string resourcesFile = OutputResourcesFile[0].ItemSpec; 191string resFileName = resourceFile.ItemSpec; 308strFileName = inputFile.ItemSpec; 331resFile.ItemSpec,

Microsoft\Build\Tasks\Windows\UidManager.cs (14)

Microsoft\Build\Tasks\Windows\UpdateManifestForBrowserApplication.cs (1)

84string appManifestFile = ApplicationManifest[0].ItemSpec;

MS\Internal\Tasks\CompilerState.cs (2)

218iHashCode += GetNonRandomizedHashCode(fileItemList[i].ItemSpec); 244sb.Append(fileItemList[i].ItemSpec);

MS\Internal\Tasks\IncrementalCompileAnalyzer.cs (4)

212string fileName = taskItem.ItemSpec; 468Path.GetFullPath(taskItem.ItemSpec), 499string fullPath = Path.GetFullPath(_mcPass1.ContentFiles[i].ItemSpec); 564if (IsFileChanged(fileList[i].ItemSpec))

GenerateFilteredReferenceAssembliesTask.cs (4)

82ExecuteImpl(ApiSets.Select(item => (item.ItemSpec, (IReadOnlyList<string>)File.ReadAllLines(item.ItemSpec)))); 87var referencesByName = References.ToDictionary(r => Path.GetFileNameWithoutExtension(r.ItemSpec), r => r.ItemSpec);