Wcf development

Binu Bhasuran
Microsoft MVP Visual C#
Facebook http://facebook.com/codeno47
Blog http://proxdev.com/

Windows Communication Foundation (WCF) is
Microsoft’s unified programming model for
building service-oriented applications. It
enables developers to build secure, reliable,
transacted solutions that integrate across
platforms and interoperate with existing
investments.

When clients call the service, will they call one
method or more than one method?
If they call more than one method, how much time
elapses between method calls?
If they call more than one method, does the service
need to maintain state between calls?
Will clients call the service frequently or
infrequently?
How many clients at a time will call the service?

Rather than requiring different technologies for
different communication styles, WCF provides a
single unified solution

Reflecting the heterogeneity of most
enterprises, WCF is designed to interoperate
well with the non-WCF world.
There are two important aspects of this:
interoperability with platforms created by other
vendors, and interoperability with the Microsoft
technologies that preceded WCF.

WCF-based applications running in a different
process on the same Windows machine
WCF-based applications running on another
Windows machine

Applications built on other technologies, such
as Java EE application servers, that support
standard Web services. These applications can
be running on Windows machines or on
machines running other operating systems, such
as Sun Solaris, IBM z/OS, or Linux.

Share schema, not class. Unlike older
distributed object technologies, services
interact with their clients only through a well-
defined XML interface. Behaviors such as
passing complete classes, methods and all,
across service boundaries aren’t allowed.

Services are autonomous. A service and its clients
agree on the interface between them, but are
otherwise independent. They may be written in
different languages, use different runtime
environments, such as the CLR and the Java Virtual
Machine, execute on different operating systems,
and differ in other ways.

A service class, implemented in C# or Visual
Basic or another CLR-based language, that
implements one or more methods.
A host process in which the service runs.
One or more endpoints that allow clients to
access the service. All communication with a
WCF service happens via the service’s
endpoints.

A service class is a class like any other, but it has a
few additions. These additions allow the class’s
creator to define one or more contracts that this
class implements.
Each service class implements at least one service
contract, which defines the operations this service
exposes.
The class might also provide an explicit data
contract, which defines the data those operations
convey.

Every service class implements methods for its
clients to use.
The creator of the class determines which of its
methods are exposed as client-callable
operations by specifying that they are part of
some service contract.
To do this, a developer uses the WCF-defined
attribute ServiceContract.

using System.ServiceModel;
[ServiceContract]
class RentalReservations
{
[OperationContract]
public bool Check(int vehicleClass, int location,
string dates)
{
bool availability;
// code to check availability goes here
return availability;
}

[OperationContract]
public int Reserve(int vehicleClass, int location,
string dates)
{
int confirmationNumber;
// code to reserve rental car goes here
return confirmationNumber;
}
[OperationContract]
public bool Cancel(int confirmationNumber)
{
bool success;
// code to cancel reservation goes here
return success;
}
public int GetStats()
{
int numberOfReservations;
// code to get the current reservation count goes here
return numberOfReservations;
}
}

A WCF service class specifies a service contract
defining which of its methods are exposed to
clients of that service.
Each of those operations will typically convey some
data, which means that a service contract also
implies some kind of data contract describing the
information that will be exchanged.
In some cases, this data contract is defined
implicitly as part of the service contract.

using System.Runtime.Serialization;
[DataContract]
struct ReservationInfo {
[DataMember] public int vehicleClass;
[DataMember] public int location;
[DataMember] public string dates;
}

A WCF service class is typically compiled into a
library. By definition, all libraries need a host
Windows process to run in.
WCF provides two main options for hosting
libraries that implement services.
One is to use a host process created by either
Internet Information Services (IIS) or a related
technology called the Windows Activation Service
(WAS).
The other allows a service to be hosted in an
arbitrary process.

The simplest way to host a WCF service is to rely
on IIS or WAS. Both rely on the notion of a
virtual directory, which is just a shorter alias for
an actual directory path in the Windows file
system.
<%@Service language=c#
class="RentalReservations" %>

public class ReservationHost
{
public static void Main()
{
ServiceHost s =
new ServiceHost(typeof(RentalReservations));
s.Open();
Console.Writeline("Press ENTER to end service");
Console.Readline();
s.Close();
}
}

An address indicating where this endpoint can be
found. Addresses are URLs that identify a machine
and a particular endpoint on that machine.
A binding determining how this endpoint can be
accessed. The binding determines what protocol
combination can be used to access this endpoint
along with other things, such as whether the
communication is reliable and what security
mechanisms can be used.

A contract name indicating which service contract
this WCF service class exposes via this endpoint. A
class marked with ServiceContract that implements
no explicit interfaces, such as RentalReservations in
the first example shown earlier, can expose only
one service contract.
In this case, all its endpoints will expose the same
contract. If a class explicitly implements two or
more interfaces marked with ServiceContract,
however, different endpoints can expose different
contracts, each defined by a different interface.

BasicHttpBinding: Conforms to the Web Services Interoperability Organization (WS-I) Basic Profiles 1.2
and 2.0, which specify SOAP over HTTP. This binding also supports other options, such as using HTTPS
as specified by the WS-I Basic Security Profile 1.1 and optimizing data transmission using MTOM.
WsHttpBinding: Uses SOAP over HTTP, like BasicProfileBinding, but also supports reliable message
transfer with WS-ReliableMessaging, security with WS-Security, and transactions with WS-
AtomicTransaction. This binding allows interoperability with other Web services implementations that
also support these specifications.
NetTcpBinding: Sends binary-encoded SOAP, including support for reliable message transfer, security,
and transactions, directly over TCP. This binding can be used only for WCF-to-WCF communication.
WebHttpBinding: Sends information directly over HTTP or HTTPS—no SOAP envelope is created. This
binding first appeared in the .NET Framework 3.5 version of WCF, and it’s the right choice for RESTful
communication and other situations where SOAP isn’t required. The binding offers three options for
representing content: text-based XML, JavaScript Object Notation (JSON), and opaque binary encoding.
NetNamedPipesBinding: Sends binary-encoded SOAP over named pipes. This binding is only usable for
WCF-to-WCF communication between processes on the same machine.
NetMsmqBinding: Sends binary-encoded SOAP over MSMQ, as described later in this paper. This
binding can only be used for WCF-to-WCF communication.

{
ServiceHost s =
new ServiceHost(typeof(RentalReservations));
s.AddEndpoint(typeof(RentalReservations),
new BasicHttpBinding(),
"http://www.fabrikam.com/reservation/reserve.svc");
s.Open();
Console.Writeline("Press ENTER to end service");
Console.Readline();
s.Close();
}

public class RentalReservationsClient
{
{
int confirmationNum;
RentalReservationsProxy p = new RentalReservationsProxy();
if (p.Check(1, 349, “9/30/09-10/10/09”)) {
confirmationNum = p.Reserve(1, 349, “9/30/09-10/10/09”);
}
p.Close();
}
}

http://msdn.microsoft.com/en-us/netframework/first-steps-with-wcf.aspx

Wcf development

More Related Content

What's hot (20)

Viewers also liked (19)

Similar to Wcf development (20)

More from Binu Bhasuran (10)

Recently uploaded (20)

Wcf development