在接受泛型的方法上使用匿名类型

Question

I have an OrderMapper class which I use as follows:

OrderMapper<Post> m = OrderMapper.For<Post>().Add("title", x => x.Title);

Where x is of type Post. The problem is when applying it to anonymous types.

var listOfAnonymousObjects = posts.SelectMany(x => x.PostsI18N, (Post, PostI18N) => new { Post, PostI18N });

OrderMapper<??> m = OrderMapper.For<??>().Add("title", x => x.Title);

Where x must be of type AnonymousObject in listOfAnonymousObjects. My OrderMapper code is:

public class OrderMapper {
  public static OrderMapper<T> For<T>() {
    return new OrderMapper<T>();
  }
}

public class OrderMapper<T> {

  private readonly Dictionary<String, LambdaExpression> _mappings = new Dictionary<String, LambdaExpression>();

  public OrderMapper<T> Add<K>(String source, Expression<Func<T, K>> target) {

    if (!_mappings.ContainsKey(source))
      _mappings.Add(source, target);
    return this;
  }

  public LambdaExpression this[String source] {
    get {
      LambdaExpression target;
      return _mappings.TryGetValue(source, out target) ? target : null;          
    }
  } // this

}

How to do this?

Answer 1

You can take advantage of type inference, but that requires you to pass along an instance. This could do:

public static OrderMapper<T> ForFromEnumerable<T>(IEnumerable<T> dummy)
{
    return new OrderMapper<T>();
}

Usage:

var m = OrderMapper.ForFromEnumerable(listOfObjectsOfTypeY).Add("title", x => x.Title);

Answer 2

You're much better off using concrete types - just project your anonymous-returning linq queries to a concrete type.

If you must support it, you're probably going to have to resort to dynamic

// no compile-time checking here.
OrderMapper<dynamic> m = OrderMapper.For<dynamic>().Add("title", x => x.Title);