"To pass an anonymous type, or a collection that contains anonymous types, outside a method boundary, you must first cast the type to object."

This isn't entirely true. Consider this helper method:

public static List<T> ListOfType<T>(this T type)
{
 return new List<T>();
}

This allows you to write:

var v = new { Amount = 108, Message = "Hello" };

var listOfV = ListOfType(v);

listOfV.Add(v);

I just passed a new strongly-typed List<some_anonymous_type> out of a method without casting it to object.

You can also cast object to an anonymous type using the following helper method:

T Cast<T>(object obj, T type)
{
  return (T)obj;
}

So even if you return the anonymous type from a method by casting to object, you can use it strongly typed like this:

var v = Cast(ThisReturnsAnonymousTypeAsObject(), new { Amount = 0, Message = "" });

if(v.Message == "Hello") ...

See "Can't return anonymous type from method? Really?" for more details:

http://tomasp.net/blog/cannot-return-anonymous-type-from-method.aspx

The need to return anonymous type can emerge e.g. while refactoring long methods with Linq code: trying to extract some Linq code into a new method

While the trick to return anonymous types is interesting by a technological point of view, it do lead to poor quality code (hard to read, error prone).

When I need to return an anonymous type, I do declare and use a real type with just automatic properties and without constructors and use that.
It work fine even with Linq2Sql (the Sql execution plan will not change because of the refactoring).
The resulting code is easy to read/understand and is type-safe.


IMHO The difference between a good programmer and a bad one is that a good programmer always strives to do things the straight way while a bad programmer feels smart when he discover and use dirty tricks

Edit: I doubt that was a useful comment. Using anonymous types in-fact reduces code thus making programmers more efficent. Creating a type class for each Linq query is definately unruly. Gawd forbid you needed to update that code. Now you have to make changes everywhere you use that typed class versus just changing the Linq query. BTW, anonymous types are strongly typed. Its called <>f__Anonymous....

The below code is what I came up with when I was trying to figure out how to iterate anonymous types from a different class. This idea is useful as it combines CompiledQuery.Query and multiple return tables. Basically this could be done with a view, or a stored procedure; but the challenge I had was doing it all through LINQ.
It should be pretty self-explanatory (I think) once you figure it out. For ease of use for this example, I put both my static Main and GetItems() in the same class MyTest.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data.Linq;
namespace MyNamespace
{
public sealed class MyTest
{
public static void Main()
{
MyContext context = new MyContext();
var output = GetItems();
foreach (var item in output.ToList())
{
Console.WriteLine(item);
}
Console.Read();
}
/// <summary>
/// Returns an iterator for an anonymous method
/// </summary>
/// <returns></returns>
public static IEnumerable<Object> GetItems()
{
var returnCode =
CompiledQuery.Compile((MyContext dc) =>
from p in dc.Table1
join f in dc.Table2 on p.ID equals f.table1ID
select new
{
p,
f
});
var output = returnCode;
MyContext context = new MyContext();
foreach (var o in output.Invoke(context))
{
yield return o.f.table1ID;
yield return o.p.ID;
}
}
}
}

"If two or more anonymous types have the same number and type of properties in the same order, the compiler treats them as the same type and they share the same compiler-generated type information."

This is not correct. In fact, the property names play into this as well, otherwise anonymous types would be dangerous. Look at this code:

var

type1 = new {lastName = "James", email = "junk@domain.com", age = 30};

var

type2 = new {companyName = "TechRepublic", domainName = "www.techrepublic.com", yearsInBusiness = 20 };

var

type1SecondVar = new { lastName = "Washington", email = "firstpres@whitehouse.gov", age = 200 };

Console

.WriteLine(type1.GetType());

Console

.WriteLine(type2.GetType());

Console

.WriteLine(type1SecondVar.GetType());

Console

.ReadLine();

It produces the following output:

<>f__AnonymousType0`3[System.String,System.String,System.Int32]
<>f__AnonymousType1`3[System.String,System.String,System.Int32]
<>f__AnonymousType0`3[System.String,System.String,System.Int32]

Clearly, the property names play into whether or not the compiler treats them as the same type.