Ayende @ Rahien

James commented on Challenge: Robust enumeration over external code

Thu, 11 Mar 2010 10:07:07 GMT

Simplest possible solution ... public static IEnumerable func) { return new[] { 1, 3, 5, 7, 9 }; } >

sergio commented on Challenge: Robust enumeration over external code

Tue, 09 Mar 2010 08:01:30 GMT

Maybe its not the best, but it works public class Program { private static void Main() { foreach (int i in RobustEnumerating(Enumerable.Range(0, 10), FaultyFunc)) { Console.WriteLine(i); } Console.ReadLine(); } public static IEnumerable func) { // how to do this? var enumerator = func(input).GetEnumerator(); while (SafeMoveNextEnumerator(input, func, ref enumerator)) { yield return enumerator.Current; } } static int skip = 0; public static bool SafeMoveNextEnumerator func, ref IEnumerator

firefly commented on Challenge: Robust enumeration over external code

Fri, 05 Mar 2010 21:44:35 GMT

@ tobi, it's not hard but I wouldn't say it's intuitive either. Especially for an interview question unless you've wrote library code where you use MoveNext a lot and have an intimate understanding of how it really work. Now if you've been exposed to this before somewhere else then it's extremely easy :). Thanks Oren and everyone else that comments. I learned a lot from the exposure... especially from Demid code, very elegant indeed.

Chris Martin commented on Challenge: Robust enumeration over external code

Fri, 05 Mar 2010 18:30:49 GMT

public static IEnumerable func) { return func(input.ToList().ConvertAll(t => int.Parse(t.ToString())).Where(i => i%2 > 0)); } lol >

Thomas Eyde commented on Challenge: Robust enumeration over external code

Fri, 05 Mar 2010 13:59:18 GMT

It looks like the solution is a variation over iterating the input, because that's the only thing we can control, evaluate each item and only return the results of those evaluations that don't fail. Here's my attempt: foreach (var item in input) { T[] evaluatedItems; try { var itemAsEnumerable = new[] { item }; evaluatedItems = func(itemAsEnumerable).ToArray(); } catch (Exception) { continue; } foreach (var evaluated in evaluatedItems) { yield return evaluated; } }

Allan PArker commented on Challenge: Robust enumeration over external code

Fri, 05 Mar 2010 11:04:06 GMT

Hi, Here is my attempt at this: public static IEnumerable func) { foreach (T item in input) { IEnumerable

Sergey Kachkovsky commented on Challenge: Robust enumeration over external code

Fri, 05 Mar 2010 10:58:57 GMT

Ok, and what is the BEST solution?

Ken Tong commented on Challenge: Robust enumeration over external code

Fri, 05 Mar 2010 02:38:10 GMT

How about this? public static IEnumerable RobustEnumerating( IEnumerable input, Func, IEnumerable> func) { IEnumerable results = new T[0]; foreach (T item in input) { try { foreach (T value in func(new[] { item })) results = results.Concat(new[] { value }); } catch { } } foreach (T result in results) yield return result; }

Ajai Shankar commented on Challenge: Robust enumeration over external code

Fri, 05 Mar 2010 02:01:44 GMT

@Demid & Dmitriy: vi & csc works too :-)

Dmitriy Nagirnyak commented on Challenge: Robust enumeration over external code

Fri, 05 Mar 2010 00:57:52 GMT

@Demind, I use LINQPad for that purpose. Copy-paste code and it just runs.

Demid commented on Challenge: Robust enumeration over external code

Fri, 05 Mar 2010 00:13:43 GMT

I can't believe so many people are so lazy to compile their code at least. It's not a crime do not know that try/catch block isn't compatible with yield statement but you can at least try to compile it. Download SnippetCompiler. It is outdated project but it really really good to test your ideas whenever you're not sure how compiler or .net behaves in a particular situation because. It loaded instantly and I ran Oren's example in two seconds after I saw it.

James C-S commented on Challenge: Robust enumeration over external code

Fri, 05 Mar 2010 00:11:37 GMT

Whoops! Now I feel bad about me, err my, grammar... ;-)

James C-S commented on Challenge: Robust enumeration over external code

Fri, 05 Mar 2010 00:10:29 GMT

OK. I felt bad about me previous answer that broke encapsulation. Here's an answer that doesn't. public static IEnumerable func) { Func safeFunc = source => { var @return = (IEnumerable o); } >

James C-S commented on Challenge: Robust enumeration over external code

Thu, 04 Mar 2010 23:46:04 GMT

This is probably not in the spirit of the challenge, but ... public static IEnumerable func) { return func(input.Cast x % 2 != 0).Cast

tobi commented on Challenge: Robust enumeration over external code

Thu, 04 Mar 2010 18:52:57 GMT

Wow I will remember this challenge and use it as an interview question. It seems like everyone gets it wrong the first time so you can discuss the problem with the candidate to see if they are smart or not. Also I do not understand why everyone seems to restart the sequence when an error has occurred. Just do nothing or else the sequence will restart over and over. I do not understand the purpose of StatefullEnumerable. It seems to do nothing.

Kvasov Roman commented on Challenge: Robust enumeration over external code

Thu, 04 Mar 2010 17:44:57 GMT

I think it`s more robust implementation with additional class, but it call function only once so if it contains some initialization logic it doesn`t break. using System; using System.Collections; using System.Collections.Generic; using System.Linq; public class Program { public class StatefullEnumerable func) { var enumerable = func(new StatefullEnumerable

Ajai Shankar commented on Challenge: Robust enumeration over external code

Thu, 04 Mar 2010 17:09:56 GMT

@Ayende "Ajai, You are iterating over the input enum more than once" Here is what I think works (I had to add a method, don't know if it is allowed) Very nice problem, do you expect the input enumerable to throw too? Now I need to go get some real work done :-) Looking forward to what you have, can't take the suspense any longer! static IEnumerable func) { input = EnumOnce(input.GetEnumerator()); var result = func(input).GetEnumerator(); while(true) { try { if(!result.MoveNext()) break; } catch(Exception) { result = func(input).GetEnumerator(); continue; } yield return result.Current; } } >

Michal commented on Challenge: Robust enumeration over external code

Thu, 04 Mar 2010 15:38:17 GMT

return input.Select(i => { try { return func(new[] { i }).First(); } catch { return default(T); } }). Where(i => !i.Equals(default(T)));

tobi commented on Challenge: Robust enumeration over external code

Thu, 04 Mar 2010 15:33:52 GMT

the func transforms a non-throwing sequence into a throwing sequence. you can solve it calling it only once.

Mike Thomas commented on Challenge: Robust enumeration over external code

Thu, 04 Mar 2010 15:10:56 GMT

@ayende or if MoveNext just sets some other flag before it throws or if MoveNext disposes of itself before it throws or if MoveNext does something like this (assuming for the moment that I still reset the state correctly): yield return memberCounterThatINeedToBeUniquePerIncomingItem + transformThatWontThrow(); yield return memberCounterThatINeedToBeUniquePerIncomingItem + transformThatWillThrow(); memberCounterThatINeedToBeUniquePerIncomingItem++; Basically, like Nick says, if we have the requirement that the func can be called only once (which makes sense since it could be keeping track of its position or could make a million expensive remote calls before returning the first item) you can't solve this in a generic way.

tobi commented on Challenge: Robust enumeration over external code

Thu, 04 Mar 2010 13:16:51 GMT

I cannot believe that 95% of all answers are just wrong. It is not that hard... If your call to movenext is not in a try-catch, your code is wrong. if you use foreach, your code is wrong because an exception will skip the rest of the enumeration. Do not call func multiple times, it is not necessary. It will enumerate the sequence multiple times. Nice challenge however.

Sergey Shishkin commented on Challenge: Robust enumeration over external code

Thu, 04 Mar 2010 13:00:19 GMT

return input.SelectMany(x => { try { return new[]{func(new[] { x }).FirstOrDefault()}; } catch { return new T[0]; } });

Frank commented on Challenge: Robust enumeration over external code

Thu, 04 Mar 2010 12:17:41 GMT

Without having looked at previous posted entries, this should do the trick, while still supporting infinite enumerations: public static IEnumerable func ) { var singleInputElementArray = new T[1]; foreach (var inputElement in input) { singleInputElementArray[0] = inputElement; IEnumerator

Mike Doherty commented on Challenge: Robust enumeration over external code

Thu, 04 Mar 2010 11:49:16 GMT

This time I've escaped the angle brackets to see if that slips past the comment sanitizer. Looking over Dimid's solution though I realize that I am repeatedly enumerating over the input which could have a performance impact if getting these values was expensive. I love the way that he wraps the input to preserve it's state. public static IEnumerable RobustEnumerating( IEnumerable input, Func, IEnumerable> func) { var rowsToSkipOnError = 1; var enumerationToWrap = func(input).GetEnumerator(); while (true) { T nextValue; try { if (!enumerationToWrap.MoveNext()) yield break; nextValue = enumerationToWrap.Current; } catch (Exception) { // This input failed so skip to the next one input = input.Skip(rowsToSkipOnError); enumerationToWrap = func(input).GetEnumerator(); rowsToSkipOnError = 1; continue; } rowsToSkipOnError++; yield return nextValue; } }

Arielr commented on Challenge: Robust enumeration over external code

Thu, 04 Mar 2010 11:30:03 GMT

return input.SelectMany(x => { try { return func(x.AsEnumerableX()).ToArray(); } catch { return Enumerable.Empty

Mike Doherty commented on Challenge: Robust enumeration over external code

Thu, 04 Mar 2010 11:26:48 GMT

Ok. Here is my solution: public static IEnumerable func) { var rowsToSkipOnError = 1; var enumerationToWrap = func(input).GetEnumerator(); while (true) { T nextValue; try { if (!enumerationToWrap.MoveNext()) yield break; nextValue = enumerationToWrap.Current; } catch (Exception) { // This input failed so skip to the next one input = input.Skip(rowsToSkipOnError); enumerationToWrap = func(input).GetEnumerator(); rowsToSkipOnError = 1; continue; } rowsToSkipOnError++; yield return nextValue; } } >

Sergey Kachkovsky commented on Challenge: Robust enumeration over external code

Thu, 04 Mar 2010 11:14:37 GMT

public static IEnumerable func) { IEnumerator

Koen commented on Challenge: Robust enumeration over external code

Thu, 04 Mar 2010 10:28:40 GMT

My generic type parameters weren't automatically HTML encoded so here's a second attempt encoding them myself: return func(input.Cast().Where(i => i % 2 == 1).Cast());

Alex Yakunin commented on Challenge: Robust enumeration over external code

Thu, 04 Mar 2010 10:14:26 GMT

@ Nick Aceves You're right - I really made a mistake. Btw, such OnErrorResumeNext is fitting very well on their sequence concept (throw terminates a sequence). So now it looks like a tricky case to implement this fully on default LINQ combinators and Rx.

Benny Thomas commented on Challenge: Robust enumeration over external code

Thu, 04 Mar 2010 10:03:29 GMT

Ugly code that needs some tuning. public static IEnumerable func) { foreach(T a in input) { List