protected override IEnumerable <string> Execute(CodeActivityContext context)
        {
            var directories = Path.GetAsArray <string>(context);
            var patterns    = SearchPattern.GetAsArray <string>(context);

            if (patterns.Length == 0)
            {
                patterns = new[] { "*.*" }
            }
            ;

            IEnumerable <string> result = new string[] { };

            foreach (var directory in directories)
            {
                foreach (var pattern in patterns)
                {
                    result = result.Union(Directory.EnumerateFiles(directory, pattern, SearchOption));
                }
            }

            if (Exclusions > 0)
            {
                result = result.Where(filePath => (new FileInfo(filePath).Attributes & Exclusions) == 0);
            }

            return(result);
        }
    }
        protected async override Task <Action <AsyncCodeActivityContext> > ExecuteAsync(AsyncCodeActivityContext context, CancellationToken token)
        {
            var folder        = Folder.Get(context);
            var patterns      = SearchPattern?.GetAsArray <string>(context) ?? new[] { "*" };
            var lastWriteTime = LastWriteTime?.Get(context) ?? DateTime.Now;

            int filesDeleted   = 0;
            int foldersDeleted = 0;

            await Task.Run(() =>
            {
                foreach (var p in patterns)
                {
                    foreach (var f in Directory.EnumerateFiles(folder, p, SearchOption.AllDirectories).Reverse())
                    {
                        try
                        {
                            if (File.GetLastWriteTime(f) > lastWriteTime)
                            {
                                continue;
                            }

                            File.Delete(f);
                            filesDeleted++;
                        }
                        catch (Exception e)
                        {
                            Trace.WriteLine($"{f}: {e.Message}");
                        }
                    }
                }

                if (DeleteEmptyFolders)
                {
                    foreach (var f in Directory.EnumerateDirectories(folder, "*", SearchOption.AllDirectories).Reverse())
                    {
                        if (Directory.EnumerateFileSystemEntries(f, "*").Any())
                        {
                            continue;
                        }

                        try
                        {
                            Directory.Delete(f);
                            foldersDeleted++;
                        }
                        catch (Exception e)
                        {
                            Trace.WriteLine($"{f}: {e.Message}");
                        }
                    }
                }
            }).ConfigureAwait(false);

            return(ctx =>
            {
                Result.Set(ctx, new CleanUpFolderResult
                {
                    FilesDeleted = filesDeleted,
                    FoldersDeleted = foldersDeleted
                });
            });
        }