internal bool AcquireSession(ListenerHandler listener)
 {
     lock (this.ThisLock)
     {
         return this.PrivateAcquireSessionListenerHandler(listener);
     }
 }
 internal ChannelHandler(ChannelHandler handler, TransactedBatchContext context)
 {
     this.messageVersion = handler.messageVersion;
     this.isManualAddressing = handler.isManualAddressing;
     this.binder = handler.binder;
     this.listener = handler.listener;
     this.wasChannelThrottled = handler.wasChannelThrottled;
     this.host = handler.host;
     this.receiveSynchronously = true;
     this.receiveWithTransaction = true;
     this.duplexBinder = handler.duplexBinder;
     this.hasSession = handler.hasSession;
     this.isConcurrent = handler.isConcurrent;
     this.receiver = handler.receiver;
     this.sharedTransactedBatchContext = context.Shared;
     this.transactedBatchContext = context;
     this.requestInfo = new RequestInfo(this);
 }
        internal ChannelHandler(MessageVersion messageVersion, IChannelBinder binder,
            ListenerHandler listener, SessionIdleManager idleManager)
        {
            ChannelDispatcher channelDispatcher = listener.ChannelDispatcher;

            _messageVersion = messageVersion;
            _isManualAddressing = channelDispatcher.ManualAddressing;
            _binder = binder;
            _listener = listener;

            _receiveSynchronously = channelDispatcher.ReceiveSynchronously;
            _sendAsynchronously = channelDispatcher.SendAsynchronously;
            _duplexBinder = binder as DuplexChannelBinder;
            _hasSession = binder.HasSession;
            _isConcurrent = ConcurrencyBehavior.IsConcurrent(channelDispatcher, _hasSession);

            if (channelDispatcher.MaxPendingReceives > 1)
            {
                throw NotImplemented.ByDesign;
            }

            if (channelDispatcher.BufferedReceiveEnabled)
            {
                _binder = new BufferedReceiveBinder(_binder);
            }

            _receiver = new ErrorHandlingReceiver(_binder, channelDispatcher);
            _idleManager = idleManager;
            Fx.Assert((_idleManager != null) == (_binder.HasSession && _listener.ChannelDispatcher.DefaultCommunicationTimeouts.ReceiveTimeout != TimeSpan.MaxValue), "idle manager is present only when there is a session with a finite receive timeout");

            _requestInfo = new RequestInfo(this);

            if (_listener.State == CommunicationState.Opened)
            {
                _listener.ChannelDispatcher.Channels.IncrementActivityCount();
                _incrementedActivityCountInConstructor = true;
            }
        }
        internal ChannelHandler(MessageVersion messageVersion, IChannelBinder binder, ServiceThrottle throttle,
            ListenerHandler listener, bool wasChannelThrottled, WrappedTransaction acceptTransaction, SessionIdleManager idleManager)
        {
            ChannelDispatcher channelDispatcher = listener.ChannelDispatcher;

            this.messageVersion = messageVersion;
            this.isManualAddressing = channelDispatcher.ManualAddressing;
            this.binder = binder;
            this.throttle = throttle;
            this.listener = listener;
            this.wasChannelThrottled = wasChannelThrottled;

            this.host = listener.Host;
            this.receiveSynchronously = channelDispatcher.ReceiveSynchronously;
            this.sendAsynchronously = channelDispatcher.SendAsynchronously;
            this.duplexBinder = binder as DuplexChannelBinder;
            this.hasSession = binder.HasSession;
            this.isConcurrent = ConcurrencyBehavior.IsConcurrent(channelDispatcher, this.hasSession);

            if (channelDispatcher.MaxPendingReceives > 1)
            {
                // We need to preserve order if the ChannelHandler is not concurrent.
                this.binder = new MultipleReceiveBinder(
                    this.binder,
                    channelDispatcher.MaxPendingReceives,
                    !this.isConcurrent);
            }

            if (channelDispatcher.BufferedReceiveEnabled)
            {
                this.binder = new BufferedReceiveBinder(this.binder);
            }

            this.receiver = new ErrorHandlingReceiver(this.binder, channelDispatcher);
            this.idleManager = idleManager;
            Fx.Assert((this.idleManager != null) == (this.binder.HasSession && this.listener.ChannelDispatcher.DefaultCommunicationTimeouts.ReceiveTimeout != TimeSpan.MaxValue), "idle manager is present only when there is a session with a finite receive timeout");

            if (channelDispatcher.IsTransactedReceive && !channelDispatcher.ReceiveContextEnabled)
            {
                receiveSynchronously = true;
                receiveWithTransaction = true;

                if (channelDispatcher.MaxTransactedBatchSize > 0)
                {
                    int maxConcurrentBatches = 1;
                    if (null != throttle && throttle.MaxConcurrentCalls > 1)
                    {
                        maxConcurrentBatches = throttle.MaxConcurrentCalls;
                        foreach (EndpointDispatcher endpointDispatcher in channelDispatcher.Endpoints)
                        {
                            if (ConcurrencyMode.Multiple != endpointDispatcher.DispatchRuntime.ConcurrencyMode)
                            {
                                maxConcurrentBatches = 1;
                                break;
                            }
                        }
                    }

                    this.sharedTransactedBatchContext = new SharedTransactedBatchContext(this, channelDispatcher, maxConcurrentBatches);
                    this.isMainTransactedBatchHandler = true;
                    this.throttle = null;
                }
            }
            else if (channelDispatcher.IsTransactedReceive && channelDispatcher.ReceiveContextEnabled && channelDispatcher.MaxTransactedBatchSize > 0)
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.IncompatibleBehaviors)));
            }

            if (this.binder.HasSession)
            {
                this.sessionOpenNotification = this.binder.Channel.GetProperty<SessionOpenNotification>();
                this.needToCreateSessionOpenNotificationMessage = this.sessionOpenNotification != null && this.sessionOpenNotification.IsEnabled;
            }

            this.acceptTransaction = acceptTransaction;
            this.requestInfo = new RequestInfo(this);

            if (this.listener.State == CommunicationState.Opened)
            {
                this.listener.ChannelDispatcher.Channels.IncrementActivityCount();
                this.incrementedActivityCountInConstructor = true;
            }
        }
        internal ChannelHandler(ChannelHandler handler, TransactedBatchContext context)
        {
            this.messageVersion = handler.messageVersion;
            this.isManualAddressing = handler.isManualAddressing;
            this.binder = handler.binder;
            this.listener = handler.listener;
            this.wasChannelThrottled = handler.wasChannelThrottled;

            this.host = handler.host;
            this.receiveSynchronously = true;
            this.receiveWithTransaction = true;
            this.duplexBinder = handler.duplexBinder;
            this.hasSession = handler.hasSession;
            this.isConcurrent = handler.isConcurrent;
            this.receiver = handler.receiver;

            this.sharedTransactedBatchContext = context.Shared;
            this.transactedBatchContext = context;
            this.requestInfo = new RequestInfo(this);

            this.sendAsynchronously = handler.sendAsynchronously;
            this.sessionOpenNotification = handler.sessionOpenNotification;
            this.needToCreateSessionOpenNotificationMessage = handler.needToCreateSessionOpenNotificationMessage;
            this.shouldRejectMessageWithOnOpenActionHeader = handler.shouldRejectMessageWithOnOpenActionHeader;
        }
 bool PrivateAcquireSessionListenerHandler(ListenerHandler listener)
 {
     if ((this.sessions != null) && (listener.Channel != null) && (listener.Channel.Throttle == null))
     {
         listener.Channel.Throttle = this;
         return this.sessions.Acquire(listener);
     }
     else
     {
         return true;
     }
 }
 internal ChannelHandler(MessageVersion messageVersion, IChannelBinder binder, ServiceThrottle throttle, ListenerHandler listener, bool wasChannelThrottled, WrappedTransaction acceptTransaction, ServiceChannel.SessionIdleManager idleManager)
 {
     ChannelDispatcher channelDispatcher = listener.ChannelDispatcher;
     this.messageVersion = messageVersion;
     this.isManualAddressing = channelDispatcher.ManualAddressing;
     this.binder = binder;
     this.throttle = throttle;
     this.listener = listener;
     this.wasChannelThrottled = wasChannelThrottled;
     this.host = listener.Host;
     this.receiveSynchronously = channelDispatcher.ReceiveSynchronously;
     this.duplexBinder = binder as DuplexChannelBinder;
     this.hasSession = binder.HasSession;
     this.isConcurrent = ConcurrencyBehavior.IsConcurrent(channelDispatcher, this.hasSession);
     if (channelDispatcher.MaxPendingReceives > 1)
     {
         this.binder = new MultipleReceiveBinder(this.binder, channelDispatcher.MaxPendingReceives, !this.isConcurrent);
     }
     if (channelDispatcher.BufferedReceiveEnabled)
     {
         this.binder = new BufferedReceiveBinder(this.binder);
     }
     this.receiver = new ErrorHandlingReceiver(this.binder, channelDispatcher);
     this.idleManager = idleManager;
     if (!channelDispatcher.IsTransactedReceive || channelDispatcher.ReceiveContextEnabled)
     {
         if ((channelDispatcher.IsTransactedReceive && channelDispatcher.ReceiveContextEnabled) && (channelDispatcher.MaxTransactedBatchSize > 0))
         {
             throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(System.ServiceModel.SR.GetString("IncompatibleBehaviors")));
         }
     }
     else
     {
         this.receiveSynchronously = true;
         this.receiveWithTransaction = true;
         if (channelDispatcher.MaxTransactedBatchSize > 0)
         {
             int maxConcurrentBatches = 1;
             if ((throttle != null) && (throttle.MaxConcurrentCalls > 1))
             {
                 maxConcurrentBatches = throttle.MaxConcurrentCalls;
                 foreach (EndpointDispatcher dispatcher2 in channelDispatcher.Endpoints)
                 {
                     if (ConcurrencyMode.Multiple != dispatcher2.DispatchRuntime.ConcurrencyMode)
                     {
                         maxConcurrentBatches = 1;
                         break;
                     }
                 }
             }
             this.sharedTransactedBatchContext = new SharedTransactedBatchContext(this, channelDispatcher, maxConcurrentBatches);
             this.isMainTransactedBatchHandler = true;
             this.throttle = null;
         }
     }
     this.acceptTransaction = acceptTransaction;
     this.requestInfo = new RequestInfo(this);
     if (!this.hasSession && (this.listener.State == CommunicationState.Opened))
     {
         this.listener.ChannelDispatcher.Channels.IncrementActivityCount();
         this.incrementedActivityCountInConstructor = true;
     }
 }
Esempio n. 8
0
 internal CloseChannelState(ListenerHandler listenerHandler, IChannel channel)
 {
     _listenerHandler = listenerHandler;
     _channel = channel;
 }
 internal CloseChannelState(ListenerHandler listenerHandler, IChannel channel)
 {
     this.listenerHandler = listenerHandler;
     this.channel = channel;
 }