Question

I have been going through the book “Learning WCF” trying to get my head around creating and using WCF web services. The first part of the book walks the reader through creating and then consuming a simple “Hello World” web service.

The problem I am having is that the client application seems to have no know the structure of the WCF Interface when calling it. How can this be necessary if a web service could be called from any number of programming languages?

I have listed the relevant example code below …

Here is the code for the Interface

 [ServiceContract(Namespace="http: //www.thatindigogirl.com/samples/2006/06")]
 public interface IHelloIndigoService
 {
  [OperationContract]
  string HelloIndigo();
 }

Here is the code for the Service that hosts the web service

static void Main(string[] args)
{
  using (ServiceHost host = new ServiceHost(typeof(HelloIndigo.HelloIndigoService) ,
    new Uri("http: //localhost: 8000/HelloIndigo")))
  {
    host. AddServiceEndpoint(typeof(HelloIndigo. IHelloIndigoService) ,
      new BasicHttpBinding(), "HelloIndigoService");
    host. Open( );
    Console. WriteLine("Press <ENTER> to terminate the service host") ;
    Console. ReadLine();
  }
}

Here is the code for the client app that consumes the WCF service
This is where I get confused. Since this client application could be any language capable of calling a web service why is there a necessity of knowing the definition of the interface?

using System. ServiceModel;
[ServiceContract(Namespace = "http: //www.thatindigogirl.com/samples/2006/06")]
public interface IHelloIndigoService
{
  [OperationContract]
  string HelloIndigo( );
}

static void Main(string[ ] args)
{
 EndpointAddress ep = new
   EndpointAddress("http: //localhost: 8000/HelloIndigo/HelloIndigoService") ;
 IHelloIndigoService proxy = ChannelFactory<IHelloIndigoService>.
   CreateChannel(new BasicHttpBinding(), ep);

 string s = proxy. HelloIndigo();
 Console. WriteLine(s) ;
 Console. WriteLine("Press <ENTER> to terminate Client.") ;
 Console. ReadLine();
}

Am I missing an important point here? Perhaps my understanding of what is needed to consume a web is lacking. My goal is to be able to use WCF to create a .NET service that could be called from any programming language or environment.

Might anyone suggest a good tutorial on creating “cross platform consumable” web services from within .NET? Thanks!

Answer 1

This approach is based on shared interface (the book acutally does not share the interface but instead it uses local copy) and is successfully applied in environment where both client and server are written in .NET. This approach is not usable for interoperability or SOA solutions.

Other approach uses metadata exposed by the service. Metadata are defined as WSDL document plus several XSD documents. These metadata files are way to provide information about your service to both .NET and non .NET developers. The book contains definition of Metadata (mex) endpoint so you will definitely read about that.

Using metadata in .NET means creating service proxy. You can do it automatically using Visual studio’s Add service reference or command line utility svcutil.exe. Anyway generated proxy code will probably still contain the interface created from metadata. It is used to create transparent abstraction of the service for the client.