DiscoveryClientChannelFactory.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.Discovery / System / ServiceModel / Discovery / DiscoveryClientChannelFactory.cs / 1305376 / DiscoveryClientChannelFactory.cs

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

namespace System.ServiceModel.Discovery 
{
    using System; 
    using System.Runtime; 
    using System.ServiceModel;
    using System.ServiceModel.Channels; 

    class DiscoveryClientChannelFactory : ChannelFactoryBase
    {
        DiscoveryEndpointProvider discoveryEndpointProvider; 
        FindCriteria findCriteria;
 
        IChannelFactory innerChannelFactory; 

        public DiscoveryClientChannelFactory(IChannelFactory innerChannelFactory, FindCriteria findCriteria, DiscoveryEndpointProvider discoveryEndpointProvider) 
        {
            Fx.Assert(findCriteria != null, "The findCriteria must be non null.");
            Fx.Assert(discoveryEndpointProvider != null, "The discoveryEndpointProvider must be non null.");
            Fx.Assert(innerChannelFactory != null, "The innerChannelFactory must be non null."); 

            this.findCriteria = findCriteria; 
            this.discoveryEndpointProvider = discoveryEndpointProvider; 
            this.innerChannelFactory = innerChannelFactory;
        } 

        protected override TChannel OnCreateChannel(EndpointAddress address, Uri via)
        {
            if (!address.Equals(DiscoveryClientBindingElement.DiscoveryEndpointAddress)) 
            {
                throw FxTrace.Exception.Argument( 
                    "address", 
                    Discovery.SR.DiscoveryEndpointAddressIncorrect("address", address.Uri, DiscoveryClientBindingElement.DiscoveryEndpointAddress.Uri));
            } 

            if (!via.Equals(DiscoveryClientBindingElement.DiscoveryEndpointAddress.Uri))
            {
                throw FxTrace.Exception.Argument( 
                    "via",
                    Discovery.SR.DiscoveryEndpointAddressIncorrect("via", via, DiscoveryClientBindingElement.DiscoveryEndpointAddress.Uri)); 
            } 

            if (typeof(TChannel) == typeof(IOutputChannel)) 
            {
                return (TChannel)(object)new DiscoveryClientOutputChannel(
                    this,
                    (IChannelFactory)this.innerChannelFactory, 
                    this.findCriteria,
                    this.discoveryEndpointProvider); 
            } 
            else if (typeof(TChannel) == typeof(IRequestChannel))
            { 
                return (TChannel)(object)new DiscoveryClientRequestChannel(
                    this,
                    (IChannelFactory)this.innerChannelFactory,
                    this.findCriteria, 
                    this.discoveryEndpointProvider);
            } 
            else if (typeof(TChannel) == typeof(IDuplexChannel)) 
            {
                return (TChannel)(object)new DiscoveryClientDuplexChannel( 
                    this,
                    (IChannelFactory)this.innerChannelFactory,
                    this.findCriteria,
                    this.discoveryEndpointProvider); 
            }
            else if (typeof(TChannel) == typeof(IOutputSessionChannel)) 
            { 
                return (TChannel)(object)new DiscoveryClientOutputSessionChannel(
                    this, 
                    (IChannelFactory)this.innerChannelFactory,
                    this.findCriteria,
                    this.discoveryEndpointProvider);
            } 
            else if (typeof(TChannel) == typeof(IRequestSessionChannel))
            { 
                return (TChannel)(object)new DiscoveryClientRequestSessionChannel( 
                    this,
                    (IChannelFactory)this.innerChannelFactory, 
                    this.findCriteria,
                    this.discoveryEndpointProvider);
            }
            else if (typeof(TChannel) == typeof(IDuplexSessionChannel)) 
            {
                return (TChannel)(object)new DiscoveryClientDuplexSessionChannel( 
                    this, 
                    (IChannelFactory)this.innerChannelFactory,
                    this.findCriteria, 
                    this.discoveryEndpointProvider);
            }

            throw FxTrace.Exception.Argument("TChannel", ServiceModel.SR.GetString(ServiceModel.SR.ChannelTypeNotSupported, typeof(TChannel))); 
        }
 
        public override T GetProperty() 
        {
            if (typeof(T) == typeof(IChannelFactory)) 
            {
                return (T)(object)this;
            }
 
            T baseProperty = base.GetProperty();
            if (baseProperty != null) 
            { 
                return baseProperty;
            } 

            return this.innerChannelFactory.GetProperty();
        }
 
        protected override IAsyncResult OnBeginOpen(TimeSpan timeout, AsyncCallback callback, object state)
        { 
            return this.innerChannelFactory.BeginOpen(timeout, callback, state); 
        }
 
        protected override void OnEndOpen(IAsyncResult result)
        {
            this.innerChannelFactory.EndOpen(result);
        } 

        protected override void OnOpen(TimeSpan timeout) 
        { 
            this.innerChannelFactory.Open(timeout);
        } 

        protected override IAsyncResult OnBeginClose(TimeSpan timeout, AsyncCallback callback, object state)
        {
            // Must close higher channels before closing lower channels. 
            return new ChainedAsyncResult(
                timeout, 
                callback, 
                state,
                base.OnBeginClose, 
                base.OnEndClose,
                this.innerChannelFactory.BeginClose,
                this.innerChannelFactory.EndClose);
        } 

        protected override void OnEndClose(IAsyncResult result) 
        { 
            ChainedAsyncResult.End(result);
        } 

        protected override void OnClose(TimeSpan timeout)
        {
            // Must close higher channels before closing lower channels. 
            TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
            base.OnClose(timeoutHelper.RemainingTime()); 
            this.innerChannelFactory.Close(timeoutHelper.RemainingTime()); 
        }
 
        protected override void OnAbort()
        {
            // Must abort higher channels before aborting lower channels.
            base.OnAbort(); 
            this.innerChannelFactory.Abort();
        } 
    } 
}

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