collection-iterable-methods/CollectionIterableAsync.cs at main · johnny-quesada-developer/collection-iterable-methods · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
namespace CollectionIterableAsync
{
    using System;
    using System.Collections.Generic;
    using CollectionIterable;
    using CollectionIterableParallel;
    using CollectionIterableUtils;

    public static class CollectionIterableAsync
    {
        #region Concat

        internal static Task<IEnumerable<T>> ConcatCommonAsync<T>(IEnumerable<T> first, IEnumerable<T> second, IIterableOptions? options = null)
        {
            return Task.Run(() => CollectionIterable.ConcatCommon(first, second, options));
        }

        public static Task<IEnumerable<T>> ConcatAsync<T>(this T[] first, T[] second, IIterableOptions? options = null)
        {
            return ConcatCommonAsync(first: first, second, options);
        }

        public static Task<IEnumerable<T>> ConcatAsync<T>(this ICollection<T> first, ICollection<T> second, IIterableOptions? options = null)
        {
            return ConcatCommonAsync(first: first, second, options);
        }

        public static Task<IEnumerable<T>> ConcatAsync<T>(this IEnumerable<T> first, IEnumerable<T> second, IIterableOptions? options = null)
        {
            return ConcatCommonAsync(first: first, second, options);
        }

        #endregion

        #region Filter

        internal static Task<IEnumerable<T>> FilterCommonAsync<T>(IEnumerable<T> source, Func<T, Int32, bool> callback, IIterableOptions? options)
        {
            return Task.Run(() => CollectionIterable.FilterCommon(source, callback, options));
        }

        public static Task<IEnumerable<T>> FilterAsync<T>(this T[] source, Func<T, Int32, Boolean> callback, IIterableOptions? options = null)
        {
            return FilterCommonAsync(source, callback, options);
        }

        public static Task<IEnumerable<T>> FilterAsync<T>(this T[] source, Func<T, Boolean> callback, IIterableOptions? options = null)
        {
            return FilterCommonAsync(source, (item, index) => callback(item), options);
        }

        public static Task<IEnumerable<T>> FilterAsync<T>(this ICollection<T> source, Func<T, Int32, Boolean> callback, IIterableOptions? options = null)
        {
            return FilterCommonAsync(source, callback, options);
        }

        public static Task<IEnumerable<T>> FilterAsync<T>(this ICollection<T> source, Func<T, Boolean> callback, IIterableOptions? options = null)
        {
            return FilterCommonAsync(source, (item, index) => callback(item), options);
        }

        public static Task<IEnumerable<T>> FilterAsync<T>(this IEnumerable<T> source, Func<T, Int32, Boolean> callback, IIterableOptions? options = null)
        {
            return FilterCommonAsync(source, callback, options);
        }

        public static Task<IEnumerable<T>> FilterAsync<T>(this IEnumerable<T> source, Func<T, Boolean> callback, IIterableOptions? options = null)
        {
            return FilterCommonAsync(source, (item, index) => callback(item), options);
        }

        #endregion

        #region FilterParallel

        internal static Task<IEnumerable<T>> FilterParallelCommonAsync<T>(IEnumerable<T> source, Func<T, Boolean> callback, IIterableOptions? options = null)
        {
            return Task.Run(() => CollectionIterableParallel.FilterParallelCommon(source, callback, options));
        }

        public static Task<IEnumerable<T>> FilterParallelAsync<T>(this T[] source, Func<T, Boolean> callback, IIterableOptions? options = null)
        {
            return FilterParallelCommonAsync(source, callback, options);
        }

        public static Task<IEnumerable<T>> FilterParallelAsync<T>(this ICollection<T> source, Func<T, Boolean> callback, IIterableOptions? options = null)
        {
            return FilterParallelCommonAsync(source, callback, options);
        }

        public static Task<IEnumerable<T>> FilterParallelAsync<T>(this IEnumerable<T> source, Func<T, Boolean> callback, IIterableOptions? options = null)
        {
            return FilterParallelCommonAsync(source, callback, options);
        }

        #endregion

        #region ForEachAsync

        internal static Task ForEachCommonAsync<T>(IEnumerable<T> source, Action<T, Int32> callback, IIterableOptions? options)
        {
            return Task.Run(() => CollectionIterable.ForEachCommon(source, callback, options));
        }

        public static Task ForEachAsync<T>(this T[] source, Action<T, Int32> callback, IIterableOptions? options = null)
        {
            return ForEachCommonAsync(source, callback, options);
        }

        public static Task ForEachAsync<T>(this T[] source, Action<T> callback, IIterableOptions? options = null)
        {
            return ForEachCommonAsync(source, (item, index) => callback(item), options);
        }

        public static Task ForEachAsync<T>(this ICollection<T> source, Action<T, Int32> callback, IIterableOptions? options = null)
        {
            return ForEachCommonAsync(source, callback, options);
        }

        public static Task ForEachAsync<T>(this ICollection<T> source, Action<T> callback, IIterableOptions? options = null)
        {
            return ForEachCommonAsync(source, (item, index) => callback(item), options);
        }

        public static Task ForEachAsync<T>(this IEnumerable<T> source, Action<T, Int32> callback, IIterableOptions? options = null)
        {
            return ForEachCommonAsync(source, callback, options);
        }

        public static Task ForEachAsync<T>(this IEnumerable<T> source, Action<T> callback, IIterableOptions? options = null)
        {
            return ForEachCommonAsync(source, (item, index) => callback(item), options);
        }

        #endregion

        #region ForeachParallel

        internal static void ForeachParallelCommonAsync<T>(IEnumerable<T> source, Action<T> callback, IIterableOptions? options = null)
        {
            Task.Run(() => CollectionIterableParallel.ForEachParallelCommon(source, callback, options));
        }

        public static void ForeachParallel<T>(this T[] source, Action<T> callback, IIterableOptions? options = null)
        {
            ForeachParallelCommonAsync(source, callback, options);
        }

        public static void ForeachParallel<T>(this ICollection<T> source, Action<T> callback, IIterableOptions? options = null)
        {
            ForeachParallelCommonAsync(source, callback, options);
        }

        public static void ForeachParallel<T>(this IEnumerable<T> source, Action<T> callback, IIterableOptions? options = null)
        {
            ForeachParallelCommonAsync(source, callback, options);
        }

        #endregion
    }
}