Post
Ask Question

New Features of WCF 4.0: Part I

Introduction

 
Microsoft.NET 4.0 and Visual Studio.NET 2010 ships a lot of new features in their underlying technologies. In this series of articles, I want to talk about the new features in the area of Windows Communication Foundation (WCF) in order to improve the development experience, enable more communication scenario, support new WS-* standards and provide a good integration with Windows Workflow Foundation (WF).
 
The new features are essentially the following: simplified configuration, standard endpoints, IIS hosting without a SVC file, support for WS-Discovery, routing service, REST improvements, enhancements for the integration with WF to support workflow services, simple byte stream encoding and ETW tracing.
 
In this series of article, I will illustrate each feature explaining the principles and showing some examples.
 

Simplified configuration

 
In WCF 3.x, when you specify a host for a Web service developed using WCF, you need to write or program the endpoints and behaviors. In WCF 4.0, you have new defaults for endpoints, binding and behaviors.
 
For our example, let's define a simple service which provides the echo functionality when it's invoked. The service contract is shown in Listing 1.
  1. using System;  
  2. using System.Collections.Generic;  
  3. using System.Linq;  
  4. using System.Runtime.Serialization;  
  5. using System.ServiceModel;  
  6. using System.Text;  
  7. namespace WCF_NewFeatures  
  8. {  
  9.     [ServiceContract]  
  10.     public interface IEchoService  
  11.     {  
  12.         [OperationContract]  
  13.         string Echo(String message);  
  14.     }  
  15. }  
Listing 1
 
The implementation for this service contract is shown in the Listing 2.
  1. using System;  
  2. using System.Collections.Generic;  
  3. using System.Linq;  
  4. using System.Runtime.Serialization;  
  5. using System.ServiceModel;  
  6. using System.Text;  
  7. namespace WCF_NewFeatures  
  8. {  
  9.     public class EchoService : IEchoService  
  10.     {  
  11.         public string Echo(String message)  
  12.         {  
  13.             return "Called the Echo Service with message " + message;  
  14.         }  
  15.     }  
  16. }  
Listing 2
 
Now let's create a ServiceHost instance for this service and bind it to a URI. When the application calls to the Open method of the ServiceHost instance, it builds the internal service description from the application configuration file along with anything the host application may have configured explicitly (see Listing 3).
  1. using System;  
  2. using System.Collections.Generic;  
  3. using System.Linq;  
  4. using System.Text;  
  5. using System.ServiceModel;  
  6. using System.ServiceModel.Description;  
  7. namespace WCF_NewFeatures  
  8. {  
  9.     class Program  
  10.     {  
  11.         static void Main(string[] args)  
  12.         {  
  13.             ServiceHost serviceHost = new ServiceHost(typeof(WCF_NewFeatures.EchoService),new Uri("http://localhost:8080/Services/EchoService"));  
  14.             serviceHost.Open();  
  15.             System.Console.WriteLine("The EchoService has started");  
  16.             foreach (ServiceEndpoint se in serviceHost.Description.Endpoints)  
  17.             {  
  18.                 System.Console.WriteLine("Address:{0}, Binding:{1}, Contract:{2}", se.Address, se.Binding.Name, se.Contract.Name);  
  19.             }  
  20.             System.Console.WriteLine("Please, press any key to finish ...");  
  21.             System.Console.ReadLine();  
  22.             serviceHost.Close();  
  23.         }  
  24.     }  
  25. }  
Listing 3
 
When you run this program, you will see that the IEchoService service contract can be accessed from the http://localhost:8080/Services/EchoService using BasicHttpBinding (see Figure 1). Notice that WCF uses the BasicHttpBinding as the default binding.
 
1.gif 
Figure 1
 
If you configure at least one endpoint, you will no longer see any default endpoint. Let's illustrate this by calling the AddServiceEndpoint method in the ServiceHost instance (see Listing 4).
  1. using System;  
  2. using System.Collections.Generic;  
  3. using System.Linq;  
  4. using System.Text;  
  5. using System.ServiceModel;  
  6. using System.ServiceModel.Description;   
  7. namespace WCF_NewFeatures  
  8. {  
  9.     class Program  
  10.     {  
  11.         static void Main(string[] args)  
  12.         {  
  13.             ServiceHost serviceHost = new ServiceHost(typeof(WCF_NewFeatures.EchoService),new Uri("http://localhost:8080/Services/EchoService"));  
  14.             serviceHost.AddServiceEndpoint(typeof(IEchoService),new WSHttpBinding(),"newEndPoint");  
  15.             serviceHost.Open();  
  16.             System.Console.WriteLine("The EchoService has started");  
  17.             foreach (ServiceEndpoint se in serviceHost.Description.Endpoints)  
  18.             {  
  19.                 System.Console.WriteLine("Address:{0}, Binding:{1}, Contract:{2}", se.Address, se.Binding.Name, se.Contract.Name);  
  20.             }  
  21.             System.Console.WriteLine("Please, press any key to finish ...");  
  22.             System.Console.ReadLine();  
  23.             serviceHost.Close();  
  24.         }  
  25.     }  
  26. }  
Listing 4
 
If you run the application, you will receive the output in the Figure 2.
 
2.gif 
Figure 2
 
However you can also add the default endpoint along with your own (see Figure 2).
  1. using System;  
  2. using System.Collections.Generic;  
  3. using System.Linq;  
  4. using System.Text;  
  5. using System.ServiceModel;  
  6. using System.ServiceModel.Description;  
  7. namespace WCF_NewFeatures  
  8. {  
  9.     class Program  
  10.     {  
  11.         static void Main(string[] args)  
  12.         {  
  13.             ServiceHost serviceHost = new ServiceHost(typeof(WCF_NewFeatures.EchoService),new Uri("http://localhost:8080/Services/EchoService"));  
  14.             serviceHost.AddServiceEndpoint(typeof(IEchoService),new WSHttpBinding(),"newEndPoint");  
  15.             serviceHost.AddDefaultEndpoints();  
  16.             serviceHost.Open();  
  17.             System.Console.WriteLine("The EchoService has started");  
  18.             foreach (ServiceEndpoint se in serviceHost.Description.Endpoints)  
  19.             {  
  20.                 System.Console.WriteLine("Address:{0}, Binding:{1}, Contract:{2}", se.Address, se.Binding.Name, se.Contract.Name);  
  21.             }  
  22.             System.Console.WriteLine("Please, press any key to finish ...");  
  23.             System.Console.ReadLine();  
  24.             serviceHost.Close();  
  25.         }  
  26.     }  
  27. }  
Listing 5
 
And the result is shown in the Figure 3.
 
3.gif 
Figure 3
 
For bindings the default is BasicHttpBinding. With WCF 4.0, you can define default behavior configurations by omitting the name of the configuration definition in the application configuration file (see Listing 6).
  1. <?xml version="1.0" encoding="utf-8" ?>  
  2. <configuration>  
  3.     <system.serviceModel>  
  4.         <behaviors>  
  5.             <serviceBehaviors>  
  6.                 <behavior name="">  
  7.                     <serviceMetadata httpGetEnabled="true" />  
  8.                 </behavior>  
  9.             </serviceBehaviors>  
  10.         </behaviors>  
  11.     </system.serviceModel>  
  12. </configuration>  
Listing 6
 
In this case, we have turned on the service metadata, so you can retrieve the service definition from the WSDL document (see Figure 4).
 
4.gif 
Figure 4
 

Standard Endpoint

 
Standard Endpoints are pre-configured endpoint definitions built into the WCF 4.0 framework without the need to define them. These endpoints are defined using the <Kind> attribute. The standard endpoints are: mexEndpoint, dynamicEndpoint, discoveryEndpoint, udpEndpoint, announcementEndpoint, udpAnnouncementEndpoint, workflowControlEndpoint, webHttpEndpoint, webScriptEndpoint.
  • The mexEndpoint endpoint defines an endpoint for MEX configured with IMetadataExchange for the service contract.
  • The dynamicEndpoint configures an endpoint with WS-Discovery support within the a WCF client application.
  • The discoveryEndpoint configures the discovery operations within a client application.
  • The udpDiscoveryEndpoint defines an endpoint for discovery operations within a client application using UDP binding at a multicast address.
  • The announcementEndpoint defines an endpoint for announcement features of discovery.
  • The udpAnnouncementEndpoint defines an endpoint for announcement features of discovery using the UDP protocol.
  • The workflowControlEndpoint defines an endpoint for controlling the execution of workflow instances.
  • The webHttpEndpoint defines an endpoint using WebHttpBinding and WebHttpBehavior to expose REST services.
  • The webScriptEndpoint defines an endpoint using WebHttpBinding and WebHttpBehavior to expose Ajax services.

IIS hosting without a SVC file

 
In WCF 4.0, you can define virtual service activation endpoints in the Web.config file order to activate a WCF service without the need of .svc file (see Listing 7).
  1. <configuration>  
  2.           <system.serviceModel>  
  3.                    <serviceHostingEnvironment>  
  4.                              <serviceActivations>  
  5.                                       <add relativeAddress="EchoService.svc" service="EchoService"/>  
  6.                              </serviceActivations>  
  7.                    </serviceHostingEnvironment>  
  8.           </system.serviceModel>  
  9. </configuration>  
Listing 7
 
With this configuration, you can activate the EchoService using the relative address EchoService.svc. If you create a Web application in your IIS named EchoApp and copy the EchoService service definitions and set up the service configuration as shown in the Listing 7, you can browse to the service following the URI http://localhost/EchoApp/EchoService.svc without having a physical EchoService.svc file with the service activation definition.
 

Conclusion

 
In this series of article, I've explained the new features of WCF 4.0 through concepts and examples.
 
Further Readings 
 


Similar Articles