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

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

namespace System.ServiceModel.Security 
{
    using System.Collections.Generic; 
    using System.ServiceModel.Channels; 
    using System.ServiceModel;
    using System.Runtime.Serialization; 
    using System.ServiceModel.Security;
    using System.Xml;

    public class ScopedMessagePartSpecification 
    {
        MessagePartSpecification channelParts; 
        Dictionary actionParts; 
        Dictionary readOnlyNormalizedActionParts;
        bool isReadOnly; 

        public ScopedMessagePartSpecification()
        {
            this.channelParts = new MessagePartSpecification(); 
            this.actionParts = new Dictionary();
        } 
 
        public ICollection Actions
        { 
            get
            {
                return this.actionParts.Keys;
            } 
        }
 
        public MessagePartSpecification ChannelParts 
        {
            get 
            {
                return this.channelParts;
            }
        } 

        public bool IsReadOnly 
        { 
            get
            { 
                return this.isReadOnly;
            }
        }
 
        public ScopedMessagePartSpecification(ScopedMessagePartSpecification other)
            : this() 
        { 
            if (other == null)
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("other")); 

            this.channelParts.Union(other.channelParts);
            if (other.actionParts != null)
            { 
                foreach (string action in other.actionParts.Keys)
                { 
                    MessagePartSpecification p = new MessagePartSpecification(); 
                    p.Union(other.actionParts[action]);
                    this.actionParts[action] = p; 
                }
            }
        }
 
        internal ScopedMessagePartSpecification(ScopedMessagePartSpecification other, bool newIncludeBody)
            : this(other) 
        { 
            this.channelParts.IsBodyIncluded = newIncludeBody;
            foreach (string action in this.actionParts.Keys) 
                this.actionParts[action].IsBodyIncluded = newIncludeBody;
        }

        public void AddParts(MessagePartSpecification parts) 
        {
            if (parts == null) 
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("parts")); 

            ThrowIfReadOnly(); 

            this.channelParts.Union(parts);
        }
 
        public void AddParts(MessagePartSpecification parts, string action)
        { 
            if (action == null) 
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("action"));
            if (parts == null) 
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("parts"));

            ThrowIfReadOnly();
 
            if (!this.actionParts.ContainsKey(action))
                this.actionParts[action] = new MessagePartSpecification(); 
            this.actionParts[action].Union(parts); 
        }
 
        internal void AddParts(MessagePartSpecification parts, XmlDictionaryString action)
        {
            if (action == null)
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("action")); 
            AddParts(parts, action.Value);
        } 
 
        internal bool IsEmpty()
        { 
            bool result;
            if (!channelParts.IsEmpty())
            {
                result = false; 
            }
            else 
            { 
                result = true;
                foreach (string action in this.Actions) 
                {
                    MessagePartSpecification parts;
                    if (TryGetParts(action, true, out parts))
                    { 
                        if (!parts.IsEmpty())
                        { 
                            result = false; 
                            break;
                        } 
                    }
                }
            }
 
            return result;
        } 
 
        public bool TryGetParts(string action, bool excludeChannelScope, out MessagePartSpecification parts)
        { 
            if (action == null)
                action = MessageHeaders.WildcardAction;
            parts = null;
 
            if (this.isReadOnly)
            { 
                if (this.readOnlyNormalizedActionParts.ContainsKey(action)) 
                    if (excludeChannelScope)
                        parts = this.actionParts[action]; 
                    else
                        parts = this.readOnlyNormalizedActionParts[action];
            }
            else if (this.actionParts.ContainsKey(action)) 
            {
                MessagePartSpecification p = new MessagePartSpecification(); 
                p.Union(this.actionParts[action]); 
                if (!excludeChannelScope)
                    p.Union(this.channelParts); 
                parts = p;
            }

            return parts != null; 
        }
 
        internal void CopyTo(ScopedMessagePartSpecification target) 
        {
            if (target == null) 
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("target");
            }
            target.ChannelParts.IsBodyIncluded = this.ChannelParts.IsBodyIncluded; 
            foreach (XmlQualifiedName headerType in ChannelParts.HeaderTypes)
            { 
                if (!target.channelParts.IsHeaderIncluded(headerType.Name, headerType.Namespace)) 
                {
                    target.ChannelParts.HeaderTypes.Add(headerType); 
                }
            }
            foreach (string action in this.actionParts.Keys)
            { 
                target.AddParts(this.actionParts[action], action);
            } 
        } 

        public bool TryGetParts(string action, out MessagePartSpecification parts) 
        {
            return this.TryGetParts(action, false, out parts);
        }
 
        public void MakeReadOnly()
        { 
            if (!this.isReadOnly) 
            {
                this.readOnlyNormalizedActionParts = new Dictionary(); 
                foreach (string action in this.actionParts.Keys)
                {
                    MessagePartSpecification p = new MessagePartSpecification();
                    p.Union(this.actionParts[action]); 
                    p.Union(this.channelParts);
                    p.MakeReadOnly(); 
                    this.readOnlyNormalizedActionParts[action] = p; 
                }
                this.isReadOnly = true; 
            }
        }

        void ThrowIfReadOnly() 
        {
            if (this.isReadOnly) 
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.ObjectIsReadOnly))); 
        }
    } 
}

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