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);
}
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);
});
}
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));
}
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;
}
public void Install(ChannelFactory channelFactory, IKernel kernel, IWcfBurden burden)
{
BindChannelFactoryAware(channelFactory, 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)
{
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);
}
