Spread operator when using Add innitalization syntax

[Dovencio]

Say I have a class:

class Foo
{
    public List<string> FooStrings { get; } = new();
}

And some arrays of strings:

string[] str1 = ["a", "b", "c"];
string[] str2 = ["x", "y", "z"];

Say I want to add str1 and str2 to Foo.FooStrings using the initialization syntax.

var foo = new Foo
{
    FooStrings = { .. str1, "d", "w", .. str2 }
};

But right now that gives the error Cannot implicitly convert type 'string[]' to 'System.Index'.
I expected it to be the equivalent of:

var foo = new Foo();
FooStrings.Add(str1[0]);
FooStrings.Add(str1[1]);
FooStrings.Add(str1[...]);
FooStrings.Add("d");
FooStrings.Add("w");
FooStrings.Add(str2[0]);
FooStrings.Add(str2[1]);
FooStrings.Add(str2[...]);

Is there a reason why the spread (..) syntax is not supported for the add initialization ({ ... }) syntax or am I missing something?

[HaloFour]

The spread operator is specific to collection expressions and has not been implemented anywhere else in the language.

[TahirAhmadov]

#5354 (comment)

[Dovencio]

I wouldn't say I'm too big of a fan of the += syntax but same idea.

[CyrusNajmabadi]

Say I want to add str1 and str2 to Foo.FooStrings using the initialization syntax.

Do this instead:

var foo = new Foo
{
    FooStrings = [.. str1, "d", "w", .. str2]
};

The point of collection expressions is to supersede and unify all the varying ways the language does collection initialization. It's def not 100% complete. But cases like this are better served with the above approach.

[333fred]

That's different semantics. Collection initializers add to an existing collection.

[timcassell]

The point of collection expressions is to supersede and unify all the varying ways the language does collection initialization.

So is there a plan to do something here?

I think something like FooStrings <| [ ... ] would feel good.

[Dovencio]

My mistake I mistyped out of habit but the class should be

class Foo
{
    public List<string> FooStrings { get; private set; } = new();
}

or even

class Foo
{
    public List<string> FooStrings { get; } = new();
}

This is very much needed in the case another object wraps an existing one and changing the reference will break the whole object. Even if Foo.FooStrings has a public setter.

class Foo
{
    private BindingList<string> _bindingList;
    public List<string> FooStrings { get; set; } = new();

    public Foo()
    {
        _bindingList = new(FooStrings);
    }

    public Refresh() => _bindingList.ResetBindings();
}

Foo foo = new() 
{
    FooStrings = [ .. str1, "d", "w", .. str2] 
};

foo.Refresh(); // fails to trigger ListChanged event with the new items, it'll provide an empty list.

A real life instance would be:

ProcessStartInfo info = new()
{
    FileName = "echo",
    ArgumentList = { .. str1, "d", "w", .. str2}
}

Note that ProcessStartInfo.ArgumentList does not have a public setter but adding args to the list rather than ProcessStartInfo.Arguments is useful because it would result in running the command echo "a" "b" "c" "d" "w" "x" "y" "z" rather than echo a b c d w x y z and can completely change things in case of cat "/path to file/file.cs" vs. cat /path to file/file.cs (using type for windows powershell).