XmlStrings.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 / XmlStrings.cs / 1 / XmlStrings.cs
                        

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

// Define any additional strings needed for wire representations of WS-C/AT 

using System; 
using System.ServiceModel; 
using System.ServiceModel.Channels;
using System.Transactions; 
using System.Xml;
using Microsoft.Transactions.Wsat.Protocol;

namespace Microsoft.Transactions.Wsat.Messaging 
{
    static class WSAtomicTransactionStrings 
    { 
        //
        // Protocol conversion 
        //

        public static ControlProtocol WellKnownNameToProtocol(string name, ProtocolVersion protocolVersion)
        { 
            AtomicTransactionStrings atomicTransactionStrings = AtomicTransactionStrings.Version(protocolVersion);
 
            if(name == atomicTransactionStrings.CompletionUri) 
            {
                return ControlProtocol.Completion; 
            }
            else if(name == atomicTransactionStrings.Durable2PCUri)
            {
                return ControlProtocol.Durable2PC; 
            }
            else if(name == atomicTransactionStrings.Volatile2PCUri) 
            { 
                return ControlProtocol.Volatile2PC;
            } 
            else
            {
                return ControlProtocol.None;
            } 
        }
 
        public static XmlDictionaryString ProtocolToWellKnownName(ControlProtocol ctrlProt, ProtocolVersion protocolVersion) 
        {
            AtomicTransactionXmlDictionaryStrings atomicTransactionXmlDictionaryStrings = 
                AtomicTransactionXmlDictionaryStrings.Version(protocolVersion);

            switch (ctrlProt)
            { 
                case ControlProtocol.Completion:
                    return atomicTransactionXmlDictionaryStrings.CompletionUri; 
 
                case ControlProtocol.Durable2PC:
                    return atomicTransactionXmlDictionaryStrings.Durable2PCUri; 

                case ControlProtocol.Volatile2PC:
                    return atomicTransactionXmlDictionaryStrings.Volatile2PCUri;
 
                default:
                    // An invalid Enum value on this internal code path indicates 
                    // a product bug and violates assumptions about 
                    // valid values in MSDTC.
                    DiagnosticUtility.FailFast("Invalid protocol"); 
                    return null;    // Keep the compiler happy
            }
        }
    } 

    static class BindingStrings 
    { 
        public const string AddressPrefix = "WsatService";
 
        public const string InteropBindingName = "Interop";
        public const string NamedPipeBindingName = "NamedPipe";
        public const string WindowsBindingName = "Windows";
 
        static readonly string InteropBindingQName10 =
            new XmlQualifiedName(InteropBindingName, AtomicTransactionExternal10Strings.Namespace).ToString(); 
 
        static readonly string InteropBindingQName11 =
            new XmlQualifiedName(InteropBindingName, AtomicTransactionExternal11Strings.Namespace).ToString(); 

        public static string InteropBindingQName(ProtocolVersion protocolVersion)
        {
            ProtocolVersionHelper.AssertProtocolVersion(protocolVersion, typeof(BindingStrings), "InteropBindingQName"); //assert valid protocol version 

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

                case ProtocolVersion.Version11 :
                    return InteropBindingQName11;
 
                default :
                    return null; // inaccessible path because we have asserted the protocol version 
            } 
        }
 
        public static readonly string NamedPipeBindingQName =
            new XmlQualifiedName(NamedPipeBindingName, DotNetAtomicTransactionExternalStrings.Namespace).ToString();

        public static readonly string WindowsBindingQName = 
            new XmlQualifiedName(WindowsBindingName, DotNetAtomicTransactionExternalStrings.Namespace).ToString();
 
        public const string RemoteProxySuffix = "Remote/"; 
        public const string DisabledSuffix = "Disabled/";
 

        public static string ActivationCoordinatorSuffix(ProtocolVersion protocolVersion)
        {
            ProtocolVersionHelper.AssertProtocolVersion(protocolVersion, typeof(BindingStrings), "ActivationCoordinatorSuffix"); //assert valid protocol version 

            switch (protocolVersion) 
            { 
                case ProtocolVersion.Version10:
                    return "Activation/Coordinator/"; 

                case ProtocolVersion.Version11:
                    return "Activation/Coordinator11/";
 
                default:
                    return null; // inaccessible path because we have asserted the protocol version 
            } 
        }
 
        public static string RegistrationCoordinatorSuffix(ProtocolVersion protocolVersion)
        {
            ProtocolVersionHelper.AssertProtocolVersion(protocolVersion, typeof(BindingStrings), "RegistrationCoordinatorSuffix"); //assert valid protocol version
 
            switch (protocolVersion)
            { 
                case ProtocolVersion.Version10: 
                    return "Registration/Coordinator/";
 
                case ProtocolVersion.Version11:
                    return "Registration/Coordinator11/";

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

 
        public static string CompletionCoordinatorSuffix(ProtocolVersion protocolVersion)
        {
            ProtocolVersionHelper.AssertProtocolVersion(protocolVersion, typeof(BindingStrings), "CompletionCoordinatorSuffix"); //assert valid protocol version
 
            switch (protocolVersion)
            { 
                case ProtocolVersion.Version10: 
                    return "Completion/Coordinator/";
 
                case ProtocolVersion.Version11:
                    return "Completion/Coordinator11/";

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

 
        public static string CompletionParticipantSuffix(ProtocolVersion protocolVersion)
        {
            ProtocolVersionHelper.AssertProtocolVersion(protocolVersion, typeof(BindingStrings), "CompletionParticipantSuffix"); //assert valid protocol version
 
            switch (protocolVersion)
            { 
                case ProtocolVersion.Version10: 
                    return "Completion/Participant/";
 
                case ProtocolVersion.Version11:
                    return "Completion/Participant11/";

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

        public static string TwoPhaseCommitCoordinatorSuffix(ProtocolVersion protocolVersion) 
        {
            ProtocolVersionHelper.AssertProtocolVersion(protocolVersion, typeof(BindingStrings), "TwoPhaseCommitCoordinatorSuffix"); //assert valid protocol version

            switch (protocolVersion) 
            {
                case ProtocolVersion.Version10: 
                    return "TwoPhaseCommit/Coordinator/"; 

                case ProtocolVersion.Version11: 
                    return "TwoPhaseCommit/Coordinator11/";

                default:
                    return null; // inaccessible path because we have asserted the protocol version 
            }
        } 
 
        public static string TwoPhaseCommitParticipantSuffix(ProtocolVersion protocolVersion)
        { 
            ProtocolVersionHelper.AssertProtocolVersion(protocolVersion, typeof(BindingStrings), "TwoPhaseCommitParticipantSuffix"); //assert valid protocol version

            switch (protocolVersion)
            { 
                case ProtocolVersion.Version10:
                    return "TwoPhaseCommit/Participant/"; 
 
                case ProtocolVersion.Version11:
                    return "TwoPhaseCommit/Participant11/"; 

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

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