Can I use constructor logic with object initializer syntax?

Question

i.e.

MyClass myClass = new MyClass() { Value = 5 };

---

I have a bunch of constructor calls like the one above, but now I've realized I need to add logic to the constructor, which was a massive oversight. Currently I have no constructor, so just a blank implicit default constructor.

The below code should explain my problem.

Edit: I'm not actually doing validation, that's just a simple example of constructor logic

class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine(new Test(1) + " should be true");
        Console.WriteLine(new Test(0) + " should be false");
        Test test = new Test(0) { Value = 1 }; // It allows this syntax, oddly, but the value that's used is the one passed as a parameter
        Console.WriteLine("I wish " + test + " was true");
        // This is what I have currently, but I'd like to add logic like that which exists in the parameterized constructor
        //Test test = new Test() { Value = 1 } // Would ideally function just like Test(1), otherwise I have to go and change every call

        // OUTPUT
        // True should be true
        // False should be false
        // I wish False was true

        Console.ReadLine();
    }
}

class Test
{
    public bool? IsGood { get; }
    public int Value { get; set; }

    // This doesn't currently exist in my class, but I'd like to add it
    public Test(int value)
    {
        if (value == 1)
            IsGood = true;
        else
            IsGood = false;
    }

    public override string ToString()
    {
        return IsGood.ToString();
    }
}

Answer 1

Don't write code like this in the first place.

I'd write your code like this:

class Test 
{
  public static bool IsValid(int value) 
  {
     return whatever; // test for validity here
  }
  public int Value { get; private set; } // Don't let anyone change it.
  public Test(int value) {
    if (!IsValid(value)) throw new InvalidArgumentException("value");
    this.Value = value;
  }
}

There, now Value is always valid; the user can know ahead of time whether it is valid or not; an attempt to set an invalid value produces an exception. This assumes that Value cannot change.

If Value can change then write it like this:

class Test 
{
  public static bool IsValid(int value) 
  {
     return whatever; // test for validity here
  }
  private int value;
  public int Value { get { return value; } 
    set 
    {
      if (!IsValid(value)) throw new InvalidArgumentException("value");
      this.value = value;
    }
  }
  public Test(int value) {
    this.Value = value;
  }
}

Now the value is again always legal.

If it is legal for value to be invalid, then:

class Test 
{
  public bool IsValid 
  {
     get 
     {
       return whatever; // test for validity here
     } // read-only property
  }
  public int Value { get; set; }
  public Test(int value) {
    this.Value = value;
  }
}

Now the value can be any integer and whether it is valid or not can be tested dynamically.

Answer 2

Can I set members outside of a constructor while still using logic in the constructor?

Meaning, what, exactly?

Using the object initializer syntax, a constructor still runs. You may even choose which one to use, through the normal constructor overload syntax (which you seem to show, but you say it's not in your class?). The code in your constructor looks at the parameter value that is passed to it, not the property Value (which it doesn't even set). But if you meant for the two to work together, then sure…you can set the property in the constructor and set IsGood in the Value property setter.

If you're going to do it that way, then I would not bother with the logic in the constructor at all. Just set the Value property and let its setter do the rest of the work:

class Test
{
    public bool? IsGood { get; private set; }

    private int _value;
    public int Value
    {
        get { return _value; }
        set
        {
            _value = value;
            IsGood = _value == 1;
        }
    }

    public Test(int value)
    {
        Value = value;
    }
}

I should point out that the semantics of the above is slightly different from what you seem to have started with. That is, the Value property is not read-only, and so can be set at any time. So, similarly, the IsGood property can change at any time. You previously had declared it as read-only and it was settable only in the constructor.

It's not clear from your question whether that's a problem or not. If you want IsGood to be strictly read-only (i.e. without even a private setter), then it won't be possible to do literally what you're asking for, because in the object initializer syntax, it relies on setting member properties after the constructor has already returned.

For the moment, I'll assume it's not a problem to add the private setter to the IsGood property.

Note that since IsGood apparently depends solely on the value of Value, you could even implement the above like this:

class Test
{
    public bool? IsGood => _value != null ? _value == 1 : (bool?)null;

    private int? _value;
    public int Value
    {
        get { return _value ?? 0; }
        set { _value = value; }
    }

    public Test(int value)
    {
        Value = value;
    }
}

That is, don't even bother storing a value for IsGood. Just return the appropriate value based on the current state of the Value property (null if it's never been set, true if it's currently set to 1, and false otherwise).