C＃实体框架-通过哈希检测外部更改

Question

I'm programming a WPF C# application with Entity Framework as the data store. The database is open to external changes, ie a user can log in to the database outside my application and edit, say, the name of a specific entity. I'd like to keep this functionality in place, as it allows the user to easily import data from different sources. However, I'd like to inform the user if such a change was made to a specific entity.

To achieve this, I implemented a hashing strategy. On each save, the app will calculate a MD5 hash for the entity. On load, it will verify the entity against this hash to ensure that no external changes were made. I'm implementing the hashing strategy using the following example, which makes use of the BinaryFormatter class: http://www.codeproject.com/Articles/21312/Generating-MD-Hash-out-of-C-Objects

What I'm however experiencing, is that the entity doesn't return the same hash (even with no external changes). Is this due to the "_entitywrapper" property being serialized as well, where "_entitywrapper" is added automatically to each entity by EF when tracking entities?

If this is indeed the case, is there a different serialization methodology that I should be using, or indeed a completely different approach?

Answer 1

Sure, BinaryFormatter is not the best way to go. Neither from performance view nor from usability.

If you want a fast, easy to write, binary serializer, you should use protocol buffer . There are two implementations for C#.

• Protobuf-net
• Protocol buffer csharp port

You can found them on Nuget.

However, if you open to change your approach, why not using a timestamp set to last modified, or a version id ?

• The advantage of the hash approach is that it permits to see any rollback to original values as a "no change" event.
• The timestamp however is much simpler to implement and less expensive in cpu processing (no serialization, no hash)
• The version id is even more efficient in terms of cpu processing, however it holds less information.

Timestamp approach:

• Add a Datetime field in the entity, set to Datetime.UtcNow everytime it is modified. If timestamp of an object is more recent than your last load of it, then it has been modified in the meanwhile. Note: It has nothing to do with the timestamp used in concurrency.

Pros: - Easy to understand and to explain to co-workers.
Cons: - Need to be implemented in each entity. Need a column added in tables. Datetime.UtcNow can be cpu-expensive if called often.

Version id approach:

• Add a, int or a long field in the entity, increase it everytime entity is modified. If version id of an object is greater than your last version id of it, then it has been modified in the meanwhile.

It is not much different from timestamp approach, however it is more cpu-efficient and use less database memory.