17public interface ITaskItem2 : ITaskItem

17public interface ITaskItem2 : ITaskItem

724ITaskItem,

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

724ITaskItem,

724ITaskItem,

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; } 310 foreach (var rootFile in RootDescriptorFiles) 314 foreach (var assemblyItem in RootAssemblyNames) { 351 foreach (var assembly in AssemblyPaths) { 404 foreach (var assembly in ReferenceAssemblyPaths) { 462 foreach (var customData in CustomData) { 472 foreach (var featureSetting in FeatureSettings) { 482 foreach (var metadata in KeepMetadata) 493 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];

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

53private readonly List<ITaskItem> _targetOutputs = new List<ITaskItem>(); 112public ITaskItem[] Projects { get; set; } = null; 119public ITaskItem[] TargetOutputs => _targetOutputs.ToArray(); 292ITaskItem[] singleProject = null; 302singleProject = new ITaskItem[1]; 311ITaskItem project = Projects[i]; 408var projectsToBuildList = new List<ITaskItem>(); 517ITaskItem[] projects, 525List<ITaskItem> targetOutputs, 660IList<IDictionary<string, ITaskItem[]>> targetOutputsPerProject = result.TargetOutputsPerProject; 672if (targetOutputsPerProject[i].TryGetValue(targetName, out ITaskItem[] outputItemsFromTarget)) 674foreach (ITaskItem outputItemFromTarget in outputItemsFromTarget)

1051foreach (var msbuildProject in msbuildTask.Projects)

306foreach (KeyValuePair<string, ITaskItem[]> output in result.TargetOutputsPerProject[i]) 977List<IDictionary<string, ITaskItem[]>> targetOutputsPerProject = null; 984targetOutputsPerProject = new List<IDictionary<string, ITaskItem[]>>(1); 985targetOutputsPerProject.Add(new Dictionary<string, ITaskItem[]>(StringComparer.OrdinalIgnoreCase)); 1146List<IDictionary<string, ITaskItem[]>> targetOutputsPerProject = null; 1161targetOutputsPerProject = new List<IDictionary<string, ITaskItem[]>>(1) 1163new Dictionary<string, ITaskItem[]>(StringComparer.OrdinalIgnoreCase) 1219targetOutputsPerProject = new List<IDictionary<string, ITaskItem[]>>(results.Length); 1225targetOutputsPerProject?.Add(new Dictionary<string, ITaskItem[]>(StringComparer.OrdinalIgnoreCase)); 1234ITaskItem[] clonedTaskItem = new ITaskItem[resultEntry.Value.Items.Length];

53ITaskItem[] Items { get; }

98public ITaskItem[] Items

466ITaskItem[] outputs = GetItemOutputs(parameter); 701private bool SetTaskItemParameter(TaskPropertyInfo parameter, ITaskItem item) 738if (parameterType != typeof(ITaskItem[])) 805private ITaskItem[] GetItemOutputs(TaskPropertyInfo parameter) 809if (!(outputs is ITaskItem[] taskItemOutputs)) 811taskItemOutputs = [(ITaskItem)outputs]; 922returnClass = new TaskFactoryWrapper(new IntrinsicTaskFactory(typeof(MSBuild)), new LoadedType(typeof(MSBuild), AssemblyLoadInfo.Create(taskExecutionHostAssembly.FullName, null), taskExecutionHostAssembly, typeof(ITaskItem)), _taskName, null); 928returnClass = new TaskFactoryWrapper(new IntrinsicTaskFactory(typeof(CallTarget)), new LoadedType(typeof(CallTarget), AssemblyLoadInfo.Create(taskExecutionHostAssembly.FullName, null), taskExecutionHostAssembly, typeof(ITaskItem)), _taskName, null); 1148if (parameterType == typeof(ITaskItem)) 1376private void GatherTaskItemOutputs(bool outputTargetIsItem, string outputTargetName, ITaskItem[] outputs, ElementLocation parameterLocation, TaskPropertyInfo parameter) 1386foreach (ITaskItem output in outputs) 1458foreach (ITaskItem output in outputs)

131if (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() 1394public void CopyMetadataTo(ITaskItem destinationItem) 1414public void CopyMetadataTo(ITaskItem destinationItem, bool addOriginalItemSpec)

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

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

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

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

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

392foreach (ITaskItem item in targetOutputs)

819foreach (ITaskItem output in targetOutputs)

1092if (kvp.item is ITaskItem taskItem) 1109if (metadataContainer is ITaskItem taskItem)

127else if (typeof(ITaskItem[]).GetTypeInfo().IsAssignableFrom(wrappedParameterType.GetTypeInfo())) 130ITaskItem[] inputAsITaskItemArray = (ITaskItem[])wrappedParameter; 131ITaskItem[] taskItemArrayParameter = new ITaskItem[inputAsITaskItemArray.Length]; 173else if (typeof(ITaskItem).IsAssignableFrom(wrappedParameterType)) 176_wrappedParameter = CreateNewTaskItemFrom((ITaskItem)wrappedParameter); 287private ITaskItem CreateNewTaskItemFrom(ITaskItem copyFrom) 347ITaskItem[] wrappedItems = (ITaskItem[])_wrappedParameter; 352foreach (ITaskItem wrappedItem in wrappedItems) 361ITaskItem[] wrappedItems = new ITaskItem[length]; 379WriteITaskItem(translator, (ITaskItem)_wrappedParameter); 383ITaskItem wrappedItem = null; 392private void WriteITaskItem(ITranslator translator, ITaskItem wrappedItem) 459private void ReadITaskItem(ITranslator translator, ref ITaskItem wrappedItem) 884public 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 */

374return type != null ? new LoadedType(type, _assemblyLoadInfo, _loadedAssembly ?? type.Assembly, typeof(ITaskItem), loadedViaMetadataLoadContext: false) : null; 390LoadedType 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 };

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

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

449ITaskItem[] 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];

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

173ITaskItem[] item = targetresult.Items;

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

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

63private ITaskItem[] _oneItem; 68private ITaskItem[] _twoItems; 900ValidateOutputItems("StringArrayOutput", Array.Empty<ITaskItem>()); 911ValidateOutputItems("StringOutput", Array.Empty<ITaskItem>()); 920ValidateOutputItems("ItemArrayNullOutput", Array.Empty<ITaskItem>()); 931ValidateOutputItems("ArrayListOutput", Array.Empty<ITaskItem>()); 1247LoadedType loadedType = new LoadedType(typeof(TaskBuilderTestTask.TaskBuilderTestTaskFactory), loadInfo, typeof(TaskBuilderTestTask.TaskBuilderTestTaskFactory).Assembly, typeof(ITaskItem)); 1275_oneItem = new ITaskItem[] { new TaskItem(item) }; 1283_twoItems = new ITaskItem[] { new TaskItem(item), new TaskItem(item2) }; 1323private void ValidateOutputItems(string outputName, ITaskItem[] values) 1367ITaskItem actualItem = _parametersSetOnTask[parameterName] as ITaskItem; 1375private void ValidateTaskParameterItem(string parameterName, string value, ITaskItem expectedItem) 1381ITaskItem actualItem = _parametersSetOnTask[parameterName] as ITaskItem; 1394ITaskItem[] actualItems = _parametersSetOnTask[parameterName] as ITaskItem[]; 1402private void ValidateTaskParameterItems(string parameterName, string value, ITaskItem[] expectedItems) 1408ITaskItem[] actualItems = _parametersSetOnTask[parameterName] as ITaskItem[]; 1426ITaskItem[] actualItems = _parametersSetOnTask[parameterName] as ITaskItem[];

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

265parameters2.Add("ItemArray", new ITaskItem[] { new TaskItem("DEF"), new TaskItem("GHI"), new TaskItem("JKL") }); 572TaskHostPacketHelpers.AreEqual((ITaskItem)config.TaskParameters["TaskItemValue"].WrappedParameter, (ITaskItem)deserializedConfig.TaskParameters["TaskItemValue"].WrappedParameter); 582parameters.Add("TaskItemArrayValue", new ITaskItem[] { new TaskItem("Foo"), new TaskItem("Baz") }); 621ITaskItem[] itemArray = (ITaskItem[])config.TaskParameters["TaskItemArrayValue"].WrappedParameter; 622ITaskItem[] deserializedItemArray = (ITaskItem[])deserializedConfig.TaskParameters["TaskItemArrayValue"].WrappedParameter; 731internal static void AreEqual(ITaskItem[] x, ITaskItem[] y) 757internal 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();

200if (item is ITaskItem taskItem)

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

1324foreach (ITaskItem item in instance.Items)

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

40private ITaskItem _taskItemParam; 41public ITaskItem TaskItemParam

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

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

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

850var 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)]; } 954internal static void AddAnalyzersToCommandLine(CommandLineBuilderExtension commandLine, ITaskItem[]? analyzers) 963foreach (ITaskItem analyzer in analyzers) 976foreach (ITaskItem additionalFile in AdditionalFiles) 995foreach (ITaskItem embeddedFile in EmbeddedFiles) 1009foreach (ITaskItem analyzerConfigFile in AnalyzerConfigFiles) 1081private void NormalizePaths(ITaskItem[]? taskItems) 1086foreach (var item in taskItems) 1154foreach (ITaskItem reference in References)

159/// Generates the <see cref="ITaskItem"/> entries for the CommandLineArgs output ItemGroup 165protected internal ITaskItem[] GenerateCommandLineArgsTaskItems(string responseFileCommands) => 168protected static ITaskItem[] GenerateCommandLineArgsTaskItems(List<string> commandLineArgs) 170var 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; 166internal delegate void LogExclusionReason(bool displayPrimaryReferenceMessage, AssemblyNameExtension assemblyName, Reference reference, ITaskItem referenceItem, string targetedFramework); 269ITaskItem[] resolvedSDKItems, 336_resolvedSDKReferences = new Dictionary<string, ITaskItem>(StringComparer.OrdinalIgnoreCase); 341foreach (ITaskItem resolvedSDK in resolvedSDKItems) 522ITaskItem[] referenceAssemblyFiles, 523ITaskItem[] referenceAssemblyNames, 530foreach (ITaskItem i in referenceAssemblyFiles) 540foreach (ITaskItem n in referenceAssemblyNames) 558ITaskItem referenceAssemblyName) 844private static AssemblyNameExtension GetAssemblyNameFromItemMetadata(ITaskItem item) 871private void SetPrimaryFileItem(ITaskItem referenceAssemblyFile) 1424ICollection<ITaskItem> dependees = assemblyReference.GetSourceItems(); 1497ICollection<ITaskItem> dependees = assemblyReference.GetSourceItems(); 1498foreach (ITaskItem dependee in dependees) 1625ITaskItem[] referenceAssemblyFiles, 1626ITaskItem[] referenceAssemblyNames, 2584out ITaskItem[] primaryFiles, 2585out ITaskItem[] dependencyFiles, 2586out ITaskItem[] relatedFiles, 2587out ITaskItem[] satelliteFiles, 2588out ITaskItem[] serializationAssemblyFiles, 2589out ITaskItem[] scatterFiles, 2590out ITaskItem[] copyLocalFiles) 2592var primaryItems = new List<ITaskItem>(); 2593var dependencyItems = new List<ITaskItem>(); 2594var relatedItems = new List<ITaskItem>(); 2595var satelliteItems = new List<ITaskItem>(); 2596var serializationAssemblyItems = new List<ITaskItem>(); 2597var scatterItems = new List<ITaskItem>(); 2598var copyLocalItems = new List<ITaskItem>(); 2633ITaskItem referenceItem = SetItemMetadata(relatedItems, satelliteItems, serializationAssemblyItems, scatterItems, assemblyName.FullName, reference, assemblyName); 2674private ITaskItem SetItemMetadata(List<ITaskItem> relatedItems, List<ITaskItem> satelliteItems, List<ITaskItem> serializationAssemblyItems, List<ITaskItem> scatterItems, string fusionName, Reference reference, AssemblyNameExtension assemblyName) 2702ICollection<ITaskItem> sourceItems = reference.GetSourceItems(); 2703foreach (ITaskItem sourceItem in sourceItems) 2749ITaskItem item = new TaskItem(reference.FullPathWithoutExtension + relatedFileExtension); 2760ITaskItem item = new TaskItem(Path.Combine(reference.DirectoryName, satelliteFile)); 2773ITaskItem item = new TaskItem(Path.Combine(reference.DirectoryName, serializationAssemblyFile)); 2784ITaskItem item = new TaskItem(Path.Combine(reference.DirectoryName, scatterFile)); 2814ITaskItem item = new TaskItem(reference.ImplementationAssembly); 3022private static Dictionary<string, string> RemoveNonForwardableMetadata(ITaskItem item) 3035private static void RemoveMetadatum(string key, ITaskItem item, Dictionary<string, string> removedMetadata) 3048private static void FindCopyLocalItems(ITaskItem[] items, List<ITaskItem> copyLocalItems) 3050foreach (ITaskItem i in items) 3069internal void LogHigherVersionUnresolve(bool displayPrimaryReferenceMessage, AssemblyNameExtension assemblyName, Reference reference, ITaskItem referenceItem, string targetedFramework) 3084internal void LogHigherVersionUnresolveDueToAttribute(bool displayPrimaryReferenceMessage, AssemblyNameExtension assemblyName, Reference reference, ITaskItem referenceItem, string targetedFramework) 3099internal void LogAnotherFrameworkUnResolve(bool displayPrimaryReferenceMessage, AssemblyNameExtension assemblyName, Reference reference, ITaskItem referenceItem, string targetedFramework) 3114internal void LogProfileExclusionUnresolve(bool displayPrimaryReferenceMessage, AssemblyNameExtension assemblyName, Reference reference, ITaskItem referenceItem, string targetedFramework)

172private ITaskItem[] _assemblyFiles = Array.Empty<TaskItem>(); 173private ITaskItem[] _assemblyNames = Array.Empty<TaskItem>(); 174private ITaskItem[] _installedAssemblyTables = Array.Empty<TaskItem>(); 175private ITaskItem[] _installedAssemblySubsetTables = Array.Empty<TaskItem>(); 176private ITaskItem[] _fullFrameworkAssemblyTables = Array.Empty<TaskItem>(); 177private ITaskItem[] _resolvedSDKReferences = Array.Empty<TaskItem>(); 192private ITaskItem[] _resolvedFiles = Array.Empty<TaskItem>(); 193private ITaskItem[] _resolvedDependencyFiles = Array.Empty<TaskItem>(); 194private ITaskItem[] _relatedFiles = Array.Empty<TaskItem>(); 195private ITaskItem[] _satelliteFiles = Array.Empty<TaskItem>(); 196private ITaskItem[] _serializationAssemblyFiles = Array.Empty<TaskItem>(); 197private ITaskItem[] _scatterFiles = Array.Empty<TaskItem>(); 198private ITaskItem[] _copyLocalFiles = Array.Empty<TaskItem>(); 199private ITaskItem[] _suggestedRedirects = Array.Empty<TaskItem>(); 200private List<ITaskItem> _unresolvedConflicts = new List<ITaskItem>(); 278public ITaskItem[] AssemblyFiles 386public ITaskItem[] Assemblies 409public ITaskItem[] ResolvedSDKReferences 465public ITaskItem[] InstalledAssemblyTables 487public ITaskItem[] InstalledAssemblySubsetTables 518public ITaskItem[] FullFrameworkAssemblyTables 602public ITaskItem[] AssemblyInformationCachePaths { get; set; } 936public ITaskItem[] ResolvedFiles 955public ITaskItem[] ResolvedDependencyFiles 967public ITaskItem[] RelatedFiles 980public ITaskItem[] SatelliteFiles 991public ITaskItem[] SerializationAssemblyFiles 1001public ITaskItem[] ScatterFiles 1012public ITaskItem[] CopyLocalFiles 1027public ITaskItem[] SuggestedRedirects 1035private List<ITaskItem> _filesWritten = new List<ITaskItem>(); 1041public ITaskItem[] FilesWritten 1072public ITaskItem[] UnresolvedAssemblyConflicts => _unresolvedConflicts.ToArray(); 1393foreach (ITaskItem sourceItem in dependeeReference.GetSourceItems()) 1498foreach (ITaskItem item in Assemblies) 1510foreach (ITaskItem item in AssemblyFiles) 1540foreach (ITaskItem installedAssemblyTable in InstalledAssemblyTables) 1592foreach (ITaskItem installedAssemblySubsetTable in InstalledAssemblySubsetTables) 1629foreach (ITaskItem profileTable in FullFrameworkAssemblyTables) 1641private void LogAttribute(ITaskItem item, string metadataName) 1903ICollection<ITaskItem> dependees = reference.GetSourceItems(); 1904foreach (ITaskItem dependee in dependees) 2631foreach (ITaskItem item in _resolvedFiles) 2797foreach (ITaskItem item in FullFrameworkAssemblyTables) 2853internal static string GenerateSubSetName(string[] frameworkSubSetNames, ITaskItem[] installedSubSetNames) 2869foreach (ITaskItem subsetItems in installedSubSetNames) 3021var holdSuggestedRedirects = new List<ITaskItem>(); 3040ITaskItem suggestedRedirect = new TaskItem(); 3057private AssemblyTableInfo[] GetInstalledAssemblyTableInfo(bool ignoreInstalledAssemblyTables, ITaskItem[] assemblyTables, GetListPath GetAssemblyListPaths, string[] targetFrameworkDirectories) 3075foreach (ITaskItem installedAssemblyTable in assemblyTables) 3144var assembliesLeft = new List<ITaskItem>(); 3145foreach (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)

43public ITaskItem[] Files { get; set; } = Array.Empty<ITaskItem>(); 69public ITaskItem[] AssignedFiles { get; private set; } 83public ITaskItem[] AssignedFilesWithCulture { get; private set; } 94public ITaskItem[] AssignedFilesWithNoCulture { get; private set; } 123public ITaskItem[] CultureNeutralAssignedFiles { get; private set; } 135AssignedFiles = new ITaskItem[Files.Length]; 136CultureNeutralAssignedFiles = new ITaskItem[Files.Length]; 137var cultureList = new List<ITaskItem>(); 138var 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)

131public ITaskItem[] SourceFiles { get; set; } 133public ITaskItem[] SourceFolders { get; set; } 135public ITaskItem DestinationFolder { get; set; } 169public ITaskItem[] DestinationFiles { get; set; } 175public ITaskItem[] CopiedFiles { get; private set; } 436DestinationFiles = Array.Empty<ITaskItem>(); 437CopiedFiles = Array.Empty<ITaskItem>(); 453List<ITaskItem> destinationFilesSuccessfullyCopied; 482out List<ITaskItem> destinationFilesSuccessfullyCopied) 485destinationFilesSuccessfullyCopied = new List<ITaskItem>(DestinationFiles.Length); 563out List<ITaskItem> destinationFilesSuccessfullyCopied) 592ITaskItem destItem = DestinationFiles[i]; 624destinationFilesSuccessfullyCopied = new List<ITaskItem>(DestinationFiles.Length); 644ITaskItem sourceItem = SourceFiles[fileIndex]; 645ITaskItem destItem = DestinationFiles[fileIndex]; 770DestinationFiles = new ITaskItem[SourceFiles.Length]; 797var sourceFiles = SourceFiles != null ? new List<ITaskItem>(SourceFiles) : new List<ITaskItem>(); 798var destinationFiles = DestinationFiles != null ? new List<ITaskItem>(DestinationFiles) : new List<ITaskItem>(); 800foreach (ITaskItem sourceFolder in SourceFolders) 853DestinationFiles = Array.Empty<ITaskItem>();

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

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

29private ITaskItem[] _resourceFiles; 35protected Dictionary<string, ITaskItem> itemSpecToTaskitem = new Dictionary<string, ITaskItem>(StringComparer.OrdinalIgnoreCase); 51public ITaskItem[] ResourceFiles 80public ITaskItem[] ManifestResourceNames { get; private set; } 86public ITaskItem[] ResourceFilesWithManifestResourceNames { get; set; } 135ManifestResourceNames = new ITaskItem[ResourceFiles.Length]; 136ResourceFilesWithManifestResourceNames = new ITaskItem[ResourceFiles.Length]; 153foreach (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; }

52private ITaskItem[] _outputs; 57private readonly List<ITaskItem> _nonEmptyOutput = new List<ITaskItem>(); 179public ITaskItem[] Outputs 181get => _outputs ?? Array.Empty<ITaskItem>(); 191public 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)

55public ITaskItem[] ProjectReferences { get; set; } 73public ITaskItem[] InvalidReferences { get; private set; } 84var invalidReferences = new List<ITaskItem>(); 90foreach (ITaskItem item in ProjectReferences)

29private ITaskItem[] _dependencies; 30private ITaskItem[] _files; 31private ITaskItem[] _isolatedComReferences; 33private ITaskItem[] _fileAssociations; 38public ITaskItem ConfigFile { get; set; } 40public ITaskItem[] Dependencies 48public ITaskItem[] FileAssociations 62public ITaskItem[] Files 70public ITaskItem IconFile { get; set; } 72public ITaskItem[] IsolatedComReferences 96public ITaskItem TrustInfoFile { get; set; } 146foreach (ITaskItem item in Dependencies) 162foreach (ITaskItem item in Files) 228foreach (ITaskItem item in IsolatedComReferences) 251foreach (ITaskItem item in FileAssociations)

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

28public ITaskItem EntryPoint { get; set; } 39public ITaskItem OutputEntryPoint { get; set; }

53public ITaskItem EntryPoint { get; set; } 55public ITaskItem InputManifest { get; set; } 62public ITaskItem OutputManifest { get; set; } 83protected internal AssemblyReference AddAssemblyNameFromItem(ITaskItem item, AssemblyReferenceType referenceType) 100protected internal AssemblyReference AddAssemblyFromItem(ITaskItem item) 149protected internal AssemblyReference AddEntryPointFromItem(ITaskItem item, AssemblyReferenceType referenceType) 157protected internal FileReference AddFileFromItem(ITaskItem item) 332protected internal FileReference FindFileFromItem(ITaskItem item) 361private AssemblyType GetItemAssemblyType(ITaskItem item) 382private static bool IsEmbedInteropEnabledForAssembly(ITaskItem item) 392private DependencyType GetItemDependencyType(ITaskItem item) 532private void SetItemAttributes(ITaskItem item, BaseReference file)

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

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

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

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)

401private static ITaskItem[] RemoveDuplicateItems(ITaskItem[] items) 413var list = new Dictionary<string, ITaskItem>(); 414foreach (ITaskItem item in items) 441public static ITaskItem[] SortItems(ITaskItem[] items) 443ITaskItem[] outputItems = RemoveDuplicateItems(items); 600if (!(obj1 is ITaskItem) || !(obj2 is ITaskItem)) 605ITaskItem item1 = obj1 as ITaskItem; 606ITaskItem 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; 268singleProject = new List<ITaskItem>(1) { null }; 277ITaskItem project = Projects[i]; 372var projectsToBuildInParallel = new List<ITaskItem>(); 475List<ITaskItem> projects, 483List<ITaskItem> targetOutputs, 609IList<IDictionary<string, ITaskItem[]>> targetOutputsPerProject = result.TargetOutputsPerProject; 621if (targetOutputsPerProject[i].TryGetValue(targetName, out ITaskItem[] outputItemsFromTarget)) 623foreach (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; } 135private static bool HasExcludedFileOrSP1File(ITaskItem[] candidateFiles) 139foreach (ITaskItem file in candidateFiles) 155private 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 262private static ITaskItem CreateAssemblyItem(ITaskItem item, string group, string targetPath, string includeHash) 264ITaskItem outputItem = new TaskItem(item.ItemSpec); 285private ITaskItem CreateFileItem(ITaskItem item, string group, string targetPath, string includeHash, bool isDataFile) 287ITaskItem outputItem = new TaskItem(item.ItemSpec); 326private static ITaskItem CreatePrerequisiteItem(ITaskItem item) 328ITaskItem outputItem = new TaskItem(item.ItemSpec); 334private static bool GetItemCopyLocal(ITaskItem item) 346private static CultureInfo GetItemCulture(ITaskItem item) 360private static string GetItemTargetPath(ITaskItem item) 384private void GetOutputAssemblies(List<PublishInfo> publishInfos, List<ITaskItem> assemblyList) 391foreach (ITaskItem item in _managedAssemblies) 426foreach (ITaskItem item in _nativeAssemblies) 496private ITaskItem[] GetOutputAssembliesAndSatellites(List<PublishInfo> assemblyPublishInfos, List<PublishInfo> satellitePublishInfos) 498var assemblyList = new List<ITaskItem>(); 504private ITaskItem[] GetOutputFiles(List<PublishInfo> publishInfos, IEnumerable<ITaskItem> outputAssemblies) 506var fileList = new List<ITaskItem>(); 515foreach (ITaskItem item in Files) 523outputAssembliesMap.TryGetValue(key, out var assembly); 554foreach (ITaskItem item in ExtraFiles) 603private void GetOutputSatellites(List<PublishInfo> publishInfos, List<ITaskItem> assemblyList) 609foreach (ITaskItem item in _satelliteAssemblies) 666private ITaskItem GetOutputEntryPoint(ITaskItem entryPoint, List<PublishInfo> manifestEntryPointList) 716foreach (ITaskItem item in PublishFiles) 742private bool IsFiltered(ITaskItem item) 807public PublishInfo(ITaskItem item) 821public readonly ITaskItem item; 824public MapEntry(ITaskItem item, bool includedByDefault) 851public void Add(ITaskItem item) 911public bool ContainsItem(ITaskItem item) 921public void Add(ITaskItem item) 960public void Add(ITaskItem item, bool includedByDefault)

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

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

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

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

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

82public ITaskItem OutputAssembly { get; set; } 84public ITaskItem[] References { get; set; } 86public ITaskItem[] Sources { get; set; } 104foreach (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; }

565internal static SystemState DeserializePrecomputedCaches(ITaskItem[] stateFiles, TaskLoggingHelper log, FileExists fileExists) 571foreach (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; }

33private ITaskItem[] _outputPaths; 41public ITaskItem[] XmlInputPaths { get; set; } 51public ITaskItem XslInputPath { get; set; } 66public ITaskItem XslCompiledDllPath { get; set; } 72public ITaskItem[] OutputPaths 275public XmlInput(ITaskItem[] xmlFile, string xml) 381public 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; }

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

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

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

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

22t.Files = new ITaskItem[] 37t.Files = new ITaskItem[] 51t.Files = new ITaskItem[] 72t.Files = new ITaskItem[] 97t.Files = new ITaskItem[]

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

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

25var items = new ITaskItem[]

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

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

42new object[] { Array.Empty<ITaskItem>() }, 145SourceFiles = new ITaskItem[] { new TaskItem(sourceFile.Path) }, 146DestinationFiles = new ITaskItem[] { new TaskItem("destination.txt") }, 170SourceFiles = new ITaskItem[] { new TaskItem(sourceFile.Path) }, 213SourceFolders = new ITaskItem[] { new TaskItem(s0Folder.Path), new TaskItem(s1Folder.Path) }, 268SourceFiles = new ITaskItem[] { new TaskItem(sourceFile.Path) }, 269SourceFolders = new ITaskItem[] { new TaskItem(sourceFolder.Path) }, 283public void CopyWithEmptySourceFiles(ITaskItem[] sourceFiles) 307public void CopyWithEmptySourceFolders(ITaskItem[] sourceFolders) 331public void CopyWithNoDestination(ITaskItem[] destinationFiles) 341SourceFiles = new ITaskItem[] { new TaskItem(sourceFile.Path) }, 365SourceFiles = new ITaskItem[] { new TaskItem(sourceFile.Path) }, 366DestinationFiles = new ITaskItem[] { new TaskItem("destination.txt") }, 389SourceFiles = new ITaskItem[] { new TaskItem(sourceFile.Path) }, 390SourceFolders = new ITaskItem[] { new TaskItem(sourceFolder.Path) }, 391DestinationFiles = new ITaskItem[] { new TaskItem("destination0.txt"), new TaskItem("destination1.txt") }, 412SourceFiles = new ITaskItem[] { new TaskItem(sourceFile.Path) }, 413DestinationFiles = new ITaskItem[] { new TaskItem("destination0.txt"), new TaskItem("destination1.txt") }, 437SourceFiles = new ITaskItem[] { new TaskItem(sourceFile.Path) }, 438DestinationFiles = new ITaskItem[] { new TaskItem("destination.txt") }, 463SourceFiles = new ITaskItem[] { new TaskItem(sourceFile.Path) }, 464DestinationFiles = new ITaskItem[] { new TaskItem("destination.txt") }, 491ITaskItem f = new TaskItem(file); 492ITaskItem[] sourceFiles = { f }; 493ITaskItem[] destinationFiles = { f }; 538ITaskItem sourceItem = new TaskItem(source); 539ITaskItem destinationItem = new TaskItem(destination); 540ITaskItem[] sourceFiles = { sourceItem }; 541ITaskItem[] destinationFiles = { destinationItem }; 598ITaskItem sourceItem = new TaskItem(source); 599ITaskItem destinationItem = new TaskItem(destination); 600ITaskItem[] sourceFiles = { sourceItem }; 601ITaskItem[] destinationFiles = { destinationItem }; 650ITaskItem sourceItem = new TaskItem(source); 651ITaskItem destinationItem = new TaskItem(destination); 652ITaskItem[] sourceFiles = { sourceItem }; 653ITaskItem[] destinationFiles = { destinationItem }; 707ITaskItem sourceItem = new TaskItem(source); 708ITaskItem destinationItem = new TaskItem(destination); 709ITaskItem[] sourceFiles = { sourceItem }; 710ITaskItem[] destinationFiles = { destinationItem }; 774ITaskItem sourceItem = new TaskItem(source); 775ITaskItem destinationItem = new TaskItem(destination); 776ITaskItem[] sourceFiles = { sourceItem }; 777ITaskItem[] destinationFiles = { destinationItem }; 841ITaskItem sourceItem = new TaskItem(source); 842ITaskItem destinationItem = new TaskItem(destination); 843ITaskItem[] sourceFiles = { sourceItem }; 844ITaskItem[] destinationFiles = { destinationItem }; 908ITaskItem sourceItem = new TaskItem(source); 909ITaskItem destinationItem = new TaskItem(destination); 910ITaskItem[] sourceFiles = { sourceItem }; 911ITaskItem[] destinationFiles = { destinationItem }; 982ITaskItem sourceItem1 = new TaskItem(source1); 983ITaskItem sourceItem2 = new TaskItem(source2); 984ITaskItem[] sourceFiles = new ITaskItem[] { sourceItem1, sourceItem2 }; 1049ITaskItem[] sourceFiles = { new TaskItem(sourceFile) }; 1050ITaskItem[] destinationFiles = { new TaskItem(destinationFile) }; 1182ITaskItem[] sourceFiles = { new TaskItem(sourceFile) }; 1183ITaskItem[] destinationFiles = { new TaskItem(destinationFile) }; 1222ITaskItem[] sourceFiles = { new TaskItem(sourceFile) }; 1223ITaskItem[] destinationFiles = { new TaskItem(destinationFile) }; 1267ITaskItem[] sourceFiles = { new TaskItem(sourceFile) }; 1268ITaskItem[] destinationFiles = { new TaskItem(destinationFile) }; 1314ITaskItem[] sourceFiles = { new TaskItem(sourceFile) }; 1315ITaskItem[] destinationFiles = { new TaskItem(destinationFile) }; 1360ITaskItem[] sourceFiles = { new TaskItem(sourceFile) }; 1368DestinationFiles = new ITaskItem[] { new TaskItem(destinationFile) }, 1486ITaskItem[] sourceFiles = { new TaskItem(sourceFile) }; 1532ITaskItem[] sourceFiles = { new TaskItem(sourceFile) }; 1533ITaskItem[] destinationFiles = { new TaskItem(destinationFile) }; 1599ITaskItem i1 = new TaskItem(inFile1); 1604ITaskItem o1 = new TaskItem(validOutFile); 1677SourceFiles = new ITaskItem[] { new TaskItem(file) }, 1678DestinationFiles = new ITaskItem[] { new TaskItem(file) }, 1696SourceFiles = new ITaskItem[] { new TaskItem(file) }, 1697DestinationFiles = new ITaskItem[] { new TaskItem(file) }, 1748SourceFiles = new ITaskItem[] { new TaskItem(file) }, 1749DestinationFiles = new ITaskItem[] { new TaskItem(filename.ToLowerInvariant()) }, 1802SourceFiles = new ITaskItem[] { new TaskItem(file), new TaskItem(invalidFile) }, 1803DestinationFiles = new ITaskItem[] { new TaskItem(file), new TaskItem(dest2) }, 1856ITaskItem[] sourceFiles = { new TaskItem(sourceFile) }; 1929ITaskItem[] sourceFiles = { new TaskItem(sourceFileEscaped) }; 1978ITaskItem[] sourceFiles = 1986foreach (ITaskItem item in sourceFiles) 2035ITaskItem[] sourceFiles = 2044foreach (ITaskItem item in sourceFiles) 2052ITaskItem[] destFiles = 2136SourceFiles = new ITaskItem[] { new TaskItem(inFile1), new TaskItem(inFile2) }, 2137DestinationFiles = new ITaskItem[] { new TaskItem(outFile1) }, 2177ITaskItem[] sourceFiles = { new TaskItem(sourceFile) }; 2178ITaskItem[] destinationFiles = { new TaskItem(destinationFile) }; 2215ITaskItem[] sourceFiles = { new TaskItem(sourceFile) }; 2216ITaskItem[] destinationFiles = { new TaskItem(destinationFile) }; 2248SourceFiles = new ITaskItem[] { new TaskItem("foo | bar") }, 2272SourceFiles = new ITaskItem[] { new TaskItem("foo") }, 2296SourceFiles = new ITaskItem[] { new TaskItem("c:\\source") }, 2297DestinationFiles = new ITaskItem[] { new TaskItem("c:\\destination") }, 2317SourceFiles = new ITaskItem[] { new TaskItem("c:\\source") }, 2318DestinationFiles = new ITaskItem[] { new TaskItem("c:\\destination") }, 2342SourceFiles = new ITaskItem[] { new TaskItem("c:\\source") }, 2343DestinationFiles = new ITaskItem[] { new TaskItem("c:\\destination") }, 2409SourceFiles = new ITaskItem[] { new TaskItem("c:\\source") }, 2410DestinationFiles = new ITaskItem[] { new TaskItem("c:\\destination") }, 2436SourceFiles = new ITaskItem[] { new TaskItem("c:\\source"), new TaskItem("c:\\source2") }, 2437DestinationFiles = new ITaskItem[] { new TaskItem("c:\\destination"), new TaskItem("c:\\destination2") }, 2468SourceFiles = new ITaskItem[] { new TaskItem("c:\\source") }, 2469DestinationFiles = new ITaskItem[] { new TaskItem("c:\\destination") }, 2497SourceFiles = new ITaskItem[] { new TaskItem("c:\\source") }, 2498DestinationFiles = new ITaskItem[] { new TaskItem("c:\\destination") }, 2532SourceFiles = new ITaskItem[] { new TaskItem(source) }, 2533DestinationFiles = new ITaskItem[] { new TaskItem(existing) }, 2557ITaskItem[] sourceFiles = { new TaskItem(sourceFile) }; 2643ITaskItem[] sourceFiles = 2733ITaskItem[] sourceFiles = { new TaskItem(sourceFile) }; 2812ITaskItem[] sourceFiles = { new TaskItem(sourceFile) }; 2876ITaskItem[] sourceFiles = { new TaskItem(sourceFile) }; 2913SourceFiles = new ITaskItem[] { new TaskItem("c:\\source") }, 2914DestinationFiles = new ITaskItem[] { new TaskItem("c:\\destination") }, 2943ITaskItem[] sourceFiles = { new TaskItem(sourceFile1.Path) }; 2944ITaskItem[] 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;

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

28ITaskItem i = new TaskItem("MyFiles.nonexistent"); 30t.Files = new ITaskItem[] { i }; 57ITaskItem sourceItem = new TaskItem(source); 58ITaskItem[] sourceFiles = { sourceItem }; 75ITaskItem[] duplicateSourceFiles = { sourceItem, sourceItem };

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

27t.Files = new ITaskItem[] { new TaskItem(@"C:\MyProject\File1.txt"), new TaskItem(@"C:\SomeoneElsesProject\File2.txt") }; 45t.Files = new ITaskItem[] { new TaskItem(@":::") }; 61t.Files = new ITaskItem[] { new TaskItem(@"foo") }; 77t.Files = new ITaskItem[] { new TaskItem(EscapingUtilities.Escape(testFile.Name)),

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

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

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

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

33t.Directories = new ITaskItem[] 80t.Directories = new ITaskItem[] 137t.Directories = new ITaskItem[] 179var dirList = new ITaskItem[] 245t.Directories = new ITaskItem[]

36ITaskItem[] sourceFiles = new ITaskItem[] { new TaskItem(sourceFile) }; 37ITaskItem[] destinationFiles = new ITaskItem[] { new TaskItem(destinationFile) }; 81ITaskItem[] sourceFiles = new ITaskItem[] { new TaskItem(sourceFile) }; 82ITaskItem[] destinationFiles = new ITaskItem[] { new TaskItem(destinationFile) }; 132ITaskItem[] sourceFiles = new ITaskItem[] { new TaskItem(sourceFile) }; 133ITaskItem[] destinationFiles = new ITaskItem[] { new TaskItem(destinationFile) }; 177ITaskItem[] sourceFiles = new ITaskItem[] { new TaskItem(sourceFile) }; 178ITaskItem[] destinationFiles = new ITaskItem[] { new TaskItem(sourceFile) }; 218ITaskItem[] sourceFiles = new ITaskItem[] { new TaskItem(sourceFile) }; 219ITaskItem[] destinationFiles = new ITaskItem[] { new TaskItem(destinationFile) }; 273ITaskItem[] sourceFiles = new ITaskItem[] { new TaskItem(sourceFile) }; 274ITaskItem[] destinationFiles = new ITaskItem[] { new TaskItem(destinationFile) }; 325ITaskItem[] sourceFiles = new ITaskItem[] { new TaskItem(sourceFile) }; 326ITaskItem[] destinationFiles = new ITaskItem[] { new TaskItem(destinationFile) }; 379ITaskItem[] sourceFiles = new ITaskItem[] { new TaskItem(sourceFile) }; 380ITaskItem[] destinationFiles = new ITaskItem[] { new TaskItem(destinationFile) }; 445ITaskItem i1 = new TaskItem(inFile1); 448t.SourceFiles = new ITaskItem[] { new TaskItem(inFile2), i1 }; 450ITaskItem o1 = new TaskItem(validOutFile); 453t.DestinationFiles = new ITaskItem[] { new TaskItem(invalidFile), o1 }; 510move.SourceFiles = new ITaskItem[] { new TaskItem(file) }; 511move.DestinationFiles = new ITaskItem[] { new TaskItem(file + "2") }; 533move.SourceFiles = new ITaskItem[] { new TaskItem("source") }; 547move.SourceFiles = new ITaskItem[] { new TaskItem("source") }; 548move.DestinationFiles = new ITaskItem[] { new TaskItem("x") }; 563move.SourceFiles = new ITaskItem[] { new TaskItem("source") }; 564move.DestinationFiles = new ITaskItem[] { new TaskItem(Directory.GetCurrentDirectory()) }; 578move.DestinationFiles = new ITaskItem[] { new TaskItem("destination") }; 579move.SourceFiles = new ITaskItem[] { new TaskItem(Directory.GetCurrentDirectory()) }; 612t.SourceFiles = new ITaskItem[] { new TaskItem(file) }; 613t.DestinationFiles = new ITaskItem[] { new TaskItem(filename.ToLowerInvariant()) }; 656t.SourceFiles = new ITaskItem[] { new TaskItem(file), new TaskItem(invalidFile) }; 657t.DestinationFiles = new ITaskItem[] { new TaskItem(file), new TaskItem(dest2) }; 692ITaskItem[] sourceFiles = new ITaskItem[] { new TaskItem(sourceFile) }; 759t.SourceFiles = new ITaskItem[] { new TaskItem(inFile1), new TaskItem(inFile2) }; 760t.DestinationFiles = new ITaskItem[] { new TaskItem(outFile1) }; 794ITaskItem[] sourceFiles = new ITaskItem[] { new TaskItem(sourceFile) }; 795ITaskItem[] destinationFiles = new ITaskItem[] { new TaskItem(destinationFile) }; 823ITaskItem[] sourceFiles = new ITaskItem[] { new TaskItem(sourceFile) }; 824ITaskItem[] destinationFiles = new ITaskItem[] { new TaskItem(destinationFile) }; 846t.SourceFiles = new ITaskItem[] { new TaskItem("foo | bar") }; 864t.SourceFiles = new ITaskItem[] { new TaskItem("source") }; 865t.DestinationFiles = new ITaskItem[] { new TaskItem("foo | bar") }; 882t.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];

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

66t.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 91foreach (ITaskItem item in t.FilesWritten) 118t.Sources = new ITaskItem[] { 121t.OutputResources = new ITaskItem[] { 136foreach (ITaskItem item in t.FilesWritten) 154t.Sources = new ITaskItem[] { new TaskItem(textFile) }; 174foreach (ITaskItem item in t.FilesWritten) 204t.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 205t.References = new ITaskItem[] { new TaskItem(systemDll) }; 245t.Sources = new ITaskItem[] { new TaskItem(resourcesFile) }; 246t.OutputResources = new ITaskItem[] { new TaskItem(Path.ChangeExtension(resourcesFile, ".resx")) }; 252t2a.Sources = new ITaskItem[] { new TaskItem(resourcesFile) }; 253t2a.OutputResources = new ITaskItem[] { new TaskItem(Path.ChangeExtension(resourcesFile, ".txt")) }; 259t2b.Sources = new ITaskItem[] { new TaskItem(t2a.FilesWritten[0].ItemSpec) }; 260t2b.OutputResources = new ITaskItem[] { new TaskItem(Utilities.GetTempFileName(".resx")) }; 274foreach (ITaskItem item in t2b.FilesWritten) 294t.Sources = new ITaskItem[] { new TaskItem(resourcesFile) }; 297t.OutputResources = new ITaskItem[] { new TaskItem(outputFile) }; 308foreach (ITaskItem item in t.FilesWritten) 327t.Sources = new ITaskItem[] { new TaskItem(resxFileInput) }; 353t2.Sources = new ITaskItem[] { new TaskItem(resxFileInput) }; 373t.Sources = new ITaskItem[] { new TaskItem(resxFileInput) }; 381t2.Sources = new ITaskItem[] { new TaskItem(resxFileInput) }; 406t.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 417t2.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 439foreach (ITaskItem item in t.FilesWritten) 455ITaskItem[] sources = new ITaskItem[] { new TaskItem(resxFileInput) }; 456ITaskItem[] output; 526t.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 569foreach (ITaskItem item in t.FilesWritten) 595t.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 606foreach (ITaskItem item in t.FilesWritten) 627t.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 638t2.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 657foreach (ITaskItem item in t.FilesWritten) 681createResources.Sources = new ITaskItem[] { new TaskItem(firstResx), new TaskItem(secondResx) }; 693t2.Sources = new ITaskItem[] { new TaskItem(firstResx), new TaskItem(secondResx) }; 741t.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 756t2.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 769foreach (ITaskItem item in t.FilesWritten) 797t.Sources = new ITaskItem[] { new TaskItem(resxFile), new TaskItem(txtFile) }; 813t2.Sources = new ITaskItem[] { new TaskItem(resxFile), new TaskItem(txtFile) }; 880initialCreator.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 881initialCreator.References = new ITaskItem[] { new TaskItem(localSystemDll) }; 890incrementalUpToDate.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 891incrementalUpToDate.References = new ITaskItem[] { new TaskItem(localSystemDll) }; 902incrementalOutOfDate.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 903incrementalOutOfDate.References = new ITaskItem[] { new TaskItem(localSystemDll) }; 953ITaskItem[] additionalInputs = null; 958additionalInputs = new ITaskItem[] { new TaskItem(FileUtilities.GetTemporaryFile()), new TaskItem(FileUtilities.GetTemporaryFile()) }; 960foreach (ITaskItem file in additionalInputs) 969t.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 976t2.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 986t3.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 1033t.Sources = new ITaskItem[] { new TaskItem(textFile) }; 1034t.OutputResources = new ITaskItem[] { new TaskItem(Path.ChangeExtension(textFile, ".resx")) }; 1046foreach (ITaskItem item in t.FilesWritten) 1066t.Sources = new ITaskItem[] { new TaskItem(resourcesFile) }; 1067t.OutputResources = new ITaskItem[] { new TaskItem(Path.ChangeExtension(resourcesFile, ".resx")) }; 1073t2a.Sources = new ITaskItem[] { new TaskItem(t.FilesWritten[0].ItemSpec) }; 1074t2a.OutputResources = new ITaskItem[] { new TaskItem(Path.ChangeExtension(t.FilesWritten[0].ItemSpec, ".resources")) }; 1080t2b.Sources = new ITaskItem[] { new TaskItem(t2a.FilesWritten[0].ItemSpec) }; 1081t2b.OutputResources = new ITaskItem[] { new TaskItem(Utilities.GetTempFileName(".resx")) }; 1094foreach (ITaskItem item in t2b.FilesWritten) 1114t.Sources = new ITaskItem[] { new TaskItem(textFile) }; 1125t2.Sources = new ITaskItem[] { new TaskItem(resourcesFile) }; 1127t2.OutputResources = new ITaskItem[] { new TaskItem(outputFile) }; 1137foreach (ITaskItem item in t.FilesWritten) 1143foreach (ITaskItem item in t2.FilesWritten) 1159t.Sources = new ITaskItem[] { new TaskItem(textFile) }; 1200foreach (ITaskItem item in t.FilesWritten) 1222t.Sources = new ITaskItem[] { new TaskItem(textFile) }; 1262t2.Sources = new ITaskItem[] { new TaskItem(textFile) }; 1278foreach (ITaskItem item in t.FilesWritten) 1285foreach (ITaskItem item in t2.FilesWritten) 1314t.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 1315t.OutputResources = new ITaskItem[] { new TaskItem(resourcesFile) }; 1335t.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 1336t.OutputResources = new ITaskItem[] { new TaskItem(resourcesFile) }; 1348t.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 1349t.OutputResources = new ITaskItem[] { new TaskItem(resourcesFile) }; 1365t.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 1366t.OutputResources = new ITaskItem[] { new TaskItem(resourcesFile) }; 1406t.Sources = new ITaskItem[] { new TaskItem(txtFile) }; 1467t.Sources = new ITaskItem[] { new TaskItem(textFile) }; 1507foreach (ITaskItem item in t.FilesWritten) 1527t.Sources = new ITaskItem[] { new TaskItem(textFile) }; 1560foreach (ITaskItem item in t.FilesWritten) 1585t.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 1626foreach (ITaskItem item in t.FilesWritten) 1711t.Sources = new ITaskItem[] { new TaskItem(textFile) }; 1717foreach (ITaskItem item in t.FilesWritten) 1727t.Sources = new ITaskItem[] { new TaskItem(textFile) }; 1736foreach (ITaskItem item in t.FilesWritten) 1762t.Sources = new ITaskItem[] { new TaskItem(resxFile1), new TaskItem(resxFile2) }; 1839t.Sources = new ITaskItem[] { new TaskItem(resxFile1), new TaskItem(resxFile2) }; 1844t.OutputResources = new ITaskItem[] { new TaskItem(resourcesFile1), new TaskItem(resourcesFile2) }; 1911t.Sources = new ITaskItem[] { new TaskItem(textFile) }; 1921foreach (ITaskItem item in t.FilesWritten) 1938t.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 1939t.OutputResources = new ITaskItem[] { new TaskItem(Path.ChangeExtension(resxFile, ".txt")) }; 1949foreach (ITaskItem item in t.FilesWritten) 1968t.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 2029gr.Sources = new ITaskItem[] { new TaskItem(resource.Path) }; 2051t.Sources = new ITaskItem[] { new TaskItem(resourcesFile) }; 2052t.OutputResources = new ITaskItem[] { new TaskItem(resxFile) }; 2063foreach (ITaskItem item in t.FilesWritten) 2082t.Sources = new ITaskItem[] { new TaskItem(resourcesFile) }; 2083t.OutputResources = new ITaskItem[] { new TaskItem(env.GetTempFile(".resources").Path) }; 2102t.Sources = new ITaskItem[] { new TaskItem(textFile) }; 2120foreach (ITaskItem item in t.FilesWritten) 2142t.Sources = new ITaskItem[] { new TaskItem(txtFile) }; 2186ITaskItem i = new TaskItem(resxFile); 2188t.Sources = new ITaskItem[] { i }; 2190ITaskItem o = new TaskItem("MyAlternateResource.resources"); 2193t.OutputResources = new ITaskItem[] { o }; 2209foreach (ITaskItem item in t.FilesWritten) 2224ITaskItem i = new TaskItem(resxFile); 2226t.Sources = new ITaskItem[] { i }; 2239foreach (ITaskItem item in t.FilesWritten) 2253t.Sources = new ITaskItem[] { 2270foreach (ITaskItem item in t.Sources) 2275foreach (ITaskItem item in t.FilesWritten) 2289t.Sources = new ITaskItem[] { 2313foreach (ITaskItem item in t.Sources) 2317foreach (ITaskItem item in t.FilesWritten) 2333t.Sources = new ITaskItem[] { 2340foreach (ITaskItem taskItem in t.Sources) 2391foreach (ITaskItem item in t.Sources) 2395foreach (ITaskItem item in t.FilesWritten) 2419t.Sources = new ITaskItem[] { new TaskItem(textFile) }; 2423t.OutputResources = new ITaskItem[] { new TaskItem("somefile.resources") }; 2441foreach (ITaskItem item in t.FilesWritten) 2462t.Sources = new ITaskItem[] { new TaskItem(textFile) }; 2487foreach (ITaskItem item in t.FilesWritten) 2523foreach (ITaskItem item in t.FilesWritten) 2545t.Sources = new ITaskItem[] { new TaskItem(textFile) }; 2546t.References = new ITaskItem[] { new TaskItem("some non-existent DLL name goes here.dll") }; 2577t.Sources = new ITaskItem[] { new TaskItem("non-existent.resx"), new TaskItem(txtFile) }; 2614t.Sources = new ITaskItem[] { new TaskItem(textFile) }; 2631foreach (ITaskItem item in t.FilesWritten) 2653t.Sources = new ITaskItem[] { new TaskItem(newTextFile) }; 2665foreach (ITaskItem item in t.FilesWritten) 2685t.Sources = new ITaskItem[] { new TaskItem(textFile) }; 2686t.OutputResources = new ITaskItem[] { new TaskItem(resxFile) }; 2697foreach (ITaskItem item in t.FilesWritten) 2717t.Sources = new ITaskItem[] { new TaskItem(textFile) }; 2718t.OutputResources = new ITaskItem[] { new TaskItem(resxFile), new TaskItem("someother.resources") }; 2729foreach (ITaskItem item in t.FilesWritten) 2749t.Sources = new ITaskItem[] { new TaskItem(textFile) }; 2761foreach (ITaskItem item in t.FilesWritten) 2786t.Sources = new ITaskItem[] { new TaskItem(resxFile), new TaskItem(resxFile2) }; 2835t.Sources = new ITaskItem[] { new TaskItem(txtFile) }; 2839t.OutputResources = new ITaskItem[] { new TaskItem("somefile.resources") }; 2875t.Sources = new ITaskItem[] { new TaskItem(txtFile) }; 2912t.Sources = new ITaskItem[] { new TaskItem(txtFile) }; 2949t.Sources = new ITaskItem[] { new TaskItem(txtFile) }; 2990t.Sources = new ITaskItem[] { new TaskItem(txtFile) }; 3037t.Sources = new ITaskItem[] { new TaskItem(resourcesFile) }; 3038t.OutputResources = new ITaskItem[] { new TaskItem("||") }; 3211t.Sources = new ITaskItem[] { new TaskItem(Path.Combine(ObjectModelHelpers.TempProjectDir, "MyStrings.resx")) }; 3214t.References = new ITaskItem[] 3360t.Sources = new ITaskItem[] { new TaskItem(Path.Combine(ObjectModelHelpers.TempProjectDir, "MyStrings.resx")) }; 3367t.References = new ITaskItem[] { reference }; 3415t.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 3451t.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 3452t.References = new ITaskItem[] { new TaskItem("baz"), new TaskItem("jazz") }; 3494t.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 3495t.References = new ITaskItem[] { new TaskItem("baz"), new TaskItem("jazz") }; 3540t.Sources = new ITaskItem[] { new TaskItem(resxFile), new TaskItem(resxFile1) }; 3541t.OutputResources = new ITaskItem[] 3625t.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 3652foreach (ITaskItem item in t.FilesWritten) 3682task.Sources = new ITaskItem[] { new TaskItem(resxFile) }; 3716t.Sources = new ITaskItem[] { new TaskItem("non-existent") }; 3717t.OutputResources = new ITaskItem[] { new TaskItem("out") }; 3859t.Sources = new ITaskItem[] { new TaskItem(sourceFile) }; 3925t.References = new ITaskItem[] { 4212t.Sources = new ITaskItem[] { new TaskItem(textFile) }; 4297foreach (ITaskItem item in t.FilesWritten)

237new TaskPropertyInfo("Parameter4", typeof(ITaskItem), output: false, required: false), 238new TaskPropertyInfo("Parameter5", typeof(ITaskItem[]), output: false, required: false), 346new TaskPropertyInfo("Parameter4", typeof(ITaskItem), output: false, required: false), 347new 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[]

41SourceFiles = new ITaskItem[] { new TaskItem(zipArchive.Path) } 69SourceFiles = new ITaskItem[] { new TaskItem(zipArchive.Path) }, 82SourceFiles = new ITaskItem[] { new TaskItem(zipArchive.Path) }, 97SourceFiles = new ITaskItem[] { new TaskItem(zipArchive.Path) }, 126SourceFiles = new ITaskItem[] { new TaskItem(zipArchive.Path) } 194SourceFiles = new ITaskItem[] { new TaskItem(zipArchive.Path) } 216SourceFiles = new ITaskItem[] { new TaskItem(file.Path), } 236SourceFiles = new ITaskItem[] { new TaskItem(Path.Combine(testEnvironment.DefaultTestDirectory.Path, "foo.zip")), } 263SourceFiles = new ITaskItem[] { new TaskItem(zipArchive.Path) }, 292SourceFiles = new ITaskItem[] { new TaskItem(zipArchive.Path) }, 325SourceFiles = new ITaskItem[] { new TaskItem(zipArchive.Path) }, 358SourceFiles = new ITaskItem[] { new TaskItem(zipArchive.Path) }, 386SourceFiles = new ITaskItem[] { new TaskItem(zipArchive.Path) }, 414SourceFiles = new ITaskItem[] { new TaskItem(zipArchive.Path) }, 442SourceFiles = new ITaskItem[] { new TaskItem(zipArchive.Path) }, 476SourceFiles = 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));

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

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

142ITaskItem sourceItem) 314public void CopyMetadataTo(ITaskItem destinationItem)

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

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

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)

41protected abstract IEnumerable<MSB.Framework.ITaskItem> GetCompilerCommandLineArgs(MSB.Execution.ProjectInstance executedProject); 241protected static bool IsNotTemporaryGeneratedFile(MSB.Framework.ITaskItem item) 244private DocumentFileInfo MakeDocumentFileInfo(MSB.Framework.ITaskItem documentItem) 255private DocumentFileInfo MakeNonSourceFileDocumentFileInfo(MSB.Framework.ITaskItem documentItem) 266private ImmutableArray<string> GetRelativeFolders(MSB.Framework.ITaskItem documentItem) 295private string GetDocumentFilePath(MSB.Framework.ITaskItem documentItem) 298private static bool IsDocumentLinked(MSB.Framework.ITaskItem documentItem) 303protected bool IsDocumentGenerated(MSB.Framework.ITaskItem documentItem) 322protected static string GetDocumentLogicalPath(MSB.Framework.ITaskItem documentItem, string projectDirectory)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

59public ITaskItem[] TargetFeedConfig { get; set; } 65public ITaskItem[] AssetManifestPaths { get; set; } 130public ITaskItem[] FeedKeys { get; set; } 131public ITaskItem[] FeedSasUris { get; set; } 133public ITaskItem[] FeedOverrides { get; set; }

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

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

20public ITaskItem[] ItemsToPush { get; set; } 46public ITaskItem[] ItemsToSign { get; set; } 48public ITaskItem[] StrongNameSignInfo { get; set; } 50public ITaskItem[] FileSignInfo { get; set; } 52public ITaskItem[] FileExtensionSignInfo { get; set; } 54public ITaskItem[] CertificatesSignInfo { get; set; } 107public ITaskItem[] ArtifactVisibilitiesToPublish { get; set; } 360private static ArtifactVisibility GetVisibilitiesToPublish(ITaskItem[] allowedVisibilities) 369foreach (var item in allowedVisibilities)

42private readonly ITaskItem[] FeedKeys = GetFeedKeys(); 44private static ITaskItem[] GetFeedKeys() 52return new ITaskItem[] 176Array.Empty<ITaskItem>(), 177Array.Empty<ITaskItem>(), 293Array.Empty<ITaskItem>(), 294Array.Empty<ITaskItem>(), 408Array.Empty<ITaskItem>(), 409Array.Empty<ITaskItem>(),

43private readonly ITaskItem[] FeedKeys = GetFeedKeys(); 45private static ITaskItem[] GetFeedKeys() 53return new ITaskItem[] 170Array.Empty<ITaskItem>(), 171Array.Empty<ITaskItem>(), 265Array.Empty<ITaskItem>(), 266Array.Empty<ITaskItem>(), 360Array.Empty<ITaskItem>(), 361Array.Empty<ITaskItem>(),

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

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

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

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

47public ITaskItem[] RawPayloadFileKinds { get; set; } = []; 49public ITaskItem[] Requires { get; set; } = []; 51public ITaskItem[] Conflicts { get; set; } = []; 53public ITaskItem[] OwnedDirectories { get; set; } = []; 55public ITaskItem[] ChangelogLines { get; set; } = []; 65public ITaskItem[] Scripts { get; set; } = []; 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; } 56List<ITaskItem> updatedDependencies = new List<ITaskItem>(); 62foreach (ITaskItem metapackage in SuppressMetaPackages) 97foreach (var originalDependency in OriginalDependencies) 133private ITaskItem CreateDependency(string id, NuGetFramework targetFramework)

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

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

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) 286foreach (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; } 40List<ITaskItem> promotedDependencies = new List<ITaskItem>(); 87private IEnumerable<ITaskItem> CopyDependencies(IEnumerable<Dependency> dependencies, NuGetFramework targetFramework) 102public Dependency(ITaskItem item) 117public ITaskItem OriginalItem { get; }

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

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