DirTree: A Simplified Directory Tree Tool

<#
    DirTree.ps1 - DirTree: a simplified directory tree tool

    Converted from Rick Zeeland's Article on CodeProject from 29 Jun 2022
        https://www.codeproject.com/Tips/5336104/DirTree-a-simplified-directory-tree-tool

    A quick and dirty Console app written in VS2019 and .NET 4.8 to scan a VS directory and create a simplified directory tree.

    Console app to scan a VS directory and create a simplified directory tree.
    Command line usage: 
       DirTree [path] [depth]
    If no $path is given, the current directory is used.
    Depth must be >= 0, default value is 2.

    PowerShell Script Notes:
      Converted from Rick Zeeland's C# DirTree.cs program  by Brooks Vaughn (developers @ brooksvaughn . net)
      Did very little optimizations and code changes from original C# code
      Added several switches and options
      If a Folder cannot be accessed, <!Access Denied!> is appended to the Folder Name
    Parameters
      -Path <Starting Directory Path> Defaults to Current Folder
      -Depth <Max Nested Directory Levels> Defaults to 2
      -filter <Directory Search Pattern> Defaults to '*.*'
      -OutputFile <FilePath> Defaults to 'C:\Temp\DirTree\DirTree.txt'
      -TimeStampFmt = 'yyyy-MMdd-HHmm'
      -excludeList <Array List of Folder Names to exclude from output> Defaults to @('bin', 'obj', 'x64', 'x86', 'Properties')
    Switches
      -NoPrompt will not pause at end of script
      -SaveOutput will enable saving output to file
      -Quiet will enable -SaveOutput
      -TimeStamp will append the DateTime to OutputFile as -TimeStampFmt

Includes Converted Functions:
DirTree() - Main Function -- Console app to scan a VS directory and create a simplified directory tree
GetFoldersFiltered() - Get folders array, exclude folders with $excludeList and starting with '.' like .git .vs.
ScanFolders() - Recursively scan folders with a depth of <see cref="$treeDepth"/>.

#>

# <summary>
# Get folders array, exclude folders with $excludeList and starting with '.' like .git .vs.
# </summary>
# <param name="path">The path</param>
# <param name="$filter">Wildcard $filter</param>
# <returns>A [string]array</returns>
Function GetFoldersFiltered() {
    [CmdletBinding()]
    Param(
        [string]$path,
        [string]$filter,
        $excludeList = $excludeList
    )
    try {
        [System.Collections.Generic.List[string]]$folders = [System.IO.Directory]::GetDirectories($path, $filter)
        for ($i = $folders.Count - 1; $i -ge 0; $i--) {
            [string]$dirname = $folders[$i].Replace($path, '')
            if ($dirname.StartsWith('.') -or $excludeList.Contains($dirname)) {
                $folders.RemoveAt($i)
            }
        }
        return $folders.ToArray()
    } catch {
        # Write-Warning $_.Exception.Message
        @(' <!Access Denied!>')
    }
}

# <summary>
# Recursively scan folders with a depth of <see cref="$treeDepth"/>.
# </summary>
# <param name="path">The start path</param>
# <param name="$continueLine">The folder level to continue vertical line</param>
# <param name="$previous_indent">The previous $indentation</param>
Function ScanFolders() {
    [CmdletBinding()]
    Param(
        [string]$path,
        [int]$continueLine = -1,
        [string]$previous_indent = [String]::Empty
    )
    $i = 0
    if (-not $path.EndsWith([System.IO.Path]::DirectorySeparatorChar)) {
        $path += [System.IO.Path]::DirectorySeparatorChar
    }

    $dirs = GetFoldersFiltered -path $path -filter $filter
    If ($dirs -is [Array] -or $dirs -notlike '*<!*!>') {
        $lastNode = $dirs.Count - 1
        while ($i -lt $dirs.Count) {
            If ($dirs -is [array]) {
                $dirFullname = $dirs[$i]
            } Else {
                $dirFullname = $dirs
            }
            $dirname = $dirFullname.Replace($path, '')
            $indent = '  '
            $indent2 = [string]::Empty
            if ($dirFullname.StartsWith($lastFolder)) {
                $lastDirFlag = $true
            }
            $folderLevel = $dirFullname.Split([System.IO.Path]::DirectorySeparatorChar).Count - $folderLevelStart
            for ($j = 0; $j -lt $folderLevel; $j++) {
                if ($lastDirFlag -and $continueLine -ge $j) {
                    $indent += (' ' + (' ' * $tabSize))
                } else {
                    $indent += ('│' + (' ' * $tabSize))
                }
            }

            if ($previous_indent.Length -gt 0) {
                $indent = $previous_indent + $indent.Substring($previous_indent.Length)
            }

            if ($i -eq $lastNode) {
                $indent2 = ('└' + ('─' * $tabSize))
                $continueLine = $folderLevel
            } else {
                $indent2 = ('├' + ('─' * $tabSize))
            }

            $Line = "`n{0}{1}{2}" -f $indent, $indent2, $dirname
            if (-not $Quiet) {
                Write-Host $line -NoNewline
            }
            $null = $sbTree.Append($Line)

            if ($folderLevel -lt $treeDepth) {
                if ($i -eq $lastNode) {
                    $indent += (' ' + (' ' * $tabSize))
                }

                # Recursive call
                ScanFolders -path $dirFullname -continueLine $continueLine -previous_indent $indent
            }
            $i++
        }
    } Else {
        if (-not $Quiet) {
            Write-Host $dirs -NoNewline
        }
        $null = $sbTree.Append($dirs)
    }

}

Function DirTree () {
    [CmdletBinding()]
    Param (
        [string]$Path,
        [string]$filter = '*.*',
        [int]$Depth = 2,
        [switch]$NoPrompt,
        [switch]$Quiet,
        [switch]$TimeStamp,
        [switch]$SaveOutput,
        [System.IO.FileInfo]$OutputFile = [System.IO.FileInfo]'C:\Temp\DirTree\DirTree.txt',
        [string]$TimeStampFmt = 'yyyy-MMdd-HHmm',
        [System.Collections.Generic.List[string]]$excludeList
    )
    if ($Path) {
        $startpath = $Path
    } Else {
        $startpath = [Environment]::CurrentDirectory
    }

    If ($Quiet) {
        $SaveOutput = $true
    }

    If ($SaveOutput -and -not $OutputFile.Directory.Exists) {
        $OutputFile.Directory.Create()
    }
    $OutFilePath = $OutputFile.FullName
    If ($TimeStamp) {
        $OutFilePath = $OutputFile.FullName.Replace($OutputFile.Extension, "_$(Get-Date -Format $TimeStampFmt)$($OutputFile.Extension)")
    }

    if (-not $startPath.EndsWith([System.IO.Path]::DirectorySeparatorChar)) {
        $startpath += [System.IO.Path]::DirectorySeparatorChar
    }

    $timeStampString = [string]::Empty
    [int]$treeDepth = $Depth

    [int]$folderLevel = 0
    [int]$folderLevelStart = 0
    [string]$lastFolder = [String]::Empty
    [bool]$lastDirFlag = $false
    [int]$tabSize = 3
    $sbTree = [System.Text.StringBuilder]::new() # Optionally write to DirTree.txt
    $null = $sbTree.AppendLine($startPath)
    $null = $sbTree.AppendLine()

    # Add directories to exclude List
    If (-not $excludeList) {
        $excludeList.Add('bin')
        $excludeList.Add('obj')
        $excludeList.Add('x64')
        $excludeList.Add('x86')
        $excludeList.Add('Properties')
    }

    $folderLevelStart = $startPath.Split([System.IO.Path]::DirectorySeparatorChar).Count
    $dirs = GetFoldersFiltered -path $startPath -filter $filter
    if ($dirs -and $dirs.Count -gt 0) {
        $lastFolder = $dirs[-1]
        ScanFolders -path $startPath
        $null = $sbTree.AppendLine()
        If ($SaveOutput) {
            $sbTree.ToString() | Out-File -FilePath $OutFilePath -Encoding utf8 -Force
            Write-Host ("`nOutput Saved to File: ({0})" -f $OutFilePath) -ForegroundColor Cyan
        }
    } else {
        Write-Host('No directories found.')
    }
    If (-not $NoPrompt) {
        Read-Host -Prompt "`n`nCompleted. Press <Return> key to exit"
    }
}

<# Usage Examples: # >
# Notes:
#   If a Folder cannot be accessed, <!Access Denied!> is appended to the Folder Name
# Parameters
#   -Path <Starting Directory Path> Defaults to Current Folder
#   -Depth <Max Nested Directory Levels> Defaults to 2
#   -filter <Directory Search Pattern> Defaults to '*.*'
#   -OutputFile <FilePath> Defaults to 'C:\Temp\DirTree\DirTree.txt'
#   -TimeStampFmt = 'yyyy-MMdd-HHmm'
#   -excludeList <Array List of Folder Names to exclude from output> Defaults to @('bin', 'obj', 'x64', 'x86', 'Properties')
# Switches
#   -NoPrompt will not pause at end of script
#   -SaveOutput will enable saving output to file
#   -Quiet will enable -SaveOutput
#   -TimeStamp will append the DateTime to OutputFile as -TimeStampFmt
DirTree
DirTree -Path C:\ -Depth 1
DirTree -SaveOutput
DirTree -SaveOutput -OutputFile C:\temp\TreeList.txt
DirTree -SaveOutput -OutputFile C:\temp\TreeList.txt -TimeStamp
DirTree -Quiet -NoPrompt
DirTree -Quiet -OutputFile C:\temp\DirTree.txt -TimeStamp
DirTree -Depth 1 -excludeList @('Roaming', 'bin', 'obj', 'x64', 'x86', 'Properties')
#>

It may be more efficient to use Directory.EnumerateDirectories rather than Directory.GetDirectories and then employ a bit of Linq to process the enumerable using deferred execution. Something like

static string[] GetFoldersFiltered(string path, string filter)
{
  var folders = Directory.EnumerateDirectories(path, filter);
  return folders.Where(s => !s.Replace(path, "").StartsWith(".") && !excludeList.Contains(s.Replace(path, ""))).ToArray();
}