Horrible grotty hack: returning an anonymous type instance

re: Horrible grotty hack: returning an anonymous type instance

James Newton-King — Sat, 07 Feb 2009 09:51:08 GMT

I added a method to Json.NET that uses this technique last year.

T JsonConvert.DeserializeAnonymous<T>(string json, T anon)

It deserializes the JSON into instances of the anonymous type. Hacky but it works :)

Reflective Perspective - Chris Alcock » The Morning Brew #262

Reflective Perspective - Chris Alcock » The Morning Brew #262 — Mon, 12 Jan 2009 08:13:44 GMT

Pingback from Reflective Perspective - Chris Alcock » The Morning Brew #262

re: Horrible grotty hack: returning an anonymous type instance

skeet — Sun, 11 Jan 2009 12:20:46 GMT

@lubos: That wouldn't just be an internal implementation change - it would be a *specification* change. There's nothing here which isn't guaranteed by the spec.

re: Horrible grotty hack: returning an anonymous type instance

lubos — Sun, 11 Jan 2009 11:40:49 GMT

It makes sense but when they change internal implementation of anonymous types, nobody who uses it, should be surprised of sudden InvalidCastExceptions... :)

re: Horrible grotty hack: returning an anonymous type instance

Chris Mullins — Sat, 10 Jan 2009 20:00:57 GMT

Wow. That it an interesting idea.

My head hurts thinking of the evil, obfuscated, and intentionally confusing code that is possible with this...

re: Horrible grotty hack: returning an anonymous type instance

Erik — Fri, 09 Jan 2009 23:41:55 GMT

Meh. That's what I get for not reading the spec.

re: Horrible grotty hack: returning an anonymous type instance

skeet — Fri, 09 Jan 2009 19:48:36 GMT

@Erik: No, it's not implementation-dependent. The compiler-generated name is, but the language spec guarantees that two anonymous object creation expressions using the same property names and compile-time types within the same assembly will create instances of the same type. See section 7.5.10.6 of the C# 3.0 spec.

re: Horrible grotty hack: returning an anonymous type instance

Erik — Fri, 09 Jan 2009 18:21:11 GMT

This is one of those examples where relying on internal implementations can bite you, I imagine - since anonymous types are by design not supposed to leave private scope, the compiler team is free to do whatever they want with the actual implementation.

Thanks for the brain-twitch, though, Jon. =)

re: Horrible grotty hack: returning an anonymous type instance

skeet — Fri, 09 Jan 2009 17:45:36 GMT

@James: Yes yes yes! +1 for that. Love it. Will use it next time I need it (which is incredibly rarely). Thanks for the suggestion!

@Lorenzo: Of course. That's why it's fun :)

re: Horrible grotty hack: returning an anonymous type instance

Lorenzo Stoakes — Fri, 09 Jan 2009 17:42:53 GMT

Dude that's just... wrong. Very, very, very wrong. *shudder*

re: Horrible grotty hack: returning an anonymous type instance

James Hart — Fri, 09 Jan 2009 17:37:16 GMT

On the subject of creating typed null references to trigger type inference, or define an anonymous type signature, without instantiating anything, I prefer:

default(string)

(string) null

obviously doesn't reduce typing at all, but it feels less like a hack. The parallel to typeof(string) is quite nice, too.

re: Horrible grotty hack: returning an anonymous type instance

JaredPar — Fri, 09 Jan 2009 17:12:21 GMT

This process is even more complicated for VB code. VB supports the notion of both mutable, immutable anonymous types and mix mode anonymous types. (C# anonymous types are immutable by default). Any property in a VB anonymous type can be made immutable by using the "Key" prefix

Dim x = new With { Key .Name = "foo" }

In order to cast to an anonymous type, the target type used must get the immutablitiy state (is that the correct phrase?) correct because different types are generated for each state.

In VB though, it's often simpler to access the property via late binding. No it's not safe, but it's as safe as doing the cast trick. In both circumstances you are doing a non-compile type assertion that a particular object has a particular type.

Overal experience for either language though is messy. I've almost completely abandoned the explicit use of anonymous types in favor of Tuples.

re: Horrible grotty hack: returning an anonymous type instance

Jacob — Fri, 09 Jan 2009 16:36:25 GMT

Dictionary -> strongly typed Anonymous type instance

re: Horrible grotty hack: returning an anonymous type instance

skeet — Fri, 09 Jan 2009 16:04:05 GMT

@serhat: Firstly, strings *are* references (and not primitives). Secondly, it shouldn't be a problem. Either create a new instance, or cast a null reference to the right type for the value. If you use Marc's idea of a Func<T> then it'll never be actually created anyway.

re: Horrible grotty hack: returning an anonymous type instance

serhat — Fri, 09 Jan 2009 15:56:58 GMT

What if the anonymous type contains reference fields instead of primitive ones like string?

re: Horrible grotty hack: returning an anonymous type instance

skeet — Fri, 09 Jan 2009 12:43:51 GMT

@Blake: I suspected it wasn't original. I didn't realise that Tomas had an example though. Doh! I should probably be reading his blog, given my current involvement in his book...

re: Horrible grotty hack: returning an anonymous type instance

Blake Coverett — Fri, 09 Jan 2009 12:38:59 GMT

You won't be blamed for it, this hack has certainly been around since before C#3.0 RTM. It is generally called "cast by example", a quick google shows:

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

But I'm sure I remember someone with one of the official msdn blogs dicussing in back in the day as well.

re: Horrible grotty hack: returning an anonymous type instance

Rene Stein — Fri, 09 Jan 2009 12:07:13 GMT

Yes, its only fun and not intended for production use, but I made and then publish on my blog some time before extensions methods for this a for returning anonymous type from mthe method in another assembly. As I say, only for fun and study. :)

namespace LINQAnonymous

{

/// <summary>

/// Rozšíření pro LINQ

/// </summary>

static class RSLinqExtensions

{

/// <summary>

/// Metoda přetypuje objekt na anonymní typ, jehož struktura byla předána v parametru <paramref name="prototype"/>

/// </summary>

/// <typeparam name="T">Kompilátorem odvozený anonymní typ</typeparam>

/// <param name="prototype">Prototyp se strukturou anonymního typu</param>

/// <returns>Instanci anonymního typu, nebo null, jestliže konverzi nelze provést</returns>

/// <remarks>Metoda se pokusí převést data z různých assembly</remarks>

public static T ToAnonymousType<T>(this object obj, T prototype)

where T: class

{

T atiObj = obj as T;

if (atiObj == null)

{

atiObj = GetTypeInstance(obj, prototype.GetType()) as T;

}

return (atiObj);

}

private static object GetTypeInstance(object obj, Type expected)

{

object atiObj = null;

ConstructorInfo constructorInfo = expected.GetConstructors()[0];

if (constructorInfo == null)

{

return null;

}

ParameterInfo[] paramInfos = constructorInfo.GetParameters();

PropertyInfo[] origProperties = obj.GetType().GetProperties();

if (paramInfos.Count() != origProperties.Count())

{

return null;

}

object[] paramArgs = new object[paramInfos.Count()];

for (int i = 0; i < paramArgs.Length; i++)

{

PropertyInfo origProperty = origProperties.Where(prop => prop.Name == paramInfos.Name).FirstOrDefault();

if (origProperty == null)

{

return null;

}

object val = origProperty.GetValue(obj, null);

if (origProperty.PropertyType != paramInfos.ParameterType)

{

val = GetTypeInstance(val, paramInfos.ParameterType);

}

paramArgs = val;

}

atiObj = constructorInfo.Invoke(paramArgs);

return atiObj;

}

/// <summary>

/// Metoda vrátí

/// </summary>

/// <typeparam name="T">Kompilátorem odvozený anonymní typ</typeparam>

/// <param name="prototype">Prototyp se strukturou anonymního typu</param>

/// <returns>List instancí anonymního typu, nebo null, jestliže konverzi nelze provést</returns>

/// <remarks>Metoda se pokusí převést data z různých assembly</remarks>

public static List<T> CastToList<T>(this object obj, T prototype)

where T : class

{

List<T> list = new List<T>();

IEnumerable<T> enumerable = obj as IEnumerable<T>;

if (enumerable != null)

{

list.AddRange(enumerable);

}

else

{

IEnumerable enumObjects = obj as IEnumerable;

if (enumObjects == null)

{

return null;

}

foreach (object enumObject in enumObjects)

{

T currObject = ToAnonymousType(enumObject, prototype);

if (currObject == null)

{

//K čistění listu by neměl být důvod, ale garantujeme, že nevrátíme částečně naplněný list

list.Clear();

return list;

}

list.Add(currObject);

}

return list;

}

And using

//TestAT.GetResult is in the another assmbly

//Anonymní typ z jiné assembly!

var result2 = TestAT.GetResult().CastToList(new {FirstLetter = default(char),

Index =default(int),

Original = default(string),

InnerAT = new { X = default(char), B = new { A = default(int) } }

})

;

foreach (var res in result2)

{

Console.WriteLine(res.FirstLetter);

Console.WriteLine(res.Original);

}

Console.WriteLine(TestAT.

GetResult().

CastToList(new

{

FirstLetter = default(char),

Index = default(int),

Original = default(string),

InnerAT = new { X = default(char), B = new { A =default(int)} }

}

Where(car => car.FirstLetter == 'T')

.FirstOrDefault()

.ToString());

Console.ReadLine();

re: Horrible grotty hack: returning an anonymous type instance

skeet — Fri, 09 Jan 2009 11:01:30 GMT

@Marc, re using a func: Ewww! I'm not sure whether I feel event dirtier now or not...

re: Horrible grotty hack: returning an anonymous type instance

Marc Gravell — Fri, 09 Jan 2009 10:48:42 GMT

Oh, forgot to say; if you use a `Func<T>` instead of a `T` in the last arg, you don't actually create an object, and the func gets cached anyway (and is never used) - i.e.

var foo = Cast(bar, ()=>new {...});

Probably not hugely better... I used a similar approach in a sample a while ago to create an empty `List<T>` of an anon-type (and then drop items in later, but in the same method) - i.e.

List<T> CreateList<T>(Func<T> template) {...}