System.IO.Directory.EnumerateDirectories Recurse enumeration with EnumerationOptions count is different as other tools

[Kriegel]

Hi!

I am like to enumerate Filesystem Directories with the .NET Classes and PowerShell 6 because they are faster than the Cmdlet Get-ChildItem.

My PowerShell Version is:

Name Value

---

PSVersion 6.2.2
PSEdition Core
GitCommitId 6.2.2
OS Microsoft Windows 10.0.16299
Platform Win32NT
PSCompatibleVersions {1.0, 2.0, 3.0, 4.0…}
PSRemotingProtocolVersion 2.3
SerializationVersion 1.1.0.1
WSManStackVersion 3.0

If I do a recurse enumeration over "C:\Windows" , with User permissions (to have a folder with lots of access denied) and the following Function under use of
System.IO.EnumerationOptions

The count of Directories is INCORRECT and shows a count of 35712
Missing 1057

Function Get-DirRecurseEnumerationOptions {

    [Cmdletbinding()]
    Param (
        [String[]]$Path
    )
    
    Begin {
         $EnumerationOptions = New-Object 'System.IO.EnumerationOptions'
         $EnumerationOptions.IgnoreInaccessible = $False
         $EnumerationOptions.RecurseSubdirectories = $False
    }


    Process {
        
        ForEach ($Dir in $Path) {
             [System.IO.DirectoryInfo]$Dir

            Try {
                ForEach ($D in [System.IO.Directory]::EnumerateDirectories($Dir,'*',$EnumerationOptions)) {
                    Get-DirRecurse -Path $D
                }
            } Catch {
                Write-Error $_
            }
        }
    }
}

Get-DirRecurseEnumerationOptions -Path 'C:\windows' -ErrorAction SilentlyContinue | measure

If I do the same with System.IO.SearchOption.TopDirectoryOnly i get the correct count of 36765

Function Get-DirRecurseSearchOption {

    [Cmdletbinding()]
    Param (
        [String[]]$Path
    )
    
    Process {
        
        ForEach ($Dir in $Path) {
             [System.IO.DirectoryInfo]$Dir

            Try {
                ForEach ($D in [System.IO.Directory]::EnumerateDirectories($Dir,'*',[System.IO.SearchOption]::TopDirectoryOnly)) {
                    Get-DirRecurse1 -Path $D
                }
            } Catch {
                Write-Error $_
            }
        }
    }
}

Get-DirRecurseSearchOption -Path 'C:\windows' -ErrorAction SilentlyContinue | measure

[Kriegel]

Here is c# code to reproduce this behavior.
This code was tested on a other machine and is producing the same difference between the 2 methods.

EnumerationOptions count = 28729
SearchOption count = 29214

using System;
using System.Collections.Generic;
using System.IO;

namespace TestDirectoryEnumeration
{
    class Program
    {
        static void Main(string[] args)
        {

            string rootpath = @"C:\Windows";

            int counter = 0;

            EnumerationOptions options = new EnumerationOptions
            {
                RecurseSubdirectories = false
            };

            counter = GetDirRecurseEnumerationOptions(rootpath, options, ref counter);

            Console.WriteLine(@"EnumerationOptions count = " + counter);

            counter = 0;

            counter = GetDirRecurseSearchOption(rootpath, ref counter);

            Console.WriteLine(@"SearchOption count = " + counter);

            Console.WriteLine("The End!");
        }

        private static int GetDirRecurseEnumerationOptions(string path, EnumerationOptions options, ref int counter)
        {
            try
            {
                foreach (string dir in Directory.EnumerateDirectories(path,@"*",options))
                {
                    // Console.WriteLine(dir);
                    counter++;
                    GetDirRecurseEnumerationOptions(dir, options, ref counter);
                }
            }
            catch (Exception e)
            {
                // Console.WriteLine(e.Message);
            }
            
            return counter;
        }

        private static int GetDirRecurseSearchOption(string path, ref int counter)
        {
            try
            {
                foreach (string dir in Directory.EnumerateDirectories(path, @"*", SearchOption.TopDirectoryOnly))
                {
                    // Console.WriteLine(dir);
                    counter++;
                    GetDirRecurseSearchOption(dir, ref counter);
                }
            }
            catch (Exception e)
            {
                // Console.WriteLine(e.Message);
            }

            return counter;
        }

    }
}

The following PowerShell command reports a count of : 29215

Get-ChildItem -Path 'C:\Windows' -Recurse -Directory -ErrorAction Silent -Force | Measure-Object

[ericstj]

It looks to me like the latter search is including System and Hidden files, but the former is not. Try setting AttributesToSkip = 0.

This worked for me:

EnumerationOptions eo = new EnumerationOptions()
{
    AttributesToSkip = 0,
    IgnoreInaccessible = false,
    RecurseSubdirectories = false
};

/cc @JeremyKuhne @carlossanlop

[Kriegel]

Thank you all for clarification!