Enumerable.Concat两个以上的参数C＃

Question

I have 4 collections containing strings, like this:

first: xxxxxxxx second: xx third: xxxxxxxx fourth: xx

I want to concat these 4 collections to get: xxxxxxxxxxxxxxxxxxxx

I wanted to use the Enumerable.Concat but I have one problem with this, It only take two parameters. As a consequence I can concat only the first with the second (for example) but not all of'em together.

Is c# offers a way to concat more than 2 collections together?

Am I having to create two collections which concat first + second and third + fourth and then concat the two collections together?

EDIT

I made a mistake, It's 4 collections I want to concat. These collections contains strings like shown before, but these are Collections

Answer 1

You can chain the Enumerable.Concat calls like this.

List<string> list1 = new List<string>();
List<string> list2 = new List<string>();
List<string> list3 = new List<string>();
List<string> list4 = new List<string>();

//Populate the lists

var mergedList = list1.Concat(list2)
    .Concat(list3)
    .Concat(list4)
    .ToList();

Another option is to create an array and call SelectMany

var mergedList = new[]
{
    list1, list2, list3, list4
}
.SelectMany(x => x)
.ToList();

Note: Enumerable.Concat will allow duplicate elements, if you want to eliminate duplicates you can use Enumerable.Union method, rest all same.

Answer 2

You should use string.Concat method, Enumerable.Concat is meant for collections.

You could also use + operator.

Please note, that strings are immutable objects. It means that when you add 2 string, a new string object is being created. Therefore, for memory optimization purposes, you should use StringBuilder class for dynamic strings and concatenation of more than 5 strings.

Answer 3

If it's only four strings, what's wrong with:

first+ second+ third+ forth;

???

Answer 4

You don't need to take any special action yourself if you are concatenating 4 strings or less.

Firstly, note that there are overloads of String.Concat() taking between one and four string parameters .

Secondly, note that the compiler will translate concatenations involving four or less strings into calls to the appropriate String.Concat() overload.

For example, consider this code:

string a = "a";
string b = "b";
string c = "c";
string d = "d";
string e = a + b + c + d;

The concatenation is turned into this IL:

.method private hidebysig static void Main(string[] args) cil managed
{
    .entrypoint
    .maxstack 4
    .locals init (
        [0] string a,
        [1] string b,
        [2] string c,
        [3] string d,
        [4] string e)
    L_0000: ldstr "a"
    L_0005: stloc.0 
    L_0006: ldstr "b"
    L_000b: stloc.1 
    L_000c: ldstr "c"
    L_0011: stloc.2 
    L_0012: ldstr "d"
    L_0017: stloc.3 
    L_0018: ldloc.0 
    L_0019: ldloc.1 
    L_001a: ldloc.2 
    L_001b: ldloc.3 
    L_001c: call string [mscorlib]System.String::Concat(string, string, string, string)
    L_0021: stloc.s e
    L_0023: ldloc.s e
    L_0025: call void [mscorlib]System.Console::WriteLine(string)
    L_002a: ret 
}

Note that the actual concatenation is done by a call to System.String::Concat(string, string, string, string) .

If you are concatenating more strings, you might want to consider using StringBuilder instead, but you will probably only see a speed improvement for more than 8 or so strings.

---

[EDIT] OK the OP completely changed the question from concatenating strings to concatenating collections of strings... so this answer is now pointless. :(