I have been looking into this lately for a specific reason. Some integration tests I want to write I want to control
the types of instances which are used
inside the service layer but I want that control from
the test class instance. One of
the problems with just referencing
the service is that a lot of
the time this will by default be done
inside a different process. I am using StructureMap as my DI of choice and one of
the tools which I am using inline with RhinoMocks is StructureMap.AutoMocking. With StructureMap
the main entry point is
the ObjectFactory. This will be process specific so if I decide that
the I want a certain instance of a type to be used
inside the ServiceLayer I cannot configure
the ObjectFactory from my test class as that will only apply to
the process which it belongs to. This is were I started thinking about two things: Running a WCF in process Being able to share mocked instances across processes A colleague in work pointed me to a project which is for
the latter but I thought that it would be a better solution if I could run
the WCF Service in process. One of
the projects which I use when I think about WCF Services is AGATHA, and
the one which I have to used to try and get my head around doing this. Another asset I have is a book called Programming WCF Services by Juval Lowy and if you have not heard of it or read it I would definately recommend it. One of
the many topics that is
inside this book is
the type of configuration you need to communicate with a service in
the same process, and it turns out to be quite simple from a config point of view. <system.serviceModel>
<services>
<service name="Agatha.ServiceLayer.WCF.WcfRequestProcessor">
<endpoint
address ="net.pipe://localhost/MyPipe"
binding="netNamedPipeBinding"
contract="Agatha.Common.WCF.IWcfRequestProcessor"/>
</service>
</services>
<client>
<endpoint name="MyEndpoint"
address="net.pipe://localhost/MyPipe"
binding="netNamedPipeBinding"
contract="Agatha.Common.WCF.IWcfRequestProcessor"/>
</client>
</system.serviceModel>
You can see here that I am referencing
the Agatha object and contract here, but also that my binding and
the address is something called Named Pipes. THis is sort of
the “Magic” which makes it happen in
the same process.
Next I need to open
the service prior to calling
the methods on a proxy which I also need. My initial attempt at
the proxy did not use any Agatha specific coding and one of
the pains I found was that you obviously need to give your proxy
the known types which
the serializer can be aware of. So we need to add to
the known types of
the proxy programmatically. I came across
the following blog post which showed me how easy it was http://bloggingabout.net/blogs/vagif/archive/2009/05/18/how-to-programmatically-define-known-types-in-wcf.aspx.
First Pass
So with this in mind, and
inside a console app this was my first pass at consuming a service in process. First here is
the proxy which I made making use of
the Agatha IWcfRequestProcessor contract.
public class InProcProxy : ClientBase<Agatha.Common.WCF.IWcfRequestProcessor>, Agatha.Common.WCF.IWcfRequestProcessor
{
public InProcProxy()
{ }
public InProcProxy(string configurationName)
: base(configurationName)
{ }
public Agatha.Common.Response[] Process(params Agatha.Common.Request[] requests)
{
return Channel.Process(requests);
}
public void ProcessOneWayRequests(params Agatha.Common.OneWayRequest[] requests)
{
Channel.ProcessOneWayRequests(requests);
}
}
So with
the proxy in place I could then use this after opening
the service so here is
the code which I use
inside the console app make
the request.
static void Main(string[] args)
{
ComponentRegistration.Register();
ServiceHost serviceHost = new ServiceHost(typeof(Agatha.ServiceLayer.WCF.WcfRequestProcessor));
serviceHost.Open();
Console.WriteLine("Service is running....");
using (var proxy = new InProcProxy())
{
foreach (var operation in proxy.Endpoint.Contract.Operations)
{
foreach (var t in KnownTypeProvider.GetKnownTypes(null))
{
operation.KnownTypes.Add(t);
}
}
var request = new GetProductsRequest();
var responses = proxy.Process(new[] { request });
var response = (GetProductsResponse)responses[0];
Console.WriteLine("{0} Products have been retrieved", response.Products.Count);
}
serviceHost.Close();
Console.WriteLine("Finished");
Console.ReadLine();
}
So what I used here is
the KnownTypeProvider of Agatha to easily get all
the types I need for
the service/proxy and add them to
the proxy. My Request handler for this was just a test one which always returned 2 products.
public class GetProductsHandler : RequestHandler<GetProductsRequest,GetProductsResponse>
{
public override Agatha.Common.Response Handle(GetProductsRequest request)
{
return new GetProductsResponse
{
Products = new List<ProductDto>
{
new ProductDto{},
new ProductDto{}
}
};
}
}
Second Pass
Now after I did this I started reading up some more on some resources including more by Davy Brion and others on Agatha. Now it turns out that
the work I did above to create a derived class of
the ClientBase implementing Agatha.Common.WCF.IWcfRequestProcessor was not necessary due to a nice class which is present
inside the Agatha code base, RequestProcessorProxy which takes care of this for you! :-)
So disregarding that class I made for
the proxy and changing my code to use it I am now left with
the following:
static void Main(string[] args)
{
ComponentRegistration.Register();
ServiceHost serviceHost = new ServiceHost(typeof(Agatha.ServiceLayer.WCF.WcfRequestProcessor));
serviceHost.Open();
Console.WriteLine("Service is running....");
using (var proxy = new RequestProcessorProxy())
{
var request = new GetProductsRequest();
var responses = proxy.Process(new[] { request });
var response = (GetProductsResponse)responses[0];
Console.WriteLine("{0} Products have been retrieved", response.Products.Count);
}
serviceHost.Close();
Console.WriteLine("Finished");
Console.ReadLine();
}
Cheers for now,
Andy
References
Agatha WCF InProcess Without WCF
StructureMap.AutoMocking
Cross Process Mocking
Agatha
Programming WCF Services by Juval Lowy
