I’m a bit late to the party with this one – Ix or Interactive Extensions.<\/p>\n
Available on NuGet via the Ix-Main package. This will give us the System.Interactive assembly.<\/p>\n
Ix are basically a bunch of extension methods for IEnumerable and the
\nEnumerableEx class. I’m sure many of us have written IEnumerable extensions to supply a ForEach extension method or the likes. Well Ix gives us that and more.<\/p>\n
In this post I will not be documenting each overload but will try to give an idea of what the methods might be used for and how to use them. Checking which overload is suitable is down to the reader.<\/p>\n
Note: some of the examples may be less than useful, I will attempt to update with better examples as\/when I come up with them.<\/em><\/p>\n Buffer<\/strong><\/p>\n Basically takes an IEnumerable and creates an IEnumerable of IList of type T of the given buffer size. <\/p>\n The above would result in an IEnumerable with 4 ILists of type T each containing up to 3 items each. An overload of this method exists which allows you to skip a number of elements at the start of each buffer.<\/p>\n Case<\/strong><\/p>\n Case is a static method on EnumerableEx and allows us to pass in an argument to compare against and an IDictionary of keys – which will be used to match with the argument passed into the Case method and it will return an IEnumerable relating to the values which appear in the dictionary against the given key. So for example<\/p>\n In the above, matches will contain the IEnumerable An overload of this method allows you to supply an IEnumerable to act as the default values should a match against the selector not be found.<\/p>\n Create<\/strong><\/p>\n Create is a static method on the EnumerableEx class which allows us to create an IEnumerable from a IEnumerator (or via an overload from an IYielder).<\/p>\n Let’s assume we have a method that returns an IEnumerator of integers, here’s a mock up of such a method<\/p>\n Now using Ix we can create an IEnumerable of integers using<\/p>\n Defer<\/strong><\/p>\n As the name suggests Defer will defer the creation of an enumerable sequence until a call to GetEnumerator, so for example<\/p>\n the code above will not call the enumerable factory method (in this case the anonymous method creating an array of integers) until the GetEnumerator is called.<\/p>\n Catch<\/strong><\/p>\n Creates an IEnumerable sequence based on the source, but if the source has an exception will switch to the second IEnumerable.<\/p>\n A somewhat convoluted sample below<\/p>\n The above will create an IEnumerable e that contains -1, -2 and then the values from the items IEnumerable.<\/p>\n There are several overloads of the Catch method to check out.<\/p>\n Distinct<\/strong><\/p>\n Returns an IEnumerable of the distinct values in a sequence<\/p>\n The above will result in a sequence 3, 5, 6, 2, 76, 45, 32, 1, 89, 100 removing the duplicates.<\/p>\n DistinctUntilChanged<\/strong><\/p>\n Returns consecutive distinct values<\/p>\n The above will return an sequence 3, 5, 2, 76, 100<\/p>\n Do<\/strong><\/p>\n Several overloads of the Do method exist, we’ll just take a look at the one which takes an Action. Do will simply invoke some action on each item within the IEnumerable, so for example<\/p>\n the above code will simply call WriteLine on each integer within the items IEnumerable. However, this is lazy and hence we actually need to do something with the items returns enumerable.<\/p>\n DoWhile<\/strong><\/p>\n The DoWhile method iterates over an IEnumerable whilst the supplied function is true, so for example<\/p>\n If we run this code the len<\/em> variable will be 12 as the DoWhile looped through the IEnumerable 3 times and the items<\/em> array contained four items. So basically if we output to the console each item returned by results<\/em> will see the array items output three times.<\/p>\n Expand<\/strong><\/p>\n Expand, basically loops through the supplied IEnumerable (possibly infinitely if you do not use a Take or similar method to stop it). In essence is applies a selector function each time through the enumerable changing the values. <\/p>\n So imagine we have an array of values 1, 2 and 0 and apply Expand to this as follows<\/p>\n what happens here is the output (if we ran results.ForEach(Console.WriteLine)<\/em>) will output 1, 2, 0 (the values from items<\/em> then 2, 3, 1 and finally 3, 4, 2. As you see each time we iterate through we add 1 to each element.<\/p>\n Finally<\/strong><\/p>\n Finally can be used on a sequence so that an action may be invoked upon the termination or disposal, so for example the following will output the sequence to the console then output “Completed”<\/p>\n For<\/strong><\/p>\n The For method takes a source enumerable and applies a supplied enumerable to it, so a simple example might be <\/p>\n In this case each item in the items<\/em> enumerable will have the new []{i + 1, i + 2}<\/em> applied to it, thus output for this would be<\/p>\n 4, 5, 6, 7, 7, 8, 3, 4, 77, 78<\/p>\n the first item 3 in the source enumerable is sent to the For method and we get back a transformed value as two values 3 + 1 and then 3 + 2 and so on.<\/p>\n ForEach<\/strong><\/p>\n ForEach will invoke an action on each item within an IEnumerable, so a simple example might be to just write a more compact foreach to write output to the console, i.e.<\/p>\n Generate<\/strong><\/p>\n As the name suggests, Generate<\/em> can be used to generate a sequence in a similar way to a for loop might be used, here’s an example which creates an IEnumerable with the range [10, 20]<\/p>\n The first argument is the starting value, then we have the condition to stop the generator, next we have the state update function, in this case we’re incrementing the state by 1, finally we have the result function, in this case we’re just using the supplied state value.<\/p>\n Hide<\/strong><\/p>\n To quote the documentation “Returns Enumerable sequence with the same behavior as the original, but hiding the source identity”.<\/p>\n I’m not wholly sure of the use cases for this, but basically if we have the following<\/p>\n if we used items.AsEnumerable()<\/em> the type returned would still be a List however using<\/p>\n result<\/em> will be a funky EnumerableEx type hiding the underlying implementation.<\/p>\n If<\/strong><\/p>\n The If method is self-explanatory, it allows us to return an IEnumerable if a condition is met or it will return an empty sequence or the overload shown below acts as an if..else returning the alternate sequence<\/p>\n So it’s probably obvious that if the someCondition<\/em> is true the first array is returned else the second array is returned.<\/p>\n IgnoreElements<\/strong><\/p>\n A slightly odd one, which probably is more useful when used in combination with other methods. IgnoreElements returns a source sequence without its elements<\/p>\n result will be an empty sequence.<\/p>\n IsEmpty<\/strong><\/p>\n As the name suggests, checks if the sequence is empty or not, obviously the following is not empty<\/p>\n whereas the following will be empty<\/p>\n Max<\/strong><\/p>\n Returns the maximum value in the sequence<\/p>\n this will result in the result<\/em> being 76.<\/p>\n MaxBy<\/strong><\/p>\n In essence MaxBy returns a sequence of values less than the supplied comparer, for example<\/p>\n this will create a sequence with values less than 50 and in this case write them to the console, thus outputting the values 3, 6 and 2.<\/p>\n Memoize<\/strong><\/p>\n Memoize creates a buffer over the source sequence to ensure that if we were to iterate over the items multiple times we would not call the source multiple times. Obviously this would be useful if we’ve got the data from some file system or remote source to stop us retrieving the data multiple times, in use we have<\/p>\n Min<\/strong><\/p>\n Returns the minimum value in the sequence<\/p>\n this will result in the result<\/em> being 2.<\/p>\n MinBy<\/strong><\/p>\n In essence MinBy returns a sequence of values greater than the supplied comparer, for example<\/p>\n this will create a sequence with values greater or equal to 50 and in this case write them to the console, thus outputting the values 50 and 76.<\/p>\n OnErrorResumeNext<\/strong><\/p>\n Concatenates the sequence with a second sequence regardless of whether an error occurred, used in situation where you might be getting data from a source that could fail, the example below just shows the syntax really as this wouldn’t need to use OnErrorResumeNext<\/p>\n result would contain the items sequence followed by the sequence { 9, 10 }.<\/p>\n Publish<\/strong><\/p>\n To quote the documentation, “creates a buffer with a view over the source sequence, causing each enumerator to obtain access to the remainder of the sequence from the current index in the buffer”.<\/p>\n This allows the sequence to be shared via the buffer, in syntax terms this looks like<\/p>\n There is an overloaded method which allows you to supply a selector.<\/p>\n Repeat<\/strong><\/p>\n Allows us to iterate through a sequence infinitely or with the overload, n times<\/p>\n Retry<\/strong><\/p>\n This method allows us to retry enumerating a sequence whilst an error occurs or via the overload we can specify the maximum number of retries<\/p>\n Return<\/strong><\/p>\n The Return method returns a single element as a sequence, for example<\/p>\n this creates an IEnumerable of integers with the single value 1 in it.<\/p>\n Scan<\/strong><\/p>\n Scan generates a sequence using an accumulator, so for example<\/p>\n will pass 3 (i) and 5 (j) into the accumulator method the result will be 8 this will then be pass into the accumulator as i followed by 6 (j) and so on.<\/p>\n SelectMany<\/strong><\/p>\n Several overloads exist, the one shown here simply projects each element of the sequence with a given sequence. For example the following simply projects the array { 5, 6 } over the original sequence<\/p>\n This will output { 5, 6 } the number of times matching the number of elements in the items sequence, i.e. 5 times.<\/p>\n Share<\/strong><\/p>\n A couple of overloads. This method creates a buffer with a shared view over the sequence so mutiple enumerators can be used to fetch the next element from the sequence, this example is a little convoluted<\/p>\n The same sequence is used on Zip and passed into Zip hence we’re zipping the sequence with itself, the result selector simply subtracts one value from the other. When output to the console this will write a sequence 10, 30 because the first item (20) has the second item (10) subtracted from it, as then the next item (60) has the final item (30) subtracted.<\/p>\n SkipLast<\/strong><\/p>\n Allows us to skip\/bypass n elements from the end of in the sequence, thus <\/p>\n lists values 3, 5, 6 but not the last 2 items.<\/p>\n StartWith<\/strong><\/p>\n StartWith starts the sequence with the newly supplied enumerable, for example<\/p>\n will output the sequence 9, 10 then follow with the items sequence.<\/p>\n TakeLast<\/strong><\/p>\n In essence the opposite of SkipLast, TakeLast results in a sequence on the last n items, such as<\/p>\n which outputs 2 and 76.<\/p>\n Throw<\/strong><\/p>\n With the Throw method we can create a sequence which throws an exception when we try to enumerate it, for example<\/p>\n will throw the NullReferenceException when ForEach attempts to enumerate the sequence.<\/p>\n Using<\/strong><\/p>\n Using creates a sequence which has a resource who’s lifetime is determined by the sequence usage. The idea being the resource is created via the Using method’s first argument then passed to the second argument (in all likelihood to be used in some way) before an IEnumerable is returned. The key thing to note is the resource is not created until we use the returned IEnumerable, for example<\/p>\n Assuming SomeDisposable implements IDisposable, when we call GetEnumerator the SomeDisposable is created and passed to the second argument – this rather simplistic example does nothing with the resource but hopefully you get the idea. We then return the IEnumerable and when the GetEnumerator completes the resources Dispose method is called.<\/p>\n While<\/strong><\/p>\n Loops through the sequence whilst a condition is true, so for example<\/p>\n will output the items sequence three times.<\/p>\n","protected":false},"excerpt":{"rendered":" I’m a bit late to the party with this one – Ix or Interactive Extensions. Available on NuGet via the Ix-Main package. This will give us the System.Interactive assembly. Ix are basically a bunch of extension methods for IEnumerable and the EnumerableEx class. I’m sure many of us have written IEnumerable extensions to supply a […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_jetpack_memberships_contains_paid_content":false,"footnotes":""},"categories":[3],"tags":[],"class_list":["post-604","post","type-post","status-publish","format-standard","hentry","category-c"],"jetpack_sharing_enabled":true,"jetpack_featured_media_url":"","_links":{"self":[{"href":"https:\/\/putridparrot.com\/blog\/wp-json\/wp\/v2\/posts\/604","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/putridparrot.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/putridparrot.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/putridparrot.com\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/putridparrot.com\/blog\/wp-json\/wp\/v2\/comments?post=604"}],"version-history":[{"count":32,"href":"https:\/\/putridparrot.com\/blog\/wp-json\/wp\/v2\/posts\/604\/revisions"}],"predecessor-version":[{"id":2325,"href":"https:\/\/putridparrot.com\/blog\/wp-json\/wp\/v2\/posts\/604\/revisions\/2325"}],"wp:attachment":[{"href":"https:\/\/putridparrot.com\/blog\/wp-json\/wp\/v2\/media?parent=604"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/putridparrot.com\/blog\/wp-json\/wp\/v2\/categories?post=604"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/putridparrot.com\/blog\/wp-json\/wp\/v2\/tags?post=604"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}\r\nIEnumerable<int> items = new int[] { 3, 5, 6, 2, 76, 45, 32, 1, 6, 3, 89, 100 };\r\nIEnumerable<IList<int>> lists = items.Buffer(3);\r\n<\/pre>\n\r\nIDictionary<int, IEnumerable<string>> d = new Dictionary<int, IEnumerable<string>>\r\n{\r\n {5, new[] {"Five"}},\r\n {4, new[] {"Four"}},\r\n {1, new[] {"One"}},\r\n {2, new[] {"Two"}},\r\n {3, new[] {"Three"}},\r\n};\r\n\r\nvar matches = EnumerableEx.Case(() => 4, d);\r\n<\/pre>\n\r\nprivate static IEnumerator<int> Factory()\r\n{\r\n yield return 1;\r\n yield return 2;\r\n yield return 3;\r\n yield return 4;\r\n}\r\n<\/pre>\n\r\nvar items = EnumerableEx.Create(Factory);\r\n<\/pre>\n
\r\nvar items = EnumerableEx.Defer(() => new [] { 3, 5, 6, 2 });\r\n<\/pre>\n\r\nIEnumerable<int> GetNegatives()\r\n{ \r\n int[] items = new int[] { -1, -2, 0, -3 };\r\n for (int i = 0; i < items.Length; i++)\r\n {\r\n if (items[i] >= 0)\r\n throw new Exception();\r\n\r\n yield return items[i];\r\n }\r\n}\r\n\r\nIEnumerable<int> items = new int[] { 3, 5, 6, 2, 76, 45, 32, 1, 6, 3, 89, 100 };\r\nIEnumerable<int> e = GetNegatives().Catch(items);\r\n<\/pre>\n\r\nIEnumerable<int> items = new int[] { 3, 5, 6, 2, 76, 45, 32, 1, 6, 3, 89, 100 };\r\nIEnumerable<int> distinct = items.Distinct();\r\n<\/pre>\n\r\nIEnumerable<int> items = new int[] { 3, 3, 3, 5, 5, 2, 76, 76, 100 };\r\nIEnumerable<int> distinct = items.DistinctUntilChanged();\r\n<\/pre>\n\r\nIEnumerable<int> items = new int[] { 3, 5, 6, 2, 76 };\r\nitems.Do(Console.WriteLine);\r\n<\/pre>\n\r\nvar items = new int[] { 3, 5, 6, 2 };\r\n\r\nint i = 0;\r\nvar results = items.DoWhile(() => i++ < 2);\r\nint len = results.Count();\r\n<\/pre>\n\r\nvar items = new [] { 1, 2, 0 };\r\nvar results = items.Expand(i => new[] {i + 1}).Take(9);\r\n<\/pre>\n\r\nIEnumerable<int> items = new [] { 3, 5, 6, 2, 76 };\r\n\r\nitems.Finally(() => Console.WriteLine("Completed")).ForEach(Console.WriteLine);\r\n<\/pre>\n\r\nIEnumerable<int> items = new int[] { 3, 5, 6, 2, 76 };\r\nEnumerableEx.For(items, i => new []{i + 1, i + 2});\r\n<\/pre>\n\r\nIEnumerable<int> items = new int[] { 3, 5, 6, 2, 76 };\r\nitems.ForEach(Console.WriteLine);\r\n<\/pre>\n\r\nEnumerableEx.Generate(10, i => i <= 20, i => i + 1, i => i)\r\n<\/pre>\n
\r\nList<int> items = new List<int> { 3, 5, 6, 2, 76 };\r\n<\/pre>\n\r\nvar result = items.Hide();\r\n<\/pre>\n
\r\nEnumerableEx.If(() => someCondition, new[] { 3, 5, 6, 2, 76 }, new [] {6, 7});\r\n<\/pre>\n\r\nIEnumerable<int> items = new [] { 3, 5, 6, 2, 76 };\r\nvar result = items.IgnoreElements();\r\n<\/pre>\n\r\nIEnumerable<int> items = new [] { 3, 5, 6, 2, 76 };\r\nvar result = items.IsEmpty();\r\n<\/pre>\n\r\nIEnumerable<int> items = new [] { 3, 5, 6, 2, 76 };\r\nvar result = items.IgnoreElements().IsEmpty();\r\n<\/pre>\n\r\nIEnumerable<int> items = new [] { 3, 5, 6, 2, 76 };\r\nvar result = items.Max();\r\n<\/pre>\n\r\nIEnumerable<int> items = new [] { 3, 50, 6, 2, 76 };\r\nitems.MaxBy(i => i < 50).ForEach(Console.WriteLine);\r\n<\/pre>\n\r\nIEnumerable<int> items = new [] { 3, 5, 6, 2, 76 };\r\nvar result = items.Memoize();\r\n<\/pre>\n\r\nIEnumerable<int> items = new [] { 3, 5, 6, 2, 76 };\r\nvar result = items.Max();\r\n<\/pre>\n\r\nIEnumerable<int> items = new [] { 3, 50, 6, 2, 76 };\r\nitems.MinBy(i => i < 50).ForEach(Console.WriteLine);\r\n<\/pre>\n\r\nIEnumerable<int> items = new [] { 3, 50, 6, 2, 76 };\r\nvar result = items.OnErrorResumeNext(new[] {9, 10});\r\n<\/pre>\n\r\nIEnumerable<int> items = new [] { 3, 50, 6, 2, 76 };\r\nvar buffer = items.Publish();\r\n<\/pre>\n\r\nIEnumerable<int> items = new [] { 3, 5, 6, 2, 76 };\r\n\r\n\/\/ iterate over three times\r\nitems.Repeat(3).ForEach(Console.WriteLine);\r\n\r\n\/\/ iterate infinitely\r\nitems.Repeat().ForEach(Console.WriteLine);\r\n<\/pre>\n\r\nitems.Retry(2);\r\n<\/pre>\n
\r\nEnumerableEx.Return(1);\r\n<\/pre>\n
\r\nIEnumerable<int> items = new [] { 3, 5, 6, 2, 76 };\r\nitems.Scan((i, j) => i + j).ForEach(Console.WriteLine);\r\n<\/pre>\n\r\nIEnumerable<int> items = new [] { 3, 50, 6, 2, 76 };\r\nitems.SelectMany(new [] { 5, 6 }).ForEach(Console.WriteLine);\r\n<\/pre>\n\r\nIEnumerable<int> items = new [] { 20, 10, 60, 30 };\r\nitems.Share(x => x.Zip(x, (a, b) => a - b)).ForEach(Console.WriteLine);\r\n<\/pre>\n\r\nIEnumerable<int> items = new [] { 3, 5, 6, 2, 76 };\r\nitems.SkipLast(2).ForEach(Console.WriteLine);\r\n<\/pre>\n\r\nIEnumerable<int> items = new [] { 3, 5, 6, 2, 76 };\r\nitems.StartWith(new []{9, 10}).ForEach(Console.WriteLine);\r\n<\/pre>\n\r\nIEnumerable<int> items = new [] { 3, 5, 6, 2, 76 };\r\nitems.TakeLast(2).ForEach(Console.WriteLine);\r\n<\/pre>\n\r\nEnumerableEx.Throw<int>(new NullReferenceException()).ForEach(Console.WriteLine);\r\n<\/pre>\n
\r\nIEnumerable<int> items = new [] { 3, 5, 6 };\r\nIEnumerable<int> results = EnumerableEx.Using(() => new SomeDisposable(), resource => items);\r\nresults.ForEach(Console.WriteLine);\r\n<\/pre>\n\r\nIEnumerable<int> items = new [] { 3, 5, 6, 2, 76 };\r\n\r\nint i = 0;\r\nEnumerableEx.While(() => i++ < 3, items).ForEach(Console.WriteLine);\r\n<\/pre>\n