ITaskItem

ITaskItem2.cs (1)

17public interface ITaskItem2 : ITaskItem

TaskItemData.cs (1)

17internal class TaskItemData : ITaskItem, IMetadataContainer

TestUtilities\SimpleTaskItem.cs (1)

12internal sealed class SimpleTaskItem : ITaskItem

PrepareForReadyToRunCompilation.cs (31)

21public ITaskItem MainAssembly { get; set; } 22public ITaskItem[] Assemblies { get; set; } 35public ITaskItem CrossgenTool { get; set; } 36public ITaskItem Crossgen2Tool { get; set; } 41public ITaskItem[] ReadyToRunCompileList => _compileList.ToArray(); 43public ITaskItem[] ReadyToRunSymbolsCompileList => _symbolsCompileList.ToArray(); 48public ITaskItem[] ReadyToRunFilesToPublish => _r2rFiles.ToArray(); 51public ITaskItem[] ReadyToRunAssembliesToReference => _r2rReferences.ToArray(); 54public ITaskItem[] ReadyToRunCompositeBuildReferences => _r2rCompositeReferences.ToArray(); 57public ITaskItem[] ReadyToRunCompositeBuildInput => _r2rCompositeInput.ToArray(); 62private List<ITaskItem> _compileList = new List<ITaskItem>(); 63private List<ITaskItem> _symbolsCompileList = new List<ITaskItem>(); 64private List<ITaskItem> _r2rFiles = new List<ITaskItem>(); 65private List<ITaskItem> _r2rReferences = new List<ITaskItem>(); 66private List<ITaskItem> _r2rCompositeReferences = new List<ITaskItem>(); 67private List<ITaskItem> _r2rCompositeInput = new List<ITaskItem>(); 97ITaskItem[] inputFiles, 98List<ITaskItem> imageCompilationList, 99List<ITaskItem> symbolsCompilationList, 100List<ITaskItem> r2rFilesPublishList, 101List<ITaskItem> r2rReferenceList, 102List<ITaskItem> r2rCompositeReferenceList, 103List<ITaskItem> r2rCompositeInputList, 114foreach (var file in inputFiles) 355private static Eligibility GetInputFileEligibility(ITaskItem file, bool compositeCompile, HashSet<string> exclusionSet, HashSet<string> r2rCompositeExclusionSet)

ResolveReadyToRunCompilers.cs (12)

23public ITaskItem[] RuntimePacks { get; set; } 24public ITaskItem[] Crossgen2Packs { get; set; } 26public ITaskItem[] TargetingPacks { get; set; } 33public ITaskItem CrossgenTool { get; set; } 35public ITaskItem Crossgen2Tool { get; set; } 45private ITaskItem _runtimePack; 46private ITaskItem _crossgen2Pack; 64ITaskItem targetingPack = GetNETCoreAppTargetingPack(); 188private ITaskItem GetNETCoreAppRuntimePack() 193private ITaskItem GetNETCoreAppTargetingPack() 198private static ITaskItem GetNETCoreAppPack(ITaskItem[] packs, string metadataKey)

RunReadyToRunCompiler.cs (10)

16public ITaskItem CrossgenTool { get; set; } 17public ITaskItem Crossgen2Tool { get; set; } 20public ITaskItem CompilationEntry { get; set; } 22public ITaskItem[] ImplementationAssemblyReferences { get; set; } 23public ITaskItem[] ReadyToRunCompositeBuildReferences { get; set; } 24public ITaskItem[] ReadyToRunCompositeBuildInput { get; set; } 28public ITaskItem[] Crossgen2PgoFiles { get; set; } 229foreach (var reference in (_createCompositeImage ? ReadyToRunCompositeBuildReferences : ImplementationAssemblyReferences)) 341foreach (var mibc in Crossgen2PgoFiles) 369foreach (var reference in ReadyToRunCompositeBuildInput)

ShimFilesSimulatingLogicInSdkRepo\SimpleItemUtilities.cs (3)

12public static bool? GetBooleanMetadata(this ITaskItem item, string metadataName) 26public static bool HasMetadataValue(this ITaskItem item, string name) 33public static bool HasMetadataValue(this ITaskItem item, string name, string expectedValue)

CombineLinkerXmlFiles.cs (2)

20public ITaskItem[] LinkerXmlFiles { get; set; } 31foreach (var linkerXmlFile in LinkerXmlFiles)

ComputeManagedAssemblies.cs (2)

16public ITaskItem[] Assemblies { get; set; } 24public ITaskItem[] ManagedAssemblies { get; set; }

CreateRuntimeRootDescriptorFile.cs (8)

20public ITaskItem NamespaceFilePath { get; set; } 26public ITaskItem MscorlibFilePath { get; set; } 32public ITaskItem CortypeFilePath { get; set; } 38public ITaskItem RexcepFilePath { get; set; } 44public ITaskItem ILLinkTrimXmlFilePath { get; set; } 46public ITaskItem[] DefineConstants { get; set; } 52public ITaskItem RuntimeRootDescriptorFilePath { get; set; } 555foreach (var item in DefineConstants)

LinkTask.cs (17)

34public ITaskItem[] AssemblyPaths { get; set; } 41public ITaskItem[] ReferenceAssemblyPaths { get; set; } 50public ITaskItem[] RootAssemblyNames { get; set; } 57public ITaskItem OutputDirectory { get; set; } 103public ITaskItem[] RootDescriptorFiles { get; set; } 146public ITaskItem[] FeatureSettings { get; set; } 169public ITaskItem[] CustomData { get; set; } 228public ITaskItem[] CustomSteps { get; set; } 233public ITaskItem[] KeepMetadata { get; set; } 315foreach (var rootFile in RootDescriptorFiles) 319foreach (var assemblyItem in RootAssemblyNames) 361foreach (var assembly in AssemblyPaths) 423foreach (var assembly in ReferenceAssemblyPaths) 483foreach (var customData in CustomData) 495foreach (var featureSetting in FeatureSettings) 507foreach (var metadata in KeepMetadata) 519foreach (var customStep in CustomSteps)

GenerateFileVersionProps.cs (4)

20public ITaskItem[] Files { get; set; } 45foreach(var file in Files) 163FileVersionData GetFileVersionData(ITaskItem file) 204public ITaskItem File { get; set; }

RegenerateDownloadTable.cs (5)

37public ITaskItem[] Branches { get; set; } 45public ITaskItem[] Platforms { get; set; } 115private string CreateRow(ITaskItem platform, string[] links) 125private string CreateCell(ITaskItem platform, ITaskItem branch, string[] links)

StaticFileRegeneration\RegenerateThirdPartyNotices.cs (1)

37public ITaskItem[] TpnRepos { get; set; }

GenerateMvcTestManifestTask.cs (2)

29public ITaskItem[] Projects { get; set; } 36foreach (var project in Projects)

BuildEngineResult.cs (4)

27private List<IDictionary<string, ITaskItem[]>> targetOutputsPerProject; 32public BuildEngineResult(bool result, List<IDictionary<string, ITaskItem[]>> targetOutputsPerProject) 38this.targetOutputsPerProject = new List<IDictionary<string, ITaskItem[]>>(); 56public IList<IDictionary<string, ITaskItem[]>> TargetOutputsPerProject

IItemData.cs (2)

56else if (value is ITaskItem ti) 92else if (Value is ITaskItem ti)

IMetadataContainer.cs (1)

45/// <see cref="ITaskItem.SetMetadata"/> on all metadata, but takes

ITaskItem.cs (1)

83void CopyMetadataTo(ITaskItem destinationItem);

ITaskItemExtensions.cs (1)

22public static IEnumerable<KeyValuePair<string, string>> EnumerateMetadata(this ITaskItem taskItem)

TaskItemData.cs (4)

13/// Lightweight specialized implementation of <see cref="ITaskItem"/> only used for deserializing items. 33/// <param name="original">An <see cref="ITaskItem"/> to clone</param> 34public TaskItemData(ITaskItem original) 71public void CopyMetadataTo(ITaskItem destinationItem)

TaskParameterEventArgs.cs (2)

212if (item is ITaskItem taskItem) 234private void WriteMetadata(BinaryWriter writer, ITaskItem taskItem)

TaskPropertyInfo.cs (1)

32IsAssignableToITask = typeof(ITaskItem).IsAssignableFrom(elementType);

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

178ITaskItem[]? parameters, 235ITaskItem[]? parameters, 246foreach (ITaskItem parameter in parameters)

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

279foreach (ITaskItem response in ResponseFiles) 332ITaskItem[]? references, 345foreach (ITaskItem reference in references)

src\Compilers\Core\MSBuildTask\GenerateMSBuildEditorConfig.cs (10)

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 50public ITaskItem[] MetadataItems { get; set; } 53public ITaskItem[] PropertyItems { get; set; } 55public ITaskItem FileName { get; set; } 60MetadataItems = Array.Empty<ITaskItem>(); 61PropertyItems = Array.Empty<ITaskItem>(); 73foreach (var prop in PropertyItems) 92foreach (var item in group)

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

16bool SetAnalyzerConfigFiles(ITaskItem[]? analyzerConfigFiles); 17bool SetPotentialAnalyzerConfigFiles(ITaskItem[]? potentialAnalyzerConfigfiles);

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

54public ITaskItem[]? CommandLineArgs 63return (ITaskItem[]?)_store[nameof(CommandLineArgs)]; 80public ITaskItem[]? Imports 89return (ITaskItem[]?)_store[nameof(Imports)]; 106public ITaskItem[]? References 115return (ITaskItem[]?)_store[nameof(References)]; 119public ITaskItem[]? ResponseFiles 128return (ITaskItem[]?)_store[nameof(ResponseFiles)]; 145public ITaskItem[]? ScriptResponseFiles 154return (ITaskItem[]?)_store[nameof(ScriptResponseFiles)]; 171public ITaskItem? Source 180return (ITaskItem?)_store[nameof(Source)]; 210foreach (var response in ResponseFiles) 228foreach (var scriptResponse in ScriptResponseFiles)

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

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

163/// Generates the <see cref="ITaskItem"/> entries for the CommandLineArgs output ItemGroup 169protected internal ITaskItem[] GenerateCommandLineArgsTaskItems(string responseFileCommands) => 172protected static ITaskItem[] GenerateCommandLineArgsTaskItems(List<string> commandLineArgs) 174var items = new ITaskItem[commandLineArgs.Count];

src\Compilers\Core\MSBuildTask\MapSourceRoots.cs (11)

44public ITaskItem[] SourceRoots { get; set; } 56public ITaskItem[]? MappedSourceRoots { get; private set; } 91var mappedSourceRoots = new List<ITaskItem>(); 92var rootByItemSpec = new Dictionary<string, ITaskItem>(); 93foreach (var sourceRoot in SourceRoots) 104if (rootByItemSpec.TryGetValue(sourceRoot.ItemSpec, out var existingRoot)) 126foreach (var root in mappedSourceRoots) 165foreach (var root in mappedSourceRoots) 188foreach (var root in mappedSourceRoots) 205private void ReportConflictingWellKnownMetadata(ITaskItem left, ITaskItem right)

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

36internal static bool TryConvertItemMetadataToBool(ITaskItem item, string itemMetadataName)

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

86public ITaskItem[]? Imports 89get { return (ITaskItem[]?)_store[nameof(Imports)]; } 554foreach (ITaskItem response in this.ResponseFiles) 568var references = new List<ITaskItem>(this.References.Length); 569var links = new List<ITaskItem>(this.References.Length); 571foreach (ITaskItem reference in this.References)

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

178ITaskItem[]? parameters, 235ITaskItem[]? parameters, 246foreach (ITaskItem parameter in parameters)

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

279foreach (ITaskItem response in ResponseFiles) 332ITaskItem[]? references, 345foreach (ITaskItem reference in references)

src\Compilers\Core\MSBuildTask\GenerateMSBuildEditorConfig.cs (10)

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 50public ITaskItem[] MetadataItems { get; set; } 53public ITaskItem[] PropertyItems { get; set; } 55public ITaskItem FileName { get; set; } 60MetadataItems = Array.Empty<ITaskItem>(); 61PropertyItems = Array.Empty<ITaskItem>(); 73foreach (var prop in PropertyItems) 92foreach (var item in group)

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

16bool SetAnalyzerConfigFiles(ITaskItem[]? analyzerConfigFiles); 17bool SetPotentialAnalyzerConfigFiles(ITaskItem[]? potentialAnalyzerConfigfiles);

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

54public ITaskItem[]? CommandLineArgs 63return (ITaskItem[]?)_store[nameof(CommandLineArgs)]; 80public ITaskItem[]? Imports 89return (ITaskItem[]?)_store[nameof(Imports)]; 106public ITaskItem[]? References 115return (ITaskItem[]?)_store[nameof(References)]; 119public ITaskItem[]? ResponseFiles 128return (ITaskItem[]?)_store[nameof(ResponseFiles)]; 145public ITaskItem[]? ScriptResponseFiles 154return (ITaskItem[]?)_store[nameof(ScriptResponseFiles)]; 171public ITaskItem? Source 180return (ITaskItem?)_store[nameof(Source)]; 210foreach (var response in ResponseFiles) 228foreach (var scriptResponse in ScriptResponseFiles)

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

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

163/// Generates the <see cref="ITaskItem"/> entries for the CommandLineArgs output ItemGroup 169protected internal ITaskItem[] GenerateCommandLineArgsTaskItems(string responseFileCommands) => 172protected static ITaskItem[] GenerateCommandLineArgsTaskItems(List<string> commandLineArgs) 174var items = new ITaskItem[commandLineArgs.Count];

src\Compilers\Core\MSBuildTask\MapSourceRoots.cs (11)

44public ITaskItem[] SourceRoots { get; set; } 56public ITaskItem[]? MappedSourceRoots { get; private set; } 91var mappedSourceRoots = new List<ITaskItem>(); 92var rootByItemSpec = new Dictionary<string, ITaskItem>(); 93foreach (var sourceRoot in SourceRoots) 104if (rootByItemSpec.TryGetValue(sourceRoot.ItemSpec, out var existingRoot)) 126foreach (var root in mappedSourceRoots) 165foreach (var root in mappedSourceRoots) 188foreach (var root in mappedSourceRoots) 205private void ReportConflictingWellKnownMetadata(ITaskItem left, ITaskItem right)

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

36internal static bool TryConvertItemMetadataToBool(ITaskItem item, string itemMetadataName)

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

86public ITaskItem[]? Imports 89get { return (ITaskItem[]?)_store[nameof(Imports)]; } 554foreach (ITaskItem response in this.ResponseFiles) 568var references = new List<ITaskItem>(this.References.Length); 569var links = new List<ITaskItem>(this.References.Length); 571foreach (ITaskItem reference in this.References)

src\Compilers\Core\MSBuildTaskTests\TestUtilities\MSBuildUtil.cs (5)

17public static ITaskItem[] CreateTaskItems(params string[] fileNames) 22public static ITaskItem CreateTaskItem(string fileName) 24var taskItem = new Mock<ITaskItem>(MockBehavior.Strict); 29public static ITaskItem CreateTaskItem(string fileName, Dictionary<string, string> metadata) 31var taskItem = new Mock<ITaskItem>(MockBehavior.Strict);

GenerateMSBuildEditorConfigTests.cs (24)

MapSourceRootTests.cs (1)

18private string InspectSourceRoot(ITaskItem sourceRoot)

TestUtilities\MSBuildUtil.cs (5)

17public static ITaskItem[] CreateTaskItems(params string[] fileNames) 22public static ITaskItem CreateTaskItem(string fileName) 24var taskItem = new Mock<ITaskItem>(MockBehavior.Strict); 29public static ITaskItem CreateTaskItem(string fileName, Dictionary<string, string> metadata) 31var taskItem = new Mock<ITaskItem>(MockBehavior.Strict);

TestUtilities\SimpleTaskItem.cs (1)

30public void CopyMetadataTo(ITaskItem destinationItem) => throw new NotImplementedException();

MSBuild\CSharp\CSharpProjectFile.cs (1)

18protected override IEnumerable<MSB.Framework.ITaskItem> GetCompilerCommandLineArgs(MSB.Execution.ProjectInstance executedProject)

MSBuild\ProjectFile\CommandLineArgumentReader.cs (5)

115protected string GetDocumentFilePath(MSB.Framework.ITaskItem documentItem) 132foreach (var additionalFile in additionalFiles) 144foreach (var analyzer in analyzers) 219static string ReadImportItem(MSB.Framework.ITaskItem item) 244foreach (var reference in references)

MSBuild\ProjectFile\Extensions.cs (8)

MSBuild\ProjectFile\ProjectFile.cs (9)

MSBuild\VisualBasic\VisualBasicProjectFile.cs (1)

18protected override IEnumerable<MSB.Framework.ITaskItem> GetCompilerCommandLineArgs(MSB.Execution.ProjectInstance executedProject)

src\DownloadFile.cs (2)

23public ITaskItem[] Uris { get; set; } 79foreach (var uriConfig in Uris)

src\GenerateChecksums.cs (2)

19public ITaskItem[] Items { get; set; } 23foreach (ITaskItem item in Items)

src\GenerateSourcePackageSourceLinkTargetsFile.cs (2)

24public ITaskItem[] SourceRoots { get; set; } 48foreach (var sourceRoot in SourceRoots)

src\GetAssemblyFullName.cs (3)

13public ITaskItem[] Items { get; set; } 21public ITaskItem[] ItemsWithFullName { get; set; } 27foreach (var item in Items)

src\GroupItemsBy.cs (6)

39public ITaskItem[] Items { get; set; } 53public ITaskItem[] GroupedItems { get; set; } 57ITaskItem mergeItems(IEnumerable<ITaskItem> items) 59var result = items.First(); 61foreach (var item in items.Skip(1))

src\SaveItems.cs (2)

23public ITaskItem[] Items { get; set; } 33foreach (var item in Items)

CreateUpdatePR.cs (2)

39public ITaskItem[] UpdatedFiles { get; set; } = Array.Empty<ITaskItem>();

BlobArtifactModelFactory.cs (2)

11BlobArtifactModel CreateBlobArtifactModel(ITaskItem item, string repoOrigin); 33public BlobArtifactModel CreateBlobArtifactModel(ITaskItem item, string repoOrigin)

BuildModelFactory.cs (3)

20ITaskItem[] artifacts, 68ITaskItem[] artifacts, 91foreach (var item in itemsToPushNoExcludes)

PackageArtifactModelFactory.cs (2)

12PackageArtifactModel CreatePackageArtifactModel(ITaskItem item, string repoOrigin); 27public PackageArtifactModel CreatePackageArtifactModel(ITaskItem item, string repoOrigin)

PdbArtifactModelFactory.cs (2)

11PdbArtifactModel CreatePdbArtifactModel(ITaskItem item, string repoOrigin); 31public PdbArtifactModel CreatePdbArtifactModel(ITaskItem item, string repoOrigin)

BuildModelFactoryTests.cs (9)

109var artifacts = new ITaskItem[] 230var artifacts = new ITaskItem[] 280var artifacts = new ITaskItem[] 316var artifacts = new ITaskItem[] 352var artifacts = new ITaskItem[] 389var artifacts = new ITaskItem[] 443var artifacts = new ITaskItem[] 590var artifacts = new ITaskItem[] 692var artifacts = new ITaskItem[]

src\BlobFeedAction.cs (2)

59public async Task PublishToFlatContainerAsync(IEnumerable<ITaskItem> taskItems, int maxClients, 74ITaskItem item,

src\common\UploadToAzure.cs (2)

33public ITaskItem[] Items { get; set; } 86foreach (var item in Items)

src\ConfigureInputFeed.cs (2)

14public ITaskItem[] EnableFeeds { get; set; } 24public void GenerateNugetConfig(ITaskItem[] EnableFeeds, string RepoRoot, TaskLoggingHelper Log)

src\model\SetupTargetFeedConfigV3.cs (2)

43ITaskItem[] feedKeys, 44ITaskItem[] feedOverrides,

src\model\SetupTargetFeedConfigV4.cs (2)

42ITaskItem[] feedKeys, 43ITaskItem[] feedOverrides,

src\PublishArtifactsInManifest.cs (4)

60public ITaskItem[] TargetFeedConfig { get; set; } 66public ITaskItem[] AssetManifestPaths { get; set; } 125public ITaskItem[] FeedKeys { get; set; } 127public ITaskItem[] FeedOverrides { get; set; }

src\PublishArtifactsInManifestV3.cs (3)

43public ITaskItem[] FeedKeys { get; set; } 45public ITaskItem[] FeedOverrides { get; set; } 158feedOverrides: AllowFeedOverrides ? FeedOverrides : Array.Empty<ITaskItem>(),

src\PublishArtifactsInManifestV4.cs (3)

39public ITaskItem[] FeedKeys { get; set; } 41public ITaskItem[] FeedOverrides { get; set; } 153feedOverrides: AllowFeedOverrides ? FeedOverrides : Array.Empty<ITaskItem>(),

src\PushToBuildStorage.cs (9)

51public ITaskItem[] ItemsToPush { get; set; } 79public ITaskItem[] ItemsToSign { get; set; } 81public ITaskItem[] StrongNameSignInfo { get; set; } 83public ITaskItem[] FileSignInfo { get; set; } 85public ITaskItem[] FileExtensionSignInfo { get; set; } 87public ITaskItem[] CertificatesSignInfo { get; set; } 144public ITaskItem[] ArtifactVisibilitiesToPublish { get; set; } 493private static ArtifactVisibility GetVisibilitiesToPublish(ITaskItem[] allowedVisibilities) 502foreach (var item in allowedVisibilities)

SetupTargetFeedConfigV3Tests.cs (6)

42private readonly ITaskItem[] FeedKeys = GetFeedKeys(); 44private static ITaskItem[] GetFeedKeys() 52return new ITaskItem[] 176Array.Empty<ITaskItem>(), 292Array.Empty<ITaskItem>(), 406Array.Empty<ITaskItem>(),

SetupTargetFeedConfigV4Tests.cs (6)

43private readonly ITaskItem[] FeedKeys = GetFeedKeys(); 45private static ITaskItem[] GetFeedKeys() 53return new ITaskItem[] 170Array.Empty<ITaskItem>(), 264Array.Empty<ITaskItem>(), 358Array.Empty<ITaskItem>(),

src\CreateControlFile.cs (4)

33public ITaskItem[] Depends { get; set; } 38public ITaskItem[] AdditionalProperties { get; set; } 53foreach (ITaskItem depend in Depends ?? []) 72foreach (ITaskItem property in AdditionalProperties ?? [])

src\CreateDebPackage.cs (2)

26public ITaskItem ControlFile { get; set; } 29public ITaskItem DataFile { get; set; }

src\CreateLightCommandPackageDrop.cs (2)

24public ITaskItem [] Sice { get; set; } 72foreach (var siceItem in Sice)

src\CreateMD5SumsFile.cs (2)

23public ITaskItem[] Files { get; set; } 35foreach (ITaskItem file in Files)

src\CreateRpmPackage.cs (10)

47public ITaskItem[] RawPayloadFileKinds { get; set; } = []; 49public ITaskItem[] Requires { get; set; } = []; 51public ITaskItem[] Conflicts { get; set; } = []; 53public ITaskItem[] OwnedDirectories { get; set; } = []; 55public ITaskItem[] ChangelogLines { get; set; } = []; 65public ITaskItem[] Scripts { get; set; } = []; 94foreach (ITaskItem require in Requires) 99foreach (ITaskItem conflict in Conflicts) 104foreach (ITaskItem changelogLine in ChangelogLines) 114foreach (ITaskItem script in Scripts)

src\CreateWixBuildWixpack.cs (12)

31public ITaskItem BindTrackingFile { get; set; } 33public ITaskItem[] BindPaths { get; set; } 39public ITaskItem[] Extensions { get; set; } 49public ITaskItem IntermediateDirectory { get; set; } 51public ITaskItem[] LocalizationFiles { get; set; } 67public ITaskItem PdbFile { get; set; } 72public ITaskItem[] SourceFiles { get; set; } 360foreach (var extension in Extensions) 369foreach (var localizationFile in LocalizationFiles) 378foreach (var bindPath in BindPaths) 405foreach (var sourceFile in SourceFiles) 485foreach (var sourceFile in SourceFiles)

src\CreateWixCommandPackageDropBase.cs (10)

29public ITaskItem[] AdditionalBasePaths { get; set; } 33public ITaskItem[] Loc { get; set; } 36public ITaskItem[] WixExtensions { get; set; } 44public ITaskItem[] WixSrcFiles { get; set; } 104foreach (var locItem in Loc) 111foreach (var wixExtension in WixExtensions) 118foreach (var wixSrcFile in WixSrcFiles) 141foreach (var wixSrcFile in WixSrcFiles) 174foreach (var locItem in Loc) 290foreach (var additionalBasePath in AdditionalBasePaths)

src\GenerateMacOSDistributionFile.cs (1)

28public ITaskItem[] BundledPackages { get; set; }

src\StabilizeWixFileId.cs (2)

48public ITaskItem[] FileElementToStabilize { get; set; } 57foreach (var file in FileElementToStabilize)

ApplyBaseLine.cs (11)

23public ITaskItem[] OriginalDependencies { get; set; } 30public ITaskItem[] BaseLinePackages { get; set; } 35public ITaskItem[] PackageIndexes { get; set; } 43public ITaskItem[] BaseLinedDependencies { get; set; } 62foreach (var baseLinePackage in BaseLinePackages.NullAsEmpty()) 72List<ITaskItem> baseLinedDependencies = new List<ITaskItem>(); 74foreach (var dependency in OriginalDependencies) 107List<ITaskItem> baseLinedDependencies = new List<ITaskItem>(); 109foreach (var dependency in OriginalDependencies)

ApplyMetaPackages.cs (9)

26public ITaskItem[] OriginalDependencies { get; set; } 31public ITaskItem[] PackageIndexes { get; set; } 38public ITaskItem[] SuppressMetaPackages { get; set; } 46public ITaskItem[] UpdatedDependencies { get; set; } 56List<ITaskItem> updatedDependencies = new List<ITaskItem>(); 62foreach (ITaskItem metapackage in SuppressMetaPackages) 97foreach (var originalDependency in OriginalDependencies) 133private ITaskItem CreateDependency(string id, NuGetFramework targetFramework)

ApplyPreReleaseSuffix.cs (8)

24public ITaskItem[] OriginalPackages { get; set; } 35public ITaskItem[] PackageIndexes { get; set; } 42public ITaskItem[] StablePackages { get; set; } 48public ITaskItem[] UpdatedPackages { get; set; } 73List<ITaskItem> updatedPackages = new List<ITaskItem>(); 75foreach (var originalPackage in OriginalPackages) 120foreach (var stablePackage in StablePackages.NullAsEmpty())

CreateTrimDependencyGroups.cs (9)

22public ITaskItem[] Dependencies 29public ITaskItem[] Files 39public ITaskItem[] PackageIndexes 47public ITaskItem[] TrimmedDependencies 125List<ITaskItem> trimmedDependencies = new List<ITaskItem>(); 182public TaskItemPackageDependency(ITaskItem item) : base(item.ItemSpec, TryParseVersionRange(item.GetMetadata("Version"))) 196private static Version GetAssemblyVersion(ITaskItem dependency) 208public ITaskItem Item { get; }

Extensions.cs (8)

FilterUnknownPackages.cs (4)

17public ITaskItem[] OriginalDependencies { get; set; } 24public ITaskItem[] BaseLinePackages { get; set; } 29public ITaskItem[] PackageIndexes { get; set; } 33public ITaskItem[] FilteredDependencies { get; set; }

GenerateNuSpec.cs (4)

86public ITaskItem[] Dependencies { get; set; } 88public ITaskItem[] References { get; set; } 90public ITaskItem[] FrameworkReferences { get; set; } 92public ITaskItem[] Files { get; set; }

GeneratePackageReport.cs (5)

37public ITaskItem[] Files 49public ITaskItem[] Frameworks 62public ITaskItem[] PackageIndexes 201foreach(var framework in Frameworks) 286foreach (var file in Files)

GenerateRuntimeDependencies.cs (6)

20public ITaskItem[] Dependencies 33public ITaskItem RuntimeJsonTemplate 40public ITaskItem RuntimeJson 76foreach (var dependency in Dependencies) 149private string GetTargetPackageId(ITaskItem dependency, IDictionary<string, string> packageAliases) 172private NuGetVersion GetDependencyVersion(ITaskItem dependency)

GetApplicableAssetsFromPackageReports.cs (8)

32public ITaskItem[] CompileAssets { get; set; } 35public ITaskItem[] RuntimeAssets { get; set; } 38public ITaskItem[] NativeAssets { get; set; } 41public ITaskItem[] BuildProjects { get; set; } 66var compileAssets = new List<ITaskItem>(); 67var runtimeAssets = new List<ITaskItem>(); 68var nativeAssets = new List<ITaskItem>(); 98private ITaskItem ItemFromApplicableAsset(PackageAsset asset, string id, string version)

GetApplicableAssetsFromPackages.cs (9)

30public ITaskItem[] PackageAssets { get; set; } 55public ITaskItem[] CompileAssets { get; set; } 58public ITaskItem[] RuntimeAssets { get; set; } 61public ITaskItem[] BuildProjects { get; set; } 150foreach (var file in PackageAssets) 198private static ITaskItem PackageItemAsResolvedAsset(PackageItem packageItem) 203private static IEnumerable<ITaskItem> PackageItemAndSymbolsAsResolvedAsset(PackageItem packageItem) 223private static ITaskItem SetPackageMetadata(ITaskItem item, PackageItem packageItem)

GetAssemblyReferences.cs (8)

18public ITaskItem[] Assemblies 25public ITaskItem[] ReferencedAssemblies 32public ITaskItem[] ReferencedNativeLibraries 43List<ITaskItem> references = new List<ITaskItem>(); 44List<ITaskItem> nativeLibs = new List<ITaskItem>(); 46foreach (var assemblyItem in Assemblies)

GetInboxFrameworks.cs (1)

15public ITaskItem[] PackageIndexes

GetLastStablePackage.cs (13)

25public ITaskItem[] LatestPackages { get; set; } 32public ITaskItem[] StablePackages { get; set; } 37public ITaskItem[] PackageIndexes { get; set; } 51public ITaskItem[] LastStablePackages { get; set; } 74Dictionary<string, ITaskItem> originalItems = new Dictionary<string, ITaskItem>(); 78foreach (var latestPackage in LatestPackages) 93foreach (var stablePackage in StablePackages.NullAsEmpty()) 132List<ITaskItem> lastStablePackages = new List<ITaskItem>(); 134foreach (var latestPackage in LatestPackages) 162private ITaskItem CreateItem(ITaskItem originalItem, Version version)

GetLayoutFiles.cs (5)

33public ITaskItem[] Frameworks { get; set; } 41public ITaskItem[] LayoutFiles { get; set; } 54var layoutFiles = new List<ITaskItem>(); 117private IEnumerable<ITaskItem> CreateLayoutFiles(IEnumerable<PackageAsset> assets, string subFolder, string assetType) 125private IEnumerable<ITaskItem> CreateLayoutFile(string source, string subfolder, string assetType)

GetMinimumNETStandard.cs (1)

16public ITaskItem[] Frameworks

GetPackageDescription.cs (1)

19public ITaskItem DescriptionFile

GetPackageDestination.cs (6)

22public ITaskItem[] PackageTargetFrameworks { get; set; } 61public ITaskItem[] PackageDestinations { get; set; } 69private List<ITaskItem> _packageDestinations = new List<ITaskItem>(); 84foreach (var packageTargetFramework in packageTargetFrameworks) 165private ITaskItem CreatePackageDestination(string path, string framework)

GetPackageFromModule.cs (8)

18public ITaskItem[] ModulesReferenced { get; set; } 25public ITaskItem[] ModulePackages { get; set; } 30public ITaskItem[] PackageIndexes { get; set; } 36public ITaskItem[] PackagesReferenced { get; set; } 52foreach(var modulePackage in ModulePackages.NullAsEmpty()) 58List<ITaskItem> packagesReferenced = new List<ITaskItem>(); 60foreach(var moduleReferenced in ModulesReferenced)

GetPackageVersion.cs (1)

15public ITaskItem[] Files

GetSupportedPackagesFromPackageReports.cs (2)

20public ITaskItem[] SupportedPackages { get; set; } 24var supportedPackages = new List<ITaskItem>();

HarvestPackage.cs (16)

47public ITaskItem[] RuntimePackages { get; set; } 67public ITaskItem[] PathsToInclude { get; set; } 79public ITaskItem[] Frameworks { get; set; } 89public ITaskItem[] Files { get; set; } 97public ITaskItem[] SupportedFrameworks { get; set; } 108public ITaskItem[] HarvestedFiles { get; set; } 114public ITaskItem[] UpdatedFiles { get; set; } 147foreach (var runtimePackage in RuntimePackages) 158List<ITaskItem> supportedFrameworks = new List<ITaskItem>(); 177foreach (var framework in Frameworks) 289var harvestedFiles = new List<ITaskItem>(); 290var removeFiles = new List<ITaskItem>(); 316ITaskItem includeItem = null; 516private Dictionary<string, ITaskItem> _pathsToInclude = null; 518private bool ShouldInclude(string packagePath, out ITaskItem includeItem)

NuGetPack.cs (7)

40public ITaskItem[] Nuspecs 94public ITaskItem[] NuspecProperties 102public ITaskItem[] LibPackageExcludes 108public ITaskItem[] AdditionalLibPackageExcludes 114public ITaskItem[] AdditionalSymbolPackageExcludes 162foreach (var nuspec in Nuspecs) 195private static Func<string, string> GetNuspecPropertyProviderFunction(ITaskItem[] nuspecProperties)

PackageItem.cs (2)

15public PackageItem(ITaskItem item) 89public ITaskItem OriginalItem { get; }

PackageReport.cs (1)

165public ITaskItem ToItem()

PromoteDependencies.cs (8)

26public ITaskItem[] Dependencies { get; set; } 29public ITaskItem[] PackageIndexes { get; set; } 32public ITaskItem[] PromotedDependencies { get; set; } 40List<ITaskItem> promotedDependencies = new List<ITaskItem>(); 87private IEnumerable<ITaskItem> CopyDependencies(IEnumerable<Dependency> dependencies, NuGetFramework targetFramework) 102public Dependency(ITaskItem item) 117public ITaskItem OriginalItem { get; }

SplitDependenciesBySupport.cs (7)

22public ITaskItem[] OriginalDependencies { get; set; } 25public ITaskItem[] SplitDependencies { get; set; } 32List<ITaskItem> splitDependencies = new List<ITaskItem>(dependencies.Where(d => d.TargetFramework != null && d.TargetFramework.Framework != FrameworkConstants.FrameworkIdentifiers.NetStandard).Select(d => d.OriginalItem)); 65public Dependency(ITaskItem originalItem) 90public ITaskItem OriginalItem { get; } 95public ITaskItem GetItemWithTargetFramework(NuGetFramework framework)

SplitReferences.cs (12)

16public ITaskItem[] References 28public ITaskItem[] PackageIndexes 35public ITaskItem[] PackageReferences 42public ITaskItem[] FrameworkReferences 57Dictionary<string, ITaskItem> packageReferences = new Dictionary<string, ITaskItem>(); 58Dictionary<string, ITaskItem> assemblyReferences = new Dictionary<string, ITaskItem>(); 64foreach (var reference in References) 99private static void AddReference(Dictionary<string, ITaskItem> collection, ITaskItem item) 101ITaskItem existingItem;

UpdatePackageIndex.cs (13)

27public ITaskItem PackageIndexFile { get; set; } 32public ITaskItem[] Packages { get; set; } 39public ITaskItem[] BaselinePackages { get; set; } 46public ITaskItem[] StablePackages { get; set; } 53public ITaskItem[] ModuleToPackages { get; set; } 58public ITaskItem[] PackageIds { get; set; } 63public ITaskItem[] PackageFolders { get; set; } 69public ITaskItem InboxFrameworkListFolder { get; set; } 76public ITaskItem[] InboxFrameworkLayoutFolders { get; set; } 133foreach (var baselinePackage in BaselinePackages) 144foreach (var stablePackage in StablePackages) 155foreach (var moduleToPackage in ModuleToPackages) 169foreach(var inboxFrameworkLayoutFolder in InboxFrameworkLayoutFolders)

ValidateHarvestVersionIsLatestForRelease.cs (1)

24public ITaskItem[] PackageReports { get; set; }

ValidatePackage.cs (7)

49public ITaskItem[] SupportedFrameworks 61public ITaskItem[] Frameworks 109public ITaskItem[] AllSupportedFrameworks 458foreach (var framework in Frameworks) 497foreach (var supportedFramework in SupportedFrameworks) 656public ITaskItem ToItem() 658ITaskItem item = new TaskItem(Framework.ToString());

ValidationTask.cs (3)

26public ITaskItem[] Suppressions { get;set; } 41public ITaskItem[] PackageIndexes { get; set; } 103foreach(var suppression in Suppressions)

ApplyBaseLineTests.cs (6)

16private ITaskItem[] _packageIndexes; 28ITaskItem[] dependencies = new[] 57ITaskItem[] dependencies = new[] 85ITaskItem[] dependencies = new[] 114ITaskItem[] dependencies = new[] 139private static ITaskItem CreateItem(string name, string version)

CreateTrimDependencyGroupsTests.cs (15)

19private ITaskItem[] packageIndexes; 39ITaskItem[] files = new[] 66ITaskItem[] dependencies = new[] 109ITaskItem[] files = new[] 116ITaskItem[] dependencies = new[] 163ITaskItem[] files = new[] 190ITaskItem[] dependencies = new[] 257ITaskItem[] files = new[] 274ITaskItem[] dependencies = new[] 304ITaskItem[] files = new[] 311ITaskItem[] dependencies = new[] 368ITaskItem[] files = new[] 372ITaskItem[] dependencies = new[] 405public static ITaskItem CreateFileItem(string sourcePath, string targetPath, string targetFramework) 412public static ITaskItem CreateDependencyItem(string sourcePath, string version, string targetFramework)

GenerateNuSpecAndPackTests.cs (16)

64private ITaskItem CreateDependency(string id, string version, string targetFramework = null) 76ITaskItem[] nuspecs, 78ITaskItem[] additionalLibPackageExcludes = null, 79ITaskItem[] additionalSymbolPackageExcludes = null, 85ITaskItem[] nuspecProperties = null, 92AdditionalLibPackageExcludes = additionalLibPackageExcludes ?? Array.Empty<ITaskItem>(), 93AdditionalSymbolPackageExcludes = additionalSymbolPackageExcludes ?? Array.Empty<ITaskItem>(), 99NuspecProperties = nuspecProperties ?? Array.Empty<ITaskItem>(), 114ITaskItem[] dependencies = null, 116ITaskItem[] files = null, 117ITaskItem[] frameworkReferences = null, 127ITaskItem[] references = null, 145Dependencies = dependencies ?? Array.Empty<ITaskItem>(), 148Files = files ?? Array.Empty<ITaskItem>(), 149FrameworkReferences = frameworkReferences ?? Array.Empty<ITaskItem>(), 161References = references ?? Array.Empty<ITaskItem>(),

GetLastStablePackageTests.cs (9)

16private ITaskItem[] _packageIndexes; 28ITaskItem[] latestPackages = new[] 56ITaskItem[] latestPackages = new[] 83ITaskItem[] latestPackages = new[] 110ITaskItem[] latestPackages = new[] 132ITaskItem[] latestPackages = new[] 160ITaskItem[] latestPackages = new[] 188ITaskItem[] latestPackages = new[] 212private static ITaskItem CreateItem(string name, string version)

HarvestPackageTests.cs (5)

19private ITaskItem[] _frameworks; 53private ITaskItem CreateFrameworkItem(string tfm, string rids) 106var ns10asset = task.HarvestedFiles.FirstOrDefault(f => f.GetMetadata("TargetFramework") == "netstandard1.0"); 133var net46asset = task.HarvestedFiles.FirstOrDefault(f => f.GetMetadata("TargetFramework") == "net46"); 171private ITaskItem CreateRuntimePackage(string packageId, string version)

ValidateHarvestVersionIsLatestForReleaseTests.cs (1)

18private ITaskItem[] _testPackageReportPaths = new [] { new TaskItem("dummyReport.json") };

ChooseBestP2PTargetFrameworkTask.cs (7)

40public ITaskItem[]? AnnotatedProjectReferences { get; set; } 46public ITaskItem[]? AssignedProjects { get; set; } 63List<ITaskItem> assignedProjects = new(AnnotatedProjectReferences.Length); 65foreach (ITaskItem annotatedProjectReference in AnnotatedProjectReferences) 67ITaskItem? assignedProject = AssignNearestFrameworkForSingleReference(annotatedProjectReference, projectNuGetFramework, targetFrameworkResolver); 78private ITaskItem? AssignNearestFrameworkForSingleReference(ITaskItem project,

ChooseBestTargetFrameworksTask.cs (4)

15public ITaskItem[]? BuildTargetFrameworks { get; set; } 27public ITaskItem[]? BestTargetFrameworks { get; set; } 31List<ITaskItem> bestTargetFrameworkList = new(BuildTargetFrameworks!.Length); 34foreach (ITaskItem buildTargetFramework in BuildTargetFrameworks)

Vsix\GetPkgDefAssemblyDependencyGuid.cs (3)

23public ITaskItem[] Items { get; set; } 31public ITaskItem[] OutputItems { get; set; } 43foreach (var item in Items)

CreateVisualStudioWorkload.wix.cs (13)

33public ITaskItem[] ComponentResources 71public ITaskItem[] ShortNames 81public ITaskItem[] WorkloadManifestPackageFiles 146foreach (ITaskItem workloadManifestPackageFile in WorkloadManifestPackageFiles) 332List<ITaskItem> msiItems = new(); 333List<ITaskItem> swixProjectItems = new(); 345ITaskItem msiOutputItem = msi.Build(MsiOutputPath, IceSuppressions); 366ITaskItem swixProjectItem = new TaskItem(swixProj); 392ITaskItem msiOutputItem = msi.Build(MsiOutputPath, IceSuppressions); 415ITaskItem swixProjectItem = new TaskItem(swixProj); 434ITaskItem msiOutputItem = msi.Build(MsiOutputPath, IceSuppressions); 444ITaskItem swixProjectItem = new TaskItem(swixProject.Create()); 471ITaskItem swixProjectItem = new TaskItem(swixComponentProject.Create());

CreateVisualStudioWorkloadSet.wix.cs (6)

32public ITaskItem[] WorkloadSetPackageFiles 42List<ITaskItem> msiItems = new(); 43List<ITaskItem> swixProjectItems = new(); 46foreach (ITaskItem workloadSetPackageFile in WorkloadSetPackageFiles) 70ITaskItem msiOutputItem = msi.Build(MsiOutputPath, IceSuppressions); 87ITaskItem swixProjectItem = new TaskItem(swixProj);

Extensions.cs (1)

22public static bool HasMetadata(this ITaskItem item, string metadataName)

FrameworkPackPackage.wix.cs (1)

21string destinationBaseDirectory, ITaskItem[]? shortNames = null, TaskLoggingHelper? log = null) :

LibraryPackPackage.wix.cs (1)

21string destinationBaseDirectory, ITaskItem[]? shortNames = null, TaskLoggingHelper? log = null) :

Msi\MsiBase.wix.cs (9)

140public abstract ITaskItem Build(string outputPath, ITaskItem[]? iceSuppressions); 191/// <returns>An <see cref="ITaskItem"/> for the MSI that was created.</returns> 193protected ITaskItem Link(string compilerOutputPath, string outputFile, ITaskItem[]? iceSuppressions = null) 206/// <returns>An <see cref="ITaskItem"/> for the MSI that was created.</returns> 208protected ITaskItem Link(string compilerOutputPath, string outputFile, ITaskItem[]? iceSuppressions, params string[] wixExtensions) 241protected void AddDefaultPackageFiles(ITaskItem msi)

Msi\MsiPayloadPackageProject.wix.cs (1)

33public MsiPayloadPackageProject(MsiMetadata package, ITaskItem msi, string baseIntermediateOutputPath, string baseOutputPath, Dictionary<string, string> packageContents) :

Msi\WorkloadManifestMsi.wix.cs (3)

47public override ITaskItem Build(string outputPath, ITaskItem[]? iceSuppressions = null) 157ITaskItem msi = Link(candle.OutputPath, Path.Combine(outputPath, OutputName), iceSuppressions);

Msi\WorkloadPackGroupMsi.wix.cs (3)

29public override ITaskItem Build(string outputPath, ITaskItem[] iceSuppressions) 145ITaskItem msi = Link(candle.OutputPath, msiFileName, iceSuppressions);

Msi\WorkloadPackMsi.wix.cs (3)

28public override ITaskItem Build(string outputPath, ITaskItem[]? iceSuppressions = null) 77ITaskItem msi = Link(candle.OutputPath, Path.Combine(outputPath, OutputName), iceSuppressions);

Msi\WorkloadSetMsi.wix.cs (3)

29public override ITaskItem Build(string outputPath, ITaskItem[]? iceSuppressions) 74ITaskItem msi = Link(candle.OutputPath, Path.Combine(outputPath, OutputName), iceSuppressions);

SdkPackPackage.wix.cs (1)

21string destinationBaseDirectory, ITaskItem[]? shortNames = null, TaskLoggingHelper? log = null) :

StringExtensions.cs (2)

40public static string Replace(this string str, ITaskItem[] replacementStrings) 44foreach (ITaskItem item in replacementStrings)

Swix\MsiSwixProject.wix.cs (2)

19ITaskItem _msi; 65public MsiSwixProject(ITaskItem msi, string baseIntermediateOutputPath, string baseOutputPath,

Swix\PackageGroupSwixProject.wix.cs (2)

77public static ITaskItem CreateProjectItem(SwixPackageGroup swixPackageGroup, string baseIntermediateOutputPath, string baseOutputPath, 81ITaskItem swixProjectItem = new TaskItem(swixPackageGroupProject.Create());

Swix\SwixComponent.cs (5)

75public ITaskItem[]? ShortNames 101bool isUiGroup, string category, ITaskItem[]? shortNames, bool advertise = false) : base(name, version) 156ITaskItem[]? componentResources = null, ITaskItem[]? shortNames = null, string? componentSuffix = null) 158ITaskItem? resourceItem = componentResources?.Where(r => string.Equals(r.ItemSpec, workload.Id)).FirstOrDefault();

TemplatePackPackage.wix.cs (1)

21string destinationBaseDirectory, ITaskItem[]? shortNames = null, TaskLoggingHelper? log = null) :

ToolsPackPackage.wix.cs (1)

21string destinationBaseDirectory, ITaskItem[]? shortNames = null, TaskLoggingHelper? log = null) :

VisualStudioWorkloadTaskBase.wix.cs (3)

46public ITaskItem[] IceSuppressions 58public ITaskItem[] Msis 79public ITaskItem[] SwixProjects

WorkloadManifestPackage.wix.cs (2)

76public WorkloadManifestPackage(ITaskItem package, string destinationBaseDirectory, Version msiVersion, 77ITaskItem[]? shortNames = null, TaskLoggingHelper? log = null, bool isSxS = false) :

WorkloadPackageBase.cs (3)

134public ITaskItem[]? ShortNames 185public WorkloadPackageBase(string packagePath, string destinationBaseDirectory, ITaskItem[]? shortNames = null, TaskLoggingHelper? log = null) 320internal static Version GetMsiVersion(ITaskItem package, Version msiVersion, string taskName,

WorkloadPackPackage.wix.cs (2)

39ITaskItem[]? shortNames = null, TaskLoggingHelper? log = null) : base(packagePath, destinationBaseDirectory, shortNames, log) 113string destinationBaseDirectory, ITaskItem[]? shortNames, TaskLoggingHelper? log) =>

WorkloadSetPackage.wix.cs (2)

50public WorkloadSetPackage(ITaskItem package, string destinationBaseDirectory, Version msiVersion, 51ITaskItem[]? shortNames = null, TaskLoggingHelper? log = null) :

CreateVisualStudioWorkloadSetTests.cs (4)

29ITaskItem[] workloadSetPackages = new[] 49ITaskItem msi = createWorkloadSetTask.Msis.Where(i => i.GetMetadata(Metadata.Platform) == "x64").FirstOrDefault(); 68ITaskItem workloadSetSwixItem = createWorkloadSetTask.SwixProjects.Where(s => s.ItemSpec.Contains(@"Microsoft.NET.Workloads.9.0.100.9.0.100-baseline.1.23464.1\x64")).FirstOrDefault(); 79ITaskItem workloadSetPackageGroupSwixItem = createWorkloadSetTask.SwixProjects.Where(

CreateVisualStudioWorkloadTests.cs (10)

33ITaskItem[] manifestsPackages = new[] 39ITaskItem[] componentResources = new[] 47ITaskItem[] shortNames = new[] 76ITaskItem manifestMsiItem = createWorkloadTask.Msis.Where(m => m.ItemSpec.ToLowerInvariant().Contains("d96ba8044ad35589f97716ecbf2732fb-x64.msi")).FirstOrDefault(); 143ITaskItem pythonPackSwixItem = createWorkloadTask.SwixProjects.Where(s => s.ItemSpec.Contains(@"Microsoft.Emscripten.Python.6.0.4\x64")).FirstOrDefault(); 152IEnumerable<ITaskItem> swixComponentProjects = createWorkloadTask.SwixProjects.Where(s => s.GetMetadata(Metadata.PackageType).Equals(DefaultValues.PackageTypeComponent)); 169ITaskItem[] manifestsPackages = new[] 176ITaskItem[] componentResources = new[] 184ITaskItem[] shortNames = new[] 212ITaskItem manifestMsiItem = createWorkloadTask.Msis.Where(m => m.ItemSpec.ToLowerInvariant().Contains("d96ba8044ad35589f97716ecbf2732fb-arm64.msi")).FirstOrDefault();

MsiTests.cs (6)

21private static ITaskItem BuildManifestMsi(string path, string msiVersion = "1.2.3", string platform = "x64", string msiOutputPath = null) 34ITaskItem msi603 = BuildManifestMsi(Path.Combine(TestAssetsPath, "microsoft.net.workload.mono.toolchain.manifest-6.0.200.6.0.3.nupkg"), 49ITaskItem msi603 = BuildManifestMsi(Path.Combine(TestAssetsPath, "microsoft.net.workload.mono.toolchain.manifest-6.0.200.6.0.3.nupkg")); 53ITaskItem msi604 = BuildManifestMsi(Path.Combine(TestAssetsPath, "microsoft.net.workload.mono.toolchain.manifest-6.0.200.6.0.4.nupkg")); 89ITaskItem item = msi.Build(MsiOutputPath); 121ITaskItem item = msi.Build(MsiOutputPath);

PackageTests.cs (1)

48ITaskItem workloadSetPackageItem = new TaskItem(Path.Combine(TestAssetsPath, "microsoft.net.workloads.9.0.100.9.0.100-baseline.1.23464.1.nupkg"));

SwixComponentTests.cs (5)

44ITaskItem[] componentResources = new[] 74ITaskItem[] componentResources = new[] 103ITaskItem[] shortNames = new TaskItem[] 145ITaskItem[] componentResources = new ITaskItem[]

SwixPackageGroupTests.cs (3)

16private static readonly ITaskItem[] s_shortNames = new[] 22public void ItGeneratesPackageGroupsForManifestPackages(string manifestPackageFilename, string destinationDirectory, Version msiVersion, ITaskItem[] shortNames, 29var packageGroupItem = PackageGroupSwixProject.CreateProjectItem(packageGroup, BaseIntermediateOutputPath, BaseOutputPath,

SwixPackageTests.cs (1)

52ITaskItem msiItem = msi.Build(MsiOutputPath);

src\CreateAkaMSLinks.cs (2)

24public ITaskItem[] Links { get; set; } 57foreach (var link in Links)

GenAPITask.cs (1)

162public ITaskItem[] ConditionalTypeLists { get; set; }

GenPartialFacadeSource.cs (3)

15public ITaskItem[] ReferencePaths { get; set; } 20public ITaskItem[] CompileFiles { get; set; } 32public ITaskItem[] SeedTypePreferences { get; set; }

GenPartialFacadeSourceGenerator.cs (3)

30ITaskItem[] seedTypePreferencesList = null) 64private static Dictionary<string, string> ParseSeedTypePreferences(ITaskItem[] preferences, ILog logger) 70foreach (var item in preferences)

NotSupportedAssemblyGenerator.cs (3)

22public ITaskItem[] SourceFiles { get; set; } 44private void GenerateNotSupportedAssemblyFiles(IEnumerable<ITaskItem> sourceFiles) 52foreach (ITaskItem item in sourceFiles)

CancelHelixJob.cs (2)

22public ITaskItem[] Jobs { get; set; } 30foreach (ITaskItem job in Jobs)

CheckAzurePipelinesTestResults.cs (3)

20public ITaskItem[] ExpectedTestFailures { get; set; } 25public ITaskItem[] WorkItems { get; set; } 141ITaskItem workItem = null;

CheckHelixJobStatus.cs (3)

19public ITaskItem[] Jobs { get; set; } 22public ITaskItem[] WorkItems { get; set; } 35foreach (ITaskItem workItem in WorkItems)

CreateFailedTestsForFailedWorkItems.cs (2)

18public ITaskItem[] WorkItems { get; set; } 22foreach (ITaskItem workItem in WorkItems)

CreateXHarnessAndroidWorkItems.cs (5)

44public ITaskItem[] Apks { get; set; } 72private async Task<ITaskItem> PrepareWorkItem(IZipArchiveManager zipArchiveManager, IFileSystem fileSystem, ITaskItem appPackage) 138private string GetDefaultCommand(ITaskItem appPackage, int expectedExitCode) 164ITaskItem appPackage,

CreateXHarnessAppleWorkItems.cs (3)

45public ITaskItem[] AppBundles { get; set; } 94private async Task<ITaskItem> PrepareWorkItem( 98ITaskItem appBundleItem)

CreateXUnitWorkItems.cs (4)

29public ITaskItem[] XUnitProjects { get; set; } 57public ITaskItem[] XUnitWorkItems { get; set; } 88private async Task<ITaskItem> PrepareWorkItem(ITaskItem xunitProject)

DownloadFromResultsContainer.cs (4)

18public ITaskItem[] WorkItems { get; set; } 27public ITaskItem[] MetadataToWrite { get; set; } 56foreach (ITaskItem metadata in MetadataToWrite) 64private async Task DownloadFilesForWorkItem(ITaskItem workItem, string directoryPath, CancellationToken ct)

FindDotNetCliPackage.cs (6)

52public ITaskItem [] AdditionalFeeds { get; set; } 83var feeds = new List<ITaskItem>(); 92foreach (var feed in feeds) 138private async Task<string> GetDownloadUrlAsync(ITaskItem feed) 172private async Task<string> GetEffectiveVersion(ITaskItem feed, string version) 321private async Task<string> ResolveVersionAsync(ITaskItem feed)

GetHelixWorkItems.cs (6)

27public ITaskItem[] Jobs { get; set; } 30public ITaskItem[] WorkItems { get; set; } 37private async Task<IEnumerable<ITaskItem>> GetWorkItemsAsync(ITaskItem job, CancellationToken cancellationToken) 50return Array.Empty<ITaskItem>(); 53var workItems = new List<ITaskItem>();

SendHelixJob.cs (10)

106public ITaskItem[] CorrelationPayloads { get; set; } 134public ITaskItem[] WorkItems { get; set; } 144public ITaskItem[] HelixProperties { get; set; } 195foreach (ITaskItem correlationPayload in CorrelationPayloads) 203foreach (ITaskItem workItem in WorkItems) 220foreach (ITaskItem helixProperty in HelixProperties) 287private IJobDefinition AddProperty(IJobDefinition def, ITaskItem property) 304private IJobDefinition AddWorkItem(IJobDefinition def, ITaskItem workItem) 401private IEnumerable<string> GetCommands(ITaskItem workItem, string workItemCommand) 492private IJobDefinition AddCorrelationPayload(IJobDefinition def, ITaskItem correlationPayload)

TaskItemExtensions.cs (2)

11public static bool TryGetMetadata(this ITaskItem item, string key, out string value) 17public static bool GetRequiredMetadata(this ITaskItem item, TaskLoggingHelper log, string key, out string value)

WaitForHelixJobCompletion.cs (1)

20public ITaskItem[] Jobs { get; set; }

XharnessTaskBase.cs (3)

43public ITaskItem[] WorkItems { get; set; } 55protected (TimeSpan TestTimeout, TimeSpan WorkItemTimeout, int ExpectedExitCode, string CustomCommands) ParseMetadata(ITaskItem xHarnessAppItem) 186public static (string WorkItemName, string AppPath) GetNameAndPath(ITaskItem item, string pathMetadataName, IFileSystem fileSystem)

CreateXHarnessAndroidWorkItemsTests.cs (7)

77var workItem = _task.WorkItems.First(); 116var workItem = _task.WorkItems.Last(); 147var workItem1 = _task.WorkItems.Last(); 154var workItem2 = _task.WorkItems.First(); 179var workItem = _task.WorkItems.First(); 216private ITaskItem CreateApk( 224var mockBundle = new Mock<ITaskItem>();

CreateXHarnessAppleWorkItemsTests.cs (8)

80var workItem = _task.WorkItems.First(); 126var workItem = _task.WorkItems.Last(); 158var workItem = _task.WorkItems.First(); 188var workItem1 = _task.WorkItems.First(); 199var workItem2 = _task.WorkItems.Last(); 231var workItem = _task.WorkItems.First(); 275private ITaskItem CreateAppBundle( 286var mockBundle = new Mock<ITaskItem>();

FindDotNetCliPackageTests.cs (2)

90ITaskItem[] additionalFeed = new TaskItem[] 141ITaskItem[] additionalFeed = new TaskItem[]

GetCompatiblePackageTargetFrameworks.cs (4)

26public ITaskItem[] TestProjects { get; set; } 30List<ITaskItem> testProjects = new(); 108private static List<ITaskItem> CreateItemFromTestFramework(string packageId, string version, IEnumerable<NuGetFramework> testFrameworks) 110List<ITaskItem> testprojects = new();

VerifyClosure.cs (4)

28public ITaskItem[] Sources { get; set; } 35public ITaskItem[] IgnoredReferences { get; set; } 76foreach (var source in Sources) 131foreach (var ignoredReference in IgnoredReferences)

VerifyTypes.cs (4)

24public ITaskItem[] Sources { get; set; } 31public ITaskItem[] IgnoredTypes { get; set; } 78foreach (var source in Sources) 129foreach(var ignoredType in IgnoredTypes)

src\CreateFrameworkListFile.cs (6)

22public ITaskItem[] Files { get; set; } 44public ITaskItem[] FileClassifications { get; set; } 59public ITaskItem[] RootAttributes { get; set; } 69Dictionary<string, ITaskItem> fileClassLookup = FileClassifications 215if (fileClassLookup.TryGetValue(f.Filename, out ITaskItem classItem)) 266private bool IsTargetPathIncluded(ITaskItem item)

src\GeneratePlatformManifestEntriesFromFileList.cs (3)

18public ITaskItem[] Files { get; set; } 21public ITaskItem[] PlatformManifestEntries { get; set; } 26foreach (var file in Files)

src\GeneratePlatformManifestEntriesFromTemplate.cs (5)

17public ITaskItem[] PlatformManifestEntryTemplates { get; set; } 20public ITaskItem[] Files { get; set; } 27public ITaskItem[] PlatformManifestEntries { get; set; } 33foreach (var entryTemplate in PlatformManifestEntryTemplates) 35if (files.TryGetValue(entryTemplate.ItemSpec, out ITaskItem existingFile))

src\GenerateSharedFrameworkDepsFile.cs (3)

34public ITaskItem[] Files { get; set; } 46public ITaskItem GeneratedDepsFile { get; set; } 55foreach (var file in Files)

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

28public ITaskItem[] Sources { get; set; } 35public ITaskItem[] IgnoredReferences { get; set; } 76foreach (var source in Sources) 131foreach (var ignoredReference in IgnoredReferences)

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

24public ITaskItem[] Sources { get; set; } 31public ITaskItem[] IgnoredTypes { get; set; } 78foreach (var source in Sources) 129foreach(var ignoredType in IgnoredTypes)

src\ValidateFileVersions.cs (4)

18public ITaskItem[] Files { get; set; } 23foreach(var file in Files) 92FileVersionData GetFileVersionData(ITaskItem file) 133public ITaskItem File { get; set; }

src\SignCheckTask.cs (1)

72public ITaskItem[] InputFiles

src\SignToolTask.cs (12)

89public ITaskItem[] ItemsToSign { get; set; } 95public ITaskItem[] ItemsToSkipStrongNameCheck { get; set; } 101public ITaskItem[] ItemsToSkip3rdPartyCheck { get; set; } 108public ITaskItem[] StrongNameSignInfo { get; set; } 114public ITaskItem[] FileSignInfo { get; set; } 123public ITaskItem[] FileExtensionSignInfo { get; set; } 130public ITaskItem[] CertificatesSignInfo { get; set; } 331foreach (var certificateSignInfo in CertificatesSignInfo) 383foreach (var itemToSign in ItemsToSign) 436foreach (var item in FileExtensionSignInfo) 483foreach (var item in StrongNameSignInfo) 539foreach (var item in FileSignInfo)

src\ZipData.cs (2)

687ITaskItem[] rawPayloadFileKinds = 698List<ITaskItem> scripts = [];

SignToolTests.cs (28)

src\ReadNuGetPackageInfos.cs (1)

24public ITaskItem[] PackageInfoItems { get; set; }

src\UsageReport\WritePackageUsageData.cs (1)

35public ITaskItem[] NuGetPackageInfos { get; set; }

src\UsageReport\WriteUsageReports.cs (3)

32public ITaskItem[] PackageVersionPropsSnapshots { get; set; } 40public ITaskItem[] ProdConPackageInfos { get; set; } 71foreach (ITaskItem item in ProdConPackageInfos.NullAsEmpty())

src\WriteBuildOutputProps.cs (4)

23public ITaskItem[] NuGetPackages { get; set; } 42public ITaskItem[] ExtraProperties { get; set; } 91foreach (var extraProp in ExtraProperties ?? Enumerable.Empty<ITaskItem>())

GenerateSwaggerCode.cs (2)

34public ITaskItem[] GeneratedFiles { get; set; } 82var generatedFiles = new List<ITaskItem>();

Tasks\EnsureAllResourcesTranslated.cs (2)

15public ITaskItem[] Sources { get; set; } 22foreach (ITaskItem item in Sources)

Tasks\GatherTranslatedSource.cs (13)

14public ITaskItem[] XlfFiles { get; set; } 17public ITaskItem[] Outputs { get; private set; } 22ITaskItem[] outputs = new ITaskItem[XlfFiles.Length]; 24foreach (ITaskItem xlf in XlfFiles) 56private static void SetLink(ITaskItem xlf, ITaskItem output, string language, string translatedFullPath, bool preserveFileName) 85private static void AdjustManifestResourceName(ITaskItem xlf, ITaskItem output, string language) 95private static void AdjustLogicalName(ITaskItem xlf, ITaskItem output, string language) 106private static void AdjustDependentUpon(ITaskItem xlf, ITaskItem output)

Tasks\GatherXlf.cs (6)

15public ITaskItem[] Sources { get; set; } 24public ITaskItem[] Outputs { get; private set; } 29ITaskItem[] outputs = new ITaskItem[Sources.Length * Languages.Length]; 32foreach (ITaskItem source in Sources) 51private string GetTranslatedOutputPath(ITaskItem source, string language, HashSet<string> outputPaths)

Tasks\SortXlf.cs (2)

13public ITaskItem[] Sources { get; set; } 20foreach (ITaskItem item in Sources)

Tasks\TaskItemExtensions.cs (2)

10public static string GetMetadataOrThrow(this ITaskItem item, string key) 22public static string GetMetadataOrDefault(this ITaskItem item, string key, string defaultValue)

Tasks\TransformTemplates.cs (12)

18public ITaskItem[] Templates { get; set; } 21public ITaskItem[] UnstructuredResources { get; set; } 30public ITaskItem[] TransformedTemplates { get; set; } 34List<ITaskItem> transformedTemplates = new(); 35Dictionary<string, ITaskItem> resourceMap = UnstructuredResources.ToDictionary(item => item.GetMetadata("FullPath")); 36foreach (ITaskItem template in Templates) 39ITaskItem defaultTemplate = TransformTemplate(template, language: null, resourceMap: null); 45ITaskItem item = TransformTemplate(template, language, resourceMap); 53private ITaskItem TransformTemplate(ITaskItem template, string language, IDictionary<string, ITaskItem> resourceMap) 100if (resourceMap.TryGetValue(templateItemFullPath, out ITaskItem unstructuredResource))

Tasks\TranslateSource.cs (1)

14public ITaskItem XlfFile { get; set; }

Tasks\UpdateXlf.cs (2)

13public ITaskItem[] Sources { get; set; } 29foreach (ITaskItem item in Sources)

GetCurrentOpenApiReference.cs (3)

10/// Restore <see cref="ITaskItem"/>s from given property value. 21/// The restored <see cref="ITaskItem"/>s. Will never contain more than one item. 24public ITaskItem[] Outputs { get; set; }

GetOpenApiReferenceMetadata.cs (4)

41public ITaskItem[] Inputs { get; set; } 47public ITaskItem[] Outputs { get; set; } 52var outputs = new List<ITaskItem>(Inputs.Length); 56foreach (var item in Inputs)

MetadataSerializer.cs (7)

12/// Utility methods to serialize and deserialize <see cref="ITaskItem"/> metadata. 27/// <param name="item">The <see cref="ITaskItem"/> to update.</param> 31public static void SetMetadata(ITaskItem item, string key, string value) 56public static string SerializeMetadata(ITaskItem item) 88/// Recreate an <see cref="ITaskItem"/> with metadata encoded in given <paramref name="value"/>. 91/// <returns>The deserialized <see cref="ITaskItem"/>.</returns> 92public static ITaskItem DeserializeMetadata(string value)

GetCurrentOpenApiReferenceTest.cs (1)

43var output = Assert.Single(task.Outputs);

GetOpenApiReferenceMetadataTest.cs (6)

57var output = Assert.Single(task.Outputs); 117var output = Assert.Single(task.Outputs); 177var output = Assert.Single(task.Outputs); 237var output = Assert.Single(task.Outputs); 390var output = Assert.Single(task.Outputs); 454var output = Assert.Single(task.Outputs);

MetadataSerializerTest.cs (7)

90var item = new Mock<ITaskItem>(MockBehavior.Strict); 123var item = MetadataSerializer.DeserializeMetadata(input); 149var item = MetadataSerializer.DeserializeMetadata(input); 164var item = MetadataSerializer.DeserializeMetadata(input); 252var input = new Mock<ITaskItem>(MockBehavior.Strict); 279var input = new Mock<ITaskItem>(MockBehavior.Strict); 302var input = new Mock<ITaskItem>(MockBehavior.Strict);

AsyncTask.cs (2)

87 public void LogDebugTaskItems(string message, ITaskItem[] items) 94 foreach (var item in items)

CreatePartialInfoPlistTask.cs (2)

10 public ITaskItem[] CustomFonts { get; set; } 45 foreach (var font in CustomFonts)

DetectInvalidResourceOutputFilenamesTask.cs (4)

13 public ITaskItem[] Items { get; set; } 21 public ITaskItem[] InvalidItems { get; set; } 25 var tempInvalidItems = new Dictionary<ITaskItem, string>(); 30 foreach (var item in Items)

GeneratePackageAppxManifest.cs (4)

26 public ITaskItem AppxManifest { get; set; } = null!; 38 public ITaskItem[]? AppIcon { get; set; } 40 public ITaskItem[]? SplashScreen { get; set; } 43 public ITaskItem GeneratedAppxManifest { get; set; } = null!;

GenerateSplashAndroidResources.cs (2)

25 public ITaskItem[] MauiSplashScreen { get; set; } 33 var splash = MauiSplashScreen?.FirstOrDefault();

GenerateSplashAssets.cs (2)

17 public ITaskItem[] MauiSplashScreen { get; set; } 21 var splash = MauiSplashScreen[0];

GenerateSplashStoryboard.cs (2)

20 public ITaskItem[]? MauiSplashScreen { get; set; } 30 var splash = MauiSplashScreen?.FirstOrDefault();

GenerateTizenManifest.cs (3)

46 public ITaskItem[]? AppIcon { get; set; } 48 public ITaskItem[]? SplashScreen { get; set; } 51 public ITaskItem GeneratedTizenManifest { get; set; } = null!;

GetMauiAssetPath.cs (3)

35 public ITaskItem[] Input { get; set; } 38 public ITaskItem[] Output { get; set; } 44 foreach (var item in Input)

ResizeImageInfo.cs (3)

59 public static List<ResizeImageInfo> Parse(IEnumerable<ITaskItem> images) 66 foreach (var image in images) 75 public static ResizeImageInfo Parse(ITaskItem image)

ResizetizeImages.cs (2)

28 public ITaskItem[] Images { get; set; } 31 public ITaskItem[] CopiedResources { get; set; }

TizenSplashUpdater.cs (1)

12 public ITaskItem[] MauiSplashScreen { get; set; }

UpdateRuntimeIdentifierGraph.cs (2)

22public ITaskItem[]? AdditionalRuntimeIdentifiers { get; set; } 35foreach (ITaskItem rid in AdditionalRuntimeIdentifiers!)

ShowItems.cs (2)

14public ITaskItem[] Items { get; set; } 40foreach (ITaskItem item in Items)

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

69var mainEmbeddedList = new List<ITaskItem>(); 70var satelliteEmbeddedList = new List<ITaskItem>(); 71var clrEmbeddedResourceList = new List<ITaskItem>(); 72var clrSatelliteEmbeddedResourceList = new List<ITaskItem>(); 145public ITaskItem [] SourceFiles { get; set; } 169public ITaskItem[] CLRResourceFiles { get; set; } 177public ITaskItem[] CLREmbeddedResource { get; set; } 185public ITaskItem[] CLRSatelliteEmbeddedResource { get; set; } 193public ITaskItem [] MainEmbeddedFiles { get; set; } 202public ITaskItem [] SatelliteEmbeddedFiles { get; set; } 288private void Classify(IEnumerable<ITaskItem> inputItems, List<ITaskItem> mainList, List<ITaskItem> satelliteList) 290foreach (ITaskItem inputItem in inputItems) 292ITaskItem outputItem = new TaskItem 317private bool IsItemLocalizable(ITaskItem fileItem)

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

177Dictionary<string, ITaskItem[]> targetOutputs = new Dictionary<string, ITaskItem[]>(); 292Dictionary<string, ITaskItem[]> targetOutputs = new Dictionary<string, ITaskItem[]>(); 372public ITaskItem[] GeneratedCodeFiles 399public ITaskItem[] ReferencePath 488public ITaskItem[] Analyzers 697private void AddNewItems(XmlDocument xmlProjectDoc, string sItemName, ITaskItem[] pItemList) 723ITaskItem pItem = pItemList[i]; 908private ITaskItem[] _generatedCodeFiles; 909private ITaskItem[] _referencePath;

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

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

298public ITaskItem[] References 361public ITaskItem [] GeneratedBaml 750GeneratedBaml = (ITaskItem[])bamlFileList.ToArray(typeof(ITaskItem)); 860private ITaskItem [] _references; 876private ITaskItem [] _generatedBaml;

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

73foreach (ITaskItem item in GeneratedLocalizationFiles) 116public ITaskItem[] GeneratedLocalizationFiles 136private ITaskItem[] _generatedLocalizationFiles;

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

175foreach (var resourceFile in ResourceFiles) 238public ITaskItem [] ResourceFiles { get; set; } 266public ITaskItem [] OutputResourcesFile { get; set; } 283private bool ValidResourceFiles(ITaskItem[] inputFiles) 287foreach (ITaskItem inputFile in inputFiles) 309private string GetResourceIdForResourceFile(ITaskItem resFile)

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

139public ITaskItem[] MarkupFiles 205foreach (ITaskItem inputFile in _markupFiles) 594private ITaskItem[] _markupFiles; // input Xaml files

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

175public ITaskItem[] ApplicationManifest 191private ITaskItem[] _applicationmanifest;

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

202internal static string GenerateCacheForFileList(ITaskItem[] fileItemList) 230private static string GenerateStringFromFileNames(ITaskItem[] fileItemList)

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

206ITaskItem taskItem = _mcPass1.PageMarkup[i]; 461ITaskItem taskItem = _mcPass1.PageMarkup[i]; 530ITaskItem taskItem = _mcPass1.ApplicationMarkup[0]; 551private bool IsFileListChanged(ITaskItem[] fileList)

GenerateFilteredReferenceAssembliesTask.cs (2)

58public ITaskItem[] ApiSets { get; private set; } = null!; 61public ITaskItem[] References { get; private set; } = null!;