Merge changes from develop before release 2.0.0

Author: tusmester

README.md

@@ -1,30 +1,29 @@
-# ParallelTreeWalker
+# Skraalsoft Parallel TreeWalker
 An extensible and highly scalable **.Net component** for processing elements in a **tree** in an **async** and **parallel** way.
 
+[![NuGet](https://img.shields.io/nuget/v/Skraalsoft.ParallelTreeWalker.svg)](https://www.nuget.org/packages/Skraalsoft.ParallelTreeWalker)
+
 * it is able to process **huge trees**, like a large directory structure in the file system.
 * **parent folders** are always processed before children.
 * **parallel**: you decide how many tree elements can be visited at the same time.
 * **efficient**: consumed resources depend only on how many parallel operations you allow, not on the size of the tree.
 * **async**: when a tree element is visited, you can perform an asynchronous operation (e.g. execute a database command or web request).
 
-[Latest release](https://github.com/tusmester/ParallelTreeWalker/releases/latest)
-
 ## Usage
 First implement the *ITreeElement* interface (relax, it is simple) to represent your tree element - or if you want to discover the file system, you can use the built-in *FileSystemElement* class.
 
-Just call the *WalkAsync* method with a root element and it will do the rest. In the options parameter you can define a callback function (*ProcessElementAsync*) that will be executed every time a tree element is reached.
+Just call the *WalkAsync* method with a root element and it will do the rest. You can define a callback function that will be executed every time a tree element is reached.
 
 ```c#
-await TreeWalker.WalkAsync(root, new TreeWalkerOptions
+await TreeWalker<FileSystemElement>.WalkAsync(root, async (element) =>
+{
+    var path = element.Path;
+    var isDirectory = element.IsDirectory;
+
+    await DoStuffAsync(element);
+}, 
+new TreeWalkerOptions
 {
-    MaxDegreeOfParallelism = 5,
-    ProcessElementAsync = async (element) =>
-    {
-        var el = element as FileSystemElement;
-        var path = el.Path;
-        var isDirectory = el.IsDirectory;
-        
-        await DoStuffAsync(el);
-    }
+    MaxDegreeOfParallelism = 10
 });
 ```

img/icon-big.png

@@ -1,15 +1,14 @@
 using Microsoft.VisualStudio.TestTools.UnitTesting;
-using ParallelTreeWalker.Elements;
+using Skraalsoft.ParallelTreewalker.Elements;
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.IO;
 using System.Linq;
-using System.Text;
 using System.Threading.Tasks;
 
-namespace ParallelTreeWalker.Tests
+namespace Skraalsoft.ParallelTreewalker.Tests
 {
     [TestClass]
     public class FileSystemTests
@@ -25,29 +24,28 @@ public async Task TwoLevels_Balanced()
             var actual = string.Join(Environment.NewLine, allVisitedPath);
 
             // expected results: enumerate manually, add root dir and sort
-            var expected = string.Join(Environment.NewLine, 
-                Enumerable.Union(new List<string> { rootDir }, Directory.EnumerateFileSystemEntries(rootDir, "*", SearchOption.AllDirectories)).OrderBy(p => p));
+            var expected = string.Join(Environment.NewLine,
+                new List<string> {rootDir}
+                    .Union(Directory.EnumerateFileSystemEntries(rootDir, "*", SearchOption.AllDirectories))
+                    .OrderBy(p => p));
 
             Assert.AreEqual(expected, actual);
         }
 
-        public async Task<string[]> TestWalk(ITreeElement root, int maxParallel)
+        public async Task<string[]> TestWalk(FileSystemElement root, int maxParallel)
         {
             var allPaths = new ConcurrentBag<string>();
 
-            await TreeWalker.WalkAsync(root, new TreeWalkerOptions
+            await TreeWalker<FileSystemElement>.WalkAsync(root, el =>
             {
-                MaxDegreeOfParallelism = maxParallel,
-                ProcessElementAsync = (element) =>
-                {
-                    var el = element as FileSystemElement;
-
-                    Trace.WriteLine(string.Format("##PTW> {0} Path: {1}", DateTime.UtcNow.ToLongTimeString(), el.Path));
+                Trace.WriteLine($"##PTW> {DateTime.UtcNow.ToLongTimeString()} Path: {el.Path}");
 
-                    allPaths.Add(el.Path);
+                allPaths.Add(el.Path);
 
-                    return Task.FromResult<object>(null);
-                }
+                return Task.FromResult<object>(null);
+            }, new TreeWalkerOptions
+            {
+                MaxDegreeOfParallelism = maxParallel
             });
 
             return allPaths.OrderBy(p => p).ToArray();
@@ -62,14 +60,14 @@ private string CreateTestStructure()
             if (Directory.Exists(rootDir))
                 Directory.Delete(rootDir, true);
 
-            var subDirs = new string[]
+            var subDirs = new[]
             {
                 Path.Combine(rootDir, @"F1\F11"),
                 Path.Combine(rootDir, @"F1\F12"),
                 Path.Combine(rootDir, @"F2\F21"),
                 Path.Combine(rootDir, @"F2\F22"),
                 Path.Combine(rootDir, @"F3\F31"),
-                Path.Combine(rootDir, @"F3\F32"),
+                Path.Combine(rootDir, @"F3\F32")
             };
 
             foreach (var subDir in subDirs)