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

                            //------------------------------------------------------------ 
// Copyright (c) Microsoft Corporation.  All rights reserved.
//-----------------------------------------------------------
namespace System.ServiceModel.Channels
{ 
    using System;
    using System.Collections.Generic; 
    using System.ServiceModel.Diagnostics; 
    using System.Threading;
 
    abstract class DeliveryStrategy : IDisposable
        where ItemType : class, IDisposable
    {
        InputQueueChannel channel; 
        ItemDequeuedCallback dequeueCallback;
        int quota; 
 
        public DeliveryStrategy(InputQueueChannel channel, int quota)
        { 
            if (quota <= 0)
            {
                DiagnosticUtility.DebugAssert("Argument quota must be positive.");
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperInternal(false); 
            }
 
            this.channel = channel; 
            this.quota = quota;
        } 

        protected InputQueueChannel Channel
        {
            get 
            {
                return this.channel; 
            } 
        }
 
        public ItemDequeuedCallback DequeueCallback
        {
            get
            { 
                return this.dequeueCallback;
            } 
            set 
            {
                this.dequeueCallback = value; 
            }
        }

        public abstract int EnqueuedCount 
        {
            get; 
        } 

        protected int Quota 
        {
            get
            {
                return this.quota; 
            }
        } 
 
        public abstract bool CanEnqueue(Int64 sequenceNumber);
 
        public virtual void Dispose()
        {
        }
 
        public abstract bool Enqueue(ItemType item, Int64 sequenceNumber);
    } 
 
    class OrderedDeliveryStrategy : DeliveryStrategy
        where ItemType : class, IDisposable 
    {
        bool isEnqueueInOrder;
        Dictionary items;
        WaitCallback onDispatchCallback; 
        Int64 windowStart;
 
        public OrderedDeliveryStrategy( 
            InputQueueChannel channel,
            int quota, 
            bool isEnqueueInOrder)
            : base(channel, quota)
        {
            this.isEnqueueInOrder = isEnqueueInOrder; 
            this.items = new Dictionary();
            this.windowStart = 1; 
        } 

        public override int EnqueuedCount 
        {
            get
            {
                return this.Channel.InternalPendingItems + this.items.Count; 
            }
        } 
 
        WaitCallback OnDispatchCallback
        { 
            get
            {
                if (this.onDispatchCallback == null)
                { 
                    this.onDispatchCallback = this.OnDispatch;
                } 
 
                return this.onDispatchCallback;
            } 
        }

        public override bool CanEnqueue(long sequenceNumber)
        { 
            if (this.EnqueuedCount >= this.Quota)
            { 
                return false; 
            }
 
            if (this.isEnqueueInOrder && (sequenceNumber > this.windowStart))
            {
                return false;
            } 

            return (this.Channel.InternalPendingItems + sequenceNumber - this.windowStart < this.Quota); 
        } 

        public override bool Enqueue(ItemType item, long sequenceNumber) 
        {
            if (sequenceNumber > this.windowStart)
            {
                this.items.Add(sequenceNumber, item); 
                return false;
            } 
 
            this.windowStart++;
 
            while (this.items.ContainsKey(this.windowStart))
            {
                if (this.Channel.EnqueueWithoutDispatch(item, this.DequeueCallback))
                { 
                    IOThreadScheduler.ScheduleCallback(this.OnDispatchCallback, null);
                } 
 
                item = this.items[this.windowStart];
                this.items.Remove(this.windowStart); 
                this.windowStart++;
            }

            return this.Channel.EnqueueWithoutDispatch(item, this.DequeueCallback); 
        }
 
        static void DisposeItems(Dictionary.Enumerator items) 
        {
            if (items.MoveNext()) 
            {
                using (ItemType item = items.Current.Value)
                {
                    DisposeItems(items); 
                }
            } 
        } 

        public override void Dispose() 
        {
            DisposeItems(this.items.GetEnumerator());
            this.items.Clear();
 
            base.Dispose();
        } 
 
        void OnDispatch(object state)
        { 
            this.Channel.Dispatch();
        }
    }
 
    class UnorderedDeliveryStrategy : DeliveryStrategy
        where ItemType : class, IDisposable 
    { 
        public UnorderedDeliveryStrategy(InputQueueChannel channel, int quota)
            : base(channel, quota) 
        {
        }

        public override int EnqueuedCount 
        {
            get 
            { 
                return this.Channel.InternalPendingItems;
            } 
        }

        public override bool CanEnqueue(Int64 sequenceNumber)
        { 
            return (this.EnqueuedCount < this.Quota);
        } 
 
        public override bool Enqueue(ItemType item, long sequenceNumber)
        { 
            return this.Channel.EnqueueWithoutDispatch(item, this.DequeueCallback);
        }
    }
} 

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