Elegant Code » WCF

Integrating Castle Windsor and NHibernate with WCF

Jan Van Ryswyck — Sun, 18 May 2008 14:08:20 +0000

Up until now, we were using the NHibernate facility of Castle Windsor for managing our NHibernate sessions in WCF. But, we want to have a session-per-request approach as one would use when integrating NHibernate with a regular web application.

Yesterday I did a small spike to figure out how this should work. It turned out to be pretty easy. I used this excellent blog post written by Oran Dennison as my guide.

First I created a class that implemented the IServiceBehavior interface.

public class DIServiceBehavior : IServiceBehavior
{
    private readonly ISessionFactory _sessionFactory;

    public DIServiceBehavior()
    {
        _sessionFactory = new Configuration()
            .Configure()
            .BuildSessionFactory();

        XmlConfigurator.Configure();    // Log4Net
    }

    public void ApplyDispatchBehavior(
             ServiceDescription serviceDescription, 
             ServiceHostBase serviceHostBase)
    {
        foreach(ChannelDispatcherBase cdb in 
                serviceHostBase.ChannelDispatchers)
        {
            ChannelDispatcher cd = cdb as ChannelDispatcher;
            if(cd != null)
            {
                foreach(EndpointDispatcher ed in cd.Endpoints)
                {
                    ed.DispatchRuntime.InstanceProvider =
                        new DIInstanceProvider
                            (serviceDescription.ServiceType,
                              _sessionFactory);
                }
            }
        }
    }

    public void AddBindingParameters(
                ServiceDescription serviceDescription, 
                ServiceHostBase serviceHostBase,
                Collection<ServiceEndpoint> endpoints, 
                BindingParameterCollection bindingParameters) 
    { }
    
    public void Validate(ServiceDescription serviceDescription, 
                         ServiceHostBase serviceHostBase) 
    { }
}

The SessionFactory is created in the constructor because the ApplyDispatchBehaviour method can be called multiple times (for each endpoint).

The next step is to create an instance provider by creating a class that implements the IInstanceProvider:

public class DIInstanceProvider : IInstanceProvider
{
    private const String NHibernateSessionKey = 
        "NHibernate.Session";

    private readonly Type _serviceType;
    private IDependencyContainer _dependencyContainer;
    private readonly ISessionFactory _sessionFactory;
    private ISession _session;

    public DIInstanceProvider(Type serviceType,
                               ISessionFactory sessionFactory)
    {
        Debug.Assert(null != serviceType, 
                     "null != serviceType");
        _serviceType = serviceType;

        Debug.Assert(null != sessionFactory, 
                     "null = sessionFactory");
        _sessionFactory = sessionFactory;
    }

    public Object GetInstance(InstanceContext instanceContext)
    {
        return GetInstance(instanceContext, null);
    }

    public Object GetInstance(InstanceContext instanceContext, 
                                Message message)
    {
        _dependencyContainer = new DependencyContainer();

        _session = _sessionFactory.OpenSession();
        _dependencyContainer
          .AddComponentInstance(NHibernateSessionKey, _session);

        return _dependencyContainer.Resolve(_serviceType);
    }

    public void ReleaseInstance(InstanceContext instanceContext, 
                                 Object instance)
    {
        if(null != _session)
        {
            _session.Close();
            _session = null;
        }

        if(null != _dependencyContainer)
        {
            _dependencyContainer.Dispose();
            _dependencyContainer = null;
        }
    }
}

I created a wrapper class around for Castle Windsor named DependencyContainer. The GetInstance method opens a new session using the SessionFactory object we instantiated in the service behavior class. The session object is then registered with Castle Windsor. We can now implement our repositories like this:

public class SomeAggregateRepository
{
    private ISession _session;

    public SomeAggregateRepository(ISession session)
    {
        _session = session;
    }
    
    public SomeAggregate Get(Int64 id) 
    {
        return _session.Get<SomeAggregate>(id);
    }
}

When our service operation has been executed, the NHibernate is released by the ReleaseInstance method. Finishing our example, we need to implement a custom ServiceHost and a ServiceHostFactory:

public class DIServiceHost : ServiceHost
{
    public DependencyInjectionServiceHost() 
        : base() 
    { }
    
    public DIServiceHost(Type serviceType, 
                         params Uri[] baseAddresses) 
        : base(serviceType, baseAddresses) 
    { }

    protected override void OnOpening()
    {
        Description.Behaviors.Add(new DIServiceBehavior());
        base.OnOpening();
    }
}

public class DIServiceHostFactory : ServiceHostFactory
{
    protected override ServiceHost CreateServiceHost(
            Type serviceType, Uri[] baseAddresses)
    {
        return new DIServiceHost(serviceType, baseAddresses);
    }
}

The custom ServiceHostFactory class can now be used in the ServiceHost file required when doing IIS hosting:

<%@ ServiceHost Language="C#" 
                Debug="true" 
                Service="WindsorService.MyWindsorService" 
                Factory="WindsorService.DIServiceHostFactory"
                CodeBehind="MyWindsorService.svc.cs" %>

There is also another way for achieving this that I will be investigating the next week or so using the WCF Integration Facility for Castle Windsor. For some reason it is not available in the current release of the Castle stack so I have to grab it from the trunk.

If you have any thoughts, improvements or suggestions I'm glad to hear them from you, my dear reader. It's the only way I'll ever learn :-).

Till next time.

WCF friction

Jan Van Ryswyck — Tue, 13 May 2008 18:10:54 +0000

Today I spent some time (thank God no more than 15 minutes) tracking down a WCF issue from hell. Every time I made a call to the service I got the following exception: System.ServiceModel.CommunicationException : The underlying connection was closed: The connection was closed unexpectedly. This is really helpful, isn't it? Fortunately there is some tool that helped me out a great deal: Service Trace Viewer Tool (SvcTraceViewer.exe). Turns out that I forgot to place a DataContract attribute on one of my DTO objects. Why am I too stupid to deduce this from the exception message in the first place?

Demonstrating WCF: Beyond the endpoints

Jan Van Ryswyck — Sun, 18 May 2008 14:08:20 +0000

Yesterday I did a small spike to figure out how this should work. It turned out to be pretty easy. I used this excellent blog post written by Oran Dennison as my guide.

First I created a class that implemented the IServiceBehavior interface.

public class DIServiceBehavior : IServiceBehavior
{
    private readonly ISessionFactory _sessionFactory;

    public DIServiceBehavior()
    {
        _sessionFactory = new Configuration()
            .Configure()
            .BuildSessionFactory();

        XmlConfigurator.Configure();    // Log4Net
    }

    public void ApplyDispatchBehavior(
             ServiceDescription serviceDescription, 
             ServiceHostBase serviceHostBase)
    {
        foreach(ChannelDispatcherBase cdb in 
                serviceHostBase.ChannelDispatchers)
        {
            ChannelDispatcher cd = cdb as ChannelDispatcher;
            if(cd != null)
            {
                foreach(EndpointDispatcher ed in cd.Endpoints)
                {
                    ed.DispatchRuntime.InstanceProvider =
                        new DIInstanceProvider
                            (serviceDescription.ServiceType,
                              _sessionFactory);
                }
            }
        }
    }

    public void AddBindingParameters(
                ServiceDescription serviceDescription, 
                ServiceHostBase serviceHostBase,
                Collection<ServiceEndpoint> endpoints, 
                BindingParameterCollection bindingParameters) 
    { }
    
    public void Validate(ServiceDescription serviceDescription, 
                         ServiceHostBase serviceHostBase) 
    { }
}

The SessionFactory is created in the constructor because the ApplyDispatchBehaviour method can be called multiple times (for each endpoint).

The next step is to create an instance provider by creating a class that implements the IInstanceProvider:

public class DIInstanceProvider : IInstanceProvider
{
    private const String NHibernateSessionKey = 
        "NHibernate.Session";

    private readonly Type _serviceType;
    private IDependencyContainer _dependencyContainer;
    private readonly ISessionFactory _sessionFactory;
    private ISession _session;

    public DIInstanceProvider(Type serviceType,
                               ISessionFactory sessionFactory)
    {
        Debug.Assert(null != serviceType, 
                     "null != serviceType");
        _serviceType = serviceType;

        Debug.Assert(null != sessionFactory, 
                     "null = sessionFactory");
        _sessionFactory = sessionFactory;
    }

    public Object GetInstance(InstanceContext instanceContext)
    {
        return GetInstance(instanceContext, null);
    }

    public Object GetInstance(InstanceContext instanceContext, 
                                Message message)
    {
        _dependencyContainer = new DependencyContainer();

        _session = _sessionFactory.OpenSession();
        _dependencyContainer
          .AddComponentInstance(NHibernateSessionKey, _session);

        return _dependencyContainer.Resolve(_serviceType);
    }

    public void ReleaseInstance(InstanceContext instanceContext, 
                                 Object instance)
    {
        if(null != _session)
        {
            _session.Close();
            _session = null;
        }

        if(null != _dependencyContainer)
        {
            _dependencyContainer.Dispose();
            _dependencyContainer = null;
        }
    }
}

public class SomeAggregateRepository
{
    private ISession _session;

    public SomeAggregateRepository(ISession session)
    {
        _session = session;
    }
    
    public SomeAggregate Get(Int64 id) 
    {
        return _session.Get<SomeAggregate>(id);
    }
}

When our service operation has been executed, the NHibernate is released by the ReleaseInstance method. Finishing our example, we need to implement a custom ServiceHost and a ServiceHostFactory:

public class DIServiceHost : ServiceHost
{
    public DependencyInjectionServiceHost() 
        : base() 
    { }
    
    public DIServiceHost(Type serviceType, 
                         params Uri[] baseAddresses) 
        : base(serviceType, baseAddresses) 
    { }

    protected override void OnOpening()
    {
        Description.Behaviors.Add(new DIServiceBehavior());
        base.OnOpening();
    }
}

public class DIServiceHostFactory : ServiceHostFactory
{
    protected override ServiceHost CreateServiceHost(
            Type serviceType, Uri[] baseAddresses)
    {
        return new DIServiceHost(serviceType, baseAddresses);
    }
}

The custom ServiceHostFactory class can now be used in the ServiceHost file required when doing IIS hosting:

<%@ ServiceHost Language="C#" 
                Debug="true" 
                Service="WindsorService.MyWindsorService" 
                Factory="WindsorService.DIServiceHostFactory"
                CodeBehind="MyWindsorService.svc.cs" %>

If you have any thoughts, improvements or suggestions I'm glad to hear them from you, my dear reader. It's the only way I'll ever learn :-).

Till next time.

WCF friction

Jan Van Ryswyck — Tue, 13 May 2008 18:10:54 +0000

Demonstrating WCF: Beyond the endpoints

Jan Van Ryswyck — Sun, 18 May 2008 14:08:20 +0000

Yesterday I did a small spike to figure out how this should work. It turned out to be pretty easy. I used this excellent blog post written by Oran Dennison as my guide.

First I created a class that implemented the IServiceBehavior interface.

public class DIServiceBehavior : IServiceBehavior
{
    private readonly ISessionFactory _sessionFactory;

    public DIServiceBehavior()
    {
        _sessionFactory = new Configuration()
            .Configure()
            .BuildSessionFactory();

        XmlConfigurator.Configure();    // Log4Net
    }

    public void ApplyDispatchBehavior(
             ServiceDescription serviceDescription, 
             ServiceHostBase serviceHostBase)
    {
        foreach(ChannelDispatcherBase cdb in 
                serviceHostBase.ChannelDispatchers)
        {
            ChannelDispatcher cd = cdb as ChannelDispatcher;
            if(cd != null)
            {
                foreach(EndpointDispatcher ed in cd.Endpoints)
                {
                    ed.DispatchRuntime.InstanceProvider =
                        new DIInstanceProvider
                            (serviceDescription.ServiceType,
                              _sessionFactory);
                }
            }
        }
    }

    public void AddBindingParameters(
                ServiceDescription serviceDescription, 
                ServiceHostBase serviceHostBase,
                Collection<ServiceEndpoint> endpoints, 
                BindingParameterCollection bindingParameters) 
    { }
    
    public void Validate(ServiceDescription serviceDescription, 
                         ServiceHostBase serviceHostBase) 
    { }
}

The SessionFactory is created in the constructor because the ApplyDispatchBehaviour method can be called multiple times (for each endpoint).

The next step is to create an instance provider by creating a class that implements the IInstanceProvider:

public class DIInstanceProvider : IInstanceProvider
{
    private const String NHibernateSessionKey = 
        "NHibernate.Session";

    private readonly Type _serviceType;
    private IDependencyContainer _dependencyContainer;
    private readonly ISessionFactory _sessionFactory;
    private ISession _session;

    public DIInstanceProvider(Type serviceType,
                               ISessionFactory sessionFactory)
    {
        Debug.Assert(null != serviceType, 
                     "null != serviceType");
        _serviceType = serviceType;

        Debug.Assert(null != sessionFactory, 
                     "null = sessionFactory");
        _sessionFactory = sessionFactory;
    }

    public Object GetInstance(InstanceContext instanceContext)
    {
        return GetInstance(instanceContext, null);
    }

    public Object GetInstance(InstanceContext instanceContext, 
                                Message message)
    {
        _dependencyContainer = new DependencyContainer();

        _session = _sessionFactory.OpenSession();
        _dependencyContainer
          .AddComponentInstance(NHibernateSessionKey, _session);

        return _dependencyContainer.Resolve(_serviceType);
    }

    public void ReleaseInstance(InstanceContext instanceContext, 
                                 Object instance)
    {
        if(null != _session)
        {
            _session.Close();
            _session = null;
        }

        if(null != _dependencyContainer)
        {
            _dependencyContainer.Dispose();
            _dependencyContainer = null;
        }
    }
}

public class SomeAggregateRepository
{
    private ISession _session;

    public SomeAggregateRepository(ISession session)
    {
        _session = session;
    }
    
    public SomeAggregate Get(Int64 id) 
    {
        return _session.Get<SomeAggregate>(id);
    }
}

When our service operation has been executed, the NHibernate is released by the ReleaseInstance method. Finishing our example, we need to implement a custom ServiceHost and a ServiceHostFactory:

public class DIServiceHost : ServiceHost
{
    public DependencyInjectionServiceHost() 
        : base() 
    { }
    
    public DIServiceHost(Type serviceType, 
                         params Uri[] baseAddresses) 
        : base(serviceType, baseAddresses) 
    { }

    protected override void OnOpening()
    {
        Description.Behaviors.Add(new DIServiceBehavior());
        base.OnOpening();
    }
}

public class DIServiceHostFactory : ServiceHostFactory
{
    protected override ServiceHost CreateServiceHost(
            Type serviceType, Uri[] baseAddresses)
    {
        return new DIServiceHost(serviceType, baseAddresses);
    }
}

The custom ServiceHostFactory class can now be used in the ServiceHost file required when doing IIS hosting:

<%@ ServiceHost Language="C#" 
                Debug="true" 
                Service="WindsorService.MyWindsorService" 
                Factory="WindsorService.DIServiceHostFactory"
                CodeBehind="MyWindsorService.svc.cs" %>

If you have any thoughts, improvements or suggestions I'm glad to hear them from you, my dear reader. It's the only way I'll ever learn :-).

Till next time.

Elegant Code » WCF

Jan Van Ryswyck — Sun, 18 May 2008 14:08:20 +0000

Yesterday I did a small spike to figure out how this should work. It turned out to be pretty easy. I used this excellent blog post written by Oran Dennison as my guide.

First I created a class that implemented the IServiceBehavior interface.

public class DIServiceBehavior : IServiceBehavior
{
    private readonly ISessionFactory _sessionFactory;

    public DIServiceBehavior()
    {
        _sessionFactory = new Configuration()
            .Configure()
            .BuildSessionFactory();

        XmlConfigurator.Configure();    // Log4Net
    }

    public void ApplyDispatchBehavior(
             ServiceDescription serviceDescription, 
             ServiceHostBase serviceHostBase)
    {
        foreach(ChannelDispatcherBase cdb in 
                serviceHostBase.ChannelDispatchers)
        {
            ChannelDispatcher cd = cdb as ChannelDispatcher;
            if(cd != null)
            {
                foreach(EndpointDispatcher ed in cd.Endpoints)
                {
                    ed.DispatchRuntime.InstanceProvider =
                        new DIInstanceProvider
                            (serviceDescription.ServiceType,
                              _sessionFactory);
                }
            }
        }
    }

    public void AddBindingParameters(
                ServiceDescription serviceDescription, 
                ServiceHostBase serviceHostBase,
                Collection<ServiceEndpoint> endpoints, 
                BindingParameterCollection bindingParameters) 
    { }
    
    public void Validate(ServiceDescription serviceDescription, 
                         ServiceHostBase serviceHostBase) 
    { }
}

The SessionFactory is created in the constructor because the ApplyDispatchBehaviour method can be called multiple times (for each endpoint).

The next step is to create an instance provider by creating a class that implements the IInstanceProvider:

public class DIInstanceProvider : IInstanceProvider
{
    private const String NHibernateSessionKey = 
        "NHibernate.Session";

    private readonly Type _serviceType;
    private IDependencyContainer _dependencyContainer;
    private readonly ISessionFactory _sessionFactory;
    private ISession _session;

    public DIInstanceProvider(Type serviceType,
                               ISessionFactory sessionFactory)
    {
        Debug.Assert(null != serviceType, 
                     "null != serviceType");
        _serviceType = serviceType;

        Debug.Assert(null != sessionFactory, 
                     "null = sessionFactory");
        _sessionFactory = sessionFactory;
    }

    public Object GetInstance(InstanceContext instanceContext)
    {
        return GetInstance(instanceContext, null);
    }

    public Object GetInstance(InstanceContext instanceContext, 
                                Message message)
    {
        _dependencyContainer = new DependencyContainer();

        _session = _sessionFactory.OpenSession();
        _dependencyContainer
          .AddComponentInstance(NHibernateSessionKey, _session);

        return _dependencyContainer.Resolve(_serviceType);
    }

    public void ReleaseInstance(InstanceContext instanceContext, 
                                 Object instance)
    {
        if(null != _session)
        {
            _session.Close();
            _session = null;
        }

        if(null != _dependencyContainer)
        {
            _dependencyContainer.Dispose();
            _dependencyContainer = null;
        }
    }
}

public class SomeAggregateRepository
{
    private ISession _session;

    public SomeAggregateRepository(ISession session)
    {
        _session = session;
    }
    
    public SomeAggregate Get(Int64 id) 
    {
        return _session.Get<SomeAggregate>(id);
    }
}

When our service operation has been executed, the NHibernate is released by the ReleaseInstance method. Finishing our example, we need to implement a custom ServiceHost and a ServiceHostFactory:

public class DIServiceHost : ServiceHost
{
    public DependencyInjectionServiceHost() 
        : base() 
    { }
    
    public DIServiceHost(Type serviceType, 
                         params Uri[] baseAddresses) 
        : base(serviceType, baseAddresses) 
    { }

    protected override void OnOpening()
    {
        Description.Behaviors.Add(new DIServiceBehavior());
        base.OnOpening();
    }
}

public class DIServiceHostFactory : ServiceHostFactory
{
    protected override ServiceHost CreateServiceHost(
            Type serviceType, Uri[] baseAddresses)
    {
        return new DIServiceHost(serviceType, baseAddresses);
    }
}

The custom ServiceHostFactory class can now be used in the ServiceHost file required when doing IIS hosting:

<%@ ServiceHost Language="C#" 
                Debug="true" 
                Service="WindsorService.MyWindsorService" 
                Factory="WindsorService.DIServiceHostFactory"
                CodeBehind="MyWindsorService.svc.cs" %>

If you have any thoughts, improvements or suggestions I'm glad to hear them from you, my dear reader. It's the only way I'll ever learn :-).

Till next time.

WCF friction

Jan Van Ryswyck — Tue, 13 May 2008 18:10:54 +0000

Demonstrating WCF: Beyond the endpoints

Jan Van Ryswyck — Tue, 13 May 2008 18:10:54 +0000

Elegant Code » WCF

Jan Van Ryswyck — Sun, 18 May 2008 14:08:20 +0000

Yesterday I did a small spike to figure out how this should work. It turned out to be pretty easy. I used this excellent blog post written by Oran Dennison as my guide.

First I created a class that implemented the IServiceBehavior interface.

public class DIServiceBehavior : IServiceBehavior
{
    private readonly ISessionFactory _sessionFactory;

    public DIServiceBehavior()
    {
        _sessionFactory = new Configuration()
            .Configure()
            .BuildSessionFactory();

        XmlConfigurator.Configure();    // Log4Net
    }

    public void ApplyDispatchBehavior(
             ServiceDescription serviceDescription, 
             ServiceHostBase serviceHostBase)
    {
        foreach(ChannelDispatcherBase cdb in 
                serviceHostBase.ChannelDispatchers)
        {
            ChannelDispatcher cd = cdb as ChannelDispatcher;
            if(cd != null)
            {
                foreach(EndpointDispatcher ed in cd.Endpoints)
                {
                    ed.DispatchRuntime.InstanceProvider =
                        new DIInstanceProvider
                            (serviceDescription.ServiceType,
                              _sessionFactory);
                }
            }
        }
    }

    public void AddBindingParameters(
                ServiceDescription serviceDescription, 
                ServiceHostBase serviceHostBase,
                Collection<ServiceEndpoint> endpoints, 
                BindingParameterCollection bindingParameters) 
    { }
    
    public void Validate(ServiceDescription serviceDescription, 
                         ServiceHostBase serviceHostBase) 
    { }
}

The SessionFactory is created in the constructor because the ApplyDispatchBehaviour method can be called multiple times (for each endpoint).

The next step is to create an instance provider by creating a class that implements the IInstanceProvider:

public class DIInstanceProvider : IInstanceProvider
{
    private const String NHibernateSessionKey = 
        "NHibernate.Session";

    private readonly Type _serviceType;
    private IDependencyContainer _dependencyContainer;
    private readonly ISessionFactory _sessionFactory;
    private ISession _session;

    public DIInstanceProvider(Type serviceType,
                               ISessionFactory sessionFactory)
    {
        Debug.Assert(null != serviceType, 
                     "null != serviceType");
        _serviceType = serviceType;

        Debug.Assert(null != sessionFactory, 
                     "null = sessionFactory");
        _sessionFactory = sessionFactory;
    }

    public Object GetInstance(InstanceContext instanceContext)
    {
        return GetInstance(instanceContext, null);
    }

    public Object GetInstance(InstanceContext instanceContext, 
                                Message message)
    {
        _dependencyContainer = new DependencyContainer();

        _session = _sessionFactory.OpenSession();
        _dependencyContainer
          .AddComponentInstance(NHibernateSessionKey, _session);

        return _dependencyContainer.Resolve(_serviceType);
    }

    public void ReleaseInstance(InstanceContext instanceContext, 
                                 Object instance)
    {
        if(null != _session)
        {
            _session.Close();
            _session = null;
        }

        if(null != _dependencyContainer)
        {
            _dependencyContainer.Dispose();
            _dependencyContainer = null;
        }
    }
}

public class SomeAggregateRepository
{
    private ISession _session;

    public SomeAggregateRepository(ISession session)
    {
        _session = session;
    }
    
    public SomeAggregate Get(Int64 id) 
    {
        return _session.Get<SomeAggregate>(id);
    }
}

When our service operation has been executed, the NHibernate is released by the ReleaseInstance method. Finishing our example, we need to implement a custom ServiceHost and a ServiceHostFactory:

public class DIServiceHost : ServiceHost
{
    public DependencyInjectionServiceHost() 
        : base() 
    { }
    
    public DIServiceHost(Type serviceType, 
                         params Uri[] baseAddresses) 
        : base(serviceType, baseAddresses) 
    { }

    protected override void OnOpening()
    {
        Description.Behaviors.Add(new DIServiceBehavior());
        base.OnOpening();
    }
}

public class DIServiceHostFactory : ServiceHostFactory
{
    protected override ServiceHost CreateServiceHost(
            Type serviceType, Uri[] baseAddresses)
    {
        return new DIServiceHost(serviceType, baseAddresses);
    }
}

The custom ServiceHostFactory class can now be used in the ServiceHost file required when doing IIS hosting:

<%@ ServiceHost Language="C#" 
                Debug="true" 
                Service="WindsorService.MyWindsorService" 
                Factory="WindsorService.DIServiceHostFactory"
                CodeBehind="MyWindsorService.svc.cs" %>

If you have any thoughts, improvements or suggestions I'm glad to hear them from you, my dear reader. It's the only way I'll ever learn :-).

Till next time.

WCF friction

Jan Van Ryswyck — Tue, 13 May 2008 18:10:54 +0000

Demonstrating WCF: Beyond the endpoints

Jan Van Ryswyck — Fri, 04 Apr 2008 13:40:52 +0000

Yesterday evening, some team members and myself went to a session about Demonstrating WCF: Beyond the endpoints. The speaker was nobody less than Juval Lowy of IDesign. I'm not particular a newbie when it comes to WCF (although this post lets you believe otherwise), I really had a nice time. It's very clear that Juval is a trained speaker. However, the overall message of WCF as a silver bullet didn't quite catch on to me. Juval is a really smart guy. Therefore, he should know better :-). There are no silver bullets and no universal truths. I must admit that Microsoft did a remarkable job with the first version of WCF. One would almost believe that Scott Gu had something to do with it. But at the end of the road, WCF is one of the many tools in a developers tool bag. Tools can only take you that far but not to the end. Again, I had a really nice time. Kudos to the Belgian Visual Studio User Group.