Adding elements together across inherited arrays, LINQ

Question

Following up on a previous question, here is my general class structure..

http://stackoverflow.com/questions/3711224/combine-elements-in-a-list-based-on-type-and-summate-their-values-linq

I am trying to combine the items using their respective .Add methods, but because of Entity Framework considerations, I can only deal with base types (Not interfaces).

 using System.Linq;
using System.Collections.Generic;

interface Item<T>
{
    T Add(T item);
}
abstract class Item
{
    public ItemType Type;
    public int Value;
}

class SubItemOne : Item, Item<SubItemOne>
{
    public int Additional { get; set; }
    public SubItemOne Add(SubItemOne item)
    {
        // ..
    }
}

class SubItemTwo : Item, Item<SubItemTwo>
{
    public int MoreData { get; set; }
    public int OtherData { get; set; }

    public SubItemTwo Add(SubItemTwo item)
    {
        // ...
    }
}

class SubItemThree : Item, Item<SubItemThree>
{
    public int StillOtherData { get; set; }
    public int SecondaryData { get; set; }
    public int TertiaryData { get; set; }

    public SubItemThree Add(SubItemThree item)
    {
        // ...
    }
}

class ItemType
{
    public string Name;
}

class Test
{
    public static void Main()
    {
        List<ItemType> types = new List<ItemType>();
        types.Add(new ItemType { Name = "Type1" });
        types.Add(new ItemType { Name = "Type2" });
        types.Add(new ItemType { Name = "Type3" });

        List<Item> items = new List<Item>();

        for (int i = 0; i < 10; i++)
        {
            items.Add(new SubItemOne
            {
                Type = types.Single(t => t.Name == "Type1"),
                Additional = i
            });
        }

        for (int i = 0; i < 10; i++)
        {
            items.Add(new SubItemTwo
            {
                Type = types.Single(t => t.Name == "Type2"),
                MoreData = 10,
                OtherData = i + 10
            });
        }

        for (int i = 0; i < 10; i++)
        {
            items.Add(new SubItemThree
            {
                Type = types.Single(t => t.Name == "Type3"),
                SecondaryData = 1000,
                StillOtherData = 1874,
                TertiaryData = i * 10
            });
        }

        List<Item> combined = new List<Item>();

        // create a list with 3 items, one of each 'type', with the sum of the total values of that type.
        // types included are not always known at runtime.

        // I am trying to invoke the .Add Method on the items so that they can be collatted together. However
        // they all return as the base type.
    }
}

Answer 1

The problem is that you're going to have to deal with the interfaces at a higher level, and thus won't be able to do so generically (i.e., using the generic type arguments). You're going to have to define a non-generic interface (even if it's in addition to your current generic interface) that these classes implement in order to do what you're after. Item<SubItemOne> is no more related to Item<SubItemTwo> in terms of assignment compatibility than string is to DateTime.

If you must do it this way, then you'll have to use reflection. This should do the trick:

Dictionary<ItemType, Item> sum = new Dictionary<ItemType, Item>();

foreach (var item in items)
{
    Item currSum;

    if (sum.TryGetValue(item.Type, out currSum))
    {
        sum[item.Type] = (Item)item.GetType().GetInterfaces().Single(
            i => i.Name == "Item").GetMethod("Add")
        .Invoke(currSum, new object[] { item });
    }
    else
    {
        sum.Add(item.Type, item);
    }
}

List<Item> combined = sum.Values.ToList();

Answer 2

To detail on how the problem was solved. I would like to thank both people who assisted with this answer, (also I want to thank jarret, from my previous question involving the linq query) for helping me to get the resolution entirely.

I have found both solutions to run substantially well, though I do not like the Microsoft.CSharp.dll library staring at me in The Resources folder (I know you're there, even if I collapse you! Don't try to deny it!)

In all, LINQ continues to amaze me, but I was shocked and astounded that dynamic worked more than anything. To test, I threw a "NotImplementedException" in each of the three derivitive classes "Add" methods and ran the entire execution, when the compiler broke out to show the Exception, it was in the appropriate class. This tested true in both cases.

Additionally, this showed that parameters are in fact different from names when it comes to implementation initialization where reflection is concerned. I tested the same for creating an interface IItem and IItem<T> and got the same results. (Additionally, IItem`1 also yielded the same results when IItem<T> was the implemented interface).

Each time I get an answer from Stackoverflow, it continues to amaze and astound me that no matter how much I think I know, there are so many people that know more, but not only that, that they are browsing the same resource sites that I am, and willing to answer such piddly questions that eat up their time and resources. Thanks again to all of you who helped!

Using Adam Robinson's Method, I approached it from this angle.

        var grouped = items.GroupBy(i => i.Name);

        grouped.ForEach(x => {
            x.ForEach(e => {
                // results handled here
                // assumes that all objects inheriting "Item" implement IItem, which contracts "Add" method.
                e.GetType().GetInterfaces().First(i => i.Name == "IItem").GetMethod("Add").Invoke(e, new object[] { e });
            });
        });

Using arootbeer's answer.

        var grouped = items.GroupBy(i => i.Name);

        grouped.ForEach(x => {
            x.ForEach(e => {
                // results handled here
                ((dynamic)e).Add((dynamic)e);
            });
        });