17public interface ITaskItem2 : ITaskItem

542ITaskItem,

2128internal sealed class DerivedFromITaskItem : ITaskItem

35internal sealed class MinimalDictionaryTaskItem : ITaskItem

424internal sealed class MyTaskItem : ITaskItem

28internal sealed class MinimalTaskItem : ITaskItem

17internal class TaskItemData : ITaskItem, IMetadataContainer

12internal sealed class SimpleTaskItem : ITaskItem

542ITaskItem,

378private sealed class TaskItemMock : ITaskItem

1342private sealed class TestTaskItemWithNullSpec : ITaskItem

542ITaskItem,

520private class TaskParameterTaskItem : MarshalByRefObject, ITaskItem, ITranslatable

18public ITaskItem[] AppProjectTargetFramework { get; set; } = []; 24public ITaskItem[] NonExecutableReferences { get; set; } = []; 28var nonExecutableReferences = new HashSet<ITaskItem>(); 32foreach (var appProject in AppProjectTargetFramework)

17public ITaskItem MainAssembly { get; set; } 18public ITaskItem[] Assemblies { get; set; } 37public ITaskItem CrossgenTool { get; set; } 38public ITaskItem Crossgen2Tool { get; set; } 43public ITaskItem[] ReadyToRunCompileList => _compileList.ToArray(); 45public ITaskItem[] ReadyToRunSymbolsCompileList => _symbolsCompileList.ToArray(); 50public ITaskItem[] ReadyToRunFilesToPublish => _r2rFiles.ToArray(); 53public ITaskItem[] ReadyToRunAssembliesToReference => _r2rReferences.ToArray(); 56public ITaskItem[] ReadyToRunCompositeBuildReferences => _r2rCompositeReferences.ToArray(); 59public ITaskItem[] ReadyToRunCompositeBuildInput => _r2rCompositeInput.ToArray(); 62public ITaskItem[] ReadyToRunCompositeUnrootedBuildInput => _r2rCompositeUnrootedInput.ToArray(); 67private List<ITaskItem> _compileList = new(); 68private List<ITaskItem> _symbolsCompileList = new(); 69private List<ITaskItem> _r2rFiles = new(); 70private List<ITaskItem> _r2rReferences = new(); 71private List<ITaskItem> _r2rCompositeReferences = new(); 72private List<ITaskItem> _r2rCompositeInput = new(); 73private List<ITaskItem> _r2rCompositeUnrootedInput = new(); 127ITaskItem[] inputFiles, 128List<ITaskItem> imageCompilationList, 129List<ITaskItem> symbolsCompilationList, 130List<ITaskItem> r2rFilesPublishList, 131List<ITaskItem> r2rReferenceList, 132List<ITaskItem> r2rCompositeReferenceList, 133List<ITaskItem> r2rCompositeInputList, 134List<ITaskItem> r2rCompositeUnrootedInput, 146foreach (var file in inputFiles) 434private static Eligibility GetInputFileEligibility(ITaskItem file, bool compositeCompile, HashSet<string> exclusionSet, HashSet<string> r2rCompositeExclusionSet, HashSet<string> r2rCompositeRootSet)

19public ITaskItem[] RuntimePacks { get; set; } 20public ITaskItem[] Crossgen2Packs { get; set; } 22public ITaskItem[] TargetingPacks { get; set; } 29public ITaskItem CrossgenTool { get; set; } 31public ITaskItem Crossgen2Tool { get; set; } 41private ITaskItem _runtimePack; 125ITaskItem targetingPack = GetNETCoreAppTargetingPack(); 142ITaskItem crossgen2Pack = Crossgen2Packs?.FirstOrDefault(); 229private ITaskItem GetNETCoreAppRuntimePack() 234private ITaskItem GetNETCoreAppTargetingPack() 239private static ITaskItem GetNETCoreAppPack(ITaskItem[] packs, string metadataKey)

13public ITaskItem CrossgenTool { get; set; } 14public ITaskItem Crossgen2Tool { get; set; } 17public ITaskItem CompilationEntry { get; set; } 19public ITaskItem[] ImplementationAssemblyReferences { get; set; } 20public ITaskItem[] ReadyToRunCompositeBuildReferences { get; set; } 21public ITaskItem[] ReadyToRunCompositeBuildInput { get; set; } 22public ITaskItem[] ReadyToRunCompositeUnrootedBuildInput { get; set; } 26public ITaskItem[] Crossgen2PgoFiles { get; set; } 228foreach (var reference in (_createCompositeImage ? ReadyToRunCompositeBuildReferences : ImplementationAssemblyReferences)) 340foreach (var mibc in Crossgen2PgoFiles) 373foreach (var reference in ReadyToRunCompositeBuildInput) 380foreach (var unrooted in ReadyToRunCompositeUnrootedBuildInput)

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)

19public ITaskItem[] GroupedItems { get; set; } = Array.Empty<ITaskItem>(); 22public ITaskItem[] BatchIds { get; set; } = Array.Empty<ITaskItem>(); 31public ITaskItem[] TimedItems { get; set; } = Array.Empty<ITaskItem>(); 36foreach (var item in GroupedItems) 43var result = new List<ITaskItem>(); 44foreach (var batchId in BatchIds)

22public ITaskItem[] Items { get; set; } = Array.Empty<ITaskItem>(); 29public ITaskItem[] GroupedItems { get; set; } = Array.Empty<ITaskItem>(); 38var itemsWithSize = new List<(ITaskItem item, long size)>(); 39foreach (var item in Items) 51var result = new List<ITaskItem>(); 55var smallItems = new List<(ITaskItem item, long size)>(); 76var batchAssignments = new List<ITaskItem>[numBatches]; 78batchAssignments[i] = new List<ITaskItem>();

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

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

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)

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)

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

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

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

240if (kvp.item is ITaskItem taskItem) 257if (metadataContainer is ITaskItem taskItem)

33private readonly List<ITaskItem> _targetOutputs = new List<ITaskItem>(); 47public ITaskItem[] TargetOutputs => _targetOutputs.ToArray(); 101var singleProject = new ITaskItem[1];

72var firstItem = parameterValue[0] as ITaskItem; 187else if (parameterValue is ITaskItem item)

54private readonly List<ITaskItem> _targetOutputs = new List<ITaskItem>(); 113public ITaskItem[] Projects { get; set; } = null; 120public ITaskItem[] TargetOutputs => _targetOutputs.ToArray(); 298ITaskItem[] singleProject = null; 308singleProject = new ITaskItem[1]; 317ITaskItem project = Projects[i]; 420var projectsToBuildList = new List<ITaskItem>(); 529ITaskItem[] projects, 537List<ITaskItem> targetOutputs, 672IList<IDictionary<string, ITaskItem[]>> targetOutputsPerProject = result.TargetOutputsPerProject; 684if (targetOutputsPerProject[i].TryGetValue(targetName, out ITaskItem[] outputItemsFromTarget)) 686foreach (ITaskItem outputItemFromTarget in outputItemsFromTarget)

919ITaskItem taskItem = itemToModify;

1069foreach (var msbuildProject in msbuildTask.Projects)

307foreach (KeyValuePair<string, ITaskItem[]> output in result.TargetOutputsPerProject[i]) 980List<IDictionary<string, ITaskItem[]>> targetOutputsPerProject = null; 987targetOutputsPerProject = new List<IDictionary<string, ITaskItem[]>>(1); 988targetOutputsPerProject.Add(new Dictionary<string, ITaskItem[]>(StringComparer.OrdinalIgnoreCase)); 1149List<IDictionary<string, ITaskItem[]>> targetOutputsPerProject = null; 1164targetOutputsPerProject = new List<IDictionary<string, ITaskItem[]>>(1) 1166new Dictionary<string, ITaskItem[]>(StringComparer.OrdinalIgnoreCase) 1222targetOutputsPerProject = new List<IDictionary<string, ITaskItem[]>>(results.Length); 1228targetOutputsPerProject?.Add(new Dictionary<string, ITaskItem[]>(StringComparer.OrdinalIgnoreCase)); 1237ITaskItem[] clonedTaskItem = new ITaskItem[resultEntry.Value.Items.Length];

53ITaskItem[] Items { get; }

110public ITaskItem[] Items

523ITaskItem[] outputs = GetItemOutputs(parameter); 759private bool SetTaskItemParameter(TaskPropertyInfo parameter, ITaskItem item) 796if (parameterType != typeof(ITaskItem[])) 863private ITaskItem[] GetItemOutputs(TaskPropertyInfo parameter) 867if (!(outputs is ITaskItem[] taskItemOutputs)) 869taskItemOutputs = [(ITaskItem)outputs]; 968returnClass = new TaskFactoryWrapper(new IntrinsicTaskFactory(typeof(MSBuild)), new LoadedType(typeof(MSBuild), AssemblyLoadInfo.Create(taskExecutionHostAssembly.FullName, null), taskExecutionHostAssembly, typeof(ITaskItem)), _taskName, TaskHostParameters.Empty); 974returnClass = new TaskFactoryWrapper(new IntrinsicTaskFactory(typeof(CallTarget)), new LoadedType(typeof(CallTarget), AssemblyLoadInfo.Create(taskExecutionHostAssembly.FullName, null), taskExecutionHostAssembly, typeof(ITaskItem)), _taskName, TaskHostParameters.Empty); 1242if (parameterType == typeof(ITaskItem)) 1471private void GatherTaskItemOutputs(bool outputTargetIsItem, string outputTargetName, ITaskItem[] outputs, ElementLocation parameterLocation, TaskPropertyInfo parameter) 1481foreach (ITaskItem output in outputs) 1581foreach (ITaskItem output in outputs) 1822typeof(ITaskItem));

99/// in task parameters: <see cref="Framework.ITaskItem"/>, <see cref="Framework.ITaskItem"/>[], 131if (obj is ITaskItem taskItem)

299string ITaskItem.ItemSpec 323ICollection ITaskItem.MetadataNames 481string ITaskItem.GetMetadata(string metadataName) 503void ITaskItem.SetMetadata(string metadataName, string metadataValue) 526void ITaskItem.CopyMetadataTo(ITaskItem destinationItem) 537IDictionary ITaskItem.CloneCustomMetadata() 1490public void CopyMetadataTo(ITaskItem destinationItem) 1510public void CopyMetadataTo(ITaskItem destinationItem, bool addOriginalItemSpec)

1765paramType = Type.GetType(expandedType + "," + typeof(ITaskItem).GetTypeInfo().Assembly.FullName, false /* don't throw on error */, true /* case-insensitive */) ?? 1771Type.GetType(expandedType + "," + typeof(ITaskItem).GetTypeInfo().Assembly.FullName, false /* don't throw on error */, true /* case-insensitive */);

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

1526private ITaskItem ReadTaskItem() 1555ITaskItem item = ReadTaskItem(); 1574foreach (var item in items) 1601foreach (var item in items) 1617private IList<ITaskItem>? ReadTaskItemList() 1625var list = new ITaskItem[count]; 1629ITaskItem item = ReadTaskItem();

911else if (items is ICollection<ITaskItem> genericList) 934if (item is ITaskItem taskItem) 1051if (item is ITaskItem taskItem && !string.IsNullOrEmpty(taskItem.ItemSpec)) 1062private void Write(ITaskItem item, bool writeMetadata = true)

610ITaskItem taskItem => taskItem.ItemSpec, // ProjectItemInstance 893foreach (ITaskItem item in targetOutputs)

1111foreach (ITaskItem output in targetOutputs) 1124(targetOutputs as IEnumerable<ITaskItem>)?

131else if (typeof(ITaskItem[]).GetTypeInfo().IsAssignableFrom(wrappedParameterType.GetTypeInfo())) 134ITaskItem[] inputAsITaskItemArray = (ITaskItem[])wrappedParameter; 135ITaskItem[] taskItemArrayParameter = new ITaskItem[inputAsITaskItemArray.Length]; 177else if (typeof(ITaskItem).IsAssignableFrom(wrappedParameterType)) 180_wrappedParameter = new TaskParameterTaskItem((ITaskItem)wrappedParameter); 293ITaskItem[] wrappedItems = (ITaskItem[])_wrappedParameter; 296wrappedItems ??= new ITaskItem[length]; 570internal TaskParameterTaskItem(ITaskItem copyFrom) 772public void CopyMetadataTo(ITaskItem destinationItem)

21parameterType.GetTypeInfo().IsValueType || parameterType == typeof(string) || parameterType == typeof(ITaskItem); 30parameterType == typeof(ITaskItem[]); 39bool result = typeof(ITaskItem[]).GetTypeInfo().IsAssignableFrom(parameterType.GetTypeInfo()) || /* ITaskItem array or derived type, or */ 40typeof(ITaskItem).IsAssignableFrom(parameterType); /* ITaskItem or derived type */

521? new LoadedType(type, _assemblyLoadInfo, _loadedAssembly ?? type.Assembly, typeof(ITaskItem), loadedViaMetadataLoadContext: false) 579var taskItemType = context.LoadFromAssemblyPath(microsoftBuildFrameworkPath).GetType(typeof(ITaskItem).FullName);

148listValue[0]!.ShouldBeAssignableTo(typeof(ITaskItem)); 149listValue[1]!.ShouldBeAssignableTo(typeof(ITaskItem)); 150((ITaskItem)listValue[0]!).ItemSpec.ShouldBe("item1"); 151((ITaskItem)listValue[1]!).ItemSpec.ShouldBe("item2"); 178var array2 = new ITaskItem[] { item1, item2 };

162ITaskItem toItem = new Utilities.TaskItem(); 164((ITaskItem)fromItem).CopyMetadataTo(toItem); 322ITaskItem taskItem = (ITaskItem)item; 416ITaskItem taskItem = (ITaskItem)item;

214LoadedType comparisonType = new LoadedType(typeof(TaskToTestFactories), _loadInfo, typeof(TaskToTestFactories).GetTypeInfo().Assembly, typeof(ITaskItem));

450ITaskItem[] item = targetresult.Items;

22public ITaskItem[] Sources { get; set; }

13public ITaskItem[] InputItemsToPassThrough 19public ITaskItem[] InputItemsToCopy 26public ITaskItem[] PassedThroughOutputItems 33public ITaskItem[] CreatedOutputItems 40public ITaskItem[] CopiedOutputItems 57CopiedOutputItems = new ITaskItem[InputItemsToCopy.Length]; 64CreatedOutputItems = new ITaskItem[2];

1294ITaskItem[] projects = new ITaskItem[] 1616ITaskItem[] projects = new ITaskItem[] 1798ITaskItem[] projects = new ITaskItem[]

16public ITaskItem[] OutputItems 24OutputItems = new ITaskItem[1];

533private static bool AreItemsIdentical(IList<ITaskItem> a, IList<ITaskItem> b)

173ITaskItem[] item = targetresult.Items;

694List<ITaskItem> outputListB = [.. targetOutputsB as IEnumerable<ITaskItem> ]; 706List<ITaskItem> outputListB = [.. targetOutputsB as IEnumerable<ITaskItem> ]; 710List<ITaskItem> outputListC = [.. targetOutputsC as IEnumerable<ITaskItem> ];

232private ITaskItem _itemOutput; 237private ITaskItem[] _itemArrayOutput; 611public ITaskItem ItemParam 623public ITaskItem[] ItemArrayParam 1091public ITaskItem NullITaskItemOutput 1117public ITaskItem[] NullITaskItemArrayOutput 1143public ITaskItem ItemOutput 1156public ITaskItem[] ItemArrayOutput 1169public ITaskItem[] ItemArrayNullOutput

64private ITaskItem[] _oneItem; 69private ITaskItem[] _twoItems; 901ValidateOutputItems("StringArrayOutput", Array.Empty<ITaskItem>()); 912ValidateOutputItems("StringOutput", Array.Empty<ITaskItem>()); 921ValidateOutputItems("ItemArrayNullOutput", Array.Empty<ITaskItem>()); 932ValidateOutputItems("ArrayListOutput", Array.Empty<ITaskItem>()); 1258LoadedType loadedType = new LoadedType(typeof(TaskBuilderTestTask.TaskBuilderTestTaskFactory), loadInfo, typeof(TaskBuilderTestTask.TaskBuilderTestTaskFactory).Assembly, typeof(ITaskItem)); 1289_oneItem = new ITaskItem[] { new TaskItem(item) }; 1297_twoItems = new ITaskItem[] { new TaskItem(item), new TaskItem(item2) }; 1337private void ValidateOutputItems(string outputName, ITaskItem[] values) 1381ITaskItem actualItem = _parametersSetOnTask[parameterName] as ITaskItem; 1389private void ValidateTaskParameterItem(string parameterName, string value, ITaskItem expectedItem) 1395ITaskItem actualItem = _parametersSetOnTask[parameterName] as ITaskItem; 1408ITaskItem[] actualItems = _parametersSetOnTask[parameterName] as ITaskItem[]; 1416private void ValidateTaskParameterItems(string parameterName, string value, ITaskItem[] expectedItems) 1422ITaskItem[] actualItems = _parametersSetOnTask[parameterName] as ITaskItem[]; 1440ITaskItem[] actualItems = _parametersSetOnTask[parameterName] as ITaskItem[];

108Assert.NotNull(((ITaskItem[])targetOutputs["Build"])[0]); 110TaskItem targetOutputItem = ((ITaskItem[])targetOutputs["Build"])[0] as TaskItem;

258parameters2.Add("ItemArray", new ITaskItem[] { new TaskItem("DEF"), new TaskItem("GHI"), new TaskItem("JKL") }); 568TaskHostPacketHelpers.AreEqual((ITaskItem)config.TaskParameters["TaskItemValue"].WrappedParameter, (ITaskItem)deserializedConfig.TaskParameters["TaskItemValue"].WrappedParameter); 578parameters.Add("TaskItemArrayValue", new ITaskItem[] { new TaskItem("Foo"), new TaskItem("Baz") }); 616ITaskItem[] itemArray = (ITaskItem[])config.TaskParameters["TaskItemArrayValue"].WrappedParameter; 617ITaskItem[] deserializedItemArray = (ITaskItem[])deserializedConfig.TaskParameters["TaskItemArrayValue"].WrappedParameter; 724internal static void AreEqual(ITaskItem[] x, ITaskItem[] y) 750internal static void AreEqual(ITaskItem x, ITaskItem y)

85parameters2.Add("ItemArray", new ITaskItem[] { new TaskItem("DEF"), new TaskItem("GHI"), new TaskItem("JKL") }); 203TaskHostPacketHelpers.AreEqual((ITaskItem)complete.TaskOutputParameters["TaskItemValue"].WrappedParameter, (ITaskItem)deserializedComplete.TaskOutputParameters["TaskItemValue"].WrappedParameter); 213parameters.Add("TaskItemArrayValue", new ITaskItem[] { new TaskItem("Foo"), new TaskItem("Baz") }); 230ITaskItem[] itemArray = (ITaskItem[])complete.TaskOutputParameters["TaskItemArrayValue"].WrappedParameter; 231ITaskItem[] deserializedItemArray = (ITaskItem[])deserializedComplete.TaskOutputParameters["TaskItemArrayValue"].WrappedParameter;

1295type = typeof(ITaskItem[]).FullName; 1336type = typeof(ITaskItem).FullName; 1407type = typeof(ITaskItem).FullName; 1417type = typeof(ITaskItem[]).FullName; 1603expandedType + "," + typeof(ITaskItem).GetTypeInfo().Assembly.FullName, 1987type + "," + typeof(ITaskItem).GetTypeInfo().Assembly.FullName, 2178public void CopyMetadataTo(ITaskItem destinationItem)

20public ITaskItem[] AdditionalParameters { get; set; } 33public ITaskItem DictionaryTaskItemOutput { get; set; } 50ICollection ITaskItem.MetadataNames => throw new NotImplementedException(); 67public void CopyMetadataTo(ITaskItem destinationItem) => throw new NotImplementedException();

234if (item is ITaskItem taskItem)

229new List<ITaskItem> { new MyTaskItem() }); 236e => ToString(e.TargetOutputs.OfType<ITaskItem>())); 722var items = new ITaskItem[] 1254private string ToString(IEnumerable<ITaskItem> items) 1259private string ToString(ITaskItem i)

1324foreach (ITaskItem item in instance.Items)

597ITaskItem withMetaItem; 602ITaskItem noMetaItem = new TaskItem("NoMetaItem", pi.FullPath); 633ITaskItem withMetaItem; 638ITaskItem noMetaItem = new TaskItem("NoMetaItem", pi.FullPath); 675ITaskItem withMetaItem = null; 680ITaskItem noMetaItem = new TaskItem("NoMetaItem", pi.FullPath);

39private ITaskItem _taskItemParam; 40public ITaskItem TaskItemParam

1751internal ITaskItem[] GetTaskArrayFromItemList(IList<TaskItem> list) 1753ITaskItem[] items = new ITaskItem[list.Count];

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

23private ITaskItem _myITaskItemParam = null; 24private ITaskItem[] _myITaskItemArrayParam = null; 32private ITaskItem _myRequiredITaskItemParam = null; 33private ITaskItem[] _myRequiredITaskItemArrayParam = null; 113public ITaskItem MyITaskItemParam 122public ITaskItem[] MyITaskItemArrayParam 192public ITaskItem MyRequiredITaskItemParam 202public ITaskItem[] MyRequiredITaskItemArrayParam 221public ITaskItem[] NullITaskItemArrayOutputParameter 225ITaskItem[] myNullITaskItemArrayOutputParameter = null; 259public ITaskItem ITaskItemOutputParameter 263ITaskItem myITaskItem = null; 458public void CopyMetadataTo(ITaskItem destinationItem)

867var itemResult = targetResult.Items.First();

201ITaskItem foo = t.WrappedParameter as ITaskItem; 210ITaskItem foo2 = t2.WrappedParameter as ITaskItem; 229ITaskItem foo = t.WrappedParameter as ITaskItem; 240ITaskItem foo2 = t2.WrappedParameter as ITaskItem; 253TaskParameter t = new TaskParameter(new ITaskItem[] { new TaskItem("foo"), new TaskItem("bar") }); 257ITaskItem[] wrappedParameter = t.WrappedParameter as ITaskItem[]; 268ITaskItem[] wrappedParameter2 = t.WrappedParameter as ITaskItem[]; 286ITaskItem foo = t.WrappedParameter as ITaskItem; 295ITaskItem foo2 = t2.WrappedParameter as ITaskItem; 311ITaskItem foo = t.WrappedParameter as ITaskItem; 320ITaskItem foo2 = t2.WrappedParameter as ITaskItem; 331ITaskItem foo4 = t4.WrappedParameter as ITaskItem; 378ITaskItem foo = t.WrappedParameter as ITaskItem; 389ITaskItem foo2 = t2.WrappedParameter as ITaskItem; 411ITaskItem foo = t.WrappedParameter as ITaskItem; 422ITaskItem foo2 = t2.WrappedParameter as ITaskItem; 435ITaskItem foo4 = t4.WrappedParameter as ITaskItem; 509(t.WrappedParameter as ITaskItem).GetMetadata("RecursiveDir").ShouldBe(expectedRecursiveDir); 515(t2.WrappedParameter as ITaskItem).GetMetadata("RecursiveDir").ShouldBe(expectedRecursiveDir);

20public ITaskItem MinimalTaskItemOutput { get => new MinimalTaskItem(); } 43public void CopyMetadataTo(ITaskItem destinationItem) => throw new NotImplementedException();

15public class TaskItemComparer : IComparer<ITaskItem> 27public static IComparer<ITaskItem> Instance 39public int Compare(ITaskItem x, ITaskItem y)

25private List<IDictionary<string, ITaskItem[]>> targetOutputsPerProject; 30public BuildEngineResult(bool result, List<IDictionary<string, ITaskItem[]>> targetOutputsPerProject) 36this.targetOutputsPerProject = new List<IDictionary<string, ITaskItem[]>>(); 54public IList<IDictionary<string, ITaskItem[]>> TargetOutputsPerProject

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

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

83void CopyMetadataTo(ITaskItem destinationItem);

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

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) 73public void CopyMetadataTo(ITaskItem destinationItem)

211if (item is ITaskItem taskItem) 233private void WriteMetadata(BinaryWriter writer, ITaskItem taskItem)

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

26ITaskItem item, 58ITaskItem item,

25List<ITaskItem> outputs = new List<ITaskItem>();

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

289foreach (ITaskItem response in ResponseFiles) 342ITaskItem[]? references, 355foreach (ITaskItem reference in references)

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)

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

52public ITaskItem[]? CommandLineArgs 61return (ITaskItem[]?)_store[nameof(CommandLineArgs)]; 78public ITaskItem[]? Imports 87return (ITaskItem[]?)_store[nameof(Imports)]; 104public ITaskItem[]? References 113return (ITaskItem[]?)_store[nameof(References)]; 117public ITaskItem[]? ResponseFiles 126return (ITaskItem[]?)_store[nameof(ResponseFiles)]; 143public ITaskItem[]? ScriptResponseFiles 152return (ITaskItem[]?)_store[nameof(ScriptResponseFiles)]; 169public ITaskItem? Source 178return (ITaskItem?)_store[nameof(Source)]; 208foreach (var response in ResponseFiles) 226foreach (var scriptResponse in ScriptResponseFiles)

81public ITaskItem[]? AdditionalFiles 84get { return (ITaskItem[]?)_store[nameof(AdditionalFiles)]; } 87public ITaskItem[]? EmbeddedFiles 90get { return (ITaskItem[]?)_store[nameof(EmbeddedFiles)]; } 99public ITaskItem[]? Analyzers 102get { return (ITaskItem[]?)_store[nameof(Analyzers)]; } 127public ITaskItem[]? CommandLineArgs 130get { return (ITaskItem[]?)_store[nameof(CommandLineArgs)]; } 169public ITaskItem[]? AnalyzerConfigFiles 172get { return (ITaskItem[]?)_store[nameof(AnalyzerConfigFiles)]; } 232public ITaskItem[]? LinkResources 235get { return (ITaskItem[]?)_store[nameof(LinkResources)]; } 269public ITaskItem? OutputAssembly 272get { return (ITaskItem?)_store[nameof(OutputAssembly)]; } 276public ITaskItem? OutputRefAssembly 279get { return (ITaskItem?)_store[nameof(OutputRefAssembly)]; } 288public ITaskItem[]? PotentialAnalyzerConfigFiles 291get { return (ITaskItem[]?)_store[nameof(PotentialAnalyzerConfigFiles)]; } 312public ITaskItem[]? References 315get { return (ITaskItem[]?)_store[nameof(References)]; } 330public ITaskItem[]? Resources 333get { return (ITaskItem[]?)_store[nameof(Resources)]; } 342public ITaskItem[]? ResponseFiles 345get { return (ITaskItem[]?)_store[nameof(ResponseFiles)]; } 366public ITaskItem[]? Sources 377get { return (ITaskItem[]?)_store[nameof(Sources)]; } 967internal static void AddAnalyzersToCommandLine(CommandLineBuilderExtension commandLine, ITaskItem[]? analyzers) 976foreach (ITaskItem analyzer in analyzers) 989foreach (ITaskItem additionalFile in AdditionalFiles) 1008foreach (ITaskItem embeddedFile in EmbeddedFiles) 1022foreach (ITaskItem analyzerConfigFile in AnalyzerConfigFiles) 1094private void NormalizePaths(ITaskItem[]? taskItems) 1099foreach (var item in taskItems) 1114private string[]? GetTransformedSourcesForCommandLine(ITaskItem[]? sources) 1220foreach (ITaskItem reference in References)

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

45public ITaskItem[] SourceRoots { get; set; } 57public ITaskItem[]? MappedSourceRoots { get; private set; } 98var mappedSourceRoots = new List<ITaskItem>(); 99var rootByItemSpec = new Dictionary<string, ITaskItem>(); 100foreach (var sourceRoot in SourceRoots) 114if (rootByItemSpec.TryGetValue(sourceRoot.ItemSpec, out var existingRoot)) 136foreach (var root in mappedSourceRoots) 175foreach (var root in mappedSourceRoots) 210foreach (var root in mappedSourceRoots) 227private void ReportConflictingWellKnownMetadata(ITaskItem left, ITaskItem right)

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

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

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

289foreach (ITaskItem response in ResponseFiles) 342ITaskItem[]? references, 355foreach (ITaskItem reference in references)

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)

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

52public ITaskItem[]? CommandLineArgs 61return (ITaskItem[]?)_store[nameof(CommandLineArgs)]; 78public ITaskItem[]? Imports 87return (ITaskItem[]?)_store[nameof(Imports)]; 104public ITaskItem[]? References 113return (ITaskItem[]?)_store[nameof(References)]; 117public ITaskItem[]? ResponseFiles 126return (ITaskItem[]?)_store[nameof(ResponseFiles)]; 143public ITaskItem[]? ScriptResponseFiles 152return (ITaskItem[]?)_store[nameof(ScriptResponseFiles)]; 169public ITaskItem? Source 178return (ITaskItem?)_store[nameof(Source)]; 208foreach (var response in ResponseFiles) 226foreach (var scriptResponse in ScriptResponseFiles)

81public ITaskItem[]? AdditionalFiles 84get { return (ITaskItem[]?)_store[nameof(AdditionalFiles)]; } 87public ITaskItem[]? EmbeddedFiles 90get { return (ITaskItem[]?)_store[nameof(EmbeddedFiles)]; } 99public ITaskItem[]? Analyzers 102get { return (ITaskItem[]?)_store[nameof(Analyzers)]; } 127public ITaskItem[]? CommandLineArgs 130get { return (ITaskItem[]?)_store[nameof(CommandLineArgs)]; } 169public ITaskItem[]? AnalyzerConfigFiles 172get { return (ITaskItem[]?)_store[nameof(AnalyzerConfigFiles)]; } 232public ITaskItem[]? LinkResources 235get { return (ITaskItem[]?)_store[nameof(LinkResources)]; } 269public ITaskItem? OutputAssembly 272get { return (ITaskItem?)_store[nameof(OutputAssembly)]; } 276public ITaskItem? OutputRefAssembly 279get { return (ITaskItem?)_store[nameof(OutputRefAssembly)]; } 288public ITaskItem[]? PotentialAnalyzerConfigFiles 291get { return (ITaskItem[]?)_store[nameof(PotentialAnalyzerConfigFiles)]; } 312public ITaskItem[]? References 315get { return (ITaskItem[]?)_store[nameof(References)]; } 330public ITaskItem[]? Resources 333get { return (ITaskItem[]?)_store[nameof(Resources)]; } 342public ITaskItem[]? ResponseFiles 345get { return (ITaskItem[]?)_store[nameof(ResponseFiles)]; } 366public ITaskItem[]? Sources 377get { return (ITaskItem[]?)_store[nameof(Sources)]; } 967internal static void AddAnalyzersToCommandLine(CommandLineBuilderExtension commandLine, ITaskItem[]? analyzers) 976foreach (ITaskItem analyzer in analyzers) 989foreach (ITaskItem additionalFile in AdditionalFiles) 1008foreach (ITaskItem embeddedFile in EmbeddedFiles) 1022foreach (ITaskItem analyzerConfigFile in AnalyzerConfigFiles) 1094private void NormalizePaths(ITaskItem[]? taskItems) 1099foreach (var item in taskItems) 1114private string[]? GetTransformedSourcesForCommandLine(ITaskItem[]? sources) 1220foreach (ITaskItem reference in References)

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

45public ITaskItem[] SourceRoots { get; set; } 57public ITaskItem[]? MappedSourceRoots { get; private set; } 98var mappedSourceRoots = new List<ITaskItem>(); 99var rootByItemSpec = new Dictionary<string, ITaskItem>(); 100foreach (var sourceRoot in SourceRoots) 114if (rootByItemSpec.TryGetValue(sourceRoot.ItemSpec, out var existingRoot)) 136foreach (var root in mappedSourceRoots) 175foreach (var root in mappedSourceRoots) 210foreach (var root in mappedSourceRoots) 227private void ReportConflictingWellKnownMetadata(ITaskItem left, ITaskItem right)

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

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

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

37ITaskItem property1 = MSBuildUtil.CreateTaskItem("Property1", new Dictionary<string, string> { { "Value", "abc123" } }); 38ITaskItem property2 = MSBuildUtil.CreateTaskItem("Property2", new Dictionary<string, string> { { "Value", "def456" } }); 57ITaskItem item1 = MSBuildUtil.CreateTaskItem("c:/file1.cs", new Dictionary<string, string> { { "ItemType", "Compile" }, { "MetadataName", "ToRetrieve" }, { "ToRetrieve", "abc123" } }); 77ITaskItem item1 = MSBuildUtil.CreateTaskItem("c:/file1.cs", new Dictionary<string, string> { { "ItemType", "Compile" }, { "MetadataName", "ToRetrieve" }, { "ToRetrieve", "abc123" } }); 78ITaskItem item2 = MSBuildUtil.CreateTaskItem("c:/file2.cs", new Dictionary<string, string> { { "ItemType", "Compile" }, { "MetadataName", "ToRetrieve" }, { "ToRetrieve", "def456" } }); 79ITaskItem item3 = MSBuildUtil.CreateTaskItem("c:/file3.cs", new Dictionary<string, string> { { "ItemType", "AdditionalFiles" }, { "MetadataName", "ToRetrieve" }, { "ToRetrieve", "ghi789" } }); 106ITaskItem item1 = MSBuildUtil.CreateTaskItem("c:/{f*i?le1}.cs", new Dictionary<string, string> { { "ItemType", "Compile" }, { "MetadataName", "ToRetrieve" }, { "ToRetrieve", "abc123" } }); 107ITaskItem item2 = MSBuildUtil.CreateTaskItem("c:/f,ile#2.cs", new Dictionary<string, string> { { "ItemType", "Compile" }, { "MetadataName", "ToRetrieve" }, { "ToRetrieve", "def456" } }); 108ITaskItem item3 = MSBuildUtil.CreateTaskItem("c:/f;i!le[3].cs", new Dictionary<string, string> { { "ItemType", "Compile" }, { "MetadataName", "ToRetrieve" }, { "ToRetrieve", "ghi789" } }); 134ITaskItem item1 = MSBuildUtil.CreateTaskItem("c:/file1.cs", new Dictionary<string, string> { { "ItemType", "Compile" }, { "MetadataName", "ToRetrieve" }, { "ToRetrieve", "abc123" } }); 135ITaskItem item2 = MSBuildUtil.CreateTaskItem("c:/file1.cs", new Dictionary<string, string> { { "ItemType", "AdditionalFile" }, { "MetadataName", "ToRetrieve" }, { "ToRetrieve", "def456" } }); 156ITaskItem item1 = MSBuildUtil.CreateTaskItem("c:/file1.cs", new Dictionary<string, string> { { "ItemType", "Compile" }, { "MetadataName", "ToRetrieve" } }); 176ITaskItem item1 = MSBuildUtil.CreateTaskItem("c:/file1.cs", new Dictionary<string, string> { }); 177ITaskItem item2 = MSBuildUtil.CreateTaskItem("c:/file1.cs", new Dictionary<string, string> { { "ItemType", "Compile" } }); 178ITaskItem item3 = MSBuildUtil.CreateTaskItem("c:/file1.cs", new Dictionary<string, string> { { "MetadataName", "ToRetrieve" } }); 197ITaskItem item1 = MSBuildUtil.CreateTaskItem("c:/file1.cs", new Dictionary<string, string> { { "ItemType", "Compile" }, { "MetadataName", "ToRetrieve" }, { "ToRetrieve", "abc123" } }); 198ITaskItem item2 = MSBuildUtil.CreateTaskItem("c:/file2.cs", new Dictionary<string, string> { { "ItemType", "Compile" }, { "MetadataName", "ToRetrieve" }, { "ToRetrieve", "def456" } }); 199ITaskItem item3 = MSBuildUtil.CreateTaskItem("c:/file3.cs", new Dictionary<string, string> { { "ItemType", "AdditionalFiles" }, { "MetadataName", "ToRetrieve" }, { "ToRetrieve", "ghi789" } }); 200ITaskItem item4 = MSBuildUtil.CreateTaskItem("c:/file1.cs", new Dictionary<string, string> { { "ItemType", "AdditionalFiles" }, { "MetadataName", "ToRetrieve" }, { "ToRetrieve", "jkl012" } }); 202ITaskItem property1 = MSBuildUtil.CreateTaskItem("Property1", new Dictionary<string, string> { { "Value", "abc123" } }); 203ITaskItem property2 = MSBuildUtil.CreateTaskItem("Property2", new Dictionary<string, string> { { "Value", "def456" } }); 339ITaskItem item1 = MSBuildUtil.CreateTaskItem("c:\\file1.cs", new Dictionary<string, string> { { "ItemType", "Compile" }, { "MetadataName", "ToRetrieve" }, { "ToRetrieve", "abc123" } }); 359ITaskItem property1 = MSBuildUtil.CreateTaskItem("Property1", new Dictionary<string, string> { { "Value", "abc123" } }); 360ITaskItem property2 = MSBuildUtil.CreateTaskItem("Property2", new Dictionary<string, string> { { "Value", "def456" } });

18private string InspectSourceRoot(ITaskItem sourceRoot)

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

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

57public ITaskItem? ApplicationManifest { get; set; }

452public ITaskItem OutputAssembly { get; set; } 478public ITaskItem[] SourceModules { get; set; } 480public ITaskItem[] EmbedResources { get; set; } 482public ITaskItem[] LinkResources { get; set; } 510ITaskItem OutputAssembly { get; set; } 523ITaskItem[] SourceModules { get; set; } 524ITaskItem[] EmbedResources { get; set; } 525ITaskItem[] LinkResources { get; set; }

34public ITaskItem[] SuggestedRedirects { get; set; } 39public ITaskItem AppConfigFile { get; set; } 50public ITaskItem OutputAppConfigFile { get; set; } 328private XDocument LoadAppConfig(ITaskItem appConfigItem) 364foreach (var redirect in SuggestedRedirects)

57ITaskItem[] copyLocalFiles = new ITaskItem[_numCopyLocalFiles]; 65static void FindCopyLocalFiles(ITaskItem[] copyLocalFiles, ref int i, ITaskItem[] items) 67foreach (ITaskItem taskItem in items)

27private Dictionary<string, ITaskItem> _sourceItems = new Dictionary<string, ITaskItem>(StringComparer.OrdinalIgnoreCase); 82private ITaskItem _primarySourceItem; 150internal void AddSourceItem(ITaskItem sourceItem) 163internal void AddSourceItems(IEnumerable<ITaskItem> sourceItemsToAdd) 165foreach (ITaskItem sourceItem in sourceItemsToAdd) 174internal void PropagateSourceItems(ITaskItem sourceItem) 189internal Dictionary<string, ITaskItem>.ValueCollection GetSourceItems() 378foreach (ITaskItem item in GetSourceItems()) 617internal ITaskItem PrimarySourceItem 881ITaskItem sourceItem, 1014foreach (ITaskItem item in _sourceItems.Values)

89private readonly Dictionary<string, ITaskItem> _resolvedSDKReferences; 177internal delegate void LogExclusionReason(bool displayPrimaryReferenceMessage, AssemblyNameExtension assemblyName, Reference reference, ITaskItem referenceItem, string targetedFramework); 280ITaskItem[] resolvedSDKItems, 347_resolvedSDKReferences = new Dictionary<string, ITaskItem>(StringComparer.OrdinalIgnoreCase); 352foreach (ITaskItem resolvedSDK in resolvedSDKItems) 533ITaskItem[] referenceAssemblyFiles, 534ITaskItem[] referenceAssemblyNames, 541foreach (ITaskItem i in referenceAssemblyFiles) 551foreach (ITaskItem n in referenceAssemblyNames) 569ITaskItem referenceAssemblyName) 855private static AssemblyNameExtension GetAssemblyNameFromItemMetadata(ITaskItem item) 882private void SetPrimaryFileItem(ITaskItem referenceAssemblyFile) 1435ICollection<ITaskItem> dependees = assemblyReference.GetSourceItems(); 1508ICollection<ITaskItem> dependees = assemblyReference.GetSourceItems(); 1509foreach (ITaskItem dependee in dependees) 1636ITaskItem[] referenceAssemblyFiles, 1637ITaskItem[] referenceAssemblyNames, 2595out ITaskItem[] primaryFiles, 2596out ITaskItem[] dependencyFiles, 2597out ITaskItem[] relatedFiles, 2598out ITaskItem[] satelliteFiles, 2599out ITaskItem[] serializationAssemblyFiles, 2600out ITaskItem[] scatterFiles, 2601out ITaskItem[] copyLocalFiles) 2603var primaryItems = new List<ITaskItem>(); 2604var dependencyItems = new List<ITaskItem>(); 2605var relatedItems = new List<ITaskItem>(); 2606var satelliteItems = new List<ITaskItem>(); 2607var serializationAssemblyItems = new List<ITaskItem>(); 2608var scatterItems = new List<ITaskItem>(); 2609var copyLocalItems = new List<ITaskItem>(); 2644ITaskItem referenceItem = SetItemMetadata(relatedItems, satelliteItems, serializationAssemblyItems, scatterItems, assemblyName.FullName, reference, assemblyName); 2685private ITaskItem SetItemMetadata(List<ITaskItem> relatedItems, List<ITaskItem> satelliteItems, List<ITaskItem> serializationAssemblyItems, List<ITaskItem> scatterItems, string fusionName, Reference reference, AssemblyNameExtension assemblyName) 2706foreach (ITaskItem sourceItem in reference.GetSourceItems()) 2848static void AddRelatedItem(List<ITaskItem> relatedItems, TaskItem relatedItemBase, string relatedFilePath) 2981private static void FindCopyLocalItems(ITaskItem[] items, List<ITaskItem> copyLocalItems) 2983foreach (ITaskItem i in items) 3002internal void LogHigherVersionUnresolve(bool displayPrimaryReferenceMessage, AssemblyNameExtension assemblyName, Reference reference, ITaskItem referenceItem, string targetedFramework) 3017internal void LogHigherVersionUnresolveDueToAttribute(bool displayPrimaryReferenceMessage, AssemblyNameExtension assemblyName, Reference reference, ITaskItem referenceItem, string targetedFramework) 3032internal void LogAnotherFrameworkUnResolve(bool displayPrimaryReferenceMessage, AssemblyNameExtension assemblyName, Reference reference, ITaskItem referenceItem, string targetedFramework) 3047internal void LogProfileExclusionUnresolve(bool displayPrimaryReferenceMessage, AssemblyNameExtension assemblyName, Reference reference, ITaskItem referenceItem, string targetedFramework)

173private ITaskItem[] _assemblyFiles = Array.Empty<TaskItem>(); 174private ITaskItem[] _assemblyNames = Array.Empty<TaskItem>(); 175private ITaskItem[] _installedAssemblyTables = Array.Empty<TaskItem>(); 176private ITaskItem[] _installedAssemblySubsetTables = Array.Empty<TaskItem>(); 177private ITaskItem[] _fullFrameworkAssemblyTables = Array.Empty<TaskItem>(); 178private ITaskItem[] _resolvedSDKReferences = Array.Empty<TaskItem>(); 193private ITaskItem[] _resolvedFiles = Array.Empty<TaskItem>(); 194private ITaskItem[] _resolvedDependencyFiles = Array.Empty<TaskItem>(); 195private ITaskItem[] _relatedFiles = Array.Empty<TaskItem>(); 196private ITaskItem[] _satelliteFiles = Array.Empty<TaskItem>(); 197private ITaskItem[] _serializationAssemblyFiles = Array.Empty<TaskItem>(); 198private ITaskItem[] _scatterFiles = Array.Empty<TaskItem>(); 199private ITaskItem[] _copyLocalFiles = Array.Empty<TaskItem>(); 200private ITaskItem[] _suggestedRedirects = Array.Empty<TaskItem>(); 201private List<ITaskItem> _unresolvedConflicts = new List<ITaskItem>(); 279public ITaskItem[] AssemblyFiles 387public ITaskItem[] Assemblies 410public ITaskItem[] ResolvedSDKReferences 466public ITaskItem[] InstalledAssemblyTables 488public ITaskItem[] InstalledAssemblySubsetTables 519public ITaskItem[] FullFrameworkAssemblyTables 603public ITaskItem[] AssemblyInformationCachePaths { get; set; } 942public ITaskItem[] ResolvedFiles 962public ITaskItem[] ResolvedDependencyFiles 975public ITaskItem[] RelatedFiles 989public ITaskItem[] SatelliteFiles 1001public ITaskItem[] SerializationAssemblyFiles 1012public ITaskItem[] ScatterFiles 1024public ITaskItem[] CopyLocalFiles 1040public ITaskItem[] SuggestedRedirects 1049private List<ITaskItem> _filesWritten = new List<ITaskItem>(); 1055public ITaskItem[] FilesWritten 1086public ITaskItem[] UnresolvedAssemblyConflicts 1411foreach (ITaskItem sourceItem in dependeeReference.GetSourceItems()) 1516foreach (ITaskItem item in Assemblies) 1528foreach (ITaskItem item in AssemblyFiles) 1558foreach (ITaskItem installedAssemblyTable in InstalledAssemblyTables) 1610foreach (ITaskItem installedAssemblySubsetTable in InstalledAssemblySubsetTables) 1647foreach (ITaskItem profileTable in FullFrameworkAssemblyTables) 1659private void LogAttribute(ITaskItem item, string metadataName) 1921ICollection<ITaskItem> dependees = reference.GetSourceItems(); 1922foreach (ITaskItem dependee in dependees) 2649foreach (ITaskItem item in _resolvedFiles) 2815foreach (ITaskItem item in FullFrameworkAssemblyTables) 2871internal static string GenerateSubSetName(string[] frameworkSubSetNames, ITaskItem[] installedSubSetNames) 2887foreach (ITaskItem subsetItems in installedSubSetNames) 3039var holdSuggestedRedirects = new List<ITaskItem>(); 3058ITaskItem suggestedRedirect = new TaskItem(); 3075private AssemblyTableInfo[] GetInstalledAssemblyTableInfo(bool ignoreInstalledAssemblyTables, ITaskItem[] assemblyTables, GetListPath GetAssemblyListPaths, string[] targetFrameworkDirectories) 3093foreach (ITaskItem installedAssemblyTable in assemblyTables) 3162var assembliesLeft = new List<ITaskItem>(); 3163foreach (ITaskItem assembly in Assemblies)

16internal sealed class TaskItemSpecFilenameComparer : IComparer<ITaskItem> 18internal static readonly IComparer<ITaskItem> GenericComparer = new TaskItemSpecFilenameComparer(); 42ITaskItem i1 = (ITaskItem)o1; 43ITaskItem i2 = (ITaskItem)o2; 48public int Compare(ITaskItem x, ITaskItem y)

44public ITaskItem[] Files { get; set; } = Array.Empty<ITaskItem>(); 70public ITaskItem[] AssignedFiles { get; private set; } 84public ITaskItem[] AssignedFilesWithCulture { get; private set; } 95public ITaskItem[] AssignedFilesWithNoCulture { get; private set; } 124public ITaskItem[] CultureNeutralAssignedFiles { get; private set; } 136AssignedFiles = new ITaskItem[Files.Length]; 137CultureNeutralAssignedFiles = new ITaskItem[Files.Length]; 138var cultureList = new List<ITaskItem>(); 139var noCultureList = new List<ITaskItem>();

22public ITaskItem[] Items { get; set; } 28public ITaskItem[] OutputItems { get; set; } 39var outputItems = new List<ITaskItem>(); 43foreach (ITaskItem item in Items) 57ITaskItem outputItem = new TaskItem(item);

142public ITaskItem[] AssignedProjects { get; set; } 150public ITaskItem[] UnassignedProjects { get; set; } 181var resolvedReferences = new List<ITaskItem>(ProjectReferences.GetLength(0)); 182var unresolvedReferences = new List<ITaskItem>(ProjectReferences.GetLength(0)); 196foreach (ITaskItem projectRef in ProjectReferences) 198bool resolveSuccess = ResolveProject(projectRef, out ITaskItem resolvedReference); 260internal bool ResolveProject(ITaskItem projectRef, out ITaskItem resolvedProjectWithConfiguration) 332internal static void SetBuildInProjectAndReferenceOutputAssemblyMetadata(bool onlyReferenceAndBuildProjectsEnabledInSolutionConfiguration, ITaskItem resolvedProjectWithConfiguration, XmlElement projectConfigurationElement)

38public ITaskItem[] Files { get; set; } = Array.Empty<ITaskItem>(); 45public ITaskItem[] AssignedFiles { get; private set; } 55AssignedFiles = new ITaskItem[Files.Length];

23private readonly List<ITaskItem> _targetOutputs = new List<ITaskItem>(); 40public ITaskItem[] TargetOutputs => _targetOutputs.ToArray(); 76var singleProject = new List<ITaskItem>(1) { null };

21private ITaskItem[] _paths; 34public ITaskItem[] Paths 50public ITaskItem[] CombinedPaths { get; set; } 63var combinedPathsList = new List<ITaskItem>(); 65foreach (ITaskItem path in Paths)

25public ITaskItem[] PropertiesAndValues { get; set; } 53foreach (ITaskItem item in PropertiesAndValues)

25public ITaskItem[] XmlElements { get; set; } 39foreach (var item in XmlElements)

173ITaskItem[] parameters, 232ITaskItem[] parameters, 243foreach (ITaskItem parameter in parameters)

20private ITaskItem[] _paths; 26public ITaskItem[] Paths 41public ITaskItem[] AbsolutePaths { get; set; } 49var absolutePathsList = new List<ITaskItem>(); 51foreach (ITaskItem path in Paths)

129public ITaskItem[] SourceFiles { get; set; } 131public ITaskItem[] SourceFolders { get; set; } 133public ITaskItem DestinationFolder { get; set; } 179public ITaskItem[] DestinationFiles { get; set; } 185public ITaskItem[] CopiedFiles { get; private set; } 440DestinationFiles = Array.Empty<ITaskItem>(); 441CopiedFiles = Array.Empty<ITaskItem>(); 466List<ITaskItem> destinationFilesSuccessfullyCopied; 495out List<ITaskItem> destinationFilesSuccessfullyCopied) 498destinationFilesSuccessfullyCopied = new List<ITaskItem>(DestinationFiles.Length); 593out List<ITaskItem> destinationFilesSuccessfullyCopied) 622ITaskItem destItem = DestinationFiles[i]; 654destinationFilesSuccessfullyCopied = new List<ITaskItem>(DestinationFiles.Length); 677ITaskItem sourceItem = SourceFiles[fileIndex]; 678ITaskItem destItem = DestinationFiles[fileIndex]; 823DestinationFiles = new ITaskItem[SourceFiles.Length]; 850var sourceFiles = SourceFiles != null ? new List<ITaskItem>(SourceFiles) : new List<ITaskItem>(); 851var destinationFiles = DestinationFiles != null ? new List<ITaskItem>(DestinationFiles) : new List<ITaskItem>(); 853foreach (ITaskItem sourceFolder in SourceFolders) 907DestinationFiles = Array.Empty<ITaskItem>();

42if (fileName != null && itemSpecToTaskitem.TryGetValue(fileName, out ITaskItem item))

22public ITaskItem[] Include { get; set; } 24public ITaskItem[] Exclude { get; set; } 59Include = Array.Empty<ITaskItem>(); 90List<ITaskItem> outputItems = CreateOutputItems(metadataTable, excludeItems); 101private List<ITaskItem> CreateOutputItems(Dictionary<string, string> metadataTable, Dictionary<string, string> excludeItems) 103var outputItems = new List<ITaskItem>(); 105foreach (ITaskItem i in Include) 111ITaskItem newItem = i; 141private (ITaskItem[]? Element, bool NoLoggedErrors) TryExpandWildcards(ITaskItem[]? expand, string attributeType) 153var expanded = new List<ITaskItem>(); 154foreach (ITaskItem i in expand) 217private static Dictionary<string, string> GetUniqueItems(ITaskItem[] items) 223foreach (ITaskItem item in items)

30private ITaskItem[] _resourceFiles; 36protected Dictionary<string, ITaskItem> itemSpecToTaskitem = new Dictionary<string, ITaskItem>(StringComparer.OrdinalIgnoreCase); 52public ITaskItem[] ResourceFiles 81public ITaskItem[] ManifestResourceNames { get; private set; } 87public ITaskItem[] ResourceFilesWithManifestResourceNames { get; set; } 136ManifestResourceNames = new ITaskItem[ResourceFiles.Length]; 137ResourceFilesWithManifestResourceNames = new ITaskItem[ResourceFiles.Length]; 154foreach (ITaskItem resourceFile in ResourceFiles)

41if (fileName != null && itemSpecToTaskitem.TryGetValue(fileName, out ITaskItem item))

25private ITaskItem[] _files; 29public ITaskItem[] Files 46public ITaskItem[] DeletedFiles { get; set; } 110var deletedFilesList = new List<ITaskItem>(); 113foreach (ITaskItem file in Files) 149ITaskItem deletedFile = new TaskItem(file);

29public ITaskItem DestinationFileName { get; set; } 32/// Gets or sets a <see cref="ITaskItem"/> that specifies the destination folder to download the file to. 35public ITaskItem DestinationFolder { get; set; } 38/// Gets or sets a <see cref="ITaskItem"/> that contains details about the downloaded file. 41public ITaskItem DownloadedFile { get; set; }

50private ITaskItem[] _outputs; 55private readonly List<ITaskItem> _nonEmptyOutput = new List<ITaskItem>(); 177public ITaskItem[] Outputs 179get => _outputs ?? Array.Empty<ITaskItem>(); 189public ITaskItem[] ConsoleOutput => !ConsoleToMSBuild ? Array.Empty<ITaskItem>() : _nonEmptyOutput.ToArray();

39public ITaskItem[] Files { get; set; } 66public ITaskItem[] Items { get; set; } 90var file = Files[index];

25public ITaskItem File { get; set; } 34public ITaskItem[] Lines { get; set; } = Array.Empty<ITaskItem>(); 51var nonEmptyLines = new List<ITaskItem>();

32public ITaskItem File { get; set; } 37public ITaskItem[] Lines { get; set; } 82foreach (ITaskItem line in Lines)

22private ITaskItem[] _primaryList; 23private ITaskItem[] _secondaryList; 36public ITaskItem[] PrimaryList 50public ITaskItem[] SecondaryList 70public ITaskItem AppConfigFile { get; set; } 121private bool IsMatchingItem(ITaskItem item, bool matchWholeItemSpec)

21private ITaskItem[] _list; 27public ITaskItem[] List 47public ITaskItem ItemFound { get; set; } 76foreach (ITaskItem item in List) 104private bool IsMatchingItem(StringComparison comparison, ITaskItem item)

56public ITaskItem[] ProjectReferences { get; set; } 74public ITaskItem[] InvalidReferences { get; private set; } 85var invalidReferences = new List<ITaskItem>(); 91foreach (ITaskItem item in ProjectReferences)

30private ITaskItem[] _dependencies; 31private ITaskItem[] _files; 32private ITaskItem[] _isolatedComReferences; 34private ITaskItem[] _fileAssociations; 39public ITaskItem ConfigFile { get; set; } 41public ITaskItem[] Dependencies 49public ITaskItem[] FileAssociations 63public ITaskItem[] Files 71public ITaskItem IconFile { get; set; } 73public ITaskItem[] IsolatedComReferences 97public ITaskItem TrustInfoFile { get; set; } 147foreach (ITaskItem item in Dependencies) 163foreach (ITaskItem item in Files) 229foreach (ITaskItem item in IsolatedComReferences) 252foreach (ITaskItem item in FileAssociations)

202public ITaskItem[] BootstrapperItems { get; set; } 243ITaskItem[] BootstrapperItems { get; set; }

29public ITaskItem EntryPoint { get; set; } 40public ITaskItem OutputEntryPoint { get; set; }

54public ITaskItem EntryPoint { get; set; } 56public ITaskItem InputManifest { get; set; } 63public ITaskItem OutputManifest { get; set; } 84protected internal AssemblyReference AddAssemblyNameFromItem(ITaskItem item, AssemblyReferenceType referenceType) 101protected internal AssemblyReference AddAssemblyFromItem(ITaskItem item) 150protected internal AssemblyReference AddEntryPointFromItem(ITaskItem item, AssemblyReferenceType referenceType) 158protected internal FileReference AddFileFromItem(ITaskItem item) 333protected internal FileReference FindFileFromItem(ITaskItem item) 362private AssemblyType GetItemAssemblyType(ITaskItem item) 383private static bool IsEmbedInteropEnabledForAssembly(ITaskItem item) 393private DependencyType GetItemDependencyType(ITaskItem item) 533private void SetItemAttributes(ITaskItem item, BaseReference file)

65private ITaskItem[] _sources = null; 72private ITaskItem[] _references = null; 75private ITaskItem[] _additionalInputs = null; 78private ITaskItem _stateFile = null; 81private ITaskItem[] _outputResources = null; 152private ITaskItem[] _excludedInputPaths; 165private List<ITaskItem> _satelliteInputs; 177public ITaskItem[] Sources 196public ITaskItem[] References 214public ITaskItem[] AdditionalInputs 223public ITaskItem StateFile 237public ITaskItem[] OutputResources 250public ITaskItem[] FilesWritten 254return (ITaskItem[])_filesWritten.ToArray(typeof(ITaskItem)); 394public ITaskItem[] ExcludedInputPaths 439public ITaskItem[] TLogReadFiles 443return Array.Empty<ITaskItem>(); 451public ITaskItem[] TLogWriteFiles 455return Array.Empty<ITaskItem>(); 565private void LogResgenCommandLine(List<ITaskItem> inputFiles, List<ITaskItem> outputFiles) 637foreach (ITaskItem reference in References) 665_satelliteInputs = new List<ITaskItem>(); 667List<ITaskItem> newSources = new List<ITaskItem>(); 668foreach (ITaskItem item in Sources) 711List<ITaskItem> inputsToProcess; 712List<ITaskItem> outputsToProcess; 713List<ITaskItem> cachedOutputFiles; // For incremental builds, this is the set of already-existing, up to date files. 759foreach (ITaskItem source in _sources) 855ITaskItem[] outputResources = process.ExtractedResWFiles.ToArray(); 867OutputResources = new ITaskItem[outputResources.Length + cachedOutputFiles.Count]; 1118private bool GenerateResourcesUsingResGen(List<ITaskItem> inputsToProcess, List<ITaskItem> outputsToProcess) 1370private void GetResourcesToProcess(out List<ITaskItem> inputsToProcess, out List<ITaskItem> outputsToProcess, out List<ITaskItem> cachedOutputFiles) 1377inputsToProcess = new List<ITaskItem>(); 1378outputsToProcess = new List<ITaskItem>(); 1379cachedOutputFiles = new List<ITaskItem>(); 1444private void AppendCachedOutputTaskItems(ResGenDependencies.PortableLibraryFile library, List<ITaskItem> cachedOutputFiles) 1448ITaskItem item = new TaskItem(outputFileName); 1465private bool ContainsDuplicates(IList<ITaskItem> originalList) 1468foreach (ITaskItem item in originalList) 1622private void GetStronglyTypedResourceToProcess(ref List<ITaskItem> inputsToProcess, ref List<ITaskItem> outputsToProcess) 1710foreach (ITaskItem input in inputs) 2057OutputResources = new ITaskItem[Sources.Length]; 2105ITaskItem[] temp = new ITaskItem[OutputResources.Length - _unsuccessfullyCreatedOutFiles.Count]; 2136foreach (ITaskItem item in this.OutputResources) 2285private ITaskItem[] _assemblyFiles; 2296private List<ITaskItem> _inFiles; 2308private List<ITaskItem> _outFiles; 2317internal List<ITaskItem> ExtractedResWFiles 2323_extractedResWFiles = new List<ITaskItem>(); 2328private List<ITaskItem> _extractedResWFiles; 2383ITaskItem[] assemblyFilesList, 2384List<ITaskItem> inputs, 2385List<ITaskItem> satelliteInputs, 2386List<ITaskItem> outputs, 2521ITaskItem assemblyFile = _assemblyFiles[i]; 2700ITaskItem newOutputFile = new TaskItem(escapedOutputFile);

119public ITaskItem BaseManifest { get; set; } 127public ITaskItem[] ApplicationDependencies { get; set; } 130public ITaskItem TrustInfoFile { get; set; } 141ITaskItem BaseManifest { get; set; } 145ITaskItem[] ApplicationDependencies { get; set; } 146ITaskItem TrustInfoFile { get; set; }

28private ITaskItem[] _assemblyFiles; 31public ITaskItem[] AssemblyFiles 42public ITaskItem[] Assemblies { get; set; } 65var list = new List<ITaskItem>(); 66foreach (ITaskItem item in AssemblyFiles) 84ITaskItem newItem = new TaskItem(an.FullName);

24public ITaskItem[] AnnotatedProjects { get; set; } 43public ITaskItem[]? AssignedProjectsWithPlatform { get; set; } 47AnnotatedProjects = Array.Empty<ITaskItem>(); 55AssignedProjectsWithPlatform = new ITaskItem[AnnotatedProjects.Length];

117public ITaskItem[] InstalledSDKs { get; set; } 155var outputItems = new List<ITaskItem>();

34private ITaskItem[] _resolvedSDKReferences = Array.Empty<ITaskItem>(); 105public ITaskItem[] ResolvedSDKReferences 167public ITaskItem[] References { get; private set; } = Array.Empty<ITaskItem>(); 173public ITaskItem[] RedistFiles { get; private set; } = Array.Empty<ITaskItem>(); 179public ITaskItem[] CopyLocalFiles { get; private set; } = Array.Empty<ITaskItem>(); 251IEnumerable<ITaskItem> filteredResolvedSDKReferences = ResolvedSDKReferences.Where( 256foreach (ITaskItem resolvedSDKReference in filteredResolvedSDKReferences) 301private void FindRedistFiles(ITaskItem resolvedSDKReference, string sdkIdentity, string targetedConfiguration, string targetedArchitecture) 360private void FindReferences(ITaskItem resolvedSDKReference, string sdkIdentity, string sdkName, string rootDirectory, string targetedConfiguration, string targetedArchitecture) 449var resolvedReferenceAssemblies = new List<ITaskItem>(); 450var copyLocalReferenceAssemblies = new List<ITaskItem>(); 451var redistReferenceItems = new List<ITaskItem>(); 568private void GatherReferenceAssemblies(HashSet<ResolvedReferenceAssembly> resolvedFiles, ITaskItem sdkReference, string path, SDKInfo info) 614private void GatherRedistFiles(HashSet<ResolvedRedistFile> resolvedRedistFiles, ITaskItem sdkReference, string redistFilePath, SDKInfo info) 656private void PopulateReferencesForSDK(IEnumerable<ITaskItem> sdks) 661foreach (ITaskItem sdk in sdks) 695private string[] GetReferencePathsFromManifest(ITaskItem sdk) 729public ResolvedReferenceAssembly(ITaskItem sdkReferenceItem, string assemblyLocation) 755public ITaskItem SDKReferenceItem { get; } 808public ResolvedRedistFile(ITaskItem sdkReferenceItem, string redistFile, string targetPath, string targetRoot) 834public ITaskItem SDKReferenceItem { get; }

44public ITaskItem[] ItemsToHash { get; set; }

20bool SetAnalyzers(ITaskItem[] analyzers); 22bool SetAdditionalFiles(ITaskItem[] additionalFiles);

45bool SetLinkResources(ITaskItem[] linkResources); 54bool SetReferences(ITaskItem[] references); 55bool SetResources(ITaskItem[] resources); 56bool SetResponseFiles(ITaskItem[] responseFiles); 57bool SetSources(ITaskItem[] sources);

22private readonly Dictionary<string, ITaskItem> _resolvedSDKs; 27public InstalledSDKResolver(Dictionary<string, ITaskItem> resolvedSDKs, string searchPathElement, GetAssemblyName getAssemblyName, FileExists fileExists, GetAssemblyRuntimeVersion getRuntimeVersion, Version targetedRuntimeVesion) 54if (_resolvedSDKs.TryGetValue(sdkName, out ITaskItem resolvedSDK))

39bool SetImports(ITaskItem[] importsList); 42bool SetLinkResources(ITaskItem[] linkResources); 54bool SetReferences(ITaskItem[] references); 56bool SetResources(ITaskItem[] resources); 57bool SetResponseFiles(ITaskItem[] responseFiles); 60bool SetSources(ITaskItem[] sources);

26public ITaskItem[] Sources 29get => (ITaskItem[])Bag[nameof(Sources)]; 36public ITaskItem OutputLicense 39get => (ITaskItem)Bag[nameof(OutputLicense)]; 46public ITaskItem LicenseTarget 49get => (ITaskItem)Bag[nameof(LicenseTarget)]; 66public ITaskItem[] ReferencedAssemblies 69get => (ITaskItem[])Bag[nameof(ReferencedAssemblies)]; 148foreach (ITaskItem item in Sources) 157foreach (ITaskItem item in ReferencedAssemblies)

30public ITaskItem Path { get; set; } 35public ITaskItem[] Files { get; set; } = Array.Empty<ITaskItem>(); 46public ITaskItem[] InPath { get; set; } 52public ITaskItem[] OutOfPath { get; set; } 59var inPathList = new List<ITaskItem>(); 60var outOfPathList = new List<ITaskItem>(); 94foreach (ITaskItem item in Files)

22public ITaskItem[] Inputs { get; set; } = Array.Empty<ITaskItem>(); 28public ITaskItem[] Filtered { get; set; } 44Filtered = Array.Empty<ITaskItem>(); 50var filteredList = new List<ITaskItem>(Inputs.Length); 52foreach (ITaskItem item in Inputs)

21public ITaskItem[] Directories 33public ITaskItem[] DirectoriesCreated { get; private set; } 40private ITaskItem[] _directories; 49var items = new List<ITaskItem>(); 52foreach (ITaskItem directory in Directories)

400private static ITaskItem[] RemoveDuplicateItems(ITaskItem[] items) 412var list = new Dictionary<string, ITaskItem>(); 413foreach (ITaskItem item in items) 440public static ITaskItem[] SortItems(ITaskItem[] items) 442ITaskItem[] outputItems = RemoveDuplicateItems(items); 599if (!(obj1 is ITaskItem) || !(obj2 is ITaskItem)) 604ITaskItem item1 = obj1 as ITaskItem; 605ITaskItem item2 = obj2 as ITaskItem;

44public ITaskItem[] SourceFiles { get; set; } 49public ITaskItem DestinationFolder { get; set; } 62public ITaskItem[] DestinationFiles { get; set; } 68public ITaskItem[] MovedFiles { get; private set; } 99DestinationFiles = Array.Empty<ITaskItem>(); 100MovedFiles = Array.Empty<ITaskItem>(); 128DestinationFiles = new ITaskItem[SourceFiles.Length]; 143DestinationFiles = Array.Empty<ITaskItem>(); 153var destinationFilesSuccessfullyMoved = new List<ITaskItem>();

53private readonly List<ITaskItem> _targetOutputs = new List<ITaskItem>(); 93public ITaskItem[] Projects { get; set; } 100public ITaskItem[] TargetOutputs => _targetOutputs.ToArray(); 258List<ITaskItem> singleProject = null; 268singleProject = new List<ITaskItem>(1) { null }; 277ITaskItem project = Projects[i]; 378var projectsToBuildInParallel = new List<ITaskItem>(); 481List<ITaskItem> projects, 489List<ITaskItem> targetOutputs, 615IList<IDictionary<string, ITaskItem[]>> targetOutputsPerProject = result.TargetOutputsPerProject; 627if (targetOutputsPerProject[i].TryGetValue(targetName, out ITaskItem[] outputItemsFromTarget)) 629foreach (ITaskItem outputItemFromTarget in outputItemsFromTarget)

380public ITaskItem[] Assemblies { get; set; } 383public ITaskItem[] TypeLibFiles { get; set; } 387public ITaskItem AssemblyListFile { get; set; } 398ITaskItem[] Assemblies { get; set; } 399ITaskItem[] TypeLibFiles { get; set; } 401ITaskItem AssemblyListFile { get; set; }

25private ITaskItem[] _directories; 31public ITaskItem[] Directories 46public ITaskItem[] RemovedDirectories { get; set; } 56var removedDirectoriesList = new List<ITaskItem>(); 58foreach (ITaskItem directory in Directories)

60public ITaskItem[] ReferencedAssemblies { get; set; } 62public ITaskItem[] Assemblies { get; set; } 64public ITaskItem DeploymentManifestEntryPoint { get; set; } 66public ITaskItem EntryPoint { get; set; } 68public ITaskItem[] Files { get; set; } 135private static bool HasExcludedFileOrSP1File(ITaskItem[] candidateFiles) 139foreach (ITaskItem file in candidateFiles) 155private static bool IsExcludedFileOrSP1File(ITaskItem candidateFile)

37ITaskItem[] TypeLibNames { get; set; } 42ITaskItem[] TypeLibFiles { get; set; } 65ITaskItem[] ResolvedAssemblyReferences { get; set; } 109ITaskItem[] ResolvedFiles { get; set; } 115ITaskItem[] ResolvedModules { get; set; } 153public ITaskItem[] TypeLibNames { get; set; } 155public ITaskItem[] TypeLibFiles { get; set; } 163public ITaskItem[] ResolvedAssemblyReferences { get; set; } 180public ITaskItem[] ResolvedFiles { get; set; } 183public ITaskItem[] ResolvedModules { get; set; }

44private ITaskItem[] _extraFiles; 45private ITaskItem[] _files; 46private ITaskItem[] _managedAssemblies; 47private ITaskItem[] _nativeAssemblies; 48private ITaskItem[] _publishFiles; 49private ITaskItem[] _satelliteAssemblies; 57private Dictionary<string, ITaskItem> _runtimePackAssets; 64public ITaskItem DeploymentManifestEntryPoint { get; set; } 66public ITaskItem EntryPoint { get; set; } 68public ITaskItem[] ExtraFiles 74public ITaskItem[] Files 80public ITaskItem[] ManagedAssemblies 86public ITaskItem[] NativeAssemblies 93public ITaskItem[] RuntimePackAssets { get; set; } 102public ITaskItem[] OutputAssemblies { get; set; } 105public ITaskItem OutputDeploymentManifestEntryPoint { get; set; } 108public ITaskItem OutputEntryPoint { get; set; } 111public ITaskItem[] OutputFiles { get; set; } 113public ITaskItem[] PublishFiles 119public ITaskItem[] SatelliteAssemblies 263private static ITaskItem CreateAssemblyItem(ITaskItem item, string group, string targetPath, string includeHash) 265ITaskItem outputItem = new TaskItem(item.ItemSpec); 286private ITaskItem CreateFileItem(ITaskItem item, string group, string targetPath, string includeHash, bool isDataFile) 288ITaskItem outputItem = new TaskItem(item.ItemSpec); 327private static ITaskItem CreatePrerequisiteItem(ITaskItem item) 329ITaskItem outputItem = new TaskItem(item.ItemSpec); 335private static bool GetItemCopyLocal(ITaskItem item) 347private static CultureInfo GetItemCulture(ITaskItem item) 361private static string GetItemTargetPath(ITaskItem item) 385private void GetOutputAssemblies(List<PublishInfo> publishInfos, List<ITaskItem> assemblyList) 392foreach (ITaskItem item in _managedAssemblies) 427foreach (ITaskItem item in _nativeAssemblies) 497private ITaskItem[] GetOutputAssembliesAndSatellites(List<PublishInfo> assemblyPublishInfos, List<PublishInfo> satellitePublishInfos) 499var assemblyList = new List<ITaskItem>(); 505private ITaskItem[] GetOutputFiles(List<PublishInfo> publishInfos, IEnumerable<ITaskItem> outputAssemblies) 507var fileList = new List<ITaskItem>(); 516foreach (ITaskItem item in Files) 524outputAssembliesMap.TryGetValue(key, out var assembly); 555foreach (ITaskItem item in ExtraFiles) 604private void GetOutputSatellites(List<PublishInfo> publishInfos, List<ITaskItem> assemblyList) 610foreach (ITaskItem item in _satelliteAssemblies) 667private ITaskItem GetOutputEntryPoint(ITaskItem entryPoint, List<PublishInfo> manifestEntryPointList) 717foreach (ITaskItem item in PublishFiles) 743private bool IsFiltered(ITaskItem item) 808public PublishInfo(ITaskItem item) 822public readonly ITaskItem item; 825public MapEntry(ITaskItem item, bool includedByDefault) 852public void Add(ITaskItem item) 912public bool ContainsItem(ITaskItem item) 922public void Add(ITaskItem item) 961public void Add(ITaskItem item, bool includedByDefault)

361public ITaskItem[] NativeReferences { get; set; } 366public ITaskItem[] ContainingReferenceFiles { get; set; } 369public ITaskItem[] ContainedPrerequisiteAssemblies { get; set; } 372public ITaskItem[] ContainedComComponents { get; set; } 375public ITaskItem[] ContainedTypeLibraries { get; set; } 378public ITaskItem[] ContainedLooseTlbFiles { get; set; } 381public ITaskItem[] ContainedLooseEtcFiles { get; set; } 392ITaskItem[] NativeReferences { get; set; } 394ITaskItem[] ContainingReferenceFiles { get; set; } 395ITaskItem[] ContainedPrerequisiteAssemblies { get; set; } 396ITaskItem[] ContainedComComponents { get; set; } 397ITaskItem[] ContainedTypeLibraries { get; set; } 398ITaskItem[] ContainedLooseTlbFiles { get; set; } 399ITaskItem[] ContainedLooseEtcFiles { get; set; }

51public ITaskItem[] ResolvedOutputPaths { get; set; } 59public ITaskItem[] UnresolvedProjectReferences { get; set; } 93var resolvedPaths = new List<ITaskItem>(ProjectReferences.GetLength(0)); 94var unresolvedReferences = new List<ITaskItem>(ProjectReferences.GetLength(0)); 98foreach (ITaskItem projectRef in ProjectReferences) 102bool resolveSuccess = ResolveProject(projectRef, out ITaskItem resolvedPath); 166internal bool ResolveProject(ITaskItem projectRef, out ITaskItem resolvedPath)

29public ITaskItem[] ProjectReferences 39private ITaskItem[] _projectReferences; 56internal bool VerifyReferenceAttributes(ITaskItem reference, out string missingAttribute) 80internal bool VerifyProjectReferenceItems(ITaskItem[] references, bool treatAsError) 84foreach (ITaskItem reference in references) 113protected string GetProjectItem(ITaskItem projectRef) 123protected XmlElement GetProjectElement(ITaskItem projectRef) 165List<ITaskItem> updatedProjectReferenceList = new List<ITaskItem>(_projectReferences); 196_projectReferences = new ITaskItem[updatedProjectReferenceList.Count];

86private ITaskItem[] _sdkReferences = Array.Empty<ITaskItem>(); 91private ITaskItem[] _installedSDKs = Array.Empty<ITaskItem>(); 122public ITaskItem[] SDKReferences 138public ITaskItem[] InstalledSDKs 200public ITaskItem[] References { get; set; } 206public ITaskItem[] DisallowedSDKDependencies { get; set; } 212public ITaskItem[] RuntimeReferenceOnlySDKDependencies { get; set; } 249public ITaskItem[] ResolvedSDKReferences { get; private set; } 278ResolvedSDKReferences = Array.Empty<ITaskItem>(); 290foreach (ITaskItem runtimeDependencyOnlyItem in RuntimeReferenceOnlySDKDependencies) 300var sdkItems = new Dictionary<string, ITaskItem>(InstalledSDKs.Length, StringComparer.OrdinalIgnoreCase); 302foreach (ITaskItem installedsdk in InstalledSDKs) 318foreach (ITaskItem referenceItem in References) 342foreach (ITaskItem referenceItem in SDKReferences) 562internal SDKReference ParseSDKReference(ITaskItem referenceItem) 731public SDKReference(ITaskItem taskItem, string sdkName, string sdkVersion) 754public ITaskItem ReferenceItem { get; } 799public ITaskItem ResolvedItem { get; set; } 912public void Resolve(Dictionary<string, ITaskItem> sdks, string targetConfiguration, string targetArchitecture, HashSet<string> sdkNamesOnReferenceItems, bool treatErrorsAsWarnings, bool prefer32Bit, string identifierTargetPlatform, Version versionTargetPlatform, string projectName, bool enableMaxPlatformVersionEmptyWarning) 914if (sdks.TryGetValue(SDKName, out ITaskItem sdk)) 1000private static string GetItemMetadataTrimmed(ITaskItem item, string metadataName)

561internal bool TryResolveAssemblyReferences(TaskLoggingHelper log, RoslynCodeTaskFactoryTaskInfo taskInfo, out ITaskItem[] items) 616items = hasInvalidReference ? null : resolvedAssemblyReferences.Select(i => (ITaskItem)new TaskItem(i)).ToArray(); 725if (!TryResolveAssemblyReferences(_log, taskInfo, out ITaskItem[] references))

83public ITaskItem OutputAssembly { get; set; } 87public ITaskItem[] References { get; set; } 89public ITaskItem[] Sources { get; set; } 107foreach (ITaskItem reference in References)

15public ITaskItem[] Projects { get; set; } = Array.Empty<ITaskItem>(); 18public ITaskItem[] UpdatedProjects { get; set; } = Array.Empty<ITaskItem>();

51ITaskItem[] SerializationAssembly { get; set; } 99public ITaskItem[] SerializationAssembly { get; set; }

36public ITaskItem SigningTarget { get; set; }

563internal static SystemState DeserializePrecomputedCaches(ITaskItem[] stateFiles, TaskLoggingHelper log, FileExists fileExists) 569foreach (ITaskItem stateFile in stateFiles)

131else if (typeof(ITaskItem[]).GetTypeInfo().IsAssignableFrom(wrappedParameterType.GetTypeInfo())) 134ITaskItem[] inputAsITaskItemArray = (ITaskItem[])wrappedParameter; 135ITaskItem[] taskItemArrayParameter = new ITaskItem[inputAsITaskItemArray.Length]; 177else if (typeof(ITaskItem).IsAssignableFrom(wrappedParameterType)) 180_wrappedParameter = new TaskParameterTaskItem((ITaskItem)wrappedParameter); 293ITaskItem[] wrappedItems = (ITaskItem[])_wrappedParameter; 296wrappedItems ??= new ITaskItem[length]; 570internal TaskParameterTaskItem(ITaskItem copyFrom) 772public void CopyMetadataTo(ITaskItem destinationItem)

21parameterType.GetTypeInfo().IsValueType || parameterType == typeof(string) || parameterType == typeof(ITaskItem); 30parameterType == typeof(ITaskItem[]); 39bool result = typeof(ITaskItem[]).GetTypeInfo().IsAssignableFrom(parameterType.GetTypeInfo()) || /* ITaskItem array or derived type, or */ 40typeof(ITaskItem).IsAssignableFrom(parameterType); /* ITaskItem or derived type */

44public ITaskItem[] Files { get; set; } 50public ITaskItem[] TouchedFiles { get; set; } 93var touchedItems = new List<ITaskItem>(); 96foreach (ITaskItem file in Files)

308public ITaskItem[] Assemblies { get; set; } 310public ITaskItem[] TypeLibFiles { get; set; } 312public ITaskItem AssemblyListFile { get; set; } 323ITaskItem[] Assemblies { get; set; } 324ITaskItem[] TypeLibFiles { get; set; } 325ITaskItem AssemblyListFile { get; set; }

46/// Gets or sets a <see cref="ITaskItem"/> with a destination folder path to unzip the files to. 49public ITaskItem DestinationFolder { get; set; } 62/// Gets or sets an array of <see cref="ITaskItem"/> objects containing the paths to .zip archive files to unzip. 65public ITaskItem[] SourceFiles { get; set; } 112foreach (ITaskItem sourceFile in SourceFiles.TakeWhile(i => !_cancellationToken.IsCancellationRequested))

59public ITaskItem ApplicationManifest { get; set; } 61public ITaskItem InputManifest { get; set; } 64public ITaskItem OutputManifest { get; set; } 77ITaskItem ApplicationManifest { get; set; } 78ITaskItem InputManifest { get; set; } 79ITaskItem OutputManifest { get; set; }

296public ITaskItem[] References { get; set; } 331ITaskItem[] References { get; set; }

61public ITaskItem[] AssemblyAttributes { get; set; } 67public ITaskItem OutputDirectory { get; set; } 77public ITaskItem OutputFile { get; set; } 198foreach (ITaskItem attributeItem in AssemblyAttributes)

33public ITaskItem XmlInputPath { get; set; } 50public ITaskItem[] Result { get; private set; } 154Result = new ITaskItem[peekValues.Count];

33public ITaskItem XmlInputPath { get; set; } 44public ITaskItem Value { get; set; }

37private ITaskItem[] _outputPaths; 45public ITaskItem[] XmlInputPaths { get; set; } 55public ITaskItem XslInputPath { get; set; } 70public ITaskItem XslCompiledDllPath { get; set; } 76public ITaskItem[] OutputPaths

27/// Gets or sets a <see cref="ITaskItem"/> containing the full path to the destination file to create. 30public ITaskItem DestinationFile { get; set; } = null!; 38/// Gets or sets a <see cref="ITaskItem"/> containing the full path to the source directory to create a zip archive from. 41public ITaskItem SourceDirectory { get; set; } = null!;

61ITaskItem[] copyLocalFiles = [

2952protected static bool ContainsItem(ITaskItem[] items, string spec) 2954foreach (ITaskItem item in items) 3002t.InstalledAssemblyTables = new ITaskItem[] { new TaskItem(redistListPath) }; 3035ITaskItem[] loadModeResolvedFiles = Array.Empty<TaskItem>(); 3038loadModeResolvedFiles = (ITaskItem[])t.ResolvedFiles.Clone(); 3131internal void ExecuteRAROnItemsAndRedist(ResolveAssemblyReference t, MockEngine e, ITaskItem[] items, string redistString, bool consistencyCheck) 3139internal void ExecuteRAROnItemsAndRedist(ResolveAssemblyReference t, MockEngine e, ITaskItem[] items, string redistString, bool consistencyCheck, List<string> additionalSearchPaths)

50t.Assemblies = new ITaskItem[] 95t.Assemblies = new ITaskItem[] { 145t.Assemblies = new ITaskItem[] { 184t.Assemblies = new ITaskItem[] 227t.Assemblies = new ITaskItem[] 280t.Assemblies = new ITaskItem[] 319t.Assemblies = new ITaskItem[] 358t.Assemblies = new ITaskItem[] 398t.Assemblies = new ITaskItem[] 441t.Assemblies = new ITaskItem[]

24ITaskItem i = new TaskItem("MyResource.fr.resx"); 25t.Files = new ITaskItem[] { i }; 43ITaskItem i = new TaskItem("MyResource.fr.resx"); 45t.Files = new ITaskItem[] { i }; 65ITaskItem i = new TaskItem("MyResource.fr.resx"); 67t.Files = new ITaskItem[] { i }; 86ITaskItem i = new TaskItem("MyResource.fr.resx"); 88t.Files = new ITaskItem[] { i }; 109ITaskItem i = new TaskItem("MyResource.resx"); 110t.Files = new ITaskItem[] { i }; 128ITaskItem i = new TaskItem("MyResource"); 129t.Files = new ITaskItem[] { i }; 148ITaskItem i = new TaskItem("MyResource..resx"); 149t.Files = new ITaskItem[] { i }; 169ITaskItem i = new TaskItem("MyResource.fr.resx"); 171t.Files = new ITaskItem[] { i }; 194ITaskItem i = new TaskItem($"MyResource.{culture}.resx"); 195t.Files = new ITaskItem[] { i }; 216ITaskItem i = new TaskItem($"MyResource.{culture}.resx"); 217t.Files = new ITaskItem[] { i }; 234ITaskItem i = new TaskItem($"MyResource.{culture}.resx"); 235t.Files = new ITaskItem[] { i }; 251ITaskItem i = new TaskItem($"MyResource.{culture}.resx"); 252t.Files = new ITaskItem[] { i }; 271ITaskItem i = new TaskItem("MyResource.fr.resx"); 273t.Files = new ITaskItem[] { i }; 292ITaskItem i = new TaskItem("MyResource.fr.resx"); 294t.Files = new ITaskItem[] { i };

45ITaskItem item = GetParentedTaskItem(_defaultItemSpec); 51Items = new ITaskItem[] { new TaskItem(item) } 65ITaskItem item = GetParentedTaskItem(_defaultItemSpec); 70Items = new ITaskItem[] { new TaskItem(item) } 91ITaskItem item1 = GetParentedTaskItem(itemSpec: "|||"); 92ITaskItem item2 = GetParentedTaskItem(_defaultItemSpec); 97Items = new ITaskItem[] { new TaskItem(item1), new TaskItem(item2) } 116ITaskItem item = GetParentedTaskItem(_defaultItemSpec, Path.Combine("SubFolder2", "SubSubFolder", "a.cs")); 121Items = new ITaskItem[] { new TaskItem(item) } 136var item = GetParentedTaskItem(NativeMethodsShared.IsUnixLike 143Items = new ITaskItem[] { new TaskItem(item) } 158ITaskItem item = new TaskItem(Path.Combine("SubFolder", "a.cs")); 163Items = new ITaskItem[] { item } 174private ITaskItem GetParentedTaskItem(string itemSpec, string linkMetadata = null) 190ITaskItem item = pi.AddItem("Foo", itemSpec, metadata);

23t.Files = new ITaskItem[] 39t.Files = new ITaskItem[] 54t.Files = new ITaskItem[] 76t.Files = new ITaskItem[] 102t.Files = new ITaskItem[]

183List<ITaskItem> targetOutputsTaskItems = new List<ITaskItem>();

31t.Paths = new ITaskItem[] { new TaskItem(path1), new TaskItem(path2) }; 60? new ITaskItem[] { new TaskItem(path1), new TaskItem(path2), new TaskItem(path3) } 61: new ITaskItem[] { new TaskItem(path1), new TaskItem(path2) }; 81t.Paths = new ITaskItem[] { new TaskItem(path1), new TaskItem(path2) }; 109? new ITaskItem[] { new TaskItem(path1), new TaskItem(path2), new TaskItem(path3) } 110: new ITaskItem[] { new TaskItem(path1), new TaskItem(path2) }; 129t.Paths = new ITaskItem[] { new TaskItem(@"jkl\mno.txt") }; 137t.Paths = new ITaskItem[] { new TaskItem("jkl/mno.txt") }; 158t.Paths = new ITaskItem[] { new TaskItem(@"jkl\mno.txt"), new TaskItem(@"c:\abc\def\ghi.txt") }; 177t.Paths = System.Array.Empty<ITaskItem>(); 194t.Paths = new ITaskItem[] { new TaskItem("") }; 212t.Paths = new ITaskItem[] { new TaskItem("ghi.txt"), new TaskItem("|.txt"), new TaskItem("jkl.txt") };

25var items = new ITaskItem[]

43new ITaskItem[] { i }, 57new ITaskItem[] { i }, 87new ITaskItem[] { i, j },

35t.Paths = new ITaskItem[] { new TaskItem(@"file.temp") }; 67t.Paths = new ITaskItem[] { new TaskItem(@"file%253A.temp") }; 97t.Paths = new ITaskItem[] { new TaskItem(fileName) }; 120t.Paths = new ITaskItem[] { new TaskItem("RandomFileThatDoesntExist.txt") };

43new object[] { Array.Empty<ITaskItem>() }, 147SourceFiles = new ITaskItem[] { new TaskItem(sourceFile.Path) }, 148DestinationFiles = new ITaskItem[] { new TaskItem("destination.txt") }, 173SourceFiles = new ITaskItem[] { new TaskItem(sourceFile.Path) }, 217SourceFolders = new ITaskItem[] { new TaskItem(s0Folder.Path), new TaskItem(s1Folder.Path) }, 274SourceFiles = new ITaskItem[] { new TaskItem(sourceFile.Path) }, 275SourceFolders = new ITaskItem[] { new TaskItem(sourceFolder.Path) }, 289public void CopyWithEmptySourceFiles(ITaskItem[] sourceFiles) 314public void CopyWithEmptySourceFolders(ITaskItem[] sourceFolders) 339public void CopyWithNoDestination(ITaskItem[] destinationFiles) 350SourceFiles = new ITaskItem[] { new TaskItem(sourceFile.Path) }, 375SourceFiles = new ITaskItem[] { new TaskItem(sourceFile.Path) }, 376DestinationFiles = new ITaskItem[] { new TaskItem("destination.txt") }, 400SourceFiles = new ITaskItem[] { new TaskItem(sourceFile.Path) }, 401SourceFolders = new ITaskItem[] { new TaskItem(sourceFolder.Path) }, 402DestinationFiles = new ITaskItem[] { new TaskItem("destination0.txt"), new TaskItem("destination1.txt") }, 424SourceFiles = new ITaskItem[] { new TaskItem(sourceFile.Path) }, 425DestinationFiles = new ITaskItem[] { new TaskItem("destination0.txt"), new TaskItem("destination1.txt") }, 450SourceFiles = new ITaskItem[] { new TaskItem(sourceFile.Path) }, 451DestinationFiles = new ITaskItem[] { new TaskItem("destination.txt") }, 477SourceFiles = new ITaskItem[] { new TaskItem(sourceFile.Path) }, 478DestinationFiles = new ITaskItem[] { new TaskItem("destination.txt") }, 505ITaskItem f = new TaskItem(file); 506ITaskItem[] sourceFiles = { f }; 507ITaskItem[] destinationFiles = { f }; 553ITaskItem sourceItem = new TaskItem(source); 554ITaskItem destinationItem = new TaskItem(destination); 555ITaskItem[] sourceFiles = { sourceItem }; 556ITaskItem[] destinationFiles = { destinationItem }; 614ITaskItem sourceItem = new TaskItem(source); 615ITaskItem destinationItem = new TaskItem(destination); 616ITaskItem[] sourceFiles = { sourceItem }; 617ITaskItem[] destinationFiles = { destinationItem }; 667ITaskItem sourceItem = new TaskItem(source); 668ITaskItem destinationItem = new TaskItem(destination); 669ITaskItem[] sourceFiles = { sourceItem }; 670ITaskItem[] destinationFiles = { destinationItem }; 725ITaskItem sourceItem = new TaskItem(source); 726ITaskItem destinationItem = new TaskItem(destination); 727ITaskItem[] sourceFiles = { sourceItem }; 728ITaskItem[] destinationFiles = { destinationItem }; 793ITaskItem sourceItem = new TaskItem(source); 794ITaskItem destinationItem = new TaskItem(destination); 795ITaskItem[] sourceFiles = { sourceItem }; 796ITaskItem[] destinationFiles = { destinationItem }; 860ITaskItem sourceItem = new TaskItem(source); 861ITaskItem destinationItem = new TaskItem(destination); 862ITaskItem[] sourceFiles = { sourceItem }; 863ITaskItem[] destinationFiles = { destinationItem }; 927ITaskItem sourceItem = new TaskItem(source); 928ITaskItem destinationItem = new TaskItem(destination); 929ITaskItem[] sourceFiles = { sourceItem }; 930ITaskItem[] destinationFiles = { destinationItem }; 1002ITaskItem sourceItem1 = new TaskItem(source1); 1003ITaskItem sourceItem2 = new TaskItem(source2); 1004ITaskItem[] sourceFiles = new ITaskItem[] { sourceItem1, sourceItem2 }; 1070ITaskItem[] sourceFiles = { new TaskItem(sourceFile) }; 1071ITaskItem[] destinationFiles = { new TaskItem(destinationFile) }; 1205ITaskItem[] sourceFiles = { new TaskItem(sourceFile) }; 1206ITaskItem[] destinationFiles = { new TaskItem(destinationFile) }; 1246ITaskItem[] sourceFiles = { new TaskItem(sourceFile) }; 1247ITaskItem[] destinationFiles = { new TaskItem(destinationFile) }; 1292ITaskItem[] sourceFiles = { new TaskItem(sourceFile) }; 1293ITaskItem[] destinationFiles = { new TaskItem(destinationFile) }; 1340ITaskItem[] sourceFiles = { new TaskItem(sourceFile) }; 1341ITaskItem[] destinationFiles = { new TaskItem(destinationFile) }; 1387ITaskItem[] sourceFiles = { new TaskItem(sourceFile) }; 1396DestinationFiles = new ITaskItem[] { new TaskItem(destinationFile) }, 1515ITaskItem[] sourceFiles = { new TaskItem(sourceFile) }; 1562ITaskItem[] sourceFiles = { new TaskItem(sourceFile) }; 1563ITaskItem[] destinationFiles = { new TaskItem(destinationFile) }; 1631ITaskItem i1 = new TaskItem(inFile1); 1636ITaskItem o1 = new TaskItem(validOutFile); 1710SourceFiles = new ITaskItem[] { new TaskItem(file) }, 1711DestinationFiles = new ITaskItem[] { new TaskItem(file) }, 1730SourceFiles = new ITaskItem[] { new TaskItem(file) }, 1731DestinationFiles = new ITaskItem[] { new TaskItem(file) }, 1783SourceFiles = new ITaskItem[] { new TaskItem(file) }, 1784DestinationFiles = new ITaskItem[] { new TaskItem(filename.ToLowerInvariant()) }, 1838SourceFiles = new ITaskItem[] { new TaskItem(file), new TaskItem(invalidFile) }, 1839DestinationFiles = new ITaskItem[] { new TaskItem(file), new TaskItem(dest2) }, 1892ITaskItem[] sourceFiles = { new TaskItem(sourceFile) }; 1966ITaskItem[] sourceFiles = { new TaskItem(sourceFileEscaped) }; 2016ITaskItem[] sourceFiles = 2024foreach (ITaskItem item in sourceFiles) 2074ITaskItem[] sourceFiles = 2083foreach (ITaskItem item in sourceFiles) 2091ITaskItem[] destFiles = 2177SourceFiles = new ITaskItem[] { new TaskItem(inFile1), new TaskItem(inFile2) }, 2178DestinationFiles = new ITaskItem[] { new TaskItem(outFile1) }, 2218ITaskItem[] sourceFiles = { new TaskItem(sourceFile) }; 2219ITaskItem[] destinationFiles = { new TaskItem(destinationFile) }; 2257ITaskItem[] sourceFiles = { new TaskItem(sourceFile) }; 2258ITaskItem[] destinationFiles = { new TaskItem(destinationFile) }; 2292SourceFiles = new ITaskItem[] { new TaskItem("foo | bar") }, 2317SourceFiles = new ITaskItem[] { new TaskItem("foo") }, 2342SourceFiles = new ITaskItem[] { new TaskItem("c:\\source") }, 2343DestinationFiles = new ITaskItem[] { new TaskItem("c:\\destination") }, 2364SourceFiles = new ITaskItem[] { new TaskItem("c:\\source") }, 2365DestinationFiles = new ITaskItem[] { new TaskItem("c:\\destination") }, 2390SourceFiles = new ITaskItem[] { new TaskItem("c:\\source") }, 2391DestinationFiles = new ITaskItem[] { new TaskItem("c:\\destination") }, 2460SourceFiles = new ITaskItem[] { new TaskItem("c:\\source") }, 2461DestinationFiles = new ITaskItem[] { new TaskItem("c:\\destination") }, 2488SourceFiles = new ITaskItem[] { new TaskItem("c:\\source"), new TaskItem("c:\\source2") }, 2489DestinationFiles = new ITaskItem[] { new TaskItem("c:\\destination"), new TaskItem("c:\\destination2") }, 2523SourceFiles = new ITaskItem[] { new TaskItem("c:\\source") }, 2524DestinationFiles = new ITaskItem[] { new TaskItem("c:\\destination") }, 2553SourceFiles = new ITaskItem[] { new TaskItem("c:\\source") }, 2554DestinationFiles = new ITaskItem[] { new TaskItem("c:\\destination") }, 2589SourceFiles = new ITaskItem[] { new TaskItem(source) }, 2590DestinationFiles = new ITaskItem[] { new TaskItem(existing) }, 2614ITaskItem[] sourceFiles = { new TaskItem(sourceFile) }; 2701ITaskItem[] sourceFiles = 2792ITaskItem[] sourceFiles = { new TaskItem(sourceFile) }; 2872ITaskItem[] sourceFiles = { new TaskItem(sourceFile) }; 2937ITaskItem[] sourceFiles = { new TaskItem(sourceFile) }; 2976SourceFiles = new ITaskItem[] { new TaskItem("c:\\source") }, 2977DestinationFiles = new ITaskItem[] { new TaskItem("c:\\destination") }, 3006ITaskItem[] sourceFiles = { new TaskItem(sourceFile1.Path) }; 3007ITaskItem[] destinationFiles = { new TaskItem(destFile) }; 3196t.SourceFiles = new ITaskItem[] { 3200t.DestinationFiles = new ITaskItem[] {

362ITaskItem i = new TaskItem("SR1.resx"); 365t.ResourceFiles = new ITaskItem[] { i }; 372ITaskItem[] resourceNames = t.ManifestResourceNames; 389ITaskItem i = new TaskItem(resXFile.Path); 397ResourceFiles = new ITaskItem[] { i } 425ITaskItem i = new TaskItem(ResourceFileName); 437ResourceFiles = new ITaskItem[] { i } 462ITaskItem i = new TaskItem(@"SR1\SR1.resx"); 470ResourceFiles = new ITaskItem[] { i } 492ITaskItem i = new TaskItem(Path.GetFileName(resXFile.Path)); 504ResourceFiles = new ITaskItem[] { i } 527ITaskItem i = new TaskItem(resXFile.Path); 535ResourceFiles = new ITaskItem[] { i } 557ITaskItem i = new TaskItem(Path.GetFileName(resXFile.Path)); 569ResourceFiles = new ITaskItem[] { i } 591ITaskItem i = new TaskItem(resXFile.Path); 605ResourceFiles = new ITaskItem[] { i }, 797ITaskItem i = new TaskItem("strings.resx"); 799t.ResourceFiles = new ITaskItem[] { i }; 805ITaskItem[] resourceFiles = t.ResourceFilesWithManifestResourceNames; 822ITaskItem i = new TaskItem("pic.bmp"); 825t.ResourceFiles = new ITaskItem[] { i }; 831ITaskItem[] resourceFiles = t.ResourceFilesWithManifestResourceNames; 847ITaskItem i = new TaskItem("pic.bmp"); 851t.ResourceFiles = new ITaskItem[] { i }; 857ITaskItem[] resourceFiles = t.ResourceFilesWithManifestResourceNames; 873ITaskItem i = new TaskItem("strings.resx"); 876t.ResourceFiles = new ITaskItem[] { i }; 882ITaskItem[] resourceFiles = t.ResourceFilesWithManifestResourceNames;

54t.Include = new ITaskItem[] { new TaskItem("MyFile.txt") }; 55t.Exclude = new ITaskItem[] { new TaskItem("MyFile.txt") }; 72t.Include = new ITaskItem[] { new TaskItem("MyFile.txt") }; 73t.Exclude = new ITaskItem[] { new TaskItem("MyFileOther.txt") }; 91t.Include = new ITaskItem[] { new TaskItem("MyFile.txt") }; 110t.Exclude = new ITaskItem[] { new TaskItem("MyFile.txt") }; 143t.Include = new ITaskItem[] { new TaskItem("MyFile.txt") }; 144t.Exclude = new ITaskItem[] { new TaskItem("myfile.tXt") }; 226t.Include = new ITaskItem[] { new TaskItem("MyFile.txt") }; 247t.Include = new ITaskItem[] { item }; 270t.Include = new ITaskItem[] { item }; 302Include = new ITaskItem[] { new TaskItem(itemSpec) }, 354Include = new ITaskItem[] { new TaskItem(itemSpec) },

29ITaskItem i = new TaskItem("MyFiles.nonexistent"); 31t.Files = new ITaskItem[] { i }; 58ITaskItem sourceItem = new TaskItem(source); 59ITaskItem[] sourceFiles = { sourceItem }; 77ITaskItem[] duplicateSourceFiles = { sourceItem, sourceItem };

851ITaskItem[] items = { new TaskItem("hi"), new TaskItem("ho") };

21f.PrimaryList = new ITaskItem[] { new TaskItem("app.config"), new TaskItem("xxx") }; 22f.SecondaryList = System.Array.Empty<ITaskItem>(); 34f.PrimaryList = new ITaskItem[] { new TaskItem("yyy"), new TaskItem("xxx") }; 35f.SecondaryList = new ITaskItem[] { new TaskItem("app.config"), new TaskItem("xxx") }; 47f.PrimaryList = new ITaskItem[] { new TaskItem("yyy"), new TaskItem("xxx") }; 48f.SecondaryList = new ITaskItem[] { new TaskItem("foo\\app.config"), new TaskItem("xxx") }; 60f.PrimaryList = new ITaskItem[] { new TaskItem("yyy"), new TaskItem("xxx") }; 61f.SecondaryList = new ITaskItem[] { new TaskItem("iii"), new TaskItem("xxx") }; 72f.PrimaryList = new ITaskItem[] { new TaskItem("yyy"), new TaskItem("xxx") }; 73f.SecondaryList = new ITaskItem[] { new TaskItem("|||"), new TaskItem(@"foo\\app.config"), new TaskItem(@"!@#$@$%|"), new TaskItem("uuu") }; 86ITaskItem item1 = new TaskItem("app.config"); 88ITaskItem item2 = new TaskItem("app.config"); 90f.PrimaryList = new ITaskItem[] { item1, item2 }; 91f.SecondaryList = System.Array.Empty<ITaskItem>();

23f.List = new ITaskItem[] { new TaskItem("A.CS"), new TaskItem("b.cs") }; 35f.List = new ITaskItem[] { new TaskItem("A.CS"), new TaskItem("a.cs") }; 47f.List = new ITaskItem[] { new TaskItem("A.CS"), new TaskItem("b.cs") }; 58ITaskItem item1 = new TaskItem("a.cs"); 60ITaskItem item2 = new TaskItem("a.cs"); 62f.List = new ITaskItem[] { item1, item2 }; 78ITaskItem item1 = new TaskItem("a.cs"); 80ITaskItem item2 = new TaskItem("a.cs"); 82f.List = new ITaskItem[] { item1, item2 }; 95f.List = Array.Empty<ITaskItem>(); 106f.List = new ITaskItem[] { new TaskItem("foo\a.cs"), new TaskItem("b.cs") }; 118f.List = new ITaskItem[] { new TaskItem(@"c:\foo\a.cs"), new TaskItem("b.cs") }; 131f.List = new ITaskItem[] { new TaskItem(@"!@#$@$%|"), new TaskItem(@"foo\a.cs"), new TaskItem("b.cs") };

29t.Files = new ITaskItem[] { new TaskItem(@"C:\MyProject\File1.txt"), new TaskItem(@"C:\SomeoneElsesProject\File2.txt") }; 58t.Files = new ITaskItem[] { new TaskItem(@":::") }; 87t.Files = new ITaskItem[] { new TaskItem(@"foo") }; 105t.Files = new ITaskItem[] { new TaskItem(EscapingUtilities.Escape(testFile.Name)),

315params ITaskItem[] suggestedRedirects) 325SuggestedRedirects = suggestedRedirects ?? Array.Empty<ITaskItem>(), 382((ITaskItem)this).ItemSpec = assemblyName; 388string ITaskItem.ItemSpec { get; set; } 390ICollection ITaskItem.MetadataNames { get; } 392int ITaskItem.MetadataCount { get; } 394string ITaskItem.GetMetadata(string metadataName) 399void ITaskItem.SetMetadata(string metadataName, string metadataValue) 404void ITaskItem.RemoveMetadata(string metadataName) 409void ITaskItem.CopyMetadataTo(ITaskItem destinationItem) 414IDictionary ITaskItem.CloneCustomMetadata()

285ITaskItem[] installedSDKs = t.InstalledSDKs; 290foreach (ITaskItem item in installedSDKs) 332ITaskItem[] installedSDKs = t.InstalledSDKs; 336foreach (ITaskItem item in installedSDKs) 406ITaskItem[] installedSDKs = t.InstalledSDKs; 410foreach (ITaskItem item in installedSDKs)

228ITaskItem item = new TaskItem("C:\\SDKDoesNotExist"); 237ResolvedSDKReferences = new ITaskItem[] { item }, 370ITaskItem item = new TaskItem(_sdkDirectory); 376t.ResolvedSDKReferences = new ITaskItem[] { item }; 395ITaskItem item = new TaskItem(_sdkDirectory); 402t.ResolvedSDKReferences = new ITaskItem[] { item }; 420ITaskItem item = new TaskItem(_sdkDirectory); 427t.ResolvedSDKReferences = new ITaskItem[] { item }; 486ITaskItem item1 = new TaskItem(_sdkDirectory); 493ITaskItem item2 = new TaskItem(_sdkDirectory); 502t.ResolvedSDKReferences = new ITaskItem[] { item1, item2 }; 513t.ResolvedSDKReferences = new ITaskItem[] { item1 }; 524t.ResolvedSDKReferences = new ITaskItem[] { item2 }; 544ITaskItem item = new TaskItem(_sdkDirectory); 551t.ResolvedSDKReferences = new ITaskItem[] { item }; 597ITaskItem item = new TaskItem(_sdkDirectory); 603t.ResolvedSDKReferences = new ITaskItem[] { item }; 606ITaskItem[] references1 = t.References; 621ITaskItem item2 = new TaskItem(_sdkDirectory2); 627t2.ResolvedSDKReferences = new ITaskItem[] { item2 }; 629ITaskItem[] references2 = t2.References; 633foreach (var ref2 in references2) 663ITaskItem item = new TaskItem(_sdkDirectory); 669t.ResolvedSDKReferences = new ITaskItem[] { item }; 711ITaskItem item = new TaskItem(_sdkDirectory); 717t.ResolvedSDKReferences = new ITaskItem[] { item }; 756ITaskItem item = new TaskItem(_sdkDirectory); 762t.ResolvedSDKReferences = new ITaskItem[] { item }; 779ITaskItem item = new TaskItem(_sdkDirectory); 785t.ResolvedSDKReferences = new ITaskItem[] { item }; 804ITaskItem item = new TaskItem(_sdkDirectory); 810t.ResolvedSDKReferences = new ITaskItem[] { item }; 855ITaskItem item = new TaskItem(_sdkDirectory); 862t.ResolvedSDKReferences = new ITaskItem[] { item }; 906ITaskItem item = new TaskItem(_sdkDirectory); 912t.ResolvedSDKReferences = new ITaskItem[] { item }; 941ITaskItem item = new TaskItem(_sdkDirectory); 949t.ResolvedSDKReferences = new ITaskItem[] { item }; 1006ITaskItem item = new TaskItem(_sdkDirectory); 1012t.ResolvedSDKReferences = new ITaskItem[] { item }; 1037ITaskItem item = new TaskItem(_sdkDirectory); 1043t.ResolvedSDKReferences = new ITaskItem[] { item }; 1069ITaskItem item = new TaskItem(_sdkDirectory); 1075t.ResolvedSDKReferences = new ITaskItem[] { item }; 1100ITaskItem item = new TaskItem(_sdkDirectory); 1107t.ResolvedSDKReferences = new ITaskItem[] { item }; 1128ITaskItem item = new TaskItem(_sdkDirectory); 1135t.ResolvedSDKReferences = new ITaskItem[] { item }; 1157ITaskItem item = new TaskItem(_sdkDirectory); 1164t.ResolvedSDKReferences = new ITaskItem[] { item }; 1184ITaskItem item = new TaskItem(_sdkDirectory); 1191t.ResolvedSDKReferences = new ITaskItem[] { item }; 1212ITaskItem item = new TaskItem(_sdkDirectory); 1219ITaskItem item2 = new TaskItem(_sdkDirectory2); 1226t.ResolvedSDKReferences = new ITaskItem[] { item, item2 }; 1257ITaskItem item = new TaskItem(_sdkDirectory); 1264ITaskItem item2 = new TaskItem(_sdkDirectory2); 1272t.ResolvedSDKReferences = new ITaskItem[] { item, item2 }; 1299ITaskItem item = new TaskItem(_sdkDirectory); 1306ITaskItem item2 = new TaskItem(_sdkDirectory2); 1313t.ResolvedSDKReferences = new ITaskItem[] { item, item2 }; 1345ITaskItem item = new TaskItem(_sdkDirectory); 1353ITaskItem item2 = new TaskItem(_sdkDirectory2); 1361t.ResolvedSDKReferences = new ITaskItem[] { item, item2 };

22var actualHash = ExecuteHashTask(new ITaskItem[] 29var actualHash2 = ExecuteHashTask(new ITaskItem[] 40var emptyItemHash = ExecuteHashTask(new ITaskItem[] { new TaskItem("") }); 48var zeroLengthItemsHash = ExecuteHashTask(System.Array.Empty<ITaskItem>()); 58ITaskItem[] itemsToHash = new ITaskItem[1000]; 79ITaskItem[] itemsToHash = new ITaskItem[] { new TaskItem(string.Join("", array)) }; 108ItemsToHash = new ITaskItem[] { new TaskItem(input) }, 120ExecuteHashTask(new ITaskItem[] 128ExecuteHashTask(new ITaskItem[] 136ExecuteHashTask(new ITaskItem[] 148private string ExecuteHashTask(ITaskItem[] items, bool ignoreCase = false)

34t.Directories = new ITaskItem[] 82t.Directories = new ITaskItem[] 140t.Directories = new ITaskItem[] 182var dirList = new ITaskItem[] 251t.Directories = new ITaskItem[]

36ITaskItem[] sourceFiles = new ITaskItem[] { new TaskItem(sourceFile) }; 37ITaskItem[] destinationFiles = new ITaskItem[] { new TaskItem(destinationFile) }; 82ITaskItem[] sourceFiles = new ITaskItem[] { new TaskItem(sourceFile) }; 83ITaskItem[] destinationFiles = new ITaskItem[] { new TaskItem(destinationFile) }; 134ITaskItem[] sourceFiles = new ITaskItem[] { new TaskItem(sourceFile) }; 135ITaskItem[] destinationFiles = new ITaskItem[] { new TaskItem(destinationFile) }; 180ITaskItem[] sourceFiles = new ITaskItem[] { new TaskItem(sourceFile) }; 181ITaskItem[] destinationFiles = new ITaskItem[] { new TaskItem(sourceFile) }; 222ITaskItem[] sourceFiles = new ITaskItem[] { new TaskItem(sourceFile) }; 223ITaskItem[] destinationFiles = new ITaskItem[] { new TaskItem(destinationFile) }; 278ITaskItem[] sourceFiles = new ITaskItem[] { new TaskItem(sourceFile) }; 279ITaskItem[] destinationFiles = new ITaskItem[] { new TaskItem(destinationFile) }; 331ITaskItem[] sourceFiles = new ITaskItem[] { new TaskItem(sourceFile) }; 332ITaskItem[] destinationFiles = new ITaskItem[] { new TaskItem(destinationFile) }; 386ITaskItem[] sourceFiles = new ITaskItem[] { new TaskItem(sourceFile) }; 387ITaskItem[] destinationFiles = new ITaskItem[] { new TaskItem(destinationFile) }; 454ITaskItem i1 = new TaskItem(inFile1); 457t.SourceFiles = new ITaskItem[] { new TaskItem(inFile2), i1 }; 459ITaskItem o1 = new TaskItem(validOutFile); 462t.DestinationFiles = new ITaskItem[] { new TaskItem(invalidFile), o1 }; 520move.SourceFiles = new ITaskItem[] { new TaskItem(file) }; 521move.DestinationFiles = new ITaskItem[] { new TaskItem(file + "2") }; 543move.SourceFiles = new ITaskItem[] { new TaskItem("source") }; 557move.SourceFiles = new ITaskItem[] { new TaskItem("source") }; 558move.DestinationFiles = new ITaskItem[] { new TaskItem("x") }; 574move.SourceFiles = new ITaskItem[] { new TaskItem("source") }; 575move.DestinationFiles = new ITaskItem[] { new TaskItem(Directory.GetCurrentDirectory()) }; 590move.DestinationFiles = new ITaskItem[] { new TaskItem("destination") }; 591move.SourceFiles = new ITaskItem[] { new TaskItem(Directory.GetCurrentDirectory()) }; 625t.SourceFiles = new ITaskItem[] { new TaskItem(file) }; 626t.DestinationFiles = new ITaskItem[] { new TaskItem(filename.ToLowerInvariant()) }; 670t.SourceFiles = new ITaskItem[] { new TaskItem(file), new TaskItem(invalidFile) }; 671t.DestinationFiles = new ITaskItem[] { new TaskItem(file), new TaskItem(dest2) }; 706ITaskItem[] sourceFiles = new ITaskItem[] { new TaskItem(sourceFile) }; 775t.SourceFiles = new ITaskItem[] { new TaskItem(inFile1), new TaskItem(inFile2) }; 776t.DestinationFiles = new ITaskItem[] { new TaskItem(outFile1) }; 810ITaskItem[] sourceFiles = new ITaskItem[] { new TaskItem(sourceFile) }; 811ITaskItem[] destinationFiles = new ITaskItem[] { new TaskItem(destinationFile) }; 840ITaskItem[] sourceFiles = new ITaskItem[] { new TaskItem(sourceFile) }; 841ITaskItem[] destinationFiles = new ITaskItem[] { new TaskItem(destinationFile) }; 865t.SourceFiles = new ITaskItem[] { new TaskItem("foo | bar") }; 884t.SourceFiles = new ITaskItem[] { new TaskItem("source") }; 885t.DestinationFiles = new ITaskItem[] { new TaskItem("foo | bar") }; 903t.SourceFiles = new ITaskItem[] { new TaskItem("source") };

80Projects = new ITaskItem[] { new TaskItem(projectFile1) } 128msbuildTask.Projects = new ITaskItem[] { new TaskItem(projectFile1), new TaskItem(projectFile2) }; 511ITaskItem[] projects = new ITaskItem[] 569ITaskItem[] projects = new ITaskItem[] 625ITaskItem[] projects = new ITaskItem[] 680ITaskItem[] projects = new ITaskItem[] 729ITaskItem[] projects = new ITaskItem[] 784ITaskItem[] projects = new ITaskItem[] 842ITaskItem[] projects = new ITaskItem[] 904ITaskItem[] projects = new ITaskItem[] 950ITaskItem[] projects = new ITaskItem[] 1154ITaskItem[] projects = new ITaskItem[] 1171projects = new ITaskItem[] 1216ITaskItem[] projects = new ITaskItem[] 1335ITaskItem[] projects = new ITaskItem[]

92rarReaderTask.AssemblyInformationCachePaths = new ITaskItem[] 136rarReaderTask.AssemblyInformationCachePaths = new ITaskItem[]

36Lines = new ITaskItem[] { new TaskItem("Line1") } 52a.Lines = new ITaskItem[] { new TaskItem("Line2"), new TaskItem("Line3") }; 85Lines = new ITaskItem[] { new TaskItem("Line1_%253b_") } 101a.Lines = new ITaskItem[] { new TaskItem("Line2"), new TaskItem("Line3") }; 132Lines = new ITaskItem[] { new TaskItem("My special character is \u00C3") } 187Lines = new ITaskItem[]

35ITaskItem i = new TaskItem("MyNonExistentDirectory"); 37t.Directories = new ITaskItem[] { i };

28internal static ITaskItem CreateReferenceItem(string itemSpec, string projectGuid, string package, string name) 53ITaskItem reference = CreateReferenceItem(itemSpec, projectGuid, package, name); 104ITaskItem reference = CreateReferenceItem(itemSpec, projectGuid, package, name); 106ITaskItem resolvedPath; 193rvpo.ProjectReferences = (ITaskItem[])projectRefs.ToArray(typeof(ITaskItem)); 232Assert.Equal("true", ((ITaskItem)resolvedOutputs[Path.Combine("obj", "managed.dll")]).GetMetadata("ManagedAssembly")); 233Assert.NotEqual("true", ((ITaskItem)resolvedOutputs[Path.Combine("obj", "unmanaged.dll")]).GetMetadata("ManagedAssembly")); 338ITaskItem[] taskItems = new ITaskItem[1];

183ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 184ITaskItem installLocation = new TaskItem(testDirectory); 196t1.SDKReferences = new ITaskItem[] { item }; 197t1.InstalledSDKs = new ITaskItem[] { installLocation }; 214t2.SDKReferences = new ITaskItem[] { item }; 215t2.InstalledSDKs = new ITaskItem[] { installLocation }; 232t3.SDKReferences = new ITaskItem[] { item }; 233t3.InstalledSDKs = new ITaskItem[] { installLocation }; 250t3a.SDKReferences = new ITaskItem[] { item }; 251t3a.InstalledSDKs = new ITaskItem[] { installLocation }; 271t4.SDKReferences = new ITaskItem[] { item }; 272t4.InstalledSDKs = new ITaskItem[] { installLocation }; 288t5.SDKReferences = new ITaskItem[] { item }; 289t5.InstalledSDKs = new ITaskItem[] { installLocation }; 435ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 437t.SDKReferences = new ITaskItem[] { item }; 439ITaskItem installedSDK = new TaskItem(_sdkPath); 441t.InstalledSDKs = new ITaskItem[] { installedSDK }; 498ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 499t.SDKReferences = new ITaskItem[] { item }; 501ITaskItem installLocation = new TaskItem(testDirectory); 503t.InstalledSDKs = new ITaskItem[] { installLocation }; 529ITaskItem dummyItem = new TaskItem(); 543private static void TestGoodSDKReferenceIncludes(ITaskItem referenceInclude, string simpleName, string version) 557private static void TestBadSDKReferenceIncludes(ITaskItem referenceInclude) 602ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 603t.SDKReferences = new ITaskItem[] { item }; 608ITaskItem installLocation = new TaskItem(testDirectory); 610t.InstalledSDKs = new ITaskItem[] { installLocation }; 657ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 658t.SDKReferences = new ITaskItem[] { item }; 663ITaskItem installLocation = new TaskItem(testDirectory); 665t.InstalledSDKs = new ITaskItem[] { installLocation }; 715ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 716t.SDKReferences = new ITaskItem[] { item }; 721ITaskItem installLocation = new TaskItem(testDirectory); 723t.InstalledSDKs = new ITaskItem[] { installLocation }; 770ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 771t.SDKReferences = new ITaskItem[] { item }; 776ITaskItem installLocation = new TaskItem(testDirectory); 778t.InstalledSDKs = new ITaskItem[] { installLocation }; 825ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 826t.SDKReferences = new ITaskItem[] { item }; 831ITaskItem installLocation = new TaskItem(testDirectory); 833t.InstalledSDKs = new ITaskItem[] { installLocation }; 880ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 881t.SDKReferences = new ITaskItem[] { item }; 886ITaskItem installLocation = new TaskItem(testDirectory); 888t.InstalledSDKs = new ITaskItem[] { installLocation }; 937ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 938t.SDKReferences = new ITaskItem[] { item }; 943ITaskItem installLocation = new TaskItem(testDirectory); 945t.InstalledSDKs = new ITaskItem[] { installLocation }; 991ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 992t.SDKReferences = new ITaskItem[] { item }; 997ITaskItem installLocation = new TaskItem(testDirectory); 999t.InstalledSDKs = new ITaskItem[] { installLocation }; 1046ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 1047t.SDKReferences = new ITaskItem[] { item }; 1052ITaskItem installLocation = new TaskItem(testDirectory); 1054t.InstalledSDKs = new ITaskItem[] { installLocation }; 1081ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 1082t.SDKReferences = new ITaskItem[] { item }; 1084ITaskItem installedSDK = new TaskItem(_sdkPath); 1086t.InstalledSDKs = new ITaskItem[] { installedSDK }; 1118ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 1119t.SDKReferences = new ITaskItem[] { item }; 1121ITaskItem installedSDK = new TaskItem(_sdkPath); 1123t.InstalledSDKs = new ITaskItem[] { installedSDK }; 1156ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 1160t.SDKReferences = new ITaskItem[] { item }; 1162ITaskItem installedSDK = new TaskItem(_sdkPath); 1164t.InstalledSDKs = new ITaskItem[] { installedSDK }; 1197ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 1198ITaskItem item2 = new TaskItem("GoodTestSDK, Version=2.0"); 1199t.SDKReferences = new ITaskItem[] { item, item2 }; 1201ITaskItem installedSDK = new TaskItem(_sdkPath); 1203t.InstalledSDKs = new ITaskItem[] { installedSDK }; 1233ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 1234t.SDKReferences = new ITaskItem[] { item }; 1240ITaskItem installedSDK = new TaskItem(_sdkPath); 1242t.InstalledSDKs = new ITaskItem[] { installedSDK }; 1268t.SDKReferences = new ITaskItem[] { item }; 1276t.InstalledSDKs = new ITaskItem[] { installedSDK }; 1305ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 1306t.SDKReferences = new ITaskItem[] { item }; 1308t.InstalledSDKs = Array.Empty<ITaskItem>(); 1329ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 1330t.SDKReferences = new ITaskItem[] { item }; 1333ITaskItem installedSDK1 = new TaskItem(_sdkPath); 1336ITaskItem installedSDK2 = new TaskItem(_sdkPath); 1339ITaskItem installedSDK3 = new TaskItem(String.Empty); 1342ITaskItem installedSDK4 = new TaskItem(_sdkPath); 1345ITaskItem installedSDK5 = new TaskItem(_sdkPath); 1347t.InstalledSDKs = new ITaskItem[] { installedSDK1, installedSDK2, installedSDK3, installedSDK4, installedSDK5 }; 1379ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 1380ITaskItem item2 = new TaskItem("GoodTestSDK2, Version=2.0"); 1381t.SDKReferences = new ITaskItem[] { item, item2 }; 1383ITaskItem installedSDK = new TaskItem("DoesNotExist"); 1385t.InstalledSDKs = new ITaskItem[] { installedSDK }; 1407ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 1408ITaskItem item2 = new TaskItem("RandomSDK, Version=2.0"); 1409t.SDKReferences = new ITaskItem[] { item, item2 }; 1411ITaskItem installedSDK = new TaskItem(_sdkPath); 1413t.InstalledSDKs = new ITaskItem[] { installedSDK }; 1471ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 1472t.SDKReferences = Array.Empty<ITaskItem>(); 1473ITaskItem installedSDK = new TaskItem(_sdkPath); 1475t.InstalledSDKs = new ITaskItem[] { installedSDK }; 1512ITaskItem item = new TaskItem("BadTestSDK, Version=2.0"); 1513ITaskItem item2 = new TaskItem("GoodTestSDK, Version=2.0"); 1514t.SDKReferences = new ITaskItem[] { item, item2 }; 1516ITaskItem installLocation = new TaskItem(testDirectory); 1520ITaskItem installLocation2 = new TaskItem(goodSDKLocation); 1522t.InstalledSDKs = new ITaskItem[] { installLocation, installLocation2 }; 1571ITaskItem item = new TaskItem("BadTestSDK, Version=2.0"); 1572ITaskItem item2 = new TaskItem("GoodTestSDK, Version=2.0"); 1573t.SDKReferences = new ITaskItem[] { item, item2 }; 1575ITaskItem installLocation = new TaskItem(testDirectory); 1578ITaskItem installLocation2 = new TaskItem("C:\\GoodSDKLocation"); 1580t.InstalledSDKs = new ITaskItem[] { installLocation, installLocation2 }; 1661ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 1662ITaskItem installLocation = new TaskItem(testDirectory); 1669t1.SDKReferences = new ITaskItem[] { item }; 1670t1.InstalledSDKs = new ITaskItem[] { installLocation }; 1682t2.SDKReferences = new ITaskItem[] { item }; 1683t2.InstalledSDKs = new ITaskItem[] { installLocation }; 1748ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 1749t.SDKReferences = new ITaskItem[] { item }; 1751ITaskItem installLocation = new TaskItem(testDirectory); 1753t.InstalledSDKs = new ITaskItem[] { installLocation }; 1830ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 1847t.SDKReferences = new ITaskItem[] { item }; 1849ITaskItem installLocation = new TaskItem(testDirectory); 1851t.InstalledSDKs = new ITaskItem[] { installLocation }; 1925ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 1926t.SDKReferences = new ITaskItem[] { item }; 1928ITaskItem installLocation = new TaskItem(testDirectory); 1930t.InstalledSDKs = new ITaskItem[] { installLocation }; 1996ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 1997t.SDKReferences = new ITaskItem[] { item }; 1999ITaskItem installLocation = new TaskItem(testDirectory); 2001t.InstalledSDKs = new ITaskItem[] { installLocation }; 2061ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 2062t.SDKReferences = new ITaskItem[] { item }; 2064ITaskItem installLocation = new TaskItem(testDirectory); 2066t.InstalledSDKs = new ITaskItem[] { installLocation }; 2134ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 2135t.SDKReferences = new ITaskItem[] { item }; 2137ITaskItem installLocation = new TaskItem(testDirectory); 2139t.InstalledSDKs = new ITaskItem[] { installLocation }; 2203ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 2204t.SDKReferences = new ITaskItem[] { item }; 2206ITaskItem installLocation = new TaskItem(testDirectory); 2208t.InstalledSDKs = new ITaskItem[] { installLocation }; 2273ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 2274t.SDKReferences = new ITaskItem[] { item }; 2276ITaskItem installLocation = new TaskItem(testDirectory); 2278t.InstalledSDKs = new ITaskItem[] { installLocation }; 2344ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 2345t.SDKReferences = new ITaskItem[] { item }; 2347ITaskItem installLocation = new TaskItem(testDirectory); 2349t.InstalledSDKs = new ITaskItem[] { installLocation }; 2416ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 2417t.SDKReferences = new ITaskItem[] { item }; 2419ITaskItem installLocation = new TaskItem(testDirectory); 2421t.InstalledSDKs = new ITaskItem[] { installLocation }; 2486ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 2487t.SDKReferences = new ITaskItem[] { item }; 2491ITaskItem installLocation = new TaskItem(testDirectory); 2493t.InstalledSDKs = new ITaskItem[] { installLocation }; 2560ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 2561t.SDKReferences = new ITaskItem[] { item }; 2565ITaskItem installLocation = new TaskItem(testDirectory); 2567t.InstalledSDKs = new ITaskItem[] { installLocation }; 2625ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 2628t.SDKReferences = new ITaskItem[] { item }; 2632ITaskItem installLocation = new TaskItem(testDirectory); 2634t.InstalledSDKs = new ITaskItem[] { installLocation }; 2692ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 2693t.SDKReferences = new ITaskItem[] { item }; 2697ITaskItem installLocation = new TaskItem(testDirectory); 2699t.InstalledSDKs = new ITaskItem[] { installLocation }; 2757ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 2760t.SDKReferences = new ITaskItem[] { item }; 2764ITaskItem installLocation = new TaskItem(testDirectory); 2766t.InstalledSDKs = new ITaskItem[] { installLocation }; 2842ITaskItem item = new TaskItem("GoodTestSDK, Version=1.0"); 2843ITaskItem item2 = new TaskItem("GoodTestSDK, Version=2.0"); 2844ITaskItem item3 = new TaskItem("GoodTestSDK, Version=3.0"); 2846t.SDKReferences = new ITaskItem[] { item, item2, item3 }; 2850ITaskItem installLocation = new TaskItem(testDirectory); 2853ITaskItem installLocation2 = new TaskItem(testDirectory2); 2856ITaskItem installLocation3 = new TaskItem(testDirectory3); 2859t.InstalledSDKs = new ITaskItem[] { installLocation, installLocation2, installLocation3 }; 2940ITaskItem item = new TaskItem("GoodTestSDK, Version=1.0"); 2941ITaskItem item2 = new TaskItem("GoodTestSDK2, Version=2.0"); 2942ITaskItem item3 = new TaskItem("GoodTestSDK3, Version=3.0"); 2944t.SDKReferences = new ITaskItem[] { item, item2, item3 }; 2948ITaskItem installLocation = new TaskItem(testDirectory); 2951ITaskItem installLocation2 = new TaskItem(testDirectory2); 2954ITaskItem installLocation3 = new TaskItem(testDirectory3); 2957t.InstalledSDKs = new ITaskItem[] { installLocation, installLocation2, installLocation3 }; 3048ITaskItem item = new TaskItem("GoodTestSDK, Version=1.0"); 3049ITaskItem item2 = new TaskItem("GoodTestSDK2, Version=2.0"); 3050ITaskItem item3 = new TaskItem("GoodTestSDK3, Version=3.0"); 3051ITaskItem item4 = new TaskItem("GoodTestSDK3, Version=4.0"); 3053t.SDKReferences = new ITaskItem[] { item, item2, item3, item4 }; 3057ITaskItem installLocation = new TaskItem(testDirectory); 3060ITaskItem installLocation2 = new TaskItem(testDirectory2); 3063ITaskItem installLocation3 = new TaskItem(testDirectory3); 3066ITaskItem installLocation4 = new TaskItem(testDirectory4); 3069t.InstalledSDKs = new ITaskItem[] { installLocation, installLocation2, installLocation3, installLocation4 }; 3151ITaskItem item = new TaskItem("GoodTestSDK, Version=1.0"); 3152ITaskItem item2 = new TaskItem("GoodTestSDK, Version=2.0"); 3153ITaskItem item3 = new TaskItem("GoodTestSDK, Version=3.0"); 3155t.SDKReferences = new ITaskItem[] { item, item2, item3 }; 3159ITaskItem installLocation = new TaskItem(testDirectory); 3162ITaskItem installLocation2 = new TaskItem(testDirectory2); 3165ITaskItem installLocation3 = new TaskItem(testDirectory3); 3168t.InstalledSDKs = new ITaskItem[] { installLocation, installLocation2, installLocation3 }; 3240ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 3242t.SDKReferences = new ITaskItem[] { item }; 3246ITaskItem installLocation = new TaskItem(testDirectory); 3248t.InstalledSDKs = new ITaskItem[] { installLocation }; 3314ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 3317t.SDKReferences = new ITaskItem[] { item }; 3321ITaskItem installLocation = new TaskItem(testDirectory); 3323t.InstalledSDKs = new ITaskItem[] { installLocation }; 3390ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 3393t.SDKReferences = new ITaskItem[] { item }; 3397ITaskItem installLocation = new TaskItem(testDirectory); 3399t.InstalledSDKs = new ITaskItem[] { installLocation }; 3458ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 3461t.SDKReferences = new ITaskItem[] { item }; 3465ITaskItem installLocation = new TaskItem(testDirectory); 3467t.InstalledSDKs = new ITaskItem[] { installLocation }; 3534ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 3535t.SDKReferences = new ITaskItem[] { item }; 3539ITaskItem installLocation = new TaskItem(testDirectory); 3541t.InstalledSDKs = new ITaskItem[] { installLocation }; 3597ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 3598t.SDKReferences = new ITaskItem[] { item }; 3601ITaskItem installLocation = new TaskItem(testDirectory); 3603t.InstalledSDKs = new ITaskItem[] { installLocation }; 3671ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 3672t.SDKReferences = new ITaskItem[] { item }; 3675ITaskItem installLocation = new TaskItem(testDirectory); 3677t.InstalledSDKs = new ITaskItem[] { installLocation }; 3820ITaskItem[] resolvedSDKReferences = result.Items; 3829ITaskItem[] SDkRedistFolders = result.Items; 3963ITaskItem[] resolvedSDKReferences = result.Items; 3972ITaskItem[] SDkRedistFolders = result.Items; 4072ITaskItem[] resolvedSDKReferences = result.Items; 4081ITaskItem[] SDkRedistFolders = result.Items; 4169ITaskItem[] resolvedSDKReferences = result.Items; 4180ITaskItem[] SDkRedistFolders = result.Items; 4200new Dictionary<string, ITaskItem>() { { "sdkName, Version=1.0.2", new TaskItem(Path.GetTempFileName(), new Dictionary<string, string>() { { "PlatformVersion", "1.0.2" } }) } }, 4298ITaskItem[] resolvedSDKReferences1 = RunBuildAndReturnResolvedSDKReferences(logger, testProjectFile, testDirectoryRoot); 4307ITaskItem[] resolvedSDKReferences2 = RunBuildAndReturnResolvedSDKReferences(logger, testProjectFile, testDirectoryRoot); 4326private ITaskItem[] RunBuildAndReturnResolvedSDKReferences(ILogger logger, string testProjectFile, string testDirectoryRoot)

66t.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 91foreach (ITaskItem item in t.FilesWritten) 118t.Sources = new ITaskItem[] { 121t.OutputResources = new ITaskItem[] { 136foreach (ITaskItem item in t.FilesWritten) 154t.Sources = new ITaskItem[] { new TaskItem(textFile) }; 174foreach (ITaskItem item in t.FilesWritten) 204t.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 205t.References = new ITaskItem[] { new TaskItem(systemDll) }; 245t.Sources = new ITaskItem[] { new TaskItem(resourcesFile) }; 246t.OutputResources = new ITaskItem[] { new TaskItem(Path.ChangeExtension(resourcesFile, ".resx")) }; 252t2a.Sources = new ITaskItem[] { new TaskItem(resourcesFile) }; 253t2a.OutputResources = new ITaskItem[] { new TaskItem(Path.ChangeExtension(resourcesFile, ".txt")) }; 259t2b.Sources = new ITaskItem[] { new TaskItem(t2a.FilesWritten[0].ItemSpec) }; 260t2b.OutputResources = new ITaskItem[] { new TaskItem(Utilities.GetTempFileName(".resx")) }; 274foreach (ITaskItem item in t2b.FilesWritten) 294t.Sources = new ITaskItem[] { new TaskItem(resourcesFile) }; 297t.OutputResources = new ITaskItem[] { new TaskItem(outputFile) }; 308foreach (ITaskItem item in t.FilesWritten) 327t.Sources = new ITaskItem[] { new TaskItem(resxFileInput) }; 353t2.Sources = new ITaskItem[] { new TaskItem(resxFileInput) }; 373t.Sources = new ITaskItem[] { new TaskItem(resxFileInput) }; 381t2.Sources = new ITaskItem[] { new TaskItem(resxFileInput) }; 406t.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 417t2.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 439foreach (ITaskItem item in t.FilesWritten) 472t.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 490t2.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 504ITaskItem[] sources = new ITaskItem[] { new TaskItem(resxFileInput) }; 505ITaskItem[] output; 575t.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 618foreach (ITaskItem item in t.FilesWritten) 644t.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 655foreach (ITaskItem item in t.FilesWritten) 676t.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 687t2.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 706foreach (ITaskItem item in t.FilesWritten) 730createResources.Sources = new ITaskItem[] { new TaskItem(firstResx), new TaskItem(secondResx) }; 742t2.Sources = new ITaskItem[] { new TaskItem(firstResx), new TaskItem(secondResx) }; 790t.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 805t2.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 818foreach (ITaskItem item in t.FilesWritten) 846t.Sources = new ITaskItem[] { new TaskItem(resxFile), new TaskItem(txtFile) }; 862t2.Sources = new ITaskItem[] { new TaskItem(resxFile), new TaskItem(txtFile) }; 929initialCreator.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 930initialCreator.References = new ITaskItem[] { new TaskItem(localSystemDll) }; 939incrementalUpToDate.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 940incrementalUpToDate.References = new ITaskItem[] { new TaskItem(localSystemDll) }; 951incrementalOutOfDate.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 952incrementalOutOfDate.References = new ITaskItem[] { new TaskItem(localSystemDll) }; 1002ITaskItem[] additionalInputs = null; 1007additionalInputs = new ITaskItem[] { new TaskItem(FileUtilities.GetTemporaryFile()), new TaskItem(FileUtilities.GetTemporaryFile()) }; 1009foreach (ITaskItem file in additionalInputs) 1018t.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 1025t2.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 1035t3.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 1082t.Sources = new ITaskItem[] { new TaskItem(textFile) }; 1083t.OutputResources = new ITaskItem[] { new TaskItem(Path.ChangeExtension(textFile, ".resx")) }; 1095foreach (ITaskItem item in t.FilesWritten) 1115t.Sources = new ITaskItem[] { new TaskItem(resourcesFile) }; 1116t.OutputResources = new ITaskItem[] { new TaskItem(Path.ChangeExtension(resourcesFile, ".resx")) }; 1122t2a.Sources = new ITaskItem[] { new TaskItem(t.FilesWritten[0].ItemSpec) }; 1123t2a.OutputResources = new ITaskItem[] { new TaskItem(Path.ChangeExtension(t.FilesWritten[0].ItemSpec, ".resources")) }; 1129t2b.Sources = new ITaskItem[] { new TaskItem(t2a.FilesWritten[0].ItemSpec) }; 1130t2b.OutputResources = new ITaskItem[] { new TaskItem(Utilities.GetTempFileName(".resx")) }; 1143foreach (ITaskItem item in t2b.FilesWritten) 1163t.Sources = new ITaskItem[] { new TaskItem(textFile) }; 1174t2.Sources = new ITaskItem[] { new TaskItem(resourcesFile) }; 1176t2.OutputResources = new ITaskItem[] { new TaskItem(outputFile) }; 1186foreach (ITaskItem item in t.FilesWritten) 1192foreach (ITaskItem item in t2.FilesWritten) 1208t.Sources = new ITaskItem[] { new TaskItem(textFile) }; 1249foreach (ITaskItem item in t.FilesWritten) 1271t.Sources = new ITaskItem[] { new TaskItem(textFile) }; 1311t2.Sources = new ITaskItem[] { new TaskItem(textFile) }; 1327foreach (ITaskItem item in t.FilesWritten) 1334foreach (ITaskItem item in t2.FilesWritten) 1363t.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 1364t.OutputResources = new ITaskItem[] { new TaskItem(resourcesFile) }; 1384t.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 1385t.OutputResources = new ITaskItem[] { new TaskItem(resourcesFile) }; 1397t.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 1398t.OutputResources = new ITaskItem[] { new TaskItem(resourcesFile) }; 1414t.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 1415t.OutputResources = new ITaskItem[] { new TaskItem(resourcesFile) }; 1455t.Sources = new ITaskItem[] { new TaskItem(txtFile) }; 1516t.Sources = new ITaskItem[] { new TaskItem(textFile) }; 1556foreach (ITaskItem item in t.FilesWritten) 1576t.Sources = new ITaskItem[] { new TaskItem(textFile) }; 1609foreach (ITaskItem item in t.FilesWritten) 1634t.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 1675foreach (ITaskItem item in t.FilesWritten) 1739t.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 1772foreach (ITaskItem item in t.FilesWritten) 1800t.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 1830foreach (ITaskItem item in t.FilesWritten) 1856t.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 1887foreach (ITaskItem item in t.FilesWritten) 1905t.Sources = new ITaskItem[] { new TaskItem(textFile) }; 1932foreach (ITaskItem item in t.FilesWritten) 1981t.Sources = new ITaskItem[] { new TaskItem(textFile) }; 1987foreach (ITaskItem item in t.FilesWritten) 1997t.Sources = new ITaskItem[] { new TaskItem(textFile) }; 2006foreach (ITaskItem item in t.FilesWritten) 2032t.Sources = new ITaskItem[] { new TaskItem(resxFile1), new TaskItem(resxFile2) }; 2109t.Sources = new ITaskItem[] { new TaskItem(resxFile1), new TaskItem(resxFile2) }; 2114t.OutputResources = new ITaskItem[] { new TaskItem(resourcesFile1), new TaskItem(resourcesFile2) }; 2181t.Sources = new ITaskItem[] { new TaskItem(textFile) }; 2191foreach (ITaskItem item in t.FilesWritten) 2208t.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 2209t.OutputResources = new ITaskItem[] { new TaskItem(Path.ChangeExtension(resxFile, ".txt")) }; 2219foreach (ITaskItem item in t.FilesWritten) 2238t.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 2299gr.Sources = new ITaskItem[] { new TaskItem(resource.Path) }; 2321t.Sources = new ITaskItem[] { new TaskItem(resourcesFile) }; 2322t.OutputResources = new ITaskItem[] { new TaskItem(resxFile) }; 2333foreach (ITaskItem item in t.FilesWritten) 2352t.Sources = new ITaskItem[] { new TaskItem(resourcesFile) }; 2353t.OutputResources = new ITaskItem[] { new TaskItem(env.GetTempFile(".resources").Path) }; 2372t.Sources = new ITaskItem[] { new TaskItem(textFile) }; 2390foreach (ITaskItem item in t.FilesWritten) 2412t.Sources = new ITaskItem[] { new TaskItem(txtFile) }; 2456ITaskItem i = new TaskItem(resxFile); 2458t.Sources = new ITaskItem[] { i }; 2460ITaskItem o = new TaskItem("MyAlternateResource.resources"); 2463t.OutputResources = new ITaskItem[] { o }; 2479foreach (ITaskItem item in t.FilesWritten) 2494ITaskItem i = new TaskItem(resxFile); 2496t.Sources = new ITaskItem[] { i }; 2509foreach (ITaskItem item in t.FilesWritten) 2523t.Sources = new ITaskItem[] { 2540foreach (ITaskItem item in t.Sources) 2545foreach (ITaskItem item in t.FilesWritten) 2559t.Sources = new ITaskItem[] { 2583foreach (ITaskItem item in t.Sources) 2587foreach (ITaskItem item in t.FilesWritten) 2603t.Sources = new ITaskItem[] { 2610foreach (ITaskItem taskItem in t.Sources) 2661foreach (ITaskItem item in t.Sources) 2665foreach (ITaskItem item in t.FilesWritten) 2689t.Sources = new ITaskItem[] { new TaskItem(textFile) }; 2693t.OutputResources = new ITaskItem[] { new TaskItem("somefile.resources") }; 2711foreach (ITaskItem item in t.FilesWritten) 2732t.Sources = new ITaskItem[] { new TaskItem(textFile) }; 2757foreach (ITaskItem item in t.FilesWritten) 2793foreach (ITaskItem item in t.FilesWritten) 2815t.Sources = new ITaskItem[] { new TaskItem(textFile) }; 2816t.References = new ITaskItem[] { new TaskItem("some non-existent DLL name goes here.dll") }; 2847t.Sources = new ITaskItem[] { new TaskItem("non-existent.resx"), new TaskItem(txtFile) }; 2884t.Sources = new ITaskItem[] { new TaskItem(textFile) }; 2901foreach (ITaskItem item in t.FilesWritten) 2923t.Sources = new ITaskItem[] { new TaskItem(newTextFile) }; 2935foreach (ITaskItem item in t.FilesWritten) 2955t.Sources = new ITaskItem[] { new TaskItem(textFile) }; 2956t.OutputResources = new ITaskItem[] { new TaskItem(resxFile) }; 2967foreach (ITaskItem item in t.FilesWritten) 2987t.Sources = new ITaskItem[] { new TaskItem(textFile) }; 2988t.OutputResources = new ITaskItem[] { new TaskItem(resxFile), new TaskItem("someother.resources") }; 2999foreach (ITaskItem item in t.FilesWritten) 3019t.Sources = new ITaskItem[] { new TaskItem(textFile) }; 3031foreach (ITaskItem item in t.FilesWritten) 3056t.Sources = new ITaskItem[] { new TaskItem(resxFile), new TaskItem(resxFile2) }; 3105t.Sources = new ITaskItem[] { new TaskItem(txtFile) }; 3109t.OutputResources = new ITaskItem[] { new TaskItem("somefile.resources") }; 3145t.Sources = new ITaskItem[] { new TaskItem(txtFile) }; 3182t.Sources = new ITaskItem[] { new TaskItem(txtFile) }; 3219t.Sources = new ITaskItem[] { new TaskItem(txtFile) }; 3260t.Sources = new ITaskItem[] { new TaskItem(txtFile) }; 3307t.Sources = new ITaskItem[] { new TaskItem(resourcesFile) }; 3308t.OutputResources = new ITaskItem[] { new TaskItem("||") }; 3481t.Sources = new ITaskItem[] { new TaskItem(Path.Combine(ObjectModelHelpers.TempProjectDir, "MyStrings.resx")) }; 3484t.References = new ITaskItem[] 3630t.Sources = new ITaskItem[] { new TaskItem(Path.Combine(ObjectModelHelpers.TempProjectDir, "MyStrings.resx")) }; 3637t.References = new ITaskItem[] { reference }; 3685t.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 3721t.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 3722t.References = new ITaskItem[] { new TaskItem("baz"), new TaskItem("jazz") }; 3764t.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 3765t.References = new ITaskItem[] { new TaskItem("baz"), new TaskItem("jazz") }; 3810t.Sources = new ITaskItem[] { new TaskItem(resxFile), new TaskItem(resxFile1) }; 3811t.OutputResources = new ITaskItem[] 3895t.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 3922foreach (ITaskItem item in t.FilesWritten) 3952task.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 3986t.Sources = new ITaskItem[] { new TaskItem("non-existent") }; 3987t.OutputResources = new ITaskItem[] { new TaskItem("out") }; 4147t.Sources = new ITaskItem[] { new TaskItem(sourceFile) }; 4213t.References = new ITaskItem[] { 4503t.Sources = new ITaskItem[] { new TaskItem(textFile) }; 4588foreach (ITaskItem item in t.FilesWritten)

373new TaskPropertyInfo("Parameter4", typeof(ITaskItem), output: false, required: false), 374new TaskPropertyInfo("Parameter5", typeof(ITaskItem[]), output: false, required: false), 482new TaskPropertyInfo("Parameter4", typeof(ITaskItem), output: false, required: false), 483new TaskPropertyInfo("Parameter5", typeof(ITaskItem[]), output: false, required: false),

192t.Files = new ITaskItem[] 216t.Files = new ITaskItem[] 240t.Files = new ITaskItem[] 266t.Files = new ITaskItem[] 288t.Files = new ITaskItem[] 312t.Files = new ITaskItem[] 329t.Files = new ITaskItem[] 355t.Files = new ITaskItem[] 382t.Files = new ITaskItem[] 407t.Files = new ITaskItem[]

41SourceFiles = new ITaskItem[] { new TaskItem(zipArchive.Path) }, 70SourceFiles = new ITaskItem[] { new TaskItem(zipArchive.Path) }, 84SourceFiles = new ITaskItem[] { new TaskItem(zipArchive.Path) }, 100SourceFiles = new ITaskItem[] { new TaskItem(zipArchive.Path) }, 130SourceFiles = new ITaskItem[] { new TaskItem(zipArchive.Path) }, 200SourceFiles = new ITaskItem[] { new TaskItem(zipArchive.Path) }, 223SourceFiles = new ITaskItem[] { new TaskItem(file.Path), }, 244SourceFiles = new ITaskItem[] { new TaskItem(Path.Combine(testEnvironment.DefaultTestDirectory.Path, "foo.zip")), }, 272SourceFiles = new ITaskItem[] { new TaskItem(zipArchive.Path) }, 302SourceFiles = new ITaskItem[] { new TaskItem(zipArchive.Path) }, 336SourceFiles = new ITaskItem[] { new TaskItem(zipArchive.Path) }, 370SourceFiles = new ITaskItem[] { new TaskItem(zipArchive.Path) }, 399SourceFiles = new ITaskItem[] { new TaskItem(zipArchive.Path) }, 428SourceFiles = new ITaskItem[] { new TaskItem(zipArchive.Path) }, 457SourceFiles = new ITaskItem[] { new TaskItem(zipArchive.Path) }, 492SourceFiles = new ITaskItem[] { new TaskItem(zipArchive.Path) },

67Lines = new ITaskItem[] { new TaskItem("\uBDEA") } 88Lines = new ITaskItem[] { new TaskItem("\uBDEA") }, 123Lines = new ITaskItem[] { new TaskItem("File contents1") } 145Lines = new ITaskItem[] { new TaskItem("File contents1") } 158Lines = new ITaskItem[] { new TaskItem("File contents2") } 184Lines = new ITaskItem[] { new TaskItem($"{nameof(RedundantParametersAreLogged)} Test") }, 210Lines = new ITaskItem[] { new TaskItem("File contents1") } 232Lines = new ITaskItem[] { new TaskItem("File contents1") }, 246Lines = new ITaskItem[] { new TaskItem("File contents2") }, 305Lines = Array.Empty<ITaskItem>(), // Test empty. 327Lines = new ITaskItem[] { new TaskItem("WriteLinesToFileDoesCreateDirectory Test") } 344ITaskItem[] lines = useNullLines ? null : Array.Empty<ITaskItem>(); 372ITaskItem[] lines = useNullLines ? null : Array.Empty<ITaskItem>();

1303ITaskItem[] xmlPathsWithNull = new ITaskItem[3]; 1349public void CopyMetadataTo(ITaskItem destinationItem) =>

297foreach (KeyValuePair<string, ITaskItem[]> output in result.TargetOutputsPerProject[i]) 316List<IDictionary<string, ITaskItem[]>> targetOutputsPerProject = null; 324targetOutputsPerProject = new List<IDictionary<string, ITaskItem[]>>(); 344targetOutputsPerProject.Add(new Dictionary<string, ITaskItem[]>(StringComparer.OrdinalIgnoreCase));

327public static void AssertItemsMatch(string expectedItemsString, ITaskItem[] actualItems) 350public static void AssertItemsMatch(string expectedItemsString, ITaskItem[] actualItems, bool orderOfItemsShouldMatch) 352List<ITaskItem> expectedItems = ParseExpectedItemsString(expectedItemsString); 356foreach (ITaskItem expectedItem in expectedItems) 368foreach (ITaskItem actualItem in actualItems) 383ITaskItem actualItem = actualItems[actualItemIndex]; 386ITaskItem expectedItem = null; 442foreach (ITaskItem expectedItem in expectedItems) 505private static List<ITaskItem> ParseExpectedItemsString(string expectedItemsString) 507List<ITaskItem> expectedItems = new List<ITaskItem>(); 532ITaskItem expectedItem = new Utilities.TaskItem(itemSpec);

384public void AppendFileNameIfNotNull(ITaskItem fileItem) 440public void AppendFileNamesIfNotNull(ITaskItem[] fileItems, string delimiter) 550public void AppendSwitchIfNotNull(string switchName, ITaskItem parameter) 603public void AppendSwitchIfNotNull(string switchName, ITaskItem[] parameters, string delimiter) 612foreach (ITaskItem parameter in parameters) 662public void AppendSwitchUnquotedIfNotNull(string switchName, ITaskItem parameter) 713public void AppendSwitchUnquotedIfNotNull(string switchName, ITaskItem[] parameters, string delimiter) 722foreach (ITaskItem parameter in parameters)

148ITaskItem sourceItem) 341public void CopyMetadataTo(ITaskItem destinationItem)

26internal static ITaskItem[]? ExpandWildcards(ITaskItem[] expand, TaskLoggingHelper? log) 33var expanded = new List<ITaskItem>(expand.Length); 34foreach (ITaskItem item in expand) 76internal static bool ItemsExist(ITaskItem[] files) 82foreach (ITaskItem item in files) 103public static ITaskItem[] ExpandWildcards(ITaskItem[] expand) => ExpandWildcards(expand, null);

32TaskItem to = new TaskItem((ITaskItem)from); 78ITaskItem item = null;

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

120foreach (var additionalFile in additionalFiles) 132foreach (var analyzer in analyzers) 207static string ReadImportItem(MSB.Framework.ITaskItem item)

17public static IEnumerable<MSB.Framework.ITaskItem> GetAdditionalFiles(this MSB.Execution.ProjectInstance executedProject) 20public static IEnumerable<MSB.Framework.ITaskItem> GetAnalyzers(this MSB.Execution.ProjectInstance executedProject) 23public static IEnumerable<MSB.Framework.ITaskItem> GetDocuments(this MSB.Execution.ProjectInstance executedProject) 26public static IEnumerable<MSB.Framework.ITaskItem> GetEditorConfigFiles(this MSB.Execution.ProjectInstance executedProject) 74public static ImmutableArray<string> GetAliases(this MSB.Framework.ITaskItem item) 83public static bool ReferenceOutputAssemblyIsTrue(this MSB.Framework.ITaskItem item) 128public static IEnumerable<MSB.Framework.ITaskItem> GetTaskItems(this MSB.Execution.ProjectInstance executedProject, string itemType)

17public abstract IEnumerable<MSB.Framework.ITaskItem> GetCompilerCommandLineArgs(MSB.Execution.ProjectInstance executedProject);

181private static bool IsNotTemporaryGeneratedFile(MSB.Framework.ITaskItem item) 184private DocumentFileInfo MakeDocumentFileInfo(MSB.Framework.ITaskItem documentItem) 194private DocumentFileInfo MakeNonSourceFileDocumentFileInfo(MSB.Framework.ITaskItem documentItem) 204private ImmutableArray<string> GetRelativeFolders(MSB.Framework.ITaskItem documentItem) 233private string GetDocumentFilePath(MSB.Framework.ITaskItem documentItem) 236private static bool IsDocumentLinked(MSB.Framework.ITaskItem documentItem) 239private static string GetDocumentLogicalPath(MSB.Framework.ITaskItem documentItem, string projectDirectory)

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

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

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

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

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

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

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

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

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

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

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

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

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[]

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

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

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

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

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

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

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

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

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)

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

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

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

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

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

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

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; } = []; 92foreach (ITaskItem require in Requires) 97foreach (ITaskItem conflict in Conflicts) 102foreach (ITaskItem changelogLine in ChangelogLines) 112foreach (ITaskItem script in Scripts)

33public ITaskItem BindTrackingFile { get; set; } 35public ITaskItem[] BindPaths { get; set; } 41public ITaskItem[] Extensions { get; set; } 51public ITaskItem IntermediateDirectory { get; set; } 53public ITaskItem[] LocalizationFiles { get; set; } 69public ITaskItem PdbFile { get; set; } 74public ITaskItem[] SourceFiles { get; set; } 373foreach (var extension in Extensions) 382foreach (var localizationFile in LocalizationFiles) 391foreach (var bindPath in BindPaths) 424foreach (var sourceFile in SourceFiles) 508foreach (var sourceFile in SourceFiles)

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)

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

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

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)

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)

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

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; }