January 2009 - Posts
The evolution of programming languages have been categorized as 1GL, 2GL, 3GL, 4GL....E.g. Machine Language -> Assembly Language -> C / Fortran -> SQL / Focus 4GL. The evolution of these languages are towards Low level language to High Level language.
In 1995, I stated learning computer languages. First I learned C, just after going through Fundamentals of Computer. In my first Academic project using C, I spent lots of time only for writing thousands lines of code. During this period I have gone through System Analysis and Design - where I learned about how to translate / transform the business application into computer systems [application]. Then I learned C++ and OOP, it was too nice experience, where I could compare the whole thing to real life cases. But it was amazing when I came to know SQL - real 4GL... Writing SQL Statement is about "WHAT" not "HOW" [With few exceptions - Query Hints etc.]. Using SQL generally few lines code computes the values from a set of collections as the resultset/output. Then I started my career with one of the biggest giant - Petroleum Company in India using Sybase and Power Builder. Here I got opportunity to work with all my favourite technologies.
About the future or coming technologies, termed as NEXT GEN Application, I expressed very early in one of my post published on September 15, 2005 Real Challenge to the architect for architecting and designing for FUTURE application development’s method.
That time I was thinking that DSL, ORM, Modeling language were dream and will be goals for the language developer.
Now Microsoft comes up to this with a fantastic way!!!
In last version - .NET Framework 3.5, we got LINQ, LINQ to SQL, LINQ to XML, LING to Object.... Here we focused more on the Entities, Visual Studio writes the code for data manipulation using SQL/XPath all underlying technologies... we stopped thinking about implementation to map the data source to object classes for .NET to some extents. Here we got LINQ to SQL, LINQ to XML and so on so...
This is not the "Full Stop" ("."). Along with more advancement, Microsoft came up with "M". It is "Oslo" Modeling Language which is a declarative language for working with data in more readable way for Structuring the the data as well as for querying too. It's not about how data is stored or accessed, even not by implementation of specific technology.
M builds on three basic concepts: values, types, and extents.
-
A value is the data which follows the rule
-
A type describes a set of values.
-
An extent provides dynamic storage for values.
M has been designed to map the relational model too. Using “Intellipad” tool of “Oslo”, model the data and the corresponding T-SQL statements generated by the compiler. Here “M”->SQL translates “M” "modules" to SQL "schemas."
More on..
http://msdn.microsoft.com/en-us/library/dd285271.aspx
http://msdn.microsoft.com/en-us/library/dd159725.aspx
Windows Communication Foundation (WCF) application is divided two layers namely Services and Clients
The WCF services can be exposed in different ways through Web, Windows Service, Self Hosting [Running Console Application]. The Endpoint [Which is having the Address, Binding, Contract(ABC)] is definded to expose service or consume it.
In our sample code so far we have developed Console Based application for both Service and Client Applications; then we have deployed the serive in IIS 6.0 in Windows Server 2003 in the first set of applications. The next set of applications are Web Applications.
For developing a WCF Service we have gone through steps
A. Sevice Layer
Step I - Designing Contracts
Step II - Service Hosting and Selecting Bindings
Step III - Configuring for Hosting the Service
B. Client Application
Step IV - Based on Sevice creating Proxy for invoking the Service
Now we will discuss futher in details.
We have looked that in both application, we have the one common thing, that is Endpoint includes the Service Contact, Address and Binding; only service hosting and client applications are different. The service contact is first item to be designed fo a Service.
A service contract is all about:
- Grouping of operations
- Signature of the operations for exchanging Mesages
- Data types of these messages.
- Protocols and serialization formats for communicating the messages
The contact is a set of specific messages organized into basic message exchange patterns (MEPs), such as request/reply, one-way, and duplex
One Way - Datagram-style delivery
Request-Reply - Immediate Reply on same logical thread
Duplex - Reply later and on backchannel (callback-style)
Three Types of Contracts
Service Contract - Operations, Behaviors and Communication Shape
Data Contract - Defines Schema and Versioning Strategies
Message Contract - Allows defining application-specific headers and unwrapped body content
All the contracts are defined on .NET application as CLR types and and on the wire it represents as XML format - WSDL/XSD/SOAP. This is implemented through Attributes. Here the details for all the types
Service
The Service and operations defines in a service through ServiceContract and OperationContract attrubutes.
Mapping: CLR types -> Web Services Description Language (WSDL)
Data
Describes a data structure using DataContract and DataMember attributes.
Mapping: CLR types -> XML Schema Definition (XSD)
Message
Defines the structure of the message on the wire using MessageContract, MessageHeader, MessageBody
Mapping: CLR types -> Simple Object Access Protocol (SOAP) messages.
Fault/Exception
For any CLR exceptions defined as fault contract using FaultContract attribute and the fault's CLR Type converts to SOAP faults.
Mapping: CLR types -> SOAP faults
Now after creating "Hello World" most easy Service we will very happy to see by getting access throug a browser to access WSDL file and can be used in any other application by adding Service Reference.
Yes, we can access it just like to .asmx web service through .svc file. To host one service using IIS 6.0 - Windows Server 2003, we have to map .svc file ISAPI extention. 
Here is the the .SVC, Web.config files to download
This is one of my most interesting eBook which gives the real concepts of SOA. I am here to share this... Click on the book's image to download
The metadata is to describe how to interact with the service's endpoints. We could generate Proxy class for the Client as well as it updates the .config files[App.config/Web.config] for the Client Application.
For example Svcutil.exe could automatically generated client code for accessing the service..
Trough Visual Studio 2008/2005 with WCF extension, we can "Add Service Reference" which does the entire necessary task for us.
For is purpose it is the following code added to the Service Code.
using System.ServiceModel.Description;
ServiceMetadataBehavior svcMetaBehav = new ServiceMetadataBehavior();
svcMetaBehav.HttpGetEnabled = true;
svcHost.Description.Behaviors.Add(svcMetaBehav);
The WSDL of this service looks like as following:
<wsdl:binding name="BasicHttpBinding_IMyFirstService" type="i0:IMyFirstService">
<soap:binding transport="http://schemas.xmlsoap.org/soap/http" />
<wsdl:operation name="MyFirstMethod">
<soap:operation soapAction="http://KolkataNET.WCF.HOL/IMyFirstService/MyFirstMethod" style="document" />
<wsdl:input>
<soap:body use="literal" />
</wsdl:input>
<wsdl:output>
<soap:body use="literal" />
</wsdl:output>
</wsdl:operation>
</wsdl:binding>
<wsdl:service name="MyFirstService">
<wsdl:port name="BasicHttpBinding_IMyFirstService" binding="tns:BasicHttpBinding_IMyFirstService">
<soap:address location="http://abu:8080/WCFKolkataNET/HOL/MyService" />
</wsdl:port>
</wsdl:service>
Step 5. Create New Console Project for creating Client Application the Service - Start running the Service when you generate the Proxy of the Service
5.1- Added Service Reference of the created Service
5.2- Created Proxy Class of the created Service - In service explorer click on show all files then a set of files will be showing which are auto generated, the proxy class file is here Reference.cs
5.3 This also generates the service binding details in App.config file
5.3 Auto generated Binding Details of the service in App.config file
<bindings>
<basicHttpBinding>
<binding name="BasicHttpBinding_IMyFirstService" closeTimeout="00:01:00"
openTimeout="00:01:00" receiveTimeout="00:10:00" sendTimeout="00:01:00"
allowCookies="false" bypassProxyOnLocal="false" hostNameComparisonMode="StrongWildcard"
maxBufferSize="65536" maxBufferPoolSize="524288" maxReceivedMessageSize="65536"
messageEncoding="Text" textEncoding="utf-8" transferMode="Buffered"
useDefaultWebProxy="true">
<readerQuotas maxDepth="32" maxStringContentLength="8192" maxArrayLength="16384"
maxBytesPerRead="4096" maxNameTableCharCount="16384" />
<security mode="None">
<transport clientCredentialType="None" proxyCredentialType="None"
realm="" />
<message clientCredentialType="UserName" algorithmSuite="Default" />
</security>
</binding>
</basicHttpBinding>
</bindings>
5.3 Auto generated End Point of the service in App.config file
<client>
<endpoint address="http://abu:8080/WCFKolkataNET/HOL/MyService" binding="basicHttpBinding"
bindingConfiguration="BasicHttpBinding_IMyFirstService" contract="MyFirstServiceClient.IMyFirstService"
name="BasicHttpBinding_IMyFirstService" />
</client>
5.4 Code in Prorgarm.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.Serialization;
using System.ServiceModel;
namespace KolkataNETWCFHelloWorld
{
class Program
{
static void Main(string[] args)
{
EndpointAddress endPointAddr = new EndpointAddress("http://abu:8080/WCFKolkataNET/HOL/MyService");
MyFirstServiceClient clientProxy = new MyFirstServiceClient(new BasicHttpBinding(), endPointAddr);
string strResponse = clientProxy.MyFirstMethod();
Console.WriteLine(string.Format("Response from MyFirstService: {0}", strResponse));
Console.WriteLine();
Console.ReadLine();
}
}
}
Run the Client Application
Step 1. Created one Console Project
Step 2. Created one Project in the same Solution IMyFirstService.csproj for declaring/designing Service contact
2.1- Added reference to System.ServiceModel
using System;
using System.Runtime.Serialization;
using System.ServiceModel;
namespace KolkataNETWCFHelloWorld
{
[ServiceContract(Namespace="http://KolkataNET.WCF.HOL")]
public interface IMyFirstService
{
[OperationContract]
string MyFirstMethod();
}
}
2.2 Design Simple Service Contract with one
[ServiceContract(Namespace="http://KolkataNET.WCF.HOL")]
public interface IMyFirstService
2.3 Design Simple Operation [Method/Function] using Attribute [OperationContract] by declaring the method name MyFirstMethod
Step 3. Created one Project in the same Solution MyFirstService.csproj for declaring/designing Service
3.1- Added reference to System.ServiceModel
using System;
using System.Runtime.Serialization;
using System.ServiceModel;
namespace KolkataNETWCFHelloWorld
{
public class MyFirstService : IMyFirstService
{
public string MyFirstMethod()
{
return string.Format("Hello World. Welcome KolkataNET!!!");
}
}
}
3.2 Design Simple Service implementing the above service Contract
public class MyFirstService : IMyFirstService
3.3 Design Simple Operation [Method/Function]
public class MyFirstService : IMyFirstService
{
public string MyFirstMethod()
{
return string.Format("Hello World. Welcome KolkataNET!!!");
}
}
Step 4. Modified the initial main Console Project to Self Host the Service
4.1- Added reference to System.ServiceModel - For hosting the service and exposing MEX - Metadata Exchange of the Service
using System;
using System.Runtime.Serialization;
using System.ServiceModel;
using System.ServiceModel.Description;
namespace KolkataNETWCFHelloWorld
{
class Program
{
static void Main(string[] args)
{
Uri svcBaseAddress = new Uri("http://abu:8080/WCFKolkataNET/HOL");
ServiceHost svcHost = new ServiceHost(typeof(MyFirstService), svcBaseAddress);
svcHost.AddServiceEndpoint(
typeof(IMyFirstService),
new BasicHttpBinding(),
"MyService");
ServiceMetadataBehavior svcMetaBehav = new ServiceMetadataBehavior();
svcMetaBehav.HttpGetEnabled = true;
svcHost.Description.Behaviors.Add(svcMetaBehav);
svcHost.Open();
Console.WriteLine("<ENTER> to stop the service - MyFirstService");
Console.WriteLine();
Console.ReadLine();
svcHost.Close();
}
}
}
4.2 Defining Base Address to host the Service
Uri svcBaseAddress = new Uri("http://abu:8080/WCFKolkataNET/HOL");
ServiceHost svcHost = new ServiceHost(typeof(MyFirstService), svcBaseAddress);
svcHost.AddServiceEndpoint(
typeof(IMyFirstService),
new BasicHttpBinding(),
"MyService");
4.3 Allowing to expose MEX of the Service
ServiceMetadataBehavior svcMetaBehav = new ServiceMetadataBehavior();
svcMetaBehav.HttpGetEnabled = true;
svcHost.Description.Behaviors.Add(svcMetaBehav);
4.3 Running the service until <ENTER> key has been pressed
svcHost.Open();
4.4 Closing the service when <ENTER> key has been pressed
svcHost.Close();
Running the Service - now we will create client to call it
Here is the code...
Click to Download
This is my first post for WCF HOL. I will be posting series of Lab Sessions with code and explanations for the whole series. I have noticed in one UG Session people who don't have any WCF backround but who are familiars of ASP.NET/.NET for them this series will be useful as a tutorial with practical.
Step by step I will be covering all the possible aspects of WCF. Same time I will be covering the SOA / Service based real life application scope especially for Connected and Distributed systems.
Please note that in the sample application every where I have used abu - which is my machine name, now for your case this will be your machine name
In Service Code
Uri svcBaseAddress = new Uri(http://abu:8080/WCFKolkataNET/HOL); // Change "abu" by your machine name
In Client Code
EndpointAddress endPointAddr = new EndpointAddress(http://abu:8080/WCFKolkataNET/HOL/MyService); // Change "abu" by your machine name