private static Grouping <TKey, TElement> CreateGroupAdjacentGrouping <TKey, TElement>( TKey key, IList <TElement> members) { Debug.Assert(members != null); return(Grouping.Create(key, members.IsReadOnly ? members : new ReadOnlyCollection <TElement>(members))); }
public static IGrouping <TKey, TSource> MinBy <TSource, TKey>(this IEnumerable <TSource> source, Func <TSource, TKey> selector, IComparer <TKey> comparer = null) { comparer = comparer ?? Comparer <TKey> .Default; using (var sourceIterator = source.GetEnumerator()) { if (!sourceIterator.MoveNext()) { return(null); } var MinimumElement = sourceIterator.Current; var MinimumKey = selector(MinimumElement); var MinimumElements = new List <TSource> { MinimumElement }; while (sourceIterator.MoveNext()) { var CurrentElement = sourceIterator.Current; var CurrentKey = selector(CurrentElement); var CompareValue = comparer.Compare(CurrentKey, MinimumKey); if (CompareValue < 0) { MinimumKey = CurrentKey; MinimumElements = new List <TSource> { CurrentElement }; } else if (CompareValue == 0) { MinimumElements.Add(CurrentElement); } } return(Grouping.Create(MinimumKey, MinimumElements)); } }
public static IQueryable <T> AutoIndex <T>(this IQueryable <T> items) { var getters = typeof(T).GetProperties() .Select(p => new { p.Name, func = new Func <T, object>(t => p.GetValue(t)) }) .ToDictionary(pair => pair.Name, pair => pair.func); Func <T, string, object> getValueFromObj = (o, s) => getters[s].Invoke(o); var lookups = new Dictionary <string, ILookup <object, T> >(); var groupingLookups = new Dictionary <string, object>(); return(new DelegateQueryable <T>(qi => { Func <IEnumerable <Where> > whereClauses = () => qi.Clauses.OfType <Where>().Where(c => c.Operator == "Equal"); IQueryable <T> filteredItems = items; List <string> propertyNames = new List <string>(); for (var whereClause = whereClauses().FirstOrDefault(); whereClause != null; whereClause = whereClauses().FirstOrDefault()) { propertyNames.Add(whereClause.PropertyName); var lookupKey = string.Join(".", propertyNames); filteredItems = LookupsForPropertyName(lookups, lookupKey, filteredItems, whereClause.PropertyName, whereClause.Value, getValueFromObj); qi.Clauses = qi.Clauses.Except(new[] { whereClause }).ToArray(); } var data = qi.ApplyTo(filteredItems); if (qi.GroupBy != null) { if (!groupingLookups.ContainsKey(qi.GroupBy.KeyName)) { var lookupKey = qi.GroupBy.KeyName; if (!lookups.ContainsKey(lookupKey)) { ILookup <object, T> lookup; if (!lookups.TryGetValue(lookupKey, out lookup)) { lookup = filteredItems.ToLookup(d => (object)getters[lookupKey].Invoke(d), d => d); lookups[lookupKey] = lookup; } } var groupings = lookups[lookupKey].Select(l => Grouping.Create(qi.GroupBy.KeyType, typeof(T), l.Key, l.Cast <object>())); groupingLookups[qi.GroupBy.KeyName] = groupings.ToArray().AsQueryable().Cast <Grouping>(); } return groupingLookups[qi.GroupBy.KeyName]; } return data; })); }
public void Create_ReturnsGrouping(object key, IEnumerable <object> values) { var sut = Grouping.Create(key, values); var grouping = sut.ShouldBeOfType <Grouping <object, object> >(); grouping.ShouldSatisfyAllConditions( () => grouping.Key.ShouldBe(key), () => grouping.AsEnumerable().ShouldBe(values)); }
public void GetEnumerator_ReturnsEquivalentGroupings( [Frozen] NameValueCollection nvc, NameValueLookup sut) => sut.AsEnumerable().ShouldBe(nvc.AllKeys .Select(key => Grouping.Create(key, nvc.GetValuesSafe(key))));
public void Create_NullValuesThrowsArgumentNullException(object key) => Should.Throw <ArgumentNullException>(() => Grouping.Create <object, object>(key, null));
public void Create_NullKeyDoesNotThrow(IEnumerable <object> values) => Should.NotThrow(() => Grouping.Create((object)null, values));