WCF Windows Hosting And Consuming APIs To Client Side

1. Right click on the solution explorer of VS 2013, Add New Project, Windows Desktop, then Windows Service.
   
   
2. Rename the project from “Service1” to “CalculatorWindowsService”.
   
   
3. Add reference of “Services” project.
   
   
4. Now, open CalculatorWindowsService class - Click to switch to code view, then CalculatorWindowsService.cs and a file will open. This file contains the name of service, creates service host, starts and stops the services.
   
   
5. Write the following code in CalculatorWindowsService.cs:
   
   1. using System;
   2. using System.Collections.Generic;
   3. using System.Linq;
   4. using System.ServiceModel;
   5. using System.ServiceProcess;
   6. using System.Text;
   7. using System.Threading.Tasks;
   9. namespace CalculatorWindowsService
   10. {
   11. public class CalculatorWindowsService : ServiceBase
   12. {
   13. public ServiceHost serviceHost = null;
   14. public CalculatorWindowsService()
   15. {
   16. // Name the Windows Service
   17. ServiceName = "WCFWindowsServiceSample";
   18. }
   20. // Start the Windows service.
   21. protected override void OnStart(string[] args)
   22. {
   23. if (serviceHost != null)
   24. {
   25. serviceHost.Close();
   26. }
   28. // Create a ServiceHost for the CalculatorService type and
   29. // provide the base address.
   30. serviceHost = new ServiceHost(typeof(Services.CalculatorService));
   32. // Open the ServiceHostBase to create listeners and start
   33. // listening for messages.
   34. serviceHost.Open();
   35. }
   37. protected override void OnStop()
   38. {
   39. if (serviceHost != null)
   40. {
   41. serviceHost.Close();
   42. serviceHost = null;
   43. }
   44. }
   46. }
   47. }
6. Right click on the project “CalculatorWindowsService” - Add New Item, Installer Class and name it “ProjectInstaller.cs”.
   
   Basically this class instantiates ServiceProcessInstaller and service account types like “Local System, Local Service, Network Service, User”, Assign the Account to LocalSystem.
   
   ServiceInstaller is being instantiated for defining the name of service.
   
   This class adds ServiceProcessInstaller and Service which contains all information.
   
   Here's the code:
   
   1. [RunInstaller(true)]
   2. public partial class ProjectInstaller : System.Configuration.Install.Installer
   3. {
   4. private ServiceProcessInstaller process;
   5. private ServiceInstaller service;
   6. public ProjectInstaller()
   7. {
   8. InitializeComponent();
   9. process = new ServiceProcessInstaller();
   10. process.Account = ServiceAccount.LocalSystem;
   11. service = new ServiceInstaller();
   12. service.ServiceName = "WCFWindowsServiceSample";
   13. Installers.Add(process);
   14. Installers.Add(service);
   15. }
   16. }
7. Now, open “Program” file to run the services. Write the following code:
   
   1. static class Program
   2. {
   3. /// <summary>
   4. /// The main entry point for the application.
   5. /// </summary>
   6. public static void Main()
   7. {
   8. ServiceBase.Run(new CalculatorWindowsService());
   9. }
   11. }
8. Right click on the App.config file - Edit WCF configuration, then a configuration window will open. Configure App.config file by defining service name, baseAddress, binding, contract, etc. like the following:
   
   1. <?xml version="1.0" encoding="utf-8" ?>
   2. <configuration>
   3. <system.serviceModel>
   4. <services>
   5. <!-- This section is optional with the new configuration model
   6. introduced in .NET Framework 4. -->
   7. <service name="Services.CalculatorService"
   8. behaviorConfiguration="CalculatorServiceBehavior">
   9. <host>
   10. <baseAddresses>
   11. <add baseAddress="http://localhost:8000/ServiceModelSamples/service"/>
   12. </baseAddresses>
   13. </host>
   14. <!-- this endpoint is exposed at the base address provided by host: http://localhost:8000/ServiceModelSamples/service -->
   15. <endpoint address=""
   16. binding="wsHttpBinding"
   17. contract="Services.ICalculator" />
   18. <!-- the mex endpoint is exposed at http://localhost:8000/ServiceModelSamples/service/mex -->
   19. <endpoint address="mex"
   20. binding="mexHttpBinding"
   21. contract="IMetadataExchange" />
   22. </service>
   23. </services>
   24. <behaviors>
   25. <serviceBehaviors>
   26. <behavior name="CalculatorServiceBehavior">
   27. <serviceMetadata httpGetEnabled="true"/>
   28. <serviceDebug includeExceptionDetailInFaults="False"/>
   29. </behavior>
   30. </serviceBehaviors>
   31. </behaviors>
   32. </system.serviceModel>
   33. </configuration>
9. Rebuild the project.
   
   
10. Open VS 2013 Developer Command Prompt, Run as administrator and navigate the path till bin like the following:
    
    cd /d F:\Tutorials\C#\Wcf_Test\CalculatorWindowsService\bin\Debug
    
    
11. Now run the following command:
    
    WCF_Test>installutil.exe CalculatorWindowsService.exe
    
    It will install and host the WCF Windows Service. You can start it with the following steps:
    
    
    1. Search - Services.mst: There you will find “WCFWindowsServiceSample” as mentioned in the installer.
       
    2. Right click on it and Start the service.
       
       Now, Window service has been installed and hosted.

Step 3: Consume WCF Service to Client Side.

Client can consume services of hosted windows services in the form of APIs.

The following are the steps to consume APIs:

1. Right click on Solution explorer - Add New Console project.
   
   
2. Give the name of console project to “CalculatorClient”.
   
   
3. Now, generate proxy file of service by the following steps:
   
   
   1. Open URL http://localhost:8000/ServiceModelSamples/service in the browser. Make sure windows service should be running.
      
      
   2. It will open the service details.
      
      
   3. Click on the URL : http://localhost:8000/ServiceModelSamples/service?wsdl
      
      
   4. You will get .wsdl file in the form of XML format.
      
      
   5. Save this file
      
      
   6. Open VS 2013 Developer Command prompt.
      
      
   7. Navigate till the folder of saved XML file and run the following command:
      
      F:\Tutorials\WCF_Test>svcutil.exe service.xml
      
      
   8. It will generate proxy file like “CalculatorService”. Add it to this project.
      
      
   9. Add reference “System.ServiceModel”.
      
      
   10. Add one App.Config file and configure like the following:
       
       1. <configuration>
       2. <system.serviceModel>
       3. <bindings>
       4. <basicHttpBinding>
       5. <binding name="BasicHttpBinding_ICustomerService" closeTimeout="00:01:00"
       6. openTimeout="00:01:00" receiveTimeout="00:10:00" sendTimeout="00:01:00"
       7. allowCookies="false" bypassProxyOnLocal="false" hostNameComparisonMode="StrongWildcard"
       8. maxBufferSize="65536" maxBufferPoolSize="524288" maxReceivedMessageSize="65536"
       9. messageEncoding="Text" textEncoding="utf-8" transferMode="Buffered"
       10. useDefaultWebProxy="true">
       11. <readerQuotas maxDepth="32" maxStringContentLength="8192" maxArrayLength="16384"
       12. maxBytesPerRead="4096" maxNameTableCharCount="16384" />
       13. <security mode="None">
       14. <transport clientCredentialType="None" proxyCredentialType="None"
       15. realm="" />
       16. <message clientCredentialType="UserName" algorithmSuite="Default" />
       17. </security>
       18. </binding>
       19. </basicHttpBinding>
       20. </bindings>
       21. <client>
       22. <endpoint address="http://localhost:8000/ServiceModelSamples/service" binding="wsHttpBinding"
       23. contract="ICalculator"/>
       24. </client>
       25. </system.serviceModel>
       26. </configuration>
   11. Rebuild the project.
       
       
   12. Now go to Class file “Program” and call the service API’s method like the following:
       
       1. static void Main(string[] args)
       2. {
       3. CalculatorClient calculator = new CalculatorClient();
       4. var addResult = calculator.Add(2, 4);
       5. Console.WriteLine("Sum: {0}", addResult);
       6. var result = calculator.Subtract(4, 2);
       7. Console.WriteLine("Subtract: {0}", result);
       8. Console.ReadKey();
       9. }

Folder structure is like the following:



See the attached code.