Handling related generic type parameters

Question

In answering a question on StackOverflow, it occurred to me that a more generic version of GroupBy for C# that delegated membership in each group to a class could be useful.

This is my attempt, but I am unsatisfied with a few things. I don't particularly like the need to constrain the element type to IOrderable - I feel like it should be possible to delegate ordering to the group type somehow (I really wanted a static method constraint in the IGGrouping interface).

public interface IOrderable<T> {
    double ordering();
}

public interface IGGrouping<T> : IEnumerable<T> where T : IOrderable<T> {
    bool BelongsToGroup(T aT);
    IGGrouping<T> Add(T aT);
}

public static class IEnumerableExt {
    public static IEnumerable<IGGrouping<T>> GroupBy<TG,T>(this IEnumerable<T> src) where TG : IGGrouping<T>, new() where T : IOrderable<T> {
        var groups = new List<IGGrouping<T>>();
        void Add(T aT) {
            var found = false;
            foreach (var g in groups) {
                found = g.BelongsToGroup(aT);
                if (found) {
                    g.Add(aT);
                    break;
                }
            }
            if (!found)
                groups.Add(new TG().Add(aT));
        }

        foreach (var s in src.OrderBy(s => s.ordering()))
            Add(s);

        return groups;
    }
}

Here's a sample class to group by distance from center of current groups:

public class gRectangleGroup : IGGrouping<Rectangle> {
    List<Rectangle> members;
    public Point center;

    public gRectangleGroup() {
        members = new List<Rectangle>();
    }

    public gRectangleGroup Add(Rectangle r) {
        members.Add(r);
        center = new Point(members.Average(m => m.Loc.X), members.Average(m => m.Loc.Y));
        return this;
    }

    public bool BelongsToGroup(Rectangle r) => center.Distance(r.Loc) <= 5;

    public Rectangle Middle() => members.OrderBy(m => m.Loc.Distance(center)).First();

    public IEnumerator<Rectangle> GetEnumerator() => members.GetEnumerator();
    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();

    IGGrouping<Rectangle> IGGrouping<Rectangle>.Add(Rectangle aT) => Add(aT);
}

You use gRectangleGroup like so:

List<Rectangle> list;

var ans2 = list.GroupBy<gRectangleGroup, Rectangle>().Cast<gRectangleGroup>().Select(rg => rg.Middle());

I don't like having to list the group type and the element type explicitly in the call to GroupBy. I don't like the Cast to gRectangleGroup when the type is passed to the GroupBy, but if GroupBy returns TG then I have to give up the fluent Add call for new groups.

I also don't like how a class that implements IGGrouping (like gRectangleGroup) and has a fluent Add that returns this, must also have another Add to return IGGrouping<T> because of the interface.

Can anyone suggest how this might be improved, or what they would change to solve the same issue?

Answer 1

You don't need the type parameter on IOrderable:

  public interface IOrderable
  {
    double Ordering();
  }

---

I don't like that you sort the source vector without notifying the client. In this way mysterious things are going on and the method does more than one thing. At least you should have a flag argument that lets the client determine if the source should be sorted or not before grouping:

public static IEnumerable<IGGrouping<T>> GroupBy<TG, T>(this IEnumerable<T> src, bool sortBeforeGrouping = false) where TG : IGGrouping<T>, new() where T : IOrderable
{
  var groups = new List<IGGrouping<T>>();

  ...
}

Alternatively you should rename the method to SortAndGroupBy(...). But I would let it total up to the client if the source should be sorted or not.

---

I think the inner of the internal Add(...) function can be simplified a bit:

  void Add(T aT)
  {
    var group = groups.FirstOrDefault(g => g.BelongsToGroup(aT));
    if (group == null)
    {
      group = new TG();
      groups.Add(group);
    }
    group.Add(aT);
  }

---

On way to get rid of the custom interfaces is to let the group type implement ICollection<T> and then inject the belongsToGroup function:

public static IEnumerable<TKey> GroupBy<TKey, TElement>(this IEnumerable<TElement> source, Func<TElement, TKey, bool> belongsToGroup) where TKey : ICollection<TElement>, new()
{
  return source.Aggregate(new List<TKey>(), (groups, e) =>
  {
    TKey group = groups.FirstOrDefault(g => belongsToGroup(e, g));
    if (group == null)
    {
      group = new TKey();
      groups.Add(group);
    }
    group.Add(e);
    return groups;
  });

}

Usage

  Func<Rectangle, RectangleGroup, bool> belongsToGroup = (r, gr) => gr.BelongsToGroup(r);
  var midPoints = list.OrderBy(r => r).GroupBy(belongsToGroup).Select(gr => gr.Middle());
  foreach (var middle in midPoints)
  {
    Console.WriteLine(middle);
  }

---

If that isn't good enough then you can inject the addToGroup function too:

public static IEnumerable<TKey> GroupBy<TKey, TElement>(this IEnumerable<TElement> source, Func<TElement, TKey, bool> belongsToGroup, Action<TElement, TKey> addToGroup) where TKey : new()
{
  List<TKey> groups = new List<TKey>();

  foreach (TElement element in source)
  {
    TKey group = groups.FirstOrDefault(g => belongsToGroup(element, g));
    if (group == null)
    {
      group = new TKey();
      groups.Add(group);
    }

    addToGroup(element, group);
  }

  return groups;
}

Usage

  Func<Rectangle, RectangleGroup, bool> belongsToGroup = (r, gr) => gr.BelongsToGroup(r);
  Action<Rectangle, RectangleGroup> adder = (r, gr) => gr.Add(r);
  var midPoints= list.OrderBy(r => r).GroupBy(belongsToGroup, adder).Select(gr => gr.Middle());
  foreach (var middle in midPoints)
  {
    Console.WriteLine(middle);
  }