ToLookup with multiple keys

Question

Is there a way to require multiple keys for the .ToLookup function provided by LINQ?

I will admit that this seems non-intuitive at first, and I'm expecting that there's no actual way to do this, but I'm hoping that someone knows a way.

I basically want to be able to lookup by two values, for example a string and an int, and retrieve the object with those two values.

Example

    public class MyClass {
      public string StringProp {get;set;}
      public int IntProp {get;set;}
      public object MoreData {get;set;}
    }

    public class Main {
      public void Main() {
        HashSet<MyClass> set = new HashSet<MyClass>();
        set.Add(new MyClass {StringProp = "a", IntProp = 1, MoreData = null});
        set.Add(new MyClass {StringProp = "c", IntProp = 4, MoreData = new object()});
        set.Add(new MyClass {StringProp = "a", IntProp = 2, MoreData = "upupdowndown"});
        set.Add(new MyClass {StringProp = "c", IntProp = 1, MoreData = string.Empty});
        set.Add(new MyClass {StringProp = "c", IntProp = 4, MoreData = string.Empty});
        // Using 'var' because I don't know how this would be defined.
        // I recognize that this will not compile - but this is what I'm trying to do.
        var lookup = set.ToLookup(x => x.StringProp && x.IntProp)
        MyClass c = lookup["a", 1].First(); // Should return the first element
        IEnumerable<MyClass> list = lookup["c", 4]; // Should return the 2nd and last elements
      }
    }

Answer 1

I would use Tuples for this sort of thing:

var lookup = set.ToLookup(x => Tuple.Create(x.StringProp, x.IntProp));
MyClass c = lookup[Tuple.Create("a", 1)].First();
IEnumerable<MyClass> list = lookup[Tuple.Create("c", 4)];

Answer 2

So the other answers are along the lines that I was thinking, but it's somewhat cumbersome to be creating a tuple or anonymous class each time you want to just get a value out of the lookup. Wouldn't it be great if you could just stick a string and an int into an indexer to get the value out. By creating your own class to wrap the lookup with an indexer you can do exactly that.

public class MyLookup<T1, T2, TOut>
{
    private ILookup<Tuple<T1, T2>, TOut> lookup;
    public MyLookup(IEnumerable<TOut> source, Func<TOut, Tuple<T1, T2>> keySelector)
    {
        lookup = source.ToLookup(keySelector);
    }

    public IEnumerable<TOut> this[T1 first, T2 second]
    {
        get
        {
            return lookup[Tuple.Create(first, second)];
        }
    }

    //feel free to either expose the lookup directly, or add other methods to access the lookup
}

Here is an example of it being used:

IEnumerable<MyClass> data = null; //TODO populate with real data
var lookup = new MyLookup<string, int, MyClass>(data
    , item => Tuple.Create(item.StringProp, item.IntProp));

IEnumerable<MyClass> someValue = lookup["c", 4];