SessionChannels.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / cdf / src / NetFx40 / System.ServiceModel.Routing / System / ServiceModel / Routing / SessionChannels.cs / 1305376 / SessionChannels.cs

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

namespace System.ServiceModel.Routing 
{
    using System; 
    using System.Diagnostics.CodeAnalysis; 
    using System.Collections.Generic;
    using System.Runtime; 
    using System.ServiceModel.Description;
    using System.ServiceModel.Channels;
    using System.ComponentModel;
    using System.Threading; 

    class SessionChannels 
    { 
        Guid activityID;
        [Fx.Tag.SynchronizationObject] 
        Dictionary sessions;
        List sessionList;

        [SuppressMessage(FxCop.Category.Performance, FxCop.Rule.AvoidUncalledPrivateCode, Justification = "gets called in RoutingService.ctor()")] 
        public SessionChannels(Guid activityID)
        { 
            this.activityID = activityID; 
            this.sessions = new Dictionary();
            this.sessionList = new List(); 
        }

        void ChannelFaulted(object sender, EventArgs args)
        { 
            FxTrace.Trace.SetAndTraceTransfer(this.activityID, true);
            IRoutingClient client = (IRoutingClient)sender; 
            if (TD.RoutingServiceChannelFaultedIsEnabled()) 
            {
                TD.RoutingServiceChannelFaulted(client.Key.ToString()); 
            }
            this.AbortChannel(client.Key);
        }
 
        [SuppressMessage(FxCop.Category.Performance, FxCop.Rule.AvoidUncalledPrivateCode, Justification = "BeginClose is called by RoutingChannelExtension.AttachService")]
        public IAsyncResult BeginClose(TimeSpan timeout, AsyncCallback callback, object state) 
        { 
            List localClients = null;
 
            lock(this.sessions)
            {
                if (this.sessions.Count > 0)
                { 
                    localClients = this.sessionList.ConvertAll((client) => (ICommunicationObject)client);
                    this.sessionList.Clear(); 
                    this.sessions.Clear(); 
                }
            } 

            if (localClients != null && localClients.Count > 0)
            {
                localClients.ForEach((client) => 
                {
                    if (TD.RoutingServiceClosingClientIsEnabled()) 
                    { 
                        TD.RoutingServiceClosingClient(((IRoutingClient)client).Key.ToString());
                    } 
                });
                return new CloseCollectionAsyncResult(timeout, callback, state, localClients);
            }
            else 
            {
                return new CompletedAsyncResult(callback, state); 
            } 
        }
 
        public void EndClose(IAsyncResult asyncResult)
        {
            if (asyncResult is CloseCollectionAsyncResult)
            { 
                CloseCollectionAsyncResult.End(asyncResult);
            } 
            else 
            {
                CompletedAsyncResult.End(asyncResult); 
            }
        }

        internal IRoutingClient GetOrCreateClient(RoutingEndpointTrait key, RoutingService service, bool impersonating) 
        {
            IRoutingClient value; 
            lock (this.sessions) 
            {
                if (!this.sessions.TryGetValue(key, out value)) 
                {
                    //Create the client here
                    value = ClientFactory.Create(key, service, impersonating);
                    value.Faulted += ChannelFaulted; 
                    this.sessions[key] = value;
                    sessionList.Add(value); 
                } 
            }
            return value; 
        }

        public void AbortAll()
        { 
            List clients = new List();
 
            lock (this.sessions) 
            {
                foreach (IRoutingClient client in this.sessions.Values) 
                {
                    clients.Add(client);
                }
                this.sessions.Clear(); 
                this.sessionList.Clear();
            } 
 
            foreach (IRoutingClient client in clients)
            { 
                RoutingUtilities.Abort((ICommunicationObject)client, client.Key);
            }
        }
 
        public void AbortChannel(RoutingEndpointTrait key)
        { 
            IRoutingClient client; 
            lock (this.sessions)
            { 
                if (this.sessions.TryGetValue(key, out client))
                {
                    this.sessions.Remove(key);
                    this.sessionList.Remove(client); 
                }
            } 
 
            if (client != null)
            { 
                RoutingUtilities.Abort((ICommunicationObject)client, client.Key);
            }
        }
 
        public IRoutingClient ReleaseChannel()
        { 
            IRoutingClient client = null; 
            lock (this.sessions)
            { 
                int count = this.sessionList.Count;
                if (count > 0)
                {
                    client = this.sessionList[count - 1]; 
                    this.sessionList.RemoveAt(count - 1);
                    this.sessions.Remove(client.Key); 
                } 
            }
            return client; 
        }
    }
}

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
                        

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