private string connection;
public string Connection
{
get { return connection; }
}
public string Connection { get; private set; }
I was inspired by my good friend Nick's latest blog entry Return of the Batch Enumerable.
Here he demonstrates a neat idea of using extension methods and yield to split an IEnumerable into arbitrary batches.
My version is slightly less efficient, but treats the batches as separate lazy collections - so you can use it on multiple threads etc.
I've also added a Split extension, which I'll describe - but first, the code!
static class InBatchesExtension
{
public static IEnumerable<IEnumerable<T>> InBatches<T>(this IEnumerable<T> source, int batchSize)
{
for (IEnumerable<T> s = source; s.Any(); s = s.Skip(batchSize))
yield return s.Take(batchSize);
}
public static IEnumerable<IEnumerable<T>> Split<T>(this IEnumerable<T> source, int items)
{
for (int i = 0; i < items; ++i)
yield return source.Where((x, index) => (index % items) == i);
}
}
The InBatches returns the same output as Nicks:
Batch: 1 2 3
Batch: 4 5 6
Batch: 7
And the Split batches the output across the collections:
Batch: 1 4 7
Batch: 2 5
Batch: 3 6
So this gives you 2 different batch splitting methods for a generic enumerable.
I love this stuff.
IEnumerable<string> ReadFile(string filename)
{
using (StreamReader reader = new StreamReader(File.OpenRead(filename)))
while (reader.EndOfStream == false)
yield return reader.ReadLine();
}
// Contrived example - How many file lines refer to "fred"?
var result = ReadFile("file.txt").Where(x => x.Contains("fred")).Count();
class Program
{
static IEnumerable<List<string>> Permutate(IEnumerable<string> people,
IEnumerable<string> current)
{
// Get remaining people and recurse
foreach (var person in people.Where(x => current.Contains(x) == false))
foreach (var result in Permutate(people, current.Concat(new string[] { person })))
yield return result;
if (current.Count() == people.Count())
yield return current.ToList();
}
static void Main(string[] args)
{
string[] people = new string[] { "Josh", "Toby", "CJ", "Sam", "Leo", "Donna" };
var result = Permutate(people, new string[] { }).ToList();
// Josh sits to the left of Leo
var Josh_Leo = result.Where(r =>
r.FindIndex(x => x == "Josh") < r.FindIndex(x => x == "Leo"));
// Josh sits to the right of Sam
var Sam_Josh = Josh_Leo.Where(r =>
r.FindIndex(x => x == "Sam") < r.FindIndex(x => x == "Josh"));
var count = Sam_Josh.Count();
}
}
Although Internet Multitasking Syndrome is not a known medical disorder (I just made it up five minutes ago), it is not uncommon for people to become so immersed in their online activities that their cognitive abilities wane.
After hours starring at a screen, flipping between web pages and information outlets, people can develop a feeling of anxiety, stress and a decrease in mental performance, said John Suler, author of The Psychology of Cyberspace.
"There are limits to how much information one person can process," he continued.
