C# BindingParameterCollection.Add方法代码示例

        public void AddBindingParameters(OperationDescription description, BindingParameterCollection parameters)
        {
            //see if ChunkingBindingParameter already exists
            ChunkingBindingParameter param =
                parameters.Find<ChunkingBindingParameter>();
            if (param == null)
            {
                param = new ChunkingBindingParameter();
                parameters.Add(param);
            }

            if ((appliesTo & ChunkingAppliesTo.InMessage)
                          == ChunkingAppliesTo.InMessage)
            {
                //add input message's action to ChunkingBindingParameter
                param.AddAction(description.Messages[0].Action);
            }
            if (!description.IsOneWay &&
                ((appliesTo & ChunkingAppliesTo.OutMessage)
                            == ChunkingAppliesTo.OutMessage))
            {
                //add output message's action to ChunkingBindingParameter
                param.AddAction(description.Messages[1].Action);
            }
        }

 void IServiceBehavior.AddBindingParameters(System.ServiceModel.Description.ServiceDescription description, ServiceHostBase serviceHostBase, Collection<ServiceEndpoint> endpoints, BindingParameterCollection parameters)
 {
     if (parameters == null)
     {
         throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("parameters"));
     }
     parameters.Add(this);
 }

 void IServiceBehavior.AddBindingParameters(System.ServiceModel.Description.ServiceDescription description, ServiceHostBase serviceHostBase, Collection<ServiceEndpoint> endpoints, BindingParameterCollection parameters)
 {
     if (parameters == null)
     {
         throw FxTrace.Exception.ArgumentNull("parameters");
     }
     parameters.Add(this.virtualPathExtension);
 }

        /// <summary>
        /// Adds the binding parameters.
        /// </summary>
        /// <param name="serviceEndpoint">The service endpoint.</param>
        /// <param name="parameters">The parameters.</param>
        void IEndpointBehavior.AddBindingParameters(ServiceEndpoint serviceEndpoint, BindingParameterCollection parameters)
        {
            if (parameters == null)
            {
                throw new ArgumentNullException("parameters");
            }

            ServiceDebugBehavior debugBehavior = parameters.Find<ServiceDebugBehavior>();
            if (debugBehavior == null && this.serviceDebugBehavior != null)
            {
                parameters.Add(this.serviceDebugBehavior);
            }

            DispatcherSynchronizationBehavior synchronizationBehavior = parameters.Find<DispatcherSynchronizationBehavior>();
            if (synchronizationBehavior == null && this.dispatcherSynchronizationBehavior != null)
            {
                parameters.Add(this.dispatcherSynchronizationBehavior);
            }
        }

 static Dictionary<DirectionalAction, TransactionFlowOption> EnsureDictionary(BindingParameterCollection parameters)
 {
     Dictionary<DirectionalAction, TransactionFlowOption> dictionary =
         parameters.Find<Dictionary<DirectionalAction, TransactionFlowOption>>();
     if (dictionary == null)
     {
         dictionary = new Dictionary<DirectionalAction, TransactionFlowOption>();
         parameters.Add(dictionary);
     }
     return dictionary;
 }

		StreamSecurityUpgradeProvider CreateClientProvider (params object [] parameters)
		{
			SslStreamSecurityBindingElement bel =
				new SslStreamSecurityBindingElement ();
			BindingParameterCollection pl =
				new BindingParameterCollection ();
			foreach (object o in parameters)
				pl.Add (o);
			BindingContext ctx = new BindingContext (
				new CustomBinding (new HttpTransportBindingElement ()), pl);
			return bel.BuildClientStreamUpgradeProvider (ctx)
				as StreamSecurityUpgradeProvider;
		}

        protected override void InitializeRuntime()
        {
            BindingParameterCollection bpc = new BindingParameterCollection();
            VirtualPathExtension virtualPathExtension = this.Extensions.Find<VirtualPathExtension>();
            if (virtualPathExtension != null)
            {
                bpc.Add(virtualPathExtension);
            }

            BasicHttpBinding basicHttpBinding = new BasicHttpBinding();

            IChannelListener<IReplyChannel> listener = basicHttpBinding.BuildChannelListener<IReplyChannel>(interestedUri, bpc);

            CustomChannelDispatcher channelDispatcher = new CustomChannelDispatcher(serviceManager, listener);
            this.ChannelDispatchers.Add(channelDispatcher);
        }

		private ChannelDispatcher BuildChannelDispatcher(Uri listenUri, ServiceHostBase host)
		{
			BindingParameterCollection parameters = new BindingParameterCollection();
			VirtualPathExtension item = host.Extensions.Find<VirtualPathExtension>();
			if (item != null)
			{
				parameters.Add(item);
			}

			IChannelListener<IReplyChannel> listener = null;
			WebHttpBinding binding = new WebHttpBinding();
			if (binding.CanBuildChannelListener<IReplyChannel>(parameters))
			{
				listener = binding.BuildChannelListener<IReplyChannel>(listenUri, parameters);
			}

			ChannelDispatcher channelDispatcher = new ChannelDispatcher(listener)
			{
				MessageVersion = MessageVersion.None
			};

			return channelDispatcher;
		}

		void IEndpointBehavior.AddBindingParameters (ServiceEndpoint endpoint,
			BindingParameterCollection parameters)
		{
			parameters.Add (this);
		}

		IChannelFactory<IRequestChannel> CreateDefaultServiceCertFactory ()
		{
			CustomBinding b = CreateBinding (delegate (Message req) {
				return null;
				});
			ClientCredentials cred = new ClientCredentials ();
			cred.ServiceCertificate.DefaultCertificate = new X509Certificate2 ("Test/Resources/test.pfx", "mono");
			BindingParameterCollection parameters =
				new BindingParameterCollection ();
			parameters.Add (cred);
			ChannelProtectionRequirements cp =
				new ChannelProtectionRequirements ();
			cp.IncomingSignatureParts.AddParts (
				new MessagePartSpecification (true),
				"http://tempuri.org/MyAction");
			cp.IncomingEncryptionParts.AddParts (
				new MessagePartSpecification (true),
				"http://tempuri.org/MyAction");
			parameters.Add (cp);

			return b.BuildChannelFactory<IRequestChannel> (parameters);
		}

		public void SendRequestWithSignatureMessagePart ()
		{
			CustomBinding b = CreateBinding ();
			ChannelProtectionRequirements cp =
				new ChannelProtectionRequirements ();
			cp.IncomingSignatureParts.AddParts (new MessagePartSpecification (true), "myAction");
			cp.IncomingEncryptionParts.AddParts (new MessagePartSpecification (true), "myAction");
			BindingParameterCollection parameters =
				new BindingParameterCollection ();
			parameters.Add (cp);

			IChannelFactory<IRequestChannel> f =
				b.BuildChannelFactory<IRequestChannel> (parameters);
			f.Open ();
			IRequestChannel ch = f.CreateChannel (CreateX509EndpointAddress ("stream:dummy"));

			ch.Open ();
			ch.Request (Message.CreateMessage (b.MessageVersion, "myAction"));
		}

        /// <summary>
        /// Called to apply the configuration on the endpoint level.
        /// </summary>
        /// <param name="webHttpRelayBinding">Azure Http endpoint.</param>
        /// <returns>The <see cref="BindingParameterCollection"/> to use when building the <see cref="IChannelListener"/> or null if no binding parameters are present.</returns>
        protected virtual BindingParameterCollection OnConfigureBinding(Binding webHttpRelayBinding)
        {
            if (webHttpRelayBinding == null)
            {
                throw new ArgumentNullException("webHttpRelayBinding");
            }

            var bindingParameters = new BindingParameterCollection();
            bindingParameters.Add(new TransportClientEndpointBehavior(TokenProvider.CreateSharedSecretTokenProvider(IssuerName, IssuerSecret)));

            return bindingParameters;
        }

		public void OpenRequestNonAuthenticatable ()
		{
			SymmetricSecurityBindingElement sbe = 
				new SymmetricSecurityBindingElement ();
			sbe.ProtectionTokenParameters =
				new UserNameSecurityTokenParameters ();
			Binding binding = new CustomBinding (sbe, new HandlerTransportBindingElement (null));
			BindingParameterCollection pl =
				new BindingParameterCollection ();
			ClientCredentials cred = new ClientCredentials ();
			cred.UserName.UserName = "mono";
			pl.Add (cred);
			IChannelFactory<IRequestChannel> f =
				binding.BuildChannelFactory<IRequestChannel> (pl);
			f.Open ();
			IRequestChannel ch = f.CreateChannel (new EndpointAddress ("stream:dummy"));
			try {
				ch.Open ();
				Assert.Fail ("NotSupportedException is expected.");
			} catch (NotSupportedException) {
			}
		}

            public void AddBindingParameters(ServiceEndpoint endpoint, BindingParameterCollection parameters)
            {
                // get Contract info security needs, and put in BindingParameterCollection
                ISecurityCapabilities isc = null;
                BindingElementCollection elements = endpoint.Binding.CreateBindingElements();
                for (int i = 0; i < elements.Count; ++i)
                {
                    if (!(elements[i] is ITransportTokenAssertionProvider))
                    {
                        ISecurityCapabilities tmp = elements[i].GetIndividualProperty<ISecurityCapabilities>();
                        if (tmp != null)
                        {
                            isc = tmp;
                            break;
                        }
                    }
                }
                if (isc != null)
                {
                    // ensure existence of binding parameter
                    ChannelProtectionRequirements requirements = parameters.Find<ChannelProtectionRequirements>();
                    if (requirements == null)
                    {
                        requirements = new ChannelProtectionRequirements();
                        parameters.Add(requirements);
                    }

                    MessageEncodingBindingElement encoding = elements.Find<MessageEncodingBindingElement>();
                    // use endpoint.Binding.Version
                    if (encoding != null && encoding.MessageVersion.Addressing == AddressingVersion.None)
                    {
                        // This binding does not support response actions, so...
                        requirements.Add(ChannelProtectionRequirements.CreateFromContractAndUnionResponseProtectionRequirements(endpoint.Contract, isc, isForClient));
                    }
                    else
                    {
                        requirements.Add(ChannelProtectionRequirements.CreateFromContract(endpoint.Contract, isc, isForClient));
                    }
                }
            }

 private BindingParameterCollection AddCredentialsToBindingParameters()
 {
     BindingParameterCollection bindingParameters = new BindingParameterCollection();
     bindingParameters.Add(_credentials);
     return bindingParameters;
 }