In the first part of this topic, I showed you how to develop a WCF service. In this next part I will show how to implement a client application that calls the exposed service methods, and how to make some enhancements to your service hosting.
Ok, so he already have built and deployed our service (either self-hosted, or in IIS for example), and by using a web browser we can see the service welcome page. Now, to call the service methods we must create a client proxy, and to do this we can use the Visual Studio Add Web Reference, which automatically creates the proxy, or we can use the command line svcutil to manually create the proxy. I prefer to do it manually because I like to control things like the generated proxy class namespace.
For example purposes, I created a Console Application that I called Tests.SampleService. There I created a batch file for calling the svcutil with my own parameters, with something similar to this:
svcutil %SERVICE_URL% /namespace:*,%NAMESPACE% /d:%OUT_DIR% /out:%OUT_FILE%
With the service running, I executed the batch file and svcutil generated two files:
- output.config – Contains the WCF runtime configurations for calling the service (<system.serviceModel>)
- Sample.Service.Proxy.cs – Contains the service proxy class, and any other classes exposed by the service
The contents of the output.config should be placed in the console application App.Config (if you prefer you can just rename the file).
In your console application main file you can place code like the following:
static void Main(string[] args)
{
Console.WriteLine("Press any key to start");
Console.ReadLine();
// Build the service proxy object
ServiceClient proxy = new ServiceClient();
// Call service methods
// Get total number of customers
Int32 totalCustomers = proxy.GetTotalNumberOfCustomers();
Console.WriteLine("Total Customers: {0}", totalCustomers);
// Get list of customers
List<Customer> customers = new List<Customer>(proxy.GetCustomers());
foreach (Customer customer in customers)
{
Console.WriteLine("Customers");
Console.WriteLine("Customer: Id - {0} / Name - {1}.", customer.Id, customer.Name);
}
// Get customer
Customer singleCustomer = proxy.GetCustomer(customers[0].Id);
Console.WriteLine("SingleCustomer: Id - {0} / Name - {1}.", singleCustomer.Id, singleCustomer.Name);
Console.WriteLine("Press any key to exit");
Console.ReadLine();
}
You are know ready to start your service and use your client application to call the service methods.
Service Host Enhancements
Regarding the self service hosting there are some steps that you can do to make it more robust to errors and faults. Two of these changes are:
- Subscribe the service host Faulted event
- Subscribe the service host Unknown Message Received event
This should be done before opening our service hosting, and the new StartServiceHost method should look like this:
/// <summary>
/// Creates the service host
/// </summary>
private void StartServiceHost()
{
Logger.Info("StartServiceHost: Starting service hosting...");
// Create service host
_serviceHost = new ServiceHost(typeof(SampleService.Service));
// Subscribe to the Faulted event of the service host
_serviceHost.Faulted += new EventHandler(FaultHandler);
// Subscribe to the Unknown message received event of the service host
_serviceHost.UnknownMessageReceived += new EventHandler<UnknownMessageReceivedEventArgs>(UnknownMessageHandler);
try
{ // Open service host
_serviceHost.Open();
Logger.Info("StartServiceHost: Service hosting success.");
}
catch (Exception ex)
{
Logger.Fatal("StartServiceHost: Could not start service hosting.", ex);
}
}
The event handler’s code can be:
/// <summary>
/// Fault error event handler
/// </summary>
private void FaultHandler(Object sender, EventArgs e)
{
// Examine the properties of the service host
// Log reason for fault
Logger.Error("FaultHandler: Host Fault occured. Aborting and restarting the hosting");
// Abort the service (Could use Close, but a service in this state does not responde to requests, and Close takes more time)
_serviceHost.Abort();
// Re-start service host
StartServiceHost();
}
/// <summary>
/// Unknown message event handler
/// </summary>
private void UnknownMessageHandler(Object sender, UnknownMessageReceivedEventArgs e)
{
// Log the unknown message
Logger.Warn("UnknownMessageHandler: Unknown Message Received");
}
Take into attention that when the service host goes into a Faulted state, it stops servicing requests. This is why in the FaultHandler we abort the service host and open it again.
You can make a quick test of the event handlers by introducing in your web browser the following address: http://localhost:8080/SampleService/Service.svc.
This makes the service receive an unknown message and the corresponding event handler is called.
I leave here the complete Visual Studio solution.
