public Scope(Type contract, M clientModel, AbstractChannelBuilder <M> builder, IWcfBurden burden) { this.contract = contract ?? clientModel.Endpoint.Contract; this.clientModel = clientModel; this.builder = builder; this.burden = burden; }
internal void TrackBurden(IWcfBurden burden) { lock (sync) { burdens.Add(burden); } }
public WcfChannelHolder(ChannelCreator channelCreator, IWcfBurden burden) { this.channelCreator = channelCreator; ChannelBurden = burden; ObtainChannelFactory(); CreateChannel(); }
public void Install(ServiceHost serviceHost, IKernel kernel, IWcfBurden burden) { BindServiceHostAware(serviceHost, kernel, burden); AddServiceBehaviors(serviceHost, kernel, burden); AddServiceHostExtensions(serviceHost, kernel, burden); AddErrorHandlers(serviceHost, kernel, burden); }
/// <summary> /// Get a delegate capable of creating channels. /// </summary> /// <param name="clientModel">The client model.</param> /// <param name="contract">The contract override.</param> /// <param name="burden">Receives the client burden.</param> /// <returns>The <see cref="ChannelCreator"/></returns> public ChannelCreator GetChannelCreator(M clientModel, Type contract, out IWcfBurden burden) { burden = new WcfBurden(Kernel); var scope = new Scope(contract, clientModel, this, burden); return(scope.BuildChannelCreator()); }
public void Install(ServiceHost serviceHost, IKernel kernel, IWcfBurden burden) { object extension = GetExtensionInstance(kernel, burden); if (extension is IServiceBehavior) { serviceHost.Description.Behaviors.Add((IServiceBehavior)extension); } else if (extension is IServiceHostAware) { WcfUtils.BindServiceHostAware(serviceHost, (IServiceHostAware)extension, true); } else if (extension is IErrorHandler) { WcfUtils.RegisterErrorHandler(serviceHost, (IErrorHandler)extension, true); } else if (extension is IExtension<ServiceHostBase>) { serviceHost.Extensions.Add((IExtension<ServiceHostBase>)extension); } else { WcfUtils.AttachExtension(serviceHost.Description.Behaviors, extension); } }
public void Install(ServiceHost serviceHost, IKernel kernel, IWcfBurden burden) { object extension = GetInstance(kernel, burden); if (extension is IServiceBehavior) { serviceHost.Description.Behaviors.Add((IServiceBehavior)extension); } else if (extension is IServiceHostAware) { WcfUtils.BindServiceHostAware(serviceHost, (IServiceHostAware)extension, true); } else if (extension is IErrorHandler) { WcfUtils.RegisterErrorHandler(serviceHost, (IErrorHandler)extension, true); } else if (extension is IExtension <ServiceHostBase> ) { serviceHost.Extensions.Add((IExtension <ServiceHostBase>)extension); } else { WcfUtils.AttachExtension(serviceHost.Description.Behaviors, extension); } }
public WcfChannelHolder(ChannelCreator channelCreator, IWcfBurden burden, TimeSpan? closeTimeout) { this.channelCreator = channelCreator; ChannelBurden = burden; CloseTimeout = closeTimeout; ObtainChannelFactory(); CreateChannel(); }
private static void AddErrorHandlers(ServiceHost serviceHost, IKernel kernel, IWcfBurden burden) { var errorHandlers = new KeyedByTypeCollection<IErrorHandler>(); WcfUtils.AddBehaviors(kernel, WcfExtensionScope.Services, errorHandlers, burden, errorHandler => { return WcfUtils.RegisterErrorHandler(serviceHost, errorHandler, true); }); }
public WcfChannelHolder(ChannelCreator channelCreator, IWcfBurden burden, TimeSpan?closeTimeout) { this.channelCreator = channelCreator; ChannelBurden = burden; CloseTimeout = closeTimeout; ObtainChannelFactory(); CreateChannel(); }
private static ChannelCreator CreateChannelCreatorInternal <TModel>( IKernel kernel, IWcfClientModel clientModel, ComponentModel model, out IWcfBurden burden) where TModel : IWcfClientModel { var channelBuilder = kernel.Resolve <IChannelBuilder <TModel> >(); return(channelBuilder.GetChannelCreator((TModel)clientModel, model.GetServiceContract(), out burden)); }
private static void BindServiceHostAware(ServiceHost serviceHost, IKernel kernel, IWcfBurden burden) { WcfUtils.AddBehaviors<IServiceHostAware>(kernel, WcfExtensionScope.Services, null, burden, serviceHostAware => { WcfUtils.BindServiceHostAware(serviceHost, serviceHostAware, true); return true; }); }
/// <summary> /// Creates the channel creator. /// </summary> /// <param name = "context"> The context for the creator. </param> /// <param name = "burden"> Receives the channel burden. </param> /// <returns> The channel creator. </returns> /// <remarks> /// Always Open the channel before being used to prevent serialization of requests. /// http://blogs.msdn.com/wenlong/archive/2007/10/26/best-practice-always-open-wcf-client-proxy-explicitly-when-it-is-shared.aspx /// </remarks> private ChannelCreator GetChannelCreator(CreationContext context, out IWcfBurden burden) { burden = channelBurden; var creator = createChannel; var clientModel = ObtainClientModel(Model, context); if (clientModel != null) { var inner = CreateChannelCreator(Kernel, Model, clientModel, out burden); var scopedBurden = burden; creator = () => { var client = (IChannel)inner(); if (client is IContextChannel) { ((IContextChannel)client).Extensions.Add(new WcfBurdenExtension <IContextChannel>(scopedBurden)); } else { var parameters = client.GetProperty <ChannelParameterCollection>(); if (parameters != null) { parameters.Add(scopedBurden); } } NotifyChannelCreatedOrAvailable(client, scopedBurden, true); if (!clientModel.OpenChannelOnDemand) { client.Open(); } return(client); }; } else if (createChannel == null) { clientModel = ObtainClientModel(Model); var inner = CreateChannelCreator(Kernel, Model, clientModel, out channelBurden); creator = createChannel = () => { var client = (IChannel)inner(); NotifyChannelCreatedOrAvailable(client, channelBurden, true); if (!clientModel.OpenChannelOnDemand) { client.Open(); } return(client); }; burden = channelBurden; clients.TrackBurden(burden); } return(creator); }
private void BindChannelFactoryAware(ChannelFactory channelFactory, IKernel kernel, IWcfBurden burden) { WcfUtils.AddBehaviors<IChannelFactoryAware>(kernel, WcfExtensionScope.Clients, null, burden, delegate(IChannelFactoryAware channelFactoryAware) { WcfUtils.BindChannelFactoryAware(channelFactory, channelFactoryAware, true); return true; }); }
private static void AddServiceHostExtensions(ServiceHost serviceHost, IKernel kernel, IWcfBurden burden) { var extensions = new KeyedByTypeCollection<IExtension<ServiceHostBase>>(); WcfUtils.AddBehaviors(kernel, WcfExtensionScope.Services, extensions, burden, extension => { serviceHost.Extensions.Add(extension); return true; }); }
public void Install(ChannelFactory channelFactory, IKernel kernel, IWcfBurden burden) { object extension = GetExtensionInstance(kernel, burden); if (extension is IChannelFactoryAware) { WcfUtils.BindChannelFactoryAware(channelFactory, (IChannelFactoryAware)extension, true); } }
public void Install(ChannelFactory channelFactory, IKernel kernel, IWcfBurden burden) { var extension = GetInstance(kernel, burden); if (extension is IChannelFactoryAware) { WcfUtils.BindChannelFactoryAware(channelFactory, (IChannelFactoryAware)extension, true); } }
private object GetInstance(IKernel kernel, IWcfBurden burden) { if (instance == null) { instance = ResolveExtension(kernel); burden.Add(instance); } return(instance); }
public void Install(ServiceEndpoint endpoint, IKernel kernel, IWcfBurden burden) { WcfUtils.AddBehaviors(kernel, scope, endpoint.Behaviors, burden); WcfUtils.AddBehaviors(kernel, scope, endpoint.Contract.Behaviors, burden); foreach (var operation in endpoint.Contract.Operations) { WcfUtils.AddBehaviors(kernel, scope, operation.Behaviors, burden); } }
private static void BindChannelFactoryAware(ChannelFactory channelFactory, IKernel kernel, IWcfBurden burden) { WcfUtils.AddBehaviors<IWcfPolicy>(kernel, WcfExtensionScope.Undefined, null, burden, null); WcfUtils.AddBehaviors<IChannelFactoryAware>(kernel, WcfExtensionScope.Clients, null, burden, channelFactoryAware => { WcfUtils.BindChannelFactoryAware(channelFactory, channelFactoryAware, true); return true; }); }
public ChannelFactoryExtensions Install(ICollection<IWcfExtension> extensions, IWcfBurden burden) { this.burden = burden; foreach (IWcfExtension extension in extensions) { extension.Accept(this); } return this; }
public ChannelFactoryExtensions Install(ICollection <IWcfExtension> extensions, IWcfBurden burden) { this.burden = burden; foreach (IWcfExtension extension in extensions) { extension.Accept(this); } return(this); }
public ServiceHostExtensions Install(ICollection<IWcfExtension> extensions, IWcfBurden burden) { this.burden = burden; foreach (var extension in extensions) { extension.Accept(this); } return this; }
public ServiceHostExtensions Install(ICollection <IWcfExtension> extensions, IWcfBurden burden) { this.burden = burden; foreach (var extension in extensions) { extension.Accept(this); } return(this); }
protected void ConfigureChannelFactory(ChannelFactory channelFactory, IWcfClientModel clientModel, IWcfBurden burden) { BindChannelFactoryAware(channelFactory, kernel, burden); var extensions =new ServiceEndpointExtensions(channelFactory.Endpoint, kernel) .Install(burden, new WcfEndpointExtensions(WcfExtensionScope.Clients)); if (clientModel != null) { extensions.Install(clientModel.Extensions, burden); extensions.Install(clientModel.Endpoint.Extensions, burden); } }
public void Install(ServiceEndpoint endpoint, bool withContract, IKernel kernel, IWcfBurden burden) { object extension = GetExtensionInstance(kernel, burden); if (extension is IEndpointBehavior) { endpoint.Behaviors.Add((IEndpointBehavior)extension); } else if (extension is IOperationBehavior) { if (withContract) { foreach (var operation in endpoint.Contract.Operations) { operation.Behaviors.Add((IOperationBehavior)extension); } } } else if (extension is IContractBehavior) { if (withContract) { endpoint.Contract.Behaviors.Add((IContractBehavior)extension); } } else if (extension is IErrorHandler) { WcfUtils.RegisterErrorHandler(endpoint, (IErrorHandler)extension, true); } else if (!WcfUtils.AttachExtension(endpoint.Behaviors, extension)) { if (withContract && !WcfUtils.AttachExtension(endpoint.Contract.Behaviors, extension)) { Type owner = null; if (WcfUtils.IsExtension(extension, ref owner)) { if (typeof(IOperationBehavior).IsAssignableFrom(owner)) { foreach (var operation in endpoint.Contract.Operations) { WcfUtils.AttachExtension(operation.Behaviors, extension, owner); } } } } } }
private void AddServiceBehaviors(ServiceHost serviceHost, IKernel kernel, IWcfBurden burden) { WcfUtils.AddBehaviors(kernel, WcfExtensionScope.Services, serviceHost.Description.Behaviors, burden, delegate(IServiceBehavior behavior) { if (behavior.GetType() == typeof(ServiceDebugBehavior)) { serviceHost.Description.Behaviors.Remove<ServiceDebugBehavior>(); } else if (behavior.GetType() == typeof(AspNetCompatibilityRequirementsAttribute)) { serviceHost.Description.Behaviors.Remove<AspNetCompatibilityRequirementsAttribute>(); } return true; }); }
protected void ConfigureChannelFactory(ChannelFactory channelFactory, IWcfClientModel clientModel, IWcfBurden burden) { var extensions = new ChannelFactoryExtensions(channelFactory, Kernel) .Install(burden, new WcfChannelExtensions()); var endpointExtensions = new ServiceEndpointExtensions(channelFactory.Endpoint, true, Kernel) .Install(burden, new WcfEndpointExtensions(WcfExtensionScope.Clients)); if (clientModel != null) { extensions.Install(clientModel.Extensions, burden); endpointExtensions.Install(clientModel.Extensions, burden); endpointExtensions.Install(clientModel.Endpoint.Extensions, burden); } burden.Add(new ChannelFactoryHolder(channelFactory)); }
internal static void AddBehaviors <T>(IKernel kernel, WcfExtensionScope scope, KeyedByTypeCollection <T> behaviors, IWcfBurden burden, Predicate <T> predicate) { foreach (var handler in FindExtensions <T>(kernel, scope)) { T behavior = (T)handler.Resolve(CreationContext.CreateEmpty()); if (predicate == null || predicate(behavior)) { if (behaviors != null) { behaviors.Add(behavior); } if (burden != null) { burden.Add(behavior); } } } }
private static void NotifyChannelCreatedOrAvailable(IChannel channel, IWcfBurden burden, bool created) { var channelFactory = burden.Dependencies.OfType <ChannelFactoryHolder>() .Select(holder => holder.ChannelFactory).FirstOrDefault(); if (channelFactory != null) { foreach (var observer in burden.Dependencies.OfType <IChannelFactoryAware>()) { if (created) { observer.ChannelCreated(channelFactory, channel); } else { observer.ChannelAvailable(channelFactory, channel); } } } }
private static void AddServiceBehaviors(ServiceHost serviceHost, IKernel kernel, IWcfBurden burden) { WcfUtils.AddBehaviors(kernel, WcfExtensionScope.Services, serviceHost.Description.Behaviors, burden, behavior => { if (behavior is ServiceBehaviorAttribute) { serviceHost.Description.Behaviors.Remove <ServiceBehaviorAttribute>(); } else if (behavior.GetType() == typeof(ServiceDebugBehavior)) { serviceHost.Description.Behaviors.Remove <ServiceDebugBehavior>(); } else if (behavior is AspNetCompatibilityRequirementsAttribute) { serviceHost.Description.Behaviors.Remove <AspNetCompatibilityRequirementsAttribute>(); } return(true); }); }
private static void BindServiceHostAware(ServiceHost serviceHost, IKernel kernel, IWcfBurden burden) { WcfUtils.AddBehaviors <IServiceHostAware>(kernel, WcfExtensionScope.Services, null, burden, serviceHostAware => { WcfUtils.BindServiceHostAware(serviceHost, serviceHostAware, true); return(true); }); }
private static void AddErrorHandlers(ServiceHost serviceHost, IKernel kernel, IWcfBurden burden) { var errorHandlers = new KeyedByTypeCollection <IErrorHandler>(); WcfUtils.AddBehaviors(kernel, WcfExtensionScope.Services, errorHandlers, burden, errorHandler => WcfUtils.RegisterErrorHandler(serviceHost, errorHandler, true)); }
protected override object GetExtensionInstance(IKernel kernel, IWcfBurden burden) { burden.Add(Instance); return Instance; }
protected override object GetExtensionInstance(IKernel kernel, IWcfBurden burden) { object extension = kernel.Resolve(ServiceType); burden.Add(extension); return extension; }
protected override object GetExtensionInstance(IKernel kernel, IWcfBurden burden) { object extension = kernel.Resolve(Key, WcfUtils.EmptyArguments); burden.Add(extension); return extension; }
public ServiceHostExtensions Install(IWcfBurden burden, params IWcfExtension[] extenions) { return(Install((ICollection <IWcfExtension>)extenions, burden)); }
private static void BindChannelFactoryAware(ChannelFactory channelFactory, IKernel kernel, IWcfBurden burden) { WcfUtils.AddBehaviors <IWcfPolicy>(kernel, WcfExtensionScope.Undefined, null, burden, null); WcfUtils.AddBehaviors <IChannelFactoryAware>(kernel, WcfExtensionScope.Clients, null, burden, channelFactoryAware => { WcfUtils.BindChannelFactoryAware(channelFactory, channelFactoryAware, true); return(true); }); }
private static ChannelCreator CreateChannelCreator(IKernel kernel, ComponentModel model, IWcfClientModel clientModel, out IWcfBurden burden) { ValidateClientModel(clientModel, model); var createChannelDelegate = createChannelCache.GetOrAdd(clientModel.GetType(), clientModelType => { return((CreateChannelDelegate)Delegate.CreateDelegate(typeof(CreateChannelDelegate), createChannelMethod.MakeGenericMethod(clientModelType))); }); var channelCreator = createChannelDelegate(kernel, clientModel, model, out burden); if (channelCreator == null) { throw new CommunicationException("Unable to generate the channel creator. " + "Either the endpoint could be be created or it's a bug so please report it."); } return(channelCreator); }
public WcfBurdenExtension(IWcfBurden burden) { this.burden = burden; }
public ChannelFactoryExtensions Install(IWcfBurden burden, params IWcfExtension[] extenions) { return Install((ICollection<IWcfExtension>)extenions, burden); }
private static void AddServiceHostExtensions(ServiceHost serviceHost, IKernel kernel, IWcfBurden burden) { var extensions = new KeyedByTypeCollection <IExtension <ServiceHostBase> >(); WcfUtils.AddBehaviors(kernel, WcfExtensionScope.Services, extensions, burden, extension => { serviceHost.Extensions.Add(extension); return(true); }); }
public void Install(ServiceHost serviceHost, IKernel kernel, IWcfBurden burden) { BindServiceHostAware(serviceHost, kernel, burden); AddServiceBehaviors(serviceHost, kernel, burden); }
private static void AddErrorHandlers(ServiceHost serviceHost, IKernel kernel, IWcfBurden burden) { var errorHandlers = new List<IErrorHandler>(); WcfUtils.AddBehaviors(kernel, WcfExtensionScope.Services, errorHandlers, burden, errorHandler => WcfUtils.IsBehaviorExtension(errorHandler) == false); if(errorHandlers.Count > 0) { WcfUtils.RegisterErrorHandlers(serviceHost, errorHandlers); } }
private static void AddErrorHandlers(ServiceHost serviceHost, IKernel kernel, IWcfBurden burden) { var errorHandlers = new List <IErrorHandler>(); WcfUtils.AddBehaviors(kernel, WcfExtensionScope.Services, errorHandlers, burden, errorHandler => WcfUtils.IsBehaviorExtension(errorHandler) == false); if (errorHandlers.Count > 0) { WcfUtils.RegisterErrorHandlers(serviceHost, errorHandlers); } }
public void Install(ServiceEndpoint endpoint, bool withContract, IKernel kernel, IWcfBurden burden) { var extension = GetInstance(kernel, burden); if (extension is IEndpointBehavior) { endpoint.Behaviors.Add((IEndpointBehavior)extension); } else if (extension is IOperationBehavior) { if (withContract) { foreach (var operation in endpoint.Contract.Operations) { operation.Behaviors.Add((IOperationBehavior)extension); } } } else if (extension is IContractBehavior) { if (withContract) { endpoint.Contract.Behaviors.Add((IContractBehavior)extension); } } else if (extension is IErrorHandler) { WcfUtils.RegisterErrorHandler(endpoint, (IErrorHandler)extension, true); } else if (WcfUtils.AttachExtension(endpoint.Behaviors, extension) == false) { if (withContract && !WcfUtils.AttachExtension(endpoint.Contract.Behaviors, extension)) { Type owner = null; if (WcfUtils.IsExtension(extension, ref owner)) { if (typeof(IOperationBehavior).IsAssignableFrom(owner)) { foreach (var operation in endpoint.Contract.Operations) { WcfUtils.AttachExtension(operation.Behaviors, extension, owner); } } } } } }
private object GetInstance(IKernel kernel, IWcfBurden burden) { if (instance == null) { instance = ResolveExtension(kernel); burden.Add(instance); } return instance; }
public void Install(ChannelFactory channelFactory, IKernel kernel, IWcfBurden burden) { BindChannelFactoryAware(channelFactory, kernel, burden); }
public void Install(ServiceEndpoint endpoint, bool withContract, IKernel kernel, IWcfBurden burden) { WcfUtils.AddBehaviors(kernel, scope, endpoint.Behaviors, burden); if (withContract) { WcfUtils.AddBehaviors(kernel, scope, endpoint.Contract.Behaviors, burden); foreach (var operation in endpoint.Contract.Operations) { WcfUtils.AddBehaviors(kernel, scope, operation.Behaviors, burden); } } }
protected override object GetExtensionInstance(IKernel kernel, IWcfBurden burden) { return instance; }
protected abstract object GetExtensionInstance(IKernel kernel, IWcfBurden burden);
public ChannelFactoryExtensions Install(IWcfBurden burden, params IWcfExtension[] extenions) { return(Install((ICollection <IWcfExtension>)extenions, burden)); }
protected override object GetExtensionInstance(IKernel kernel, IWcfBurden burden) { object extension = kernel[key]; burden.Add(extension); return extension; }
/// <summary> /// Get a delegate capable of creating channels. /// </summary> /// <param name="clientModel">The client model.</param> /// <param name="contract">The contract override.</param> /// <param name="burden">Receives the client burden.</param> /// <returns>The <see cref="ChannelCreator"/></returns> public ChannelCreator GetChannelCreator(M clientModel, Type contract, out IWcfBurden burden) { ClientModel = clientModel; burden = Burden = new WcfBurden(Kernel); return(GetEndpointChannelCreator(clientModel.Endpoint, contract)); }
public ServiceHostExtensions Install(IWcfBurden burden, params IWcfExtension[] extenions) { return Install((ICollection<IWcfExtension>)extenions, burden); }
internal static void AddBehaviors <T>(IKernel kernel, WcfExtensionScope scope, KeyedByTypeCollection <T> behaviors, IWcfBurden burden) { AddBehaviors(kernel, scope, behaviors, burden, null); }