Beginner WCF Client/Server Loosely Coupled Design
===

I have a WCF Service that communicates with a single client. My goal is to have a client that is updated as little as possible, and should not need to be updated when I add new properties/methods to my Service.

My first approach, below, breaks my goal since when adding a property/methods to my Service, I need to update the Service Reference of the client.

The structure of the WCF Service DLL looks like the following:

	- IMyService.cs
	- MyService.cs
		- Hardware Interface 1.cs
		- Hardware Interface 2.cs
		- Definitions.cs

Within each hardware interface I have multiple properties and methods that I would like the client to access.

Currently, the way I expose these properties/methods to the client is through the following IMyService methods:

    [ServiceContract]
    interface IMyService 
    {
        [OperationContract]
        void MethodA(Object msg);
        [OperationContract]
        void MethodB(Object msg);
        [OperationContract]
        void MethodC(Object msg);

        [OperationContract]
        Object Hardware1GetProperty(Hardware1Property propID);	//large switch case for all properties
        [OperationContract]
        void Hardware1SetProperty(Hardware1Property propID, Object val);	//large switch case for all properties


        [OperationContract]
        Object Hardware2GetProperty(Hardware2Property propID);	//large switch case for all properties
        [OperationContract]
        void Hardware2SetProperty(Hardware2Property propID, Object val);	//large switch case for all properties
    }

Where Hardware1Property and Hardware2Property are enums stored in Definitions.cs with the following structure:

    public enum Hardware1Property : uint
    {
        PropertyA,
        PropertyB,
        PropertyC,
    }

Since the Client can access the enums Hardware1Property and Hardware2Property, I thought this would be a good approach since the Client would not have to store a list of all properties on the Service. So the client can get the value of a property by doing the following, for example:

	MyVar = MyClient.Proxy.Hardware1GetProperty(Hardware1GetProperty.PropertyA);

How can I improve this design?

 - Are DataContracts the way to go, and if yes how can I implement them?
   (I have never used them before)
 - Should I move to a Name Value Pair model for accessing properties? Such that everything is done through Strings and not enums?
 - Can I use similar approaches for calling methods?