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

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

namespace System.ServiceModel 
{
    using System.Xml; 
 
    // NOTE: This is a dynamic dictionary of XmlDictionaryStrings for the Binary Encoder to dynamically encode should
    // the string not exist in the static cache. 
    // When adding or removing memebers please keep the capacity of the XmlDictionary field current.
    static class DXD
    {
        static AtomicTransactionExternal11Dictionary atomicTransactionExternal11Dictionary; 
        static CoordinationExternal11Dictionary coordinationExternal11Dictionary;
        static SecureConversationDec2005Dictionary secureConversationDec2005Dictionary; 
        static SecurityAlgorithmDec2005Dictionary securityAlgorithmDec2005Dictionary; 
        static TrustDec2005Dictionary trustDec2005Dictionary;
        static Wsrm11Dictionary wsrm11Dictionary; 

        static DXD()
        {
            // Each string added to the XmlDictionary will keep a reference to the XmlDictionary so this class does 
            // not need to keep a reference.
            XmlDictionary dictionary = new XmlDictionary(137); 
 
            // Each dictionaries' constructor should add strings to the XmlDictionary.
            atomicTransactionExternal11Dictionary = new AtomicTransactionExternal11Dictionary(dictionary); 
            coordinationExternal11Dictionary = new CoordinationExternal11Dictionary(dictionary);
            secureConversationDec2005Dictionary = new SecureConversationDec2005Dictionary(dictionary);
            securityAlgorithmDec2005Dictionary = new SecurityAlgorithmDec2005Dictionary(dictionary);
            trustDec2005Dictionary = new TrustDec2005Dictionary(dictionary); 
            wsrm11Dictionary = new Wsrm11Dictionary(dictionary);
        } 
 
        static public AtomicTransactionExternal11Dictionary AtomicTransactionExternal11Dictionary
        { 
            get { return atomicTransactionExternal11Dictionary; }
        }

        static public CoordinationExternal11Dictionary CoordinationExternal11Dictionary 
        {
            get { return coordinationExternal11Dictionary; } 
        } 

        static public SecureConversationDec2005Dictionary SecureConversationDec2005Dictionary 
        {
            get { return secureConversationDec2005Dictionary; }
        }
 
        static public SecurityAlgorithmDec2005Dictionary SecurityAlgorithmDec2005Dictionary
        { 
            get { return securityAlgorithmDec2005Dictionary; } 
        }
 
        static public TrustDec2005Dictionary TrustDec2005Dictionary
        {
            get { return trustDec2005Dictionary; }
        } 

        static public Wsrm11Dictionary Wsrm11Dictionary 
        { 
            get { return wsrm11Dictionary; }
        } 
    }

    class AtomicTransactionExternal11Dictionary
    { 
        public XmlDictionaryString Namespace;
        public XmlDictionaryString CompletionUri; 
        public XmlDictionaryString Durable2PCUri; 
        public XmlDictionaryString Volatile2PCUri;
        public XmlDictionaryString CommitAction; 
        public XmlDictionaryString RollbackAction;
        public XmlDictionaryString CommittedAction;
        public XmlDictionaryString AbortedAction;
        public XmlDictionaryString PrepareAction; 
        public XmlDictionaryString PreparedAction;
        public XmlDictionaryString ReadOnlyAction; 
        public XmlDictionaryString ReplayAction; 
        public XmlDictionaryString FaultAction;
        public XmlDictionaryString UnknownTransaction; 

        public AtomicTransactionExternal11Dictionary(XmlDictionary dictionary)
        {
            this.Namespace = dictionary.Add(AtomicTransactionExternal11Strings.Namespace); 
            this.CompletionUri = dictionary.Add(AtomicTransactionExternal11Strings.CompletionUri);
            this.Durable2PCUri = dictionary.Add(AtomicTransactionExternal11Strings.Durable2PCUri); 
            this.Volatile2PCUri = dictionary.Add(AtomicTransactionExternal11Strings.Volatile2PCUri); 
            this.CommitAction = dictionary.Add(AtomicTransactionExternal11Strings.CommitAction);
            this.RollbackAction = dictionary.Add(AtomicTransactionExternal11Strings.RollbackAction); 
            this.CommittedAction = dictionary.Add(AtomicTransactionExternal11Strings.CommittedAction);
            this.AbortedAction = dictionary.Add(AtomicTransactionExternal11Strings.AbortedAction);
            this.PrepareAction = dictionary.Add(AtomicTransactionExternal11Strings.PrepareAction);
            this.PreparedAction = dictionary.Add(AtomicTransactionExternal11Strings.PreparedAction); 
            this.ReadOnlyAction = dictionary.Add(AtomicTransactionExternal11Strings.ReadOnlyAction);
            this.ReplayAction = dictionary.Add(AtomicTransactionExternal11Strings.ReplayAction); 
            this.FaultAction = dictionary.Add(AtomicTransactionExternal11Strings.FaultAction); 
            this.UnknownTransaction = dictionary.Add(AtomicTransactionExternal11Strings.UnknownTransaction);
        } 
    }

    class CoordinationExternal11Dictionary
    { 
        public XmlDictionaryString Namespace;
        public XmlDictionaryString CreateCoordinationContextAction; 
        public XmlDictionaryString CreateCoordinationContextResponseAction; 
        public XmlDictionaryString RegisterAction;
        public XmlDictionaryString RegisterResponseAction; 
        public XmlDictionaryString FaultAction;
        public XmlDictionaryString CannotCreateContext;
        public XmlDictionaryString CannotRegisterParticipant;
 
        public CoordinationExternal11Dictionary(XmlDictionary dictionary)
        { 
            this.Namespace = dictionary.Add(CoordinationExternal11Strings.Namespace); 
            this.CreateCoordinationContextAction = dictionary.Add(CoordinationExternal11Strings.CreateCoordinationContextAction);
            this.CreateCoordinationContextResponseAction = dictionary.Add(CoordinationExternal11Strings.CreateCoordinationContextResponseAction); 
            this.RegisterAction = dictionary.Add(CoordinationExternal11Strings.RegisterAction);
            this.RegisterResponseAction = dictionary.Add(CoordinationExternal11Strings.RegisterResponseAction);
            this.FaultAction = dictionary.Add(CoordinationExternal11Strings.FaultAction);
            this.CannotCreateContext = dictionary.Add(CoordinationExternal11Strings.CannotCreateContext); 
            this.CannotRegisterParticipant = dictionary.Add(CoordinationExternal11Strings.CannotRegisterParticipant);
        } 
    } 

    class SecureConversationDec2005Dictionary : SecureConversationDictionary 
    {
        public XmlDictionaryString RequestSecurityContextRenew;
        public XmlDictionaryString RequestSecurityContextRenewResponse;
        public XmlDictionaryString RequestSecurityContextClose; 
        public XmlDictionaryString RequestSecurityContextCloseResponse;
        public XmlDictionaryString Instance; 
 
        public SecureConversationDec2005Dictionary(XmlDictionary dictionary)
        { 
            this.SecurityContextToken = dictionary.Add(SecureConversationDec2005Strings.SecurityContextToken);
            this.AlgorithmAttribute = dictionary.Add(SecureConversationDec2005Strings.AlgorithmAttribute);
            this.Generation = dictionary.Add(SecureConversationDec2005Strings.Generation);
            this.Label = dictionary.Add(SecureConversationDec2005Strings.Label); 
            this.Offset = dictionary.Add(SecureConversationDec2005Strings.Offset);
            this.Properties = dictionary.Add(SecureConversationDec2005Strings.Properties); 
            this.Identifier = dictionary.Add(SecureConversationDec2005Strings.Identifier); 
            this.Cookie = dictionary.Add(SecureConversationDec2005Strings.Cookie);
            this.RenewNeededFaultCode = dictionary.Add(SecureConversationDec2005Strings.RenewNeededFaultCode); 
            this.BadContextTokenFaultCode = dictionary.Add(SecureConversationDec2005Strings.BadContextTokenFaultCode);
            this.Prefix = dictionary.Add(SecureConversationDec2005Strings.Prefix);
            this.DerivedKeyTokenType = dictionary.Add(SecureConversationDec2005Strings.DerivedKeyTokenType);
            this.SecurityContextTokenType = dictionary.Add(SecureConversationDec2005Strings.SecurityContextTokenType); 
            this.SecurityContextTokenReferenceValueType = dictionary.Add(SecureConversationDec2005Strings.SecurityContextTokenReferenceValueType);
            this.RequestSecurityContextIssuance = dictionary.Add(SecureConversationDec2005Strings.RequestSecurityContextIssuance); 
            this.RequestSecurityContextIssuanceResponse = dictionary.Add(SecureConversationDec2005Strings.RequestSecurityContextIssuanceResponse); 
            this.RequestSecurityContextRenew = dictionary.Add(SecureConversationDec2005Strings.RequestSecurityContextRenew);
            this.RequestSecurityContextRenewResponse = dictionary.Add(SecureConversationDec2005Strings.RequestSecurityContextRenewResponse); 
            this.RequestSecurityContextClose = dictionary.Add(SecureConversationDec2005Strings.RequestSecurityContextClose);
            this.RequestSecurityContextCloseResponse = dictionary.Add(SecureConversationDec2005Strings.RequestSecurityContextCloseResponse);
            this.Namespace = dictionary.Add(SecureConversationDec2005Strings.Namespace);
            this.DerivedKeyToken = dictionary.Add(SecureConversationDec2005Strings.DerivedKeyToken); 
            this.Nonce = dictionary.Add(SecureConversationDec2005Strings.Nonce);
            this.Length = dictionary.Add(SecureConversationDec2005Strings.Length); 
            this.Instance = dictionary.Add(SecureConversationDec2005Strings.Instance); 
        }
    } 

    class SecurityAlgorithmDec2005Dictionary
    {
        public XmlDictionaryString Psha1KeyDerivationDec2005; 

        public SecurityAlgorithmDec2005Dictionary(XmlDictionary dictionary) 
        { 
            this.Psha1KeyDerivationDec2005 = dictionary.Add(SecurityAlgorithmDec2005Strings.Psha1KeyDerivationDec2005);
        } 
    }

    class TrustDec2005Dictionary : TrustDictionary
    { 
        public XmlDictionaryString AsymmetricKeyBinarySecret;
        public XmlDictionaryString RequestSecurityTokenCollectionIssuanceFinalResponse; 
        public XmlDictionaryString RequestSecurityTokenRenewal; 
        public XmlDictionaryString RequestSecurityTokenRenewalResponse;
        public XmlDictionaryString RequestSecurityTokenCollectionRenewalFinalResponse; 
        public XmlDictionaryString RequestSecurityTokenCancellation;
        public XmlDictionaryString RequestSecurityTokenCancellationResponse;
        public XmlDictionaryString RequestSecurityTokenCollectionCancellationFinalResponse;
        public XmlDictionaryString KeyWrapAlgorithm; 
        public XmlDictionaryString BearerKeyType;
        public XmlDictionaryString SecondaryParameters; 
        public XmlDictionaryString Dialect; 
        public XmlDictionaryString DialectType;
 
        public TrustDec2005Dictionary(XmlDictionary dictionary)
        {
            this.CombinedHashLabel = dictionary.Add(TrustDec2005Strings.CombinedHashLabel);
            this.RequestSecurityTokenResponse = dictionary.Add(TrustDec2005Strings.RequestSecurityTokenResponse); 
            this.TokenType = dictionary.Add(TrustDec2005Strings.TokenType);
            this.KeySize = dictionary.Add(TrustDec2005Strings.KeySize); 
            this.RequestedTokenReference = dictionary.Add(TrustDec2005Strings.RequestedTokenReference); 
            this.AppliesTo = dictionary.Add(TrustDec2005Strings.AppliesTo);
            this.Authenticator = dictionary.Add(TrustDec2005Strings.Authenticator); 
            this.CombinedHash = dictionary.Add(TrustDec2005Strings.CombinedHash);
            this.BinaryExchange = dictionary.Add(TrustDec2005Strings.BinaryExchange);
            this.Lifetime = dictionary.Add(TrustDec2005Strings.Lifetime);
            this.RequestedSecurityToken = dictionary.Add(TrustDec2005Strings.RequestedSecurityToken); 
            this.Entropy = dictionary.Add(TrustDec2005Strings.Entropy);
            this.RequestedProofToken = dictionary.Add(TrustDec2005Strings.RequestedProofToken); 
            this.ComputedKey = dictionary.Add(TrustDec2005Strings.ComputedKey); 
            this.RequestSecurityToken = dictionary.Add(TrustDec2005Strings.RequestSecurityToken);
            this.RequestType = dictionary.Add(TrustDec2005Strings.RequestType); 
            this.Context = dictionary.Add(TrustDec2005Strings.Context);
            this.BinarySecret = dictionary.Add(TrustDec2005Strings.BinarySecret);
            this.Type = dictionary.Add(TrustDec2005Strings.Type);
            this.SpnegoValueTypeUri = dictionary.Add(TrustDec2005Strings.SpnegoValueTypeUri); 
            this.TlsnegoValueTypeUri = dictionary.Add(TrustDec2005Strings.TlsnegoValueTypeUri);
            this.Prefix = dictionary.Add(TrustDec2005Strings.Prefix); 
            this.RequestSecurityTokenIssuance = dictionary.Add(TrustDec2005Strings.RequestSecurityTokenIssuance); 
            this.RequestSecurityTokenIssuanceResponse = dictionary.Add(TrustDec2005Strings.RequestSecurityTokenIssuanceResponse);
            this.RequestTypeIssue = dictionary.Add(TrustDec2005Strings.RequestTypeIssue); 
            this.AsymmetricKeyBinarySecret = dictionary.Add(TrustDec2005Strings.AsymmetricKeyBinarySecret);
            this.SymmetricKeyBinarySecret = dictionary.Add(TrustDec2005Strings.SymmetricKeyBinarySecret);
            this.NonceBinarySecret = dictionary.Add(TrustDec2005Strings.NonceBinarySecret);
            this.Psha1ComputedKeyUri = dictionary.Add(TrustDec2005Strings.Psha1ComputedKeyUri); 
            this.KeyType = dictionary.Add(TrustDec2005Strings.KeyType);
            this.SymmetricKeyType = dictionary.Add(TrustDec2005Strings.SymmetricKeyType); 
            this.PublicKeyType = dictionary.Add(TrustDec2005Strings.PublicKeyType); 
            this.Claims = dictionary.Add(TrustDec2005Strings.Claims);
            this.InvalidRequestFaultCode = dictionary.Add(TrustDec2005Strings.InvalidRequestFaultCode); 
            this.FailedAuthenticationFaultCode = dictionary.Add(TrustDec2005Strings.FailedAuthenticationFaultCode);
            this.UseKey = dictionary.Add(TrustDec2005Strings.UseKey);
            this.SignWith = dictionary.Add(TrustDec2005Strings.SignWith);
            this.EncryptWith = dictionary.Add(TrustDec2005Strings.EncryptWith); 
            this.EncryptionAlgorithm = dictionary.Add(TrustDec2005Strings.EncryptionAlgorithm);
            this.CanonicalizationAlgorithm = dictionary.Add(TrustDec2005Strings.CanonicalizationAlgorithm); 
            this.ComputedKeyAlgorithm = dictionary.Add(TrustDec2005Strings.ComputedKeyAlgorithm); 
            this.RequestSecurityTokenResponseCollection = dictionary.Add(TrustDec2005Strings.RequestSecurityTokenResponseCollection);
            this.Namespace = dictionary.Add(TrustDec2005Strings.Namespace); 
            this.BinarySecretClauseType = dictionary.Add(TrustDec2005Strings.BinarySecretClauseType);
            this.RequestSecurityTokenCollectionIssuanceFinalResponse = dictionary.Add(TrustDec2005Strings.RequestSecurityTokenCollectionIssuanceFinalResponse);
            this.RequestSecurityTokenRenewal = dictionary.Add(TrustDec2005Strings.RequestSecurityTokenRenewal);
            this.RequestSecurityTokenRenewalResponse = dictionary.Add(TrustDec2005Strings.RequestSecurityTokenRenewalResponse); 
            this.RequestSecurityTokenCollectionRenewalFinalResponse = dictionary.Add(TrustDec2005Strings.RequestSecurityTokenCollectionRenewalFinalResponse);
            this.RequestSecurityTokenCancellation = dictionary.Add(TrustDec2005Strings.RequestSecurityTokenCancellation); 
            this.RequestSecurityTokenCancellationResponse = dictionary.Add(TrustDec2005Strings.RequestSecurityTokenCancellationResponse); 
            this.RequestSecurityTokenCollectionCancellationFinalResponse = dictionary.Add(TrustDec2005Strings.RequestSecurityTokenCollectionCancellationFinalResponse);
            this.RequestTypeRenew = dictionary.Add(TrustDec2005Strings.RequestTypeRenew); 
            this.RequestTypeClose = dictionary.Add(TrustDec2005Strings.RequestTypeClose);
            this.RenewTarget = dictionary.Add(TrustDec2005Strings.RenewTarget);
            this.CloseTarget = dictionary.Add(TrustDec2005Strings.CloseTarget);
            this.RequestedTokenClosed = dictionary.Add(TrustDec2005Strings.RequestedTokenClosed); 
            this.RequestedAttachedReference = dictionary.Add(TrustDec2005Strings.RequestedAttachedReference);
            this.RequestedUnattachedReference = dictionary.Add(TrustDec2005Strings.RequestedUnattachedReference); 
            this.IssuedTokensHeader = dictionary.Add(TrustDec2005Strings.IssuedTokensHeader); 
            this.KeyWrapAlgorithm = dictionary.Add(TrustDec2005Strings.KeyWrapAlgorithm);
            this.BearerKeyType = dictionary.Add(TrustDec2005Strings.BearerKeyType); 
            this.SecondaryParameters = dictionary.Add(TrustDec2005Strings.SecondaryParameters);
            this.Dialect = dictionary.Add(TrustDec2005Strings.Dialect);
            this.DialectType = dictionary.Add(TrustDec2005Strings.DialectType);
        } 
    }
 
    class Wsrm11Dictionary 
    {
        public XmlDictionaryString AckRequestedAction; 
        public XmlDictionaryString CloseSequence;
        public XmlDictionaryString CloseSequenceAction;
        public XmlDictionaryString CloseSequenceResponse;
        public XmlDictionaryString CloseSequenceResponseAction; 
        public XmlDictionaryString CreateSequenceAction;
        public XmlDictionaryString CreateSequenceResponseAction; 
        public XmlDictionaryString DiscardFollowingFirstGap; 
        public XmlDictionaryString Endpoint;
        public XmlDictionaryString FaultAction; 
        public XmlDictionaryString Final;
        public XmlDictionaryString IncompleteSequenceBehavior;
        public XmlDictionaryString LastMsgNumber;
        public XmlDictionaryString MaxMessageNumber; 
        public XmlDictionaryString Namespace;
        public XmlDictionaryString NoDiscard; 
        public XmlDictionaryString None; 
        public XmlDictionaryString SequenceAcknowledgementAction;
        public XmlDictionaryString SequenceClosed; 
        public XmlDictionaryString TerminateSequenceAction;
        public XmlDictionaryString TerminateSequenceResponse;
        public XmlDictionaryString TerminateSequenceResponseAction;
        public XmlDictionaryString UsesSequenceSSL; 
        public XmlDictionaryString UsesSequenceSTR;
        public XmlDictionaryString WsrmRequired; 
 
        public Wsrm11Dictionary(XmlDictionary dictionary)
        { 
            this.AckRequestedAction = dictionary.Add(Wsrm11Strings.AckRequestedAction);
            this.CloseSequence = dictionary.Add(Wsrm11Strings.CloseSequence);
            this.CloseSequenceAction = dictionary.Add(Wsrm11Strings.CloseSequenceAction);
            this.CloseSequenceResponse = dictionary.Add(Wsrm11Strings.CloseSequenceResponse); 
            this.CloseSequenceResponseAction = dictionary.Add(Wsrm11Strings.CloseSequenceResponseAction);
            this.CreateSequenceAction = dictionary.Add(Wsrm11Strings.CreateSequenceAction); 
            this.CreateSequenceResponseAction = dictionary.Add(Wsrm11Strings.CreateSequenceResponseAction); 
            this.DiscardFollowingFirstGap = dictionary.Add(Wsrm11Strings.DiscardFollowingFirstGap);
            this.Endpoint = dictionary.Add(Wsrm11Strings.Endpoint); 
            this.FaultAction = dictionary.Add(Wsrm11Strings.FaultAction);
            this.Final = dictionary.Add(Wsrm11Strings.Final);
            this.IncompleteSequenceBehavior = dictionary.Add(Wsrm11Strings.IncompleteSequenceBehavior);
            this.LastMsgNumber = dictionary.Add(Wsrm11Strings.LastMsgNumber); 
            this.MaxMessageNumber = dictionary.Add(Wsrm11Strings.MaxMessageNumber);
            this.Namespace = dictionary.Add(Wsrm11Strings.Namespace); 
            this.NoDiscard = dictionary.Add(Wsrm11Strings.NoDiscard); 
            this.None = dictionary.Add(Wsrm11Strings.None);
            this.SequenceAcknowledgementAction = dictionary.Add(Wsrm11Strings.SequenceAcknowledgementAction); 
            this.SequenceClosed = dictionary.Add(Wsrm11Strings.SequenceClosed);
            this.TerminateSequenceAction = dictionary.Add(Wsrm11Strings.TerminateSequenceAction);
            this.TerminateSequenceResponse = dictionary.Add(Wsrm11Strings.TerminateSequenceResponse);
            this.TerminateSequenceResponseAction = dictionary.Add(Wsrm11Strings.TerminateSequenceResponseAction); 
            this.UsesSequenceSSL = dictionary.Add(Wsrm11Strings.UsesSequenceSSL);
            this.UsesSequenceSTR = dictionary.Add(Wsrm11Strings.UsesSequenceSTR); 
            this.WsrmRequired = dictionary.Add(Wsrm11Strings.WsrmRequired); 
        }
    } 

    static class AtomicTransactionExternal11Strings
    {
        // dictionary strings 
        public const string Namespace = "http://docs.oasis-open.org/ws-tx/wsat/2006/06";
        public const string CompletionUri = "http://docs.oasis-open.org/ws-tx/wsat/2006/06/Completion"; 
        public const string Durable2PCUri = "http://docs.oasis-open.org/ws-tx/wsat/2006/06/Durable2PC"; 
        public const string Volatile2PCUri = "http://docs.oasis-open.org/ws-tx/wsat/2006/06/Volatile2PC";
        public const string CommitAction = "http://docs.oasis-open.org/ws-tx/wsat/2006/06/Commit"; 
        public const string RollbackAction = "http://docs.oasis-open.org/ws-tx/wsat/2006/06/Rollback";
        public const string CommittedAction = "http://docs.oasis-open.org/ws-tx/wsat/2006/06/Committed";
        public const string AbortedAction = "http://docs.oasis-open.org/ws-tx/wsat/2006/06/Aborted";
        public const string PrepareAction = "http://docs.oasis-open.org/ws-tx/wsat/2006/06/Prepare"; 
        public const string PreparedAction = "http://docs.oasis-open.org/ws-tx/wsat/2006/06/Prepared";
        public const string ReadOnlyAction = "http://docs.oasis-open.org/ws-tx/wsat/2006/06/ReadOnly"; 
        public const string ReplayAction = "http://docs.oasis-open.org/ws-tx/wsat/2006/06/Replay"; 
        public const string FaultAction = "http://docs.oasis-open.org/ws-tx/wsat/2006/06/fault";
        public const string UnknownTransaction = "UnknownTransaction"; 
    }

    static class CoordinationExternal11Strings
    { 
        // dictionary strings
        public const string Namespace = "http://docs.oasis-open.org/ws-tx/wscoor/2006/06"; 
        public const string CreateCoordinationContextAction = "http://docs.oasis-open.org/ws-tx/wscoor/2006/06/CreateCoordinationContext"; 
        public const string CreateCoordinationContextResponseAction = "http://docs.oasis-open.org/ws-tx/wscoor/2006/06/CreateCoordinationContextResponse";
        public const string RegisterAction = "http://docs.oasis-open.org/ws-tx/wscoor/2006/06/Register"; 
        public const string RegisterResponseAction = "http://docs.oasis-open.org/ws-tx/wscoor/2006/06/RegisterResponse";
        public const string FaultAction = "http://docs.oasis-open.org/ws-tx/wscoor/2006/06/fault";
        public const string CannotCreateContext = "CannotCreateContext";
        public const string CannotRegisterParticipant = "CannotRegisterParticipant"; 
    }
 
    static class SecureConversationDec2005Strings 
    {
        // dictionary strings 
        public const string SecurityContextToken = "SecurityContextToken";
        public const string AlgorithmAttribute = "Algorithm";
        public const string Generation = "Generation";
        public const string Label = "Label"; 
        public const string Offset = "Offset";
        public const string Properties = "Properties"; 
        public const string Identifier = "Identifier"; 
        public const string Cookie = "Cookie";
        public const string RenewNeededFaultCode = "RenewNeeded"; 
        public const string BadContextTokenFaultCode = "BadContextToken";
        public const string Prefix = "sc";
        public const string DerivedKeyTokenType = "http://docs.oasis-open.org/ws-sx/ws-secureconversation/200512/dk";
        public const string SecurityContextTokenType = "http://docs.oasis-open.org/ws-sx/ws-secureconversation/200512/sct"; 
        public const string SecurityContextTokenReferenceValueType = "http://docs.oasis-open.org/ws-sx/ws-secureconversation/200512/sct";
        public const string RequestSecurityContextIssuance = "http://docs.oasis-open.org/ws-sx/ws-trust/200512/RST/SCT"; 
        public const string RequestSecurityContextIssuanceResponse = "http://docs.oasis-open.org/ws-sx/ws-trust/200512/RSTR/SCT"; 
        public const string RequestSecurityContextRenew = "http://docs.oasis-open.org/ws-sx/ws-trust/200512/RST/SCT/Renew";
        public const string RequestSecurityContextRenewResponse = "http://docs.oasis-open.org/ws-sx/ws-trust/200512/RSTR/SCT/Renew"; 
        public const string RequestSecurityContextClose = "http://docs.oasis-open.org/ws-sx/ws-trust/200512/RST/SCT/Cancel";
        public const string RequestSecurityContextCloseResponse = "http://docs.oasis-open.org/ws-sx/ws-trust/200512/RSTR/SCT/Cancel";
        public const string Namespace = "http://docs.oasis-open.org/ws-sx/ws-secureconversation/200512";
        public const string DerivedKeyToken = "DerivedKeyToken"; 
        public const string Nonce = "Nonce";
        public const string Length = "Length"; 
        public const string Instance = "Instance"; 
    }
 
    static class SecurityAlgorithmDec2005Strings
    {
        // dictionary strings
        public const string Psha1KeyDerivationDec2005 = "http://docs.oasis-open.org/ws-sx/ws-secureconversation/200512/dk/p_sha1"; 
    }
 
    static class TrustDec2005Strings 
    {
        // dictionary strings 
        public const string CombinedHashLabel = "AUTH-HASH";
        public const string RequestSecurityTokenResponse = "RequestSecurityTokenResponse";
        public const string TokenType = "TokenType";
        public const string KeySize = "KeySize"; 
        public const string RequestedTokenReference = "RequestedTokenReference";
        public const string AppliesTo = "AppliesTo"; 
        public const string Authenticator = "Authenticator"; 
        public const string CombinedHash = "CombinedHash";
        public const string BinaryExchange = "BinaryExchange"; 
        public const string Lifetime = "Lifetime";
        public const string RequestedSecurityToken = "RequestedSecurityToken";
        public const string Entropy = "Entropy";
        public const string RequestedProofToken = "RequestedProofToken"; 
        public const string ComputedKey = "ComputedKey";
        public const string RequestSecurityToken = "RequestSecurityToken"; 
        public const string RequestType = "RequestType"; 
        public const string Context = "Context";
        public const string BinarySecret = "BinarySecret"; 
        public const string Type = "Type";
        public const string SpnegoValueTypeUri = "http://schemas.xmlsoap.org/ws/2005/02/trust/spnego";
        public const string TlsnegoValueTypeUri = "http://schemas.xmlsoap.org/ws/2005/02/trust/tlsnego";
        public const string Prefix = "trust"; 
        public const string RequestSecurityTokenIssuance = "http://docs.oasis-open.org/ws-sx/ws-trust/200512/RST/Issue";
        public const string RequestSecurityTokenIssuanceResponse = "http://docs.oasis-open.org/ws-sx/ws-trust/200512/RSTR/Issue"; 
        public const string RequestTypeIssue = "http://docs.oasis-open.org/ws-sx/ws-trust/200512/Issue"; 
        public const string AsymmetricKeyBinarySecret = "http://docs.oasis-open.org/ws-sx/ws-trust/200512/AsymmetricKey";
        public const string SymmetricKeyBinarySecret = "http://docs.oasis-open.org/ws-sx/ws-trust/200512/SymmetricKey"; 
        public const string NonceBinarySecret = "http://docs.oasis-open.org/ws-sx/ws-trust/200512/Nonce";
        public const string Psha1ComputedKeyUri = "http://docs.oasis-open.org/ws-sx/ws-trust/200512/CK/PSHA1";
        public const string KeyType = "KeyType";
        public const string SymmetricKeyType = "http://docs.oasis-open.org/ws-sx/ws-trust/200512/SymmetricKey"; 
        public const string PublicKeyType = "http://docs.oasis-open.org/ws-sx/ws-trust/200512/PublicKey";
        public const string Claims = "Claims"; 
        public const string InvalidRequestFaultCode = "InvalidRequest"; 
        public const string FailedAuthenticationFaultCode = "FailedAuthentication";
        public const string UseKey = "UseKey"; 
        public const string SignWith = "SignWith";
        public const string EncryptWith = "EncryptWith";
        public const string EncryptionAlgorithm = "EncryptionAlgorithm";
        public const string CanonicalizationAlgorithm = "CanonicalizationAlgorithm"; 
        public const string ComputedKeyAlgorithm = "ComputedKeyAlgorithm";
        public const string RequestSecurityTokenResponseCollection = "RequestSecurityTokenResponseCollection"; 
        public const string Namespace = "http://docs.oasis-open.org/ws-sx/ws-trust/200512"; 
        public const string BinarySecretClauseType = "http://docs.oasis-open.org/ws-sx/ws-trust/200512#BinarySecret";
        public const string RequestSecurityTokenCollectionIssuanceFinalResponse = "http://docs.oasis-open.org/ws-sx/ws-trust/200512/RSTRC/IssueFinal"; 
        public const string RequestSecurityTokenRenewal = "http://docs.oasis-open.org/ws-sx/ws-trust/200512/RST/Renew";
        public const string RequestSecurityTokenRenewalResponse = "http://docs.oasis-open.org/ws-sx/ws-trust/200512/RSTR/Renew";
        public const string RequestSecurityTokenCollectionRenewalFinalResponse = "http://docs.oasis-open.org/ws-sx/ws-trust/200512/RSTR/RenewFinal";
        public const string RequestSecurityTokenCancellation = "http://docs.oasis-open.org/ws-sx/ws-trust/200512/RST/Cancel"; 
        public const string RequestSecurityTokenCancellationResponse = "http://docs.oasis-open.org/ws-sx/ws-trust/200512/RSTR/Cancel";
        public const string RequestSecurityTokenCollectionCancellationFinalResponse = "http://docs.oasis-open.org/ws-sx/ws-trust/200512/RSTR/CancelFinal"; 
        public const string RequestTypeRenew = "http://docs.oasis-open.org/ws-sx/ws-trust/200512/Renew"; 
        public const string RequestTypeClose = "http://docs.oasis-open.org/ws-sx/ws-trust/200512/Cancel";
        public const string RenewTarget = "RenewTarget"; 
        public const string CloseTarget = "CancelTarget";
        public const string RequestedTokenClosed = "RequestedTokenCancelled";
        public const string RequestedAttachedReference = "RequestedAttachedReference";
        public const string RequestedUnattachedReference = "RequestedUnattachedReference"; 
        public const string IssuedTokensHeader = "IssuedTokens";
        public const string KeyWrapAlgorithm = "KeyWrapAlgorithm"; 
        public const string BearerKeyType = "http://docs.oasis-open.org/ws-sx/ws-trust/200512/Bearer"; 
        public const string SecondaryParameters = "SecondaryParameters";
        public const string Dialect = "Dialect"; 
        public const string DialectType = "http://schemas.xmlsoap.org/ws/2005/05/identity";
    }

    static class Wsrm11Strings 
    {
        // dictionary strings 
        public const string AckRequestedAction = "http://docs.oasis-open.org/ws-rx/wsrm/200702/AckRequested"; 
        public const string CloseSequence = "CloseSequence";
        public const string CloseSequenceAction = "http://docs.oasis-open.org/ws-rx/wsrm/200702/CloseSequence"; 
        public const string CloseSequenceResponse = "CloseSequenceResponse";
        public const string CloseSequenceResponseAction = "http://docs.oasis-open.org/ws-rx/wsrm/200702/CloseSequenceResponse";
        public const string CreateSequenceAction = "http://docs.oasis-open.org/ws-rx/wsrm/200702/CreateSequence";
        public const string CreateSequenceResponseAction = "http://docs.oasis-open.org/ws-rx/wsrm/200702/CreateSequenceResponse"; 
        public const string DiscardFollowingFirstGap = "DiscardFollowingFirstGap";
        public const string Endpoint = "Endpoint"; 
        public const string FaultAction = "http://docs.oasis-open.org/ws-rx/wsrm/200702/fault"; 
        public const string Final = "Final";
        public const string IncompleteSequenceBehavior = "IncompleteSequenceBehavior"; 
        public const string LastMsgNumber = "LastMsgNumber";
        public const string MaxMessageNumber = "MaxMessageNumber";
        public const string Namespace = "http://docs.oasis-open.org/ws-rx/wsrm/200702";
        public const string NoDiscard = "NoDiscard"; 
        public const string None = "None";
        public const string SequenceAcknowledgementAction = "http://docs.oasis-open.org/ws-rx/wsrm/200702/SequenceAcknowledgement"; 
        public const string SequenceClosed = "SequenceClosed"; 
        public const string TerminateSequenceAction = "http://docs.oasis-open.org/ws-rx/wsrm/200702/TerminateSequence";
        public const string TerminateSequenceResponse = "TerminateSequenceResponse"; 
        public const string TerminateSequenceResponseAction = "http://docs.oasis-open.org/ws-rx/wsrm/200702/TerminateSequenceResponse";
        public const string UsesSequenceSSL = "UsesSequenceSSL";
        public const string UsesSequenceSTR = "UsesSequenceSTR";
        public const string WsrmRequired = "WsrmRequired"; 
        // string constants
        public const string DiscardEntireSequence = "DiscardEntireSequence"; 
    } 
}

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