Transactions.cs source code in C# .NET

Source code for the .NET framework in C#

                        
Code:

                         / FXUpdate3074 / FXUpdate3074 / 1.1 / untmp / whidbey / QFE / ndp / fx / src / xsp / System / Web / Util / Transactions.cs / 1 / Transactions.cs
                        

                        
                            //------------------------------------------------------------------------------ 
// 
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// 
//----------------------------------------------------------------------------- 

/* 
 * Transactions support for ASP.NET pages 
 *
 * Copyright (c) 2000, Microsoft Corporation 
 */
namespace System.Web.Util {

using System.Collections; 
using System.EnterpriseServices;
using System.Security.Permissions; 
 
//
//  Delegate to the transacted managed code 
//


///  
///    [To be supplied.]
///  
public delegate void TransactedCallback(); 

// 
//  Delegate for the internal transacted execution
//

internal enum TransactedExecState { 
    CommitPending = 0,
    AbortPending = 1, 
    Error = 2 
}
 
internal delegate int TransactedExecCallback();  // return value 'int' for interop

//
//  Utility class with to be called to do transactions 
//
 
 
/// 
///    [To be supplied.] 
/// 
[AspNetHostingPermission(SecurityAction.LinkDemand, Level=AspNetHostingPermissionLevel.Minimal)]
[AspNetHostingPermission(SecurityAction.InheritanceDemand, Level=AspNetHostingPermissionLevel.Minimal)]
public class Transactions { 

    ///  
    ///    [To be supplied.] 
    /// 
    public static void InvokeTransacted(TransactedCallback callback, TransactionOption mode) { 
        bool aborted = false;
        InvokeTransacted(callback, mode, ref aborted);
    }
 

    ///  
    ///    [To be supplied.] 
    /// 
    public static void InvokeTransacted(TransactedCallback callback, TransactionOption mode, ref bool transactionAborted) { 
        //
        HttpRuntime.CheckAspNetHostingPermission(AspNetHostingPermissionLevel.Medium, SR.Transaction_not_supported_in_low_trust);

        bool executeWithoutTransaction = false; 

#if !FEATURE_PAL // FEATURE_PAL does not enable Transactions 
        if (Environment.OSVersion.Platform != PlatformID.Win32NT || Environment.OSVersion.Version.Major <= 4) 
            throw new PlatformNotSupportedException(SR.GetString(SR.RequiresNT));
#else // !FEATURE_PAL 
        throw new NotImplementedException("ROTORTODO");
#endif // !FEATURE_PAL

 
        if (mode == TransactionOption.Disabled)
            executeWithoutTransaction = true; 
 
        if (executeWithoutTransaction) {
            // bypass the transaction logic 
            callback();
            transactionAborted = false;
            return;
        } 

        TransactedInvocation call = new TransactedInvocation(callback); 
        TransactedExecCallback execCallback = new TransactedExecCallback(call.ExecuteTransactedCode); 

        PerfCounters.IncrementCounter(AppPerfCounter.TRANSACTIONS_PENDING); 

        int rc;
        try {
            rc = UnsafeNativeMethods.TransactManagedCallback(execCallback, (int)mode); 
        }
        finally { 
            PerfCounters.DecrementCounter(AppPerfCounter.TRANSACTIONS_PENDING); 
        }
 
        // rethrow the expection originally caught in managed code
        if (call.Error != null)
            throw new HttpException(null, call.Error);
 
        PerfCounters.IncrementCounter(AppPerfCounter.TRANSACTIONS_TOTAL);
 
        if (rc == 1) { 
            PerfCounters.IncrementCounter(AppPerfCounter.TRANSACTIONS_COMMITTED);
            transactionAborted = false; 
        }
        else if (rc == 0) {
            PerfCounters.IncrementCounter(AppPerfCounter.TRANSACTIONS_ABORTED);
            transactionAborted = true; 
        }
        else { 
            throw new HttpException(SR.GetString(SR.Cannot_execute_transacted_code)); 
        }
    } 

    // Class with wrappers to ContextUtil that don't throw

    internal class Utils { 
        private Utils() {
        } 
 
        /*
        internal static String TransactionId { 
            get {
                String id = null;

                try { 
                    id = ContextUtil.TransactionId.ToString();
                } 
                catch { 
                }
 
                return id;
            }
        }
        */ 

        internal static bool IsInTransaction { 
            get { 
                bool inTransaction = false;
 
                try {
                    inTransaction = ContextUtil.IsInTransaction;
                }
                catch { 
                }
 
                return inTransaction; 
            }
        } 

        internal static bool AbortPending {
            get {
                bool aborted = false; 

                try { 
                    if (ContextUtil.MyTransactionVote == TransactionVote.Abort) 
                        aborted = true;
                } 
                catch {
                }

                return aborted; 
            }
        } 
    } 

    // Managed class encapsulating the transacted call 

    internal class TransactedInvocation {
        private TransactedCallback _callback;
        private Exception _error; 

        internal TransactedInvocation(TransactedCallback callback) { 
            _callback = callback; 
        }
 
        internal int ExecuteTransactedCode() {
            TransactedExecState state = TransactedExecState.CommitPending;

            try { 
                _callback();
 
                if (Transactions.Utils.AbortPending) 
                    state = TransactedExecState.AbortPending;
            } 
            catch (Exception e) {
                _error = e;  // remember exception to be rethrown back in managed code
                state = TransactedExecState.Error;
            } 

            return (int)state; 
        } 

        internal Exception Error { 
            get { return _error; }
        }
    }
} 
}

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK