WsatStrings.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 / TransactionBridge / Microsoft / Transactions / Wsat / Messaging / WsatStrings.cs / 1 / WsatStrings.cs

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

using System.ServiceModel; 
using System.Xml;
using Microsoft.Transactions.Wsat.Protocol; 
 
namespace Microsoft.Transactions.Wsat.Messaging
{ 
//=====================================================================================
//                       Coordination strings
//=====================================================================================
 
    abstract class CoordinationStrings
    { 
        //---------------------------------------------------------------- 
        //                       Strings helper
        //--------------------------------------------------------------- 
        public static CoordinationStrings Version(ProtocolVersion protocolVersion)
        {
            ProtocolVersionHelper.AssertProtocolVersion(protocolVersion, typeof(CoordinationStrings), "V"); //assert valid protocol version
 
            switch (protocolVersion)
            { 
                case ProtocolVersion.Version10: 
                    return CoordinationStrings10.Instance;
 
                case ProtocolVersion.Version11:
                    return CoordinationStrings11.Instance;

                default: 
                    return null; // inaccessible path because we have asserted the protocol version
            } 
        } 

        //---------------------------------------------------------------- 
        //                      version dependent strings
        //----------------------------------------------------------------
        public abstract string Namespace { get; }
        public abstract string CreateCoordinationContextAction { get; } 
        public abstract string CreateCoordinationContextResponseAction { get; }
        public abstract string RegisterAction { get; } 
        public abstract string RegisterResponseAction { get; } 
        public abstract string FaultAction { get; }
 
        //---------------------------------------------------------------
        //                      version independent strings
        //----------------------------------------------------------------
        public string Prefix 
        {
            get { return CoordinationExternalStrings.Prefix; } 
        } 

        public string CreateCoordinationContext 
        {
            get { return CoordinationExternalStrings.CreateCoordinationContext; }
        }
 
        public string CreateCoordinationContextResponse
        { 
            get { return CoordinationExternalStrings.CreateCoordinationContextResponse; } 
        }
 
        public string CoordinationContext
        {
            get { return CoordinationExternalStrings.CoordinationContext; }
        } 

        public string CurrentContext 
        { 
            get { return CoordinationExternalStrings.CurrentContext; }
        } 

        public string CoordinationType
        {
            get { return CoordinationExternalStrings.CoordinationType; } 
        }
 
        public string RegistrationService 
        {
            get { return CoordinationExternalStrings.RegistrationService; } 
        }

        public string Register
        { 
            get { return CoordinationExternalStrings.Register; }
        } 
 
        public string RegisterResponse
        { 
            get { return CoordinationExternalStrings.RegisterResponse; }
        }

        public string Protocol 
        {
            get { return CoordinationExternalStrings.Protocol; } 
        } 

        public string CoordinatorProtocolService 
        {
            get { return CoordinationExternalStrings.CoordinatorProtocolService; }
        }
 
        public string ParticipantProtocolService
        { 
            get { return CoordinationExternalStrings.ParticipantProtocolService; } 
        }
 
        public string Expires
        {
            get { return CoordinationExternalStrings.Expires; }
        } 

        public string Identifier 
        { 
            get { return CoordinationExternalStrings.Identifier; }
        } 

        public string ActivationCoordinatorPortType
        {
            get { return CoordinationExternalStrings.ActivationCoordinatorPortType; } 
        }
 
        public string RegistrationCoordinatorPortType 
        {
            get { return CoordinationExternalStrings.RegistrationCoordinatorPortType; } 
        }

        public string InvalidState
        { 
            get { return CoordinationExternalStrings.InvalidState; }
        } 
 
        public string InvalidProtocol
        { 
            get { return CoordinationExternalStrings.InvalidProtocol; }
        }

        public string InvalidParameters 
        {
            get { return CoordinationExternalStrings.InvalidParameters; } 
        } 

        public string NoActivity 
        {
            get { return CoordinationExternalStrings.NoActivity; }
        }
 
        public string ContextRefused
        { 
            get { return CoordinationExternalStrings.ContextRefused; } 
        }
 
        public string AlreadyRegistered
        {
            get { return CoordinationExternalStrings.AlreadyRegistered; }
        } 

        public string CannotCreateContext 
        { 
            get { return CoordinationExternal11Strings.CannotCreateContext; }
        } 

        public string CannotRegisterParticipant
        {
            get { return CoordinationExternal11Strings.CannotRegisterParticipant; } 
        }
    } 
 
//=========================================================================
//                              implementations 
//=========================================================================

    class CoordinationStrings10 : CoordinationStrings
    { 

        static CoordinationStrings instance = new CoordinationStrings10(); 
        public static CoordinationStrings Instance 
        {
            get { return instance; } 
        }

        //version dependent strings
        public override string Namespace 
        {
            get { return CoordinationExternal10Strings.Namespace; } 
        } 

        public override string CreateCoordinationContextAction 
        {
            get { return CoordinationExternal10Strings.CreateCoordinationContextAction; }
        }
 
        public override string CreateCoordinationContextResponseAction
        { 
            get { return CoordinationExternal10Strings.CreateCoordinationContextResponseAction; } 
        }
 
        public override string RegisterAction
        {
            get { return CoordinationExternal10Strings.RegisterAction; }
        } 

        public override string RegisterResponseAction 
        { 
            get { return CoordinationExternal10Strings.RegisterResponseAction; }
        } 

        public override string FaultAction
        {
            get { return CoordinationExternal10Strings.FaultAction; } 
        }
    } 
 
    class CoordinationStrings11 : CoordinationStrings
    { 
        static CoordinationStrings instance = new CoordinationStrings11();
        public static CoordinationStrings Instance
        {
            get { return instance; } 
        }
 
        //version independent strings 
        public override string Namespace
        { 
            get { return CoordinationExternal11Strings.Namespace; }
        }

        public override string CreateCoordinationContextAction 
        {
            get { return CoordinationExternal11Strings.CreateCoordinationContextAction; } 
        } 

        public override string CreateCoordinationContextResponseAction 
        {
            get { return CoordinationExternal11Strings.CreateCoordinationContextResponseAction; }
        }
 
        public override string RegisterAction
        { 
            get { return CoordinationExternal11Strings.RegisterAction; } 
        }
 
        public override string RegisterResponseAction
        {
            get { return CoordinationExternal11Strings.RegisterResponseAction; }
        } 

        public override string FaultAction 
        { 
            get { return CoordinationExternal11Strings.FaultAction; }
        } 
    }


//===================================================================================== 
//                       Coordination XmlDictionaryStrings
//====================================================================================== 
 
    abstract class CoordinationXmlDictionaryStrings
    { 
        //-------------------------------------------------------------------
        //                       Strings helper
        //--------------------------------------------------------------------
        public static CoordinationXmlDictionaryStrings Version(ProtocolVersion protocolVersion) 
        {
            ProtocolVersionHelper.AssertProtocolVersion(protocolVersion, typeof(CoordinationXmlDictionaryStrings), "V"); //assert valid protocol version 
 
            switch (protocolVersion)
            { 
                case ProtocolVersion.Version10:
                    return CoordinationXmlDictionaryStrings10.Instance;

                case ProtocolVersion.Version11: 
                    return CoordinationXmlDictionaryStrings11.Instance;
 
                default: 
                    return null; // inaccessible path because we have asserted the protocol version
            } 
        }

        //--------------------------------------------------------------------
        //                     version dependent strings 
        //-------------------------------------------------------------------
        public abstract XmlDictionaryString Namespace { get; } 
        public abstract XmlDictionaryString CreateCoordinationContextAction { get; } 
        public abstract XmlDictionaryString CreateCoordinationContextResponseAction { get; }
        public abstract XmlDictionaryString RegisterAction { get; } 
        public abstract XmlDictionaryString RegisterResponseAction { get; }
        public abstract XmlDictionaryString FaultAction { get; }

        //-------------------------------------------------------------------- 
        //                     version independent strings
        //------------------------------------------------------------------- 
        public XmlDictionaryString Prefix 
        {
            get { return XD.CoordinationExternalDictionary.Prefix; } 
        }

        public XmlDictionaryString CreateCoordinationContext
        { 
            get { return XD.CoordinationExternalDictionary.CreateCoordinationContext; }
        } 
 
        public XmlDictionaryString CreateCoordinationContextResponse
        { 
            get { return XD.CoordinationExternalDictionary.CreateCoordinationContextResponse; }
        }

        public XmlDictionaryString CoordinationContext 
        {
            get { return XD.CoordinationExternalDictionary.CoordinationContext; } 
        } 

        public XmlDictionaryString CurrentContext 
        {
            get { return XD.CoordinationExternalDictionary.CurrentContext; }
        }
 
        public XmlDictionaryString CoordinationType
        { 
            get { return XD.CoordinationExternalDictionary.CoordinationType; } 
        }
 
        public XmlDictionaryString RegistrationService
        {
            get { return XD.CoordinationExternalDictionary.RegistrationService; }
        } 

        public XmlDictionaryString Register 
        { 
            get { return XD.CoordinationExternalDictionary.Register; }
        } 

        public XmlDictionaryString RegisterResponse
        {
            get { return XD.CoordinationExternalDictionary.RegisterResponse; } 
        }
 
        public XmlDictionaryString Protocol 
        {
            get { return XD.CoordinationExternalDictionary.Protocol; } 
        }

        public XmlDictionaryString CoordinatorProtocolService
        { 
            get { return XD.CoordinationExternalDictionary.CoordinatorProtocolService; }
        } 
 
        public XmlDictionaryString ParticipantProtocolService
        { 
            get { return XD.CoordinationExternalDictionary.ParticipantProtocolService; }
        }

        public XmlDictionaryString Expires 
        {
            get { return XD.CoordinationExternalDictionary.Expires; } 
        } 

        public XmlDictionaryString Identifier 
        {
            get { return XD.CoordinationExternalDictionary.Identifier; }
        }
 
        public XmlDictionaryString ActivationCoordinatorPortType
        { 
            get { return XD.CoordinationExternalDictionary.ActivationCoordinatorPortType; } 
        }
 
        public XmlDictionaryString RegistrationCoordinatorPortType
        {
            get { return XD.CoordinationExternalDictionary.RegistrationCoordinatorPortType; }
        } 

        public XmlDictionaryString InvalidState 
        { 
            get { return XD.CoordinationExternalDictionary.InvalidState; }
        } 

        public XmlDictionaryString InvalidProtocol
        {
            get { return XD.CoordinationExternalDictionary.InvalidProtocol; } 
        }
 
        public XmlDictionaryString InvalidParameters 
        {
            get { return XD.CoordinationExternalDictionary.InvalidParameters; } 
        }

        public XmlDictionaryString NoActivity
        { 
            get { return XD.CoordinationExternalDictionary.NoActivity; }
        } 
 
        public XmlDictionaryString ContextRefused
        { 
            get { return XD.CoordinationExternalDictionary.ContextRefused; }
        }

        public XmlDictionaryString AlreadyRegistered 
        {
            get { return XD.CoordinationExternalDictionary.AlreadyRegistered; } 
        } 

        public XmlDictionaryString CannotCreateContext 
        {
            get { return DXD.CoordinationExternal11Dictionary.CannotCreateContext; }
        }
 
        public XmlDictionaryString CannotRegisterParticipant
        { 
            get { return DXD.CoordinationExternal11Dictionary.CannotRegisterParticipant; } 
        }
    } 

//=========================================================================
//                              implementations
//========================================================================= 
    class CoordinationXmlDictionaryStrings10 : CoordinationXmlDictionaryStrings
    { 
        static CoordinationXmlDictionaryStrings instance = new CoordinationXmlDictionaryStrings10(); 
        public static CoordinationXmlDictionaryStrings Instance
        { 
            get { return instance; }
        }

        public override XmlDictionaryString Namespace 
        {
            get { return XD.CoordinationExternal10Dictionary.Namespace; } 
        } 

        public override XmlDictionaryString CreateCoordinationContextAction 
        {
            get { return XD.CoordinationExternal10Dictionary.CreateCoordinationContextAction; }
        }
 
        public override XmlDictionaryString CreateCoordinationContextResponseAction
        { 
            get { return XD.CoordinationExternal10Dictionary.CreateCoordinationContextResponseAction; } 
        }
 
        public override XmlDictionaryString RegisterAction
        {
            get { return XD.CoordinationExternal10Dictionary.RegisterAction; }
        } 

        public override XmlDictionaryString RegisterResponseAction 
        { 
            get { return XD.CoordinationExternal10Dictionary.RegisterResponseAction; }
        } 

        public override XmlDictionaryString FaultAction
        {
            get { return XD.CoordinationExternal10Dictionary.FaultAction; } 
        }
    } 
 
    class CoordinationXmlDictionaryStrings11 : CoordinationXmlDictionaryStrings
    { 
        static CoordinationXmlDictionaryStrings instance = new CoordinationXmlDictionaryStrings11();
        public static CoordinationXmlDictionaryStrings Instance
        {
            get { return instance; } 
        }
 
        public override XmlDictionaryString Namespace 
        {
            get { return DXD.CoordinationExternal11Dictionary.Namespace; } 
        }

        public override XmlDictionaryString CreateCoordinationContextAction
        { 
            get { return DXD.CoordinationExternal11Dictionary.CreateCoordinationContextAction; }
        } 
 
        public override XmlDictionaryString CreateCoordinationContextResponseAction
        { 
            get { return DXD.CoordinationExternal11Dictionary.CreateCoordinationContextResponseAction; }
        }

        public override XmlDictionaryString RegisterAction 
        {
            get { return DXD.CoordinationExternal11Dictionary.RegisterAction; } 
        } 

        public override XmlDictionaryString RegisterResponseAction 
        {
            get { return DXD.CoordinationExternal11Dictionary.RegisterResponseAction; }
        }
 
        public override XmlDictionaryString FaultAction
        { 
            get { return DXD.CoordinationExternal11Dictionary.FaultAction; } 
        }
    } 

//======================================================================================
//                       AtomicTransaction strings
//===================================================================================== 

    abstract class AtomicTransactionStrings 
    { 
        //--------------------------------------------------------------------
        //                       Strings helper 
        //--------------------------------------------------------------------
        public static AtomicTransactionStrings Version(ProtocolVersion protocolVersion)
        {
            ProtocolVersionHelper.AssertProtocolVersion(protocolVersion, typeof(AtomicTransactionStrings), "V"); //assert valid protocol version 

            switch (protocolVersion) 
            { 
                case ProtocolVersion.Version10:
                    return AtomicTransactionStrings10.Instance; 

                case ProtocolVersion.Version11:
                    return AtomicTransactionStrings11.Instance;
 
                default:
                    return null; // inaccessible path because we have asserted the protocol version 
            } 
        }
 
        //-------------------------------------------------------------------
        //                     version dependent strings
        //--------------------------------------------------------------------
        public abstract string Namespace { get; } 
        public abstract string CompletionUri { get; }
        public abstract string Durable2PCUri { get; } 
        public abstract string Volatile2PCUri { get; } 
        public abstract string CommitAction { get; }
        public abstract string RollbackAction { get; } 
        public abstract string CommittedAction { get; }
        public abstract string AbortedAction { get; }
        public abstract string PrepareAction { get; }
        public abstract string PreparedAction { get; } 
        public abstract string ReadOnlyAction { get; }
        public abstract string ReplayAction { get; } 
        public abstract string FaultAction { get; } 

        //------------------------------------------------------------------- 
        //                     version independent strings
        //-------------------------------------------------------------------
        public string Prefix
        { 
            get { return AtomicTransactionExternalStrings.Prefix; }
        } 
 
        public string Prepare
        { 
            get { return AtomicTransactionExternalStrings.Prepare; }
        }

        public string Prepared 
        {
            get { return AtomicTransactionExternalStrings.Prepared; } 
        } 

        public string ReadOnly 
        {
            get { return AtomicTransactionExternalStrings.ReadOnly; }
        }
 
        public string Commit
        { 
            get { return AtomicTransactionExternalStrings.Commit; } 
        }
 
        public string Rollback
        {
            get { return AtomicTransactionExternalStrings.Rollback; }
        } 

        public string Committed 
        { 
            get { return AtomicTransactionExternalStrings.Committed; }
        } 

        public string Aborted
        {
            get { return AtomicTransactionExternalStrings.Aborted; } 
        }
 
        public string Replay 
        {
            get { return AtomicTransactionExternalStrings.Replay; } 
        }

        public string CompletionCoordinatorPortType
        { 
            get { return AtomicTransactionExternalStrings.CompletionCoordinatorPortType; }
        } 
 
        public string CompletionParticipantPortType
        { 
            get { return AtomicTransactionExternalStrings.CompletionParticipantPortType; }
        }

        public string CoordinatorPortType 
        {
            get { return AtomicTransactionExternalStrings.CoordinatorPortType; } 
        } 

        public string ParticipantPortType 
        {
            get { return AtomicTransactionExternalStrings.ParticipantPortType; }
        }
 
        public string InconsistentInternalState
        { 
            get { return AtomicTransactionExternalStrings.InconsistentInternalState; } 
        }
 
        public string UnknownTransaction
        {
            get { return AtomicTransactionExternal11Strings.UnknownTransaction; }
        } 
    }
 
 
//=========================================================================
//                              implementations 
//==========================================================================

    class AtomicTransactionStrings10 : AtomicTransactionStrings
    { 
        static AtomicTransactionStrings instance = new AtomicTransactionStrings10();
        public static AtomicTransactionStrings Instance 
        { 
            get { return instance; }
        } 

        public override string Namespace
        {
            get { return AtomicTransactionExternal10Strings.Namespace; } 
        }
 
        public override string CompletionUri 
        {
            get { return AtomicTransactionExternal10Strings.CompletionUri; } 
        }

        public override string Durable2PCUri
        { 
            get { return AtomicTransactionExternal10Strings.Durable2PCUri; }
        } 
 
        public override string Volatile2PCUri
        { 
            get { return AtomicTransactionExternal10Strings.Volatile2PCUri; }
        }

        public override string CommitAction 
        {
            get { return AtomicTransactionExternal10Strings.CommitAction; } 
        } 

        public override string RollbackAction 
        {
            get { return AtomicTransactionExternal10Strings.RollbackAction; }
        }
 
        public override string CommittedAction
        { 
            get { return AtomicTransactionExternal10Strings.CommittedAction; } 
        }
 
        public override string AbortedAction
        {
            get { return AtomicTransactionExternal10Strings.AbortedAction; }
        } 

        public override string PrepareAction 
        { 
            get { return AtomicTransactionExternal10Strings.PrepareAction; }
        } 

        public override string PreparedAction
        {
            get { return AtomicTransactionExternal10Strings.PreparedAction; } 
        }
 
        public override string ReadOnlyAction 
        {
            get { return AtomicTransactionExternal10Strings.ReadOnlyAction; } 
        }

        public override string ReplayAction
        { 
            get { return AtomicTransactionExternal10Strings.ReplayAction; }
        } 
 
        public override string FaultAction
        { 
            get { return AtomicTransactionExternal10Strings.FaultAction; }
        }
    }
 
    class AtomicTransactionStrings11 : AtomicTransactionStrings
    { 
        static AtomicTransactionStrings instance = new AtomicTransactionStrings11(); 
        public static AtomicTransactionStrings Instance
        { 
            get { return instance; }
        }

        public override string Namespace 
        {
            get { return AtomicTransactionExternal11Strings.Namespace; } 
        } 

        public override string CompletionUri 
        {
            get { return AtomicTransactionExternal11Strings.CompletionUri; }
        }
 
        public override string Durable2PCUri
        { 
            get { return AtomicTransactionExternal11Strings.Durable2PCUri; } 
        }
 
        public override string Volatile2PCUri
        {
            get { return AtomicTransactionExternal11Strings.Volatile2PCUri; }
        } 

        public override string CommitAction 
        { 
            get { return AtomicTransactionExternal11Strings.CommitAction; }
        } 

        public override string RollbackAction
        {
            get { return AtomicTransactionExternal11Strings.RollbackAction; } 
        }
 
        public override string CommittedAction 
        {
            get { return AtomicTransactionExternal11Strings.CommittedAction; } 
        }

        public override string AbortedAction
        { 
            get { return AtomicTransactionExternal11Strings.AbortedAction; }
        } 
 
        public override string PrepareAction
        { 
            get { return AtomicTransactionExternal11Strings.PrepareAction; }
        }

        public override string PreparedAction 
        {
            get { return AtomicTransactionExternal11Strings.PreparedAction; } 
        } 

        public override string ReadOnlyAction 
        {
            get { return AtomicTransactionExternal11Strings.ReadOnlyAction; }
        }
 
        public override string ReplayAction
        { 
            get { return AtomicTransactionExternal11Strings.ReplayAction; } 
        }
 
        public override string FaultAction
        {
            get { return AtomicTransactionExternal11Strings.FaultAction; }
        } 
    }
 
//===================================================================================== 
//                       AtomicTransaction XmlDictionaryStrings
//====================================================================================== 

    abstract class AtomicTransactionXmlDictionaryStrings
    {
        //-------------------------------------------------------------------- 
        //                       Strings helper
        //------------------------------------------------------------------- 
        public static AtomicTransactionXmlDictionaryStrings Version(ProtocolVersion protocolVersion) 
        {
            ProtocolVersionHelper.AssertProtocolVersion(protocolVersion, typeof(AtomicTransactionXmlDictionaryStrings), "V"); //assert valid protocol version 

            switch (protocolVersion)
            {
                case ProtocolVersion.Version10: 
                    return AtomicTransactionXmlDictionaryStrings10.Instance;
 
                case ProtocolVersion.Version11: 
                    return AtomicTransactionXmlDictionaryStrings11.Instance;
 
                default:
                    return null; // inaccessible path because we have asserted the protocol version
            }
        } 

        //---------------------------------------------------------------- 
        //                      version dependent strings 
        //---------------------------------------------------------------
        public abstract XmlDictionaryString Namespace { get; } 
        public abstract XmlDictionaryString CompletionUri { get; }
        public abstract XmlDictionaryString Durable2PCUri { get; }
        public abstract XmlDictionaryString Volatile2PCUri { get; }
        public abstract XmlDictionaryString CommitAction { get; } 
        public abstract XmlDictionaryString RollbackAction { get; }
        public abstract XmlDictionaryString CommittedAction { get; } 
        public abstract XmlDictionaryString AbortedAction { get; } 
        public abstract XmlDictionaryString PrepareAction { get; }
        public abstract XmlDictionaryString PreparedAction { get; } 
        public abstract XmlDictionaryString ReadOnlyAction { get; }
        public abstract XmlDictionaryString ReplayAction { get; }
        public abstract XmlDictionaryString FaultAction { get; }
 
        //---------------------------------------------------------------
        //                      version independent strings 
        //--------------------------------------------------------------- 
        public XmlDictionaryString Prefix
        { 
            get { return XD.AtomicTransactionExternalDictionary.Prefix; }
        }

        public XmlDictionaryString Prepare 
        {
            get { return XD.AtomicTransactionExternalDictionary.Prepare; } 
        } 

        public XmlDictionaryString Prepared 
        {
            get { return XD.AtomicTransactionExternalDictionary.Prepared; }
        }
 
        public XmlDictionaryString ReadOnly
        { 
            get { return XD.AtomicTransactionExternalDictionary.ReadOnly; } 
        }
 
        public XmlDictionaryString Commit
        {
            get { return XD.AtomicTransactionExternalDictionary.Commit; }
        } 

        public XmlDictionaryString Rollback 
        { 
            get { return XD.AtomicTransactionExternalDictionary.Rollback; }
        } 

        public XmlDictionaryString Committed
        {
            get { return XD.AtomicTransactionExternalDictionary.Committed; } 
        }
 
        public XmlDictionaryString Aborted 
        {
            get { return XD.AtomicTransactionExternalDictionary.Aborted; } 
        }

        public XmlDictionaryString Replay
        { 
            get { return XD.AtomicTransactionExternalDictionary.Replay; }
        } 
 
        public XmlDictionaryString CompletionCoordinatorPortType
        { 
            get { return XD.AtomicTransactionExternalDictionary.CompletionCoordinatorPortType; }
        }

        public XmlDictionaryString CompletionParticipantPortType 
        {
            get { return XD.AtomicTransactionExternalDictionary.CompletionParticipantPortType; } 
        } 

        public XmlDictionaryString CoordinatorPortType 
        {
            get { return XD.AtomicTransactionExternalDictionary.CoordinatorPortType; }
        }
 
        public XmlDictionaryString ParticipantPortType
        { 
            get { return XD.AtomicTransactionExternalDictionary.ParticipantPortType; } 
        }
 
        public XmlDictionaryString InconsistentInternalState
        {
            get { return XD.AtomicTransactionExternalDictionary.InconsistentInternalState; }
        } 

        public XmlDictionaryString UnknownTransaction 
        { 
            get { return DXD.AtomicTransactionExternal11Dictionary.UnknownTransaction; }
        } 
    }


//========================================================================== 
//                              implementations
//========================================================================= 
 
    class AtomicTransactionXmlDictionaryStrings10 : AtomicTransactionXmlDictionaryStrings
    { 
        static AtomicTransactionXmlDictionaryStrings instance = new AtomicTransactionXmlDictionaryStrings10();
        public static AtomicTransactionXmlDictionaryStrings Instance
        {
            get { return instance; } 
        }
 
        public override XmlDictionaryString Namespace 
        {
            get { return XD.AtomicTransactionExternal10Dictionary.Namespace; } 
        }

        public override XmlDictionaryString CompletionUri
        { 
            get { return XD.AtomicTransactionExternal10Dictionary.CompletionUri; }
        } 
 
        public override XmlDictionaryString Durable2PCUri
        { 
            get { return XD.AtomicTransactionExternal10Dictionary.Durable2PCUri; }
        }

        public override XmlDictionaryString Volatile2PCUri 
        {
            get { return XD.AtomicTransactionExternal10Dictionary.Volatile2PCUri; } 
        } 

        public override XmlDictionaryString CommitAction 
        {
            get { return XD.AtomicTransactionExternal10Dictionary.CommitAction; }
        }
 
        public override XmlDictionaryString RollbackAction
        { 
            get { return XD.AtomicTransactionExternal10Dictionary.RollbackAction; } 
        }
 
        public override XmlDictionaryString CommittedAction
        {
            get { return XD.AtomicTransactionExternal10Dictionary.CommittedAction; }
        } 

        public override XmlDictionaryString AbortedAction 
        { 
            get { return XD.AtomicTransactionExternal10Dictionary.AbortedAction; }
        } 

        public override XmlDictionaryString PrepareAction
        {
            get { return XD.AtomicTransactionExternal10Dictionary.PrepareAction; } 
        }
 
        public override XmlDictionaryString PreparedAction 
        {
            get { return XD.AtomicTransactionExternal10Dictionary.PreparedAction; } 
        }

        public override XmlDictionaryString ReadOnlyAction
        { 
            get { return XD.AtomicTransactionExternal10Dictionary.ReadOnlyAction; }
        } 
 
        public override XmlDictionaryString ReplayAction
        { 
            get { return XD.AtomicTransactionExternal10Dictionary.ReplayAction; }
        }

        public override XmlDictionaryString FaultAction 
        {
            get { return XD.AtomicTransactionExternal10Dictionary.FaultAction; } 
        } 
    }
 
    class AtomicTransactionXmlDictionaryStrings11 : AtomicTransactionXmlDictionaryStrings
    {
        static AtomicTransactionXmlDictionaryStrings instance = new AtomicTransactionXmlDictionaryStrings11();
        public static AtomicTransactionXmlDictionaryStrings Instance 
        {
            get { return instance; } 
        } 

        public override XmlDictionaryString Namespace 
        {
            get { return DXD.AtomicTransactionExternal11Dictionary.Namespace; }
        }
 
        public override XmlDictionaryString CompletionUri
        { 
            get { return DXD.AtomicTransactionExternal11Dictionary.CompletionUri; } 
        }
 
        public override XmlDictionaryString Durable2PCUri
        {
            get { return DXD.AtomicTransactionExternal11Dictionary.Durable2PCUri; }
        } 

        public override XmlDictionaryString Volatile2PCUri 
        { 
            get { return DXD.AtomicTransactionExternal11Dictionary.Volatile2PCUri; }
        } 

        public override XmlDictionaryString CommitAction
        {
            get { return DXD.AtomicTransactionExternal11Dictionary.CommitAction; } 
        }
 
        public override XmlDictionaryString RollbackAction 
        {
            get { return DXD.AtomicTransactionExternal11Dictionary.RollbackAction; } 
        }

        public override XmlDictionaryString CommittedAction
        { 
            get { return DXD.AtomicTransactionExternal11Dictionary.CommittedAction; }
        } 
 
        public override XmlDictionaryString AbortedAction
        { 
            get { return DXD.AtomicTransactionExternal11Dictionary.AbortedAction; }
        }

        public override XmlDictionaryString PrepareAction 
        {
            get { return DXD.AtomicTransactionExternal11Dictionary.PrepareAction; } 
        } 

        public override XmlDictionaryString PreparedAction 
        {
            get { return DXD.AtomicTransactionExternal11Dictionary.PreparedAction; }
        }
 
        public override XmlDictionaryString ReadOnlyAction
        { 
            get { return DXD.AtomicTransactionExternal11Dictionary.ReadOnlyAction; } 
        }
 
        public override XmlDictionaryString ReplayAction
        {
            get { return DXD.AtomicTransactionExternal11Dictionary.ReplayAction; }
        } 

        public override XmlDictionaryString FaultAction 
        { 
            get { return DXD.AtomicTransactionExternal11Dictionary.FaultAction; }
        } 
    }
}

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