How can I join strings from one List into another one? [closed]

Answer 1

Here is how you can do it with LINQ:

var result =
    Names
        .Select((item, index) => new {Item = item, Index = index})
        .GroupBy(x => x.Index / 500)
        .Select(g => string.Join(",", g.Select(x => x.Item)))
        .ToList();

First, for each item, you select the item it self along with its index. Then you group these items by index / 500 which means that each 500 items will be grouped together.

Then you use string.Join to join the 500 strings in each group together.

Answer 2

something like this:

public static void Main()
    {
        string[] strs = new string[]{"aaaa","bbb","ccc","ffffd","eeee","fff","ggg","hhhh","iiiii","JJJJ"};
        List<string> res=new List<string>();
        for(int i=0;i<strs.Length;i+=5){
            res.Add(string.Join(",",strs,i,5));
        }
        res.ForEach(F => Console.WriteLine(F));
    }

just change the iteration to be with 500 instead of 5, and strs to be your array.

Answer 3

With MoreLINQ Batch (or any other batch implementation):

var abc = names.Batch(500).Select(x => String.Join(",", x)).ToList();

NOTE: Grouping operator is not streaming operator (as well as ToList). That means that all 700k strings should be enumerated and keys should be calculated for each item, and each items should be stored in internal groups. And that will cost some time and resources. Batching is streaming and it does not store all items internally. It stores only current batch. So with batching if you will not convert results to list, you can process batches one by one faster and save some memory.

Answer 4

The shortest way is to use LINQ Chunks implementation from SO answer:

List<string> ABC = Names.Select((x, i) => new { x, i })
                        .GroupBy(xi => xi.i / 500, xi => xi.x)
                        .Select(g => string.Join(",", g))
                        .ToList();

Answer 5

If you don't want to use a separate library, you can use a simple extension method to partition a sequence into subsequences of a given size:

public static class EnumerableExt
{
    public static IEnumerable<IEnumerable<T>> Partition<T>(this IEnumerable<T> input, int blockSize)
    {
        var enumerator = input.GetEnumerator();

        while (enumerator.MoveNext())
            yield return nextPartition(enumerator, blockSize);
    }

    static IEnumerable<T> nextPartition<T>(IEnumerator<T> enumerator, int blockSize)
    {
        do    yield return enumerator.Current;
        while (--blockSize > 0 && enumerator.MoveNext());
    }
}

Then you can use it like so:

        // Create some sample strings.
        var strings = Enumerable.Range(1, 10000).Select(x => x.ToString()).ToList();

        var result = strings.Partition(500).Select(block => string.Join(",", block)).ToList(); 

This approach does not make a copy of the input array.