17public interface ITaskItem2 : ITaskItem

17public interface ITaskItem2 : ITaskItem

726ITaskItem,

2263internal 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

378private sealed class TaskItemMock : ITaskItem

726ITaskItem,

726ITaskItem,

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

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

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

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)

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

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

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

34 public ITaskItem[] AssemblyPaths { get; set; } 41 public ITaskItem[] ReferenceAssemblyPaths { get; set; } 50 public ITaskItem[] RootAssemblyNames { get; set; } 57 public ITaskItem OutputDirectory { get; set; } 103 public ITaskItem[] RootDescriptorFiles { get; set; } 146 public ITaskItem[] FeatureSettings { get; set; } 169 public ITaskItem[] CustomData { get; set; } 228 public ITaskItem[] CustomSteps { get; set; } 233 public ITaskItem[] KeepMetadata { get; set; } 311 foreach (var rootFile in RootDescriptorFiles) 315 foreach (var assemblyItem in RootAssemblyNames) { 352 foreach (var assembly in AssemblyPaths) { 405 foreach (var assembly in ReferenceAssemblyPaths) { 463 foreach (var customData in CustomData) { 473 foreach (var featureSetting in FeatureSettings) { 483 foreach (var metadata in KeepMetadata) 494 foreach (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[] Branches { get; set; } 45public ITaskItem[] Platforms { get; set; } 115private string CreateRow(ITaskItem platform, string[] links) 125private string CreateCell(ITaskItem platform, ITaskItem branch, string[] links)

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

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

32private readonly List<ITaskItem> _targetOutputs = new List<ITaskItem>(); 46public ITaskItem[] TargetOutputs => _targetOutputs.ToArray(); 100var singleProject = new ITaskItem[1];

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

54private readonly List<ITaskItem> _targetOutputs = new List<ITaskItem>(); 113public ITaskItem[] Projects { get; set; } = null; 120public ITaskItem[] TargetOutputs => _targetOutputs.ToArray(); 293ITaskItem[] singleProject = null; 306singleProject = new ITaskItem[1]; 315ITaskItem project = Projects[i]; 412var projectsToBuildList = new List<ITaskItem>(); 521ITaskItem[] projects, 529List<ITaskItem> targetOutputs, 664IList<IDictionary<string, ITaskItem[]>> targetOutputsPerProject = result.TargetOutputsPerProject; 676if (targetOutputsPerProject[i].TryGetValue(targetName, out ITaskItem[] outputItemsFromTarget)) 678foreach (ITaskItem outputItemFromTarget in outputItemsFromTarget)

1042foreach (var msbuildProject in msbuildTask.Projects)

305foreach (KeyValuePair<string, ITaskItem[]> output in result.TargetOutputsPerProject[i]) 976List<IDictionary<string, ITaskItem[]>> targetOutputsPerProject = null; 983targetOutputsPerProject = new List<IDictionary<string, ITaskItem[]>>(1); 984targetOutputsPerProject.Add(new Dictionary<string, ITaskItem[]>(StringComparer.OrdinalIgnoreCase)); 1145List<IDictionary<string, ITaskItem[]>> targetOutputsPerProject = null; 1160targetOutputsPerProject = new List<IDictionary<string, ITaskItem[]>>(1) 1162new Dictionary<string, ITaskItem[]>(StringComparer.OrdinalIgnoreCase) 1218targetOutputsPerProject = new List<IDictionary<string, ITaskItem[]>>(results.Length); 1224targetOutputsPerProject?.Add(new Dictionary<string, ITaskItem[]>(StringComparer.OrdinalIgnoreCase)); 1233ITaskItem[] clonedTaskItem = new ITaskItem[resultEntry.Value.Items.Length];

53ITaskItem[] Items { get; }

98public ITaskItem[] Items

462ITaskItem[] outputs = GetItemOutputs(parameter); 697private bool SetTaskItemParameter(TaskPropertyInfo parameter, ITaskItem item) 734if (parameterType != typeof(ITaskItem[])) 801private ITaskItem[] GetItemOutputs(TaskPropertyInfo parameter) 805if (!(outputs is ITaskItem[] taskItemOutputs)) 807taskItemOutputs = [(ITaskItem)outputs]; 918returnClass = new TaskFactoryWrapper(new IntrinsicTaskFactory(typeof(MSBuild)), new LoadedType(typeof(MSBuild), AssemblyLoadInfo.Create(taskExecutionHostAssembly.FullName, null), taskExecutionHostAssembly, typeof(ITaskItem)), _taskName, null); 924returnClass = new TaskFactoryWrapper(new IntrinsicTaskFactory(typeof(CallTarget)), new LoadedType(typeof(CallTarget), AssemblyLoadInfo.Create(taskExecutionHostAssembly.FullName, null), taskExecutionHostAssembly, typeof(ITaskItem)), _taskName, null); 1144if (parameterType == typeof(ITaskItem)) 1369private void GatherTaskItemOutputs(bool outputTargetIsItem, string outputTargetName, ITaskItem[] outputs, ElementLocation parameterLocation, TaskPropertyInfo parameter) 1379foreach (ITaskItem output in outputs) 1451foreach (ITaskItem output in outputs)

98if (obj is ITaskItem taskItem)

291string ITaskItem.ItemSpec 315ICollection ITaskItem.MetadataNames 468string ITaskItem.GetMetadata(string metadataName) 490void ITaskItem.SetMetadata(string metadataName, string metadataValue) 511void ITaskItem.CopyMetadataTo(ITaskItem destinationItem) 522IDictionary ITaskItem.CloneCustomMetadata() 1392public void CopyMetadataTo(ITaskItem destinationItem) 1412public void CopyMetadataTo(ITaskItem destinationItem, bool addOriginalItemSpec)

1703paramType = Type.GetType(expandedType + "," + typeof(ITaskItem).GetTypeInfo().Assembly.FullName, false /* don't throw on error */, true /* case-insensitive */) ?? 1709Type.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,

1528private ITaskItem ReadTaskItem() 1557ITaskItem item = ReadTaskItem(); 1576foreach (var item in items) 1603foreach (var item in items) 1619private IList<ITaskItem>? ReadTaskItemList() 1627var list = new ITaskItem[count]; 1631ITaskItem item = ReadTaskItem();

908else if (items is ICollection<ITaskItem> genericList) 931if (item is ITaskItem taskItem) 1036if (item is ITaskItem taskItem && !string.IsNullOrEmpty(taskItem.ItemSpec)) 1047private void Write(ITaskItem item, bool writeMetadata = true)

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

392foreach (ITaskItem item in targetOutputs)

1151if (kvp.item is ITaskItem taskItem) 1168if (metadataContainer is ITaskItem taskItem)

129else if (typeof(ITaskItem[]).GetTypeInfo().IsAssignableFrom(wrappedParameterType.GetTypeInfo())) 132ITaskItem[] inputAsITaskItemArray = (ITaskItem[])wrappedParameter; 133ITaskItem[] taskItemArrayParameter = new ITaskItem[inputAsITaskItemArray.Length]; 175else if (typeof(ITaskItem).IsAssignableFrom(wrappedParameterType)) 178_wrappedParameter = CreateNewTaskItemFrom((ITaskItem)wrappedParameter); 289private ITaskItem CreateNewTaskItemFrom(ITaskItem copyFrom) 349ITaskItem[] wrappedItems = (ITaskItem[])_wrappedParameter; 354foreach (ITaskItem wrappedItem in wrappedItems) 363ITaskItem[] wrappedItems = new ITaskItem[length]; 381WriteITaskItem(translator, (ITaskItem)_wrappedParameter); 385ITaskItem wrappedItem = null; 394private void WriteITaskItem(ITranslator translator, ITaskItem wrappedItem) 461private void ReadITaskItem(ITranslator translator, ref ITaskItem wrappedItem) 886public void CopyMetadataTo(ITaskItem destinationItem)

24parameterType.GetTypeInfo().IsValueType || parameterType == typeof(string) || parameterType == typeof(ITaskItem); 33parameterType == typeof(ITaskItem[]); 42bool result = typeof(ITaskItem[]).GetTypeInfo().IsAssignableFrom(parameterType.GetTypeInfo()) || /* ITaskItem array or derived type, or */ 43typeof(ITaskItem).IsAssignableFrom(parameterType); /* ITaskItem or derived type */

377return type != null ? new LoadedType(type, _assemblyLoadInfo, _loadedAssembly ?? type.Assembly, typeof(ITaskItem), loadedViaMetadataLoadContext: false) : null; 393LoadedType loadedType = new(publicType, _assemblyLoadInfo, loadedAssembly, _context.LoadFromAssemblyPath(microsoftBuildFrameworkPath).GetType(typeof(ITaskItem).FullName), loadedViaMetadataLoadContext: true);

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

168ITaskItem toItem = new Utilities.TaskItem(); 170((ITaskItem)fromItem).CopyMetadataTo(toItem); 328ITaskItem taskItem = (ITaskItem)item; 422ITaskItem taskItem = (ITaskItem)item;

215LoadedType 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];

1292ITaskItem[] projects = new ITaskItem[] 1614ITaskItem[] projects = new ITaskItem[] 1796ITaskItem[] projects = new ITaskItem[]

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

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

186ITaskItem[] item = targetresult.Items;

730List<ITaskItem> outputListB = new List<ITaskItem>(); 731foreach (ITaskItem item in targetOutputsB) 741List<ITaskItem> outputListC = new List<ITaskItem>(); 742foreach (ITaskItem item in targetOutputsC)

234private ITaskItem _itemOutput; 239private ITaskItem[] _itemArrayOutput; 613public ITaskItem ItemParam 625public ITaskItem[] ItemArrayParam 1093public ITaskItem NullITaskItemOutput 1119public ITaskItem[] NullITaskItemArrayOutput 1145public ITaskItem ItemOutput 1158public ITaskItem[] ItemArrayOutput 1171public 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>()); 1248LoadedType loadedType = new LoadedType(typeof(TaskBuilderTestTask.TaskBuilderTestTaskFactory), loadInfo, typeof(TaskBuilderTestTask.TaskBuilderTestTaskFactory).Assembly, typeof(ITaskItem)); 1276_oneItem = new ITaskItem[] { new TaskItem(item) }; 1284_twoItems = new ITaskItem[] { new TaskItem(item), new TaskItem(item2) }; 1309private void ValidateOutputItem(string outputName, ITaskItem value) 1336private void ValidateOutputItems(string outputName, ITaskItem[] values) 1380ITaskItem actualItem = _parametersSetOnTask[parameterName] as ITaskItem; 1388private void ValidateTaskParameterItem(string parameterName, string value, ITaskItem expectedItem) 1394ITaskItem actualItem = _parametersSetOnTask[parameterName] as ITaskItem; 1407ITaskItem[] actualItems = _parametersSetOnTask[parameterName] as ITaskItem[]; 1415private void ValidateTaskParameterItems(string parameterName, string value, ITaskItem[] expectedItems) 1421ITaskItem[] actualItems = _parametersSetOnTask[parameterName] as ITaskItem[]; 1439ITaskItem[] actualItems = _parametersSetOnTask[parameterName] as ITaskItem[];

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

267parameters2.Add("ItemArray", new ITaskItem[] { new TaskItem("DEF"), new TaskItem("GHI"), new TaskItem("JKL") }); 574TaskHostPacketHelpers.AreEqual((ITaskItem)config.TaskParameters["TaskItemValue"].WrappedParameter, (ITaskItem)deserializedConfig.TaskParameters["TaskItemValue"].WrappedParameter); 584parameters.Add("TaskItemArrayValue", new ITaskItem[] { new TaskItem("Foo"), new TaskItem("Baz") }); 623ITaskItem[] itemArray = (ITaskItem[])config.TaskParameters["TaskItemArrayValue"].WrappedParameter; 624ITaskItem[] deserializedItemArray = (ITaskItem[])deserializedConfig.TaskParameters["TaskItemArrayValue"].WrappedParameter; 733internal static void AreEqual(ITaskItem[] x, ITaskItem[] y) 759internal 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;

1404type = typeof(ITaskItem[]).FullName; 1445type = typeof(ITaskItem).FullName; 1516type = typeof(ITaskItem).FullName; 1526type = typeof(ITaskItem[]).FullName; 1712expandedType + "," + typeof(ITaskItem).GetTypeInfo().Assembly.FullName, 2122type + "," + typeof(ITaskItem).GetTypeInfo().Assembly.FullName, 2313public 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();

201if (item is ITaskItem taskItem)

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

1276foreach (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);

40private ITaskItem _taskItemParam; 41public ITaskItem TaskItemParam

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

59public ITaskItem[] Items { get; set; } 65foreach (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)

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

196ITaskItem foo = t.WrappedParameter as ITaskItem; 205ITaskItem foo2 = t2.WrappedParameter as ITaskItem; 224ITaskItem foo = t.WrappedParameter as ITaskItem; 235ITaskItem foo2 = t2.WrappedParameter as ITaskItem; 248TaskParameter t = new TaskParameter(new ITaskItem[] { new TaskItem("foo"), new TaskItem("bar") }); 252ITaskItem[] wrappedParameter = t.WrappedParameter as ITaskItem[]; 263ITaskItem[] wrappedParameter2 = t.WrappedParameter as ITaskItem[]; 281ITaskItem foo = t.WrappedParameter as ITaskItem; 290ITaskItem foo2 = t2.WrappedParameter as ITaskItem; 306ITaskItem foo = t.WrappedParameter as ITaskItem; 315ITaskItem foo2 = t2.WrappedParameter as ITaskItem; 326ITaskItem foo4 = t4.WrappedParameter as ITaskItem; 373ITaskItem foo = t.WrappedParameter as ITaskItem; 384ITaskItem foo2 = t2.WrappedParameter as ITaskItem; 406ITaskItem foo = t.WrappedParameter as ITaskItem; 417ITaskItem foo2 = t2.WrappedParameter as ITaskItem; 430ITaskItem foo4 = t4.WrappedParameter as ITaskItem;

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)

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

61else if (value is ITaskItem ti)

26/// <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) 67public void CopyMetadataTo(ITaskItem destinationItem)

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

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

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

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

272foreach (ITaskItem response in ResponseFiles) 325ITaskItem[]? references, 338foreach (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);

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

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)]; } 948internal static void AddAnalyzersToCommandLine(CommandLineBuilderExtension commandLine, ITaskItem[]? analyzers) 957foreach (ITaskItem analyzer in analyzers) 970foreach (ITaskItem additionalFile in AdditionalFiles) 989foreach (ITaskItem embeddedFile in EmbeddedFiles) 1003foreach (ITaskItem analyzerConfigFile in AnalyzerConfigFiles) 1075private void NormalizePaths(ITaskItem[]? taskItems) 1080foreach (var item in taskItems) 1148foreach (ITaskItem reference in References)

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

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

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

85public ITaskItem[]? Imports 88get { return (ITaskItem[]?)_store[nameof(Imports)]; } 547foreach (ITaskItem response in this.ResponseFiles) 561var references = new List<ITaskItem>(this.References.Length); 562var links = new List<ITaskItem>(this.References.Length); 564foreach (ITaskItem reference in this.References)

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

56public ITaskItem? ApplicationManifest { get; set; }

443public ITaskItem OutputAssembly { get; set; } 469public ITaskItem[] SourceModules { get; set; } 471public ITaskItem[] EmbedResources { get; set; } 473public ITaskItem[] LinkResources { get; set; } 501ITaskItem OutputAssembly { get; set; } 514ITaskItem[] SourceModules { get; set; } 515ITaskItem[] EmbedResources { get; set; } 516ITaskItem[] 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)

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 ICollection<ITaskItem> GetSourceItems() 378foreach (ITaskItem item in GetSourceItems()) 617internal ITaskItem PrimarySourceItem 881ITaskItem sourceItem, 1014foreach (ITaskItem item in _sourceItems.Values)

78private readonly Dictionary<string, ITaskItem> _resolvedSDKReferences; 160internal delegate void LogExclusionReason(bool displayPrimaryReferenceMessage, AssemblyNameExtension assemblyName, Reference reference, ITaskItem referenceItem, string targetedFramework); 258ITaskItem[] resolvedSDKItems, 325_resolvedSDKReferences = new Dictionary<string, ITaskItem>(StringComparer.OrdinalIgnoreCase); 330foreach (ITaskItem resolvedSDK in resolvedSDKItems) 511ITaskItem[] referenceAssemblyFiles, 512ITaskItem[] referenceAssemblyNames, 519foreach (ITaskItem i in referenceAssemblyFiles) 529foreach (ITaskItem n in referenceAssemblyNames) 547ITaskItem referenceAssemblyName) 834private static AssemblyNameExtension GetAssemblyNameFromItemMetadata(ITaskItem item) 861private void SetPrimaryFileItem(ITaskItem referenceAssemblyFile) 1412ICollection<ITaskItem> dependees = assemblyReference.GetSourceItems(); 1485ICollection<ITaskItem> dependees = assemblyReference.GetSourceItems(); 1486foreach (ITaskItem dependee in dependees) 1613ITaskItem[] referenceAssemblyFiles, 1614ITaskItem[] referenceAssemblyNames, 2581out ITaskItem[] primaryFiles, 2582out ITaskItem[] dependencyFiles, 2583out ITaskItem[] relatedFiles, 2584out ITaskItem[] satelliteFiles, 2585out ITaskItem[] serializationAssemblyFiles, 2586out ITaskItem[] scatterFiles, 2587out ITaskItem[] copyLocalFiles) 2589var primaryItems = new List<ITaskItem>(); 2590var dependencyItems = new List<ITaskItem>(); 2591var relatedItems = new List<ITaskItem>(); 2592var satelliteItems = new List<ITaskItem>(); 2593var serializationAssemblyItems = new List<ITaskItem>(); 2594var scatterItems = new List<ITaskItem>(); 2595var copyLocalItems = new List<ITaskItem>(); 2630ITaskItem referenceItem = SetItemMetadata(relatedItems, satelliteItems, serializationAssemblyItems, scatterItems, assemblyName.FullName, reference, assemblyName); 2671private ITaskItem SetItemMetadata(List<ITaskItem> relatedItems, List<ITaskItem> satelliteItems, List<ITaskItem> serializationAssemblyItems, List<ITaskItem> scatterItems, string fusionName, Reference reference, AssemblyNameExtension assemblyName) 2699ICollection<ITaskItem> sourceItems = reference.GetSourceItems(); 2700foreach (ITaskItem sourceItem in sourceItems) 2746ITaskItem item = new TaskItem(reference.FullPathWithoutExtension + relatedFileExtension); 2757ITaskItem item = new TaskItem(Path.Combine(reference.DirectoryName, satelliteFile)); 2770ITaskItem item = new TaskItem(Path.Combine(reference.DirectoryName, serializationAssemblyFile)); 2781ITaskItem item = new TaskItem(Path.Combine(reference.DirectoryName, scatterFile)); 2811ITaskItem item = new TaskItem(reference.ImplementationAssembly); 3019private static Dictionary<string, string> RemoveNonForwardableMetadata(ITaskItem item) 3032private static void RemoveMetadatum(string key, ITaskItem item, Dictionary<string, string> removedMetadata) 3045private static void FindCopyLocalItems(ITaskItem[] items, List<ITaskItem> copyLocalItems) 3047foreach (ITaskItem i in items) 3066internal void LogHigherVersionUnresolve(bool displayPrimaryReferenceMessage, AssemblyNameExtension assemblyName, Reference reference, ITaskItem referenceItem, string targetedFramework) 3081internal void LogHigherVersionUnresolveDueToAttribute(bool displayPrimaryReferenceMessage, AssemblyNameExtension assemblyName, Reference reference, ITaskItem referenceItem, string targetedFramework) 3096internal void LogAnotherFrameworkUnResolve(bool displayPrimaryReferenceMessage, AssemblyNameExtension assemblyName, Reference reference, ITaskItem referenceItem, string targetedFramework) 3111internal void LogProfileExclusionUnresolve(bool displayPrimaryReferenceMessage, AssemblyNameExtension assemblyName, Reference reference, ITaskItem referenceItem, string targetedFramework)

170private ITaskItem[] _assemblyFiles = Array.Empty<TaskItem>(); 171private ITaskItem[] _assemblyNames = Array.Empty<TaskItem>(); 172private ITaskItem[] _installedAssemblyTables = Array.Empty<TaskItem>(); 173private ITaskItem[] _installedAssemblySubsetTables = Array.Empty<TaskItem>(); 174private ITaskItem[] _fullFrameworkAssemblyTables = Array.Empty<TaskItem>(); 175private ITaskItem[] _resolvedSDKReferences = Array.Empty<TaskItem>(); 188private ITaskItem[] _resolvedFiles = Array.Empty<TaskItem>(); 189private ITaskItem[] _resolvedDependencyFiles = Array.Empty<TaskItem>(); 190private ITaskItem[] _relatedFiles = Array.Empty<TaskItem>(); 191private ITaskItem[] _satelliteFiles = Array.Empty<TaskItem>(); 192private ITaskItem[] _serializationAssemblyFiles = Array.Empty<TaskItem>(); 193private ITaskItem[] _scatterFiles = Array.Empty<TaskItem>(); 194private ITaskItem[] _copyLocalFiles = Array.Empty<TaskItem>(); 195private ITaskItem[] _suggestedRedirects = Array.Empty<TaskItem>(); 196private List<ITaskItem> _unresolvedConflicts = new List<ITaskItem>(); 274public ITaskItem[] AssemblyFiles 382public ITaskItem[] Assemblies 405public ITaskItem[] ResolvedSDKReferences 443public ITaskItem[] InstalledAssemblyTables 465public ITaskItem[] InstalledAssemblySubsetTables 496public ITaskItem[] FullFrameworkAssemblyTables 580public ITaskItem[] AssemblyInformationCachePaths { get; set; } 914public ITaskItem[] ResolvedFiles 933public ITaskItem[] ResolvedDependencyFiles 945public ITaskItem[] RelatedFiles 958public ITaskItem[] SatelliteFiles 969public ITaskItem[] SerializationAssemblyFiles 979public ITaskItem[] ScatterFiles 990public ITaskItem[] CopyLocalFiles 1005public ITaskItem[] SuggestedRedirects 1013private List<ITaskItem> _filesWritten = new List<ITaskItem>(); 1019public ITaskItem[] FilesWritten 1050public ITaskItem[] UnresolvedAssemblyConflicts => _unresolvedConflicts.ToArray(); 1367foreach (ITaskItem sourceItem in dependeeReference.GetSourceItems()) 1472foreach (ITaskItem item in Assemblies) 1484foreach (ITaskItem item in AssemblyFiles) 1511foreach (ITaskItem installedAssemblyTable in InstalledAssemblyTables) 1557foreach (ITaskItem installedAssemblySubsetTable in InstalledAssemblySubsetTables) 1594foreach (ITaskItem profileTable in FullFrameworkAssemblyTables) 1606private void LogAttribute(ITaskItem item, string metadataName) 1868ICollection<ITaskItem> dependees = reference.GetSourceItems(); 1869foreach (ITaskItem dependee in dependees) 2594foreach (ITaskItem item in _resolvedFiles) 2760foreach (ITaskItem item in FullFrameworkAssemblyTables) 2816internal static string GenerateSubSetName(string[] frameworkSubSetNames, ITaskItem[] installedSubSetNames) 2832foreach (ITaskItem subsetItems in installedSubSetNames) 2984var holdSuggestedRedirects = new List<ITaskItem>(); 3003ITaskItem suggestedRedirect = new TaskItem(); 3020private AssemblyTableInfo[] GetInstalledAssemblyTableInfo(bool ignoreInstalledAssemblyTables, ITaskItem[] assemblyTables, GetListPath GetAssemblyListPaths, string[] targetFrameworkDirectories) 3038foreach (ITaskItem installedAssemblyTable in assemblyTables) 3107var assembliesLeft = new List<ITaskItem>(); 3108foreach (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)

42public ITaskItem[] Files { get; set; } = Array.Empty<ITaskItem>(); 63public ITaskItem[] AssignedFiles { get; private set; } 77public ITaskItem[] AssignedFilesWithCulture { get; private set; } 88public ITaskItem[] AssignedFilesWithNoCulture { get; private set; } 117public ITaskItem[] CultureNeutralAssignedFiles { get; private set; } 129AssignedFiles = new ITaskItem[Files.Length]; 130CultureNeutralAssignedFiles = new ITaskItem[Files.Length]; 131var cultureList = new List<ITaskItem>(); 132var 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)

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

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

20private ITaskItem[] _paths; 33public ITaskItem[] Paths 49public ITaskItem[] CombinedPaths { get; set; } 62var combinedPathsList = new List<ITaskItem>(); 64foreach (ITaskItem path in Paths)

24public ITaskItem[] PropertiesAndValues { get; set; } 52foreach (ITaskItem item in PropertiesAndValues)

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

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

19private ITaskItem[] _paths; 25public ITaskItem[] Paths 40public ITaskItem[] AbsolutePaths { get; set; } 48var absolutePathsList = new List<ITaskItem>(); 50foreach (ITaskItem path in Paths)

103public ITaskItem[] SourceFiles { get; set; } 105public ITaskItem[] SourceFolders { get; set; } 107public ITaskItem DestinationFolder { get; set; } 141public ITaskItem[] DestinationFiles { get; set; } 147public ITaskItem[] CopiedFiles { get; private set; } 408DestinationFiles = Array.Empty<ITaskItem>(); 409CopiedFiles = Array.Empty<ITaskItem>(); 425List<ITaskItem> destinationFilesSuccessfullyCopied; 454out List<ITaskItem> destinationFilesSuccessfullyCopied) 457destinationFilesSuccessfullyCopied = new List<ITaskItem>(DestinationFiles.Length); 520out List<ITaskItem> destinationFilesSuccessfullyCopied) 549ITaskItem destItem = DestinationFiles[i]; 576ITaskItem sourceItem = SourceFiles[fileIndex]; 577ITaskItem destItem = DestinationFiles[fileIndex]; 635destinationFilesSuccessfullyCopied = new List<ITaskItem>(DestinationFiles.Length); 722DestinationFiles = new ITaskItem[SourceFiles.Length]; 749var sourceFiles = SourceFiles != null ? new List<ITaskItem>(SourceFiles) : new List<ITaskItem>(); 750var destinationFiles = DestinationFiles != null ? new List<ITaskItem>(DestinationFiles) : new List<ITaskItem>(); 752foreach (ITaskItem sourceFolder in SourceFolders) 801DestinationFiles = 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); 100private List<ITaskItem> CreateOutputItems(Dictionary<string, string> metadataTable, Dictionary<string, string> excludeItems) 102var outputItems = new List<ITaskItem>(); 104foreach (ITaskItem i in Include) 110ITaskItem newItem = i; 140private (ITaskItem[] Element, bool NoLoggedErrors) TryExpandWildcards(ITaskItem[] expand, string attributeType) 153var expanded = new List<ITaskItem>(); 154foreach (ITaskItem i in expand) 213private static Dictionary<string, string> GetUniqueItems(ITaskItem[] items) 219foreach (ITaskItem item in items)

29private ITaskItem[] _resourceFiles; 33protected Dictionary<string, ITaskItem> itemSpecToTaskitem = new Dictionary<string, ITaskItem>(StringComparer.OrdinalIgnoreCase); 49public ITaskItem[] ResourceFiles 69public ITaskItem[] ManifestResourceNames { get; private set; } 75public ITaskItem[] ResourceFilesWithManifestResourceNames { get; set; } 124ManifestResourceNames = new ITaskItem[ResourceFiles.Length]; 125ResourceFilesWithManifestResourceNames = new ITaskItem[ResourceFiles.Length]; 142foreach (ITaskItem resourceFile in ResourceFiles)

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

24private ITaskItem[] _files; 28public ITaskItem[] Files 45public ITaskItem[] DeletedFiles { get; set; } 106var deletedFilesList = new List<ITaskItem>(); 109foreach (ITaskItem file in Files) 142ITaskItem deletedFile = new TaskItem(file); 178private void LogError(ITaskItem file, Exception e, string lockedFileMessage)

28public ITaskItem DestinationFileName { get; set; } 31/// Gets or sets a <see cref="ITaskItem"/> that specifies the destination folder to download the file to. 34public ITaskItem DestinationFolder { get; set; } 37/// Gets or sets a <see cref="ITaskItem"/> that contains details about the downloaded file. 40public ITaskItem DownloadedFile { get; set; }

49private ITaskItem[] _outputs; 54private readonly List<ITaskItem> _nonEmptyOutput = new List<ITaskItem>(); 174public ITaskItem[] Outputs 176get => _outputs ?? Array.Empty<ITaskItem>(); 186public ITaskItem[] ConsoleOutput => !ConsoleToMSBuild ? Array.Empty<ITaskItem>() : _nonEmptyOutput.ToArray();

38public ITaskItem[] Files { get; set; } 65public ITaskItem[] Items { get; set; } 86var file = Files[index];

24public ITaskItem File { get; set; } 30public ITaskItem[] Lines { get; set; } = Array.Empty<ITaskItem>(); 47var nonEmptyLines = new List<ITaskItem>();

28public ITaskItem File { get; set; } 33public ITaskItem[] Lines { get; set; } 77foreach (ITaskItem line in Lines)

21private ITaskItem[] _primaryList; 22private ITaskItem[] _secondaryList; 35public ITaskItem[] PrimaryList 49public ITaskItem[] SecondaryList 69public ITaskItem AppConfigFile { get; set; } 120private bool IsMatchingItem(ITaskItem item, bool matchWholeItemSpec)

20private ITaskItem[] _list; 26public ITaskItem[] List 46public ITaskItem ItemFound { get; set; } 75foreach (ITaskItem item in List) 103private bool IsMatchingItem(StringComparison comparison, ITaskItem item)

50public ITaskItem[] ProjectReferences { get; set; } 68public ITaskItem[] InvalidReferences { get; private set; } 79var invalidReferences = new List<ITaskItem>(); 85foreach (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; }

28public ITaskItem EntryPoint { get; set; } 39public 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) 1708ITaskItem[] inputs = this.References ?? [.. (this.AdditionalInputs ?? [])]; 1710foreach (ITaskItem input in inputs) 2062OutputResources = new ITaskItem[Sources.Length]; 2110ITaskItem[] temp = new ITaskItem[OutputResources.Length - _unsuccessfullyCreatedOutFiles.Count]; 2141foreach (ITaskItem item in this.OutputResources) 2290private ITaskItem[] _assemblyFiles; 2301private List<ITaskItem> _inFiles; 2306private List<ITaskItem> _satelliteInFiles; 2311private List<ITaskItem> _outFiles; 2325internal List<ITaskItem> ExtractedResWFiles 2331_extractedResWFiles = new List<ITaskItem>(); 2336private List<ITaskItem> _extractedResWFiles; 2391ITaskItem[] assemblyFilesList, 2392List<ITaskItem> inputs, 2393List<ITaskItem> satelliteInputs, 2394List<ITaskItem> outputs, 2528ITaskItem assemblyFile = _assemblyFiles[i]; 2707ITaskItem 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; }

26private ITaskItem[] _assemblyFiles; 29public ITaskItem[] AssemblyFiles 40public ITaskItem[] Assemblies { get; set; } 58var list = new List<ITaskItem>(); 59foreach (ITaskItem item in AssemblyFiles) 77ITaskItem newItem = new TaskItem(an.FullName);

23public ITaskItem[] AnnotatedProjects { get; set; } 42public ITaskItem[]? AssignedProjectsWithPlatform { get; set; } 46AnnotatedProjects = Array.Empty<ITaskItem>(); 54AssignedProjectsWithPlatform = 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; }

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

24public ITaskItem Path { get; set; } 29public ITaskItem[] Files { get; set; } = Array.Empty<ITaskItem>(); 40public ITaskItem[] InPath { get; set; } 46public ITaskItem[] OutOfPath { get; set; } 53var inPathList = new List<ITaskItem>(); 54var outOfPathList = new List<ITaskItem>(); 76foreach (ITaskItem item in Files)

21public ITaskItem[] Inputs { get; set; } = Array.Empty<ITaskItem>(); 27public ITaskItem[] Filtered { get; set; } 43Filtered = Array.Empty<ITaskItem>(); 49var filteredList = new List<ITaskItem>(Inputs.Length); 51foreach (ITaskItem item in Inputs)

20public ITaskItem[] Directories 32public ITaskItem[] DirectoriesCreated { get; private set; } 36private ITaskItem[] _directories; 45var items = new List<ITaskItem>(); 48foreach (ITaskItem directory in Directories)

417private static ITaskItem[] RemoveDuplicateItems(ITaskItem[] items) 429var list = new Dictionary<string, ITaskItem>(); 430foreach (ITaskItem item in items) 457public static ITaskItem[] SortItems(ITaskItem[] items) 459ITaskItem[] outputItems = RemoveDuplicateItems(items); 616if (!(obj1 is ITaskItem) || !(obj2 is ITaskItem)) 621ITaskItem item1 = obj1 as ITaskItem; 622ITaskItem item2 = obj2 as ITaskItem;

28ITaskItem item, 60ITaskItem item,

44public ITaskItem[] SourceFiles { get; set; } 49public ITaskItem DestinationFolder { get; set; } 62public ITaskItem[] DestinationFiles { get; set; } 68public ITaskItem[] MovedFiles { get; private set; } 96DestinationFiles = Array.Empty<ITaskItem>(); 97MovedFiles = Array.Empty<ITaskItem>(); 125DestinationFiles = new ITaskItem[SourceFiles.Length]; 140DestinationFiles = Array.Empty<ITaskItem>(); 150var 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; 271singleProject = new List<ITaskItem>(1) { null }; 280ITaskItem project = Projects[i]; 375var projectsToBuildInParallel = new List<ITaskItem>(); 478List<ITaskItem> projects, 486List<ITaskItem> targetOutputs, 612IList<IDictionary<string, ITaskItem[]>> targetOutputsPerProject = result.TargetOutputsPerProject; 624if (targetOutputsPerProject[i].TryGetValue(targetName, out ITaskItem[] outputItemsFromTarget)) 626foreach (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; }

24private ITaskItem[] _directories; 27public ITaskItem[] Directories 42public ITaskItem[] RemovedDirectories { get; set; } 52var removedDirectoriesList = new List<ITaskItem>(); 54foreach (ITaskItem directory in Directories) 114private bool RemoveDirectory(ITaskItem directory, bool logUnauthorizedError, out bool unauthorizedAccess)

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; } 130private static bool HasExcludedFileOrSP1File(ITaskItem[] candidateFiles) 134foreach (ITaskItem file in candidateFiles) 150private static bool IsExcludedFileOrSP1File(ITaskItem candidateFile)

36ITaskItem[] TypeLibNames { get; set; } 41ITaskItem[] TypeLibFiles { get; set; } 64ITaskItem[] ResolvedAssemblyReferences { get; set; } 108ITaskItem[] ResolvedFiles { get; set; } 114ITaskItem[] ResolvedModules { get; set; } 152public ITaskItem[] TypeLibNames { get; set; } 154public ITaskItem[] TypeLibFiles { get; set; } 162public ITaskItem[] ResolvedAssemblyReferences { get; set; } 179public ITaskItem[] ResolvedFiles { get; set; } 182public ITaskItem[] ResolvedModules { get; set; }

43private ITaskItem[] _extraFiles; 44private ITaskItem[] _files; 45private ITaskItem[] _managedAssemblies; 46private ITaskItem[] _nativeAssemblies; 47private ITaskItem[] _publishFiles; 48private ITaskItem[] _satelliteAssemblies; 56private Dictionary<string, ITaskItem> _runtimePackAssets; 63public ITaskItem DeploymentManifestEntryPoint { get; set; } 65public ITaskItem EntryPoint { get; set; } 67public ITaskItem[] ExtraFiles 73public ITaskItem[] Files 79public ITaskItem[] ManagedAssemblies 85public ITaskItem[] NativeAssemblies 92public ITaskItem[] RuntimePackAssets { get; set; } 101public ITaskItem[] OutputAssemblies { get; set; } 104public ITaskItem OutputDeploymentManifestEntryPoint { get; set; } 107public ITaskItem OutputEntryPoint { get; set; } 110public ITaskItem[] OutputFiles { get; set; } 112public ITaskItem[] PublishFiles 118public ITaskItem[] SatelliteAssemblies 257private static ITaskItem CreateAssemblyItem(ITaskItem item, string group, string targetPath, string includeHash) 259ITaskItem outputItem = new TaskItem(item.ItemSpec); 280private ITaskItem CreateFileItem(ITaskItem item, string group, string targetPath, string includeHash, bool isDataFile) 282ITaskItem outputItem = new TaskItem(item.ItemSpec); 321private static ITaskItem CreatePrerequisiteItem(ITaskItem item) 323ITaskItem outputItem = new TaskItem(item.ItemSpec); 329private static bool GetItemCopyLocal(ITaskItem item) 341private static CultureInfo GetItemCulture(ITaskItem item) 355private static string GetItemTargetPath(ITaskItem item) 379private void GetOutputAssemblies(List<PublishInfo> publishInfos, List<ITaskItem> assemblyList) 386foreach (ITaskItem item in _managedAssemblies) 421foreach (ITaskItem item in _nativeAssemblies) 491private ITaskItem[] GetOutputAssembliesAndSatellites(List<PublishInfo> assemblyPublishInfos, List<PublishInfo> satellitePublishInfos) 493var assemblyList = new List<ITaskItem>(); 499private ITaskItem[] GetOutputFiles(List<PublishInfo> publishInfos, IEnumerable<ITaskItem> outputAssemblies) 501var fileList = new List<ITaskItem>(); 510foreach (ITaskItem item in Files) 518outputAssembliesMap.TryGetValue(key, out var assembly); 549foreach (ITaskItem item in ExtraFiles) 598private void GetOutputSatellites(List<PublishInfo> publishInfos, List<ITaskItem> assemblyList) 604foreach (ITaskItem item in _satelliteAssemblies) 661private ITaskItem GetOutputEntryPoint(ITaskItem entryPoint, List<PublishInfo> manifestEntryPointList) 711foreach (ITaskItem item in PublishFiles) 737private bool IsFiltered(ITaskItem item) 802public PublishInfo(ITaskItem item) 816public readonly ITaskItem item; 819public MapEntry(ITaskItem item, bool includedByDefault) 846public void Add(ITaskItem item) 906public bool ContainsItem(ITaskItem item) 916public void Add(ITaskItem item) 955public 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];

82private ITaskItem[] _sdkReferences = Array.Empty<ITaskItem>(); 87private ITaskItem[] _installedSDKs = Array.Empty<ITaskItem>(); 118public ITaskItem[] SDKReferences 134public ITaskItem[] InstalledSDKs 196public ITaskItem[] References { get; set; } 202public ITaskItem[] DisallowedSDKDependencies { get; set; } 208public ITaskItem[] RuntimeReferenceOnlySDKDependencies { get; set; } 245public ITaskItem[] ResolvedSDKReferences { get; private set; } 274ResolvedSDKReferences = Array.Empty<ITaskItem>(); 286foreach (ITaskItem runtimeDependencyOnlyItem in RuntimeReferenceOnlySDKDependencies) 296var sdkItems = new Dictionary<string, ITaskItem>(InstalledSDKs.Length, StringComparer.OrdinalIgnoreCase); 298foreach (ITaskItem installedsdk in InstalledSDKs) 314foreach (ITaskItem referenceItem in References) 338foreach (ITaskItem referenceItem in SDKReferences) 558internal SDKReference ParseSDKReference(ITaskItem referenceItem) 727public SDKReference(ITaskItem taskItem, string sdkName, string sdkVersion) 750public ITaskItem ReferenceItem { get; } 795public ITaskItem ResolvedItem { get; set; } 908public 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) 910if (sdks.TryGetValue(SDKName, out ITaskItem sdk)) 996private static string GetItemMetadataTrimmed(ITaskItem item, string metadataName)

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

79public ITaskItem OutputAssembly { get; set; } 81public ITaskItem[] References { get; set; } 83public ITaskItem[] Sources { get; set; } 101foreach (ITaskItem reference in References)

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

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

35public ITaskItem SigningTarget { get; set; }

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

43public ITaskItem[] Files { get; set; } 49public ITaskItem[] TouchedFiles { get; set; } 89var touchedItems = new List<ITaskItem>(); 92foreach (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; }

45/// Gets or sets a <see cref="ITaskItem"/> with a destination folder path to unzip the files to. 48public ITaskItem DestinationFolder { get; set; } 61/// Gets or sets an array of <see cref="ITaskItem"/> objects containing the paths to .zip archive files to unzip. 64public ITaskItem[] SourceFiles { get; set; } 107foreach (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; }

58public ITaskItem[] AssemblyAttributes { get; set; } 64public ITaskItem OutputDirectory { get; set; } 74public ITaskItem OutputFile { get; set; } 185foreach (ITaskItem attributeItem in AssemblyAttributes)

29public ITaskItem XmlInputPath { get; set; } 46public ITaskItem[] Result { get; private set; } 149Result = new ITaskItem[peekValues.Count]; 233public XmlInput(ITaskItem xmlInputPath, string xmlContent)

29public ITaskItem XmlInputPath { get; set; } 40public ITaskItem Value { get; set; }

30private ITaskItem[] _outputPaths; 38public ITaskItem[] XmlInputPaths { get; set; } 48public ITaskItem XslInputPath { get; set; } 63public ITaskItem XslCompiledDllPath { get; set; } 69public ITaskItem[] OutputPaths 272public XmlInput(ITaskItem[] xmlFile, string xml) 378public XsltInput(ITaskItem xsltFile, string xslt, ITaskItem xsltCompiledDll, TaskLoggingHelper logTool, bool preserveWhitespace)

17/// Gets or sets a <see cref="ITaskItem"/> containing the full path to the destination file to create. 20public ITaskItem DestinationFile { get; set; } 28/// Gets or sets a <see cref="ITaskItem"/> containing the full path to the source directory to create a zip archive from. 31public ITaskItem SourceDirectory { get; set; }

2951protected static bool ContainsItem(ITaskItem[] items, string spec) 2953foreach (ITaskItem item in items) 3001t.InstalledAssemblyTables = new ITaskItem[] { new TaskItem(redistListPath) }; 3034ITaskItem[] loadModeResolvedFiles = Array.Empty<TaskItem>(); 3037loadModeResolvedFiles = (ITaskItem[])t.ResolvedFiles.Clone(); 3130internal void ExecuteRAROnItemsAndRedist(ResolveAssemblyReference t, MockEngine e, ITaskItem[] items, string redistString, bool consistencyCheck) 3138internal void ExecuteRAROnItemsAndRedist(ResolveAssemblyReference t, MockEngine e, ITaskItem[] items, string redistString, bool consistencyCheck, List<string> additionalSearchPaths)

51t.Assemblies = new ITaskItem[] 96t.Assemblies = new ITaskItem[] { 146t.Assemblies = new ITaskItem[] { 185t.Assemblies = new ITaskItem[] 228t.Assemblies = new ITaskItem[] 281t.Assemblies = new ITaskItem[] 320t.Assemblies = new ITaskItem[] 359t.Assemblies = new ITaskItem[] 399t.Assemblies = new ITaskItem[] 442t.Assemblies = new ITaskItem[]

26ITaskItem i = new TaskItem("MyResource.fr.resx"); 27t.Files = new ITaskItem[] { i }; 45ITaskItem i = new TaskItem("MyResource.fr.resx"); 47t.Files = new ITaskItem[] { i }; 67ITaskItem i = new TaskItem("MyResource.fr.resx"); 69t.Files = new ITaskItem[] { i }; 88ITaskItem i = new TaskItem("MyResource.fr.resx"); 90t.Files = new ITaskItem[] { i }; 111ITaskItem i = new TaskItem("MyResource.resx"); 112t.Files = new ITaskItem[] { i }; 130ITaskItem i = new TaskItem("MyResource"); 131t.Files = new ITaskItem[] { i }; 150ITaskItem i = new TaskItem("MyResource..resx"); 151t.Files = new ITaskItem[] { i }; 171ITaskItem i = new TaskItem("MyResource.fr.resx"); 173t.Files = new ITaskItem[] { i }; 196ITaskItem i = new TaskItem($"MyResource.{culture}.resx"); 197t.Files = new ITaskItem[] { i }; 218ITaskItem i = new TaskItem($"MyResource.{culture}.resx"); 219t.Files = new ITaskItem[] { i }; 236ITaskItem i = new TaskItem($"MyResource.{culture}.resx"); 237t.Files = new ITaskItem[] { i }; 253ITaskItem i = new TaskItem($"MyResource.{culture}.resx"); 254t.Files = new ITaskItem[] { i }; 273ITaskItem i = new TaskItem("MyResource.fr.resx"); 275t.Files = new ITaskItem[] { i }; 294ITaskItem i = new TaskItem("MyResource.fr.resx"); 296t.Files = new ITaskItem[] { i };

46ITaskItem item = GetParentedTaskItem(_defaultItemSpec); 52Items = new ITaskItem[] { new TaskItem(item) } 66ITaskItem item = GetParentedTaskItem(_defaultItemSpec); 71Items = new ITaskItem[] { new TaskItem(item) } 92ITaskItem item1 = GetParentedTaskItem(itemSpec: "|||"); 93ITaskItem item2 = GetParentedTaskItem(_defaultItemSpec); 98Items = new ITaskItem[] { new TaskItem(item1), new TaskItem(item2) } 117ITaskItem item = GetParentedTaskItem(_defaultItemSpec, Path.Combine("SubFolder2", "SubSubFolder", "a.cs")); 122Items = new ITaskItem[] { new TaskItem(item) } 137var item = GetParentedTaskItem(NativeMethodsShared.IsUnixLike 144Items = new ITaskItem[] { new TaskItem(item) } 159ITaskItem item = new TaskItem(Path.Combine("SubFolder", "a.cs")); 164Items = new ITaskItem[] { item } 175private ITaskItem GetParentedTaskItem(string itemSpec, string linkMetadata = null) 191ITaskItem item = pi.AddItem("Foo", itemSpec, metadata);

23t.Files = new ITaskItem[] 38t.Files = new ITaskItem[] 52t.Files = new ITaskItem[] 73t.Files = new ITaskItem[] 98t.Files = new ITaskItem[]

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

33t.Paths = new ITaskItem[] { new TaskItem(path1), new TaskItem(path2) }; 62? new ITaskItem[] { new TaskItem(path1), new TaskItem(path2), new TaskItem(path3) } 63: new ITaskItem[] { new TaskItem(path1), new TaskItem(path2) }; 83t.Paths = new ITaskItem[] { new TaskItem(path1), new TaskItem(path2) }; 111? new ITaskItem[] { new TaskItem(path1), new TaskItem(path2), new TaskItem(path3) } 112: new ITaskItem[] { new TaskItem(path1), new TaskItem(path2) }; 131t.Paths = new ITaskItem[] { new TaskItem(@"jkl\mno.txt") }; 139t.Paths = new ITaskItem[] { new TaskItem("jkl/mno.txt") }; 160t.Paths = new ITaskItem[] { new TaskItem(@"jkl\mno.txt"), new TaskItem(@"c:\abc\def\ghi.txt") }; 179t.Paths = System.Array.Empty<ITaskItem>(); 196t.Paths = new ITaskItem[] { new TaskItem("") }; 214t.Paths = new ITaskItem[] { new TaskItem("ghi.txt"), new TaskItem("|.txt"), new TaskItem("jkl.txt") };

26var 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") };

42new object[] { Array.Empty<ITaskItem>() }, 150SourceFiles = new ITaskItem[] { new TaskItem(sourceFile.Path) }, 151DestinationFiles = new ITaskItem[] { new TaskItem("destination.txt") }, 175SourceFiles = new ITaskItem[] { new TaskItem(sourceFile.Path) }, 218SourceFolders = new ITaskItem[] { new TaskItem(s0Folder.Path), new TaskItem(s1Folder.Path) }, 273SourceFiles = new ITaskItem[] { new TaskItem(sourceFile.Path) }, 274SourceFolders = new ITaskItem[] { new TaskItem(sourceFolder.Path) }, 288public void CopyWithEmptySourceFiles(ITaskItem[] sourceFiles) 312public void CopyWithEmptySourceFolders(ITaskItem[] sourceFolders) 336public void CopyWithNoDestination(ITaskItem[] destinationFiles) 346SourceFiles = new ITaskItem[] { new TaskItem(sourceFile.Path) }, 370SourceFiles = new ITaskItem[] { new TaskItem(sourceFile.Path) }, 371DestinationFiles = new ITaskItem[] { new TaskItem("destination.txt") }, 394SourceFiles = new ITaskItem[] { new TaskItem(sourceFile.Path) }, 395SourceFolders = new ITaskItem[] { new TaskItem(sourceFolder.Path) }, 396DestinationFiles = new ITaskItem[] { new TaskItem("destination0.txt"), new TaskItem("destination1.txt") }, 417SourceFiles = new ITaskItem[] { new TaskItem(sourceFile.Path) }, 418DestinationFiles = new ITaskItem[] { new TaskItem("destination0.txt"), new TaskItem("destination1.txt") }, 442SourceFiles = new ITaskItem[] { new TaskItem(sourceFile.Path) }, 443DestinationFiles = new ITaskItem[] { new TaskItem("destination.txt") }, 468SourceFiles = new ITaskItem[] { new TaskItem(sourceFile.Path) }, 469DestinationFiles = new ITaskItem[] { new TaskItem("destination.txt") }, 496ITaskItem f = new TaskItem(file); 497ITaskItem[] sourceFiles = { f }; 498ITaskItem[] destinationFiles = { f }; 543ITaskItem sourceItem = new TaskItem(source); 544ITaskItem destinationItem = new TaskItem(destination); 545ITaskItem[] sourceFiles = { sourceItem }; 546ITaskItem[] destinationFiles = { destinationItem }; 603ITaskItem sourceItem = new TaskItem(source); 604ITaskItem destinationItem = new TaskItem(destination); 605ITaskItem[] sourceFiles = { sourceItem }; 606ITaskItem[] destinationFiles = { destinationItem }; 655ITaskItem sourceItem = new TaskItem(source); 656ITaskItem destinationItem = new TaskItem(destination); 657ITaskItem[] sourceFiles = { sourceItem }; 658ITaskItem[] destinationFiles = { destinationItem }; 712ITaskItem sourceItem = new TaskItem(source); 713ITaskItem destinationItem = new TaskItem(destination); 714ITaskItem[] sourceFiles = { sourceItem }; 715ITaskItem[] destinationFiles = { destinationItem }; 779ITaskItem sourceItem = new TaskItem(source); 780ITaskItem destinationItem = new TaskItem(destination); 781ITaskItem[] sourceFiles = { sourceItem }; 782ITaskItem[] destinationFiles = { destinationItem }; 846ITaskItem sourceItem = new TaskItem(source); 847ITaskItem destinationItem = new TaskItem(destination); 848ITaskItem[] sourceFiles = { sourceItem }; 849ITaskItem[] destinationFiles = { destinationItem }; 913ITaskItem sourceItem = new TaskItem(source); 914ITaskItem destinationItem = new TaskItem(destination); 915ITaskItem[] sourceFiles = { sourceItem }; 916ITaskItem[] destinationFiles = { destinationItem }; 987ITaskItem sourceItem1 = new TaskItem(source1); 988ITaskItem sourceItem2 = new TaskItem(source2); 989ITaskItem[] sourceFiles = new ITaskItem[] { sourceItem1, sourceItem2 }; 1054ITaskItem[] sourceFiles = { new TaskItem(sourceFile) }; 1055ITaskItem[] destinationFiles = { new TaskItem(destinationFile) }; 1187ITaskItem[] sourceFiles = { new TaskItem(sourceFile) }; 1188ITaskItem[] destinationFiles = { new TaskItem(destinationFile) }; 1227ITaskItem[] sourceFiles = { new TaskItem(sourceFile) }; 1228ITaskItem[] destinationFiles = { new TaskItem(destinationFile) }; 1272ITaskItem[] sourceFiles = { new TaskItem(sourceFile) }; 1273ITaskItem[] destinationFiles = { new TaskItem(destinationFile) }; 1319ITaskItem[] sourceFiles = { new TaskItem(sourceFile) }; 1320ITaskItem[] destinationFiles = { new TaskItem(destinationFile) }; 1365ITaskItem[] sourceFiles = { new TaskItem(sourceFile) }; 1373DestinationFiles = new ITaskItem[] { new TaskItem(destinationFile) }, 1491ITaskItem[] sourceFiles = { new TaskItem(sourceFile) }; 1537ITaskItem[] sourceFiles = { new TaskItem(sourceFile) }; 1538ITaskItem[] destinationFiles = { new TaskItem(destinationFile) }; 1604ITaskItem i1 = new TaskItem(inFile1); 1609ITaskItem o1 = new TaskItem(validOutFile); 1682SourceFiles = new ITaskItem[] { new TaskItem(file) }, 1683DestinationFiles = new ITaskItem[] { new TaskItem(file) }, 1701SourceFiles = new ITaskItem[] { new TaskItem(file) }, 1702DestinationFiles = new ITaskItem[] { new TaskItem(file) }, 1753SourceFiles = new ITaskItem[] { new TaskItem(file) }, 1754DestinationFiles = new ITaskItem[] { new TaskItem(filename.ToLowerInvariant()) }, 1807SourceFiles = new ITaskItem[] { new TaskItem(file), new TaskItem(invalidFile) }, 1808DestinationFiles = new ITaskItem[] { new TaskItem(file), new TaskItem(dest2) }, 1861ITaskItem[] sourceFiles = { new TaskItem(sourceFile) }; 1934ITaskItem[] sourceFiles = { new TaskItem(sourceFileEscaped) }; 1983ITaskItem[] sourceFiles = 1991foreach (ITaskItem item in sourceFiles) 2040ITaskItem[] sourceFiles = 2049foreach (ITaskItem item in sourceFiles) 2057ITaskItem[] destFiles = 2141SourceFiles = new ITaskItem[] { new TaskItem(inFile1), new TaskItem(inFile2) }, 2142DestinationFiles = new ITaskItem[] { new TaskItem(outFile1) }, 2182ITaskItem[] sourceFiles = { new TaskItem(sourceFile) }; 2183ITaskItem[] destinationFiles = { new TaskItem(destinationFile) }; 2220ITaskItem[] sourceFiles = { new TaskItem(sourceFile) }; 2221ITaskItem[] destinationFiles = { new TaskItem(destinationFile) }; 2253SourceFiles = new ITaskItem[] { new TaskItem("foo | bar") }, 2277SourceFiles = new ITaskItem[] { new TaskItem("foo") }, 2301SourceFiles = new ITaskItem[] { new TaskItem("c:\\source") }, 2302DestinationFiles = new ITaskItem[] { new TaskItem("c:\\destination") }, 2322SourceFiles = new ITaskItem[] { new TaskItem("c:\\source") }, 2323DestinationFiles = new ITaskItem[] { new TaskItem("c:\\destination") }, 2347SourceFiles = new ITaskItem[] { new TaskItem("c:\\source") }, 2348DestinationFiles = new ITaskItem[] { new TaskItem("c:\\destination") }, 2414SourceFiles = new ITaskItem[] { new TaskItem("c:\\source") }, 2415DestinationFiles = new ITaskItem[] { new TaskItem("c:\\destination") }, 2441SourceFiles = new ITaskItem[] { new TaskItem("c:\\source"), new TaskItem("c:\\source2") }, 2442DestinationFiles = new ITaskItem[] { new TaskItem("c:\\destination"), new TaskItem("c:\\destination2") }, 2473SourceFiles = new ITaskItem[] { new TaskItem("c:\\source") }, 2474DestinationFiles = new ITaskItem[] { new TaskItem("c:\\destination") }, 2502SourceFiles = new ITaskItem[] { new TaskItem("c:\\source") }, 2503DestinationFiles = new ITaskItem[] { new TaskItem("c:\\destination") }, 2537SourceFiles = new ITaskItem[] { new TaskItem(source) }, 2538DestinationFiles = new ITaskItem[] { new TaskItem(existing) }, 2562ITaskItem[] sourceFiles = { new TaskItem(sourceFile) }; 2648ITaskItem[] sourceFiles = 2738ITaskItem[] sourceFiles = { new TaskItem(sourceFile) }; 2817ITaskItem[] sourceFiles = { new TaskItem(sourceFile) }; 2881ITaskItem[] sourceFiles = { new TaskItem(sourceFile) }; 2918SourceFiles = new ITaskItem[] { new TaskItem("c:\\source") }, 2919DestinationFiles = new ITaskItem[] { new TaskItem("c:\\destination") }, 2948ITaskItem[] sourceFiles = { new TaskItem(sourceFile1.Path) }; 2949ITaskItem[] destinationFiles = { new TaskItem(destFile) };

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;

58t.Include = new ITaskItem[] { new TaskItem("MyFile.txt") }; 59t.Exclude = new ITaskItem[] { new TaskItem("MyFile.txt") }; 76t.Include = new ITaskItem[] { new TaskItem("MyFile.txt") }; 77t.Exclude = new ITaskItem[] { new TaskItem("MyFileOther.txt") }; 95t.Include = new ITaskItem[] { new TaskItem("MyFile.txt") }; 114t.Exclude = new ITaskItem[] { new TaskItem("MyFile.txt") }; 147t.Include = new ITaskItem[] { new TaskItem("MyFile.txt") }; 148t.Exclude = new ITaskItem[] { new TaskItem("myfile.tXt") }; 230t.Include = new ITaskItem[] { new TaskItem("MyFile.txt") }; 251t.Include = new ITaskItem[] { item }; 274t.Include = new ITaskItem[] { item }; 306Include = new ITaskItem[] { new TaskItem(itemSpec) }, 358Include = new ITaskItem[] { new TaskItem(itemSpec) },

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

830ITaskItem[] 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") };

28t.Files = new ITaskItem[] { new TaskItem(@"C:\MyProject\File1.txt"), new TaskItem(@"C:\SomeoneElsesProject\File2.txt") }; 46t.Files = new ITaskItem[] { new TaskItem(@":::") }; 62t.Files = new ITaskItem[] { new TaskItem(@"foo") }; 78t.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()

286ITaskItem[] installedSDKs = t.InstalledSDKs; 291foreach (ITaskItem item in installedSDKs) 333ITaskItem[] installedSDKs = t.InstalledSDKs; 337foreach (ITaskItem item in installedSDKs) 407ITaskItem[] installedSDKs = t.InstalledSDKs; 411foreach (ITaskItem item in installedSDKs)

230ITaskItem item = new TaskItem("C:\\SDKDoesNotExist"); 239ResolvedSDKReferences = new ITaskItem[] { item }, 372ITaskItem item = new TaskItem(_sdkDirectory); 378t.ResolvedSDKReferences = new ITaskItem[] { item }; 397ITaskItem item = new TaskItem(_sdkDirectory); 404t.ResolvedSDKReferences = new ITaskItem[] { item }; 422ITaskItem item = new TaskItem(_sdkDirectory); 429t.ResolvedSDKReferences = new ITaskItem[] { item }; 488ITaskItem item1 = new TaskItem(_sdkDirectory); 495ITaskItem item2 = new TaskItem(_sdkDirectory); 504t.ResolvedSDKReferences = new ITaskItem[] { item1, item2 }; 515t.ResolvedSDKReferences = new ITaskItem[] { item1 }; 526t.ResolvedSDKReferences = new ITaskItem[] { item2 }; 546ITaskItem item = new TaskItem(_sdkDirectory); 553t.ResolvedSDKReferences = new ITaskItem[] { item }; 599ITaskItem item = new TaskItem(_sdkDirectory); 605t.ResolvedSDKReferences = new ITaskItem[] { item }; 608ITaskItem[] references1 = t.References; 623ITaskItem item2 = new TaskItem(_sdkDirectory2); 629t2.ResolvedSDKReferences = new ITaskItem[] { item2 }; 631ITaskItem[] references2 = t2.References; 635foreach (var ref2 in references2) 665ITaskItem item = new TaskItem(_sdkDirectory); 671t.ResolvedSDKReferences = new ITaskItem[] { item }; 713ITaskItem item = new TaskItem(_sdkDirectory); 719t.ResolvedSDKReferences = new ITaskItem[] { item }; 758ITaskItem item = new TaskItem(_sdkDirectory); 764t.ResolvedSDKReferences = new ITaskItem[] { item }; 781ITaskItem item = new TaskItem(_sdkDirectory); 787t.ResolvedSDKReferences = new ITaskItem[] { item }; 806ITaskItem item = new TaskItem(_sdkDirectory); 812t.ResolvedSDKReferences = new ITaskItem[] { item }; 857ITaskItem item = new TaskItem(_sdkDirectory); 864t.ResolvedSDKReferences = new ITaskItem[] { item }; 908ITaskItem item = new TaskItem(_sdkDirectory); 914t.ResolvedSDKReferences = new ITaskItem[] { item }; 943ITaskItem item = new TaskItem(_sdkDirectory); 951t.ResolvedSDKReferences = new ITaskItem[] { item }; 1008ITaskItem item = new TaskItem(_sdkDirectory); 1014t.ResolvedSDKReferences = new ITaskItem[] { item }; 1039ITaskItem item = new TaskItem(_sdkDirectory); 1045t.ResolvedSDKReferences = new ITaskItem[] { item }; 1071ITaskItem item = new TaskItem(_sdkDirectory); 1077t.ResolvedSDKReferences = new ITaskItem[] { item }; 1102ITaskItem item = new TaskItem(_sdkDirectory); 1109t.ResolvedSDKReferences = new ITaskItem[] { item }; 1130ITaskItem item = new TaskItem(_sdkDirectory); 1137t.ResolvedSDKReferences = new ITaskItem[] { item }; 1159ITaskItem item = new TaskItem(_sdkDirectory); 1166t.ResolvedSDKReferences = new ITaskItem[] { item }; 1186ITaskItem item = new TaskItem(_sdkDirectory); 1193t.ResolvedSDKReferences = new ITaskItem[] { item }; 1214ITaskItem item = new TaskItem(_sdkDirectory); 1221ITaskItem item2 = new TaskItem(_sdkDirectory2); 1228t.ResolvedSDKReferences = new ITaskItem[] { item, item2 }; 1259ITaskItem item = new TaskItem(_sdkDirectory); 1266ITaskItem item2 = new TaskItem(_sdkDirectory2); 1274t.ResolvedSDKReferences = new ITaskItem[] { item, item2 }; 1301ITaskItem item = new TaskItem(_sdkDirectory); 1308ITaskItem item2 = new TaskItem(_sdkDirectory2); 1315t.ResolvedSDKReferences = new ITaskItem[] { item, item2 }; 1347ITaskItem item = new TaskItem(_sdkDirectory); 1355ITaskItem item2 = new TaskItem(_sdkDirectory2); 1363t.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[] 81t.Directories = new ITaskItem[] 138t.Directories = new ITaskItem[] 180var dirList = new ITaskItem[] 246t.Directories = new ITaskItem[]

37ITaskItem[] sourceFiles = new ITaskItem[] { new TaskItem(sourceFile) }; 38ITaskItem[] destinationFiles = new ITaskItem[] { new TaskItem(destinationFile) }; 82ITaskItem[] sourceFiles = new ITaskItem[] { new TaskItem(sourceFile) }; 83ITaskItem[] destinationFiles = new ITaskItem[] { new TaskItem(destinationFile) }; 133ITaskItem[] sourceFiles = new ITaskItem[] { new TaskItem(sourceFile) }; 134ITaskItem[] destinationFiles = new ITaskItem[] { new TaskItem(destinationFile) }; 178ITaskItem[] sourceFiles = new ITaskItem[] { new TaskItem(sourceFile) }; 179ITaskItem[] destinationFiles = new ITaskItem[] { new TaskItem(sourceFile) }; 219ITaskItem[] sourceFiles = new ITaskItem[] { new TaskItem(sourceFile) }; 220ITaskItem[] destinationFiles = new ITaskItem[] { new TaskItem(destinationFile) }; 274ITaskItem[] sourceFiles = new ITaskItem[] { new TaskItem(sourceFile) }; 275ITaskItem[] destinationFiles = new ITaskItem[] { new TaskItem(destinationFile) }; 326ITaskItem[] sourceFiles = new ITaskItem[] { new TaskItem(sourceFile) }; 327ITaskItem[] destinationFiles = new ITaskItem[] { new TaskItem(destinationFile) }; 380ITaskItem[] sourceFiles = new ITaskItem[] { new TaskItem(sourceFile) }; 381ITaskItem[] destinationFiles = new ITaskItem[] { new TaskItem(destinationFile) }; 446ITaskItem i1 = new TaskItem(inFile1); 449t.SourceFiles = new ITaskItem[] { new TaskItem(inFile2), i1 }; 451ITaskItem o1 = new TaskItem(validOutFile); 454t.DestinationFiles = new ITaskItem[] { new TaskItem(invalidFile), o1 }; 511move.SourceFiles = new ITaskItem[] { new TaskItem(file) }; 512move.DestinationFiles = new ITaskItem[] { new TaskItem(file + "2") }; 534move.SourceFiles = new ITaskItem[] { new TaskItem("source") }; 548move.SourceFiles = new ITaskItem[] { new TaskItem("source") }; 549move.DestinationFiles = new ITaskItem[] { new TaskItem("x") }; 564move.SourceFiles = new ITaskItem[] { new TaskItem("source") }; 565move.DestinationFiles = new ITaskItem[] { new TaskItem(Directory.GetCurrentDirectory()) }; 579move.DestinationFiles = new ITaskItem[] { new TaskItem("destination") }; 580move.SourceFiles = new ITaskItem[] { new TaskItem(Directory.GetCurrentDirectory()) }; 613t.SourceFiles = new ITaskItem[] { new TaskItem(file) }; 614t.DestinationFiles = new ITaskItem[] { new TaskItem(filename.ToLowerInvariant()) }; 657t.SourceFiles = new ITaskItem[] { new TaskItem(file), new TaskItem(invalidFile) }; 658t.DestinationFiles = new ITaskItem[] { new TaskItem(file), new TaskItem(dest2) }; 693ITaskItem[] sourceFiles = new ITaskItem[] { new TaskItem(sourceFile) }; 760t.SourceFiles = new ITaskItem[] { new TaskItem(inFile1), new TaskItem(inFile2) }; 761t.DestinationFiles = new ITaskItem[] { new TaskItem(outFile1) }; 795ITaskItem[] sourceFiles = new ITaskItem[] { new TaskItem(sourceFile) }; 796ITaskItem[] destinationFiles = new ITaskItem[] { new TaskItem(destinationFile) }; 824ITaskItem[] sourceFiles = new ITaskItem[] { new TaskItem(sourceFile) }; 825ITaskItem[] destinationFiles = new ITaskItem[] { new TaskItem(destinationFile) }; 847t.SourceFiles = new ITaskItem[] { new TaskItem("foo | bar") }; 865t.SourceFiles = new ITaskItem[] { new TaskItem("source") }; 866t.DestinationFiles = new ITaskItem[] { new TaskItem("foo | bar") }; 883t.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[]

35Lines = new ITaskItem[] { new TaskItem("Line1") } 50a.Lines = new ITaskItem[] { new TaskItem("Line2"), new TaskItem("Line3") }; 82Lines = new ITaskItem[] { new TaskItem("Line1_%253b_") } 97a.Lines = new ITaskItem[] { new TaskItem("Line2"), new TaskItem("Line3") }; 127Lines = new ITaskItem[] { new TaskItem("My special character is \u00C3") } 179Lines = 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];

184ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 185ITaskItem installLocation = new TaskItem(testDirectory); 197t1.SDKReferences = new ITaskItem[] { item }; 198t1.InstalledSDKs = new ITaskItem[] { installLocation }; 215t2.SDKReferences = new ITaskItem[] { item }; 216t2.InstalledSDKs = new ITaskItem[] { installLocation }; 233t3.SDKReferences = new ITaskItem[] { item }; 234t3.InstalledSDKs = new ITaskItem[] { installLocation }; 251t3a.SDKReferences = new ITaskItem[] { item }; 252t3a.InstalledSDKs = new ITaskItem[] { installLocation }; 272t4.SDKReferences = new ITaskItem[] { item }; 273t4.InstalledSDKs = new ITaskItem[] { installLocation }; 289t5.SDKReferences = new ITaskItem[] { item }; 290t5.InstalledSDKs = new ITaskItem[] { installLocation }; 436ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 438t.SDKReferences = new ITaskItem[] { item }; 440ITaskItem installedSDK = new TaskItem(_sdkPath); 442t.InstalledSDKs = new ITaskItem[] { installedSDK }; 499ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 500t.SDKReferences = new ITaskItem[] { item }; 502ITaskItem installLocation = new TaskItem(testDirectory); 504t.InstalledSDKs = new ITaskItem[] { installLocation }; 530ITaskItem dummyItem = new TaskItem(); 544private static void TestGoodSDKReferenceIncludes(ITaskItem referenceInclude, string simpleName, string version) 558private static void TestBadSDKReferenceIncludes(ITaskItem referenceInclude) 603ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 604t.SDKReferences = new ITaskItem[] { item }; 609ITaskItem installLocation = new TaskItem(testDirectory); 611t.InstalledSDKs = new ITaskItem[] { installLocation }; 658ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 659t.SDKReferences = new ITaskItem[] { item }; 664ITaskItem installLocation = new TaskItem(testDirectory); 666t.InstalledSDKs = new ITaskItem[] { installLocation }; 716ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 717t.SDKReferences = new ITaskItem[] { item }; 722ITaskItem installLocation = new TaskItem(testDirectory); 724t.InstalledSDKs = new ITaskItem[] { installLocation }; 771ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 772t.SDKReferences = new ITaskItem[] { item }; 777ITaskItem installLocation = new TaskItem(testDirectory); 779t.InstalledSDKs = new ITaskItem[] { installLocation }; 826ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 827t.SDKReferences = new ITaskItem[] { item }; 832ITaskItem installLocation = new TaskItem(testDirectory); 834t.InstalledSDKs = new ITaskItem[] { installLocation }; 881ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 882t.SDKReferences = new ITaskItem[] { item }; 887ITaskItem installLocation = new TaskItem(testDirectory); 889t.InstalledSDKs = new ITaskItem[] { installLocation }; 938ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 939t.SDKReferences = new ITaskItem[] { item }; 944ITaskItem installLocation = new TaskItem(testDirectory); 946t.InstalledSDKs = new ITaskItem[] { installLocation }; 992ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 993t.SDKReferences = new ITaskItem[] { item }; 998ITaskItem installLocation = new TaskItem(testDirectory); 1000t.InstalledSDKs = new ITaskItem[] { installLocation }; 1047ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 1048t.SDKReferences = new ITaskItem[] { item }; 1053ITaskItem installLocation = new TaskItem(testDirectory); 1055t.InstalledSDKs = new ITaskItem[] { installLocation }; 1082ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 1083t.SDKReferences = new ITaskItem[] { item }; 1085ITaskItem installedSDK = new TaskItem(_sdkPath); 1087t.InstalledSDKs = new ITaskItem[] { installedSDK }; 1119ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 1120t.SDKReferences = new ITaskItem[] { item }; 1122ITaskItem installedSDK = new TaskItem(_sdkPath); 1124t.InstalledSDKs = new ITaskItem[] { installedSDK }; 1157ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 1161t.SDKReferences = new ITaskItem[] { item }; 1163ITaskItem installedSDK = new TaskItem(_sdkPath); 1165t.InstalledSDKs = new ITaskItem[] { installedSDK }; 1198ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 1199ITaskItem item2 = new TaskItem("GoodTestSDK, Version=2.0"); 1200t.SDKReferences = new ITaskItem[] { item, item2 }; 1202ITaskItem installedSDK = new TaskItem(_sdkPath); 1204t.InstalledSDKs = new ITaskItem[] { installedSDK }; 1234ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 1235t.SDKReferences = new ITaskItem[] { item }; 1241ITaskItem installedSDK = new TaskItem(_sdkPath); 1243t.InstalledSDKs = new ITaskItem[] { installedSDK }; 1269t.SDKReferences = new ITaskItem[] { item }; 1277t.InstalledSDKs = new ITaskItem[] { installedSDK }; 1306ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 1307t.SDKReferences = new ITaskItem[] { item }; 1309t.InstalledSDKs = Array.Empty<ITaskItem>(); 1330ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 1331t.SDKReferences = new ITaskItem[] { item }; 1334ITaskItem installedSDK1 = new TaskItem(_sdkPath); 1337ITaskItem installedSDK2 = new TaskItem(_sdkPath); 1340ITaskItem installedSDK3 = new TaskItem(String.Empty); 1343ITaskItem installedSDK4 = new TaskItem(_sdkPath); 1346ITaskItem installedSDK5 = new TaskItem(_sdkPath); 1348t.InstalledSDKs = new ITaskItem[] { installedSDK1, installedSDK2, installedSDK3, installedSDK4, installedSDK5 }; 1380ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 1381ITaskItem item2 = new TaskItem("GoodTestSDK2, Version=2.0"); 1382t.SDKReferences = new ITaskItem[] { item, item2 }; 1384ITaskItem installedSDK = new TaskItem("DoesNotExist"); 1386t.InstalledSDKs = new ITaskItem[] { installedSDK }; 1408ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 1409ITaskItem item2 = new TaskItem("RandomSDK, Version=2.0"); 1410t.SDKReferences = new ITaskItem[] { item, item2 }; 1412ITaskItem installedSDK = new TaskItem(_sdkPath); 1414t.InstalledSDKs = new ITaskItem[] { installedSDK }; 1472ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 1473t.SDKReferences = Array.Empty<ITaskItem>(); 1474ITaskItem installedSDK = new TaskItem(_sdkPath); 1476t.InstalledSDKs = new ITaskItem[] { installedSDK }; 1513ITaskItem item = new TaskItem("BadTestSDK, Version=2.0"); 1514ITaskItem item2 = new TaskItem("GoodTestSDK, Version=2.0"); 1515t.SDKReferences = new ITaskItem[] { item, item2 }; 1517ITaskItem installLocation = new TaskItem(testDirectory); 1521ITaskItem installLocation2 = new TaskItem(goodSDKLocation); 1523t.InstalledSDKs = new ITaskItem[] { installLocation, installLocation2 }; 1572ITaskItem item = new TaskItem("BadTestSDK, Version=2.0"); 1573ITaskItem item2 = new TaskItem("GoodTestSDK, Version=2.0"); 1574t.SDKReferences = new ITaskItem[] { item, item2 }; 1576ITaskItem installLocation = new TaskItem(testDirectory); 1579ITaskItem installLocation2 = new TaskItem("C:\\GoodSDKLocation"); 1581t.InstalledSDKs = new ITaskItem[] { installLocation, installLocation2 }; 1662ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 1663ITaskItem installLocation = new TaskItem(testDirectory); 1670t1.SDKReferences = new ITaskItem[] { item }; 1671t1.InstalledSDKs = new ITaskItem[] { installLocation }; 1683t2.SDKReferences = new ITaskItem[] { item }; 1684t2.InstalledSDKs = new ITaskItem[] { installLocation }; 1749ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 1750t.SDKReferences = new ITaskItem[] { item }; 1752ITaskItem installLocation = new TaskItem(testDirectory); 1754t.InstalledSDKs = new ITaskItem[] { installLocation }; 1831ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 1848t.SDKReferences = new ITaskItem[] { item }; 1850ITaskItem installLocation = new TaskItem(testDirectory); 1852t.InstalledSDKs = new ITaskItem[] { installLocation }; 1926ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 1927t.SDKReferences = new ITaskItem[] { item }; 1929ITaskItem installLocation = new TaskItem(testDirectory); 1931t.InstalledSDKs = new ITaskItem[] { installLocation }; 1997ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 1998t.SDKReferences = new ITaskItem[] { item }; 2000ITaskItem installLocation = new TaskItem(testDirectory); 2002t.InstalledSDKs = new ITaskItem[] { installLocation }; 2062ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 2063t.SDKReferences = new ITaskItem[] { item }; 2065ITaskItem installLocation = new TaskItem(testDirectory); 2067t.InstalledSDKs = new ITaskItem[] { installLocation }; 2135ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 2136t.SDKReferences = new ITaskItem[] { item }; 2138ITaskItem installLocation = new TaskItem(testDirectory); 2140t.InstalledSDKs = new ITaskItem[] { installLocation }; 2204ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 2205t.SDKReferences = new ITaskItem[] { item }; 2207ITaskItem installLocation = new TaskItem(testDirectory); 2209t.InstalledSDKs = new ITaskItem[] { installLocation }; 2274ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 2275t.SDKReferences = new ITaskItem[] { item }; 2277ITaskItem installLocation = new TaskItem(testDirectory); 2279t.InstalledSDKs = new ITaskItem[] { installLocation }; 2345ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 2346t.SDKReferences = new ITaskItem[] { item }; 2348ITaskItem installLocation = new TaskItem(testDirectory); 2350t.InstalledSDKs = new ITaskItem[] { installLocation }; 2417ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 2418t.SDKReferences = new ITaskItem[] { item }; 2420ITaskItem installLocation = new TaskItem(testDirectory); 2422t.InstalledSDKs = new ITaskItem[] { installLocation }; 2487ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 2488t.SDKReferences = new ITaskItem[] { item }; 2492ITaskItem installLocation = new TaskItem(testDirectory); 2494t.InstalledSDKs = new ITaskItem[] { installLocation }; 2561ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 2562t.SDKReferences = new ITaskItem[] { item }; 2566ITaskItem installLocation = new TaskItem(testDirectory); 2568t.InstalledSDKs = new ITaskItem[] { installLocation }; 2626ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 2629t.SDKReferences = new ITaskItem[] { item }; 2633ITaskItem installLocation = new TaskItem(testDirectory); 2635t.InstalledSDKs = new ITaskItem[] { installLocation }; 2693ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 2694t.SDKReferences = new ITaskItem[] { item }; 2698ITaskItem installLocation = new TaskItem(testDirectory); 2700t.InstalledSDKs = new ITaskItem[] { installLocation }; 2758ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 2761t.SDKReferences = new ITaskItem[] { item }; 2765ITaskItem installLocation = new TaskItem(testDirectory); 2767t.InstalledSDKs = new ITaskItem[] { installLocation }; 2843ITaskItem item = new TaskItem("GoodTestSDK, Version=1.0"); 2844ITaskItem item2 = new TaskItem("GoodTestSDK, Version=2.0"); 2845ITaskItem item3 = new TaskItem("GoodTestSDK, Version=3.0"); 2847t.SDKReferences = new ITaskItem[] { item, item2, item3 }; 2851ITaskItem installLocation = new TaskItem(testDirectory); 2854ITaskItem installLocation2 = new TaskItem(testDirectory2); 2857ITaskItem installLocation3 = new TaskItem(testDirectory3); 2860t.InstalledSDKs = new ITaskItem[] { installLocation, installLocation2, installLocation3 }; 2941ITaskItem item = new TaskItem("GoodTestSDK, Version=1.0"); 2942ITaskItem item2 = new TaskItem("GoodTestSDK2, Version=2.0"); 2943ITaskItem item3 = new TaskItem("GoodTestSDK3, Version=3.0"); 2945t.SDKReferences = new ITaskItem[] { item, item2, item3 }; 2949ITaskItem installLocation = new TaskItem(testDirectory); 2952ITaskItem installLocation2 = new TaskItem(testDirectory2); 2955ITaskItem installLocation3 = new TaskItem(testDirectory3); 2958t.InstalledSDKs = new ITaskItem[] { installLocation, installLocation2, installLocation3 }; 3049ITaskItem item = new TaskItem("GoodTestSDK, Version=1.0"); 3050ITaskItem item2 = new TaskItem("GoodTestSDK2, Version=2.0"); 3051ITaskItem item3 = new TaskItem("GoodTestSDK3, Version=3.0"); 3052ITaskItem item4 = new TaskItem("GoodTestSDK3, Version=4.0"); 3054t.SDKReferences = new ITaskItem[] { item, item2, item3, item4 }; 3058ITaskItem installLocation = new TaskItem(testDirectory); 3061ITaskItem installLocation2 = new TaskItem(testDirectory2); 3064ITaskItem installLocation3 = new TaskItem(testDirectory3); 3067ITaskItem installLocation4 = new TaskItem(testDirectory4); 3070t.InstalledSDKs = new ITaskItem[] { installLocation, installLocation2, installLocation3, installLocation4 }; 3152ITaskItem item = new TaskItem("GoodTestSDK, Version=1.0"); 3153ITaskItem item2 = new TaskItem("GoodTestSDK, Version=2.0"); 3154ITaskItem item3 = new TaskItem("GoodTestSDK, Version=3.0"); 3156t.SDKReferences = new ITaskItem[] { item, item2, item3 }; 3160ITaskItem installLocation = new TaskItem(testDirectory); 3163ITaskItem installLocation2 = new TaskItem(testDirectory2); 3166ITaskItem installLocation3 = new TaskItem(testDirectory3); 3169t.InstalledSDKs = new ITaskItem[] { installLocation, installLocation2, installLocation3 }; 3241ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 3243t.SDKReferences = new ITaskItem[] { item }; 3247ITaskItem installLocation = new TaskItem(testDirectory); 3249t.InstalledSDKs = new ITaskItem[] { installLocation }; 3315ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 3318t.SDKReferences = new ITaskItem[] { item }; 3322ITaskItem installLocation = new TaskItem(testDirectory); 3324t.InstalledSDKs = new ITaskItem[] { installLocation }; 3391ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 3394t.SDKReferences = new ITaskItem[] { item }; 3398ITaskItem installLocation = new TaskItem(testDirectory); 3400t.InstalledSDKs = new ITaskItem[] { installLocation }; 3459ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 3462t.SDKReferences = new ITaskItem[] { item }; 3466ITaskItem installLocation = new TaskItem(testDirectory); 3468t.InstalledSDKs = new ITaskItem[] { installLocation }; 3535ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 3536t.SDKReferences = new ITaskItem[] { item }; 3540ITaskItem installLocation = new TaskItem(testDirectory); 3542t.InstalledSDKs = new ITaskItem[] { installLocation }; 3598ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 3599t.SDKReferences = new ITaskItem[] { item }; 3602ITaskItem installLocation = new TaskItem(testDirectory); 3604t.InstalledSDKs = new ITaskItem[] { installLocation }; 3672ITaskItem item = new TaskItem("GoodTestSDK, Version=2.0"); 3673t.SDKReferences = new ITaskItem[] { item }; 3676ITaskItem installLocation = new TaskItem(testDirectory); 3678t.InstalledSDKs = new ITaskItem[] { installLocation }; 3821ITaskItem[] resolvedSDKReferences = result.Items; 3830ITaskItem[] SDkRedistFolders = result.Items; 3964ITaskItem[] resolvedSDKReferences = result.Items; 3973ITaskItem[] SDkRedistFolders = result.Items; 4073ITaskItem[] resolvedSDKReferences = result.Items; 4082ITaskItem[] SDkRedistFolders = result.Items; 4170ITaskItem[] resolvedSDKReferences = result.Items; 4181ITaskItem[] SDkRedistFolders = result.Items; 4201new Dictionary<string, ITaskItem>() { { "sdkName, Version=1.0.2", new TaskItem(Path.GetTempFileName(), new Dictionary<string, string>() { { "PlatformVersion", "1.0.2" } }) } }, 4299ITaskItem[] resolvedSDKReferences1 = RunBuildAndReturnResolvedSDKReferences(logger, testProjectFile, testDirectoryRoot); 4308ITaskItem[] resolvedSDKReferences2 = RunBuildAndReturnResolvedSDKReferences(logger, testProjectFile, testDirectoryRoot); 4327private ITaskItem[] RunBuildAndReturnResolvedSDKReferences(ILogger logger, string testProjectFile, string testDirectoryRoot)

68t.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 93foreach (ITaskItem item in t.FilesWritten) 120t.Sources = new ITaskItem[] { 123t.OutputResources = new ITaskItem[] { 138foreach (ITaskItem item in t.FilesWritten) 156t.Sources = new ITaskItem[] { new TaskItem(textFile) }; 176foreach (ITaskItem item in t.FilesWritten) 206t.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 207t.References = new ITaskItem[] { new TaskItem(systemDll) }; 247t.Sources = new ITaskItem[] { new TaskItem(resourcesFile) }; 248t.OutputResources = new ITaskItem[] { new TaskItem(Path.ChangeExtension(resourcesFile, ".resx")) }; 254t2a.Sources = new ITaskItem[] { new TaskItem(resourcesFile) }; 255t2a.OutputResources = new ITaskItem[] { new TaskItem(Path.ChangeExtension(resourcesFile, ".txt")) }; 261t2b.Sources = new ITaskItem[] { new TaskItem(t2a.FilesWritten[0].ItemSpec) }; 262t2b.OutputResources = new ITaskItem[] { new TaskItem(Utilities.GetTempFileName(".resx")) }; 276foreach (ITaskItem item in t2b.FilesWritten) 296t.Sources = new ITaskItem[] { new TaskItem(resourcesFile) }; 299t.OutputResources = new ITaskItem[] { new TaskItem(outputFile) }; 310foreach (ITaskItem item in t.FilesWritten) 329t.Sources = new ITaskItem[] { new TaskItem(resxFileInput) }; 355t2.Sources = new ITaskItem[] { new TaskItem(resxFileInput) }; 375t.Sources = new ITaskItem[] { new TaskItem(resxFileInput) }; 383t2.Sources = new ITaskItem[] { new TaskItem(resxFileInput) }; 408t.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 419t2.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 441foreach (ITaskItem item in t.FilesWritten) 457ITaskItem[] sources = new ITaskItem[] { new TaskItem(resxFileInput) }; 458ITaskItem[] output; 528t.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 571foreach (ITaskItem item in t.FilesWritten) 597t.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 608foreach (ITaskItem item in t.FilesWritten) 629t.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 640t2.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 659foreach (ITaskItem item in t.FilesWritten) 683createResources.Sources = new ITaskItem[] { new TaskItem(firstResx), new TaskItem(secondResx) }; 695t2.Sources = new ITaskItem[] { new TaskItem(firstResx), new TaskItem(secondResx) }; 743t.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 758t2.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 771foreach (ITaskItem item in t.FilesWritten) 799t.Sources = new ITaskItem[] { new TaskItem(resxFile), new TaskItem(txtFile) }; 815t2.Sources = new ITaskItem[] { new TaskItem(resxFile), new TaskItem(txtFile) }; 882initialCreator.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 883initialCreator.References = new ITaskItem[] { new TaskItem(localSystemDll) }; 892incrementalUpToDate.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 893incrementalUpToDate.References = new ITaskItem[] { new TaskItem(localSystemDll) }; 904incrementalOutOfDate.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 905incrementalOutOfDate.References = new ITaskItem[] { new TaskItem(localSystemDll) }; 955ITaskItem[] additionalInputs = null; 960additionalInputs = new ITaskItem[] { new TaskItem(FileUtilities.GetTemporaryFile()), new TaskItem(FileUtilities.GetTemporaryFile()) }; 962foreach (ITaskItem file in additionalInputs) 971t.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 978t2.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 988t3.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 1035t.Sources = new ITaskItem[] { new TaskItem(textFile) }; 1036t.OutputResources = new ITaskItem[] { new TaskItem(Path.ChangeExtension(textFile, ".resx")) }; 1048foreach (ITaskItem item in t.FilesWritten) 1068t.Sources = new ITaskItem[] { new TaskItem(resourcesFile) }; 1069t.OutputResources = new ITaskItem[] { new TaskItem(Path.ChangeExtension(resourcesFile, ".resx")) }; 1075t2a.Sources = new ITaskItem[] { new TaskItem(t.FilesWritten[0].ItemSpec) }; 1076t2a.OutputResources = new ITaskItem[] { new TaskItem(Path.ChangeExtension(t.FilesWritten[0].ItemSpec, ".resources")) }; 1082t2b.Sources = new ITaskItem[] { new TaskItem(t2a.FilesWritten[0].ItemSpec) }; 1083t2b.OutputResources = new ITaskItem[] { new TaskItem(Utilities.GetTempFileName(".resx")) }; 1096foreach (ITaskItem item in t2b.FilesWritten) 1116t.Sources = new ITaskItem[] { new TaskItem(textFile) }; 1127t2.Sources = new ITaskItem[] { new TaskItem(resourcesFile) }; 1129t2.OutputResources = new ITaskItem[] { new TaskItem(outputFile) }; 1139foreach (ITaskItem item in t.FilesWritten) 1145foreach (ITaskItem item in t2.FilesWritten) 1161t.Sources = new ITaskItem[] { new TaskItem(textFile) }; 1202foreach (ITaskItem item in t.FilesWritten) 1224t.Sources = new ITaskItem[] { new TaskItem(textFile) }; 1264t2.Sources = new ITaskItem[] { new TaskItem(textFile) }; 1280foreach (ITaskItem item in t.FilesWritten) 1287foreach (ITaskItem item in t2.FilesWritten) 1316t.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 1317t.OutputResources = new ITaskItem[] { new TaskItem(resourcesFile) }; 1337t.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 1338t.OutputResources = new ITaskItem[] { new TaskItem(resourcesFile) }; 1350t.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 1351t.OutputResources = new ITaskItem[] { new TaskItem(resourcesFile) }; 1367t.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 1368t.OutputResources = new ITaskItem[] { new TaskItem(resourcesFile) }; 1408t.Sources = new ITaskItem[] { new TaskItem(txtFile) }; 1469t.Sources = new ITaskItem[] { new TaskItem(textFile) }; 1509foreach (ITaskItem item in t.FilesWritten) 1529t.Sources = new ITaskItem[] { new TaskItem(textFile) }; 1562foreach (ITaskItem item in t.FilesWritten) 1587t.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 1628foreach (ITaskItem item in t.FilesWritten) 1713t.Sources = new ITaskItem[] { new TaskItem(textFile) }; 1719foreach (ITaskItem item in t.FilesWritten) 1729t.Sources = new ITaskItem[] { new TaskItem(textFile) }; 1738foreach (ITaskItem item in t.FilesWritten) 1764t.Sources = new ITaskItem[] { new TaskItem(resxFile1), new TaskItem(resxFile2) }; 1841t.Sources = new ITaskItem[] { new TaskItem(resxFile1), new TaskItem(resxFile2) }; 1846t.OutputResources = new ITaskItem[] { new TaskItem(resourcesFile1), new TaskItem(resourcesFile2) }; 1913t.Sources = new ITaskItem[] { new TaskItem(textFile) }; 1923foreach (ITaskItem item in t.FilesWritten) 1940t.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 1941t.OutputResources = new ITaskItem[] { new TaskItem(Path.ChangeExtension(resxFile, ".txt")) }; 1951foreach (ITaskItem item in t.FilesWritten) 1970t.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 2031gr.Sources = new ITaskItem[] { new TaskItem(resource.Path) }; 2053t.Sources = new ITaskItem[] { new TaskItem(resourcesFile) }; 2054t.OutputResources = new ITaskItem[] { new TaskItem(resxFile) }; 2065foreach (ITaskItem item in t.FilesWritten) 2084t.Sources = new ITaskItem[] { new TaskItem(resourcesFile) }; 2085t.OutputResources = new ITaskItem[] { new TaskItem(env.GetTempFile(".resources").Path) }; 2104t.Sources = new ITaskItem[] { new TaskItem(textFile) }; 2122foreach (ITaskItem item in t.FilesWritten) 2144t.Sources = new ITaskItem[] { new TaskItem(txtFile) }; 2188ITaskItem i = new TaskItem(resxFile); 2190t.Sources = new ITaskItem[] { i }; 2192ITaskItem o = new TaskItem("MyAlternateResource.resources"); 2195t.OutputResources = new ITaskItem[] { o }; 2211foreach (ITaskItem item in t.FilesWritten) 2226ITaskItem i = new TaskItem(resxFile); 2228t.Sources = new ITaskItem[] { i }; 2241foreach (ITaskItem item in t.FilesWritten) 2255t.Sources = new ITaskItem[] { 2272foreach (ITaskItem item in t.Sources) 2277foreach (ITaskItem item in t.FilesWritten) 2291t.Sources = new ITaskItem[] { 2315foreach (ITaskItem item in t.Sources) 2319foreach (ITaskItem item in t.FilesWritten) 2335t.Sources = new ITaskItem[] { 2342foreach (ITaskItem taskItem in t.Sources) 2393foreach (ITaskItem item in t.Sources) 2397foreach (ITaskItem item in t.FilesWritten) 2421t.Sources = new ITaskItem[] { new TaskItem(textFile) }; 2425t.OutputResources = new ITaskItem[] { new TaskItem("somefile.resources") }; 2443foreach (ITaskItem item in t.FilesWritten) 2464t.Sources = new ITaskItem[] { new TaskItem(textFile) }; 2489foreach (ITaskItem item in t.FilesWritten) 2525foreach (ITaskItem item in t.FilesWritten) 2547t.Sources = new ITaskItem[] { new TaskItem(textFile) }; 2548t.References = new ITaskItem[] { new TaskItem("some non-existent DLL name goes here.dll") }; 2579t.Sources = new ITaskItem[] { new TaskItem("non-existent.resx"), new TaskItem(txtFile) }; 2616t.Sources = new ITaskItem[] { new TaskItem(textFile) }; 2633foreach (ITaskItem item in t.FilesWritten) 2655t.Sources = new ITaskItem[] { new TaskItem(newTextFile) }; 2667foreach (ITaskItem item in t.FilesWritten) 2687t.Sources = new ITaskItem[] { new TaskItem(textFile) }; 2688t.OutputResources = new ITaskItem[] { new TaskItem(resxFile) }; 2699foreach (ITaskItem item in t.FilesWritten) 2719t.Sources = new ITaskItem[] { new TaskItem(textFile) }; 2720t.OutputResources = new ITaskItem[] { new TaskItem(resxFile), new TaskItem("someother.resources") }; 2731foreach (ITaskItem item in t.FilesWritten) 2751t.Sources = new ITaskItem[] { new TaskItem(textFile) }; 2763foreach (ITaskItem item in t.FilesWritten) 2788t.Sources = new ITaskItem[] { new TaskItem(resxFile), new TaskItem(resxFile2) }; 2837t.Sources = new ITaskItem[] { new TaskItem(txtFile) }; 2841t.OutputResources = new ITaskItem[] { new TaskItem("somefile.resources") }; 2877t.Sources = new ITaskItem[] { new TaskItem(txtFile) }; 2914t.Sources = new ITaskItem[] { new TaskItem(txtFile) }; 2951t.Sources = new ITaskItem[] { new TaskItem(txtFile) }; 2992t.Sources = new ITaskItem[] { new TaskItem(txtFile) }; 3039t.Sources = new ITaskItem[] { new TaskItem(resourcesFile) }; 3040t.OutputResources = new ITaskItem[] { new TaskItem("||") }; 3213t.Sources = new ITaskItem[] { new TaskItem(Path.Combine(ObjectModelHelpers.TempProjectDir, "MyStrings.resx")) }; 3216t.References = new ITaskItem[] 3362t.Sources = new ITaskItem[] { new TaskItem(Path.Combine(ObjectModelHelpers.TempProjectDir, "MyStrings.resx")) }; 3369t.References = new ITaskItem[] { reference }; 3417t.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 3453t.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 3454t.References = new ITaskItem[] { new TaskItem("baz"), new TaskItem("jazz") }; 3496t.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 3497t.References = new ITaskItem[] { new TaskItem("baz"), new TaskItem("jazz") }; 3542t.Sources = new ITaskItem[] { new TaskItem(resxFile), new TaskItem(resxFile1) }; 3543t.OutputResources = new ITaskItem[] 3627t.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 3654foreach (ITaskItem item in t.FilesWritten) 3684task.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 3718t.Sources = new ITaskItem[] { new TaskItem("non-existent") }; 3719t.OutputResources = new ITaskItem[] { new TaskItem("out") }; 3861t.Sources = new ITaskItem[] { new TaskItem(sourceFile) }; 3927t.References = new ITaskItem[] { 4214t.Sources = new ITaskItem[] { new TaskItem(textFile) }; 4299foreach (ITaskItem item in t.FilesWritten)

238new TaskPropertyInfo("Parameter4", typeof(ITaskItem), output: false, required: false), 239new TaskPropertyInfo("Parameter5", typeof(ITaskItem[]), output: false, required: false), 347new TaskPropertyInfo("Parameter4", typeof(ITaskItem), output: false, required: false), 348new TaskPropertyInfo("Parameter5", typeof(ITaskItem[]), output: false, required: false),

191t.Files = new ITaskItem[] 214t.Files = new ITaskItem[] 237t.Files = new ITaskItem[] 262t.Files = new ITaskItem[] 283t.Files = new ITaskItem[] 306t.Files = new ITaskItem[] 322t.Files = new ITaskItem[] 347t.Files = new ITaskItem[] 373t.Files = new ITaskItem[] 397t.Files = new ITaskItem[]

43SourceFiles = new ITaskItem[] { new TaskItem(zipArchive.Path) } 71SourceFiles = new ITaskItem[] { new TaskItem(zipArchive.Path) }, 84SourceFiles = new ITaskItem[] { new TaskItem(zipArchive.Path) }, 99SourceFiles = new ITaskItem[] { new TaskItem(zipArchive.Path) }, 128SourceFiles = new ITaskItem[] { new TaskItem(zipArchive.Path) } 196SourceFiles = new ITaskItem[] { new TaskItem(zipArchive.Path) } 218SourceFiles = new ITaskItem[] { new TaskItem(file.Path), } 238SourceFiles = new ITaskItem[] { new TaskItem(Path.Combine(testEnvironment.DefaultTestDirectory.Path, "foo.zip")), } 265SourceFiles = new ITaskItem[] { new TaskItem(zipArchive.Path) }, 294SourceFiles = new ITaskItem[] { new TaskItem(zipArchive.Path) }, 327SourceFiles = new ITaskItem[] { new TaskItem(zipArchive.Path) }, 360SourceFiles = new ITaskItem[] { new TaskItem(zipArchive.Path) }, 388SourceFiles = new ITaskItem[] { new TaskItem(zipArchive.Path) }, 416SourceFiles = new ITaskItem[] { new TaskItem(zipArchive.Path) }, 444SourceFiles = new ITaskItem[] { new TaskItem(zipArchive.Path) }, 478SourceFiles = new ITaskItem[] { new TaskItem(zipArchive.Path) },

60Lines = new ITaskItem[] { new TaskItem("\uBDEA") } 79Lines = new ITaskItem[] { new TaskItem("\uBDEA") }, 112Lines = new ITaskItem[] { new TaskItem("File contents1") } 133Lines = new ITaskItem[] { new TaskItem("File contents1") } 145Lines = new ITaskItem[] { new TaskItem("File contents2") } 170Lines = new ITaskItem[] { new TaskItem($"{nameof(RedundantParametersAreLogged)} Test") }, 195Lines = new ITaskItem[] { new TaskItem("File contents1") } 216Lines = new ITaskItem[] { new TaskItem("File contents1") }, 229Lines = new ITaskItem[] { new TaskItem("File contents2") }, 286Lines = Array.Empty<ITaskItem>(), // Test empty. 307Lines = new ITaskItem[] { new TaskItem("WriteLinesToFileDoesCreateDirectory Test") } 324ITaskItem[] lines = useNullLines ? null : Array.Empty<ITaskItem>(); 351ITaskItem[] lines = useNullLines ? null : Array.Empty<ITaskItem>();

273foreach (KeyValuePair<string, ITaskItem[]> output in result.TargetOutputsPerProject[i]) 292List<IDictionary<string, ITaskItem[]>> targetOutputsPerProject = null; 300targetOutputsPerProject = new List<IDictionary<string, ITaskItem[]>>(); 320targetOutputsPerProject.Add(new Dictionary<string, ITaskItem[]>(StringComparer.OrdinalIgnoreCase));

328public static void AssertItemsMatch(string expectedItemsString, ITaskItem[] actualItems) 351public static void AssertItemsMatch(string expectedItemsString, ITaskItem[] actualItems, bool orderOfItemsShouldMatch) 353List<ITaskItem> expectedItems = ParseExpectedItemsString(expectedItemsString); 357foreach (ITaskItem expectedItem in expectedItems) 369foreach (ITaskItem actualItem in actualItems) 384ITaskItem actualItem = actualItems[actualItemIndex]; 387ITaskItem expectedItem = null; 443foreach (ITaskItem expectedItem in expectedItems) 506private static List<ITaskItem> ParseExpectedItemsString(string expectedItemsString) 508List<ITaskItem> expectedItems = new List<ITaskItem>(); 533ITaskItem expectedItem = new Utilities.TaskItem(itemSpec);

379public void AppendFileNameIfNotNull(ITaskItem fileItem) 435public void AppendFileNamesIfNotNull(ITaskItem[] fileItems, string delimiter) 545public void AppendSwitchIfNotNull(string switchName, ITaskItem parameter) 598public void AppendSwitchIfNotNull(string switchName, ITaskItem[] parameters, string delimiter) 607foreach (ITaskItem parameter in parameters) 657public void AppendSwitchUnquotedIfNotNull(string switchName, ITaskItem parameter) 708public void AppendSwitchUnquotedIfNotNull(string switchName, ITaskItem[] parameters, string delimiter) 717foreach (ITaskItem parameter in parameters)

125ITaskItem sourceItem) 297public void CopyMetadataTo(ITaskItem destinationItem)

27public static ITaskItem[] ExpandWildcards(ITaskItem[] expand) 34var expanded = new List<ITaskItem>(expand.Length); 35foreach (ITaskItem item in expand) 73internal static bool ItemsExist(ITaskItem[] files) 79foreach (ITaskItem item in files)

33TaskItem to = new TaskItem((ITaskItem)from); 79ITaskItem item = null;

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

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

16public static IEnumerable<MSB.Framework.ITaskItem> GetAdditionalFiles(this MSB.Execution.ProjectInstance executedProject) 19public static IEnumerable<MSB.Framework.ITaskItem> GetAnalyzers(this MSB.Execution.ProjectInstance executedProject) 22public static IEnumerable<MSB.Framework.ITaskItem> GetDocuments(this MSB.Execution.ProjectInstance executedProject) 25public static IEnumerable<MSB.Framework.ITaskItem> GetEditorConfigFiles(this MSB.Execution.ProjectInstance executedProject) 28public static IEnumerable<MSB.Framework.ITaskItem> GetMetadataReferences(this MSB.Execution.ProjectInstance executedProject) 58public static ImmutableArray<string> GetAliases(this MSB.Framework.ITaskItem item) 67public static bool ReferenceOutputAssemblyIsTrue(this MSB.Framework.ITaskItem item) 109public static IEnumerable<MSB.Framework.ITaskItem> GetTaskItems(this MSB.Execution.ProjectInstance executedProject, string itemType)

43protected abstract IEnumerable<MSB.Framework.ITaskItem> GetCompilerCommandLineArgs(MSB.Execution.ProjectInstance executedProject); 240protected static bool IsNotTemporaryGeneratedFile(MSB.Framework.ITaskItem item) 243private DocumentFileInfo MakeDocumentFileInfo(MSB.Framework.ITaskItem documentItem) 254private DocumentFileInfo MakeNonSourceFileDocumentFileInfo(MSB.Framework.ITaskItem documentItem) 265private ImmutableArray<string> GetRelativeFolders(MSB.Framework.ITaskItem documentItem) 294private string GetDocumentFilePath(MSB.Framework.ITaskItem documentItem) 297private static bool IsDocumentLinked(MSB.Framework.ITaskItem documentItem) 302protected bool IsDocumentGenerated(MSB.Framework.ITaskItem documentItem) 321protected static string GetDocumentLogicalPath(MSB.Framework.ITaskItem documentItem, string projectDirectory)

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

22public ITaskItem[] Uris { get; set; } 78foreach (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)

41public ITaskItem[] Dependencies { get; set; }

12BlobArtifactModel CreateBlobArtifactModel(ITaskItem item, string repoOrigin); 34public BlobArtifactModel CreateBlobArtifactModel(ITaskItem item, string repoOrigin)

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

34ITaskItem[] artifacts, 35ITaskItem[] itemsToSign, 36ITaskItem[] strongNameSignInfo, 37ITaskItem[] fileSignInfo, 38ITaskItem[] fileExtensionSignInfo, 39ITaskItem[] certificatesSignInfo, 130ITaskItem[] artifacts, 131ITaskItem[] itemsToSign, 132ITaskItem[] strongNameSignInfo, 133ITaskItem[] fileSignInfo, 134ITaskItem[] fileExtensionSignInfo, 135ITaskItem[] certificatesSignInfo, 154foreach (var artifact in artifacts)

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

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

29public ITaskItem[] Artifacts { get; set; } 40public ITaskItem[] ItemsToSign { get; set; } 45public ITaskItem[] StrongNameSignInfo { get; set; } 50public ITaskItem[] FileSignInfo { get; set; } 55public ITaskItem[] FileExtensionSignInfo { get; set; } 57public ITaskItem[] CertificatesSignInfo { get; set; }

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

13PackageArtifactModel CreatePackageArtifactModel(ITaskItem item, string repoOrigin); 28public PackageArtifactModel CreatePackageArtifactModel(ITaskItem item, string repoOrigin)

21public ITaskItem[] ItemsToPush { get; set; } 51public ITaskItem[] ItemsToSign { get; set; } 53public ITaskItem[] StrongNameSignInfo { get; set; } 55public ITaskItem[] FileSignInfo { get; set; } 57public ITaskItem[] FileExtensionSignInfo { get; set; } 59public ITaskItem[] CertificatesSignInfo { get; set; } 150foreach (var blobItem in itemsToPushNoExcludes) 163ITaskItem[] symbolItems = itemsToPushNoExcludes 188ITaskItem[] packageItems = itemsToPushNoExcludes 192foreach (var packagePath in packageItems) 203foreach (var blobItem in blobItems) 259private void PushToLocalStorageOrAzDO(ItemType itemType, ITaskItem item)

17ITaskItem[] itemsToSign, 18ITaskItem[] strongNameSignInfo, 19ITaskItem[] fileSignInfo, 20ITaskItem[] fileExtensionSignInfo, 21ITaskItem[] certificatesSignInfo, 36ITaskItem[] itemsToSign, 37ITaskItem[] strongNameSignInfo, 38ITaskItem[] fileSignInfo, 39ITaskItem[] fileExtensionSignInfo, 40ITaskItem[] certificatesSignInfo, 52foreach (var itemToSign in itemsToSign) 65foreach (var signInfo in strongNameSignInfo) 73foreach (var signInfo in fileSignInfo) 93foreach (var signInfo in fileExtensionSignInfo) 101foreach (var signInfo in certificatesSignInfo)

101var artifacts = new ITaskItem[] 186var artifacts = new ITaskItem[] 222var artifacts = new ITaskItem[] 249var artifacts = new ITaskItem[] 277var artifacts = new ITaskItem[] 324var artifacts = new ITaskItem[] 351var itemsToSign = new ITaskItem[] 357var strongNameSignInfo = new ITaskItem[] 366var fileSignInfo = new ITaskItem[] 387var certificatesSignInfo = new ITaskItem[] 399var fileExtensionSignInfo = new ITaskItem[] 560var artifacts = new ITaskItem[] 591var artifacts = new ITaskItem[] 600var itemsToSign = new ITaskItem[] 606var strongNameSignInfo = new ITaskItem[] 615var fileSignInfo = new ITaskItem[] 623var certificatesSignInfo = new ITaskItem[] 635var fileExtensionSignInfo = new ITaskItem[] 701var artifacts = new ITaskItem[] 710var itemsToSign = new ITaskItem[]

456task.FileExtensionSignInfo = new ITaskItem[] 471task.FileSignInfo = new ITaskItem[] 482task.CertificatesSignInfo = new ITaskItem[] 493task.StrongNameSignInfo = new ITaskItem[] 506task.ItemsToSign = new ITaskItem[]

56private readonly ITaskItem[] FeedKeys = GetFeedKeys(); 58private static ITaskItem[] GetFeedKeys() 66return new ITaskItem[] 182Array.Empty<ITaskItem>(), 183Array.Empty<ITaskItem>(), 291Array.Empty<ITaskItem>(), 292Array.Empty<ITaskItem>(), 399Array.Empty<ITaskItem>(), 400Array.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; }

25public ITaskItem [] Sice { get; set; } 73foreach (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; } = []; 94foreach (ITaskItem require in Requires) 99foreach (ITaskItem conflict in Conflicts) 104foreach (ITaskItem changelogLine in ChangelogLines) 114foreach (ITaskItem script in Scripts)

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)

26public ITaskItem[] Properties { get; set; } 61ITaskItem item = group.First(); 70foreach (ITaskItem item in group) 105private void WriteProperty(StringBuilder result, ITaskItem item, string indent)

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; } 57List<ITaskItem> updatedDependencies = new List<ITaskItem>(); 63foreach (ITaskItem metapackage in SuppressMetaPackages) 94foreach (var originalDependency in OriginalDependencies) 130private 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; }

20public static string GetString(this ITaskItem taskItem, string metadataName) 26public static bool GetBoolean(this ITaskItem taskItem, string metadataName, bool defaultValue = false) 37public static NuGetFramework GetTargetFramework(this ITaskItem taskItem) 49public static NuGetFramework GetTargetFrameworkMoniker(this ITaskItem taskItem) 61public static PackageDirectory GetPackageDirectory(this ITaskItem taskItem) 74public static VersionRange GetVersion(this ITaskItem taskItem) 86public static IReadOnlyList<string> GetValueList(this ITaskItem taskItem, string metadataName) 96public static IEnumerable<string> GetStrings(this ITaskItem taskItem, string metadataName)

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

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

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

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

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

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

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

15public ITaskItem[] PackageIndexes

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

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

16public ITaskItem[] Frameworks

19public ITaskItem DescriptionFile

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

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

15public ITaskItem[] Files

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

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

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

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

165public ITaskItem ToItem()

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