Program structure and 'Command pattern'

Ruan Rothmann

Hi,
This is hard to explain, but it is a simple enough problem...

I have a large dataset (Class 'Dataset') that will be altered by a sequence of events (Abstract class Event, not events in the sense of delegate events). I need to be able to reconstruct the state of this dataset after any amount of events, so I designed an Event abstract class which will be extended for every type of event that can happen. An instance of the specific type is created, applied to the dataset, and stored in a list whenever an event occurs.

Now, it is quite important that the rest of my program does not modify any of the data without constructing an Event, otherwise if I recreate the dataset at that point in time (by re-applying all the events in my list) it will not be consistent with the original.

At the moment my Event has the abstract method Apply(Dataset data), which applies the changes for that event to the given dataset. However, this means I have to keep a most of Dataset's members public, and (besides being bad OO practice) if I or someone else accidentally modify any of them w/o an Event, it's going to be quite hard to debug.

My other option would be to include an overloaded method in Dataset that applies each Event accordingly, but I'm not sure how it will apply. For example, if I have extended Event to EventA, and do:

Event e = new EventA();

Dataset.ApplyEvent (e);

and Dataset has two ApplyEvent methods:

public void ApplyEvent (Event e) {}

public void ApplyEvent (EventA e) {}

Will the overloaded method for EventA be called? Or is there a simpler, elegant solution I'm not thinking of?

Sorry for the long post and thanks for your help :)

2 Replies

Know the answer? Post it — somebody with the same question will find it here.

Alan19y ago
The method which takes an Event argument will in fact be called. This is because the choice of overloaded method needs to be resolved at compile time and the 'compile time type' of the variable 'e' is Event, not EventA.

This can be seen more clearly by running this short program which models the sitation you have in a simple way:

using System;

class DataSet
{
     static void Main()
     {
        DataSet ds = new DataSet();
        Event e = new Event();
        ds.ApplyEvent(e);
        e = new EventA();
        ds.ApplyEvent(e);
        EventA ea = new EventA();
        ds.ApplyEvent(ea);
        Console.ReadLine();
     }

    public void ApplyEvent(Event e)
     {
       // need to be careful here to put derived class first in ladder
       if (e is EventA)
         Console.WriteLine("First overload called, object is an EventA");
       else if (e is Event)
         Console.WriteLine("First overload called, object is an Event");
    }

    public void ApplyEvent(EventA ea)
    {
       Console.WriteLine("Second overload called, object is an EventA");

    }

}

public class Event {}

public class EventA : Event {}

The program also suggests that a possible solution to this problem is to just use one ApplyEvent() method which takes an Event object as an argument. The method can then use the runtime type of the object to determine what action to take.
0
Ruan Rothmann19y ago
I have no idea how to format on these forums. sigh..
Edit: Manually adding breaks helped.
0