public override bool Execute()
        {
            ItemFilter.ItemMetadataFilter itemMetadataSkipFilter = (ItemFilter.ItemMetadataFilter)null;
            if (this.SkipMetadataExcludeTrueItems)
            {
                itemMetadataSkipFilter = new ItemFilter.ItemMetadataFilter(ItemFilter.ItemFilterExcludeTrue);
            }
            List <ITaskItem> failedPipeLineItems = new List <ITaskItem>(8);

            this.m_updateItemsITaskItem = new List <ITaskItem>(this.m_pipeLineItemsITaskItem == null ? 0 : this.m_pipeLineItemsITaskItem.GetLength(0));
            bool folder = CopyPipelineFiles.CopyPipelineFilesToFolder(this.Log, this.m_pipeLineItemsITaskItem, this.SourceDirectory, this.TargetDirectory, itemMetadataSkipFilter, this.UpdateItemSpec, this.DeleteItemsMarkAsExcludeTrue, this.m_updateItemsITaskItem, failedPipeLineItems);

            if (folder && failedPipeLineItems.Count > 0)
            {
                for (int index = 1; index < this.MaxRetries & folder && failedPipeLineItems != null; ++index)
                {
                    Thread.Sleep(this.RetryDelay * (index > 0 ? index : 1));
                    ITaskItem[] array = failedPipeLineItems.ToArray();
                    failedPipeLineItems.Clear();
                    if (this.MaxRetries == index + 1)
                    {
                        failedPipeLineItems = (List <ITaskItem>)null;
                    }
                    folder = CopyPipelineFiles.CopyPipelineFilesToFolder(this.Log, array, this.SourceDirectory, this.TargetDirectory, itemMetadataSkipFilter, this.UpdateItemSpec, this.DeleteItemsMarkAsExcludeTrue, this.m_updateItemsITaskItem, failedPipeLineItems);
                }
            }
            return(folder);
        }
        internal static bool CopyPipelineFilesToFolder(TaskLoggingHelper log, ITaskItem[] allpipeLineItems, string sourceFolderName, string targetFolderName, ItemFilter.ItemMetadataFilter itemMetadataSkipFilter, bool fUpdateItemSpec, bool deleteItemsMarkAsExcludeTrue, List <ITaskItem> updatedPipeLineItems, List <ITaskItem> failedPipeLineItems)
        {
            bool   flag1            = failedPipeLineItems == null;
            string currentDirectory = Directory.GetCurrentDirectory();

            if (!string.IsNullOrEmpty(sourceFolderName) && string.Compare(Path.GetFullPath(sourceFolderName), currentDirectory, StringComparison.OrdinalIgnoreCase) == 0)
            {
                sourceFolderName = (string)null;
            }
            if (!string.IsNullOrEmpty(sourceFolderName) && !Path.IsPathRooted(targetFolderName))
            {
                targetFolderName = Path.Combine(currentDirectory, targetFolderName);
            }
            bool flag2 = CopyPipelineFiles.CreateDirectoryInNeeded(log, targetFolderName);

            if (flag2)
            {
                foreach (ITaskItem allpipeLineItem in allpipeLineItems)
                {
                    string str1 = Path.Combine(targetFolderName, allpipeLineItem.GetMetadata(PipelineMetadata.DestinationRelativePath.ToString()));
                    if (itemMetadataSkipFilter != null && itemMetadataSkipFilter(allpipeLineItem))
                    {
                        if (deleteItemsMarkAsExcludeTrue)
                        {
                            if (File.Exists(str1))
                            {
                                try
                                {
                                    log.LogMessage(MessageImportance.Normal, string.Format((IFormatProvider)CultureInfo.CurrentCulture, SR.BUILDTASK_CopyFilesToFolders_Deleting, (object)str1), Array.Empty <object>());
                                    File.Delete(str1);
                                }
                                catch (Exception ex)
                                {
                                    if (flag1 && ex is IOException)
                                    {
                                        failedPipeLineItems.Add(allpipeLineItem);
                                    }
                                    else
                                    {
                                        log.LogError(string.Format((IFormatProvider)CultureInfo.CurrentCulture, SR.BUILDTASK_CopyFilesToFolders_DeleteFailed, (object)str1, (object)ex.Message), Array.Empty <object>());
                                        flag2 = false;
                                        break;
                                    }
                                }
                            }
                        }
                    }
                    else
                    {
                        string str2 = allpipeLineItem.ItemSpec;
                        if (!Path.IsPathRooted(str2) && !string.IsNullOrEmpty(sourceFolderName))
                        {
                            str2 = Path.Combine(sourceFolderName, str2);
                        }
                        try
                        {
                            bool flag3 = false;
                            if (!File.Exists(str1))
                            {
                                flag3 = true;
                            }
                            else
                            {
                                FileInfo fileInfo1 = new FileInfo(str2);
                                FileInfo fileInfo2 = new FileInfo(str1);
                                if (fileInfo1.LastWriteTimeUtc > fileInfo2.LastWriteTimeUtc || fileInfo1.Length != fileInfo2.Length)
                                {
                                    flag3 = true;
                                }
                            }
                            if (flag3)
                            {
                                log.LogMessage(MessageImportance.Normal, string.Format((IFormatProvider)CultureInfo.CurrentCulture, SR.BUILDTASK_CopyFilesToFolders_Copying, (object)str2, (object)str1), Array.Empty <object>());
                                string directoryName = Path.GetDirectoryName(str1);
                                flag2 = CopyPipelineFiles.CreateDirectoryInNeeded(log, directoryName);
                                if (flag2)
                                {
                                    File.Copy(str2, str1, true);
                                    File.SetAttributes(str1, FileAttributes.Normal);
                                    updatedPipeLineItems.Add(allpipeLineItem);
                                }
                                else
                                {
                                    break;
                                }
                            }
                            else
                            {
                                log.LogMessage(MessageImportance.Normal, string.Format((IFormatProvider)CultureInfo.CurrentCulture, SR.BUILDTASK_CopyFilesToFolders_UpToDate, (object)str2, (object)str1), Array.Empty <object>());
                            }
                            if (fUpdateItemSpec)
                            {
                                allpipeLineItem.ItemSpec = str1;
                            }
                        }
                        catch (Exception ex)
                        {
                            if (flag1 && ex is IOException)
                            {
                                failedPipeLineItems.Add(allpipeLineItem);
                            }
                            else
                            {
                                log.LogError(string.Format((IFormatProvider)CultureInfo.CurrentCulture, SR.BUILDTASK_CopyFilesToFolders_CopyFailed, (object)str2, (object)str1, (object)ex.Message), Array.Empty <object>());
                                flag2 = false;
                                break;
                            }
                        }
                    }
                }
            }
            return(flag2);
        }