Section 2.1. Operation Overloading

2.1. Operation Overloading

Programming languages such as C++ and C# support method overloading: defining two methods with the same name but with different parameters. For example, this is a valid C# interface definition:

 interface ICalculator {    int Add(int arg1,int arg2);    double Add(double arg1,double arg2); } 

However, operation overloading is invalid in the world of WSDL-based operations. Consequently, while the following contract definition compiles, it will throw an InvalidOperationException at the service host load time:

 //Invalid contract definition: [ServiceContract] interface ICalculator {    [OperationContract]    int Add(int arg1,int arg2);    [OperationContract]    double Add(double arg1,double arg2); } 

However, you can manually enable operation overloading. The trick is using the Name property of the OperationContract attribute to alias the operation:

 [AttributeUsage(AttributeTargets.Method)] public sealed class OperationContractAttribute : Attribute {    public string Name    {get;set;}    //More members } 

You need to alias the operation both on the service and on the client side. On the service side, provide a unique name for the overloaded operations, as shown in Example 2-1.

Example 2-1. Service-side operation overloading

 [ServiceContract] interface ICalculator {    [OperationContract(Name = "AddInt")]    int Add(int arg1,int arg2);    [OperationContract(Name = "AddDouble")]    double Add(double arg1,double arg2); } 

When the client imports the contract and generates the proxy, the imported operations will have the aliased names:

 [ServiceContract] public interface ICalculator {    [OperationContract]    int AddInt(int arg1,int arg2);    [OperationContract]    double AddDouble(double arg1,double arg2); } public partial class CalculatorClient : ClientBase<ICalculator>,ICalculator {    public int AddInt(int arg1,int arg2)    {       return Channel.AddInt(arg1,arg2);    }    public double AddDouble(double arg1,double arg2)    {       return Channel.AddDouble(arg1,arg2);    }    //Rest of the proxy } 

The client can use the generated proxy and contract as is, but you can also rework those to provide overloading on the client side. Rename the methods on the imported contract and the proxy to the overloaded name, and make sure the proxy class makes calls on the internal proxy using the overloaded methods, such as:

 public int Add(int arg1,int arg2) {    return Channel.Add(arg1,arg2); } 

Finally, use the Name property on the imported contract on the client side to alias and overload the methods, matching the imported operation names, as shown in Example 2-2.

Example 2-2. Client-side operation overloading

 [ServiceContract] public interface ICalculator {    [OperationContract(Name = "AddInt")]    int Add(int arg1,int arg2);    [OperationContract(Name = "AddDouble")]    double Add(double arg1,double arg2); } public partial class CalculatorClient : ClientBase<ICalculator>,ICalculator {    public int Add(int arg1,int arg2)    {       return Channel.Add(arg1,arg2);    }    public double Add(double arg,double arg2)    {       return Channel.Add(arg1,arg2);    }    //Rest of the proxy } 

Now the client can benefit from the readable and smooth programming model offered by overloaded operations:

 CalculatorClient proxy = new CalculatorClient( ); int result1 = proxy.Add(1,2); double result2 = proxy.Add(1.0,2.0); proxy.Close( );