WCF service design

This is a tough question to answer definitively, because this space is still relatively young. When it all settles down, then we will know what the answer should have been. :)

Since the kinds of objects and their specific properties are potentially unbounded (depends on what comes to market), I would be tempted to treat each node as essentially a data bucket. The far extreme of this would be something like:

public void SetNodeProperty(string name, string value)

public void SetNodeProperties(Dictionary<string, string> properties)

This really only works if you have no nested object properties (instead of node.Temperature.Minimum, you would need to do node.MinTemperature) and your property values are convertible from strings.

If you have some core data like Name, Room, etc. You can base your object around that, and use tricks to communicate the extra properties back to the server. JsonExtensionData is one way of doing that where any extra properties which are not direct properties on the class are put into a Dictionary<string, object> upon deserialization so you can access them.

public class Node
{
    public string Name {get;set;}
    ...
    [JsonExtensionData]
    public Dictionary<string, object> ExtraData {get;set;}
}

// API
public void UpdateNode(Node node)

Another way would be to take advantage of polymorphism in your API (here is the WCF version) so that anything which implements INode will be deserialized to the proper concrete type on the server (provided the client can give you a type hint when they send the JSON data).

// something like this required for WCF polymorphic parameters
[ServiceKnownType("GetKnownTypesOfINode", typeof(MyHelperClass))]
public void UpdateNode(INode node)
// node could deserialize as ThermostatNode, LightSourceNode, etc.
//   but will be cast as INode
// client has to send $type property for JSON.NET to deserialize properly
//   the value for $type usually takes the form:
//   'My.Namespace.SubNamespace.Class, My.Assembly'

Thirdly, you could deal with the JSON in a purely dynamic way. JSON.NET allows you to deserialize to a dynamic or ExpandoObject to interrogate the posted JSON body. This supports nested properties unlike the string dictionary. I'm pretty sure WCF does not support this since a central theme is providing an interface as a data contract. However, even in Web API, I would likely read the request body manually to avoid having to make a custom model binder or filter or whatever.