Generic Method with generic return

Question

Well, I have the following scenario:

public class Joins<TOuter, TInner, TResult>
{
    public Expression<Func<TOuter, object>> outerKeySelector;
    public Expression<Func<TInner, object>> innerKeySelector;
    public Expression<Func<TOuter, TInner, object>> resultSelector;

    public IEnumerable<TResult> r;

}

public class Test<T>
{
    public IEnumerable<TResult> Join<TInner, TResult>(
        Expression<Func<T, object>> outerKeySelector,
        Expression<Func<TInner, object>> innerKeySelector,
        Expression<Func<T, TInner, TResult>> resultSelector) where TInner : class
    {
        var join = new Joins<T, TInner, TResult>();
        join.innerKeySelector = innerKeySelector;
        join.outerKeySelector = outerKeySelector;

        return join.r;
    }
}

To create the join method, I relied on the link: http://msdn.microsoft.com/en-us/library/bb534644(v=vs.100).aspx

However, when I try to invoke the method, TInner is not recognized, making the method becomes invalid me returning the following error:

Cannot convert expression type 'type' to return type 'TResult'

Note: The class 'Joins' is purely a test, none of it is definitive and the var 'r' is for testing only, used only to facilitate the return.

Example of intended use:

var test = new Test<User>().Join<Permission>(u => u.Id, p => p.IdUser, (u, p) => new { Id = u.Id , Area = p.Area });

More details:

As mentioned, TInner is not recognized, so I can not make a call the correct method.

As a test I did so:

var test = new Test<User>().Join<Permission>(u => u.Id, p => p.ToString(), (u, p) => new {Id = u.Id, Name = p.ToString()});

I know p.ToString() is not correct, but is not recognizing the properties of the class indicated (in the case Permission), then put ToString() just to finish writing the method.

EDIT:

I need to use the result in a foreach/for

example:

foreach(var obj in test)
{
    var id = obj.Id;
    var area = obj.Area;
    .
    .
    .
}

Answer 1

To make it work, you should do the following:

 var test = new Test<User>().Join<Permission, object>(u => u.Id, p => p.IdUser, (u, p) => new { Id = u.Id, Area = p.Area });
 //                                           ^^ (resolve the second type argument as well)     

When you define the following:

public TResult Join<TInner, TResult>

then you should either give compiler a hint which type there will be (instead of any, mentioned as type argument: TInner, TResult) explicitly, or it must be somehow recognized automatically by compiler (and then you can ommit it from explicit definition), but in your case you must do that explicitly.

---

Have a look of this answer. Even though that question is also related to extension methods, there is a pretty good explanation of the logic with the type arguments to resolve.

EDIT:

But object, for sure, is not the best decision, as you can not do anything with that object later (especially, if that's an anonymous type).

So, you should change it, for instance, in the following way:

    public class Test<T, TInner> where TInner : class where T : class 
    {
        public IEnumerable<TResult> Join<TResult>(

        ...

            Expression<Func<T, TInner, TResult>> resultSelector)

after that you can use it as follows:

var test = new Test<User, Permission>()
                .Join(u => u.Id, p => p.IdUser, (u, p) => new { Id = u.Id, Area = p.Area });

EDIT:

if you need the TInner and TResult to be passed to Join method, that's not really possible. The anonymous class can be resolved only automatically by compiler - you can not specify it explicitly.

So, the only way you can solve it then, as the following:

var test = new Test<User>().Join<Permission, dynamic>(...

that would allow you to use your result then with LinQ .Where( method, however, without intellisense support (unless, you create a concrete class for the Join output).