Revolutionary new way to iterate indexable collections. Who needs to know how many elements they have?
-
Recently I encountered brand new look at standard boring indexable collections like arrays or lists in code I worked on. To be more precise, at ways we usually use to iterate them. We no longer need properties or functions like: Length, Size, Count. See how it goes (example demonstrating the idea):
int[] someArray = new int[] {/*element initialization*/};
for (int i = 0; /*note, the loop is infinite here*/; i++)
{
try
{
int item = someArray[i];
//do some stuff here
}
catch(Exception e)
{
break;//Bingo, we're done!
}
}Smell the power! Lenght, Count, Size, etc. They are obsolete now. :) We will iterate an indexable collection item by item until it crashes and that means our iteration is finished. That's what try/catch block was really intended for! P.S. int[] was used for demonstration purposes. You can try it at home with any indexable collection you want (in .NET, for example, any collection implementing IList or IList<T> will do just fine).
-
Recently I encountered brand new look at standard boring indexable collections like arrays or lists in code I worked on. To be more precise, at ways we usually use to iterate them. We no longer need properties or functions like: Length, Size, Count. See how it goes (example demonstrating the idea):
int[] someArray = new int[] {/*element initialization*/};
for (int i = 0; /*note, the loop is infinite here*/; i++)
{
try
{
int item = someArray[i];
//do some stuff here
}
catch(Exception e)
{
break;//Bingo, we're done!
}
}Smell the power! Lenght, Count, Size, etc. They are obsolete now. :) We will iterate an indexable collection item by item until it crashes and that means our iteration is finished. That's what try/catch block was really intended for! P.S. int[] was used for demonstration purposes. You can try it at home with any indexable collection you want (in .NET, for example, any collection implementing IList or IList<T> will do just fine).
VUnreal wrote:
You can try it at home
Shouldn't that be 'don't try this at home, leave it to the trained professionals'?
The bearing of a child takes nine months, no matter how many women are assigned.
-
Recently I encountered brand new look at standard boring indexable collections like arrays or lists in code I worked on. To be more precise, at ways we usually use to iterate them. We no longer need properties or functions like: Length, Size, Count. See how it goes (example demonstrating the idea):
int[] someArray = new int[] {/*element initialization*/};
for (int i = 0; /*note, the loop is infinite here*/; i++)
{
try
{
int item = someArray[i];
//do some stuff here
}
catch(Exception e)
{
break;//Bingo, we're done!
}
}Smell the power! Lenght, Count, Size, etc. They are obsolete now. :) We will iterate an indexable collection item by item until it crashes and that means our iteration is finished. That's what try/catch block was really intended for! P.S. int[] was used for demonstration purposes. You can try it at home with any indexable collection you want (in .NET, for example, any collection implementing IList or IList<T> will do just fine).
-
Recently I encountered brand new look at standard boring indexable collections like arrays or lists in code I worked on. To be more precise, at ways we usually use to iterate them. We no longer need properties or functions like: Length, Size, Count. See how it goes (example demonstrating the idea):
int[] someArray = new int[] {/*element initialization*/};
for (int i = 0; /*note, the loop is infinite here*/; i++)
{
try
{
int item = someArray[i];
//do some stuff here
}
catch(Exception e)
{
break;//Bingo, we're done!
}
}Smell the power! Lenght, Count, Size, etc. They are obsolete now. :) We will iterate an indexable collection item by item until it crashes and that means our iteration is finished. That's what try/catch block was really intended for! P.S. int[] was used for demonstration purposes. You can try it at home with any indexable collection you want (in .NET, for example, any collection implementing IList or IList<T> will do just fine).
Jesus H. Christ. That's so appalling, I thought I'd investigate, so I ran this testbed:
static int listSize = 10000000;
static int tests = 10;
static List list = new List();static void LoopClassic()
{
DateTime start= DateTime.Now;
int f;
for(int i= 0; i< tests; i++)
{
for(int j = 0; j < list.Count; j++)
f = list[j];
}
TimeSpan elapsed = DateTime.Now.Subtract(start);
Console.WriteLine("Classic: {0}", elapsed.TotalMilliseconds );
}static void LoopCrufty()
{
DateTime start = DateTime.Now;
int f;for (int i = 0; i < tests; i++) { for(int j=0;true;j++) try { f = list\[j\]; } catch { break; } } TimeSpan elapsed = DateTime.Now.Subtract(start); Console.WriteLine("Crufty: {0}", elapsed.TotalMilliseconds);}
static void Main(string[] args)
{
for (int i = 0; i < listSize; i++)
list.Add(i);
LoopClassic();
LoopCrufty();
Console.ReadKey();
}The Crufty method was faster for the large list (over several runs in release mode)@ Classic~1000 ms, Crufty ~650ms. I changed the list size to 1,000,000 and the normal loop ran quicker (130ms vs 160). Still not justified though! [Edit] This is quicker for loops <= 10,000,000 or so!
static void LoopClassic2()
{
DateTime start = DateTime.Now;
int f;
for (int i = 0; i < tests; i++)
{
int count = list.Count;
for (int j = 0; j < count; j++)
f = list[j];
}
TimeSpan elapsed = DateTime.Now.Subtract(start);
Console.WriteLine("Classic2: {0}", elapsed.TotalMilliseconds);
}Sort of a cross between Lawrence of Arabia and Dilbert.[^]
-Or-
A Dead ringer for Kate Winslett[^]modified on Saturday, April 16, 2011 12:58 PM
-
Jesus H. Christ. That's so appalling, I thought I'd investigate, so I ran this testbed:
static int listSize = 10000000;
static int tests = 10;
static List list = new List();static void LoopClassic()
{
DateTime start= DateTime.Now;
int f;
for(int i= 0; i< tests; i++)
{
for(int j = 0; j < list.Count; j++)
f = list[j];
}
TimeSpan elapsed = DateTime.Now.Subtract(start);
Console.WriteLine("Classic: {0}", elapsed.TotalMilliseconds );
}static void LoopCrufty()
{
DateTime start = DateTime.Now;
int f;for (int i = 0; i < tests; i++) { for(int j=0;true;j++) try { f = list\[j\]; } catch { break; } } TimeSpan elapsed = DateTime.Now.Subtract(start); Console.WriteLine("Crufty: {0}", elapsed.TotalMilliseconds);}
static void Main(string[] args)
{
for (int i = 0; i < listSize; i++)
list.Add(i);
LoopClassic();
LoopCrufty();
Console.ReadKey();
}The Crufty method was faster for the large list (over several runs in release mode)@ Classic~1000 ms, Crufty ~650ms. I changed the list size to 1,000,000 and the normal loop ran quicker (130ms vs 160). Still not justified though! [Edit] This is quicker for loops <= 10,000,000 or so!
static void LoopClassic2()
{
DateTime start = DateTime.Now;
int f;
for (int i = 0; i < tests; i++)
{
int count = list.Count;
for (int j = 0; j < count; j++)
f = list[j];
}
TimeSpan elapsed = DateTime.Now.Subtract(start);
Console.WriteLine("Classic2: {0}", elapsed.TotalMilliseconds);
}Sort of a cross between Lawrence of Arabia and Dilbert.[^]
-Or-
A Dead ringer for Kate Winslett[^]modified on Saturday, April 16, 2011 12:58 PM
You made me laugh. You even managed to test the stuff :) Actually I can even say how this wonderful code has emerged. One "colleague" of mine (I don't consider him as a real colleague to be honest, 'cause he produces sh*t regularly) was too lame to read documentation. Every wise enough human being must have a thought in his/her mind that if a collection's element can be retrieved by index, there must be some kind of function/property like Size, Count, Length, etc. allowing us to know when to stop. So that "guru" had found function that retrieves an object by index, but had failed to scroll the documentation a little further to find number of elements. And little genius invented the construction you saw above. I had no words when I first saw the stuff.
-
You made me laugh. You even managed to test the stuff :) Actually I can even say how this wonderful code has emerged. One "colleague" of mine (I don't consider him as a real colleague to be honest, 'cause he produces sh*t regularly) was too lame to read documentation. Every wise enough human being must have a thought in his/her mind that if a collection's element can be retrieved by index, there must be some kind of function/property like Size, Count, Length, etc. allowing us to know when to stop. So that "guru" had found function that retrieves an object by index, but had failed to scroll the documentation a little further to find number of elements. And little genius invented the construction you saw above. I had no words when I first saw the stuff.
VUnreal wrote:
You made me laugh.
Glad to be of service :-)
Sort of a cross between Lawrence of Arabia and Dilbert.[^]
-Or-
A Dead ringer for Kate Winslett[^] -
Recently I encountered brand new look at standard boring indexable collections like arrays or lists in code I worked on. To be more precise, at ways we usually use to iterate them. We no longer need properties or functions like: Length, Size, Count. See how it goes (example demonstrating the idea):
int[] someArray = new int[] {/*element initialization*/};
for (int i = 0; /*note, the loop is infinite here*/; i++)
{
try
{
int item = someArray[i];
//do some stuff here
}
catch(Exception e)
{
break;//Bingo, we're done!
}
}Smell the power! Lenght, Count, Size, etc. They are obsolete now. :) We will iterate an indexable collection item by item until it crashes and that means our iteration is finished. That's what try/catch block was really intended for! P.S. int[] was used for demonstration purposes. You can try it at home with any indexable collection you want (in .NET, for example, any collection implementing IList or IList<T> will do just fine).
I wonder what will happen when
//do some stuff herethrows an exception??? ;-)