Is there an event for when all properties of an object have been set?

Question

Imagine a simple POCO

public class Test{
    public int ID {get; set;}
    public string Name {get; set;}
    public string SomeProperty {get; set;}
}

Is there a way to wire this object up such that an event will fire only when all properties have been set? Like an InitializeComplete event or something? Or alternately is there a way to easily create such an event custom?

thanks

Answer 1

You could implement this by yourself like so:

public delegate void AllPropertiesSetDelegate();
public class Test
{
    public delegate void AllPropertiesSetDelegate(object sender, EventArgs args);

    public int Id
    {
        get => _id;
        set
        {
            _id = value;
            CheckAllProperties();
        }
    }
    private int _id;
    public string Name
    {
        get => _name;
        set
        {
            _name = value;
            CheckAllProperties();
        }
    }
    private string _name;

    private void CheckAllProperties()
    {
        //Comparing Id to null is pointless here because it is not nullable.
        if (Name != null && Id != null)
        {
            AllPropertiesSet?.Invoke(this, new EventArgs());
        }
    }
}

class Program
{
    static void Main(string[] args)
    {
        Test t = new Test();
        t.AllPropertiesSet += delegate { AllPropsSet(); };
        t.Id = 1;
        t.Name = "asd";
        Console.ReadKey();
    }

    static void AllPropsSet()
    {
        Console.WriteLine("All properties have been set.");
    }
}

See for yourself if you can get the implementation smaller/less painfull to deal with.

Test code:

class Program
{
    static void Main(string[] args)
    {
        Test t = new Test();
        t.AllPropertiesSet += delegate { AllPropsSet(); };
        t.Id = 1;
        t.Name = "asd";
        Console.ReadKey();
    }

    static void AllPropsSet()
    {
        Console.WriteLine("All properties have been set.");
    }
}

Heres how you could use reflection to check all non-value types for null:

    public static bool AllPropertiesNotNull<T>(this T obj) where T : class
    {
        foreach (var prop in obj.GetType().GetProperties())
        {
            //See if our property is not a value type (value types can't be null)
            if (!prop.PropertyType.IsValueType)
            {
                if (prop.GetValue(obj, null) == null)
                {
                    return false;
                }
            }
        }
        return true;
    }

You can consume this in the original code by modifying the CheckAllProperties method:

    private void CheckAllProperties()
    {
        if (this.AllPropertiesNotNull())
        {
            AllPropertiesSet?.Invoke(this, new EventArgs());
        }
    }

Answer 2

If you want to ensure that an object is properly created, why not make it so the only way to create it is to also set all the properties.

public class Test{
    public int ID {get; set;}
    public string Name {get; set;}
    public string SomeProperty {get; set;}

    // Constructor
    public Test(int id, string Name, string someProperty)
    {
        this.ID = id;
        this.Name = name;
        this.SomeProperty = someProperty;
    }
}

Answer 3

Here's a variation on @fstam's answer. It changes this to a full on event and makes the call to check the properties cleaner. If you upvote me, upvote @fstam.

First the class:

public class TestPropertyCheck
{
    public event EventHandler AllPropertiesSet;

    public int Id
    {
        get => _id;
        set
        {
            _id = value;
            CheckAllProperties(PropertyNames.Id);
        }
    }
    private int _id;
    public string Name
    {
        get => _name;
        set
        {
            _name = value;
            CheckAllProperties(PropertyNames.Name);
        }
    }
    private string _name;

    public string Address
    {
        get => _address;
        set
        {
            _address = value;
            CheckAllProperties(PropertyNames.Address);
        }
    }
    private string _address;

    private void CheckAllProperties(PropertyNames propName)
    {
        propertiesSet |= propName;
        if (propertiesSet == PropertyNames.AllProps)
        {
            AllPropertiesSet?.Invoke(this, new EventArgs());
        }

    }

    private PropertyNames propertiesSet = PropertyNames.None;

    [Flags]
    private enum PropertyNames
    {
        None = 0,
        Id = 0x01,
        Name = 0x02,
        Address = 0x04,
        AllProps = Id | Name | Address,
    }
}

Then a test program

public static class PropertyCheckTester
{
    public static void Test()
    {
        var test = new TestPropertyCheck();
        test.AllPropertiesSet += AllPropertiesSet;
        Debug.WriteLine("Setting Name");
        test.Name = "My Name";
        Debug.WriteLine("Setting ID");
        test.Id = 42;
        Debug.WriteLine("Setting Address");
        test.Address = "Your address goes here";

    }

    public static void AllPropertiesSet(object sender, EventArgs args)
    {
        Debug.WriteLine("All Properties Set");
    }
}

And the output:

Setting Name
Setting ID
Setting Address
All Properties Set

Answer 4

Such event is fairly easy to implement for normal classes with full properties (code below is from answer of @fstam and partially from head, tell me if something is wrong, or threat it as pseudo-code):

public class Test
{
    public EventHandler InitializeCompleted;

    int _id;
    public int Id
    {
        get => _id;
        set
        {
            _id = value;
            CheckAllProperties();
        }
    }

    string _name;
    public string Name
    {
        get => _name;
        set
        {
            _name = value;
            CheckAllProperties();
        }
    }

    HashSet<string> _initialized = new HashSet<string();

    void CheckAllProperties([CallerMemberName] string property = null)
    {
        if(_initialized == null) // ignore calls after initialization is done
            return;
        _initialized.Add(property);
        if(_initialized.Count == 2) // all properties setters were called
        {
            _initialized = null;
            InitializeCompleted?.Invoke(this, EventArgs.Empty);
        }
    }
}

Using reflection can make the task even simpler: you can get property counter (no need to maintain that number in CheckAllProperties), mark properties which has to be included/excluded. If you decide to do so, don't forget to use lazy pattern, to only do it once for type, not for each instance.