WSE 3.0 and WCF

How to Get Ready for WCF

Most developers are understandably ambivalent about a major upcoming release such as WCF. On the one hand, we welcome advancements in technology and the improvements in functionality and productivity that it will hopefully bring. On the other hand, we dread having to learn a new way of doing things, and we wonder whether we will be able to migrate our existing code to the new infrastructure.

These are valid concerns, especially with WCF. But the issue is less about WCF changing things than it is about things needing to change. Developers today are faced with multiple and often competing technologies for building distributed applications, including the classic choice between XML Web services vs. .NET Remoting. Certainly, there are cases where there is no overlap and no ambivalence and where one technology is clearly the better choice than another. But these technologies share too much in common to be treated differently. They are simply variations of the same technology. In the case of XML Web services and .NET Remoting, they are both concerned with remote distributed object and service invocation over a defined transport channel.

Microsoft is starting to address developer concerns by providing guidelines for how to get ready for WCF. It is already making sure to bring this topic up at professional conferences, and it will certainly continue to do so until the release of WCF. There has simply been too much investment in existing technologies for it not to.

WCF is obviously not a replacement for the entire set of .NET Framework functionality. Instead, it is focused on supporting distributed service-oriented applications with security, transaction support, and reliable messaging. WCF primarily extends four core technologies that are available today:

• ASP.NET Web services (built with .asmx pages)

• Web Services Enhancements (WSE)

• System.Messaging

• System.EnterpriseServices

Microsoft has stated that it will make the migration to WCF from current technologies a straightforward process. Here are some guidelines on how to get ready for WCF based on professional conferences, published white papers, and conversations with members of product development teams:

• Build services using .asmx pages.

• Use WSE 3.0 for additional, extended functionality, including security, policy, and secure conversation.

• Build qualified XML schema files for all custom data types used by the service.

• Use managed framework classes for integrating your services with MSMQ message queues and with COM+ components. Use the managed System.Messaging namespace for MSMQ, and the System.EnterpriseServices namespace for COM+ components.

• Avoid using the HTTP Context object in your .asmx pages.

• Avoid using .NET Remoting sinks and channels.

Given that WSE 3.0 is such an important part of this book, let's look in more detail at how you can use the toolkit to prepare for WCF

WSE 3.0 and WCF

WSE 3.0 allows developers to become early adopters of the next generation of service-oriented application technology. Every hour that you spend working with WSE 3.0 is an hour that you have contributed toward WCF. Applications that are built using WSE should migrate smoothly to the WCF framework, with only minor modifications required. If you choose to implement WSE today, then you should expect to accommodate changes to WSE between now and the release of WCF. It is unclear how many revisions WSE is expected to undergo prior to the release of WCF, but it is likely that we will only see service packs released, and they are not expected to negatively impact compatibility between WSE 3.0 andWCF. If anything, they should only make the compatibility tighter.

Feature Comparison of WSE 3.0 and WCF 

The main feature that is lacking in WSE 3.0 (compared to WCF) is that it does not provide wide system-level or infrastructure-level support for the enterprise aspect of service-oriented applications. Specifically, it does not provide support for transactions or reliable messaging. Certainly, WSE 3.0 provides many of the required parts, but it does not provide the whole. For example, WSE 3.0 provides support for message addressing, and it also integrates with MSMQ via the System.Messaging namespace classes. So WSE 3.0 gives you the ability today to custom build a service-oriented application that implements "reliable" messaging (via MSMQ) and which can process message addressing information and provide message correlation. But this is not the same as a built-in support infrastructure that manages these tasks for you.

These limitations are not a weakness of the WSE 3.0 technology. They simply underscore two things:

1. Infrastructure support for message-based, service-oriented architecture is most effectively handled at the operating system level.

2. WSE 3.0 allows early adopters to start designing and building their code for the future WCF infrastructure. More importantly, it gets developers thinking about application design in new ways. There is a large conceptual jump between traditional RPC-based applications and message-based, service-oriented applications.

With this being said, let's review the major feature areas of WSE 3.0 (which you should by now feel very familiar with) and explain where they fit within the WCF framework:

• Security and policy specifications: The WS-Security and WS-Policy specifications are supported by the WCF connector.

• Messaging specifications: WCF provides Messaging services that subsume the functionality currently provided by MSMQ. In addition, it provides support for reliable messaging. WSE does not currently provide comprehensive support for the WS-Reliable Messaging specification, but it does provide some of the component parts that you can cobble together to approximate the specification. Specifically, WSE includes support for WS-Addressing, and it integrates with MSMQ via the managed System.Messaging namespace.

• Routing and referral specifications: WCF includes these within its Messaging services functionality.

• Alternate transport channels: WCF provides support for several transport channels, including HTTP, TCP, and IPC. WSE 3.0 currently provides support for the same three channels, so you can begin coding with them today.

In closing, we hope that this book has ultimately convinced you of three important things:

1. Message orientation and service orientation are the way to go.

2. WCF provides a welcome level of support for this technology, which will increase developer productivity and minimize confusion by unifying today's disparate technologies.

3. WSE 3.0 is an excellent way for developers to become early adopters for WCF.

Good luck with your future adventures in service-oriented architecture!

OOPS

Difference between Abstract class and Interface in C# .Net

Interfaces are essentially having all method prototypes no definition but Abstract class can contain method definations also.

In short Interface is a abstract class having all methods abstract.

If you create a abstract class writing the abstract keyword in the declaration part then You only can inherit the class. You can not create an instance of this abstract class but can inherit the class and with creating the instance of the derived class you can access the method of the abstract class.

If you use a virtual keyword in a method then you can override this method in the subclass if you wish..

If you create a abstract method then you must override this method in the subclass other wise it shows error in the program.

You cannot instantiate Abstract Classes and Interfaces

An interface has all public members

 You can inherit abstract classes to other class

Abstract :
=========================================
1. Abstract class cannot be instantiated.
2. Abstract class may contain abstract methods and accessors.
3. Abstract modifier can be used with classes, methods and properties.
4. A non-abstract class derived from an abstract class must include actual implementations of all inherited abstract methods and accessors.
5. Abstract method declarations are only permitted in abstract classes.

6.Abstract class can contain abstract methods, abstract property as well as other members (just like normal class).

7.Interface can be used to achieve multiple inheritance; abstract class can be used as a single inheritance

8.Abstract class are known as partial abstract class whereas interface is known as fully abstract class
***********************************************************
Interface :
=========================================
1.Interfaces are similar to classes.
2.They can have member properties and methods.
3.All the properties and methods of interfaces are abstract.
4.They have no body, just the declaration.
5.Public, Protected, Private, Friend, Shared, Overrides, MustOverride, NotOverridable are permitted inside an interface.

6.It’s a pure abstract class.

Runtime polymorphism

using System;
using System.Collections.Generic;
using System.Text;

namespace ConsoleApplication1
{
class Program
{
static void Main(string[] args)
{
A objA = new A();
B objB = new B();
sendmsg(objA);
sendmsg(objB);
Console.ReadLine();
}
public static void sendmsg(imsg objmsg)
{
objmsg.displaymessage();
}
}

interface imsg
{
void displaymessage();
}
class A : imsg
{
public void displaymessage()
{
Console.WriteLine("this is class A displaymsg()");
}
}

class B : imsg
{
public void displaymessage()
{
Console.WriteLine("this is class B displaymsg()");
}
}
}

WCF OverView PPT

WCF OverView

WCF: Step-by-Step Tutorial

This is a getting started tutorial to Windows Communication Foundation (WCF) Services. I have discussed a simple service to calculate the area of a rectangle; yup, very simple 

1. First you need to download and install Visual Studio 2005 extensions for .NET Framework 3.0 (Windows Workflow Foundation).

Oops, looks like it needs a windows validation (bit of a problem if you have a pirate copy  )

2. Once the installation is complete, start Visual Studio to create the project.

Goto File->New->Web Site, and you’ll see a new template called WFC Service.

Click OK to create an empty WCF Service.

3. Time to get started with the coding

Service.svc

<% @ServiceHost Language=C# Debug="true" Service="GeometryService" CodeBehind="~/App_Code/Service.cs" %>

Only a small change here – the name of the service

Web.config

<?xml version="1.0"?>

 

<configuration xmlns="http://schemas.microsoft.com/.NetConfiguration/v2.0">

  <system.serviceModel>

    <services>

      <!-- Before deployment, you should remove the returnFaults behavior configuration to avoid disclosing information in exception messages -->

      <service name="GeometryService" behaviorConfiguration="GeometryServiceBehavior">

        <endpoint contract="IGeometryService" binding="wsHttpBinding"/>

      </service>

    </services>

    <behaviors>

      <serviceBehaviors>

        <behavior name="GeometryServiceBehavior" >

          <serviceDebug includeExceptionDetailInFaults="true" />

          <serviceMetadata httpGetEnabled="true" />

        </behavior>

      </serviceBehaviors>

    </behaviors>

  </system.serviceModel>

 

  <system.web>

    <compilation debug="true"/>

  </system.web>

 

 </configuration>

Enable metadata publishing and change the name of the service.

Service.cs

using System;

using System.ServiceModel;

using System.Runtime.Serialization;

 

// A WCF service consists of a contract (defined below as IMyService, DataContract1), 

// a class which implements that interface (see MyService), 

// and configuration entries that specify behaviors associated with 

// that implementation (see <system.serviceModel> in web.config)

 

[ServiceContract()]

public interface IGeometryService

{

 [OperationContract]

 int GetArea(Rectangle rect);

 [OperationContract]

 int GetPerimeter(int width, int height);

}

 

public class GeometryService : IGeometryService

{

 public int GetArea(Rectangle rect)

 {

  return rect.Area();

 }

 

 public int GetPerimeter(int width, int height)

 {

  Rectangle rect = new Rectangle(width, height);

  return rect.Perimeter();

 }

}

 

[DataContract]

public class Rectangle

{

 int width;

 int height;

 

 public Rectangle(int width, int height)

 {

  Width = width;

  Height = height;

 }

 

 [DataMember]

 public int Width

 {

  get { return width; }

  set { width = value < 0 ? 0 : value; }

 }

 

 [DataMember]

 public int Height

 {

  get { return height; }

  set { height = value < 0 ? 0 : value; }

 }

 

 public int Area()

 {

  return Height * Width;

 }

 

 public int Perimeter()

 {

  return 2 * (Height + Width);

 }

}

This is the code for the service.

4. Run the service – click F5 

This is what you get on the browser. So, lets do what they want.

5. Run the following on you command on Visual Studio Command Prompt

svcutil.exe http://localhost:1479/GeoWFCService/Service.svc?wsdl

Watch out, the path might be different  . And if you don’t know what Visual Studio command prompt is

6. Let’s create the client

Create (or rather add) a new project; this could even be a website

7. Then run the service – Ctrl + F5

8. Add a web reference to the service

8. Copy the GeometryService.cs created by svcutil in step 5 to the clients working (main) folder and add them to the project

You should also copy the configurations of output.config created by svcutil to app.config

9. Again time for coding

Form1.cs

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Data;

using System.Drawing;

using System.Text;

using System.Windows.Forms;

 

namespace GeoWFCClient

{

 public partial class Form1 : Form

 {

  public Form1()

  {

   InitializeComponent();

  }

 

  private void calculateButton_Click(object sender, EventArgs e)

  {

   GeometryServiceClient gsclient = new GeometryServiceClient();

 

   /* The overloaded constructor of Rectangle is not present here */

   Rectangle rect = new Rectangle();

 

   rect.Width = Int32.Parse(widthTextBox.Text);

   rect.Height = Int32.Parse(heightTextBox.Text);

 

   areaTextBox.Text = gsclient.GetArea(rect).ToString();

   perimeterTextBox.Text = gsclient.GetPerimeter(rect.Width, rect.Height).ToString();

  }

 }

}

Set the textboxes and labels with appropriate names.

10. When you compile you’ll get a set of error because some assemblies are not referenced. Add references to them

11. Now see how it works

Start the service if haven’t done so already, and run the client

Wow! It works 

Ok, hope you learned something with this and I got to go study for exam