Visual Studio Add Service Reference

If you’re using Add Service Reference, you’re doing it wrong.

Visual Studio makes invoking web services very easy by allowing you to add a service reference to the target service…but should you?

Service References are Evil

Well mostly evil. Let me explain.

When you add a service reference, Visual Studio is doing some things for you. First, it hits the WSDL of the target service and generates a copy of the service contract(s), data contract(s), and from this information generates service clients (one per service contract) for you to use. These service client objects, or proxies, can then be used to invoke the target service. While this method certainly works, it comes with several problems.

Code Duplication

As I mentioned above, Visual Studio generates a copy of the service and data contracts of the services you add references to. For most projects, this means maintaining multiple copies of the service and data contracts. Code duplication, in any form, should be avoided when possible.

Unneeded Files

If you show all files in the project that contains the service reference, you’ll see that Visual Studio attempts to maintain multiple files that you do not need. The image above is only for one service, with one service contract, and one operation! This becomes very painful on a large team where the duplicated code and unneeded files are being regenerated often, and checked in and out often as the reference changes.

Namespace Control

When you add a service reference, you can specify the namespace to put the generated service contracts, data contracts and service clients in. But this namespace cannot be reused, which can be problematic. One example of this pain point is a data contract that came from a service call via Service Client A and now needs to be passed to Service Client B, which is in a different namespace. No fun.

Bloated Configuration

Adding a service reference creates a bloated client config entry by specifying a value for every attribute in the binding and endpoint elements. Yuck.

Alternatives

There are several good alternatives to adding service references that aren’t that difficult to implement, a couple of which I will demonstrate here. For these examples we will be using the following service contract.

Service Contract

[ServiceContract]
public interface ISampleService
{
  [OperationContract]
  void DoSomething();
}

ChannelFactory

The first alternative (and my personal choice) is to use a ChannelFactory. A ChannelFactory is a factory that creates channels of different types that are used by clients to send messages to service endpoints. Here is an example.

Client Implementation

ChannelFactory channelFactory = new ChannelFactory("yourEndpointConfigName");
ISampleService channel = channelFactory.CreateChannel();

channel.DoSomething();

((ICommunicationObject)channel).Close();

For more information on using the ChannelFactory, take a look at this .NET FAQ.

ClientBase Implementation

The second alternative is to create your own ClientBase implementation. The ClientBase class provides the base implementation used to create client objects that can call services. This is what Visual studio does for you when you add a service reference.

Proxy Implementation

public class SampleServiceClient : ClientBase<ISampleService>, ISampleService
{
  public void DoSomething()
  {
    Channel.DoSomething();
  }
}

Using the Proxy

Once you have created this class, you can start using to to invoke services, the same way you would have if Visual Studio generated for you, but without the mess.

var client = new SampleServiceClient();
client.DoSomething();

This method works well, but comes at the price of having to create proxy classes for each service contract.

More Information

For more information on service references and the problems that they can cause, check out this dnrTV episode with Miguel Castro.

Conclusion

There are many better options available for invoking an operation on a service than adding a service reference. Having said that, there are times when it makes sense. Some examples would be if you’re new to WCF and want to see how it works or for a quick proof of concept. But really, how much time do you save over doing it the right way?