Here i am going to explain creating proxies at runtime for WCF Service. So basically we use to generate proxies using Add Service Reference and then giving the Url of the WCF service then generate proxy files at client side. Ok, what if something gets changed at service? Do we need to regenerate the proxy files? Yes of course, we have to. How to over come such limitation? Here comes WCF handy in creating proxies at runtime. So we need not to create proxy using Add Service Reference option.
Actually speaking we are not going to create proxy at runtime, we are just invoking calls to WCF service using ChannelFactory class which is available under System.ServiceModel namespace. But to achieve this we need to expose the Interface(which define the service and operation) to the client. This option is more suitable if both the service and client is in your control. Ok lets start implementing the same. I ll create an small calculator service.
Define an Service Contract and Operation Contract. Create an separate class library so that it can be exposed to client.
namespace CalculatorServiceContract
{
[ServiceContract]
public interface ICalculator
{
[OperationContract]
int Add (int a, int b);
}
}
Next step is to implement the Interface in a class. Add reference to the CalculatorServiceContract dll in the Service class project. And implement as follows
namespace CalculatorService
{
// Implementation of CalculatorServiceContract
public class CalculatorService : ICalculator
{
public int Add(int a, int b)
{
return a + b;
}
}
}
Next step is to configure web.config at service.
<system.serviceModel>
<behaviors>
<serviceBehaviors>
<behavior>
<!-- To avoid disclosing metadata information, set the value below to false and remove the metadata endpoint above before deployment -->
<serviceMetadata httpGetEnabled="true"/>
<!-- To receive exception details in faults for debugging purposes, set the value below to true. Set to false before deployment to avoid disclosing exception information -->
<serviceDebug includeExceptionDetailInFaults="false"/>
</behavior>
</serviceBehaviors>
</behaviors>
<bindings>
<basicHttpBinding>
<binding name="basicHttpBinding_AtServer"/>
</basicHttpBinding>
</bindings>
<services>
<service name="CalculatorService">
<endpoint address="http://localhost/CalculatorSample/CalculatorService.svc"
binding="basicHttpBinding" bindingConfiguration="basicHttpBinding_AtServer"
contract="CalculatorServiceContract.ICalculator"/>
</service>
</services>
<serviceHostingEnvironment multipleSiteBindingsEnabled="true" />
</system.serviceModel>
Once done with the above steps, build the project and host in IIS. You can also use Visual Studio built-in web server by doing appropriate changes to web.config. For better flexibility i am using IIS.
Next is to create client project.
Create a Client project. It can be ASP.NET or Windows app or even console app. After creating new project try adding reference to CalculatorServiceContract dll. By doing this you are exposing the definition of service and operation to client. Also add reference to System.ServiceModel.
Configure the web.config(in case of ASP.NET app) or app.config(Windows app or console app).
<system.serviceModel>
<client>
<endpoint binding="basicHttpBinding"
address="http://localhost/CalculatorSample/CalculatorService.svc"
contract="CalculatorServiceContract .ICalculator"
name="basicHttpBind"/>
</client>
</system.serviceModel>
Then try to invoke the Service calls using ChannelFactory class. ChannelFactory class is used to create endpoint listener. You can also have multiple endpoint listeners by creating channels of same instance multiple times but with different endpoint configuration. Below is the code for the same.
public static void main(string args[])
{
/*Create a ChannelFactory instance of type ICalculator.
You need to create an channel by specifying the binding
name which is defined at web.config in client project
which is shown above. So the the below code will
create an endpoint listener*/
ICalculator calc = new ChannelFactory<ICalculator>("basicHttpBind").CreateChannel();
int A = calc.Add(12, 15);
Console.WriteLine(A);
}
Here ChannelFactory will be invoking the service calls by using the endpoint binding information. Endpoint can be of any type. If you want to use netTcpBinding, then appropriate changes need to be done in web.config(server) and web.config(client).
The main advantage of following the above method is whenever any changes is done at service methods, client need not to worry about it. But if any endpoint configuration changes happen in service then appropriate changes has to be done to config file at client because service calls happens only through the endpoint configurations.
IDev 