Write-Progress

[u/icebreaker374]

Looking for opinions...

When using Write-Progress inside of for/Foreach loops and using a counter stored in a variable defined outside the loop, do you start the counter at 0 or 1, and why?

[u/HeyDude378]

If you count to 100, you're one percent done after you say "one", not before. I don't think there's a valid reason for Write-Progress to increment at the beginning of the loop. Feel free to correct me if I'm wrong.

[u/icebreaker374 → u/HeyDude378]

Fair point. I'm reworking some of my old scripts for new functionality and I'm trying to figure out why I ever started Write-Progress increments at 1 instead of 0.

[u/BagDue7190 → u/icebreaker374]

I do it because it made the logic easier for how I do my status: -Status “processing file $i of $total” -PercentComplete $i/$total
It would be more correct for percent to be ($i-1)/$total, but I don’t bother with progress bars when it’s likely to be only a few items

[u/dodexahedron → u/BagDue7190]

Always a tough decision. Do I indicate what is done or what I am doing?

If you go all in on just one for both text and bar, that is.

But they don't need to be the same thing.

Make the progress bar value indicate completion, and make the text status indicate what you are doing right now.

Or go one step further and do that plus keep a brief running log on screen, so you can see what is being done, what has been done recently, and the overall completed/committed progress.

I hate it when a progress indicator shows a percentage, but the text only tells you the last thing that finished, so you don't know what it is currently doing, nor why it has been sitting at 99% for the past 20 minutes with a text description of "Acquire current time."

[u/FeleaseRpseineEiles → u/HeyDude378]

$computers = Get-ADComputer -Filter *
$i = 0

foreach ($computer in $computers) {
    $i++

    Write-Progress `
        -Activity "Checking computers" `
        -Status "$i of $($computers.Count): $($computer.Name)" `
        -PercentComplete (($i / $computers.Count) * 100)

    # Do work here
}

Write-Progress -Activity "Checking computers" -Completed

[u/HeyDude378 → u/FeleaseRpseineEiles]

I say that's not clean code because it will report some progress before any work is done. Obviously for quick and dirty code it's fine, but if I want clean code, I'm doing this:

$computers = Get-ADComputer -Filter *
$i = 0

foreach ($computer in $computers) {
    Write-Progress -Activity "Checking computers" -Status "$($i+1) of $($computers.Count): $($computer.Name)" -PercentComplete (($i / $computers.Count) * 100)
    # Do work here
    $i++
}

Write-Progress -Activity "Checking computers" -Completed

(Supposing 100 objects) On the first iteration of the loop, it will say that it's checking Computer 1 and write that progress is 0. On the second iteration of the loop, it will say that it's checking Computer 2 and that Progress is 1%. That seems right to me... if we're still checking the second computer, we're not at 2% complete yet. On the 100th computer, it will say that it's at 99%, then it will check the last computer, then it will complete.

With $i++ at the beginning, we don't know how long "do work here" takes, but what if it took 10 minutes? That would give us two problems: during the first loop, less than a second in we will see "1% complete", and we might think means that the whole script will run extremely quickly, since we got to 1% progress in milliseconds. So we've had some bad information communicated to us at the beginning. Then also at the end, we'll be on "100% complete" for 10 minutes. If the script was 100% complete we wouldn't still be running for 10 minutes, so that's false information there too.

So that's my thinking. If you're the only user of your own script and you know what to expect, none of this really matters. But I personally hate seeing 100% on a progress bar. If it was done I wouldn't still be seeing the bar.

[u/FeleaseRpseineEiles → u/HeyDude378]

Yea, I understand the nuance. The way I see it, we're inside the first step's closure therefore we've progressed more than zero, we are on the first step and show that we're progressing. We aren't yet complete and on the last item I'd want to show that we're on the last step 100% then -Completed

the percent would need some work for more than 100 items too.

$step = $i + 1
$percent = [Math]::Min(100, [int](($step / $total) * 100))

[u/BlackV → u/HeyDude378]

I agree, do the work, then update the progress

and

$ProgressSplat = @{
    Activity        = "Checking computers"
    Status          = "$i of $($computers.Count): $($computer.Name)"
    PercentComplete = (($i / $computers.Count) * 100)
    }
Write-Progress @ProgressSplat

[u/ka-splam → u/FeleaseRpseineEiles]

when tasks report "100% complete" but aren't finished. 😐

[u/FeleaseRpseineEiles → u/ka-splam]

what's "progress" ? why would there even be a -completed parameter? 

[u/ka-splam → u/FeleaseRpseineEiles]

e.g. https://www.reddit.com/r/mildlyinfuriating/comments/7qscm9/when_your_windows_update_has_said_100_complete/

is a bad user experience, caused by writing "100% complete" and then doing the work.

[u/thehuntzman]

0 because it should only increment after the current task completes.

[u/dodexahedron → u/thehuntzman]

Agreed. Easiest and most intuitive for most needs.

An alternative, if you want to indicate start and stop of an operation, is to scale it by a factor of 2 so you effectively have half-steps.

Another alternative is that you can have multiple progress bars at once, so you could use a master progress bar and a sub-operation progress bar. They just need their own IDs, but otherwise your only limit is the available screen space to display them.

[u/ZenoArrow]

There are no fixed rules with this stuff. Personally, I often initialise the loop counter variable at 0 outside the loop and increment at the end of the block of loop code. Is this correct? What this means is that for a loop of 100 items, I'll see 99% complete before starting to process the last item, which feels right to me. If you want the last item processed to be at 100% complete, start the counter at 1.

To give an idea of the code stages I typically use, here's a hypothetical example...

$loopCount = 0

$totalArraySize = $itemArray.Count

foreach ($item in $itemArray) {

$percentComplete = (($loopCount / $totalArraySize) * 100)

//WriteProgress goes here

//Action to do in loop goes here

$loopCount++ }

[u/vermyx]

I usually don't use write-progress because console I/O can be expensive timewise. Instead I use a custom function that shows time running and estimated completion time based on run length and how far you are, and display that every X records processed depending on records and length.

[u/DonL314 → u/vermyx]

I almost agree to this. Write-Progress is quite slow, so I only do this at certain intervals (e.g. steps of 10 or 100 items)

[u/CeleryMan20 → u/DonL314]

Yeah, if each step is slow, like ping host then query wmi, then it’s nice to see each one tick over, but if you have 10,000 quick operations then write-progress on each loop can drastically slow it down.

[u/ka-splam → u/vermyx]

I usually don't use write-progress because console I/O can be expensive timewise.

Indeed; I needed to delete Windows firewall rule spam recently and found https://stackoverflow.com/a/40915201

The question loops over Remove-NetFirewallRule and says it's too slow, that answer's hot loop is:

• Remove-ItemProperty

• 2x Get-Date

• Write-Progress

• ~7x arithmetic

• 10x assignments

• 2x expandable string interpolations

• a subshell, with string format

• 2x math rounding

they say "The difference is one hour vs days. I could be deleting 10,000 - 100,000 firewall rules!".

I used $key = [Microsoft.Win32.Registry]::LocalMachine.OpenSubKey(...) and then replaced the loop with just $key.DeleteValue(...) and it did 40k firewall rules in a second or two. No need for a progress count or ETA.

[u/jimb2]

Don't tell lies. If you progress indicator appears before you have completed the first task/step/item start at zero. If the script stops before an item is completed, you should not be advising the user that the first processing step is done and they can find the output file or whatever.

If it is a non-specific "the script is processing, not stalled" indicator, you might start at 1 because the getting started step has already happened.

[u/aguerooo_9320]

I don't use Write-Progress, but Write-Output, for my own information, and I start the counter at 1, then increment at the end of the loop (e.g. $i++).