use default property value in C# constructor initializer

Question

Consider the following class:

class Foo
{
    public string Bar { get; set; } = "foobar";
}

And this piece of code:

var foo = new Foo {
    Bar = bar == null
            ? null
            : bar
};

Obviously, the value of Bar would be null after the execution of this code (suppose that bar = null).

I want the constructor initializer to use default property value in given cases (e.g. when bar is null). I want to know if there is an easier way to do this instead of using:

if (bar == null) {
    foo = new Foo();
} else {
    foo = new Foo { Bar = bar };
}

Or

foo = new Foo();
if (bar != null)
    foo.Bar = bar;

Just don't assign the value then? `if (bar != null) { ... }` — Lasse V. Karlsen, Sep 07 '16 at 07:42
@LasseV.Karlsen the conditional statement would be complex when the number of parameters increase. — AllOutOfSalt, Sep 07 '16 at 07:44
Possible duplicate of [Object Initializer and Dynamically specifying properties](http://stackoverflow.com/questions/2234091/object-initializer-and-dynamically-specifying-properties) — slawekwin, Sep 07 '16 at 07:50
I don't think you got Lasse's point. Don't use the object initializer if it doesn't fit your needs - there's no benefit you get from that. Just do `var foo = new Foo(); if (bar != null) foo.Bar = bar;`. — Luaan, Sep 07 '16 at 07:53
What is the actual question? Because the constructor *did* initialize the property. The question's code overwrote the default value. If you want to restrict the kinds of values stored in a procedure, add proper validation - ie a conditional — Panagiotis Kanavos, Sep 07 '16 at 07:55
The answers will do the trick. Actually I was looking for something like "ignore me" in initialization. — AllOutOfSalt, Sep 07 '16 at 08:29

Fabjan · Accepted Answer · 2016-09-07T12:52:52.670

Well, you can simplify it by using null coalescing operator:

  var foo = new Foo();
  foo.Bar = bar ?? foo.Bar;

Or you can change property to check for null values and ignore them :

    private string _bar = "foobar";
    public string Bar
    {
        get { return _bar; }
        set { _bar = value ?? _bar;  }
    }

Then you can use this code to instantiate Foo :

   var foo = new Foo() { Bar = bar };

Note that now if bar is null its value will be ignored in property's setter.

slawekwin · Answer 2 · 2016-09-07T08:07:24.710

1

Easiest and most readable (IMHO) solution would be:

var foo = new Foo();
if (bar != null)
    foo.Bar = bar;

There is no way to make the validation like you suggested in the initializer (at least not as of C# 6). You could use some constructs with extracting your default to constant like other answers here suggest, but this takes away from readability and does not make using the class easier - you have to know about implementation (default value in the constant) details, which breaks the encapsulation.

If your main concern is about code style, I suggest you get used to ifs, because there is nothing wrong with them and are easy to understand for someone else maintaining your code or yourself in a few months.

If there is something else you need, like validation of the property value, you need to place it in the setter itself (and you should have stated so in the question).

edited Sep 07 '16 at 08:07

answered Sep 07 '16 at 07:43

slawekwin

6,270
1
44
57

Yes that's correct but I wanted to know if there is such feature to avoid conditional statements – AllOutOfSalt Sep 07 '16 at 07:45
@danrah There is not (yet?). Unless you can change auto property to make the `if` there? – slawekwin Sep 07 '16 at 07:51
You can replace a null with a default value using `??`. Although the code shown in the question has nothing to do with constructors - the constructor *already* initialized the property. Then the code cleared it. If a property shouldn't have a null value, just validate the values in the setter – Panagiotis Kanavos Sep 07 '16 at 07:54

score 1 · Answer 3 · answered Sep 07 '16 at 09:30

The cleanest OO way of doing that would be by using overloaded constructor and a factory method:

    class Foo
    {
        public Foo Create(string bar)
        {
            return bar == null ? new Foo() : new Foo(bar);
        }

        public Foo() : this("foobar")
        {
        }

        public Foo(string bar)
        {
            Bar = bar;
        }
        public string Bar { get; }
    }

webnoob · Answer 4 · 2016-09-07T07:56:20.580

0

You could do:

class Foo
{
    public const string BarDefault = "foobar";
    public string Bar { get; set; } = BarDefault;
}

var foo = new Foo { Bar = bar ?? Foo.BarDefault };

It has an advantage of having all your defaults in consts at the top of the class but I don't really see the point personally. It does however mean you don't need a conditional statement (kind of).

edited Sep 07 '16 at 07:56

answered Sep 07 '16 at 07:47

webnoob

15,747
13
83
165

score 0 · Answer 5 · answered Sep 07 '16 at 07:55

0

If you'll extract the default value of the Bar property to a static field:

public class Foo
{
    public string Bar { get; set; } = defaultBarValue;

    public static string defaultBarValue = "foobar";
}

You'll be able to do this:

new Foo
{
    Bar = bar != null ? bar : Foo.defaultBarValue,
};

But I doubt it's worth the effort...

answered Sep 07 '16 at 07:55

haim770

48,394
7
105
133

Or simply: `new Foo { Bar = bar ?? Foo.defaultBarValue, }` – Orkhan Alikhanov Sep 07 '16 at 07:57
Or just `Bar = bar ?? "foobar"`. If the *caller* has to validate the value, it doesn't matter whether you use a static field, a constant or a hard-coded string. The validation logic has already leaked – Panagiotis Kanavos Sep 07 '16 at 07:57
@OrkhanAlikhanov, True. But I wanted to use the same constructs the OP used. – haim770 Sep 07 '16 at 07:58
I think the joke here is that OP does not want to use `if`, but suggests the ternary operator himself, which is also an `if` – slawekwin Sep 07 '16 at 07:58
I think the OP mistook object initializers and constructors and doesn't realize this is a property validation problem, not an initialization problem – Panagiotis Kanavos Sep 07 '16 at 08:00
@slawekwin, I think his main point is that, he *ought* to set a value to `Bar`, but doesn't want to abandon the value the auto-property initializer sets by default. – haim770 Sep 07 '16 at 08:00
isn't it worth the effort if I have for example 4 properties? – AllOutOfSalt Sep 07 '16 at 08:12

use default property value in C# constructor initializer

5 Answers5