public virtual void ApplyConfiguration(BindingElement bindingElement)
 {
     if (bindingElement == null)
     {
         throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("bindingElement");
     }
 }

 public override void ApplyConfiguration(BindingElement bindingElement)
 {
     base.ApplyConfiguration(bindingElement);
     System.ServiceModel.Channels.MsmqBindingElementBase base2 = bindingElement as System.ServiceModel.Channels.MsmqBindingElementBase;
     if (base2 != null)
     {
         if (null != this.CustomDeadLetterQueue)
         {
             base2.CustomDeadLetterQueue = this.CustomDeadLetterQueue;
         }
         base2.DeadLetterQueue = this.DeadLetterQueue;
         base2.Durable = this.Durable;
         base2.ExactlyOnce = this.ExactlyOnce;
         base2.MaxRetryCycles = this.MaxRetryCycles;
         base2.ReceiveContextEnabled = this.ReceiveContextEnabled;
         base2.ReceiveErrorHandling = this.ReceiveErrorHandling;
         base2.ReceiveRetryCount = this.ReceiveRetryCount;
         base2.RetryCycleDelay = this.RetryCycleDelay;
         base2.TimeToLive = this.TimeToLive;
         base2.UseSourceJournal = this.UseSourceJournal;
         base2.UseMsmqTracing = this.UseMsmqTracing;
         base2.ValidityDuration = this.ValidityDuration;
         this.MsmqTransportSecurity.ApplyConfiguration(base2.MsmqTransportSecurity);
     }
 }

        public override void ApplyConfiguration(BindingElement bindingElement)
        {
            base.ApplyConfiguration(bindingElement);

            Msmq.MsmqIntegrationBindingElement binding = bindingElement as Msmq.MsmqIntegrationBindingElement;
            binding.SerializationFormat = this.SerializationFormat;
        }

        /// <summary>
        /// Applies the content of a specified binding element to this binding configuration element.
        /// </summary>
        /// <param name="bindingElement">A binding element.</param>
        /// <exception cref="T:System.ArgumentNullException">
        /// 	<paramref name="bindingElement"/> is null.</exception>
        public override void ApplyConfiguration(BindingElement bindingElement)
        {
            base.ApplyConfiguration(bindingElement);

            var binding = (GzipMessageEncodingBindingElement)bindingElement;

            //TODO: Enable to be able to choose inner encoder
            //var propertyInfo = ElementInformation.Properties;
            //if (propertyInfo["innerMessageEncoding"].ValueOrigin != PropertyValueOrigin.Default)
            //{
            //    switch (this.InnerMessageEncoding)
            //    {
            //        case "binary":
            //            binding.InnerMessageEncodingBindingElement = new BinaryMessageEncodingBindingElement();
            //            break;
            //        default:
            //            binding.InnerMessageEncodingBindingElement = new TextMessageEncodingBindingElement();
            //            break;
            //    }
            //}

            //Set Reader Quotas
            if (ReaderQuotas.ElementInformation.IsPresent)
            {
                XmlDictionaryReaderQuotasElement elementQuotas = ReaderQuotas;
                XmlDictionaryReaderQuotas bindingQuotas = binding.ReaderQuotas;
                if (elementQuotas.MaxArrayLength != 0) bindingQuotas.MaxArrayLength = elementQuotas.MaxArrayLength;
                if (elementQuotas.MaxBytesPerRead != 0) bindingQuotas.MaxBytesPerRead = elementQuotas.MaxBytesPerRead;
                if (elementQuotas.MaxDepth != 0) bindingQuotas.MaxDepth = elementQuotas.MaxDepth;
                if (elementQuotas.MaxNameTableCharCount != 0) bindingQuotas.MaxNameTableCharCount = elementQuotas.MaxNameTableCharCount;
                if (elementQuotas.MaxStringContentLength != 0) bindingQuotas.MaxStringContentLength = elementQuotas.MaxStringContentLength;
            }
        }

 protected internal override void InitializeFrom(BindingElement bindingElement)
 {
     base.InitializeFrom(bindingElement);
     PrivacyNoticeBindingElement element = (PrivacyNoticeBindingElement) bindingElement;
     this.Url = element.Url;
     this.Version = element.Version;
 }

 protected internal override void InitializeFrom(BindingElement bindingElement)
 {
     base.InitializeFrom(bindingElement);
     System.ServiceModel.Channels.MsmqBindingElementBase base2 = bindingElement as System.ServiceModel.Channels.MsmqBindingElementBase;
     if (base2 != null)
     {
         if (null != base2.CustomDeadLetterQueue)
         {
             this.CustomDeadLetterQueue = base2.CustomDeadLetterQueue;
         }
         this.DeadLetterQueue = base2.DeadLetterQueue;
         this.Durable = base2.Durable;
         this.ExactlyOnce = base2.ExactlyOnce;
         this.MaxRetryCycles = base2.MaxRetryCycles;
         this.ReceiveErrorHandling = base2.ReceiveErrorHandling;
         this.ReceiveRetryCount = base2.ReceiveRetryCount;
         this.RetryCycleDelay = base2.RetryCycleDelay;
         this.TimeToLive = base2.TimeToLive;
         this.UseSourceJournal = base2.UseSourceJournal;
         if (!base2.ReceiveContextEnabled)
         {
             this.ReceiveContextEnabled = base2.ReceiveContextEnabled;
         }
         this.UseMsmqTracing = base2.UseMsmqTracing;
         if (base2.ValidityDuration != MsmqDefaults.ValidityDuration)
         {
             this.ValidityDuration = base2.ValidityDuration;
         }
         this.MsmqTransportSecurity.InitializeFrom(base2.MsmqTransportSecurity);
     }
 }

        static void Main(string[] args)
        {
            try
            {
                BindingElement[] bindingElements = new BindingElement[2];
                bindingElements[0] = new TextMessageEncodingBindingElement();
                bindingElements[1] = new HttpTransportBindingElement();

                CustomBinding binding = new CustomBinding(bindingElements);
                using (Message message = Message.CreateMessage(binding.MessageVersion, "sendMessage", "Message Body"))
                {
                    IChannelFactory<IRequestChannel> factory = binding.BuildChannelFactory<IRequestChannel>(new BindingParameterCollection());
                    factory.Open();

                    IRequestChannel requestChannel = factory.CreateChannel(new EndpointAddress("http://localhost:9090/RequestReplyService"));
                    requestChannel.Open();
                    Message response = requestChannel.Request(message);

                    Console.WriteLine("Successful send message!");

                    Console.WriteLine("Receive a return message, action: {0}, body: {1}", response.Headers.Action, response.GetBody<String>());
                    requestChannel.Close();
                    factory.Close();
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.ToString());
            }
            finally {
                Console.Read();
            }
        }

        bool TryCreateMatchingExtension(BindingElement bindingElement, ExtensionElementCollection collection, bool allowDerivedTypes, string assemblyName, out BindingElementExtensionElement result)
        {
            result = null;
            foreach (ExtensionElement element in collection)
            {
                BindingElementExtensionElement bindingElementExtension = Activator.CreateInstance(Type.GetType(element.Type, true)) as BindingElementExtensionElement;
                if (null == bindingElementExtension)
                {
                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ConfigurationErrorsException(SR.GetString(SR.ConfigInvalidExtensionType,
                        element.Type,
                        assemblyName,
                        ConfigurationStrings.BindingElementExtensions)));
                }

                bool isMatch;
                if (allowDerivedTypes)
                {
                    isMatch = bindingElementExtension.BindingElementType.IsAssignableFrom(bindingElement.GetType());
                }
                else
                {
                    isMatch = bindingElementExtension.BindingElementType.Equals(bindingElement.GetType());
                }

                if (isMatch)
                {
                    result = bindingElementExtension;
                    return true;
                }
            }
            return false;
        }

 protected internal override void InitializeFrom(BindingElement bindingElement)
 {
     base.InitializeFrom(bindingElement);
     WindowsStreamSecurityBindingElement windowsBindingElement
         = (WindowsStreamSecurityBindingElement)bindingElement;
     SetPropertyValueIfNotDefaultValue(ConfigurationStrings.ProtectionLevel, windowsBindingElement.ProtectionLevel);
 }

 public override void ApplyConfiguration(BindingElement bindingElement)
 {
     base.ApplyConfiguration(bindingElement);
     PrivacyNoticeBindingElement binding = (PrivacyNoticeBindingElement)bindingElement;
     binding.Url = this.Url;
     binding.Version = this.Version;
 }

        protected internal override void InitializeFrom(BindingElement bindingElement)
        {
            base.InitializeFrom(bindingElement);
            ByteStreamMessageEncodingBindingElement element = (ByteStreamMessageEncodingBindingElement)bindingElement;

            this.InitializeFrom(element.ReaderQuotas);
        }

        protected override void InitializeFrom(BindingElement bindingElement)
        {
            base.InitializeFrom(bindingElement);
            MakeConnectionBindingElement element = (MakeConnectionBindingElement)bindingElement;

            this.InitializeFrom(element);
        }

        public override void ApplyConfiguration(BindingElement bindingElement)
        {
            base.ApplyConfiguration(bindingElement);
            ByteStreamMessageEncodingBindingElement binding = (ByteStreamMessageEncodingBindingElement)bindingElement;

            this.ApplyConfiguration(binding.ReaderQuotas);
        }

 public override void ApplyConfiguration(BindingElement bindingElement)
 {
     base.ApplyConfiguration(bindingElement);
     SslStreamSecurityBindingElement sslBindingElement = 
         (SslStreamSecurityBindingElement)bindingElement;
     sslBindingElement.RequireClientCertificate = this.RequireClientCertificate;
 }

        public override void ApplyConfiguration(BindingElement bindingElement)
        {
            base.ApplyConfiguration(bindingElement);
            MakeConnectionBindingElement binding = (MakeConnectionBindingElement)bindingElement;

            this.ApplyConfiguration(binding);
        }

        private BindingElement Transform(BindingElement original)
        {
            if (original is MessageEncodingBindingElement)
                return new BinaryMessageEncodingBindingElement();

            return original;
        }

 public override void ApplyConfiguration(BindingElement bindingElement)
 {
     base.ApplyConfiguration(bindingElement);
     WindowsStreamSecurityBindingElement windowsBindingElement =
         (WindowsStreamSecurityBindingElement)bindingElement;
     windowsBindingElement.ProtectionLevel = this.ProtectionLevel;
 }

 protected internal override void InitializeFrom(BindingElement bindingElement)
 {
     base.InitializeFrom(bindingElement);
     PrivacyNoticeBindingElement binding = (PrivacyNoticeBindingElement)bindingElement;
     SetPropertyValueIfNotDefaultValue(ConfigurationStrings.Url, binding.Url);
     SetPropertyValueIfNotDefaultValue(ConfigurationStrings.Version, binding.Version);
 }

 protected override void InitializeFrom(BindingElement bindingElement)
 {
     base.InitializeFrom(bindingElement);
     var element = (CompressionBindingElement) bindingElement;
     Level = element.Level;
     Algorithm = element.Algorithm;
 }

        static void Main(string[] args)
        {
            try {
                BindingElement[] bindingElements = new BindingElement[2];
                bindingElements[0] = new TextMessageEncodingBindingElement();
                bindingElements[1] = new HttpTransportBindingElement();

                CustomBinding binding = new CustomBinding(bindingElements);

                IChannelListener<IReplyChannel> listener=binding.BuildChannelListener<IReplyChannel>(new Uri("http://localhost:9090/RequestReplyService"),new BindingParameterCollection());
                listener.Open();

                IReplyChannel replyChannel = listener.AcceptChannel();
                replyChannel.Open();
                Console.WriteLine("starting to receive message....");

                RequestContext requestContext = replyChannel.ReceiveRequest();
                Console.WriteLine("Received a Message, action:{0},body:{1}", requestContext.RequestMessage.Headers.Action,
                                    requestContext.RequestMessage.GetBody<string>());
                Message message = Message.CreateMessage(binding.MessageVersion, "response", "response Message");
                requestContext.Reply(message);

                requestContext.Close();
                replyChannel.Close();
                listener.Close();

            }
            catch (Exception ex) {
                Console.WriteLine(ex.ToString());
            }
            finally {
                Console.Read();
            }
        }