You want to experiment with PowerShell's transactions support, but don't want to use the Registry Provider as your playground.

Use PowerShell's System.Management.Automation.TransactedString object along with the Use-Transaction cmdlet to experiment with a string, rather than registry keys:

PS > Start-Transaction

Suggestion [1,Transactions]: Once a transaction is started, only commands that
 get called with the -UseTransaction flag become part of that transaction.
PS > 
PS > $transactedString = New-Object Microsoft.PowerShell.Commands.Management.Tra
nsactedString
PS > $transactedString.Append("Hello ")
PS > 
PS > Use-Transaction -UseTransaction { $transactedString.Append("World") }

Suggestion [2,Transactions]: The Use-Transaction cmdlet is intended for script
ing of transaction-enabled .NET objects. Its ScriptBlock should contain nothin
g else.
PS > 
PS > $transactedString.ToString()
Hello
PS > 
PS > Complete-Transaction
PS > 
PS > $transactedString.ToString()
Hello World
PS > 

PowerShell's transaction support builds on four core cmdlets: Start-Transaction, Use-Transaction, Complete-Transaction, and Undo-Transaction.

The Start-Transaction begins a transaction, creating a context where changes are visible to commands within the transaction, but not outside of it. For the most part, after starting a transaction, you'll apply commands to that transaction by adding the -UseTransaction to a cmdlet that supports it. For example, when a PowerShell provider supports transactions, all of PowerShell's core cmdlets (Get-ChildItem, Remove-Item, etc), let you specify the -UseTransaction parameter for actions against that provider.

The Use-Transaction cmdlet is slightly different. While it still requires the -UseTransaction parameter to apply its script block to the current transaction, its sole purpose is to let you script against .NET objects that support transactions themselves. Since they have no way to supply a -UseTransaction parameter, PowerShell offers this generic cmdlet for any type of transactional .NET scripting.

To give users an opportunity to play with something a little less risky than the Windows Registry, PowerShell includes the Microsoft.PowerShell.Commands.Management.TransactedString class. This class acts like you'd expect any transacted command to act, and lets you become familiar with how the rest of PowerShell's transaction cmdlets work together. Since this is a .NET object, it must be called from within the script block of the Use-Transaction cmdlet.

Finally, when you are finished performing tasks for the current transaction, call either the Complete-Transaction or Undo-Transaction cmdlets. As compared to the solution, here's an example session where the Undo-Transaction cmdlet lets you discard changes made during the transaction:

PS > Start-Transaction

Suggestion [1,Transactions]: Once a transaction is started, only commands that
 get called with the -UseTransaction flag become part of that transaction.
PS > 
PS > $transactedString = New-Object Microsoft.PowerShell.Commands.Management.Tra
nsactedString
PS > $transactedString.Append("Hello ")
PS > 
PS > Use-Transaction -UseTransaction { $transactedString.Append("World") }

Suggestion [2,Transactions]: The Use-Transaction cmdlet is intended for script
ing of transaction-enabled .NET objects. Its ScriptBlock should contain nothin
g else.
PS > 
PS > $transactedString.ToString()
Hello
PS > 
PS > Undo-Transaction
PS > 
PS > $transactedString.ToString()
Hello

For more information about transactions in the Windows Registry, see the section called “Safely Combine Related Registry Modifications”.

You want to change how PowerShell responds to errors during the execution of a transacted cmdlet.

Use the -RollbackPreference parameter of the Start-Transaction cmdlet to control what type of error will cause PowerShell to automatically undo your transaction:

HKCU:\ >Start-Transaction
HKCU:\ >New-Item Foo -UseTransaction

    Hive: HKEY_CURRENT_USER

SKC  VC Name                           Property
---  -- ----                           --------
  0   0 Foo                            {}

HKCU:\ >Copy IDoNotExist Foo -UseTransaction
Copy-Item : Cannot find path 'HKCU:\IDoNotExist' because it does not exist.

HKCU:\ >Complete-Transaction
Complete-Transaction : Cannot commit transaction. The transaction has been ro
lled back or has timed out.

HKCU:\ >Start-Transaction -RollbackPreference TerminatingError

    Hive: HKEY_CURRENT_USER

SKC  VC Name                           Property
---  -- ----                           --------
  0   0 Foo                            {}

HKCU:\ >Copy IDoNotExist Foo -UseTransaction
Copy-Item : Cannot find path 'HKCU:\IDoNotExist' because it does not exist.

HKCU:\ >Complete-Transaction
HKCU:\ >Get-Item Foo

    Hive: HKEY_CURRENT_USER

SKC  VC Name                           Property
---  -- ----                           --------
  0   0 Foo                            {}

Errors in scripts are an extremely frequent cause of system inconsistency. If a script incorrectly assumes the existence of a registry key or other system state, this type of error tends to waterfall through the entire script. As the script continues, some of the operations succeed, while others fail. When the script completes, you're in a difficult situation in not knowing exactly what portions of the script worked correctly.

Sometimes, running the script again will magically make the problems go away. Unfortunately, it's just as common to have a painstaking manual cleanup effort facing you.

Addressing these consistency issues is one of the primary goals of system transactions.

When PowerShell creates a new transaction, it undoes (rolls back) your transaction for any error it encounters that is operating in the context of that transaction. When PowerShell rolls back your transaction, the system impact is clear: no part of your transaction was made permanent, so your system is still entirely consistent.

Some situations are simply too volatile to be able to depend on this rigid interpretation of consistency, though, so PowerShell offers the -RollbackPreference parameter on the Start-Transaction to let you configure how it should respond to errors:

For more information about PowerShell's error handling and error levels, see Chapter 15, Tracing and Error Management.