Better Alternative For Storing Multiple Booleans?

Question

I have a class, which stores an enum to track if my object is modified, newly created, or no change. If the object is modified, I have additional booleans for each field that is modified.

For instance,

public enum status
{
    NoChange,
    Created,
    Modified
}

private bool? name;
private bool? address;
...
private bool? numberOfDonkeysPurchased;

So the idea is that if the status is modified, then the nullable bools will be either true or false, depending on if these fields are changed.

If the status is not modified, then the nullable bools will be null.

The problem with this is that I have a couple of these fields that I want to check (say 10). Is it valid to create a nullable bool for each field that I am checking, knowing that I maybe be storing a lot of nulls? Or is that not a concern?

Is there a better way to store this?

Thanks!

Answer 1

Alternatively, you could use a bitmask via a Flags enum:

[Flags]
public enum Changes
{
   None                     = 0x000,
   Name                     = 0x001,
   Address                  = 0x002,
   ...
   NumberOfDonkeysPurchased = 0x100,
   ...
}

Then, you merely update the appropriate flags as you call setters:

public string Name
{
   get { return name; }
   set
   {
      name = value;
      changes |= Changes.Name;
   }
}

Checking for changes is just a matter of comparing changes with Change.None.

Note: this will be preferable to a collections object if you are transmitting your data between a client and a server, since the bitmask will be stored as a single int or long.

Answer 2

I would suggest that you use a Dictionary, with the property as the key and the bool as the value. e.g.

Dictionary<string, bool?> myProperties = new Dictionary<string, bool?>();

Use reflection to get all the properties from your object. Then you dont have any work when properties gets added/removed.

You can initialise your dictionary with reflection like this:

foreach (PropertyInfo propertyInfo in myObject.GetType().GetProperties()) {
    myProperties.Add(propertyInfo.Name, false);
}

Or you can even only add those that are not null.

Answer 3

You could use INotifyPropertyChanged which would also mean that your object can be databound easily. Something like this may be suitable:

public abstract class ChangeTrackingObject : INotifyPropertyChanged
{
    private readonly HashSet<string> changedProperties = new HashSet<string>();

    protected ChangeTrackingObject()
    {
    }

    public event PropertyChangedEventHandler PropertyChanged;

    public IEnumerable<string> ChangedProperties
    {
        get
        {
            return this.changedProperties;
        }
    }

    public bool PropertyWasChanged(string member)
    {
        return this.changedProperties.Contains(member);
    }

    protected virtual void OnPropertyChanged([CallerMemberName] string member = "")
    {
        this.changedProperties.Add(member);

        var propertyChanged = this.PropertyChanged;
        if (propertyChanged != null)
        {
            propertyChanged(this, new PropertyChangedEventArgs(member));
        }
    }
}

The [CallerMemberName] is new in C#5 which does some compile time magic to put the correct string in place. Using a HashSet<string> instead of List<string> ensures that we get unique values only and no duplicates without having to call List<T>.Contains()

public class Thing : ChangeTrackingObject
{
    private string address;
    private string name;
    private int numberOfDonkeysPurchased;

    public string Address
    {
        get
        {
            return address;
        }
        set
        {
            address = value;
            this.OnPropertyChanged();
        }
    }

    public string Name
    {
        get
        {
            return name;
        }
        set
        {
            name = value;
            this.OnPropertyChanged();
        }
    }

    public int NumberOfDonkeysPurchased
    {
        get
        {
            return numberOfDonkeysPurchased;
        }
        set
        {
            numberOfDonkeysPurchased = value;
            this.OnPropertyChanged();
        }
    }
}

Example usage:

var thing = new Thing();

System.Console.WriteLine("NumberOfDonkeysPurchased Changed? " + thing.PropertyWasChanged("NumberOfDonkeysPurchased"));
thing.NumberOfDonkeysPurchased = 5;
System.Console.WriteLine("NumberOfDonkeysPurchased Changed? " + thing.PropertyWasChanged("NumberOfDonkeysPurchased"));

System.Console.WriteLine("Changed Properties");
thing.ChangedProperties.ToList().ForEach(System.Console.WriteLine);