Download WcfDemoApplication - 82.4 KB

Table of Contents

Introduction
Background & References
Prerequisites
WCF Core Component
WCF Service -Server
Host :WCF Service
WCF Client
Enable Multiple Binding: <HTTP> <Binding><TCP Binding> etc.
Configure IIS Hosting Platform For WCF Service
Asynchronous Calling Of WCF Service In WCFClient.exe
Conclusion

Introduction

The objective of this article;

For beginner with ground knowledge of WCF.

Covers common errors and mistakes that developer makes during WCF implementation. The remediation to overcome the problem area.

Demo: Step by step WCF Implementation.

Technique to host WCF Service.

Multiple Binding and Asynchronous Call

Background & References

A reader can go through below references to understand the concept of Windows Communication Foundation. In short WCF services is workaround to below .net services. WCF is a way to leverage all these features under one umbrella.

.Net Remoting [ System.Runtime.Remoting ]

MSMQ [ System.Messaging ]

COM+/Enterprise Services [ .Net System.EnterpriseServices ]

XML Webservice [ System.Web.Services ]

WCF Overview

Working With WCF Instance

Prerequisites

Visual Studio 2010 and .Net 4.0

WCF Core Component

We've three core component in WCF implementation.

WCF Services

WCF Host

WCF Client

Each of the above component shipped with respective configuration file. This configuration file helps in establishing communication between WCF Service/Server, hosting and client environment.

These configuration consists of end points which defines the connection between host and client. The end points definition exist in host and client code package. Now it is important that we understand the underlying concept of endpoints. The simplest way to remember them is A B C 's (Address, Binding and Contract) of Endpoint.

A: Address [http://localhost:8080/abc]

B: Binding [wshttp]

C: Contract [ICustomerService]

One can very well relate this endpoint to Spring. net framework Dependency Injection Design where we declare the references in configuration and can be initialized and invoke at runtime.

WCF Service -Server

Open VS1010 ,select Project ->Select WCF -> Select WCF Service Application

1. Create ICustomer.cs and CustomerService.cs

ICustomer.cs

            
namespace WcfCustomerService
{
    [ServiceContract]
    public interface ICustomerService
    {
        [OperationContract]
        string GetServerResponse(int value);

        [OperationContract]
        Customer GetCustomerDetails(int customerID);
    }

    [DataContract]
    public class Customer
    {
        int m_CustomerID;
        string m_CustomerName = string.Empty;

        [DataMember]
        public int CustomerID
        {
            get { return m_CustomerID; }
            set { m_CustomerID = value; }
        }

        [DataMember]
        public string CustomerName
        {
            get { return m_CustomerName; }
            set { m_CustomerName = value; }
        }
    }
}

CustomerService .cs

            
namespace WcfCustomerService
{    
    public class CustomerService : ICustomerService
    {
        public string GetServerResponse(int value)
        {
            return string.Format("RESPONSE FROM WCF SERVICE :{0}", value);
        }

        public Customer GetCustomerDetails(int customerID)
        {
            Customer customer = null;
            if (customerID == 1)
            {
                customer = new Customer();
                customer.CustomerID = 1;
                customer.CustomerName = "Santosh Poojari";
            }
            return customer;
        }
    }
}

2. Add Service Web Configuration setting

The below given configuration is available by default and can be customized as per our need. If we are choosing IIS as WCF hosting platform then this configuration underwent changes. If used IIS as hosting then we need to mention endpoints of connectivity in the WCF service configuration file. We can explore more on this later part of this article.

3. Test WCF Service: Inbuilt VS2010 WCFTestClient.exe

To start the testing built +Run the service package. CTRL+F5. Once done application builds successfully and test executable will appear for testing this services.

The double click on methods as given below. Once done that Client test form will appear where we can easily test WCF service without any explicit host and client.

4. Troubleshooting: Most Common Mistake

Make sure you have changed the markup html references of Customerservice. If this tags are not updated as per the file names then WCFClientTest.Exe will throw error. Right click on the CustomerService.cs file in Solution explorer and select 'Markup'. One can make changes to this references as per the file name given.

If this changes are not taken care then it will throw below given error.

Host: WCF Client

Create simple console application. Select Project->Windows-> Console Application

1: Add WCF Service Package References

Add two Reference

using WcfCustomerService;

using System.ServiceModel;

2: Add Host Configuration App.config file

Define Connectivity to WCF Service through host using Endpoints. The host configuration has base address .This is required we're going to have multiple binding for our applications. We'll explore this configuration in details at later stage for multiple hosting configuration. We just need to append things to customize this hosting for different binding.

Define Endpoints: [Address][Binding][Contract]

Define Service Name WcfCustomerService.CustomerService

Define Host Base Address.

       
<configuration>
	<system.serviceModel>
		<services>
			<service name="WcfCustomerService.CustomerService">
				<endpoint address =""
				binding="basicHttpBinding"
				contract="WcfCustomerService.ICustomerService"/>
				<host>
					<baseAddresses>
						<add baseAddress ="http://localhost:8081/CustomerService"/>
					</baseAddresses>
				</host>
			</service>
		</services>		
	</system.serviceModel>
</configuration>

Once above code is in place we can now good to built and run the console host executable. Action: CTRL+F5

***Built & Run WCFHost :Output

3: Troubleshooting: Most Common Problem

It may happen the port which we configured in Endpoints may be used by some other application in transport layer and hence we may come across below mentioned error. Remediation change the Address port number[XXX] to some unused one like http://localhost:XXX/ABC

WCF Client

Add project-> window Console application for WCF Client.

1. Configure WCF Service Proxy: Metadata Exchange

Add Service Reference(Project -> Add Service Reference menu )

The following error may occurred: WCF Host is not running. ERROR 1:There was an error downloading 'http://localhost:8081/CustomerService'. Unable to connect to the remote server No connection could be made because the target machine actively refused it 10.0.0.1:8081 Metadata contains a reference that cannot be resolved: 'http://localhost:8081/CustomerService'. There was no endpoint listening at http://localhost:8081/CustomerService that could accept the message. This is often caused by an incorrect address or SOAP action. See InnerException, if present, for more details. Unable to connect to the remote server No connection could be made because the target machine actively refused it 10.0.0.1:8081 If the service is defined in the current solution, try building the solution and adding the service reference again.

Meta Data Not Configured In WCF Host Configuration

***Add Meta Data Exchange

In order to create proxy class or allow VS2010 Add Service Reference(Project ➤ Add Service Reference menu ) to properly create proxy class we need to add metadata exchange configuration. This can be achieved including <Behaviour> tags in Host configuration file. The host will create meta data representation of service to help creating proxy class for client. This is the same concept we've in Web service WSDL. We can also author proxy class using .net 4.0 framework SDK tool:svcutil.exe In existing host configuration just Add behaviour tag under system.serviceModel and give behaviour.configuration under services node.

       
 <behaviors>
				<serviceBehaviors>
					<behavior name="CustomerServiceMEXBehavior" >
						<serviceMetadata httpGetEnabled="true" />
					</behavior>
				</serviceBehaviors>
			</behaviors>

Complete WCF Host configuration Setting

         
<configuration>
	<system.serviceModel>
		<services>
			<service name="WcfCustomerService.CustomerService"
				behaviorConfiguration = "CustomerServiceMEXBehavior" >
				<endpoint address =""
				binding="basicHttpBinding"
				contract="WcfCustomerService.ICustomerService"/>
				<host>
					<baseAddresses>
						<add baseAddress ="http://localhost:8081/CustomerService"/>
					</baseAddresses>
				</host>
			</service>			
		</services>	
		<behaviors>
				<serviceBehaviors>
					<behavior name="CustomerServiceMEXBehavior" >
						<serviceMetadata httpGetEnabled="true" />
					</behavior>
				</serviceBehaviors>
			</behaviors>
	</system.serviceModel>
</configuration>

Once above tags are added,again add service reference by right click on WCFClient project. Enter the address as http://localhost:8081/CustomerService and click on 'Go' button. Reference will be added successfully.

2.Main Program: Client Code

Consume WCF Service in Main Program. The BasicHttpBinding_ICustomerService can be found in app.config file.The main highlight of this implementation is that we consumed service using HTTP binding. In later part we cover consuming service through IIS and TCP binding.

Note:If we're using IIS as hosting platform then we do not require explicit Host console application like we've now.

       

using WCFClient.BasicHttpBindingService;

namespace WCFClient
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                using (CustomerServiceClient customerServiceClient = new CustomerServiceClient("BasicHttpBinding_ICustomerService"))
                {
                    Console.WriteLine("***** Console Based WCF Client Started *****");
                    Customer customer = customerServiceClient.GetCustomerDetails(1);
                    Console.WriteLine("***** Consume WCF Service *****");
                    Console.WriteLine("HTTP Binding WCF Service Response :{0}", customer.CustomerName);
                    Console.ReadLine();
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine("HTTP Binding WCF Service Response ERROR:{0}", ex);
            }

        }
    }
}

3.WCF Client Configuration Setting App.config

This configuration will be created by default once we add service reference successfully.

       
<configuration>
    <system.serviceModel>
        <bindings>
            <basicHttpBinding>
                <binding name="BasicHttpBinding_ICustomerService" 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>
        <client>
            <endpoint address="http://localhost:8081/CustomerService" binding="basicHttpBinding"
                bindingConfiguration="BasicHttpBinding_ICustomerService" contract="BasicHttpBindingService.ICustomerService"
                name="BasicHttpBinding_ICustomerService" />
        </client>
    </system.serviceModel>
</configuration>

Now built and run the WCFClient Console application .CTRL+F5 . So with above steps and troubleshooting we are able to create WCF Service,WCF Hosting Engine and WCF Client.

***WCF Service -WCF Host-WCF Client Layers Snapshot

***Run WCFClient :Output

Enable Multiple Binding: <HTTP Binding><TCP Binding> etc.

In above example we configured HTTP binding in endpoints .Now we'll configure TCP binding. The objective is that client can consumed services through muiltple binding at a time.We can include multiple binding information in Host Console application's configuration file.

1. Configure ENDPOINT For TCP Binding

  
<endpoint address ="net.tcp://localhost:8090/CustomerService"
                  binding="netTcpBinding"
                  contract="WcfCustomerService.ICustomerService"/>

                   
<host>
	<baseAddresses>
	<add baseAddress ="http://localhost:8081/CustomerService"/>
	<add baseAddress ="net.tcp://localhost:8090/CustomerService"/>
	</baseAddresses>
</host>

				 
 <configuration>
	  <system.serviceModel>
		  <services>
			  <service name="WcfCustomerService.CustomerService"
				behaviorConfiguration = "CustomerServiceMEXBehavior" >
				  <endpoint address =""
				binding="basicHttpBinding"
				contract="WcfCustomerService.ICustomerService"/>
				
				  <endpoint address ="net.tcp://localhost:8090/CustomerService"
                  binding="netTcpBinding"
                  contract="WcfCustomerService.ICustomerService"/>
				
				  <host>
					  <baseAddresses>
						  <add baseAddress ="http://localhost:8081/CustomerService"/>
						  <add baseAddress ="net.tcp://localhost:8090/CustomerService"/>
					  </baseAddresses>
				  </host>
			  </service>			
		  </services>		
		  <behaviors>
				  <serviceBehaviors>
					  <behavior name="CustomerServiceMEXBehavior" >
						  <serviceMetadata httpGetEnabled="true" />
					  </behavior>
				  </serviceBehaviors>
			  </behaviors>
	  </system.serviceModel>
  </configuration  >

Built and run the WCFHost.exe again.CTRL+F5 .Keep this service running so that we can take service reference of this in WCFClient.exe

***Run WCFHost.exe

2. Add Service Reference In WCFClient.exe

Go to WCFClient.exe and update service reference(BasicHttpBindingService) file.The dialog box appear ,add TCP address. Once we update following tags will be added as default in WCFClient.exe app.config file

    
<netTcpBinding>
                 <binding name="NetTcpBinding_ICustomerService" closeTimeout="00:01:00"
                    openTimeout="00:01:00" receiveTimeout="00:10:00" sendTimeout="00:01:00"
                    transactionFlow="false" transferMode="Buffered" transactionProtocol="OleTransactions"
                    hostNameComparisonMode="StrongWildcard" listenBacklog="10"
                    maxBufferPoolSize="524288" maxBufferSize="65536" maxConnections="10"
                    maxReceivedMessageSize="65536">
                     <readerQuotas maxDepth="32" maxStringContentLength="8192" maxArrayLength="16384"
                        maxBytesPerRead="4096" maxNameTableCharCount="16384" />
                     <reliableSession ordered="true" inactivityTimeout="00:10:00"
                        enabled="false" />
                     <security mode="Transport">
                         <transport clientCredentialType="Windows" protectionLevel="EncryptAndSign" />
                         <message clientCredentialType="Windows" />
                     </security>
                 </binding>
             </netTcpBinding>
         </bindings>
         <client>
             <endpoint address="http://localhost:8081/CustomerService" binding="basicHttpBinding"
                bindingConfiguration="BasicHttpBinding_ICustomerService" contract="BasicHttpBindingService.ICustomerService"
                name="BasicHttpBinding_ICustomerService" />
             <endpoint address="net.tcp://localhost:8091/CustomerService"
                binding="netTcpBinding" bindingConfiguration="NetTcpBinding_ICustomerService"
                contract="BasicHttpBindingService.ICustomerService" name="NetTcpBinding_ICustomerService">
             </endpoint>
         </client >

***Update WCF Service Request In WCFClient

3.Call WCF Service From WCFClient

Invoke WCFService through TCP binding using below code.

   

namespace WCFClient
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                using (CustomerServiceClient customerServiceClient = new CustomerServiceClient("BasicHttpBinding_ICustomerService"))
                {
                    Console.WriteLine("***** Console Based WCF Client Started *****");
                    Customer customer = customerServiceClient.GetCustomerDetails(1);
                    Console.WriteLine("***** Consume WCF Service *****");
                    Console.WriteLine("HTTP Binding WCF Service Response :{0}", customer.CustomerName);                    
                }
                using (CustomerServiceClient customerServiceClient = new CustomerServiceClient("NetTcpBinding_ICustomerService"))
                {
                    Console.WriteLine("***** Console Based WCF Client Started *****");
                    Customer customer = customerServiceClient.GetCustomerDetails(1);
                    Console.WriteLine("***** Consume WCF Service *****");
                    Console.WriteLine("TCP Binding WCF Service Response :{0}", customer.CustomerName);                    
                }
                Console.ReadLine();
            }
            catch (Exception ex)
            {
                Console.WriteLine("HTTP/TCP Binding WCF Service Response ERROR:{0}", ex);
            }
        }
    }
}

Select WCFClient and CTRL+F5

***Run WCFClient :Output

Configure IIS Hosting Platform For WCF Service

If we're using IIS as host engine then no need to create explicit console or window service to run continuous WCF Service. No Host application here. So you must be thinking where can we mention my endpoints between host and Client.In previous example host application contains endpoint information for client to consume service.In IIS as hosting engine we can specify endpoint information in WCFService configuration itself. i.e Web.config file of WCF Service Application.

1. Create Virtual Directory For WCF Service :WCFCustomerService

Select WCFCustomerService and rightclick and select Property menu. In VS2010 we get options to create virtual directory for the WCFCustomerService.

2. Add Services Endpoint In WCFCustomerService Package.[WCF Service-Server]

If we're using IIS platform then there is no need of host package.In such cases we need to configure endpoint in server itself. Add below tags in WCFCustomerService package configuration file itself.

 
              <services>
		  <service name="WcfCustomerService.CustomerService">
			  <endpoint address =""
			  binding="basicHttpBinding"
			  contract="WcfCustomerService.ICustomerService"/>
		  </service>
	  </services>

Note: The configuration file for Service,Host and Client are almost similar.This configuration can be done using tool available in VS2010 but having hands -on will help in understand the concept.

3.Add Service Reference in WCFClient

Once virtual directory is created and endpoints are mentioned in WCFCustomerService Package, add service reference in WCFClient.exe for hosted services in IIS.

***Multiple Binding In Service Reference

The below endpoints and bindings gets added in WCFClient configuration file by default. There is no manual addition of tags here.

Note: If IIS is set for windows Authentication then in below configuration set Windows as <transport clientCredentialType="Windows" > <security mode="TransportCredentialOnly"> under basicHttpBinding

	      
<bindings>
           <basicHttpBinding>
	   <binding name="BasicHttpBinding_ICustomerService1" 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="TransportCredentialOnly">
                        <transport clientCredentialType="Windows" proxyCredentialType="None"
                            realm="" />
                        <message clientCredentialType="UserName" algorithmSuite="Default" />
                    </security>
                </binding>
                 </bindings>
            </basicHttpBinding>
             <client>
            <endpoint address="http://localhost:8081/CustomerService" binding="basicHttpBinding"
                bindingConfiguration="BasicHttpBinding_ICustomerService" contract="BasicHttpBindingService.ICustomerService"
                name="BasicHttpBinding_ICustomerService" />
            <endpoint address="net.tcp://localhost:8091/CustomerService"
                binding="netTcpBinding" bindingConfiguration="NetTcpBinding_ICustomerService"
                contract="BasicHttpBindingService.ICustomerService" name="NetTcpBinding_ICustomerService" />
            <endpoint address="http://10.10.10.10/WcfCustomerService1/CustomerService.svc"
                binding="basicHttpBinding" bindingConfiguration="BasicHttpBinding_ICustomerService1"
                contract="IISHostCustomerService.ICustomerService" name="BasicHttpBinding_ICustomerService1" />
        </client>

4.Call WCF Service From WCFClient

One must include specific references in case of multiple bindings.

	 
using WCFClient.BasicHttpBindingService;
using WCFClient.IISHostCustomerService;
namespace WCFClient
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                Console.WriteLine("...HTTP BINDING...");
                
                using (BasicHttpBindingService.CustomerServiceClient customerServiceClient1 = 
new BasicHttpBindingService.CustomerServiceClient("BasicHttpBinding_ICustomerService"))
          {
          Console.WriteLine("***** Console Based WCF Client Started *****");
          BasicHttpBindingService.Customer customer = customerServiceClient1.GetCustomerDetails(1);
          Console.WriteLine("***** Consume WCF Service *****");
          Console.WriteLine("HTTP Binding WCF Service Response :{0}", customer.CustomerName);                    
           }
           Console.WriteLine("...");
           Console.WriteLine("...TCP BINDING...");
            using (BasicHttpBindingService.CustomerServiceClient customerServiceClient2 = 
new BasicHttpBindingService.CustomerServiceClient("NetTcpBinding_ICustomerService"))
            {
               Console.WriteLine("***** Console Based WCF Client Started *****");
               BasicHttpBindingService.Customer customer = customerServiceClient2.GetCustomerDetails(1);
               Console.WriteLine("***** Consume WCF Service *****");
               Console.WriteLine("TCP Binding WCF Service Response :{0}", customer.CustomerName);                 
                }
                Console.WriteLine("...");
                Console.WriteLine("...IIS HTTP BINDING...");
                using (IISHostCustomerService.CustomerServiceClient customerServiceClient3 = new IISHostCustomerService.CustomerServiceClient("BasicHttpBinding_ICustomerService1"))
                {
                    Console.WriteLine("***** Console Based WCF Client Started *****");
                    IISHostCustomerService.Customer customer = customerServiceClient3.GetCustomerDetails(1);
                    Console.WriteLine("***** Consume WCF Service *****");
                    Console.WriteLine("IIS HTTP Binding WCF Service Response :{0}", customer.CustomerName);
                }
                Console.ReadLine();
            }
            catch (Exception ex)
            {
                Console.WriteLine("HTTP/TCP Binding WCF Service Response ERROR:{0}", ex);
            }
        }
    }
}

***Run WCFClient :Output

Asynchronous Calling Of WCF Service In WCFClient.exe

Add any service reference as given above.

Add Service Reference In WCFClient

Click on Advance button as given in the screen shot below.

Select Aysnchronous options under client section and click ok ,close the dialog box. Configuration for END Points will be added by default in WCFClient App.config file

   
            <client>           
            <endpoint address="net.tcp://localhost:8091/CustomerService"
                binding="netTcpBinding" bindingConfiguration="NetTcpBinding_ICustomerService1"
                
contract="AsynchronousCallWCFService.ICustomerService" name="NetTcpBinding_ICustomerService1">
            </endpoint>
        </client>

Invoke Asynchronous Call to WCF Service: WCFClient

        
namespace WCFClient
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {               
                Console.WriteLine("...");
                Console.WriteLine("...Async Calling of WCF Service...");
                Console.WriteLine("***** The Async Customer Client *****\n");

                using (AsynchronousCallWCFService.CustomerServiceClient asynProxyService = 
new AsynchronousCallWCFService.CustomerServiceClient("NetTcpBinding_ICustomerService1"))
                {
                    asynProxyService.Open();
                    
                    IAsyncResult asyncResult = asynProxyService.BeginGetServerResponse(786,
                      strResult =>
                      {
                          Console.WriteLine
("Get Server Response = {0}", asynProxyService.EndGetServerResponse(strResult));
                      },
                      null);

                    while (!asyncResult.IsCompleted)
                    {
                        Thread.Sleep(100);
                        Console.WriteLine("In Progress...");
                    }
                }
                Console.ReadLine();         
            }
            catch (Exception ex)
            {
                Console.WriteLine
("Aysnhcronous WCFClient Server Response ERROR:{0}", ex);
            }

        }
    }
}

Run the WCFClient.exe and you can see the response from WCFCustomerService. My whole idea was to represent the simplest cases that can help developer to built WCF fabrics in their application. Initially I ran pillars to post to do it by myself but it took me a lot to understand the concept and implementation. Thought of writing it as a demo and helping folks who would be interested to try simple WCF development.

Conclusion

I hope novice learner will able to grasp usuage of WCF service with ease and less issues.Any suggestions and corrections are most welcome.

Windows Communication Foundation QuickStart - Multiple Binding VS2010