1. LINQ

2. Iterators

3. Iteration

4. Iteration

5. What do we see
• It is imperative (repetitive, verbose etc.)
– Sort of awkward
• This is “default” way to iterate data structure
– Can be put into library
• But sometimes we want to iterate differently
– Determined by business rules

6. Custom iteration

7. Custom iteration

8. Custom iteration

9. The problem
Given:
• Data structure knows how to iterate itself
• Additionally, we want to define other ways to
iterate data structure
Goal:
• Nice abstraction for that

10. Solution
foreach loop

12. Agenda
• Manual iteration
• …magic…
• foreach iteration
• …magic…
• No iteration

13. Iterator pattern

14. Usage

15. Implementation
Let’s implement ReverseEnumerator<T>

16. ReverseEnumerator<T>

17. ReverseEnumerator<T>

18. Usage

19. Let’s make usage code identical

21. Now compiler can do iteration
for us

22. Iterators are lazy (deferred)
Let’s show it in debugger

23. Iteration side effects
are observed
each time the sequence is iterated

24. Let’s see what else can compiler do for us

28. yield return – makes MoveNext()
return true

29. yield return is also lazy
Let’s check that in debugger

30. yield return is lazy

31. yield return is lazy

32. yield break – makes MoveNext()
return false

33. IEnumerables are immutable
We cannot change the sequence
We can only create new sequences
based on old ones

35. We can chain iterators
Remember, the sequence is lazy

36. Infinite iterators

37. Infinite iterators

38. Let’s recall our goal
Given:
• Data structure knows how to iterate itself
• Additionally, we want to define other ways to
iterate data structure
Goal:
• Nice abstraction for that

39. Iterate data structure

41. In fact, often we don’t need
iteration at all
Typical tasks:
• Find element(s) in sequence
• Check if condition is true/false for all elements
• Transform sequence
• Filter sequence
• Aggregate sequence

42. In these cases iteration is just an
implementation detail
We can express what we want declaratively

43. Generation
• Empty(), Range(), Repeat()

44. Aggregation
• Aggregate(), All(), Any(), Average(),
Contains(), Count(), Max(), Min(), Sum()
• ElementAt(), First(), Last(), Single()

45. Transformation
• Cast(), OfType()
• Concat(), Distinct(), Except(), Intersect(),
Reverse(), Union(), Zip()
• Select(), SelectMany()
• GroupBy()
• OrderBy(), OrderByDescending()

46. Filtration
• Skip(), SkipWhile(), TakeWhile(), Where()

47. Anonymous types

48. Extension methods are nice
But we’ve got something even better!

49. LINQ
(Language Integrated Queries)
(a.k.a. query comprehensions)

50. select

51. where

52. select + where

53. select + where + anonymous types

54. select many

55. select many + where

56. order by

57. let

58. group by

59. group by

60. Sum up
• Use LINQ and LINQ extension methods
– to declaratively specify what you want
– to simplify your code
– to generalize your code
– to create complex abstractions from simple ones
• Remember that IEnumerables are lazy

61. Questions?