TransactionFlowProperty.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ WCF / WCF / 3.5.30729.1 / untmp / Orcas / SP / ndp / cdf / src / WCF / ServiceModel / System / ServiceModel / Channels / TransactionFlowProperty.cs / 1 / TransactionFlowProperty.cs

                            //------------------------------------------------------------------------------ 
// Copyright (c) Microsoft Corporation.  All rights reserved.
//-----------------------------------------------------------------------------
namespace System.ServiceModel.Channels
{ 
    using System;
    using System.Collections.Generic; 
    using System.ServiceModel; 
    using System.ServiceModel.Security;
 
    using System.Transactions;
    using System.Runtime.Remoting.Messaging;
    using System.ServiceModel.Transactions;
    using System.ServiceModel.Diagnostics; 

    sealed public class TransactionMessageProperty 
    { 
        TransactionInfo flowedTransactionInfo;
        Transaction flowedTransaction; 
        const string PropertyName = "TransactionMessageProperty";

        private TransactionMessageProperty()
        { 
        }
 
        public Transaction Transaction 
        {
            get 
            {
                if(this.flowedTransaction == null && this.flowedTransactionInfo != null)
                {
                    try 
                    {
                        this.flowedTransaction = this.flowedTransactionInfo.UnmarshalTransaction(); 
                    } 
                    catch(TransactionException e)
                    { 
                        throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(e);
                    }
                }
                return this.flowedTransaction; 
            }
        } 
 
        static internal TransactionMessageProperty TryGet(Message message)
        { 
            if (message.Properties.ContainsKey(PropertyName))
                return message.Properties[PropertyName] as TransactionMessageProperty;
            else
                return null; 
        }
 
        static internal Transaction TryGetTransaction(Message message) 
        {
            if (!message.Properties.ContainsKey(PropertyName)) 
                return null;

            return ((TransactionMessageProperty)message.Properties[PropertyName]).Transaction;
 
        }
 
        static TransactionMessageProperty GetPropertyAndThrowIfAlreadySet(Message message) 
        {
            if (message.Properties.ContainsKey(PropertyName)) 
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
                    new FaultException(SR.GetString(SR.SFxTryAddMultipleTransactionsOnMessage)));
            } 

            return new TransactionMessageProperty(); 
        } 

        static public void Set(Transaction transaction, Message message) 
        {
            TransactionMessageProperty property = GetPropertyAndThrowIfAlreadySet(message);
            property.flowedTransaction = transaction;
            message.Properties.Add(PropertyName, property); 
        }
 
        static internal void Set(TransactionInfo transactionInfo, Message message) 
        {
            TransactionMessageProperty property = GetPropertyAndThrowIfAlreadySet(message); 
            property.flowedTransactionInfo = transactionInfo;
            message.Properties.Add(PropertyName, property);
        }
    } 

 
 
    class TransactionFlowProperty
    { 
        Transaction flowedTransaction;
        List issuedTokens;
        const string PropertyName = "TransactionFlowProperty";
 
        private TransactionFlowProperty()
        { 
        } 

        internal ICollection IssuedTokens 
        {
            get
            {
                if (this.issuedTokens == null) 
                {
                    this.issuedTokens = new List(); 
                } 

                return this.issuedTokens; 
            }
        }

        internal Transaction Transaction 
        {
            get {return this.flowedTransaction;} 
        } 

        static internal TransactionFlowProperty Ensure(Message message) 
        {
            if (message.Properties.ContainsKey(PropertyName))
                return (TransactionFlowProperty)message.Properties[PropertyName];
 
            TransactionFlowProperty property = new TransactionFlowProperty();
            message.Properties.Add(PropertyName, property); 
            return property; 
        }
 
        static internal TransactionFlowProperty TryGet(Message message)
        {
            if (message.Properties.ContainsKey(PropertyName))
                return message.Properties[PropertyName] as TransactionFlowProperty; 
            else
                return null; 
        } 

        static internal ICollection TryGetIssuedTokens(Message message) 
        {
            TransactionFlowProperty property = TransactionFlowProperty.TryGet(message);
            if (property == null)
                return null; 

            // use this when reading only, consistently return null if no tokens. 
            if (property.issuedTokens == null || property.issuedTokens.Count == 0) 
                return null;
 
            return property.issuedTokens;
        }

        static internal Transaction TryGetTransaction(Message message) 
        {
            if (!message.Properties.ContainsKey(PropertyName)) 
                return null; 

            return ((TransactionFlowProperty)message.Properties[PropertyName]).Transaction; 

        }

        static TransactionFlowProperty GetPropertyAndThrowIfAlreadySet(Message message) 
        {
            TransactionFlowProperty property = TryGet(message); 
 
            if (property != null)
            { 
                if(property.flowedTransaction != null)
                {
                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new FaultException(SR.GetString(SR.SFxTryAddMultipleTransactionsOnMessage)));
                } 
            }
            else 
            { 
                property = new TransactionFlowProperty();
            } 

            return property;
        }
 
        static internal void Set(Transaction transaction, Message message)
        { 
            TransactionFlowProperty property = GetPropertyAndThrowIfAlreadySet(message); 
            property.flowedTransaction = transaction;
            message.Properties.Add(PropertyName, property); 
        }
    }
}

// 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