Tips on architecture for consuming/wrapping large webservice

Hello Experts,

I am looking for good practices for implementing a smart architecture and way to handle integration against a system with many different wdsl webservices.

I have been hobby developing with C# for 2 years~, by that I am not always using the correct terminology, but I'll try to describe what I am looking for.

The main reason I'm posting this, is to get ideas of areas that I should read up on, design patterns to implement and how to manage API calls in a good way.

I'm integrating against a system that offers lots of different API's. Each API have 20-30 methods. Each API takes a number of parameters in XML format.

To give you an idea, I have taken the following API as an example, its the DeviceManager API and the Create method to create a device in the system.
The API takes two parameters, a string key and a XML parameter string.

Example

DeviceManager

public string Create(string sKey, string sXmlParameters)  

Parameters:

Name: sKey Type: string  
Description:
The API security key. A valid API security key is required for every API call.  

Name: sXmlParameters Type: string  
Description: Values needed to create a new device. See the Additional Information      section for XML format.  

Return Value: Type: string  
 Description: Returns XML containing the status of the creation and if the status is  
 Constants.ExternalServiceReturnCodes.SUCCEEDED, the ID of the new device.

XMLParameters:

<PARAMETERS>      
                          <NAME>  
                                   string - up to 64 characters. Non-blank name of the device. Must be  
                                   unique within a gateway.  
                          </NAME>  
                          <DESCRIPTION>  
                                   string - up to 1024 characters. The description of the new device.  
                          </DESCRIPTION> (optional)  
                          <TYPEID>  
                                   string of DeviceType. The type of device.
                          </TYPEID>  
                            <GATEWAYID>  
                                     string - 32-character GUID. The ID of the gateway to associate  
                                     with the device. If this node is included, it must contain an ID of  
                                     a gateway that exists in the solution.  
                            </GATEWAYID> (optional)  
                            <INSTALLATIONDATETIME>  
                                     date time in UTC - greater than or equal to  
                                     1753-01-01 00:00:00.000 and less than or equal to  
                                     9999- 12-31 23:59:59.998. The date time that the device was  
                                     installed.  
                            </INSTALLATIONDATETIME> (optional - if not included, the installation  
                            date time is set to the date time in UTC when the device is created in
                            the solution)      
                            <SERIALNUMBER>  
                                     string - up to 64 characters. The serial number of the device.  
                            </SERIALNUMBER>
                            <TIMEZONEID>  
                                     string - time zone ID. The time zone ID of the device. Call  
                                     the TimeZoneManager.RetrieveList API to get a list of  
                                     valid time zone IDs  
                            </TIMEZONEID> (required for device type 'meter')  
                            <HARDWAREVERSION>  
                                     string - up to 32 characters. The hardware version of the device.  
                            </HARDWAREVERSION> (optional)  
                            <GEOGRAPHICCOORDINATES>  
                                     <LATITUDE>  
                                               decimal - greater than or equal to -90 and less than or  
                                               equal to 90. The latitude geographical coordinate of the  
                                               device in decimal degrees. The value must be from the  
                                              WGS84 spatial reference system.  
                                               If more than 6 digits after the decimal point are included,  
                                               the value will be rounded to 6 digits.  
                                     </LATITUDE>  
                                     <LONGITUDE>  
                                               decimal - greater than or equal to -180 and less than or  
                                               equal to 180. The longitude geographical coordinate of the  
                                               device in decimal degrees. The value must be from the  
                                              WGS84 spatial reference system.
                                               If more than 6 digits after the decimal point are included,  
                                              the value will be rounded to 6 digits.  
                                     </LONGITUDE>  
                            </GEOGRAPHICCOORDINATES> (optional)
                            <METER>  
                                     <ID>  
                                               string - 12 hexadecimal characters.
                                     </ID>
                                     <TRANSFORMERID>  
                                              string - up to 128 characters.
                                     </TRANSFORMERID>  
                                     <DOWNLIMIT>  
                                                  integer - greater than or equal to 0 and less than or  
                                                  equal to 65535.
                                        </DOWNLIMIT> (optional)
                              </METER> (required for device type of 'meter')  
                    </PARAMETERS>

Return API payload format:

<DEVICEID>string - 32-character GUID. The ID of the new device.</DEVICEID>

The API's always return the data in the following format:

<RETURNS>
        <STATUS>
                 String from Constants.ExternalServiceReturnCodes class.
        </STATUS>
        <APIPAYLOAD>
                 Additional information from the API call. Node may be empty. For
                 APIs that return information, that information will be shown in
                 the Return section.
        </APIPAYLOAD>
</RETURNS>

So in the example above, the payload would look something like:

<RETURNS>
        <STATUS>
                 SUCCEEDED
        </STATUS>
        <APIPAYLOAD>
                <DEVICEID>string - 32-character GUID. The ID of the new device.</DEVICEID>
        </APIPAYLOAD>
</RETURNS>

As for now, I have been working on designing classes for all XMLparameters to be able to serialize and deserialize the parameters and payloads from the APIs, but it is a very time consuming job to define these. Example given below for the create API parameters and payload. (simple example using get set)

DeviceManager Create Parameters

 [XmlRoot(ElementName = "PARAMETERS")]
    public class Create
    {

        [XmlElement(ElementName = "NAME")]
        public string Name { get; set; }

        [XmlElement(ElementName = "DESCRIPTION")]
        public string Description { get; set; }

        [XmlElement(ElementName = "TYPEID")]
        public string TypeId { get; set; }

        [XmlElement(ElementName = "GATEWAYID")]
        public string GatewayId { get; set; }

        [XmlElement(ElementName = "INSTALLATIONDATETIME")]
        public string InstallationDateTime { get; set; }

        [XmlElement(ElementName = "SERIALNUMBER")]
        public string SerialNumber { get; set; }

        [XmlElement(ElementName = "TIMEZONEID")]
        public string TimeZoneId { get; set; }

        [XmlElement(ElementName = "HARDWAREVERSION")]
        public string HardWareVersion { get; set; }

        [XmlElement(ElementName = "GEOGRAPHICCOORDINATES")]
        public CreateParametersGeoGraphicCoordinates GeographicCoordinates { get; set; }

        [XmlElement(ElementName = "METER")]
        public CreateMeter Meter { get; set; }
    }

    public class CreateMeter
    {
        [XmlElement(ElementName = "NEURONID")]
        public string NeuronId { get; set; }

        [XmlElement(ElementName = "TRANSFORMERID")]
        public string TransformerId { get; set; }

        [XmlElement(ElementName = "UTILITYID")]
        public string UtilityId { get; set; }

        [XmlElement(ElementName = "LONTALKKEY")]
        public string LonTalkKey { get; set; }

        [XmlElement(ElementName = "DOWNLIMIT")]
        public string DownLimit { get; set; }
    }

    public class CreateParametersGeoGraphicCoordinates
    {
        [XmlElement(ElementName = "LATITUDE")]
        public string Latitude { get; set; }

        [XmlElement(ElementName = "LONGITUDE")]
        public string Longitude { get; set; }
    }

Select allOpen in new window

And for PayLoads I have the following generic class and DeviceManager.Create Payload specific class:

Create PayLoad

    public class CreatePayLoad
    {
        [XmlElement(ElementName = "DEVICEID")]
        public string DeviceId { get; set; }
    }

Select allOpen in new window

PayLoad

    [XmlRoot(ElementName = "RETURNS")]
    public class PayLoad<T> where T : new()
    {
        public PayLoad()
        {
            ApiPayLoad = new T();
        }

        /// <summary>
        /// Contains the payload from the command.
        /// </summary>
        [XmlElement(ElementName = "APIPAYLOAD")]
        public T ApiPayLoad { get; set; }

        /// <summary>
        /// Status of the call
        /// </summary>
        [XmlElement(ElementName = "STATUS")]
        public string Status { get; set; }
    }

Select allOpen in new window

So in my code i can do the call in the following way:

Example use

//Create the parameters
var parameters = new Create
					 {
						 Description = "Description",
						 GatewayId = "GatewayId",
						 Name = "NameOfDevice",
						 GeographicCoordinates = new CreateParametersGeoGraphicCoordinates
													 {
														 Latitude = "Lat",
														 Longitude = "Long"
													 },
						 Meter = new CreateMeter
									 {
										 TransformerId = "ID",
										 DownLimit = "120"
									 }
					 };

//Serialize the parameters to xml
string sXmlParameters = Helper.SerializeToXml<Create>(parameters);

//API call
string apiPayLoad = DeviceManager.Create(apiKey, sXmlParameters);

//Deserialize payload
var payLoad = Helper.DeserializeFromXml<PayLoad<CreatePayLoad>>(apiPayLoad);

}

Select allOpen in new window

Can someone please contribute with ideas and better ways to manage this?
Please bear in mind that there are about 300 methods in the system, some with very complicated xml parameters where some properties are optional, some mandatory if property A, B or C are used and so on.

I have been looking at XSD.exe, but the generated code is not neat to the eye and it doesn't handle collections very well.

A friend also proposed T4 templates, where one could generate classes based on templates, but I'm not really finding any good examples out there.

I'm not sure if I have explained myself in a good way, If I'm being unclear - please let me know and I will try to elaborate.

Thank you,
amr-it