castleproject / windsor Goto Github PK

    public void Bug()
    {
        var container = new WindsorContainer();
        container.AddFacility<TypedFactoryFacility>();

        container.Register(Component.For<ISomeServiceToResolveLater>().ImplementedBy<SomeServiceToResolverLaterImpl>());
        container.Register(Component.For<ISomethingWithAFuncCtorDependency>().ImplementedBy<SomethingWithAFuncCtorDependency>());
        container.Register(Component.For<ClassWithOptionalDependency>());

        // this will make the test pass
        // container.Resolve<ISomethingWithAFuncCtorDependency>();

        var component = container.Resolve<ClassWithOptionalDependency>();

        Assert.That(component.Optional, Is.Not.Null);
    }

public class ClassWithOptionalDependency
{
    public ISomethingWithAFuncCtorDependency Optional { get; set; } 
}
public interface ISomeServiceToResolveLater
{

}
public class ISomethingWithAFuncCtorDependency
{

}
public class SomeServiceToResolverLaterImpl : ISomeServiceToResolveLater
{
     public SomeServiceToResolverLaterImpl(string giveMeThis)
     {

     }
}
public class SomethingWithAFuncCtorDependency : ISomethingWithAFuncCtorDependency
{
    private Func<string, ISomeServiceToResolveLater> _mandatory;

    public SomethingWithAFuncCtorDependency(Func<string, ISomeServiceToResolveLater> mandatory)
    {
        _mandatory = mandatory;
    }
}

    public class ArchiveSerializerContractBehaviorAttribute : Attribute, IContractBehavior
    {
...
    }

Server Error in '/' Application.

The value could not be added to the collection, as the collection already contains an item of the same type: 'Common.Interfaces.Wcf.ArchiveSerializerContractBehaviorAttribute'. This collection only supports one instance of each type.
Parameter name: item 
  Description: An unhandled exception occurred during the execution of the current web request. Please review the stack trace for more information about the error and where it originated in the code. 

 Exception Details: System.ArgumentException: The value could not be added to the collection, as the collection already contains an item of the same type: 'Common.Interfaces.Wcf.ArchiveSerializerContractBehaviorAttribute'. This collection only supports one instance of each type.
Parameter name: item

Source Error: 


 An unhandled exception was generated during the execution of the current web request. Information regarding the origin and location of the exception can be identified using the exception stack trace below.  

Stack Trace: 



[ArgumentException: The value could not be added to the collection, as the collection already contains an item of the same type: 'Common.Interfaces.Wcf.ArchiveSerializerContractBehaviorAttribute'. This collection only supports one instance of each type.
Parameter name: item]
   System.Collections.Generic.KeyedByTypeCollection`1.InsertItem(Int32 index, TItem item) +17217335
   Castle.Facilities.WcfIntegration.Internal.WcfUtils.AddBehaviors(IKernel kernel, WcfExtensionScope scope, ICollection`1 behaviors, IWcfBurden burden, Predicate`1 predicate) +299
   Castle.Facilities.WcfIntegration.WcfEndpointExtensions.Install(ServiceEndpoint endpoint, Boolean withContract, IKernel kernel, IWcfBurden burden) +201
   Castle.Facilities.WcfIntegration.ServiceHostExtensions.Castle.Facilities.WcfIntegration.IWcfExtensionVisitor.VisitEndpointExtension(IWcfEndpointExtension extension) +334
   Castle.Facilities.WcfIntegration.ServiceHostExtensions.Install(ICollection`1 extensions, IWcfBurden burden) +110
   Castle.Facilities.WcfIntegration.AbstractServiceHostBuilder.ConfigureServiceHost(ServiceHost serviceHost, IWcfServiceModel serviceModel, ComponentModel model) +931
   Castle.Facilities.WcfIntegration.AbstractServiceHostBuilder`1.Build(ComponentModel model, Uri[] baseAddresses) +50
   Castle.Facilities.WcfIntegration.WindsorServiceHostFactory`1.CreateServiceHost(String constructorString, Uri[] baseAddresses) +273
   System.ServiceModel.HostingManager.CreateService(String normalizedVirtualPath, EventTraceActivity eventTraceActivity) +1451
   System.ServiceModel.HostingManager.ActivateService(ServiceActivationInfo serviceActivationInfo, EventTraceActivity eventTraceActivity) +76
   System.ServiceModel.HostingManager.EnsureServiceAvailable(String normalizedVirtualPath, EventTraceActivity eventTraceActivity) +901

[ServiceActivationException: The service '/ProductService.svc' cannot be activated due to an exception during compilation.  The exception message is: The value could not be added to the collection, as the collection already contains an item of the same type: 'Common.Interfaces.Wcf.ArchiveSerializerContractBehaviorAttribute'. This collection only supports one instance of each type.
Parameter name: item.]
   System.Runtime.AsyncResult.End(IAsyncResult result) +654324
   System.ServiceModel.Activation.HostedHttpRequestAsyncResult.End(IAsyncResult result) +210877
   System.Web.AsyncEventExecutionStep.OnAsyncEventCompletion(IAsyncResult ar) +166

<parameters>
    <myProcessor>
       ${myProcessor}
    </myProcessor>
</parameters>```

It only works if I change them to a single line like this:

```<parameters>
   <myProcessor>${myProcessor}</myProcessor>
</parameters>```


Is there likely to be a fix for this as reformatting all of our config files for our clients as well as updating our documentation will be considerable work.



Thanks


Chris

protected override IController GetControllerInstance(RequestContext requestContext, Type controllerType)
{
    if (controllerType == null)
    {
        throw new HttpException(404, string.Format("The controller for path '{0}' could not be found.", requestContext.HttpContext.Request.Path));
    }

    // HANG HERE
    return (IController) _kernel.Resolve(controllerType);
}

        public static T GetClient<T>(this IWcfClientFactory factory) where T : class
        {
            var componentName = typeof (T).FullName;
            return factory.GetClient<T>(componentName);
        }

Castle.MicroKernel.ComponentActivator.ComponentActivatorException: WcfClientActivator: could not proxy component XXX ---> System.NullReferenceException: Object reference not set to an instance of an object.
   at System.RuntimeMethodHandle.GetHashCode()
   at System.Collections.Generic.ObjectEqualityComparer`1.GetHashCode(T obj)
   at System.Collections.Generic.Dictionary`2.FindEntry(TKey key)
   at System.ServiceModel.Dispatcher.OperationSelectorBehavior.MethodInfoOperationSelector..ctor(ContractDescription description, MessageDirection directionThatRequiresClientOpSelection)
   at System.ServiceModel.Dispatcher.OperationSelectorBehavior.System.ServiceModel.Description.IContractBehavior.ApplyClientBehavior(ContractDescription description, ServiceEndpoint endpoint, ClientRuntime proxy)
   at System.ServiceModel.Description.DispatcherBuilder.ApplyClientBehavior(ServiceEndpoint serviceEndpoint, ClientRuntime clientRuntime)
   at System.ServiceModel.Description.DispatcherBuilder.BuildProxyBehavior(ServiceEndpoint serviceEndpoint, BindingParameterCollection& parameters)
   at System.ServiceModel.Channels.ServiceChannelFactory.BuildChannelFactory(ServiceEndpoint serviceEndpoint, Boolean useActiveAutoClose)
   at System.ServiceModel.ChannelFactory.CreateFactory()
   at System.ServiceModel.ChannelFactory.OnOpening()
   at System.ServiceModel.Channels.CommunicationObject.Open(TimeSpan timeout)
   at System.ServiceModel.ChannelFactory.EnsureOpened()
   at System.ServiceModel.ChannelFactory`1.CreateChannel(EndpointAddress address, Uri via)
   at System.ServiceModel.ChannelFactory`1.CreateChannel()
   at Castle.Facilities.WcfIntegration.WcfClientActivator.<>c__DisplayClass6.<GetChannelCreator>b__1()
   at Castle.Facilities.WcfIntegration.WcfChannelHolder.CreateChannel()
   at Castle.Facilities.WcfIntegration.WcfChannelHolder..ctor(ChannelCreator channelCreator, IWcfBurden burden, Nullable`1 closeTimeout)
   at Castle.Facilities.WcfIntegration.WcfClientActivator.Instantiate(CreationContext context)
   --- End of inner exception stack trace ---
   at Castle.Facilities.WcfIntegration.WcfClientActivator.Instantiate(CreationContext context)
   at Castle.MicroKernel.ComponentActivator.DefaultComponentActivator.InternalCreate(CreationContext context)
   at Castle.MicroKernel.ComponentActivator.AbstractComponentActivator.Create(CreationContext context, Burden burden)
   at Castle.MicroKernel.Lifestyle.AbstractLifestyleManager.CreateInstance(CreationContext context, Boolean trackedExternally)
   at Castle.MicroKernel.Lifestyle.AbstractLifestyleManager.Resolve(CreationContext context, IReleasePolicy releasePolicy)
   at Castle.MicroKernel.Handlers.DefaultHandler.ResolveCore(CreationContext context, Boolean requiresDecommission, Boolean instanceRequired, Burden& burden)
   at Castle.MicroKernel.Handlers.DefaultHandler.Resolve(CreationContext context, Boolean instanceRequired)
   at Castle.MicroKernel.Handlers.AbstractHandler.Resolve(CreationContext context)
   at Castle.MicroKernel.DefaultKernel.ResolveComponent(IHandler handler, Type service, IDictionary additionalArguments, IReleasePolicy policy)
   at Castle.MicroKernel.DefaultKernel.Castle.MicroKernel.IKernelInternal.Resolve(String key, Type service, IDictionary arguments, IReleasePolicy policy)
   at Castle.Facilities.WcfIntegration.WcfClientFactorySelector.<>c__DisplayClass2.<SelectComponent>b__1(IKernelInternal k, IReleasePolicy p)
   at Castle.Facilities.TypedFactory.Internal.TypedFactoryInterceptor.Resolve(IInvocation invocation)
   at Castle.Facilities.TypedFactory.Internal.TypedFactoryInterceptor.Intercept(IInvocation invocation)
   at Castle.DynamicProxy.AbstractInvocation.Proceed()
   at Castle.Proxies.IWcfClientFactoryProxy.GetClient[T](String name)

System.TypeLoadException occurred
  _HResult=-2146233054
  _message=GenericArguments[0], 'System.ServiceModel.ServiceHostBase', on 
           'Castle.Facilities.WcfIntegration.IChannelFactoryBuilder`1[M]' 
           violates the constraint of type parameter 'M'.
  HResult=-2146233054
  IsTransient=false
  Message=GenericArguments[0], 'System.ServiceModel.ServiceHostBase', on 
          'Castle.Facilities.WcfIntegration.IChannelFactoryBuilder`1[M]' 
          violates the constraint of type parameter 'M'.
  ResourceId=0
  TypeName=""
  InnerException: 

host = new DefaultServiceHostFactory().CreateServiceHost(typeof(IAdminServices).AssemblyQualifiedName, new Uri[0]);
host.Open();

<%@ ServiceHost
  Language="C#" Service="MyService"
  Factory="Castle.Facilities.WcfIntegration.DefaultServiceHostFactory, Castle.Facilities.WcfIntegration"
  %>

private static object poolFactoryLock = new object();
protected IPool CreatePool(int initialSize, int maxSize)
{
    if (!Kernel.HasComponent(typeof(IPoolFactory)))
    {
        lock (poolFactoryLock)
        { 
            if (!Kernel.HasComponent(typeof(IPoolFactory))) // Avoid the race
            {
                Kernel.Register(Component.For<IPoolFactory>().ImplementedBy<DefaultPoolFactory>().NamedAutomatically("castle.internal-pool-factory"));
            }
        }
    }
}

        [Test]
        public void CreatePoolRaceCondition()
        {
            using (AutoResetEvent evt = new AutoResetEvent(false))
            {
                MyKernel kernel = new MyKernel(evt);

                var manager1 = new MyClass();
                var manager2 = new MyClass();

                manager1.Init(null, kernel, null);
                manager2.Init(null, kernel, null);

                Task.Factory.StartNew(() => manager1.CreatePool());
                Task.Factory.StartNew(() => manager2.CreatePool());

                Thread.Sleep(TimeSpan.FromSeconds(5));
                evt.Set();
                Thread.Sleep(TimeSpan.FromSeconds(5));

                Assert.That(kernel.parallelCount, Is.EqualTo(0));
            }
        }

        private class MyClass : PoolableLifestyleManager
        {
            public MyClass()
                : base(1, 2)
            {            
            }

            public void CreatePool()
            {
                base.CreatePool(2, 5).Dispose();
            }
        }

        private class MyKernel : IKernel
        {
            private readonly AutoResetEvent evt;
            public event ComponentDataDelegate ComponentRegistered;
            public event ComponentModelDelegate ComponentModelCreated;
            public event EventHandler AddedAsChildKernel;
            public event EventHandler RemovedAsChildKernel;
            public event ComponentInstanceDelegate ComponentCreated;
            public event ComponentInstanceDelegate ComponentDestroyed;
            public event HandlerDelegate HandlerRegistered;
            public event HandlersChangedDelegate HandlersChanged;
            public event DependencyDelegate DependencyResolving;
            public event EventHandler RegistrationCompleted;
            public event ServiceDelegate EmptyCollectionResolving;

            public MyKernel(AutoResetEvent evt)
            {
                this.evt = evt;
            }

            public void Dispose()
            {
            }

            object IKernel.this[string key]
            {
                get { throw new NotImplementedException(); }
            }

            object IKernel.this[Type service]
            {
                get { throw new NotImplementedException(); }
            }

            public void AddComponent(string key, Type classType)
            {
                throw new NotImplementedException();
            }

            public void AddComponent(string key, Type classType, LifestyleType lifestyle)
            {
                throw new NotImplementedException();
            }

            public void AddComponent(string key, Type classType, LifestyleType lifestyle, bool overwriteLifestyle)
            {
                throw new NotImplementedException();
            }

            public void AddComponent(string key, Type serviceType, Type classType)
            {
                throw new NotImplementedException();
            }

            public void AddComponent(string key, Type serviceType, Type classType, LifestyleType lifestyle)
            {
                throw new NotImplementedException();
            }

            public void AddComponent(string key, Type serviceType, Type classType, LifestyleType lifestyle, bool overwriteLifestyle)
            {
                throw new NotImplementedException();
            }

            public void AddComponent<T>()
            {
                throw new NotImplementedException();
            }

            public void AddComponent<T>(LifestyleType lifestyle)
            {
                throw new NotImplementedException();
            }

            public void AddComponent<T>(LifestyleType lifestyle, bool overwriteLifestyle)
            {
                throw new NotImplementedException();
            }

            public void AddComponent<T>(Type serviceType)
            {
                throw new NotImplementedException();
            }

            public void AddComponent<T>(Type serviceType, LifestyleType lifestyle)
            {
                throw new NotImplementedException();
            }

            public void AddComponent<T>(Type serviceType, LifestyleType lifestyle, bool overwriteLifestyle)
            {
                throw new NotImplementedException();
            }

            public void AddComponentInstance<T>(object instance)
            {
                throw new NotImplementedException();
            }

            public void AddComponentInstance<T>(Type serviceType, object instance)
            {
                throw new NotImplementedException();
            }

            public void AddComponentInstance(string key, object instance)
            {
                throw new NotImplementedException();
            }

            public void AddComponentInstance(string key, Type serviceType, object instance)
            {
                throw new NotImplementedException();
            }

            public void AddComponentInstance(string key, Type serviceType, Type classType, object instance)
            {
                throw new NotImplementedException();
            }

            public void AddComponentWithExtendedProperties(string key, Type classType, IDictionary extendedProperties)
            {
                throw new NotImplementedException();
            }

            public void AddComponentWithExtendedProperties(string key, Type serviceType, Type classType, IDictionary extendedProperties)
            {
                throw new NotImplementedException();
            }

            public IKernel AddFacility(string key, IFacility facility)
            {
                throw new NotImplementedException();
            }

            public IKernel AddFacility<T>(string key) where T : IFacility, new()
            {
                throw new NotImplementedException();
            }

            public IKernel AddFacility<T>(string key, Action<T> onCreate) where T : IFacility, new()
            {
                throw new NotImplementedException();
            }

            public object Resolve(string key, object argumentsAsAnonymousType)
            {
                throw new NotImplementedException();
            }

            public object Resolve(string key, IDictionary arguments)
            {
                throw new NotImplementedException();
            }

            public IComponentModelBuilder ComponentModelBuilder { get; private set; }
            public IConfigurationStore ConfigurationStore { get; set; }
            public GraphNode[] GraphNodes { get; private set; }
            public IHandlerFactory HandlerFactory { get; private set; }
            public IKernel Parent { get; set; }
            public IProxyFactory ProxyFactory { get; set; }
            public IReleasePolicy ReleasePolicy { get; set; }
            public IDependencyResolver Resolver { get; private set; }

            public void AddChildKernel(IKernel kernel)
            {
                throw new NotImplementedException();
            }

            public IKernel AddFacility(IFacility facility)
            {
                throw new NotImplementedException();
            }

            public IKernel AddFacility<T>() where T : IFacility, new()
            {
                throw new NotImplementedException();
            }

            public IKernel AddFacility<T>(Action<T> onCreate) where T : IFacility, new()
            {
                throw new NotImplementedException();
            }

            public void AddHandlerSelector(IHandlerSelector selector)
            {
                throw new NotImplementedException();
            }

            public void AddHandlersFilter(IHandlersFilter filter)
            {
                throw new NotImplementedException();
            }

            public void AddSubSystem(string name, ISubSystem subsystem)
            {
                throw new NotImplementedException();
            }

            public IHandler[] GetAssignableHandlers(Type service)
            {
                throw new NotImplementedException();
            }

            public IFacility[] GetFacilities()
            {
                throw new NotImplementedException();
            }

            public IHandler GetHandler(string name)
            {
                throw new NotImplementedException();
            }

            public IHandler GetHandler(Type service)
            {
                throw new NotImplementedException();
            }

            public IHandler[] GetHandlers(Type service)
            {
                throw new NotImplementedException();
            }

            public ISubSystem GetSubSystem(string name)
            {
                throw new NotImplementedException();
            }

            public bool HasComponent(string name)
            {
                throw new NotImplementedException();
            }

            public int parallelCount = 0;
            private bool registered;

            public bool HasComponent(Type service)
            {
                return registered;
            }

            public IKernel Register(params IRegistration[] registrations)
            {
                Interlocked.Increment(ref parallelCount);
                evt.WaitOne();
                registered = true;
                Interlocked.CompareExchange(ref parallelCount, 0, 1);
                return null;
            }

            public void ReleaseComponent(object instance)
            {
                throw new NotImplementedException();
            }

            public void RemoveChildKernel(IKernel kernel)
            {
                throw new NotImplementedException();
            }

            public object Resolve(Type service)
            {
                throw new NotImplementedException();
            }

            public object Resolve(Type service, IDictionary arguments)
            {
                throw new NotImplementedException();
            }

            public object Resolve(Type service, object argumentsAsAnonymousType)
            {
                throw new NotImplementedException();
            }

            public object Resolve(string key, Type service)
            {
                throw new NotImplementedException();
            }

            public T Resolve<T>(IDictionary arguments)
            {
                throw new NotImplementedException();
            }

            public T Resolve<T>(object argumentsAsAnonymousType)
            {
                throw new NotImplementedException();
            }

            public T Resolve<T>()
            {
                return (T)(object)new DummyFactory();
            }

            public T Resolve<T>(string key)
            {
                throw new NotImplementedException();
            }

            public T Resolve<T>(string key, IDictionary arguments)
            {
                throw new NotImplementedException();
            }

            public object Resolve(string key, Type service, IDictionary arguments)
            {
                throw new NotImplementedException();
            }

            public Array ResolveAll(Type service)
            {
                throw new NotImplementedException();
            }

            public Array ResolveAll(Type service, IDictionary arguments)
            {
                throw new NotImplementedException();
            }

            public Array ResolveAll(Type service, object argumentsAsAnonymousType)
            {
                throw new NotImplementedException();
            }

            public TService[] ResolveAll<TService>()
            {
                throw new NotImplementedException();
            }

            public TService[] ResolveAll<TService>(IDictionary arguments)
            {
                throw new NotImplementedException();
            }

            public TService[] ResolveAll<TService>(object argumentsAsAnonymousType)
            {
                throw new NotImplementedException();
            }
        }

        private class DummyFactory : IPoolFactory
        {
            public IPool Create(int initialsize, int maxSize, IComponentActivator activator)
            {
                return new MyPool();
            }
        }

        private sealed class MyPool : IPool
        {
            public void Dispose()
            {
            }

            public bool Release(object instance)
            {
                throw new NotImplementedException();
            }

            public object Request(CreationContext context, Func<CreationContext, Burden> creationCallback)
            {
                throw new NotImplementedException();
            }
        }

var binding = MetadataExchangeBindings.CreateMexHttpBinding();
var mexAddress = "http://localhost:8744/TVIRecorderWcfService/mex";
var behaviour = new ServiceMetadataBehavior() {HttpGetEnabled = true};


serviceHost.Description.Behaviors.Add(behaviour);
serviceHost.AddServiceEndpoint(typeof(IMetadataExchange), binding, mexAddress);

public class WindsorInstaller: IWindsorInstaller
{
    public void Install(IWindsorContainer container, IConfigurationStore store)
    {
        container.AddFacility<LoggingFacility>(f => f.UseLog4Net());

        container
            .AddFacility<WcfFacility>(f =>
            {
                f.CloseTimeout = TimeSpan.Zero;
            });


        string baseAddress = "http://localhost:8744/TVIRecorderWcfService/";

        container.Register(

            Component
                .For<ITVIRecorderWcfService>()
                .ImplementedBy<TVIRecorderWcfService>()
                .AsWcfService(
                new DefaultServiceModel()
                    .AddBaseAddresses(baseAddress)
                    .Hosted()
                    //publish doesn't either put here or below
                    //.PublishMetadata(x => x.EnableHttpGet()).Discoverable()
                    .AddEndpoints(WcfEndpoint
                        .BoundTo(new BasicHttpBinding()))
                        //.PublishMetadata(x=>x.EnableHttpGet()).Discoverable()
                        ).LifestyleSingleton()
                        ,

            Component
                .For<ServiceBase>()
                .ImplementedBy<TVIRecorderService>());
    }
}

    [Fact]
    public void ReleasingPoolDisposesItems()
    {
        // Arrange.
        bool result = false;
        var container = new WindsorContainer();
        container.Register(Component.For<DisposableMock>().LifestylePooled(1, 5));
        container.Release(container.Resolve<DisposableMock>(new { disposeAction = new Action(() => result = true) }));

        // Act.
        container.Dispose();

        // Assert.
        Assert.True(result);
    }

public class DisposableMock : IDisposable
{
    private Action disposeAction;

    public DisposableMock(Action disposeAction)
    {
        this.disposeAction = disposeAction;
    }

    public void Dispose()
    {
        disposeAction();
    }
}

Server stack trace: 
   bei System.ServiceModel.Channels.CommunicationObject.Close(TimeSpan timeout)
Exception rethrown at [0]: 
   bei System.Runtime.Remoting.Proxies.RealProxy.HandleReturnMessage(IMessage reqMsg, IMessage retMsg)
   bei System.Runtime.Remoting.Proxies.RealProxy.PrivateInvoke(MessageData& msgData, Int32 type)
   bei System.IDisposable.Dispose()
   bei Castle.MicroKernel.LifecycleConcerns.DisposalConcern.Apply(ComponentModel model, Object component)
   bei Castle.MicroKernel.ComponentActivator.AbstractComponentActivator.ApplyConcerns(IEnumerable`1 steps, Object instance)
   bei Castle.MicroKernel.ComponentActivator.AbstractComponentActivator.ApplyDecommissionConcerns(Object instance)
   bei Castle.Facilities.WcfIntegration.WcfClientActivator.ApplyDecommissionConcerns(Object instance)
   bei Castle.MicroKernel.ComponentActivator.DefaultComponentActivator.InternalDestroy(Object instance)
   bei Castle.MicroKernel.ComponentActivator.AbstractComponentActivator.Destroy(Object instance)
   bei Castle.MicroKernel.Lifestyle.AbstractLifestyleManager.Release(Object instance)
   bei Castle.MicroKernel.Handlers.DefaultHandler.ReleaseCore(Burden burden)
   bei Castle.MicroKernel.Handlers.AbstractHandler.Release(Burden burden)
   bei Castle.MicroKernel.Burden.Release()
   bei XXXXXXXXXXX.DependencyInjection.Castle.DependencyInjectionContainer.FixedLifecycledComponentsReleasePolicy.Release(Object instance)
   bei Castle.MicroKernel.DefaultKernel.ReleaseComponent(Object instance)
   bei Castle.MicroKernel.Internal.LazyEx`1.Dispose()
   bei Castle.MicroKernel.LifecycleConcerns.DisposalConcern.Apply(ComponentModel model, Object component)
   bei Castle.MicroKernel.ComponentActivator.AbstractComponentActivator.ApplyConcerns(IEnumerable`1 steps, Object instance)
   bei Castle.MicroKernel.ComponentActivator.AbstractComponentActivator.ApplyDecommissionConcerns(Object instance)
   bei Castle.MicroKernel.ComponentActivator.DefaultComponentActivator.InternalDestroy(Object instance)
   bei Castle.MicroKernel.ComponentActivator.AbstractComponentActivator.Destroy(Object instance)
   bei Castle.MicroKernel.Lifestyle.AbstractLifestyleManager.Release(Object instance)
   bei Castle.MicroKernel.Handlers.DefaultHandler.ReleaseCore(Burden burden)
   bei Castle.MicroKernel.Handlers.AbstractHandler.Release(Burden burden)
   bei Castle.MicroKernel.Burden.Release()
   bei Castle.MicroKernel.Burden.<Release>b__0(Burden c)
   bei System.Collections.Generic.List`1.ForEach(Action`1 action)
   bei Castle.MicroKernel.Burden.Release()
   bei Castle.MicroKernel.Lifestyle.Scoped.ScopeCache.<Dispose>b__0(Burden b)
   bei Castle.Core.Internal.CollectionExtensions.ForEach[T](IEnumerable`1 items, Action`1 action)
   bei Castle.MicroKernel.Lifestyle.Scoped.ScopeCache.Dispose()
   bei Castle.MicroKernel.Lifestyle.Scoped.DefaultLifetimeScope.Dispose()
   bei Castle.Facilities.WcfIntegration.Lifestyles.WcfOperationScopeHolder.Dispose()
   bei Castle.Facilities.WcfIntegration.Lifestyles.WcfOperationScopeHolder.Shutdown(Object sender, EventArgs e)
   bei System.ServiceModel.OperationContext.FireOperationCompleted()

public void Apply(ComponentModel model, object component)
{
    // HACK
    var attributes = component.GetType().GetCustomAttributes(typeof(ServiceContractAttribute), true);
    if (attributes.Any())
    {
        var channel = component as IChannel;
        if (channel != null && channel.State == CommunicationState.Faulted)
        {
            channel.Abort();
        }
    }

    var disposable = component as IDisposable;
    if (disposable == null)
    {
        return;
    }
    disposable.Dispose();
}

DuplexClientModel model = new DuplexClientModel
    {
        Endpoint = WcfEndpoint.ForContract<IServiceWithCallback>()
            .FromConfiguration("IServiceWithCallback_Endpoint")

    }.Callback(callbackService);

DuplexClientModel model = new DuplexClientModel
    {
        Endpoint = WcfEndpoint.ForContract<IServiceWithCallback>()                 
           .BoundTo(new NetTcpBinding())
           .At("net.tcp://localhost:9898/ServiceWithCallback")

    }.Callback(callbackService);