Comment faire pour accélérer Powershell Get-Childitem sur UNC

Bon d'accord, c'est la façon dont je le fais, et il semble fonctionner.

$files = cmd /c "$GETFILESBAT \$server\logs$filemask"
foreach( $f in $files ) {
    if( $f.length -gt 0 ) {
        select-string -Path $f -pattern $regex | foreach-object { $_ }
    }
}

Puis $GETFILESBAT points à ceci:

@dir /a-d /b /s %1
@exit

Je suis d'écriture et de suppression de ce fichier BAT à partir du script PowerShell, donc je suppose que c'est une PowerShell seule solution, mais elle ne l'utilise pas seulement PowerShell.

Ma préliminaire des mesures de performance montrent que c'est eleventy mille fois plus rapide.

J'ai testé dcg vs cmd dir vs FileIO.Système de fichiers.GetFiles de @Shawn Melton est référencé lien.

La ligne de fond est que, pour une utilisation quotidienne sur les disques locaux, GetFiles est le plus rapide. De loin. CMD DIR est respectable. Une fois que vous introduisez un ralentissement de la connexion réseau avec de nombreux fichiers, CMD DIR est légèrement plus rapide que GetFiles. Puis Get-ChildItem... wow, cela va de pas trop mal à l'horrible, selon le nombre de fichiers concernés et de la vitesse de la connexion.

Quelques essais. J'ai déplacé DCG autour de dans les tests pour s'assurer que les résultats étaient cohérents.

10 itérations de la numérisation c:\windows\temp pour *.fichiers tmp

.\test.ps1 "c:\windows\temp" "*.tmp" 10
GetFiles ... 00:00:00.0570057
CMD dir  ... 00:00:00.5360536
GCI      ... 00:00:01.1391139

GetFiles est 10x plus rapide que CMD dir, qui lui-même est plus de 2x plus rapide que la GCI.

10 itérations de la numérisation c:\windows\temp pour *.fichiers tmp avec la récursivité

.\test.ps1 "c:\windows\temp" "*.tmp" 10 -recurse
GetFiles ... 00:00:00.7020180
CMD dir  ... 00:00:00.7644196
GCI      ... 00:00:04.7737224

GetFiles est un peu plus rapide que CMD dir, et les deux sont presque 7x plus rapide que la GCI.

10 itérations de la numérisation d'un serveur sur site sur un autre domaine d'application les fichiers journaux

.\test.ps1 "\\closeserver\logs\subdir" "appname*.*" 10
GetFiles ... 00:00:00.3590359
CMD dir  ... 00:00:00.6270627
GCI      ... 00:00:06.0796079

GetFiles est environ 2x plus rapide que CMD dir, lui-même 10x plus rapide que la GCI.

Une itération de la numérisation d'un serveur distant sur un autre domaine d'application les fichiers journaux, avec de nombreux fichiers impliqués

.\test.ps1 "\\distantserver.company.com\logs\subdir" "appname.2011082*.*"
CMD dir  ... 00:00:00.3340334
GetFiles ... 00:00:00.4360436
GCI      ... 00:11:09.5525579

CMD dir est plus rapide d'aller vers le serveur distant avec beaucoup de fichiers, mais GetFiles est honorablement à proximité. GCI sur l'autre main est un couple de mille fois plus lent.

Deux itérations de la numérisation d'un serveur distant sur un autre domaine d'application les fichiers journaux, avec de nombreux fichiers

.\test.ps1 "\\distantserver.company.com\logs\subdir" "appname.20110822*.*" 2
CMD dir  ... 00:00:00.9360240
GetFiles ... 00:00:01.4976384
GCI      ... 00:22:17.3068616

Plus ou moins linéaire de l'augmentation, comme le test d'itérations augmente.

Une itération de la numérisation d'un serveur distant sur un autre domaine d'application les fichiers journaux, avec moins de fichiers

.\test.ps1 "\\distantserver.company.com\logs\othersubdir" "appname.2011082*.*" 10
GetFiles ... 00:00:00.5304170
CMD dir  ... 00:00:00.6240200
GCI      ... 00:00:01.9656630

Ici GCI n'est pas trop mauvais, GetFiles est 3x plus rapide, et CMD dir est pas loin derrière.

Conclusion

GCI besoin d'un -raw ou -fast option qui n'a pas essayer d'en faire autant. Dans l'intervalle, GetFiles est une alternative saine qui est seulement de temps en temps un peu plus lent que CMD dir, et généralement plus rapide (en raison de la ponte CMD.exe?).

Pour référence, voici le test.ps1 code.

param ( [string]$path, [string]$filemask, [switch]$recurse=$false, [int]$n=1 )
[reflection.assembly]::loadwithpartialname("Microsoft.VisualBasic") | Out-Null
write-host "GetFiles... " -nonewline
$dt = get-date;
for($i=0;$i -lt $n;$i++){
if( $recurse ){ [Microsoft.VisualBasic.FileIO.FileSystem]::GetFiles( $path,
[Microsoft.VisualBasic.FileIO.SearchOption]::SearchAllSubDirectories,$filemask
)  | out-file ".\testfiles1.txt"}
else{ [Microsoft.VisualBasic.FileIO.FileSystem]::GetFiles( $path,
[Microsoft.VisualBasic.FileIO.SearchOption]::SearchTopLevelOnly,$filemask
)  | out-file ".\testfiles1.txt" }}
$dt2=get-date;
write-host $dt2.subtract($dt)
write-host "CMD dir... " -nonewline
$dt = get-date;
for($i=0;$i -lt $n;$i++){
if($recurse){
cmd /c "dir /a-d /b /s $path\$filemask" | out-file ".\testfiles2.txt"}
else{ cmd /c "dir /a-d /b $path\$filemask" | out-file ".\testfiles2.txt"}}
$dt2=get-date;
write-host $dt2.subtract($dt)
write-host "GCI... " -nonewline
$dt = get-date;
for($i=0;$i -lt $n;$i++){
if( $recurse ) {
get-childitem "$path\*" -include $filemask -recurse | out-file ".\testfiles0.txt"}
else {get-childitem "$path\*" -include $filemask | out-file ".\testfiles0.txt"}}
$dt2=get-date;
write-host $dt2.subtract($dt)

Voici un lecteur interactif qui analyse cmd /c dir (qui peut prendre en charge les chemins d'accès unc), et permettra de recueillir les 3 plus importantes propriétés pour la plupart des gens: chemin d'accès complet, la taille, l'horodatage

d'utilisation serait quelque chose comme $files_with_details = $faster_get_files.GetFileList($unc_compatible_folder)

et il y a une fonction d'aide à vérifier la taille combinée $faster_get_files.GetSize($files_with_details)

$faster_get_files = New-Module -AsCustomObject -ScriptBlock {
#$DebugPreference = 'Continue' #verbose, this will take figuratively forever
#$DebugPreference = 'SilentlyContinue'
$directory_filter = "Directory of (.+)"
$file_filter = "(\d+/\d+/\d+)\s+(\d+:\d+ \w{2})\s+([\d,]+)\s+(.+)" # [1] is day, [2] is time (AM/PM), [3] is size,  [4] is filename
$extension_filter = "(.+)[\.](\w{3,4})" # [1] is leaf, [2] is extension
$directory = ""
function GetFileList ($directory = $this.directory)
{
if ([System.IO.Directory]::Exists($directory))
{
# Gather raw file list
write-Information "Gathering files..."
$files_raw = cmd /c dir $folder\*.* /s/a-d
# Parse file list
Write-Information "Parsing file list..."
$directory = $folder
$files_with_details = foreach ($line in $files_raw)
{
Write-Debug "starting line {$($line)}"
Switch -regex ($line)
{
$this.directory_filter
{
$directory = $matches[1]
break
}
$this.file_filter
{
Write-Debug "parsing matches {$($matches.value -join ";")}"
$date     = $matches[1]
$time     = $matches[2] # am/pm style
$size     = $matches[3]
$filename = $matches[4]
# we do a second match here so as to not append a fake period to files without an extension, otherwise we could do a single match up above
Write-Debug "parsing extension from {$($filename)}"
if ($filename -match $this.extension_filter) 
{
$file_leaf = $matches[1]
$file_extension = $matches[2]
}
else
{
$file_leaf = $filename
$file_extension = ""
}
[pscustomobject][ordered]@{
"fullname"  = [string]"$($directory)\$($filename)"
"filename"  = [string]$filename
"folder"    = [string]$directory
"file_leaf" = [string]$file_leaf
"extension" = [string]$file_extension
"date"      = get-date "$($date) $($time)"
"size"      = [int]$size
}
break
} 
} # finish directory/file test
} # finish all files
return $files_with_details
} #finish directory exists test
else #directory doesn't exist
{throw("Directory not found")}
}
function GetSize($files_with_details)
{
$combined_size = ($files_with_details|measure -Property size -sum).sum
$pretty_size_gb = "$([math]::Round($combined_size /1GB, 4)) GB"
return $pretty_size_gb
}
Export-ModuleMember -Function * -Variable *
}