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));
