Implementing Audit Trail for Objects in C#?

Question

I'm looking for ideas on how to implement audit trails for my objects in C#, for the current project,basically I need to:

1.Store the old values and new values of a given object. 2.Record creation of new objects. 3.Deletion of old object.

Is there any generic way of doing this,like using C# Generics,so that I don't have to write code for events of the base object like on creation,on deletion etc.(ORM objects).The thing is that if there was a way to inject audit trail if one is using a .Anybody have any experiences or any methods they follow.Any way to do this in a Aspect-oriented (AOP) mannner.

Please share your ideas etc.

Solution 1

Question is pretty similar to How do you implement audit trail for your objects (Programming)?

We've implemented a similar solution, using AOP (aspectJ implementation). Using this particular points can be captured and specific operations can be performed.

This can be plugged in and plugged off when we like.

However, our implementation was in J2EE..

If you really want to do it in the app layer, i would suggest this.

Hope it helps..

Solution 2

You could implement something similiar to INotifyPropertyChanged with a slight difference. I've extracted most of INotifyPropertyChanged and changed it to be generic and store new and old values. You can then have some sort of a management class that can listen to this and onSaving and onDeleting you can deal with the changes.

public interface INotifyProperyChanged<T>
{
   event PropertyChangedEventHandler<T> PropertyChanged;
}

    public delegate void PropertyChangedEventHandler<T>(object sender,   
PropertyChangedEventArgs<T> e);

public class PropertyChangedEventArgs<T> : EventArgs
{
    private readonly string propertyName;

    public PropertyChangedEventArgs(string propertyName)
    {
        this.propertyName = propertyName
    }

    public virtual string PropertyName { get { return propertyName; } }

    public T OldValue { get; set; }
    public T NewValue { get; set; }
}

Solution 3

In addition to some of the things mentioned in the above thread the Command Pattern might be of help, if you wrap all the state changes on your object in a command then the command can be responsible for keeping the audit trail, while the object does not have to worry about auditing itself. Of course there is added overhead to creating and disposing commands.

You can wrap commands around any existing object structure, you just delegate your actions to the command layer as opposed to doing them on the objects directly.

Solution 4

Have you considered using a simple notification pattern? You could have your service layer raise events such as NewObject, ChangedObject, DeletedObject that, will be listened to by a generic service layer which can then take the object and save the results.

If you want to save the state of the object you could leverage Xml Serialization.

Another approach is available if your using SQL Server 2008 you can implement the new Auditing features which will let you audit changes to database records you can even track (I think) when the data is read.

View more solutions