I was reading this particular entry from AlexJ's blog, in which he discussed how to use anonymous type returned from one function in another function. I strongly recommend you read it first before reading any further.
Basically, most people would think that there is no easy way to return a strongly typed anonymous type from a function since you wouldn't know what it is that you are returning beforehand. Thus, if you wish to return an anonymous type from a function, you are forced to return it as object like so:
object CreateAnonymousObject()
{
return new { Name = "John Doe" };
}
The problem of doing it like this is that you lost the ability to access the Name property since object does not have a Name property. So, your option is to cast it back to its original anonymous type, but alas, how could you do it?
It turned out that there is a way to do this using generic. If you create a generic function that will return a generic type T and also pass an object of type T in the parameter, you can cast whatever object that you pass as T. In effect, you are using the object of type T as your example to cast the boxed object to. See the following code:
T CastByExample<T>(object source, T example)
{
return (T)source;
}
So now, you can do something like this (for the sake of clarity, I am not going to shorthand these examples):
var o = CreateAnonymousObject();
var prototype = new { Name = "" };
var result = CastByExample(o, prototype);
Console.WriteLine(result.Name); //This should work just fine
To make things a little bit easier to read, we can use the new extension method feature of .NET 3.5 like so:
public static class MyExtensions
{
public static T CastToTypeOf<T>(this object source, T example)
{
return (T)source;
}
}
And rewrite the example to:
var o = CreateAnonymousObject();
var prototype = new { Name = "" };
var result = o.CastToTypeOf(prototype);
Console.WriteLine(result.Name); //This should work just fine.
This is great. I don't know what I am going to use it for, but it's nice to know that I can do it when I need it.
And then, another idea comes to my mind. Hey, what if we need to do similar thing to an anonymous object collection. How could I do that? How could one creata a generic list of anonymous object? As it turned out, Kirill Osenkov already solve this particular problem. You can see it here.
So, let's come up with something interesting to explore this problem. Lets say that you are querying a Contact database through LINQ, but instead of returning the entire Contact fields, you wish to only return some of them.
Making thing simpler, I decided to mock the Contact class like so (too lazy to create a dbml, so I am querying from in-memory object :) ):
public class Contact
{
public string FirstName { get ; set; }
public string LastName { get; set; }
public string PhoneNumber { get; set; }
public string StreetAddress { get; set; }
public string City { get; set; }
}
And here is an example function that will return you a list of Contacts:
IEnumerable<Contact> GetContacts()
{
return new List<Contact> {
new Contact {
FirstName = "John",
LastName = "Doe",
PhoneNumber = "555-5501",
StreetAddress = "123 Lala Lane",
City = "Los Angeles"
},
new Contact {
FirstName = "Jane",
LastName = "Doe",
PhoneNumber = "555-5502",
StreetAddress = "567 Lala Lane",
City = "New York" }
};
}
}
And you only wish to return the FirstName and LastName from your LINQ query like so:
var query = from c in GetContacts()
select new { Name = c.FirstName + " " + c.LastName };
Again, for whatever reason, you really really want to encapsulate this as a method, so, you do something like this:
object GetContactNamesFrom(IEnumerable<Contact> contacts)
{
var query = from c in contacts
select new { Name = c.FirstName + " " + c.LastName };
return query.AsEnumerable();
}
Great! Now you have something that can return a generic collection of an anonymous type. But how can we use this in our own function and allow our function to access the Name property?
Well, combining what we've learnt so far, we can come up with something like this...
First, we know we can now cast something to an anonymous type (sort of) using the generic method CastByExample or CastToTypeOf as seen above.
Second, we need a way to create an anonymous collection.
Let's start with the second one first. We need a way to create an anonymous collection. So let's think about this a bit. i hope you've read the blog post by Kirill by now. If not, well, here is how you do it...
Now you can do something like:
var prototype = new { Name = "" };
var prototypeCollection = CreateEnumerablesByExample(prototype); //This is now a generic collection of anonymous.
What's left for us to do is cast our LINQ result back as the prototypeCollection so we can get access to the Name property from our code like so:
var contactInfo = GetContactNamesFrom(GetContact());
var prototype = new { Name = "" };
var prototypeCollection = CreateEnumerablesByExample(prototype);
var result = contactInfo.CastToTypeOf(prototypeCollection);
foreach (var c in result)
{
Console.WriteLine(c.Name);
};
We can do one better by using extension method. Let's refactor CreateEnumerableFrom as an extension method like so:
public static IEnumerable<T> CreateEnumerablesOfThis<T>(this T prototype)
{
return new List<T>();
}
The refactored code of our final example will look like this:
var contactInfo = GetContactNamesFrom(GetContact());
var prototype = new { Name = "" };
var protoypeCollection = prototype.CreateEnumerablesOfThis();
var result = contactInfo.CastToTypeOf(prototypeCollection);
foreach (var c in result)
{
Console.WriteLine(c.Name);
}
So, why would go through all these trouble? Honestly, I have no idea. I am just exercising my brain just to see if I can do such a thing. I have no real need for this type of things yet. Who knows... maybe someday...
