Click here to Skip to main content
15,112,866 members
Articles / Programming Languages / C#
Posted 6 Jan 2004


11 bookmarked

Really Lazy Properties

Rate me:
Please Sign up or sign in to vote.
2.56/5 (9 votes)
6 Jan 20042 min read
Make the task of defining properties a little less typing intensive. It should provide a convenient location to track changes to entities or whatever you can think of.


Greetings reader, this article sets out to make the task of defining properties a little less typing intensive. It should provide a convenient location to track changes to entities or whatever you can think of.

In short, you'll be able to write properties that look like this:

public DateTime DateCreated{
    get{ return (DateTime)propertyValue; }
    set{ propertyValue = value; }

The above code is a very simple example, it doesn't do much more than save you defining the underlying variable (i.e. DateTime dateCreated = DateTime.MinValue;).

Let's look at what's needed to get this going.

The base class

public abstract class Persistable {
    public Persistable(){
        properties = (PropertyValue[]) 
          GetType().GetCustomAttributes(typeof(PropertyValue), true);

        for (int i = 0; i < properties.Length; i++)
            properties[i].parent = this;

    PropertyValue[] properties;

    //The main point of entry/exit for our entities data
    protected object propertyValue{
            PropertyValue property = PropertyValue;

            if (property == null) 
                throw new Exception("Property not found");                
            PropertyValue property = PropertyValue;                
            return property == null ? null : property.Value;

    //To only be used by the propertyValue property
    //Finds the PropertyValue attribute for the currently executing property
    PropertyValue PropertyValue{
            System.Diagnostics.StackTrace st = 
                 new System.Diagnostics.StackTrace();

            if (st.FrameCount > 0){
                string propertyName = 
                  st.GetFrame(2).GetMethod().Name;//Jump TWO steps back
                propertyName = propertyName.Substring(4);
                return FindProperty(propertyName);

            return null;

    //Scans through the PropertyValue array 
    //till it finds the requested PropertyValue.
    PropertyValue FindProperty(string name){
        for (int i = 0; i < properties.Length; i++){
            if (properties[i].Name.Equals(name)){
                return properties[i];

        return null;

    [AttributeUsage(AttributeTargets.Class, AllowMultiple=true)]
    public class PropertyValue : Attribute{
        public PropertyValue(string name){
   = name;

        protected object value;
        string name;
        internal Persistable parent;

        public string Name{
            get{ return name; }

        public virtual object Value{
            get { return value; }

        internal virtual void SetValue(object value){
            this.value = value;

Using the code

Here's a simple example:

public class ApplicationMessage : Persistable {
    #region ApplicationMessage Properties
    public string ApplicationNumber{
        get{ return (string)propertyValue; }
        set{ propertyValue = value; }

Important: Note that the first argument to the PropertyValue constructor is the same as the name of the property. This is how the relationship is made and these two values must match.

Now in order to make PropertyValue more than just a performance degrader, you need to add some useful functionality. Let's take another look at the implementation of PropertyValue::SetValue(object value).

Suppose we need an audit log of changes made to our "Persistable" entities. First we need to centralize the persistence of our entities.

public virtual Persist(){
    //Custom persistence in override OR
    //I like to pass "this" to the Data Layer
    //ie. id = MyObjPersister.Persist(this);

Next add supporting objects for logging.

StringBuilder changeLog;

long id;//Standardise Persistable ids.

//Depending on how you run things you can
//get away with no having a Set'er on the ID
public long ID{
    get{ return id; }
    set{ id = value; }

//Appends the supplied string to the log
void LogChange(string detail){
    if (changeLog == null){
        changeLog = new StringBuilder();

        if (id == 0)
            changeLog.AppendFormat("{0}: Instance" +
                " of {1} was created.\n",
                DateTime.Now, GetType());
            changeLog.AppendFormat("{0}: Log started" +
              " for instance of {1} with ID : {2}.\n",
              DateTime.Now, GetType(), id);

    changeLog.AppendFormat("{0}: {1}\n", DateTime.Now, detail);

//Returns the body of the changelog
string ChangeLog{
 get{ return changeLog == null ? string.Empty : changeLog.ToString(); }

Now we change the implementation of PropertyValue::SetValue(object value).


internal virtual void SetValue(object value){
    parent.LogChange(string.Format("Property {0} " +
      "was changed from {1} to {2}.", this.value, value));

    this.value = value;

Now we're logging our changes to a StringBuilder. We need to output them somewhere, sometime. To do this, we need to make one final tweak to Persistable::Persist().


public virtual Persist(){
    ...//persist the object


Log.LogAudit could do anything. Personally, I like to send to the Event Log. Here's a simple e.g.:

//The alternative is to create it manually and just let the app add to it.

    public sealed class Log    {
        static readonly string applicationName = 
        static readonly string logSourceName = 

        static Log(){
            if (!EventLog.Exists(applicationName))
                EventLog.CreateEventSource(logSourceName, applicationName);

        public static void LogAudit(string info) {
            string output = string.Format("{0}\n", info);
              output, EventLogEntryType.Information, 1);

So now every time you Persist a Persistable entity, any changes that have been made are conveniently logged to the event log (or elsewhere). Incidentally, I've adapted all/most of this code from an application whilst writing this article, so nothing has been tested :D

Points of Interest

In the future (post Whidbey), it'd be sweet to change PropertyValue to support Generics. That way it would know what data type it was storing. This would make it possible to do more cool stuff like put constraints on the property etc.


This article has no explicit license attached to it but may contain usage terms in the article text or the download files themselves. If in doubt please contact the author via the discussion board below.

A list of licenses authors might use can be found here


About the Author

Web Developer
Australia Australia
No Biography provided

Comments and Discussions

GeneralInteresting Pin
Colin Breame8-May-06 11:38
MemberColin Breame8-May-06 11:38 
GeneralRe: Interesting Pin
worldspawn8-May-06 15:43
Memberworldspawn8-May-06 15:43 
GeneralA bit pointless Pin
Broken God8-Jan-04 7:32
MemberBroken God8-Jan-04 7:32 
Complicating code for lazyness' sake does not seem like a good thing. This is not even considerably faster, IMO, since adding the attribute takes at least as much time as adding a variable.

GeneralRe: A bit pointless Pin
dog_spawn8-Jan-04 8:54
Memberdog_spawn8-Jan-04 8:54 
GeneralRe: A bit pointless Pin
worldspawn8-Jan-04 12:18
Memberworldspawn8-Jan-04 12:18 
QuestionWhat about performance ? Pin
Pedro_Gomes6-Jan-04 22:04
MemberPedro_Gomes6-Jan-04 22:04 
AnswerRe: What about performance ? Pin
worldspawn6-Jan-04 23:50
Memberworldspawn6-Jan-04 23:50 

General General    News News    Suggestion Suggestion    Question Question    Bug Bug    Answer Answer    Joke Joke    Praise Praise    Rant Rant    Admin Admin   

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.