Follow these steps to start the debugging process from the client application:

As soon as you press F5, you will notice a little window pop up in the lower-right corner of the screen, as shown in the following image:

This is because the client program HelloWorldClient is referencing HelloWorldService, which is hosted in the ASP.NET Development Server, and you have the project property Always Start When Debugging set to True.

Note that this setting is for the WCF hosting project, not for the client or WCF service project. This is very useful when debugging, because you don't need to start it explicitly. However, sometimes, it might be annoying, especially when you have several hosting projects within the same solution. In this case, you can turn it off by setting it to False. However, you then have to start the Service prior to debugging the client application. Otherwise, you will get an exception. We will discuss more about this, later in this chapter.

The cursor should have stopped on the breakpoint line, as you can see in the following HelloWorld (Debugging) image. The active line is highlighted, and you can examine the variables just as you do for any other C# applications.

At this point, the channel between the client and the hosting server (HostDevServer) hasn't been created. Press F10, or select menu option Debug | Step Over to skip over this line. If you don't have the menu option Debug | Step Over, you may have to reset your development environment settings via menu option Tools | Import and Export Settings… (select General Development Settings from the Import and Export Settings Wizard, and check all of the available options).

Now, the following line of source code should be active and highlighted. At this point, we have a valid client object, which contains all of the information related to the WCF service, such as the channel, the endpoint, the members, and the security credentials. The following Locals image shows the details of the Endpoint local variable.

Let us press F11 to step into the WCF service. But instead of stepping in, we will receive an error message, as shown in the following image stating that the service debugging is not enabled:

This is because we haven't enabled debugging for the HostDevServer application. Click the OK button to dismiss this dialog, and then press Shift+F5, or select menu option Debug | Stop Debugging, to return to the development mode.

To enable the debugging of HostDevServer, open the web.config file inside the HostDevServer project and add following nodes to this file:

<system.web>
<compilation debug="true"/>
</system.web>

Above system.web, nodes should be added as child nodes of the root node <configuration>, and the content of the web.config file should now be like this:

<?xml version="1.0"?>
debugging from client application, HelloWorld WCF servicedebugging, enabling<configuration>
<appSettings>
<add key="HTTPBaseAddress" value=""/>
</appSettings>
<system.serviceModel>
<services>
<service name="MyWCFServices.HelloWorldService" behaviorConfiguration="MyServiceTypeBehaviors">
<endpoint address="" binding="wsHttpBinding" contract="MyWCFServices.IHelloWorldService"/>
<endpoint contract="IMetadataExchange" binding="mexHttpBinding" address="mex"/>
</service>
</services>
<behaviors>
<serviceBehaviors>
<behavior name="MyServiceTypeBehaviors">
<serviceMetadata httpGetEnabled="true"/>
</behavior>
</serviceBehaviors>
</behaviors>
</system.serviceModel>
<system.web>
<compilation debug="true"/>
</system.web>
</configuration>

Now, press F5 to start debugging again. Press F10 to skip the first line, and then press F11 to step into the service code. The cursor now resides on the opening bracket of the GetMessage method of the HelloWorldService. You can now examine the variables inside HelloWorldService, just as you would for any other programs. Keep pressing F10, and you should eventually come back to the client program.

However, if you stay inside the HelloWorldService for too long, when you come back to HelloWorldClient, you will get an exception window saying that it has timed out. This is because, by default, the HelloWorldClient will call HelloWorldService, and wait for a response for a maximum time of one minute. You can change this to a longer value in the configuration file web.config, depending on your own needs.

You may also have noticed that you don't see the output window of the HelloWorldClient. This is because, in debug mode, once a console application finishes, the console window is closed. You can add one line to the end of Program.cs to wait for a keystroke so that you can look at the output before it closes. You can do this by adding the following line of code:

Console.ReadKey();

To start HelloWorldService in the debug mode, first set HostDevServer as the startup project. Then open HelloWorldService.cs from the HelloWorldService project and set a breakpoint at the line inside the GetMessage method, as shown below.

Now press F5 to start the service in debugging mode.

Once you press F5, the WCF service will be running in debugging mode, waiting for requests. A browser will open displaying all of the files under the HostDevServer folder. If you go back to Visual Studio IDE, you may find that a new solution folder, Script Documents, has been added to the solution. This folder is the actual content of the web page being displayed in the browser. Because its content is dynamically generated, this folder will only be included in the solution when the HostDevServer is being debugged. Whenever you stop the debugging session, this folder will go away automatically.

After you press F5 to start a WCF service in debugging mode, you might see an error message warning you that script debugging is disabled, as shown the following Script Debugging Disabled image:

For this dialog box, you can do as instructed (clear the checkbox from the Internet Explorer under Tools | Advanced | Browsing | Disable Script Debugging), or you can just click the Yes button to continue debugging without enabling script debugging for Internet Explorer, because we will not debug any script from Internet Explorer (our application is not a web application).

Once you clicked the Yes button (or you may never see this message box because you have the correct settings), the service will be started in debugging mode.

Now that we have the WCF service running in debugging mode, we need to start the client application in non-debugging mode so that the debugging process can start from the WCF service side, and not from the client side.

For this example, you can't start the HelloWorldClient program from the same Visual Studio IDE instance. The reason for this is that, once you have started the HelloWorldService in debugging mode, the solution is in running status. You can't start another project from the same solution inside the same Visual Studio instance while the HelloWorldService project is running. Actually, the Set as Startup Project menu option is disabled, making it impossible to set any other project as the startup project. Also, a bunch of other menu options are disabled, meaning that you can't change them while in debugging mode.

There are two ways to start the HelloWorldClient program in non-debugging mode. The first one is to start it in another instance of Visual Studio. While leaving the previous instance of Visual Studio running for the HelloWorldService in debugging mode, start a new Visual Studio instance, and open the HelloWorld solution. Set HelloWorldClient as the startup project, and then press Ctrl+F5 to start it in non-debugging mode. As soon as you press Ctrl+F5, you will see that the previous Visual Studio is active and the cursor has stopped on the breakpoint line. You can now examine all of the variables inside HelloWorldService, as you would do for any other program. Press F10 once and you will be taken to the end of the GetMessage method; press F10 again and you will be taken outside of the HelloWorldService project. Because the HelloWorldClient is now not running in debugging mode, you will see the output window immediately.

Another way to start HelloWorldClient is to start it from Windows Explorer. Go to the D:SOAwithWCFandLINQProjectsHelloWorldHelloWorldClientinDebug directory and double click HelloWorldClient.exe file. You will then get the same result as you did when you started it from inside a new Visual Studio instance.

What if you start HelloWorldClient in debugging mode, while HelloWorldService is also running in the debugging mode? Suppose you have started HelloWorldService in debugging mode, have set a breakpoint inside the GetMessage method, and have attached a debugger to the HelloWorldService. Now, if you start another Visual Studio instance, open the solution, set HelloWorldClient as the startup project, and press F5 to start HelloWorldClient

also in debugging mode, you will get an exception, as shown in the following image indicating that you attach to the server process:

The main reason for this is that, by default, HostDevServer has the setting Always Start When Debugging set to True. Because of this setting, when HelloWorldClient is started in debugging mode, it also tries to start the service. However, as we have started it in another Visual Studio instance, it will not start a new one. Instead, it will just re-use the existing one. Now, when the breakpoint inside the HelloWorldService is hit, the second Visual Studio instance will try to attach to the HelloWorldService process, which fails because the first Visual Studio instance has already attached a debugger to it.

To overcome this, just change the setting Always Start When Debugging to False, and control the startup of each project manually, or when you start debugging from the client program, don't start the service in advance. The following Properties image shows the setting of this property:

To try this scenario, change the app.config file to use the IIS hosting HelloWorldService. This means that we use the following address for the endpoint in the app.config file for the HelloWorldClient project:

http://localhost/HelloWorldService/HelloWorldService.svc

Build the solution, and set a breakpoint inside the GetMessage method of the HelloWorldService project. Then, run the <ltieral>HelloWorldClient</ltieral> in non-debugging mode by pressing Ctrl+F5. You will see there is no way to hit the breakpoint we had previously set inside HelloWorldService. This is because the service is now hosted by the IIS, and it is not under debugging by any debugger.

To debug the service hosted by the IIS, we can attach it to the IIS process. Start Visual Studio, select menu option Debug | Attach to Process…. The Attach to Process window should now appear. If you can't see the Debug menu from Visual Studio, just open any project or, create an empty new project.

Select process aspnet_wp.exe from the list of available processes, and click the Attach button. You will find this process attached to the debugger. Open the HelloWorldService.cs file and set a breakpoint if you haven't done so already. Now run the HelloWorldClient program in non-debugging mode (use Ctrl+F5) from another Visual Studio instance or from Windows Explorer, and you will see that the breakpoint is now hit.

When you have finished debugging HelloWorldService using this method, you can select menu option Debug | Detach All or Debug | Stop Debugging to exit debugging mode.

You may also have noticed that when you attach to aspnet_wp.exe, the ASP.NET Development Server is also started. We will not use it at all at this time. This is again because the Always Start When Debugging property of HostDevServer is set to True, and as we did earlier, you can turn it off if you feel it is annoying.