System [00 00 00 00 00 00 00 00 04 00 00 00 00 00 00 00] 1.0.3300.0 1.0.5000.0 2.0.0.0 4.0.0.0 Gtk# is thread aware, but not thread safe; See the <link location="node:gtk-sharp/programming/threads">Gtk# Thread Programming</link> for details. System.Object System.IDisposable

Transactions can track actions that can be undone later. Changes made during a transaction can be reversed by canceling a transaction, which automatically attempts to reverse each change by setting each changed property to its pre-change value. Transactions can also improve performance during a series of operations by deferring updates to the display until the completion of the transaction.

When a transaction is in progress, some components defer their processing until the transaction has completed by listening to the and events. The Properties window, for example, does not update its display after a transaction has opened until the transaction has closed.

To use transactions for reversible or multiple operations, have your designer create a for each operation or series of operations which should be reversible. Be careful not to perform actions outside the transactions that might prevent a sequence of undo events from completing successfully.

You can obtain a new by calling the method of an . Be sure to obtain each from the active in order to correctly integrate with the designer transaction processing mechanism, rather than creating a new directly.

To perform an action within a transaction, you must first create a transaction. Then you must call the method before each change or set of changes occurs, and the method after each change or set of changes occur. Finally, complete and close the transaction by calling the method.

When making changes to property values, use the method of a , which calls the component change methods of the and creates a representing the change automatically.

To perform a transaction, complete the following steps:

Call to obtain a that can be used to control the transaction.

Within a try block, for each action that you want to track with a , call the method, make the change or changes, then call the method to signal that the change or changes have been made.

To complete the transaction, call from within a finally block.

In C#, you can use the using statement rather than a try/finally block, such as in the following example.

`using (host.CreateTransaction() { // Insert your code here. }`

To cancel and attempt to roll back a transaction before it has been committed, call the method. When the method is invoked, the actions tracked by the are reversed to attempt to roll back the changes. To undo actions that occurred as part of earlier transactions, you must use the undo command provided by the development environment.

Provides a way to group a series of design-time actions to improve performance and enable most types of changes to be undone.

- Constructor
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  To be added

  Initializes a new instance of the class with no description.

- Constructor
  1.0.5000.0
  2.0.0.0
  4.0.0.0

  This constructor initializes the transaction with the specified description.

  Initializes a new instance of the class using the specified transaction description.

  A description for this transaction.
- Method
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Void To be added

  Cancels the transaction and attempts to roll back the changes made by the events of the transaction.

- Property
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Boolean To be added: an object of type 'bool'

  When a designer transaction is canceled, the transaction processing mechanism attempts to roll back the changes that have been made so far in the transaction. Whether this succeeds is dependent upon such factors as the type of each operation, whether other operations interfered with any of the involved code's state, and whether a sequence of expected operations failed to complete.

  Gets a value indicating whether the transaction was canceled.

- Method
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Void

  When a designer transaction is committed, the transaction is considered complete and does not track further changes.

  Once a transaction has been committed, further calls to this method do nothing. Always call this method after creating a transaction to ensure that the transaction closes properly.

  Commits this transaction.

- Property
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Boolean To be added: an object of type 'bool'

  When a designer transaction is committed, the transaction is considered complete and does not track further changes.

  Gets a value indicating whether the transaction was committed.

- Property
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.String To be added: an object of type 'string'

  A transaction can have a description that is useful in identifying the nature of the operation or operations.

  Gets a description for the transaction.

- Method
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Void ``

  This method is called by the public Dispose() method and the method. Dispose() invokes the protected Dispose(Boolean) method with the parameter set to true. invokes Dispose with set to false.

  When the parameter is true, this method releases all resources held by any managed objects that this references. This method invokes the Dispose() method of each referenced object.

  Releases the unmanaged resources used by the and optionally releases the managed resources.

  true to release both managed and unmanaged resources; false to release only unmanaged resources.
- Method
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Void

  This method overrides and cleans up resources by calling Dispose(false). Override Dispose(Boolean) to customize the cleanup.

  Application code should not call this method; an object's Finalize method is automatically invoked during garbage collection, unless finalization by the garbage collector has been disabled by a call to the method.

  For more information, see Finalize Methods and Destructors, Cleaning Up Unmanaged Resources, and Overriding the Finalize Method.

  Releases the resources associated with this object. This override commits this transaction if it was not already committed.

- Method
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Void

  When a designer transaction is canceled, the transaction processing mechanism attempts to roll back the changes that have been made so far in the transaction. Whether this succeeds is dependent upon such factors as the type of each operation, whether other operations interfered with any of the involved code's state, and whether a sequence of expected operations failed to complete.

  Raises the Cancel event.

- Method
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Void

  When a designer transaction is committed, the transaction is considered complete and does not track further changes.

  Performs the actual work of committing a transaction.

- Method
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Void

  When a transaction is disposed, it is committed.

  Releases all resources used by the .