3

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;
Improve this question
6
  • Just don't assign the value then? if (bar != null) { ... } Commented Sep 7, 2016 at 7:42
  • @LasseV.Karlsen the conditional statement would be complex when the number of parameters increase. Commented Sep 7, 2016 at 7:44
  • Possible duplicate of Object Initializer and Dynamically specifying properties Commented Sep 7, 2016 at 7: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;. Commented Sep 7, 2016 at 7: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 Commented Sep 7, 2016 at 7:55

5 Answers 5

Reset to default
2

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.

Improve this answer
Sign up to request clarification or add additional context in comments.

Comments

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).

Improve this answer

3 Comments

Yes that's correct but I wanted to know if there is such feature to avoid conditional statements
@danrah There is not (yet?). Unless you can change auto property to make the if there?
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
1

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; }
    }
Improve this answer

Comments

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...

Improve this answer

7 Comments

Or simply: new Foo { Bar = bar ?? Foo.defaultBarValue, }
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
@OrkhanAlikhanov, True. But I wanted to use the same constructs the OP used.
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
I think the OP mistook object initializers and constructors and doesn't realize this is a property validation problem, not an initialization problem
|
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).

Improve this answer

Comments

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.