IssuedTokenClientCredential.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 / IssuedTokenClientCredential.cs / 1 / IssuedTokenClientCredential.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.ServiceModel.Description; 
    using System.ServiceModel.Security.Tokens;

    public sealed class IssuedTokenClientCredential
    { 
        SecurityKeyEntropyMode defaultKeyEntropyMode = AcceleratedTokenProvider.defaultKeyEntropyMode;
        KeyedByTypeCollection localIssuerChannelBehaviors; 
        Dictionary> issuerChannelBehaviors; 
        bool cacheIssuedTokens = SpnegoTokenProvider.defaultClientCacheTokens;
        TimeSpan maxIssuedTokenCachingTime = SpnegoTokenProvider.DefaultClientMaxTokenCachingTime; 
        EndpointAddress localIssuerAddress;
        Binding localIssuerBinding;
        int issuedTokenRenewalThresholdPercentage = AcceleratedTokenProvider.defaultServiceTokenValidityThresholdPercentage;
        bool isReadOnly; 

        internal IssuedTokenClientCredential() 
        { 
        }
 
        internal IssuedTokenClientCredential(IssuedTokenClientCredential other)
        {
            this.defaultKeyEntropyMode = other.defaultKeyEntropyMode;
            this.cacheIssuedTokens = other.cacheIssuedTokens; 
            this.issuedTokenRenewalThresholdPercentage = other.issuedTokenRenewalThresholdPercentage;
            this.maxIssuedTokenCachingTime = other.maxIssuedTokenCachingTime; 
            this.localIssuerAddress = other.localIssuerAddress; 
            this.localIssuerBinding = (other.localIssuerBinding != null) ? new CustomBinding(other.localIssuerBinding) : null;
            if (other.localIssuerChannelBehaviors != null) 
                this.localIssuerChannelBehaviors = GetBehaviorCollection(other.localIssuerChannelBehaviors);
            if (other.issuerChannelBehaviors != null)
            {
                this.issuerChannelBehaviors = new Dictionary>(); 
                foreach (Uri uri in other.issuerChannelBehaviors.Keys)
                { 
                    this.issuerChannelBehaviors.Add(uri, GetBehaviorCollection(other.issuerChannelBehaviors[uri])); 
                }
            } 
            this.isReadOnly = other.isReadOnly;
        }

        public EndpointAddress LocalIssuerAddress 
        {
            get 
            { 
                return this.localIssuerAddress;
            } 
            set
            {
                ThrowIfImmutable();
                this.localIssuerAddress = value; 
            }
        } 
 
        public Binding LocalIssuerBinding
        { 
            get
            {
                return this.localIssuerBinding;
            } 
            set
            { 
                ThrowIfImmutable(); 
                this.localIssuerBinding = value;
            } 
        }

        public SecurityKeyEntropyMode DefaultKeyEntropyMode
        { 
            get
            { 
                return this.defaultKeyEntropyMode; 
            }
            set 
            {
                SecurityKeyEntropyModeHelper.Validate(value);
                ThrowIfImmutable();
                this.defaultKeyEntropyMode = value; 
            }
        } 
 
        public bool CacheIssuedTokens
        { 
            get
            {
                return this.cacheIssuedTokens;
            } 
            set
            { 
                ThrowIfImmutable(); 
                this.cacheIssuedTokens = value;
            } 
        }

        public int IssuedTokenRenewalThresholdPercentage
        { 
            get
            { 
                return this.issuedTokenRenewalThresholdPercentage; 
            }
            set 
            {
                ThrowIfImmutable();
                this.issuedTokenRenewalThresholdPercentage = value;
            } 
        }
 
        public Dictionary> IssuerChannelBehaviors 
        {
            get 
            {
                if (this.issuerChannelBehaviors == null)
                    this.issuerChannelBehaviors = new Dictionary>();
                return this.issuerChannelBehaviors; 
            }
        } 
 
        public KeyedByTypeCollection LocalIssuerChannelBehaviors
        { 
            get
            {
                if (this.localIssuerChannelBehaviors == null)
                    this.localIssuerChannelBehaviors = new KeyedByTypeCollection(); 
                return this.localIssuerChannelBehaviors;
            } 
        } 

        public TimeSpan MaxIssuedTokenCachingTime 
        {
            get
            {
                return this.maxIssuedTokenCachingTime; 
            }
            set 
            { 
                if (value < TimeSpan.Zero)
                { 
                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("value", value,
                        SR.GetString(SR.SFxTimeoutOutOfRange0)));
                }
 
                if (TimeoutHelper.IsTooLarge(value))
                { 
                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("value", value, 
                        SR.GetString(SR.SFxTimeoutOutOfRangeTooBig)));
                } 

                ThrowIfImmutable();
                this.maxIssuedTokenCachingTime = value;
            } 
        }
 
        KeyedByTypeCollection GetBehaviorCollection(KeyedByTypeCollection behaviors) 
        {
            KeyedByTypeCollection result = new KeyedByTypeCollection(); 
            foreach (IEndpointBehavior behavior in behaviors)
            {
                result.Add(behavior);
            } 
            return result;
        } 
 
        internal void MakeReadOnly()
        { 
            this.isReadOnly = true;
        }

        void ThrowIfImmutable() 
        {
            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