/// <summary>
/// A WCF service client.
/// </summary>
/// <typeparam name="TContract">The type of the service contract.</typeparam>
internal class ServiceClient<TContract> : IDisposable
	where TContract : class
{
	/// <summary>
	/// The service client object.
	/// </summary>
	private TContract client;

	/// <summary>
	/// Initializes a new instance of the ServiceClient class.
	/// </summary>
	/// <param name="endpointName">The name of the endpoint to use.</param>
	public ServiceClient(string endpointName)
	{
		ChannelFactory<TContract> f = new ChannelFactory<TContract>(endpointName);
		this.client = f.CreateChannel();
	}

	/// <summary>
	/// Calls an operation on the service.
	/// </summary>
	/// <typeparam name="TResult">The type of the object returned by the service operation.</typeparam>
	/// <param name="operation">The operation to call.</param>
	/// <returns>The results of the service operation.</returns>
	public TResult ServiceOperation<TResult>(Func<TContract, TResult> operation)
	{
		return operation(this.client);
	}

	/// <summary>
	/// Calls an operation on the service.
	/// </summary>
	/// <param name="operation">The operation to call.</param>
	public void ServiceOperation(Action<TContract> operation)
	{
		operation(this.client);
	}

	/// <summary>
	/// Disposes this object.
	/// </summary>
	public void Dispose()
	{
		try
		{
			if (this.client != null)
			{
				IClientChannel channel = this.client as IClientChannel;
				if (channel.State == CommunicationState.Faulted)
				{
					channel.Abort();
				}
				else
				{
					channel.Close();
				}
			}
		}
		finally
		{
			this.client = null;
			GC.SuppressFinalize(this);
		}
	}
}

With this class, you can call an operation SaveEmployee on a service with an IEmployeeService interface like this:

using (var client = new ServiceClient<IEmployeeService>("EmployeeEndpoint"))
{
	var response = client.ServiceOperation<EmployeeResponse>(
		c => c.SaveEmployee(request));
}

Wrapping the call in a using block means the client object is correctly closed and disposed, using the IDisposable interface. And if you’re calling an operation that doesn’t return anything, you can use the overload of ServiceOperation that takes in an Action.

So, the local Person business class will be something like this:

public class Person
{
    public string Forename { get; set; }

    public string Surname { get; set; }

    public int Age { get; set; }
}

We want to call a WCF service called EmployeeService, which has an operation SaveEmployee(). This operation takes a person to save as a parameter. The type of this parameter is Employee, which svcutil has created for us in the service proxy. This may look something like this:

internal partial class Employee :
    object, System.Runtime.Serialization.IExtensibleDataObject
{
    private string FirstNameField;
    private string LastNameField;
    private int AgeField;

    [System.Runtime.Serialization.DataMemeberAttribute()]
    internal string FirstName
    {
        get { return this.FirstNameField; }
        set { this.FirstNameField = value; }
    }

    [System.Runtime.Serialization.DataMemeberAttribute()]
    internal string LastName
    {
        get { return this.LastNameField; }
        set { this.LastNameField = value; }
    }

    [System.Runtime.Serialization.DataMemeberAttribute()]
    internal int Age
    {
        get { return this.AgeField; }
        set { this.AgeField = value; }
    }
}

As the service operation SaveEmployee needs an Employee and we have a Person, we need to translate from the latter to the former. An extension object can do this for us nicely:

internal static class PersonTranslator
{
    public static Employee TranslateToEmployee(this Person person)
    {
        return new Employee()
        {
            FirstName = person.Forename,
            LastName = person.Surname,
            Age = person.Age
        };
    }
}

Now the call to the service operation is nice and clear:

public SaveEmployee(Person person)
{
    var client = new EmployeeServiceClient();
    client.SaveEmployee(person.TranslateToEmployee());
    client.Close();
}

The test certificate’s subject looked like this:

CN = TestCertName

Whereas the environment certificate’s subject looked like:

CN = CertName
OU = Company Ltd.
O = Company
L = Town
S = County
C = Country Code

All the examples I’ve seen just cover certificates with the CN part. This is straightforward to reference in the WCF config:

<serviceCredentials>
   <serviceCertificate
            storeLocation="LocalMachine"
            storeName="My"
            findValue="CN=TestCertName"
            x509FindType="FindBySubjectDistinguishedName" />
</serviceCredentials>

However, when the certificate subject has multiple parts (i.e. more than just CN), you need to put all of them in the findValue attribute. But how to separate them? I tried several characters – space, comma, semicolon, colon – none worked. The certificate could not be found! Finally I noticed that in the top part of the certificate’s properties window, the values are separated by a comma and a space. Unbelievably, this also applies to the config! How intuitive. So for the “CertName” certificate above, here’s how to reference it in the WCF config:

<serviceCredentials>
   <serviceCertificate
            storeLocation="LocalMachine"
            storeName="My"
            findValue="CN=TestCertName, OU=Company Ltd., O=Company, L=Town, S=County, C=Country Code"
            x509FindType="FindBySubjectDistinguishedName" />
</serviceCredentials>