Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System/compmod/system/componentmodel/design/DesignerTransaction.cs

@@ -0,0 +1,140 @@
+//------------------------------------------------------------------------------
+// <copyright file="DesignerTransaction.cs" company="Microsoft">
+//     Copyright (c) Microsoft Corporation.  All rights reserved.
+// </copyright>                                                                
+//------------------------------------------------------------------------------
+
+/*
+ */
+namespace System.ComponentModel.Design {
+    using System;
+    using System.Security.Permissions;
+
+    /// <devdoc>
+    ///     Identifies a transaction within a designer.  Transactions are
+    ///     used to wrap serveral changes into one unit of work, which 
+    ///     helps performance.
+    /// </devdoc>
+    [HostProtection(SharedState = true)]
+    [System.Security.Permissions.PermissionSetAttribute(System.Security.Permissions.SecurityAction.InheritanceDemand, Name = "FullTrust")]
+    public abstract class DesignerTransaction : IDisposable {
+        private bool committed = false;
+        private bool canceled = false;
+        private bool suppressedFinalization = false;
+        private string desc;
+        
+        /// <devdoc>
+        ///    <para>[To be supplied.]</para>
+        /// </devdoc>
+        protected DesignerTransaction() : this("") {
+        }
+        
+        
+        /// <devdoc>
+        ///    <para>[To be supplied.]</para>
+        /// </devdoc>
+        protected DesignerTransaction(string description) {
+            this.desc = description;
+        }
+        
+        
+        /// <devdoc>
+        ///    <para>[To be supplied.]</para>
+        /// </devdoc>
+        public bool Canceled {
+            get {
+                return canceled;
+            }
+        }
+        
+        /// <devdoc>
+        ///    <para>[To be supplied.]</para>
+        /// </devdoc>
+        public bool Committed {
+            get {
+                return committed;
+            }
+        }
+        
+        /// <devdoc>
+        ///    <para>[To be supplied.]</para>
+        /// </devdoc>
+        public string Description {
+            get {
+                return desc;
+            }
+        }
+        
+        /// <devdoc>
+        ///    <para>[To be supplied.]</para>
+        /// </devdoc>
+        public void Cancel() {
+            if (!canceled && !committed) {
+                canceled = true;
+                GC.SuppressFinalize(this);
+                suppressedFinalization = true;
+                OnCancel();
+            }
+        }
+    
+        /// <devdoc>
+        ///     Commits this transaction.  Once a transaction has
+        ///     been committed, further calls to this method
+        ///     will do nothing.  You should always call this
+        ///     method after creating a transaction to ensure
+        ///     that the transaction is closed properly.
+        /// </devdoc>
+        public void Commit() {
+            if (!committed && !canceled) {
+                committed = true;
+                GC.SuppressFinalize(this);
+                suppressedFinalization = true;
+                OnCommit();
+            }
+        }
+        
+          /// <devdoc>
+        ///     User code should implement this method to perform
+        ///     the actual work of committing a transaction.
+        /// </devdoc>
+        protected abstract void OnCancel(); 
+        
+        /// <devdoc>
+        ///     User code should implement this method to perform
+        ///     the actual work of committing a transaction.
+        /// </devdoc>
+        protected abstract void OnCommit();
+        
+        /// <devdoc>
+        ///     Overrides Object to commit this transaction
+        ///     in case the user forgot.
+        /// </devdoc>
+        ~DesignerTransaction() {
+            Dispose(false);
+        }
+        
+        /// <internalonly/>
+        /// <devdoc>
+        /// Private implementation of IDisaposable.
+        /// When a transaction is disposed it is
+        /// committed.
+        /// </devdoc>
+        void IDisposable.Dispose() {
+            Dispose(true);
+
+            // note - Dispose calls Cancel which sets this bit, so
+            //        this should never be hit.
+            //
+            if (!suppressedFinalization) {
+                System.Diagnostics.Debug.Fail("Invalid state. Dispose(true) should have called cancel which does the SuppressFinalize");
+                GC.SuppressFinalize(this);
+            }
+        }
+        protected virtual void Dispose(bool disposing) {
+            System.Diagnostics.Debug.Assert(disposing, "Designer transaction garbage collected, unable to cancel, please Cancel, Close, or Dispose your transaction.");
+            System.Diagnostics.Debug.Assert(disposing || canceled || committed, "Disposing DesignerTransaction that has not been comitted or canceled; forcing Cancel" );
+            Cancel();
+        }
+    }
+}
+