/** * The execution of this behavior comes rather late. * Anyone that inspects the service description in the meantime, * such as for metadata generation, won't see the protection level that we want to use. * * One way of doing it is at when create HostFactory * * ServiceEndpoint endpoint = host.Description.Endpoints.Find(typeof(IService)); * OperationDescription operation = endpoint.Contract.Operations.Find("Action"); * MessageDescription message = operation.Messages.Find("http://tempuri.org/IService/ActionResponse"); * MessageHeaderDescription header = message.Headers[new XmlQualifiedName("aheader", "http://tempuri.org/")]; * header.ProtectionLevel = ProtectionLevel.Sign; * * **/ public void AddBindingParameters(ContractDescription contractDescription, ServiceEndpoint endpoint, BindingParameterCollection bindingParameters) { ChannelProtectionRequirements requirements = bindingParameters.Find<ChannelProtectionRequirements>(); XmlQualifiedName qName = new XmlQualifiedName(header, ns); MessagePartSpecification part = new MessagePartSpecification(qName); requirements.OutgoingSignatureParts.AddParts(part, action); }
public void AddBindingParameters( ServiceDescription serviceDescription, ServiceHostBase serviceHostBase, Collection<ServiceEndpoint> endpoints, BindingParameterCollection bindingParameters) { }
/// <summary> /// /// </summary> /// <param name="contractDescription"></param> /// <param name="endpoint"></param> /// <param name="bindingParameters"></param> public void AddBindingParameters( ContractDescription contractDescription, ServiceEndpoint endpoint, BindingParameterCollection bindingParameters) { // empty }
public void AddBindingParameters(ServiceDescription serviceDescription, ServiceHostBase serviceHostBase, System.Collections.ObjectModel.Collection<ServiceEndpoint> endpoints, BindingParameterCollection bindingParameters) { //no-op }
/// <summary> /// Provides the ability to pass custom data to binding elements to support the contract implementation. /// </summary> /// <param name="serviceDescription"> /// The service description of the service. /// </param> /// <param name="serviceHostBase"> /// The host of the service. /// </param> /// <param name="endpoints"> /// The service endpoints. /// </param> /// <param name="bindingParameters"> /// Custom objects to which binding elements have access. /// </param> public void AddBindingParameters(ServiceDescription serviceDescription, ServiceHostBase serviceHostBase, Collection<ServiceEndpoint> endpoints, BindingParameterCollection bindingParameters) { foreach (ChannelDispatcher chanDisp in serviceHostBase.ChannelDispatchers) { chanDisp.ErrorHandlers.Add(new ErrorHandler(this._messageFaultBuilder)); } }
void IContractBehavior.AddBindingParameters ( ContractDescription description, ServiceEndpoint endpoint, BindingParameterCollection parameters) { throw new NotImplementedException (); }
/// <summary> /// Adds the binding parameters. /// </summary> /// <param name="description">The description.</param> /// <param name="serviceHostBase">The service host base.</param> /// <param name="endpoints">The endpoints.</param> /// <param name="parameters">The parameters.</param> void IServiceBehavior.AddBindingParameters(ServiceDescription description, ServiceHostBase serviceHostBase, Collection<ServiceEndpoint> endpoints, BindingParameterCollection parameters) { if (throttlingBehavior != null) { ((IServiceBehavior)throttlingBehavior).AddBindingParameters(description, serviceHostBase, endpoints, parameters); } }
public void AddBindingParameters(ServiceEndpoint endpoint, BindingParameterCollection bindingParameters) { foreach (var operation in endpoint.Contract.Operations) { operation.Behaviors.Add(this); } }
public void Use () { var b = new ServiceDiscoveryBehavior (); b.AnnouncementEndpoints.Add (new UdpAnnouncementEndpoint ()); IServiceBehavior sb = b; var host = new ServiceHost (new Uri ("http://localhost:37564")); var bc = new BindingParameterCollection (); sb.AddBindingParameters (host.Description, host, host.Description.Endpoints, bc); Assert.AreEqual (0, bc.Count, "#1"); Assert.AreEqual (0, host.Extensions.Count, "#2-1"); sb.Validate (host.Description, host); // ... should "validate" not "apply dispatch behavior" do "add host extension" job? I doubt that. Assert.AreEqual (1, host.Extensions.Count, "#2-2"); var dse = host.Extensions.Find<DiscoveryServiceExtension> (); Assert.IsNotNull (dse, "#2-3"); Assert.AreEqual (0, dse.PublishedEndpoints.Count, "#2-4"); Assert.AreEqual (0, host.ChannelDispatchers.Count, "#3-1"); sb.ApplyDispatchBehavior (host.Description, host); Assert.AreEqual (0, host.Description.Endpoints.Count, "#3-2"); Assert.AreEqual (2, host.ChannelDispatchers.Count, "#3-3"); // for online and offline announcements Assert.AreEqual (0, dse.PublishedEndpoints.Count, "#3-4"); // discovery endpoints are not "published" int idx = 0; foreach (var cdisb in host.ChannelDispatchers) { var cdis = cdisb as ChannelDispatcher; string head = "#4." + idx + "."; Assert.IsNull (cdis, head + "dispatcher"); if (cdisb.Listener != null) Assert.AreEqual ("urn:schemas-microsoft-org:ws:2008:07:discovery", cdisb.Listener.Uri.ToString (), head + "uri"); // else ... WHOA! .NET "OnlineAnnouncementChannelDispatcher" type does not seem to provide the listener. idx++; } }
void IServiceBehavior.AddBindingParameters ( ServiceDescription description, ServiceHostBase serviceHostBase, Collection<ServiceEndpoint> endpoints, BindingParameterCollection parameters) { }
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); } }
public virtual void AddBindingParameters(ServiceDescription serviceDescription, ServiceHostBase serviceHostBase, Collection<ServiceEndpoint> endpoints, BindingParameterCollection bindingParameters) { throw new NotImplementedException(); }
void IEndpointBehavior.AddBindingParameters (ServiceEndpoint endpoint, BindingParameterCollection bindingParameters) { if (endpoint == null) throw new ArgumentNullException ("endpoint"); if (bindingParameters == null) throw new ArgumentNullException ("bindingParameters"); }
public void AddBindingParameters(OperationDescription operationDescription, BindingParameterCollection bindingParameters) { if (_innerOperationBehavior == null) return; (_innerOperationBehavior as IOperationBehavior).AddBindingParameters(operationDescription, bindingParameters); }
internal static ClientRuntime BuildProxyBehavior(ServiceEndpoint serviceEndpoint, out BindingParameterCollection parameters) { parameters = new BindingParameterCollection(); SecurityContractInformationEndpointBehavior.ClientInstance.AddBindingParameters(serviceEndpoint, parameters); AddBindingParameters(serviceEndpoint, parameters); ContractDescription contractDescription = serviceEndpoint.Contract; ClientRuntime clientRuntime = new ClientRuntime(contractDescription.Name, contractDescription.Namespace); clientRuntime.ContractClientType = contractDescription.ContractType; IdentityVerifier identityVerifier = serviceEndpoint.Binding.GetProperty<IdentityVerifier>(parameters); if (identityVerifier != null) { clientRuntime.IdentityVerifier = identityVerifier; } for (int i = 0; i < contractDescription.Operations.Count; i++) { OperationDescription operation = contractDescription.Operations[i]; if (!operation.IsServerInitiated()) { DispatcherBuilder.BuildProxyOperation(operation, clientRuntime); } else { DispatcherBuilder.BuildDispatchOperation(operation, clientRuntime.CallbackDispatchRuntime); } } DispatcherBuilder.ApplyClientBehavior(serviceEndpoint, clientRuntime); return clientRuntime; }
public void AddBindingParameters(ServiceDescription serviceDescription, ServiceHostBase serviceHostBase, Collection<ServiceEndpoint> endpoints, BindingParameterCollection bindingParameters) { foreach (var operation in endpoints.SelectMany(val => val.Contract.Operations.Where(x => x.Behaviors.Find<ExceptionHandlerOperationBehavior>() == null))) { operation.Behaviors.Add(new ExceptionHandlerOperationBehavior()); } }
/// <summary> /// Provides the ability to pass custom data to binding elements to support the contract implementation /// </summary> /// <param name="serviceDescription">The service description of the service.</param> /// <param name="serviceHostBase">The host of the service.</param> /// <param name="endpoints">The service endpoints.</param> /// <param name="bindingParameters">The service endpoints.</param> public void AddBindingParameters( ServiceDescription serviceDescription, ServiceHostBase serviceHostBase, Collection<ServiceEndpoint> endpoints, BindingParameterCollection bindingParameters) { //not apply for this sample }
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); }
void IServiceBehavior.AddBindingParameters(ServiceDescription description, ServiceHostBase serviceHostBase, Collection<ServiceEndpoint> endpoints, BindingParameterCollection parameters) { // Forward the call if we created a ServiceThrottlingBehavior. if (this.throttlingBehavior != null) { ((IServiceBehavior)this.throttlingBehavior).AddBindingParameters(description, serviceHostBase, endpoints, parameters); } }
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); }
public void AddBindingParameters( ServiceDescription serviceDescription, ServiceHostBase serviceHostBase, Collection<ServiceEndpoint> endpoints, BindingParameterCollection bindingParameters) { AutoMapBootstrap.InitMap(); }
void IServiceBehavior.AddBindingParameters ( ServiceDescription description, ServiceHostBase serviceHostBase, Collection<ServiceEndpoint> endpoints, BindingParameterCollection parameters) { throw new NotImplementedException (); }
void IOperationBehavior.AddBindingParameters(OperationDescription description, BindingParameterCollection parameters) { if (parameters == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("parameters"); } this.ApplyBehavior(description, parameters); }
/// <summary> /// Registers custom contract binding parameters /// </summary> /// <param name="desc"> /// The WCF contract description /// </param> /// <param name="endpoint"> /// The WCF contract endpoint /// </param> /// <param name="binding"> /// The WCF endpoint binding parameters /// </param> public virtual void AddBindingParameters( ContractDescription desc, ServiceEndpoint endpoint, BindingParameterCollection binding) { foreach (OperationDescription op in desc.Operations) AddBindingParameters(op, binding); }
public void AddBiningParameters () { var se = CreateEndpoint (); var b = new WebHttpBehavior (); var pl = new BindingParameterCollection (); b.AddBindingParameters (se, pl); Assert.AreEqual (0, pl.Count, "#1"); }
internal ExportedPolicyConversionContext(ServiceEndpoint endpoint, BindingParameterCollection bindingParameters) : base(endpoint) { this.bindingElements = endpoint.Binding.CreateBindingElements(); this.bindingAssertions = new PolicyAssertionCollection(); this.operationBindingAssertions = new Dictionary<OperationDescription, PolicyAssertionCollection>(); this.messageBindingAssertions = new Dictionary<MessageDescription, PolicyAssertionCollection>(); this.faultBindingAssertions = new Dictionary<FaultDescription, PolicyAssertionCollection>(); this.bindingParameters = bindingParameters; }
public void AddBindingParameters () { IEndpointBehavior eb = new CallbackBehaviorAttribute (); var cd = ContractDescription.GetContract (typeof (IFoo)); var se = new ServiceEndpoint (cd); Assert.AreEqual (0, se.Behaviors.Count, "#1"); var pc = new BindingParameterCollection (); eb.AddBindingParameters (se, pc); Assert.AreEqual (0, pc.Count, "#2"); Assert.AreEqual (0, se.Behaviors.Count, "#3"); }
private static Dictionary<DirectionalAction, TransactionFlowOption> EnsureDictionary(BindingParameterCollection parameters) { Dictionary<DirectionalAction, TransactionFlowOption> dictionary = parameters.Find<Dictionary<DirectionalAction, TransactionFlowOption>>(); if (dictionary == null) { dictionary = new Dictionary<DirectionalAction, TransactionFlowOption> { dictionary }; } return dictionary; }
/// <summary> /// Provides the ability to pass custom data to binding elements to support the contract implementation. /// </summary> /// <param name="serviceDescription">The service description of the service.</param><param name="serviceHostBase">The host of the service.</param><param name="endpoints">The service endpoints.</param><param name="bindingParameters">Custom objects to which binding elements have access.</param> void IServiceBehavior.AddBindingParameters(ServiceDescription serviceDescription, ServiceHostBase serviceHostBase, Collection<ServiceEndpoint> endpoints, BindingParameterCollection bindingParameters) { endpoints .SelectMany(x => x.Contract.Operations) .Where(x => x.DeclaringContract.ContractType != typeof(IMetadataExchange)) .ToList() .ForEach(x => { if (!x.Behaviors.Any(b => b.GetType() == GetType())) x.Behaviors.Add(this); }); }
public void AddBindingParameters(ServiceDescription serviceDescription, ServiceHostBase serviceHostBase, Collection<ServiceEndpoint> endpoints, BindingParameterCollection bindingParameters) { //ContentNegotiationBindingElement contentNegotiation = new ContentNegotiationBindingElement(); //contentNegotiation.CompressionMode = SmartCompressionMode.Optimistic; //binding = contentNegotiation.PlugIn(binding); //foreach (var endpoint in endpoints) //{ // endpoint.Binding = contentNegotiation.PlugIn(endpoint.Binding); //} }
void IOperationBehavior.AddBindingParameters(OperationDescription operationDescription, System.ServiceModel.Channels.BindingParameterCollection bindingParameters) { // do nothing }
public virtual bool CanBuildChannelFactory <TChannel>(BindingParameterCollection parameters) { BindingContext context = new BindingContext(new CustomBinding(this), parameters); return(context.CanBuildInnerChannelFactory <TChannel>()); }
/// <summary> /// /// </summary> /// <param name="serviceDescription"></param> /// <param name="serviceHostBase"></param> /// <param name="endpoints"></param> /// <param name="bindingParameters"></param> public void AddBindingParameters(ServiceDescription serviceDescription, ServiceHostBase serviceHostBase, Collection <ServiceEndpoint> endpoints, System.ServiceModel.Channels.BindingParameterCollection bindingParameters) { }
public virtual bool CanBuildChannelListener <TChannel>(BindingParameterCollection parameters) where TChannel : class, IChannel { BindingContext context = new BindingContext(new CustomBinding(this), parameters); return(context.CanBuildInnerChannelListener <TChannel>()); }
public T GetProperty <T>(BindingParameterCollection parameters) where T : class { BindingContext context = new BindingContext(new CustomBinding(this), parameters); return(context.GetInnerProperty <T>()); }
private void ValidateSecurityCapabilities(ISecurityCapabilities runtimeSecurityCapabilities, BindingParameterCollection parameters) { if (!SecurityCapabilities.IsEqual(this.GetProperty <ISecurityCapabilities>(parameters), runtimeSecurityCapabilities)) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(System.ServiceModel.SR.GetString("SecurityCapabilitiesMismatched", new object[] { this }))); } }
public virtual IChannelListener <TChannel> BuildChannelListener <TChannel>(BindingParameterCollection parameters) where TChannel : class, IChannel { UriBuilder builder = new UriBuilder(this.Scheme, DnsCache.MachineName); return(this.BuildChannelListener <TChannel>(builder.Uri, string.Empty, ListenUriMode.Unique, parameters)); }
public void AddBindingParameters(ServiceEndpoint endpoint, System.ServiceModel.Channels.BindingParameterCollection bindingParameters) { // No implementation necessary }
public void AddBindingParameters(OperationDescription operationDescription, System.ServiceModel.Channels.BindingParameterCollection bindingParameters) { //throw new NotImplementedException(); }
void IContractBehavior.AddBindingParameters(ContractDescription contractDescription, ServiceEndpoint endpoint, System.ServiceModel.Channels.BindingParameterCollection bindingParameters) { }
void IEndpointBehavior.AddBindingParameters(ServiceEndpoint endpoint, System.ServiceModel.Channels.BindingParameterCollection bindingParameters) { }
private void ValidateSecurityCapabilities(ISecurityCapabilities runtimeSecurityCapabilities, BindingParameterCollection parameters) { ISecurityCapabilities bindingSecurityCapabilities = this.GetProperty <ISecurityCapabilities>(parameters); if (!SecurityCapabilities.IsEqual(bindingSecurityCapabilities, runtimeSecurityCapabilities)) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError( new InvalidOperationException(SR.Format(SR.SecurityCapabilitiesMismatched, this))); } }
public virtual IChannelListener <TChannel> BuildChannelListener <TChannel>(Uri listenUriBaseAddress, string listenUriRelativeAddress, ListenUriMode listenUriMode, BindingParameterCollection parameters) where TChannel : class, IChannel { this.EnsureInvariants(); BindingContext context = new BindingContext(new CustomBinding(this), parameters, listenUriBaseAddress, listenUriRelativeAddress, listenUriMode); IChannelListener <TChannel> listener = context.BuildInnerChannelListener <TChannel>(); context.ValidateBindingElementsConsumed(); this.ValidateSecurityCapabilities(listener.GetProperty <ISecurityCapabilities>(), parameters); return(listener); }
public void AddBindingParameters(ServiceEndpoint endpoint, System.ServiceModel.Channels.BindingParameterCollection bindingParameters) { //throw new NotImplementedException(); }
public virtual IChannelListener <TChannel> BuildChannelListener <TChannel>(Uri listenUriBaseAddress, string listenUriRelativeAddress, BindingParameterCollection parameters) where TChannel : class, IChannel { return(this.BuildChannelListener <TChannel>(listenUriBaseAddress, listenUriRelativeAddress, ListenUriMode.Explicit, parameters)); }
public void AddBindingParameters(ServiceDescription serviceDescription, System.ServiceModel.ServiceHostBase serviceHostBase, System.Collections.ObjectModel.Collection <ServiceEndpoint> endpoints, System.ServiceModel.Channels.BindingParameterCollection bindingParameters) { //提供方法执行的上下文环境 //OperationContext context = OperationContext.Current; //获取传进的消息属性 //MessageProperties properties = context.IncomingMessageProperties; ///获取消息发送的远程终结点IP和端口 //RemoteEndpointMessageProperty endpoint = properties[RemoteEndpointMessageProperty.Name] as RemoteEndpointMessageProperty; //throw new NotImplementedException(); }
public void AddBindingParameters(ContractDescription contractDescription, ServiceEndpoint endpoint, System.ServiceModel.Channels.BindingParameterCollection bindingParameters) { return; }
public ChannelBuilder(ChannelBuilder channelBuilder) { _binding = new CustomBinding(channelBuilder.Binding); _bindingParameters = channelBuilder.BindingParameters; }
void IServiceBehavior.AddBindingParameters(ServiceDescription serviceDescription, ServiceHostBase serviceHostBase, System.Collections.ObjectModel.Collection <ServiceEndpoint> endpoints, System.ServiceModel.Channels.BindingParameterCollection bindingParameters) { }
private BindingContext(CustomBinding binding, BindingElementCollection remainingBindingElements, BindingParameterCollection parameters) { Initialize(binding, remainingBindingElements, parameters); }