protected internal override async Task OnOpenAsync(TimeSpan timeout)
            {
                TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);

                EnableChannelBindingSupport();

                SecurityProtocol securityProtocol = SecurityProtocolFactory.CreateSecurityProtocol(
                    RemoteAddress,
                    Via,
                    null,
                    typeof(TChannel) == typeof(IRequestChannel),
                    timeoutHelper.RemainingTime());

                OnProtocolCreationComplete(securityProtocol);
                await SecurityProtocol.OpenAsync(timeoutHelper.RemainingTime());

                await base.OnOpenAsync(timeoutHelper.RemainingTime());
            }
        //Reference OnAcceptChannel/SecurityChannelListner
        private async Task <IServiceChannelDispatcher> GetInnerChannelDispatcherAsync(IChannel outerChannel)
        {
            IServiceChannelDispatcher securityChannelDispatcher = null;
            SecurityProtocol          securityProtocol          = SecurityProtocolFactory.CreateSecurityProtocol(null, null,
                                                                                                                 (outerChannel is IReplyChannel || outerChannel is IReplySessionChannel), TimeSpan.Zero);
            await securityProtocol.OpenAsync(TimeSpan.Zero);

            /* TODO once we add more features
             * if (outerChannel is IInputChannel)
             * {
             *  securityChannel = new SecurityInputChannel(listener, (IInputChannel)innerChannel, securityProtocol, listener.settingsLifetimeManager);
             * }
             * else if (outerChannel is IInputSessionChannel))
             * {
             *  securityChannel = new SecurityInputSessionChannel(listener, (IInputSessionChannel)innerChannel, securityProtocol, listener.settingsLifetimeManager);
             * }
             * else if (outerChannel is IDuplexChannel))
             * {
             *  securityChannel = new SecurityDuplexChannel(listener, (IDuplexChannel)innerChannel, securityProtocol, listener.settingsLifetimeManager);
             * }
             * else if (outerChannel is IDuplexSessionChannel))
             * {
             *  securityChannel = new SecurityDuplexSessionChannel(listener, (IDuplexSessionChannel)innerChannel, securityProtocol, listener.settingsLifetimeManager);
             * }
             * else*/
            if (outerChannel is IReplyChannel replyChannel)
            {
                securityChannelDispatcher = new SecurityReplyChannelDispatcher(this, replyChannel, securityProtocol, _settingsLifetimeManager);
            }

            /* else if (listener.SupportsRequestReply && typeof(TChannel) == typeof(IReplySessionChannel))
             * {
             *   securityChannel = new SecurityReplySessionChannel(listener, (IReplySessionChannel)innerChannel, securityProtocol, listener.settingsLifetimeManager);
             * }
             * else
             * {
             *   throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException(SR.GetString(SR.UnsupportedChannelInterfaceType, typeof(TChannel))));
             * }*/

            return(securityChannelDispatcher);
        }