Best architecture practice for multiple clients using one web service

Question

I have a web service and multiple clients that will use it. A MVC 2.0 website, a winforms app, and potentially mobile apps.

I understand that in the case of the mobile apps, each application will need to access and manage the web service connection internally. But what do I do about the .net applications? I am using composite types for the request object and return type. Here's a sample.

My initial thought was to have a wrapper class that would reference the web service and just be a wrapper. Then each project just needs to call my wrapper class and the connection and credentials would just need to be configured in the web config.

This is my abstract request. I have all the shared properties each request will need.

[DataContract]
    public abstract class RequestBase : IRequest
    {
        #region IRequest Members

        [DataMember]
        public string ApiKey { get; set; }

        [DataMember]
        public string ApiPassword { get; set; }

        [DataMember]
        public int PageSize { get; set; }

        [DataMember]
        public int PageIndex { get; set; }

        #endregion

        public RequestBase() : this(String.Empty, String.Empty) { }

        public RequestBase(string apiKey, string apiPassword)
        {
            ApiKey = apiKey;
            ApiPassword = apiPassword;
        }
    }

Then here's class that inherits from my base class.

[DataContract]
    public class CustomerRequest : RequestBase
    {
        [DataMember]
        public int Id { get; set; }
    }

And, here is my Response object. I use Generics because each response is the same, except for the type of resultset.

[Serializable]
public class Response<T>
{
    public IEnumerable<T> Results { get; set; }
    public int TotalResults { get; set; }
    public int PageIndex { get; set; }
    public int PageSize { get; set; }
    public RulesException Exception { get; set; }
}

The problem is that when I created a web reference, it transformed the types accepted/returned by my service into proxy objects.

When I used a Service Reference (as opposed to web reference) it seemed to work better, except then the service reference was exposed, which is less than ideal.

I'm looking for any ideas that will reduce the duplication of code.

Answer 1

Use none! Use WCF to connect to the web service by creating and caching ChannelFactory and then each time create a proxy. WCF is ideal for accessing Web Services. This way you do not need any reference.