The WCF service class cannot exist in a void. Every WCF service must be hosted in a Windows process called the host process. A single host process can host multiple services, and the same service type can be hosted in multiple host processes. WCF makes no demand on whether or not the host process is also the client process, although having a separate process obviously promotes fault and security isolation. It is also immaterial who provides the process and what kind of process is involved. The host can be provided by Internet Information Services (IIS), by the Windows Activation Service (WAS) on Windows Vista or Windows Server 2008 or later, or by the developer as part of the application.
Tip
In-process (or in-proc) hosting, where the service resides in the same process as the client, is a special case. The host for the in-proc case is, by definition, provided by the developer.
The main advantage of hosting a service in the Microsoft IIS web server is that the host process is launched automatically upon the first client request, and you rely on IIS 5/6 to manage the lifecycle of the host process. The main disadvantage of IIS 5/6 hosting is that you can only use HTTP. With IIS 5, you are further restricted to having all services use the same port number.
Hosting in IIS is very similar to hosting a classic ASMX web service. You need to create a virtual directory under IIS and supply an .svc file. The .svc file functions similarly to an .asmx file and is used to identify the service code behind the file and class. Example 1-2 shows the syntax for the .svc file.
Example 1-2. A .svc file
<%@ ServiceHost Language = "C#" Debug = "true" CodeBehind = "˜/App_Code/MyService.cs" Service = "MyService" %>
Tip
You can even inject the service code inline in the .svc file, but that is not advisable, as is the case with ASMX web services.
When you use IIS 5/6 hosting, the base address used for the service always has to be the same as the address of the .svc file.
You can use Visual Studio 2008 to generate a boilerplate IIS-hosted service. From the File menu, select New Web Site, and then select WCF Service from the New Web Site dialog box. This causes Visual Studio 2008 to create a new website, service code, and a matching .svc file. You can also use the Add New Item dialog to add another service later.
The website config file (Web.Config) typically lists the types you want to expose as services. You need to use fully qualified type names, including the assembly name if the service type comes from an unreferenced assembly:
<system.serviceModel>
<services>
<service name = "MyNamespace.MyService">
...
</service>
</services>
</system.serviceModel>Self-hosting is the name for the technique used when the developer is responsible for providing and managing the lifecycle of the host process. Self-hosting is used both when you want a process (or machine) boundary between the client and the service, and when using the service in-proc—that is, in the same process as the client. The process you need to provide can be any Windows process, such as a Windows Forms application, a Console application, or a Windows NT Service. Note that the process must be running before the client calls the service, which typically means you have to prelaunch it. This is not an issue for NT Services or in-proc hosting. Providing a host can be done with only a few lines of code, and it does offer a few advantage over IIS 5/6 hosting.
As with IIS 5/6 hosting, the hosting application config file (App.Config) typically lists the types of the services you wish to host and expose to the world:
<system.serviceModel>
<services>
<service name = "MyNamespace.MyService">
...
</service>
</services>
</system.serviceModel>In addition, the host process must explicitly register the service types at runtime
and open the host for client calls, which is why the host process must be running before
the client calls arrive. Creating the host is typically done in the Main( ) method using the class ServiceHost, defined in Example 1-3.
Example 1-3. The ServiceHost class
public interface ICommunicationObject
{
void Open( );
void Close( );
//More members
}
public abstract class CommunicationObject : ICommunicationObject
{...}
public abstract class ServiceHostBase : CommunicationObject,IDisposable,...
{...}
public class ServiceHost : ServiceHostBase,...
{
public ServiceHost(Type serviceType,params Uri[] baseAddresses);
//More members
}You need to provide the constructor of ServiceHost
with the service type, and optionally with default base addresses. The set of base
addresses can be an empty set, and even if you provide base addresses, the service can be
configured to use different base addresses. Having a set of base addresses enables the
service to accept calls on multiple addresses and protocols, and to use only a relative
URI.
Note that each ServiceHost instance is associated
with a particular service type, and if the host process needs to host multiple types of
services, you will need a matching number of ServiceHost instances. By calling the Open(
) method on the host you allow calls in, and by calling the Close( ) method you gracefully exit the host instance,
allowing calls in progress to complete yet refusing future client calls even if the host
process is still running. Closing is typically done on host process shutdown. For example,
to host this service in a Windows Forms application:
[ServiceContract]
interface IMyContract
{...}
class MyService : IMyContract
{...}you would have the following hosting code:
public static void Main( )
{
ServiceHost host = new ServiceHost(typeof(MyService));
host.Open( );
//Can do blocking calls:
Application.Run(new MyForm( ));
host.Close( );
}Opening a host loads the WCF runtime and launches worker threads to monitor incoming requests. Incoming calls are dispatched by the monitoring threads to worker threads from the I/O completion thread pool (where there are 1,000 threads by default). Since worker threads are involved, you can perform blocking operations after opening the host.
Because the host is closed gracefully, the amount of time it will take is
undetermined. By default, the host will block for 10 seconds waiting for Close( ) to return and will proceed with the shutdown after
that timeout has expired. Before opening the host, you can configure a different close
timeout with the CloseTimeout property of ServiceHostBase:
public abstract class ServiceHostBase : ...
{
public TimeSpan CloseTimeout
{get;set;}
//More members
}For example, you could use programmatic calls to set the close timeout to 20 seconds:
ServiceHost host = new ServiceHost(...); host.CloseTimeout = TimeSpan.FromSeconds(20); host.Open( );
You can do the same in a config file by placing the close timeout in the host section of the service:
<system.serviceModel>
<services>
<service name = "MyNamespace.MyService">
<host>
<timeouts
closeTimeout = "00:00:20"
/>
</host>
...
</service>
</services>
</system.serviceModel>Visual Studio 2008 allows you to add a WCF service to any application project by selecting WCF Service from the Add New Item dialog box. A service added this way is, of course, in-proc toward the host process, but out-of-proc clients can also access it.
You can launch a service host without providing any base address by omitting the base addresses altogether:
ServiceHost host = new ServiceHost(typeof(MyService));
Warning
Do not provide a null instead of an empty list,
because that will throw an exception:
ServiceHost host; host = new ServiceHost(typeof(MyService),null);
You can also register multiple base addresses separated by commas, as in the
following snippet, as long as the addresses do not use the same transport schema (note
the use of the params qualifier in Example 1-3):
Uri tcpBaseAddress = new Uri("net.tcp://localhost:8001/");
Uri httpBaseAddress = new Uri("http://localhost:8002/");
ServiceHost host = new ServiceHost(typeof(MyService),
tcpBaseAddress,httpBaseAddress);WCF also lets you list the base addresses in the host config file:
<system.serviceModel>
<services>
<service name = "MyNamespace.MyService">
<host>
<baseAddresses>
<add baseAddress = "net.tcp://localhost:8001/"/>
<add baseAddress = "http://localhost:8002/"/>
</baseAddresses>
</host>
...
</service>
</services>
</system.serviceModel>When you create the host, it will use whichever base addresses it finds in the config file, plus any base addresses you provide programmatically. Take extra care to ensure that the configured base addresses and the programmatic ones do not overlap in the schema.
You can even register multiple hosts for the same type, as long as the hosts use different base addresses:
Uri baseAddress1 = new Uri("net.tcp://localhost:8001/");
ServiceHost host1 = new ServiceHost(typeof(MyService),baseAddress1);
host1.Open( );
Uri baseAddress2 = new Uri("net.tcp://localhost:8002/");
ServiceHost host2 = new ServiceHost(typeof(MyService),baseAddress2);
host2.Open( );However, with the exception of some threading issues discussed in Chapter 8, opening multiple hosts this way offers no real
advantage. In addition, opening multiple hosts for the same type does not work with base
addresses supplied in the config file and requires use of the ServiceHost constructor.
The ICommunicationObject interface supported by
ServiceHost offers some advanced features, listed
in Example 1-4.
Example 1-4. The ICommunicationObject interface
public interface ICommunicationObject
{
void Open( );
void Close( );
void Abort( );
event EventHandler Closed;
event EventHandler Closing;
event EventHandler Faulted;
event EventHandler Opened;
event EventHandler Opening;
IAsyncResult BeginClose(AsyncCallback callback,object state);
IAsyncResult BeginOpen(AsyncCallback callback,object state);
void EndClose(IAsyncResult result);
void EndOpen(IAsyncResult result);
CommunicationState State
{get;}
//More members
}
public enum CommunicationState
{
Created,
Opening,
Opened,
Closing,
Closed,
Faulted
}If opening or closing the host is a lengthy operation, you can do so asynchronously
with the BeginOpen( ) and BeginClose( ) methods. You can subscribe to hosting events such as state
changes or faults, and you can use the State property
to query for the host status. Finally, the ServiceHost class also offers the Abort(
) method. Abort( ) is an ungraceful
exit—when called, it immediately aborts all service calls in progress and shuts down the
host. Active clients will each get an exception.
You can improve on the WCF-provided ServiceHost
class by defining the ServiceHost<T> class, as
shown in Example 1-5.
Example 1-5. The ServiceHost<T> class
public class ServiceHost<T> : ServiceHost
{
public ServiceHost( ) : base(typeof(T))
{}
public ServiceHost(params string[] baseAddresses) :
base(typeof(T),Convert(baseAddresses))
{}
public ServiceHost(params Uri[] baseAddresses) : base(typeof(T),baseAddresses)
{}
static Uri[] Convert(string[] baseAddresses)
{
Converter<string,Uri> convert = (address)=>
{
return new Uri(address);
};
return baseAddresses.ConvertAll(convert);
}
}ServiceHost<T> provides simple constructors
that do not require the service type as a construction parameter and that can operate on
raw strings instead of the cumbersome Uri. I'll add
quite a few extensions, features, and capabilities to ServiceHost<T> in the rest of this book.
The Windows Activation Service (WAS) is a system service available with Windows Vista and Windows Server 2008 (or later). WAS is part of IIS7, but it can be installed and configured separately. To use WAS for hosting your WCF service, you need to supply a .svc file, just as with IIS 5/6. All the other development aspects, such as support in Visual Studio 2008, remain exactly the same. The main difference between IIS and WAS is that WAS is not limited to HTTP and can be used with any of the available WCF transports, ports, and queues.
WAS offers many advantages over self-hosting, including application pooling, recycling, idle time management, identity management, and isolation, and it is the host process of choice when available—that is, when you can target either a Windows Server 2008 (or later) machine for scalability, or a Windows Vista (or later) client machine for a handful of clients.
That said, self-hosted processes do offer singular advantages, such as in-proc hosting, dealing well with unknown customer environments, and easy programmatic access to the advanced hosting features described previously. In addition, in some instance-management cases (such as lengthy sessions or singleton services) it is better to use self-hosting so that you can avoid WAS autorecycling of the host process and control when to launch the host.
It is often the case that you need to interact with the host instance. While this is
integral to the use of a self-hosting solution, when using IIS 5/6 or WAS, you have no
direct access to the host. To overcome this hurdle, WCF provides a hook called a
host factory. Using the Factory
tag in the .svc file, you can specify a class you provide that
creates the host instance:
<%@ ServiceHost Language = "C#" Debug = "true" CodeBehind = "˜/App_Code/MyService.cs" Service = "MyService" Factory = "MyServiceFactory" %>
The host factory class must derive from the ServiceHostFactory class and override the CreateServiceHost( ) virtual method:
public class ServiceHostFactory : ...
{
protected virtual ServiceHost CreateServiceHost(Type serviceType,
Uri[] baseAddresses);
//More members
}For example:
class MyServiceFactory : ServiceHostFactory
{
protected override ServiceHost CreateServiceHost(Type serviceType,
Uri[] baseAddresses)
{
ServiceHost host = new ServiceHost(serviceType,baseAddresses);
//Custom steps here
return host;
}
}Get Programming WCF Services, 2nd Edition now with the O’Reilly learning platform.
O’Reilly members experience books, live events, courses curated by job role, and more from O’Reilly and nearly 200 top publishers.
