Only update some properties on an EF entity that are not set to null

Question

I've got a browser sending up JSON but it only includes the properties of a given model that have been changed. So once the WCF DataContractJsonSerializer does it's work I have an object that will have perhaps only the ID and Description fields populated.

Attaching this to the DbContext as is will result in the description field being updated but all the other fields being set to their types default value in the database. This is because if WCF doesn't see the property specified in the JSON then it'll skip over it, meaning the property in the instance will just use the types default value as per the auto-implemented property.

So this means that I need to decide on which fields have been passed up without having access to the JSON itself. In fact it could be XML on the wire so all I can work from is this partly serialized object.

What seems most logical is to use null as the special value that means this property hasn't been serializd over. So in the constructor of the POCO model I set all the properties to null.

In the Update method I then use this serialized object as a stub. I have to walk each property and if the value isn't set to null then I set it's state to modified. As far as I can tell this is working without any side effects but I'm just not sure that this is the way to do something like this.

One limitation it does add is that the client can no longer intentionally set a property to null as that update would be lost. One way around this is to have a special int value that can be set to represent null in the database and perhaps an empty string to represent null in the database and have code in the update to look for these special values and then set the entity property to null. Far from ideal and likely to be prone to bugs.

Here is the code I currently have to process the update. I would really really appreciate advice as to a better, perhaps more obvious way of doing this.

To Summerise: How can I tell which properties on an model instance have been set by the DataContractSerializer/DataContractJsonSerializer and which are just using default values from it's constructor. Using special values is problematic as the client might want to set something to an empty string, or to 0 or -1 or indeed to null.

public T Update(T obj)
{
    var entity = ds.Attach(obj);

    // For each property in the model
    foreach (var p in typeof(T).GetProperties())
    {
        // Get the value of the property
        var v = p.GetValue(obj, null);

        // Assume null means that the property wasn't passed from the client
        if (v == null)
            continue;

        // Set this property on the entity to modified unless it's ID which won't change
        if (p.Name != "ID")
            dc.Entry(entity).Property(p.Name).IsModified = true;
    }

    dc.SaveChanges();
    return entity;
}

UPDATE: Using Hammerstein's answer below to have self tracked models, I've updated my update function as below. Unfortunately due to my use of the Required attribute on the models for pre-save validation EF throws a wobbly when using a stub instance that contains nulls for the non modified values. You would think that EF would realise as part of it's validation that some fields are set to not modified but alas it doesn't so I'm forced to do a read and then update that. Actually this might be a good candidate for a separate question to post to try and avoid the read.

public virtual T Update(T obj)
{
    var entity = ds.Find(obj.ID);

    ((TrackedModel)obj).Modified.ForEach(p => { 
        var prop = dc.Entry(entity).Property(p.PropertyName);
        prop.CurrentValue = p.NewValue;
        prop.IsModified = true;
    });

    dc.SaveChanges();
    return entity;
}

Answer 1

My solution to this problem was a tracked change model, I created an abstract base class that had a list of strings, then for each property on my model, I called a method NotifyChanged( "MyProperty") which added the property to the list.

Because model binding will only set the fields that have been posted back, you should get an accurate list of fields that changed.

Then I loop through the list, and set the values on my entity.

Not clean, but it worked for my purpose.

Update: My solution did require me to get away from auto-properties and to hand write them. In the setter, after setting the value, I call NotifyChanged. I'm using this with MVC regular model binding, I don't think I have a working example of passing an object as JSON and deserializing. You could look at JSON.NET, controlling the serialization/deserialization I believe you can tell it to ignore default property values etc.