Constructor of a proxy - wcf

Question

The solution consists of two projects:
The DemoService project, which is a simple WCF service library that implements the IGetHeaders interface. This interface consists of a single method(GetHeaders) that retrieves some information about the headers in the message sent to the service. For this exercise, it returns the Action header.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Serialization;
using System.ServiceModel;
using System.Text;
using System.ServiceModel.Channels;
namespace DemoService
{
public class HeaderService : IGetHeaders
{
public string GetHeaders()
{
return OperationContext.Current.RequestContext.RequestMessage.Headers.Action;
}
}
}
The TestClient project, which is a console application that enables you to consume the DemoService service. A proxy to the DemoService has already been created.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace TestClient
{
class Program
{
static void Main(string[] args)
{
DemoService.GetHeadersClient proxy = new DemoService.GetHeadersClient("TcpIGetHeaders");
Console.WriteLine("And the header is: " + proxy.GetHeaders());
Console.ReadLine();
}
}
}
In the constructor for the object, pass the name of the binding to use as the sole parameter.
The app.config file:
<?xml version="1.0" encoding="utf-8" ?>
<configuration>
<system.serviceModel>
<bindings>
<wsHttpBinding>
<binding name="WsIGetHeaders" />
</wsHttpBinding>
<netTcpBinding>
<binding name="TcpIGetHeaders" />
</netTcpBinding>
</bindings>
<client>
<endpoint address="http://localhost:8731/Design_Time_Addresses/DemoService/HeaderService/"
binding="wsHttpBinding" bindingConfiguration="WsIGetHeaders"
contract="DemoService.IGetHeaders" name="WsIGetHeaders">
</endpoint>
<endpoint address="net.tcp://localhost:8731/Design_Time_Addresses/DemoService/HeaderService/"
binding="netTcpBinding" bindingConfiguration="TcpIGetHeaders"
contract="DemoService.IGetHeaders" name="TcpIGetHeaders">
</endpoint>
</client>
</system.serviceModel>
</configuration>
My two questions:
In the service code, there is no constructor. Why in the proxy object, we can pass a sole parameter.
Why the parameter is the name must be the name of the endpoint, here it is ="TcpIGetHeaders".

Answer 1

The service does have a constructor - since one is not explicitly defined, a default parameterless constructor is supplied by the compiler. The following line of code will create a new instance of the service, even though there is no explicit constructor defined in it:
HeaderService myService = new HeaderService();
The proxy object is not creating an instance of the service - it's creating an object that can communicate with the service. When you add a service reference, .NET generates the code to create the proxy, as well as the call the methods exposed by the service.
If you look in the reference.cs file, you'll see the auto-generated code for the proxy. This proxy inherits from ClientBase<T> and implements the interface that defines your service.
DemoService.GetHeadersClient proxy = new DemoService.GetHeadersClient("TcpIGetHeaders");
The above code is calling the auto-generated GetHeadersClient class constructor, not your service constructor. The constructor for ClientBase<T> has several overloads - in the case of the code above, it's using the constructor that takes the specified endpoint configuration (determined by the name attribute on the endpoint element in the config file).
If you open the refernce.cs file, you'll probably see code similar to this (using an older example so the version numbers are probably different in your case, and I'm making an educated guess on the namespaces):
[System.Diagnostics.DebuggerStepThroughAttribute()]
[System.CodeDom.Compiler.GeneratedCodeAttribute("System.ServiceModel", "3.0.0.0")]
public partial class HeaderServiceClient : System.ServiceModel.ClientBase<TestService.DemoService.IGetHeaders>, TestService.DemoService.IGetHeaders
{
public HeaderServiceClient()
{
}
public HeaderServiceClient(string endpointConfigurationName) :
base(endpointConfigurationName)
{
}
public HeaderServiceClient(string endpointConfigurationName, string remoteAddress) :
base(endpointConfigurationName, remoteAddress)
{
}
public HeaderServiceClient(string endpointConfigurationName, System.ServiceModel.EndpointAddress remoteAddress) :
base(endpointConfigurationName, remoteAddress)
{
}
public HeaderServiceClient(System.ServiceModel.Channels.Binding binding, System.ServiceModel.EndpointAddress remoteAddress) :
base(binding, remoteAddress)
{
}
public string GetHeadesr()
{
return base.Channel.GetData(value);
}
}
Notice how the constructors that have parameters reference the base constructor from ClientBase<T>.
In summary, you're calling the constructor for the proxy, and you're using the overload that takes a string for the endpoint configuration.
See ClientBase(T Channel) Constructor for more information.