This article shows how we can debug a WCF Service in Visual Studio which is hosted in a Windows Service with netTcpBinding.
As we know when we create WCF Service as a class library in visual studio and run the service. We don’t need any kind of host (Like Self-Hosting App, Windows Services, IIS OR WAS) Right? It happens because fortunately Microsoft has already included a small testing service host and a test client in order to ease development and testing of WCF services. Press F5 in Visual Studio and you are set to start debugging by setting break point anywhere in the service where we want to. You would see following message when WCF service runs:
Figure-1
But suppose we host our WCF service in a Windows Service and make Windows Service as our main start up project, then it becomes difficult to debug our WCF Service because this time Windows Service is the main driving application which doesn’t allow running the WCF Service in debugger mode.
It gives the following error message if you try to do it:
Figure-2
So what is the solution? For this problem, we have following simple remedial options:
(1) Through Visual Studio
(2) Through Code
(1) Through Visual Studio: In this option (which I am not going to discuss here), you need to open your visual studio in administrative mode and you have to have your Service attached to process. For more detail, you could see MSDN article for this:
(2) Through Code: We are going to discuss this option in detail in this article.
To explain this, I divided article into following sections:
(1) Creating a small WCF Service with netTcpBinding
(2) Creating Windows Service Host
(3) Setting Windows Service that enables debugging in Visual Studio
(4) Creating our own Test Client
(1) Creating a small WCF Service with netTcpBinding:
- On the File menu, point to New and then click Project.
- In the New Project dialog box, expand the Visual C# node and click WCF, followed by WCF Service Library. Click OK to open the project.
- An in-built WCF Service with two operation contracts (by default) is created for you by Visual Studio. You don’t need to change any operation contract/ data contract because here our focus is not to learn creating WCF Service and their contracts (operation/Data)
- For netTcpBinding , we need to change the contents of the default app.Config file as:
<configuration>
<system.serviceModel>
<services>
<service name="MyWcfService.Service1">
<endpoint address="" binding="netTcpBinding" bindingConfiguration=""
contract="MyWcfService.IService1">
<identity>
<dns value="localhost" />
</identity>
</endpoint>
<endpoint address="mex" binding="mexTcpBinding" bindingConfiguration=""
contract="IMetadataExchange" />
<host>
<baseAddresses>
<add baseAddress="net.tcp://localhost:8732/Design_Time_Addresses/MyWcfService/Service1/" />
</baseAddresses>
</host>
</service>
</services>
<behaviors>
<serviceBehaviors>
<behavior>
<!-- To avoid disclosing metadata information,
set the value below to false and remove the metadata endpoint above before deployment -->
<serviceMetadata/>
<!-- To receive exception details in faults for debugging purposes,
set the value below to true. Set to false before deployment
to avoid disclosing exception information -->
<serviceDebug includeExceptionDetailInFaults="True" />
</behavior>
</serviceBehaviors>
</behaviors>
</system.serviceModel>
</configuration>
- That’s it! We are done with creating our Test WCF Service.
(1) Creating Windows Service Host:
Now we create a Windows Service project in Visual Studio:
- On the File menu, point to New and then click Project.
- In the New Project dialog box, expand the Windows node and click Window Service and Click OK to open the project.
- A default Window service project is created.
- Although this step is optional right now but eventually we would ended up following this step because we want to install our Windows Service in the system. For this, we need to add project Installer into our windows service so that we could install our windows service using “regsvr32” command. In order to do that, we go to designer of Service1.cs
- Right click in the designer of Service1.cs. Choose “Add Installer” option from the menu.
- Visual Studio automatically creates ProjectInstallar for us.
- Give any name to your service in the properties window of serviceInstaller1.
- How we can install any windows service using “installutil” coomand, we could go to following MSDN link:
- Add the WCF Service DLL reference into Window Service project.
- Add System.ServiceModel reference to Windows Service
- Open the Service1.cs file and create WCF Service host into OnStart() method as follows
public partial class Service1 : ServiceBase
{
ServiceHost host;
public Service1()
{
InitializeComponent();
}
protected override void OnStart(string[] args)
{
Type serviceType = typeof(MyWcfService.Service1);
host = new ServiceHost(serviceType);
host.Open();
}
protected override void OnStop()
{
host.Close();
}
}
- Add a new “app.config” file into Windows Service Project.
- Copy the same contents of WCF service app.config (described in section1.4) into our newly added Windows Service app.config file.
(2) Setting Windows Service that enables debugging in Visual Studio:
1. Open Program.cs file of the Windows Service Host Application and replace the existing Program.cs with the following code:
· In the following Code, We created instance of “Service1” class of the Windows Service and calling explicitly our own methods: OnDebugMode_Start() and OnDebugMode_Stop() .
· This portion will be run only in DEBUG Mode as we used #if DEBUG directive.
· The portion in #else block will not be run in DEBUG Mode.
· We also put the Main Thread into Infinite time Sleep Mode in order to make “Debugging” available for all the time till we want.
Note: When we want to install this windos service using “installutil” command, we have to comment the #if DEBUG directive and its code as following:
static void Main()
{
System.Threading.Thread.CurrentThread.Name = "ServiceMain";
try
{
//#if DEBUG
//// Run as interactive exe in debug mode to allow easy debugging.
//var service = new Service1();
//service.OnDebugMode_Start();
//// Sleep the main thread indefinitely while the service code runs in OnStart()
//System.Threading.Thread.Sleep(System.Threading.Timeout.Infinite);
//service.OnDebugMode_Stop();
//#else
ServiceBase[] ServicesToRun;
ServicesToRun = new ServiceBase[]
{
new Service1()
};
ServiceBase.Run(ServicesToRun);
//#endif
}
catch (Exception exc)
{
throw exc;
}
}
1. Open the Service1.cs file and Add two more public methods in the same class, which basically calls OnStart() and OnStop() methods internally:
public void OnDebugMode_Start()
{
OnStart(null);
}
public void OnDebugMode_Stop()
{
OnStop();
}
2. Press F5 to run the service and make sure service is running properly. Since Windows Service is debugger mode, so it won’t complain as in Figure-2
3. Creating our own Test Client:
- Create any WinForm Application or Console Application to be a client of our WCF Service which will consume the WCF Service.
- Make sure WCF Service is running.
- Right click the Reference tab of your project. Click “Add a ServiceReference” .
- Add Service Reference Window will open
- Put the WCF Endpoint base address (copying from app.config)into Address bar of the Window.
- Click Go. It must have found out our WCF Service interfaces.
- Click OK. In this way, you added service reference to you client project.
- Create Proxy Client Object of your WCF Service as:
ServiceReference1.Service1Client objectProxyClient = new Service1Client();
- Access interfaces of WCF Service with “objectProxyClient” object.
So, here we learned how we can easily debug a WCF Service in Visual Studio which is hosted in a Window Service by making a small Test WCF Service with netTcpBinding, Hosting Windows Service and Test Client Tool.
Thanks
Hemant Srivastava
