A service is a program that performs a task and that a
client application can communicate with through well-defined messages. To call
a Web or WCF service, the client passes it a message, which consists of XML.
The message will typically include a request for the service to perform an
action, such as retrieve or update the inventory information for a product. If
the service returns data to the client, it passes back a message, also
consisting of XML.
The client and the service need to agree on what the XML
will look like. The most common message format is Simple Object Access Protocol
(SOAP). SOAP defines the format of XML request and reply messages and how
clients and services encode the data in the messages.
In object-oriented programming, objects are tightly coupled.
To call the Inventory component, a client application creates an instance of
the component and therefore, controls its lifetime. In a service-oriented
application, services and clients are loosely coupled. To call the Inventory
service, a client does not instantiate an instance of a component. It simply
passes a message to the service and may receive a message in return.
Service-oriented applications are loosely coupled. All
communication occurs through messages. SOAP defines the format of messages.
Contracts define the contents of messages. A service will publish a contract
that specifies what methods clients can call, what arguments those methods take
and what, if anything, the methods return. The contract can also specify
security requirements and whether a transaction is required.
Why Use Windows Communication Foundation?
WCF provides a number of benefits over ASP.NET Web Services,
including:
- Support for sending
messages using not only HTTP, but also TCP and other network protocols.
- The ability to switch
message protocols with minimal effort.
- Support for hosting
services on hosts other than a Web server.
- Built-in support for the
latest Web services standards (SOAP 1.2 and WS-*) and the ability to
easily support new ones.
- Support for security,
transactions and reliability.
- Support for sending
messages using formats other than SOAP, such as Representational State
Transfer (REST).
What is Serialization
Serialization is the process of converting an object into a stream of
bytes in order to store the object or transmit it to memory, a database,
or a file. Its main purpose is to save the state of an object in order
to be able to recreate it when needed. The reverse process is called
deserialization.
The object is serialized to a stream, which carries not just the data,
but information about the object's type, such as its version, culture,
and assembly name. From that stream, it can be stored in a database, a
file, or memory.
Uses of Serailization
Serialization allows the developer to save the state of an object and
recreate it as needed, providing storage of objects as well as data
exchange. Through serialization, a developer can perform actions like
sending the object to a remote application by means of a Web Service,
passing an object from one domain to another, passing an object through a
firewall as an XML string, or maintaining security or user-specific
information across applications.
Types of Serialization
Binary Serialization
Binary serialization is used for serializing an object which uses
network steams,
or convert a WCF object type and store in the file system.
Binary serialization is used to get data back from a network stream and
other types without any loss. The binary object can be serialized to
disk, memory, network, etc. The class public and private members are
serialized and restored
back as the original value in the deserialization
process. This process is used to store large object values in
persistence storage or
to send them through a network and restore back when
required.
The serialization process is useful when a large object has to
be stored in persistence storage. The object
oriented class hierarchy
may involve complexity for storing and retrieving values. This process
is useful for resolving complexities automatically. The
Common Language
Runtime will manage the object reference and circular references between
classes automatically.
Binary serialization uses binary format for understanding communication
between .NET
Framework applications. It saves metadata information along
with an object. It helps for restructuring the object when it
deserializes an object from persistence storage.
A binary formatter is faster
than other serialization formatters. It can serialize generic and
non-generic collections. This serialization supports serializing private
and public members.
XML And Soap Serialization
The XmlSerializer class is derived directly from the Object
base class. XML serialization does not include type information. XML
serialization serializes only public fields and properties of the
object into an XML stream that confirms with the specific XSD language.
he
System.Xml.Serialization namespace has all the classes and interfaces
for serializing and deserializing values. SOAP serialization confirms to the
SOAP specification. Web applications can use the
XmlSerializer class to create XML and send across applications. XML
serialization converts only public fields and properties of an object into the XML stream.
Serializer in WCF
Basically their are two Serializer in WCF
1- DataContactSerializer
2- NetDataContactSerializer
DataContractSerializer does not include the CLR type information in the serialized XML, which allows for loose coupling between the client and server because they don’t have to share the same CLR types.
However, this also means you often have to re-create the same types
on the client, though Visual Studio handles most of this for you when
you add a new service reference to your project. However, rather
than deserializing the original type, messages are
deserialized into a new, but identical
CLR type on the client.
NetDataContactSerializer
While DataContractSerializer is used by
WCF by default, there is another serializer which you can use if you wish to share the same
CLR types between the client and server – the
NetDataContractSerializer. The NetDataContractSerializer differs from the DataContractSerializer in that it includes the
CLR type information in the serialized
XML and can only be used if the same
CLR types are serialized and deserialized at both ends.
You can use the NetDataContractSerializer on any type which are marked with the
DataContractAttribute or
SerializableAttribute, or types that implement the
ISerializable interface.
Here is the DataContractSerializer version of the Person data
<Customer xmlns="http://www.contoso.com" xmlns:i="http://www.w3.org/2001/XMLSchema-instance">
<FirstName>Zighetti</FirstName>
<ID>101</ID>
<LastName>Barbara</LastName>
</Customer>
And here is the version from the NetDataContractSerializer
<Customer z:Id="1" z:Type="NetDCS.Person" z:Assembly="NetDCS, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null" xmlns="http://www.contoso.com" xmlns:i="http://www.w3.org/2001/XMLSchema-instance" xmlns:z="http://schemas.microsoft.com/2003/10/Serialization/">
<FirstName z:Id="2">Zighetti</FirstName>
<ID>101</ID>
<LastName z:Id="3">Barbara</LastName>
</Customer>
