WCF Fundamentals

Windows communication foundation

Polymorphism
Encapsulation
Subclassing
Message-based
Schema+Contract
Binding via Policy
1980s
2000s
Interface-based
Dynamic Loading
Runtime Metadata
1990s
Object-Oriented
Service-Oriented
Component-Based

SOA can be simply defined as an architectural
concept or style that uses a set of “loosely
coupled services” to achieve the desired
functionality.

 Boundaries are Explicit.
 Services are Autonomous
 Services share schema and contract, not class
 Service compatibility is determined based on
policy

 Services are secure
 Services leave the system in a consistent state
 Services are thread-safe
 Services are reliable

 WCF is a programming model that enables
developers to build service solutions that are
reliable and secure, and even transacted.
 WCF simplifies development of unified,
simplified and manageable distributed
systems

ASMX
Interoperable
WSE
Interoperable
Secure
Remoting
Fast
Secure
‘Objects’
COM+
Fast
Secure
Transactions
MSMQ
Queued
Secure
Transactions

Interoperability across platforms
Service –oriented development
Unification of existing distributed technology

 Programming model type
1. You can use the object model programmatically.
2. You can use configuration files.
3. You can use declarative programming
(attributes).
 The order in which settings are applied is as
follows:
1. Attributes are applied.
2. The configuration is applied.
3. The code runs.

Client
SOAP Request
SOAP Response
Service
Metadata
Message (SOAP)
Headers: Addressing, Security, etc
Body: Payload

What do I send?
Where do I send it?
How should I send it?
Contract
Address
Binding ServiceClient
Endpoint Endpoint
a network address
indicates where the service
is located.
specifies how a client can
communicate with the
endpoint
identifies what operations
are available to the
clients

 WCF Service Library
◦ WCF Test Client
◦ WCF Configuration Editor
◦ Output is dll
◦ Has app.config file
 Website Project Template
◦ Has web.config
◦ Used over asp.net webservice
◦ Has a .svc file

 Address
 Binding
 Contract

 It contains information about what a service
does and the type of information it will make
available.
 There are three types of contracts:
 Data Contract
 Message Contract
 Service Contract
 Operation Contact

16
[ServiceContract]
public interface IHello
{
[OperationContract]
string Hello(string name);
}
public class HelloService : IHello
{
public string Hello(string name)
{
return “Hello, ” + name;
}
}

 The service contract expresses the “methods”
that are exposed to the outside world.
using System.ServiceModel;
namespace MyFirstWCF
{
[ServiceContract(Namespace =
"http://Ebusiness30/WCF")]
interface IService
{
[OperationContract]
Operation1( );
[OperationContract]
Operation2( );
}
}
class MyService :
IMyContract
{
public string
MyMethod( )
{
return "Hello WCF";
}
}

 Define the custom types that you will use as a
parameter or return in your operation
contract
[DataContract(Namespace=" Ebusiness30WCF")]
public class Customer
{
[DataMember(Name=“CustomerName")]
public string Name;
[DataMember(Name=“NID")]
public int id;
[DataMember(Name=“Type")]
private string type;
}

 use message contracts to control how
properties of your types map to the SOAP
headers and SOAP body
[MessageContract(Namespace=" Ebusiness30/WCF")]
public class Customer
{
[MessageBody(Name=“CustomerName")]
public string Name;
[MessageBody(Name=“NID")]
public int id;
[MessageHeader(Name=“Type")]
private string type;
}

 Http-Based Binding
◦ BasicHttpBinding-wsBinding-wsDualHttpBinding-
wsFederationHttpBinding-
 TCP-Based Binding
◦ netNamedPipeBinding-netPeerTcpBinding-
netTcpBinding
 MSMQ-Based Binding
◦ msmqIntegrationBinding-netMsmqBinding

 Bindings are the mechanism by which communication
details are specified to make connecting to a service’s WCF
endpoint possible
 A binding defines how you can communicate with the
service
 The binding controls the following:
◦ The transport (HTTP, MSMQ, Named Pipes, TCP)
◦ The channels (one-way, duplex, request-reply)
◦ The encoding (XML, binary,MTOM)
◦ The supported WS-* protocols (WS-Security, WS-Federation, WS-
reliability, WS-Transactions)
 Using bindings is a two-step process, as follows
◦ Select the binding from the predefined list of WCF bindings that
you will use for a particular endpoint.
◦ Create an endpoint that utilizes the binding that you have selected
or created.

Binding Name
Transport
Encoding
Interop
Security
Session
Transaction
Duplex
Streaming
BasicHttpBinding HTTP/S Text.MTOM BP 1.1 T X
WsHttpBinding HTTP/S Text.MTOM WS T | S X X X
WsDualHttpBinding HTTP/S Text.MTOM WS T | S X X X X
NetTcpBinding TCP Binary .NET T | S X X X X
NetNamedPipesBinding IPC Binary .NET T | S X X X X
NetMsmqBinding MSMQ Binary .NET T | S X
NetPeerTcpBinding P2P Binary .NET T | S X
MsmqIntegrationBinding MSMQ Binary MSMQ T X
T = Transport Security | S = WS-Security
 It specifies the communication details required to connect to the
endpoint.

ServiceClient
Message Message
Transactions
Security
Transport
Transactions
Security
Transport
Channels
Configuration
Configuration
Configuration
Transport Channel (HTTP, TCP, etc)
Configuration

An address basically declares “here I am” to the
outside world.
Example
http://localhost/myservice/
protocol domain Service path

 HTTP
◦ http://domain [:port]/path
 HTTPS
◦ https://domain[:port]/path
 TCP
◦ net.tcp://domain/path
 MSMQ
◦ net.msmq://domain/queue name
 Named pipe no port not cross-machine
◦ net.pipe://localhost/path
 IIS
◦ http://domain[:port]/virtual directory[.svc file]

 Base address
◦ enables you to host multiple endpoints under the same
base address
◦ [transport]://[host name][:optional port]/[optional path]
 Endpoint address
◦ Endpoint address is where the service is actually listening.
 Mex address
◦ Used to obtain metadata of the service
◦ [transport]://[host name][:optional port]/[optional path]
MyServiceMex

<host>
<baseAddresses>
<add
baseAddress="http://localhost:8080/QuickReturns"/>
<add
baseAddress="net.tcp://localhost/QuickReturns"/>
</baseAddresses>
</host>
<endpoint
name="BasicHttpBinding"
address="Exchange"
bindingsSectionName="BasicHttpBi
nding"
contract="IExchange" />
<endpoint
name="NetNamedPipeBinding"
address="Exchange"
bindingsSectionName="NetName
dPipeBinding"
contract="IExchange" />
This allows you to define the following endpoints:

 Custom .exe (self hosting )
 IIS
Windows Service

 IIS 6 (ASPNET_WP.EXE / W3wp.exe)
◦ Activation on demand upon client request.
◦ Only supports HTTP/S transport.
 Self Hosting
◦ Can be any managed application, i.e. Console or
WinForms application.
◦ Low-level but flexible.
 Windows Activation Service (WAS)
◦ Supports all transports.
◦ Will ship with IIS 7 on Vista and Longhorn Server.
 Managed Windows Services (NT Services)

33
class HelloHost
{
static void Main(string[] args)
{
ServiceHost host =
new ServiceHost(typeof(HelloService));
host.Open();
// Wait until done accepting connections
Console.ReadLine();
host.Close();
}
}
<%@ Service Language=“C#” Class=“HelloService” %>
http://localhost/HelloService/HelloService.svc
Self-host
WAS/IIS-host

34
<?xml version="1.0" encoding="utf-8" ?>
<configuration>
<system.serviceModel>
<services>
<service type=“HelloService"
<endpoint address=“http://localhost/HelloService"
binding=“basicHttpBinding"
contract="IHello" />
</service>
</services>
</system.serviceModel>
</configuration>

 Create a service host
 Open the host to allow calls in
 Close the host to gracefully exit
◦ Calls in progress complete.
◦ Host refuse any further calls even if host process is still
running.
public static void Main ()
{
Uri baseAddress = new Uri ("http://localhost:8000");
using (ServiceHost serviceHost =
new ServiceHost (typeof(MyService), baseAddress))
{
serviceHost.Open ();
// The service can now be accessed.
Console.WriteLine ("Press <ENTER> to terminate service.");
Console.ReadLine ();
}
}

 Application hosting
◦ App.Config
<services>
<service name = "MyNamespace.MyService" >
<endpoint
address = "http://localhost:8000/MyService"
binding = "wsHttpBinding"
contract = "MyNamespace.IMyContract">
</endpoint>
</service>
</services>

 Using svcutil.exe
 Using visual studio 2008

 Client uses a proxy to consume the service
 The proxy
◦ Is CLR interface and class representing the service.
◦ Provides the same operations as service.
◦ Has additional methods for managing the proxy and the
connection.
 Generate the proxy
◦ SvcUtil.exe <Base Address> [/out:<file>] [/config:<file>]
◦ When hosted in IIS/WAS
SvcUtil http://localhost/MyService/MyService.svc /out:Proxy.cs
◦ When self-hosting
SvcUtil http://localhost:8000/MyService/ /out:Proxy.cs
SvcUtil net.tcp://localhost:8001/ /out:Proxy.cs
SvcUtil net.pipe://localhost/MyPipe/ /out:Proxy.cs
◦ HTTP transport
Add Service Reference to the project in VS 2005

 Client Configuration
◦ Application: App.Config
<client>
<endpoint name="MyEndpoint"
address="http://localhost:8000/MyService"
binding="wsHttpBinding"
contract="MyNamespace.IMyContract" />
</client>

 Client needs to instantiate proxy object
◦ Provide the constructor with endpoint
◦ Endpoint section name from config file
 Use service methods
 Close proxy instance
using (MyContractProxy proxy = new MyContractProxy
("MyEndpoint") )
{
proxy.MyMethod ();
}

 No Proxy Client
◦ Work directly with channel
ChannelFactory<IMyContract> factory =
new ChannelFactory<IMyContract> ("MyEndpoint");
IMyContract channel = factory.CreateChannel();
channel.MyMethod ();
factory.Close ();
 Need to know the contract interface
upfront

 in this section you will learn how
1. Handle exceptions in the client applications and
services
2. Specify the exception that a WCF can raise
3. Propagate information about exceptions form
service to client
4. Learn about services state
5. Recover service that has failed
6. Detect unrecognized messages sent to the service
by the client application

 Why SOAP fault and not CLR exception
◦ Simply , CLR exceptions are specific to the.NET
framework, java client application would not
understand the format of a CLR exception raised by
a WCF service
 So, Interoperable services built by using the
WCF should convert .NET Framework
exceptions into SOAP faults and follow the
SOAP specification for reporting these faults
to client applications.

WCF Service
WCF
runtime
Client
Throws FaultException
Object
Generate Soap fault
message

ServiceMthod{
Try{
service logic that may
generate an exception
}
catch(Exception e )
{
throw new
FaultException(
e.message,
new
FaultCode(“FaultName”)
}
Catching Client side
SeviceCall{
Try{
calling serviceMethod()
}
catch(FaultException e )
{
print e.code.name,
print e.Reason
}

 Strongly typed exception
◦ A SOAP fault message that contains a sufficient
detail about the exception in order to enable the
user, or an administrator, to understand the reason
for the exception and if possible take any necessary
corrective action.
◦ Use FaultContract attributes in a service contract
◦ Note you cannot use it with one way operations

 Configure the WCF service to send details
of Unanticipated exceptions
◦ Configuration file
 In the <serviceBehaviors> section of the App.config file add this tag in
the <behavior> section
 Setting the includeExceptionDetailInFaults attribute to true causes WCF
to transmit the full details of exceptions when it generates SOAP faults
for unanticipated errors.
◦ Programmatically
<serviceDebug includeExceptionDetailInFaults="true"/>
[ServiceBehavior(IncludeExceptionDetailInFaults=true)]
public class ServiceImpl : IService {}

 May I decide to make it a self study topic or
research that must be given in lab
 Or give them a hint about it
 Or decide to give it with no examples
 Or decide to give it with examples
 Summary if I didn’t give it I won’t be upset s

 when a ServiceHost object enters the Faulted state it triggers Faulted
event . You should subscribe to this event, and provide a method
that attempts to determine the cause, and then abort and restart the
service.// ServiceHost object for hosting a WCF service
ServiceHost HelloworldServiceHost;
HelloworldServiceHost = new ServiceHost(…);
// Subscribe to the Faulted event of the productsServiceHost object
HelloworldServiceHost.Faulted += new
EventHandler(faultHandler);
// FaultHandler method Runs when productsServiceHost enters the
Faulted state
void faultHandler(object sender, EventArgs e)
{
// Examine the properties of the HelloworldServiceHost
object
// and log the reasons for the fault
// Abort the service
HelloWorldServiceHost.Abort();
// Recreate the ServiceHost object
HelloWorldServiceHost = new ServiceHost(…);
// Start the service
HelloWorldServiceHost.Open();

 If a client application sends a message specifying an action that
the service does not recognize, the service host application
raises the UnknownMessageReceived event. The host application
can catch this event and record the unrecognized message, like
this// ServiceHost object for hosting a WCF service
ServiceHost HelloWorldServiceHost;
HelloWorldServiceHost = new ServiceHost(…);
// Subscribe to the UnknownMessageReceived event of the
HelloWorldServiceHost object
HelloWorldServiceHost.UnknownMessageReceived += new
EventHandler<UnknownMessageReceivedEventArgs>(unknownMessag
e);
// UnknownMessageReceived event handler
void unknownMessage(object sender,
UnknownMessageReceivedEventArgs e)
{
// Log the unknown message
// Display a message to the administrator
MessageBox.Show("A client attempted to send the message
" +
e.Message.Headers.Action);

WCF Fundamentals

In this document