ItemSpec

TaskItemData.cs (1)

21public string ItemSpec { get; set; }

TestUtilities\SimpleTaskItem.cs (1)

14public string ItemSpec { get; set; }

src\Compilers\Core\MSBuildTask\ManagedCompiler.cs (4)

859OutputAssembly.ItemSpec += ".dll"; 863OutputAssembly.ItemSpec += ".netmodule"; 867OutputAssembly.ItemSpec += ".exe"; 1089item.ItemSpec = Utilities.GetFullPathNoThrow(item.ItemSpec);

src\Compilers\Core\MSBuildTask\ManagedCompiler.cs (4)

859OutputAssembly.ItemSpec += ".dll"; 863OutputAssembly.ItemSpec += ".netmodule"; 867OutputAssembly.ItemSpec += ".exe"; 1089item.ItemSpec = Utilities.GetFullPathNoThrow(item.ItemSpec);

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)

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

ComputeManagedAssemblies.cs (1)

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

CreateRuntimeRootDescriptorFile.cs (7)

102var namespaceFilePath = NamespaceFilePath.ItemSpec; 109var mscorlibFilePath = MscorlibFilePath.ItemSpec; 116var cortypeFilePath = CortypeFilePath.ItemSpec; 123var rexcepFilePath = RexcepFilePath.ItemSpec; 132var iLLinkTrimXmlFilePath = ILLinkTrimXmlFilePath.ItemSpec; 147OutputXml(iLLinkTrimXmlFilePath, RuntimeRootDescriptorFilePath.ItemSpec); 556defineConstants.Add(item.ItemSpec.Trim());

LinkTask.cs (9)

316args.Append("-x ").AppendLine(Quote(rootFile.ItemSpec)); 321args.Append("-a ").Append(Quote(assemblyItem.ItemSpec)); 363var assemblyPath = assembly.ItemSpec; 425var assemblyPath = assembly.ItemSpec; 443args.Append("-out ").AppendLine(Quote(OutputDirectory.ItemSpec)); 485var key = customData.ItemSpec; 497var feature = featureSetting.ItemSpec; 508args.Append("--keep-metadata ").AppendLine(Quote(metadata.ItemSpec)); 522var 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.");

IItemData.cs (1)

58EvaluatedInclude = ti.ItemSpec;

TaskItemData.cs (1)

36ItemSpec = original.ItemSpec;

TaskParameterEventArgs.cs (1)

214writer.Write(taskItem.ItemSpec);

src\Compilers\Core\MSBuildTask\CommandLineBuilderExtension.cs (1)

248AppendSwitchIfNotNull(switchName, parameter.ItemSpec);

src\Compilers\Core\MSBuildTask\Csc.cs (8)

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); 571CheckHostObjectSupport(param = nameof(OutputAssembly), cscHostObject.SetOutputAssembly(OutputAssembly?.ItemSpec));

src\Compilers\Core\MSBuildTask\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;

src\Compilers\Core\MSBuildTask\InteractiveCompiler.cs (2)

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

src\Compilers\Core\MSBuildTask\ManagedCompiler.cs (8)

851OutputAssembly = new TaskItem(Path.GetFileNameWithoutExtension(Sources[0].ItemSpec)); 966commandLine.AppendSwitchIfNotNull("/analyzer:", analyzer.ItemSpec); 979commandLine.AppendSwitchIfNotNull("/additionalfile:", additionalFile.ItemSpec); 998commandLine.AppendSwitchIfNotNull("/embed:", embeddedFile.ItemSpec); 1012commandLine.AppendSwitchIfNotNull("/analyzerconfig:", analyzerConfigFile.ItemSpec); 1089item.ItemSpec = Utilities.GetFullPathNoThrow(item.ItemSpec); 1157if (!File.Exists(reference.ItemSpec)) 1160Log.LogErrorWithCodeFromResources("General_ReferenceDoesNotExist", reference.ItemSpec);

src\Compilers\Core\MSBuildTask\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);

src\Compilers\Core\MSBuildTask\Utilities.cs (1)

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

src\Compilers\Core\MSBuildTask\Vbc.cs (3)

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

src\Compilers\Core\MSBuildTask\CommandLineBuilderExtension.cs (1)

248AppendSwitchIfNotNull(switchName, parameter.ItemSpec);

src\Compilers\Core\MSBuildTask\Csc.cs (8)

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); 571CheckHostObjectSupport(param = nameof(OutputAssembly), cscHostObject.SetOutputAssembly(OutputAssembly?.ItemSpec));

src\Compilers\Core\MSBuildTask\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;

src\Compilers\Core\MSBuildTask\InteractiveCompiler.cs (2)

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

src\Compilers\Core\MSBuildTask\ManagedCompiler.cs (8)

851OutputAssembly = new TaskItem(Path.GetFileNameWithoutExtension(Sources[0].ItemSpec)); 966commandLine.AppendSwitchIfNotNull("/analyzer:", analyzer.ItemSpec); 979commandLine.AppendSwitchIfNotNull("/additionalfile:", additionalFile.ItemSpec); 998commandLine.AppendSwitchIfNotNull("/embed:", embeddedFile.ItemSpec); 1012commandLine.AppendSwitchIfNotNull("/analyzerconfig:", analyzerConfigFile.ItemSpec); 1089item.ItemSpec = Utilities.GetFullPathNoThrow(item.ItemSpec); 1157if (!File.Exists(reference.ItemSpec)) 1160Log.LogErrorWithCodeFromResources("General_ReferenceDoesNotExist", reference.ItemSpec);

src\Compilers\Core\MSBuildTask\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);

src\Compilers\Core\MSBuildTask\Utilities.cs (1)

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

src\Compilers\Core\MSBuildTask\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));

MSBuild\ProjectFile\CommandLineArgumentReader.cs (2)

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

MSBuild\ProjectFile\ProjectFile.cs (6)

226.Select(item => item.ItemSpec) 242=> !Path.GetFileName(item.ItemSpec).StartsWith("TemporaryGeneratedFile_", StringComparison.Ordinal); 275var filePath = documentItem.ItemSpec; 296=> GetAbsolutePathRelativeToProject(documentItem.ItemSpec); 319return !_documents.ContainsKey(GetAbsolutePathRelativeToProject(documentItem.ItemSpec)); 332var filePath = documentItem.ItemSpec;

src\DownloadFile.cs (2)

81var uri = uriConfig.ItemSpec; 102Log.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)}'"))}"));

BlobArtifactModelFactory.cs (2)

38_log.LogError($"Missing 'RelativeBlobPath' property on blob {item.ItemSpec}"); 46OriginalFile = item.ItemSpec

BuildModelFactory.cs (1)

95_log.LogError($"Missing 'Kind' property on artifact {item.ItemSpec}. Possible values are 'Blob', 'PDB', 'Package'.");

PackageArtifactModelFactory.cs (3)

29_log.LogMessage($"Creating NupkgInfo based on '{item.ItemSpec}'"); 31NupkgInfo info = _nupkgInfoFactory.CreateNupkgInfo(item.ItemSpec); 39OriginalFile = item.ItemSpec

PdbArtifactModelFactory.cs (2)

36_log.LogError($"Missing 'RelativePdbPath' property on pdb {item.ItemSpec}"); 44OriginalFile = 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\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)

75FeedKeys = feedKeys.ToImmutableDictionary(i => i.ItemSpec, i => i.GetMetadata("Key")); 76FeedSasUris = feedSasUris.ToImmutableDictionary(i => i.ItemSpec, i => ConvertFromBase64(i.GetMetadata("Base64Uri"))); 77FeedOverrides = feedOverrides.ToImmutableDictionary(i => i.ItemSpec, i => i.GetMetadata("Replacement"));

src\model\SetupTargetFeedConfigV4.cs (3)

74FeedKeys = feedKeys.ToImmutableDictionary(i => i.ItemSpec, i => i.GetMetadata("Key")); 75FeedSasUris = feedSasUris.ToImmutableDictionary(i => i.ItemSpec, i => ConvertFromBase64(i.GetMetadata("Base64Uri"))); 76FeedOverrides = feedOverrides.ToImmutableDictionary(i => i.ItemSpec, i => i.GetMetadata("Replacement"));

src\PublishArtifactsInManifest.cs (1)

248.Select(manifestParam => WhichPublishingTask(manifestParam.ItemSpec))

src\PushToBuildStorage.cs (2)

504if (Enum.TryParse(item.ItemSpec, true, out ArtifactVisibility parsedVisibility)) 510throw new ArgumentException($"Invalid visibility: {item.ItemSpec}");

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)

74commandString.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).Replace('\\', '/');

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\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)

64if (!suppressMetaPackages.TryGetValue(metapackage.ItemSpec, out var value)) 67suppressMetaPackages.Add(metapackage.ItemSpec, value); 99var 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."); 312Log.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)

104Id = item.ItemSpec;

SplitDependenciesBySupport.cs (1)

68Name = originalItem.ItemSpec;

SplitReferences.cs (4)

66string referenceName = reference.ItemSpec; 103if (collection.TryGetValue(item.ItemSpec, out existingItem)) 110collection[item.ItemSpec] = item; 115collection[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)

105AddSuppression(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)

src\SignCheckTask.cs (1)

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

src\SignToolTask.cs (9)

243var filesToSkip3rdPartyCheck = ItemsToSkip3rdPartyCheck?.Select(i => i.ItemSpec).ToHashSet(StringComparer.OrdinalIgnoreCase); 250var itemsToSign = ItemsToSign.Select(i => new ItemToSign(i.ItemSpec, i.GetMetadata(SignToolConstants.CollisionPriorityId))).OrderBy(i => i.CollisionPriorityId).ToList(); 285ItemsToSkipStrongNameCheck?.Select(i => i.ItemSpec).ToArray(), 324var certificateName = certificateSignInfo.ItemSpec; 376if (!Path.IsPathRooted(itemToSign.ItemSpec)) 382var directoryParts = Path.GetFullPath(Path.GetDirectoryName(itemToSign.ItemSpec)).Split(separators); 429var extension = item.ItemSpec; 476var strongName = item.ItemSpec; 532var fileName = item.ItemSpec;

src\UsageReport\WriteUsageReports.cs (2)

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

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)

58Assert.Equal(identity, output.ItemSpec); 118Assert.Equal(identity, output.ItemSpec); 178Assert.Equal(identity, output.ItemSpec); 238Assert.Equal(identity, output.ItemSpec); 391Assert.Equal(identity, output.ItemSpec); 455Assert.Equal(identity, output.ItemSpec); 556Assert.Equal(identity12, output.ItemSpec); 570Assert.Equal(identity12, output.ItemSpec); 583Assert.Equal(identity3, output.ItemSpec);

MetadataSerializerTest.cs (9)

126Assert.Equal(identity, item.ItemSpec); 152Assert.Equal(identity, item.ItemSpec); 167Assert.Equal(value, item.ItemSpec); 253input.SetupGet(i => i.ItemSpec).Returns(identity).Verifiable(); 266input.VerifyGet(i => i.ItemSpec, Times.Once); 280input.SetupGet(i => i.ItemSpec).Returns(identity).Verifiable(); 290input.VerifyGet(i => i.ItemSpec, Times.Once); 303input.SetupGet(i => i.ItemSpec).Returns(value).Verifiable(); 313input.VerifyGet(i => i.ItemSpec, Times.Once);

AsyncTask.cs (1)

95 LogDebugMessage(" {0}", item.ItemSpec);

CreatePartialInfoPlistTask.cs (1)

47 var fontFile = new FileInfo(font.ItemSpec);

DetectInvalidResourceOutputFilenamesTask.cs (1)

58 builder.Append($"{pair.Value} ({pair.Key.ItemSpec})");

GeneratePackageAppxManifest.cs (1)

53 var appx = XDocument.Load(AppxManifest.ItemSpec);

GetMauiAssetPath.cs (1)

48 ? Normalize(item.ItemSpec)

ResizeImageInfo.cs (1)

79 info.ItemSpec = image.ItemSpec;

UpdateRuntimeIdentifierGraph.cs (2)

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

ShowItems.cs (1)

42Log.LogMessage(item.ItemSpec);

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

294ItemSpec = inputItem.ItemSpec,

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

187TemporaryAssemblyForLocalTypeReference = targetOutputs[CompileTargetName][0].ItemSpec; 302TemporaryAssemblyForLocalTypeReference = targetOutputs[CompileTargetName][0].ItemSpec; 726attrInclude.Value = pItem.ItemSpec;

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

393return SplashScreen[0].ItemSpec.ToLowerInvariant(); 938_applicationFile = TaskHelper.CreateFullFilePath(ApplicationMarkup[0].ItemSpec, SourceDir); 1020bValidItem = IsValidInputFile(inputItem.ItemSpec); 1122refpath = References[i].ItemSpec; 1462GetGeneratedFiles(inputXamlItemList[i].ItemSpec, out genLangFilePath, out bamlFile); 1532string xamlInputFullPath = TaskHelper.CreateFullFilePath(inputXamlItem.ItemSpec, SourceDir); 1668string xamlRelativeFilePath = GetResolvedFilePath(xamlItem.ItemSpec, ref tempDir);

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

602refpath = References[i].ItemSpec;

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

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

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

171string resourcesFile = OutputResourcesFile[0].ItemSpec; 180string resFileName = resourceFile.ItemSpec; 294strFileName = inputFile.ItemSpec; 317resFile.ItemSpec,

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

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

72string appManifestFile = ApplicationManifest[0].ItemSpec;

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

214iHashCode += GetNonRandomizedHashCode(fileItemList[i].ItemSpec); 240sb.Append(fileItemList[i].ItemSpec);

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

207string fileName = taskItem.ItemSpec; 463Path.GetFullPath(taskItem.ItemSpec), 494string fullPath = Path.GetFullPath(_mcPass1.ContentFiles[i].ItemSpec); 559if (IsFileChanged(fileList[i].ItemSpec))

GenerateFilteredReferenceAssembliesTask.cs (4)

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