public override object Create(IKernel kernel, object instance, ComponentModel model,
CreationContext context, params object[] constructorArguments)
{
var channelHolder = instance as IWcfChannelHolder;
if (channelHolder == null)
{
throw new ArgumentException(string.Format("Given instance is not an {0}", typeof(IWcfChannelHolder)), "instance");
}
if (channelHolder.RealProxy == null)
{
return(channelHolder.Channel);
}
if (model.Services.Count() > 1)
{
throw new ArgumentException(string.Format(
"Component {0}, which was designated as a WCF proxy exposes {1} services. The facility currently only supports single-service components.",
model.Name, model.Services.Count()));
}
var isDuplex = IsDuplex(channelHolder.RealProxy);
var proxyOptions = model.ObtainProxyOptions();
var serviceContract = model.GetServiceContract();
var generationOptions = CreateProxyGenerationOptions(serviceContract, proxyOptions, kernel, context);
var additionalInterfaces = GetInterfaces(model.Services, proxyOptions, isDuplex);
var interceptors = GetInterceptors(kernel, model, serviceContract, channelHolder, context);
return(generator.CreateInterfaceProxyWithTarget(typeof(IWcfChannelHolder),
additionalInterfaces, channelHolder, generationOptions, interceptors));
}
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 void Kernel_ComponentModelCreated(ComponentModel model)
{
var clientModel = ResolveClientModel(model);
if (clientModel != null && model.Implementation == model.GetServiceContract())
{
model.CustomComponentActivator = typeof(WcfClientActivator);
model.ExtendedProperties[WcfConstants.ClientModelKey] = clientModel;
model.Lifecycle.Add(DisposalConcern.Instance);
var dependencies = new ExtensionDependencies(model, kernel)
.Apply(new WcfEndpointExtensions(WcfExtensionScope.Clients))
.Apply(clientModel.Extensions);
if (clientModel.Endpoint != null)
{
dependencies.Apply(clientModel.Endpoint.Extensions);
}
}
}
private static void ValidateClientModel(IWcfClientModel clientModel, ComponentModel model)
{
if (clientModel.Endpoint == null)
{
throw new FacilityException("The client model requires an endpoint.");
}
var contract = clientModel.Contract ?? model.GetServiceContract();
if (contract == null)
{
throw new FacilityException("The service contract for the client endpoint could not be determined.");
}
if (model.Services.Contains(contract) == false)
{
throw new FacilityException(string.Format(
"The service contract {0} is not supported by the component {0} or any of its services.",
clientModel.Contract.FullName, model.Implementation.FullName));
}
}
public override object Create(IKernel kernel, object instance, ComponentModel model,
CreationContext context, params object[] constructorArguments)
{
var channelHolder = instance as IWcfChannelHolder;
if (channelHolder == null)
{
throw new ArgumentException(string.Format("Given instance is not an {0}", typeof(IWcfChannelHolder)), "instance");
}
var isDuplex = IsDuplex(channelHolder.RealProxy);
var proxyOptions = model.ObtainProxyOptions();
var serviceContract = model.GetServiceContract();
var remainingServices = model.Services.Except(new[] { serviceContract });
var generationOptions = CreateProxyGenerationOptions(serviceContract, proxyOptions, kernel, context);
generationOptions.AddMixinInstance(channelHolder);
var additionalInterfaces = GetInterfaces(remainingServices, proxyOptions, isDuplex);
var interceptors = GetInterceptors(kernel, model, serviceContract, channelHolder, context);
return(generator.CreateInterfaceProxyWithTargetInterface(serviceContract,
additionalInterfaces, channelHolder.Channel, generationOptions, interceptors));
}
