Goals to demonstrate:

• Creating WCF services and their clients.
• Hosting a WCF service and connecting to it from a client.
• Configuration settings for a service and a client.

Steps:

1. Simple WCF service and its client.
   • Create a new Console Application project. This project will contain a WCF service, a contract and a host.
     
   • Add a reference to the System.ServiceModel assembly:
     
   • Add an interface (named IMyFirstService) which will serve as a contract for the service:
     [ServiceContract]
     public interface IMyFirstService
     {
         [OperationContract]
         int GetNumberWords(string s);
     }
     • The service's contract is necessary to make the service's methods available for clients.
   • Add a class (named MyFirstService) with implementation of the IMyFirstService interface:
     public class MyFirstService : IMyFirstService
     {
         public int GetNumberWords(string s)
         {
             return s.Split(
                 new char[] { ' ', ';', ',', '.', '?' },
                 StringSplitOptions.RemoveEmptyEntries).Length;
         }
     }
     • This class will serve the service's functionality.
   • Add to the Main method code running the service's host:
     static void Main(string[] args)
     {
         const string serviceURL = "http://localhost:1234/MyFirstService";
     
         ServiceHost serviceHost = new ServiceHost(
             typeof(MyFirstService),
             new Uri(serviceURL));
         serviceHost.AddServiceEndpoint(
             typeof(IMyFirstService),
             new BasicHttpBinding(),
             "");
     
         serviceHost.Open();
     
         Console.WriteLine("This console application hosts the MyFirstService WCF service");
         Console.WriteLine(string.Format("The service is available at address: {0}", serviceURL));
         Console.WriteLine("Press ENTER to finish hosting");
         Console.ReadLine();
     
         serviceHost.Close();
     }
     • The ServiceHost class hosts the service after calling its Open method till calling its Close method.
     • The BasicHttpBinding class is used, so the service will be available through the HTTP protocol.
     • The address of the service is hardcoded. It is definitely wrong, see the next point of this presentation to check how to use configuration settings for hosting WCF services.
   • Run the console application. While it is running, open address of the service (http://localhost:1234/MyFirstService) in a browser :
     
     • The service is working. It is time to create a client for it.
   • Add a new Console Application project to the solution.
   • Copy the IMyFirstService interface from the service to the client.
     • It is definitely wrong idea to copy code between projects, it is used here only for simplicity. One common class library should be used by both the service and the client.
   • Add a reference to the System.ServiceModel assembly:
     
   • Add the following code to the main method of the client:
     static void Main(string[] args)
     {
         const string serviceURL = "http://localhost:1234/MyFirstService";
     
         ChannelFactory<IMyFirstService> channelFactory =
             new ChannelFactory<IMyFirstService>(
                 new BasicHttpBinding(),
                 new EndpointAddress(serviceURL));
     
         IMyFirstService myFirstService = channelFactory.CreateChannel();
     
         Console.WriteLine("This console application is a client for the MyFirstService WCF service");
         Console.WriteLine(string.Format("It tries to use the service at address: {0}", serviceURL));
         Console.WriteLine();
         Console.Write("Write text to get number of words: ");
     
         string s = Console.ReadLine();
         int numberWords = myFirstService.GetNumberWords(s);
     
         Console.WriteLine(string.Format("Number of words: {0}", numberWords));
     }
     • The ChannelFactory object is used to create a communication channel with the service. Note that the BasicHttpBinding is used (because it was used in configuration of the service's host) and the same URL address (again, it is wrong idea to hardcode such settings, in the next part of this tutorial, a better solution will be demonstrated).
     • The used ChannelFactor object is created for the service's interface (IMyFirstService) and is able to create an object implementing this interface which can be easily used in the code.
   • Run the service and while it is running, run also the client:
     
2. Simple WCF service and its client, both configured using configuration files.
   • Create a new Console Application project in a new solution. This project will contain a WCF service, its contract and a host (like in the previous example).
   • Add a reference to the System.ServiceModel assembly.
   • Add an interface (named IMySecondService) serving as a contract for the service:
     [ServiceContract]
     public interface IMySecondService
     {
         [OperationContract]
         int GetNumberWords(string s);
     }
   • Add a class (named MySecondService) with implementation of the IMySecondService interface:
     public class MySecondService : IMySecondService
     {
         public int GetNumberWords(string s)
         {
             return s.Split(
                 new char[] { ' ', ';', ',', '.', '?' },
                 StringSplitOptions.RemoveEmptyEntries).Length;
         }
     }
   • Add to the Main method code running the service's host:
     static void Main(string[] args)
     {
         ServiceHost serviceHost = new ServiceHost(typeof(MySecondService));
     
         serviceHost.Open();
     
         Console.WriteLine("This console application hosts the MySecondService WCF service");
         Console.WriteLine("Press ENTER to finish hosting");
         Console.ReadLine();
     
         serviceHost.Close();
     }
     • Note differences between the code presented above and the code from the previous example. In this code there are no settings (in particular, no endpoint is defined), all necessary settings will be placed in a configuration file.
   • Add an Application Configuration File item to the project:
     
   • Add the following content to the configuration file:
     <?xml version="1.0" encoding="utf-8" ?>
     <configuration>
         <system.serviceModel>
             <services>
                 <service name="SecondService.MySecondService">
                     <host>
                         <baseAddresses>
                             <add baseAddress="http://localhost:1235/MySecondService"/>
                         </baseAddresses>
                     </host>
                     <endpoint address=""
                               binding="basicHttpBinding"
                               contract="SecondService.IMySecondService" />
                 </service>
             </services>
         </system.serviceModel>
     </configuration>
     • The name attribute of the service tag is a name (including a namespace) of the service's class.
     • The contract attribute of the endpoint tag is a name of the service's contract, i.e. the service's interface.
     • The baseAddress contains the URL of the service. It must be consistent with the binding set for the endpoint. In this example, HTTP binding and address are used.
   • Run the console application. While it is running, open address of the service (http://localhost:1235/MySecondService) in a browser :
     
     • Now it is time to create a client.
   • Add new Console Application project to the solution.
   • Run the service and while it is running, try to add a service reference to the client's project. The try will fail:
     
     • The reason of the failure is that by default WCF services do not expose a MEX endpoint. An MEX endpoint allows a client to discover how to communicate with the service.
   • To add a MEX endpoint to the service, modify its configuration by adding a new special endpoint and so-called 'behavior' to allow to access the MEX endpoint via HTTP.
     <?xml version="1.0" encoding="utf-8" ?>
     <configuration>
         <system.serviceModel>
             <services>
                 <service name="SecondService.MySecondService"
                          behaviorConfiguration="mySecondServiceBehavior">
                     <host>
                         <baseAddresses>
                             <add baseAddress="http://localhost:1235/MySecondService"/>
                         </baseAddresses>
                     </host>
                     <endpoint address=""
                               binding="basicHttpBinding"
                               contract="SecondService.IMySecondService" />
                     <endpoint address="mex"
                               binding="mexHttpBinding"
                               contract="IMetadataExchange" />
                 </service>
             </services>
             <behaviors>
                 <serviceBehaviors>
                     <behavior name="mySecondServiceBehavior">
                         <serviceMetadata httpGetEnabled="true"/>
                     </behavior>
                 </serviceBehaviors>
             </behaviors>
         </system.serviceModel>
     </configuration>
   • Run the service and look at the page generated for it:
     
     • The difference is very important - the WSDL document describing the service is available now.
   • Run the service and while it is running, try to add a service reference to the client's project. Now, it works:
     
     
   • Calling the service's method from the client is very simple now:
     ServiceReference1.MySecondServiceClient client = new ServiceReference1.MySecondServiceClient();
     int numberWords = client.GetNumberWords("Sample text for the service");
   • Note the configuration file generated automatically for the client:
     <?xml version="1.0" encoding="utf-8" ?>
     <configuration>
         <system.serviceModel>
             <bindings>
                 <basicHttpBinding>
                     <binding name="BasicHttpBinding_IMySecondService" closeTimeout="00:01:00"
                         openTimeout="00:01:00" receiveTimeout="00:10:00" sendTimeout="00:01:00"
                         allowCookies="false" bypassProxyOnLocal="false" hostNameComparisonMode="StrongWildcard"
                         maxBufferSize="65536" maxBufferPoolSize="524288" maxReceivedMessageSize="65536"
                         messageEncoding="Text" textEncoding="utf-8" transferMode="Buffered"
                         useDefaultWebProxy="true">
                         <readerQuotas maxDepth="32" maxStringContentLength="8192" maxArrayLength="16384"
                             maxBytesPerRead="4096" maxNameTableCharCount="16384" />
                         <security mode="None">
                             <transport clientCredentialType="None" proxyCredentialType="None"
                                 realm="" />
                             <message clientCredentialType="UserName" algorithmSuite="Default" />
                         </security>
                     </binding>
                 </basicHttpBinding>
             </bindings>
             <client>
                 <endpoint address="http://localhost:1235/MySecondService" binding="basicHttpBinding"
                     bindingConfiguration="BasicHttpBinding_IMySecondService" contract="ServiceReference1.IMySecondService"
                     name="BasicHttpBinding_IMySecondService" />
             </client>
         </system.serviceModel>
     </configuration>
   • Note also the 'Service References\ServiceReference1' directory created in the project's directory and its content:
     

[Source code]