将一个列表中的8个元素拆分为另一个C＃的第一个元素

Question

one a integer list and one a string list. The integer list's length will always be a multiple of 8. I would like to put the first 8 integers from my integer list into the first element of a string list, then loop and put the next 8 into the second element of the string list and so on. I have made an attempt, I currently have an error on the Add method as string doesn't have an add extension? Also I'm not sure if the way I have done it using loops is correct, any advice would be helpful.

List1 is my integer list

List2 is my string list

string x = "";
            for (int i = 0; i < List1.Count/8; i++) {

                for(int i2 = 0; i2 < i2+8; i2+=8)
                {
                    x = Convert.ToString(List1[i2]);

                    List2[i].Add(h);
                } 
        }

Answer 1

You can do that by using something like that

var list1 = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 };
var list2 = new List<string>();

for (int i = 0; i < list1.Count / 8; i++)
{
    list2.Add(string.Concat(list1.Skip(i * 8).Take(8)));
}

// list2[0] = "12345678"
// list2[1] = "910111213141516"

A slightly more complicated approach, which only iterates once over list1 (would work with IEnumerable would be sth. like this:

var list1 = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 }.AsEnumerable();
var list2 = new List<string>();

var i = 0;
var nextValue = new StringBuilder();

foreach (var integer in list1)
{
    nextValue.Append(integer);
    i++;

    if (i != 0 && i % 8 == 0)
    {
        list2.Add(nextValue.ToString());
        nextValue.Clear();
    }
}

// could add remaining items if count of list1 is not a multiple of 8
// if (nextValue.Length > 0)
// {
//     list2.Add(nextValue.ToString());
// }

Answer 2

For the fun of it, you can implement your own general purpose Batch extension method. Good practice to understand extension methods , enumerators , iterators , generics and c#'s local functions :

static IEnumerable<IEnumerable<T>> Batch<T>(
    this IEnumerable<T> source, 
    int batchCount,
    bool throwOnPartialBatch = false)
{
    IEnumerable<T> nextBatch(IEnumerator<T> enumerator)
    {
        var counter = 0;

        do
        {
           yield return enumerator.Current;
           counter += 1;

        } while (counter < batchCount && enumerator.MoveNext());

        if (throwOnPartialBatch && counter != batchCount) //numers.Count % batchCount is not zero.
            throw new InvalidOperationException("Invalid batch size.");
    }

    if (source == null)
        throw new ArgumentNullException(nameof(source));

    if (batchCount < 1)
        throw new ArgumentOutOfRangeException(nameof(batchCount));

    using (var e = source.GetEnumerator())
    {
        while (e.MoveNext())
        {
            yield return nextBatch(e);
        }
    }
}

Using it is rather trivial:

var ii = new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };
var ss = ii.Batch(4, true)
           .Select(b => string.Join(", ", b))

And sure enough, the output is:

1, 2, 3, 4
5, 6, 7, 8
9, 10, 11, 12

Answer 3

while (listOfintergers.Count() > 0)
        {
            var first8elements = listOfintergers.ConvertAll(t=>t.ToString()).Take(8);
            listOfStrings.Add(string.Concat(first8elements));
            listOfintergers = listOfintergers.Skip(8).ToList();
        }