String arrays in LINQ

Question

I have an array which is containing 10000 values and I want to take each 50 items from the array and will do some string operations. How should I do it using LINQ or FOR loop. Thanks in advance.

Answer 1

You can use Skip and Take in your for loop, like this:

for (int pos = 0 ; pos < values.Length ; pos += 50) {
    var subArray = values.Skip(pos).Take(50).ToArray();
}

Note: this would be extremely inefficient if values is not an array or a List<String>.

However, this is not the most efficient way of doing it: you would be better off not using LINQ at all, and use Array.Copy method instead:

var subArray = new String[50];
for (int pos = 0 ; pos < values.Length ; pos += 50) {
    Array.Copy(values, pos, subArray, 0, 50);
}

The above solution requires that subArray is not stored as part of whatever processing that you are planning to do, and that values.Length be divisible by 50 (with 10000 items, it is).

Answer 2

You can just use GetRange

       List<string> elements  = yourArray.ToList();
       if (null != elements && elements.Count > 50)
        {
            for (int i = 0; i < elements.Count; i += 50)
            {
                Array result = elements.GetRange(i,50).ToArray();
                // here you can pass the retrived list to your private method to do the necessary functionility. 
                StringOperationForArray(result);
            }
        }

Answer 3

Make that as list<string>

List <string> lst = array.ToList ();

string [] strarr= lst.GetRange (0,50);

From MSDN

Answer 4

Here you go:

using System;
using System.Collections.Generic;
using System.Linq; 

namespace ConsoleApplication2
{
    class Program
    {
        const int chunkSize = 50;
        static void Main(string[] args)
        {
            var bigList = Enumerable.Range(0, 10000).Select(s => s.ToString()).ToList();

            ChunkerProcess(bigList, i => { Console.WriteLine(i); });
        }

        private static void ChunkerProcess<T>(List<T> bigList, Action<T> action )
        {
            int pointer = 0;
            List<T> chunks = bigList.GetRange(0, chunkSize>bigList.Count?bigList.Count:chunkSize);
            while (chunks.Count > 0)
            {
                foreach (var chunk in chunks)
                {
                    action.Invoke(chunk);
                }
                chunks.Clear();
                if (chunkSize * pointer < bigList.Count)
                {
                    chunks = bigList.GetRange(chunkSize * pointer, chunkSize * (pointer + 1) > bigList.Count ? bigList.Count - chunkSize * pointer : chunkSize);
                    pointer++;
                }
            }
        }
    }
}

Answer 5

If you can use Rx Extensions, this would be my favorite solution.

namespace ConsoleApplication2
{
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Reactive.Linq;

    internal class Program
    {
        #region Constants

        private const int chunkSize = 50;

        #endregion

        #region Methods

        private static void Main(string[] args)
        {
            List<string> bigList = Enumerable.Range(0, 99).Select(s => s.ToString()).ToList();
            bigList.ToObservable().Buffer(chunkSize).Subscribe(
                chunk =>
                {
                    foreach (string s in chunk)
                    {
                        Console.WriteLine(s);
                    }
                    Console.WriteLine(String.Empty.PadRight(80, '-'));
                });
        }

        #endregion
    }
}

Combined with Parallel Extensions Extras

namespace ConsoleApplication2
{
    using System;
    using System.Collections.Concurrent;
    using System.Collections.Generic;
    using System.Linq;
    using System.Reactive.Linq;
    using System.Threading;
    using System.Threading.Tasks;
    using System.Threading.Tasks.Schedulers;

    internal class Program
    {
        #region Constants

        private const int ChunkSize = 50;

        #endregion

        #region Methods

        private static void Main(string[] args)
        {
            var cancellationTokenSource = new CancellationTokenSource();
            CancellationToken cancellationToken = cancellationTokenSource.Token;
            var workStealingTaskScheduler = new WorkStealingTaskScheduler(Environment.ProcessorCount - 1);
            var bag = new ConcurrentBag<Task>();
            IEnumerable<string> bigList = Enumerable.Range(0, 10000).Select(s => s.ToString());
            bigList.ToObservable().Buffer(ChunkSize).Subscribe(
                chunk => bag.Add(
                    Task.Factory.StartNew(
                        () =>
                        {
                            foreach (string s in chunk)
                            {
                                Console.WriteLine(s);
                            }
                            Console.WriteLine(String.Empty.PadRight(80, '-'));
                        },
                        cancellationToken,
                        TaskCreationOptions.None,
                        workStealingTaskScheduler)));
            Task.WaitAll(bag.ToArray());
        }

        #endregion
    }
}

Answer 6

How is data enumerated actually? If it is IEnumerable then even foreach will work fine else if you have List even then foreach or IEnumerable.ForEach is also applicable and there is no extra penalty in performance even by slicing data. e.g.

foreach(var item in list)
{
//your operation here
}

OR,

list.ForEach(o=>
{
//your operation here
}
);