Tuesday, August 26, 2008

And then you hit the wall.

So as this dynamic nonsense continues, there is a sticking point to how much fun I can have. The wall? Anonymous types and generic declarations.

Here's the old:
  Func<User, Int32> selectUserID = currentUser => currentUser.UserID;
Great if I want to select userIDs, but what if I want UserIDs AND UserNames... Easy right?
 userList.Select(currentUser => new { currentUser.ID, currentUser.UserName });
Now this is the old way, but I want the new way... IE the Func way. Problem is here
  Func<User, EHH??> selectUserID = currentUser =>  new { currentUser.ID, currentUser.UserName };
You see, there's a problem. What the hell do I put at the return type? Fact is, without creating a method that passes back a Func or a class that has UserName and UserID properties, I'm screwed. Now from what I read here I think I get it. First take the func:
  Func<K, T>
I have K and T that the compiler has to figure out what they are. Well it's safe to say in the example User is K, but what is T? Well it has to figure that out from the Lamdba expression. The lambda expression has no idea what it is because it's an anonymous type. So why not just use var?
  Func<User, var>
Seems easy enough. I don't have to know the type because of var right? Wellll problem is the compiler is looking at the lambda expression to figure out what var will be. Mr. Lambda expression can't really figure out the type either. Enter the wall. Currently there is no way around this without methods or classes created. Supposedly there are things called Mumble Types on the way that will solve this problem.

No comments: