Question

Consider this:

var me = new { FirstName = 'John', LastName = 'Smith' }; 

This is fine as we can then do this:

Console.WriteLine('{0} {1}', me.FirstName, me.LastName); 

However we can’t do this:

public T GetMe() {     return new { FirstName = 'John', LastName = 'Smith' }; } 

because we don’t know the type of T.

We could do this:

public object GetMe() {     return new { FirstName = 'John', LastName = 'Smith' }; } 

but then we’d have to inspect the properties of the object using reflection in order to access them:

var p = new Prog(); object o = p.GetMe(); Type t = o.GetType(); foreach (var prop in t.GetProperties()) {     Console.WriteLine(prop.Name + ': ' + prop.GetValue(o, null)); } 

However what about if we could name an anonymous type as we define it? Of course it would no longer be anonymous, however it would be more succinct and maintainable than a normal class definition.

Consider this:

public Person GetMe() {     return new public class Person { FirstName = 'John', LastName = 'Smith' }; } 

The benefit being it would then be possible to return the result of a complicated Linq query from a method without having to define the class explicitly.

Consider this relatively complex Linq query:

List<int> list = new List<int>(); var query = from number in list             select                 new                     {                         Number = number,                         Square = number*number,                         Absolute = Math.Abs(number),                         Range = Enumerable.Range(0, number)                     }; 

Instead of defining a class like so:

public class MyNumbers {     public int Number { get; set; }     public int Square { get; set; }     public int Absolute { get; set; }     public IEnumerable<int> Range { get; set; } } 

in order to return the query variable from a method we could instead just do this:

List<int> list = new List<int>(); return from number in list             select new public class MyNumbers                     {                         Number = number,                         Square = number*number,                         Absolute = Math.Abs(number),                         Range = Enumerable.Range(0, number)                     }; 

Answer 1

Actually, there’s a ‘hack’ that you can do to get an anonymous type back from a method. Consider this:

public object MyMethod()     {         var myNewObject = new         {             stringProperty = 'Hello, World!',             intProperty = 1337,             boolProperty = false         };          return myNewObject;     }      public T Cast<T>(object obj, T type)     {         return (T)obj;     } 

You can now do this:

var obj = MyMethod(); var myNewObj = Cast(obj, new { stringProperty = '', intProperty = 0, boolProperty = false }); 

The myNewObj will now be an object of the same Type as the anonymous type.