Cast to Anonymous Type

Question

I had the following problem today, and I was wondering if there is a solution for my problem.

My idea was to build anonymous classes and use it as a datasource for a WinForm BindingSource:

public void Init()
{
    var option1 = new
                  {
                      Id = TemplateAction.Update,
                      Option = "Update the Templates",
                      Description = "Bla bla 1."
                  };

    var option2 = new
                  {
                      Id = TemplateAction.Download,
                      Option = "Download the Templates",
                      Description = "Bla bla 2."
                  };

    var list = new[] {option1, option2}.ToList();

    bsOptions.DataSource = list; // my BindingSource

    // cboTemplates is a ComboBox
    cboTemplates.DataSource = bsOptions; 
    cboTemplates.ValueMember = "Id";
    cboTemplates.DisplayMember = "Option";

    lblInfoTemplates.DataBindings.Add("Text", bsOptions, "Description");
}

That works fine so far.

The problem I had is to get Id out of the "Current" property of the BindingSource, because I can't cast it back to the Anonymous Type:

private void cmdOK_Click(object sender, EventArgs e)
{
    var option = (???)bsOptions.Current;
}

I guess there is no way to find out the type of "Current" and access the "Id" Property? Maybe someone has a good solution...

I know there are other (and also better) ways to get the Id (Reflection, reading the value from the ComboBox, not using anonymous tpyes,...) I'm just courious if it's possible to get the Type out of bsOptions.Current in an elegant way.

Benefactor

Br... anonymous class can be useful (sometimes), but really, used that way, to me it's a regression to VB age :/. – Cutworm

Just wait until dynamic enters the scene, be glad we're only seeing questions about passing anonymous objects around. – Sleave

Right, with enough luck we'll have a brand new "marquee" attribute on Label :D – Cutworm

Duplicate of #714021 – Lucas

Answer 1

Note, as per the comment, I'd just like to point out that I too recommend using a real type when you need to pass it around the program like this. Anonymous types should only really be used locally in a single method at a time (in my opinion), but anyway, here's the rest of my answer.

---

You can do it using a trick, by tricking the compiler into inferring the right type for you:

using System;

namespace ConsoleApplication4
{
    class Program
    {
        static void Main(string[] args)
        {
            var a = new { Id = 1, Name = "Bob" };
            TestMethod(a);

            Console.Out.WriteLine("Press enter to exit...");
            Console.In.ReadLine();
        }

        private static void TestMethod(Object x)
        {
            // This is a dummy value, just to get 'a' to be of the right type
            var a = new { Id = 0, Name = "" };
            a = Cast(a, x);
            Console.Out.WriteLine(a.Id + ": " + a.Name);
        }

        private static T Cast<T>(T typeHolder, Object x)
        {
            // typeHolder above is just for compiler magic
            // to infer the type to cast x to
            return (T)x;
        }
    }
}

The trick is that inside the assembly, the same anonymous type (same properties, same order) resolves to the same type, which makes the trick above work.

private static T CastTo<T>(this Object value, T targetType)
{
    // targetType above is just for compiler magic
    // to infer the type to cast value to
    return (T)value;
}

usage:

var value = x.CastTo(a);

But we're really pushing the limits here. Use a real type, it'll look and feel cleaner as well.

Sleave

I don't like this though as it can be error prone, far better to just create an actual class to hold the values. – Historiography

I agree, though it's not really all that error prone, but I agree, a real type is warranted here, I edited the answer to clarify. – Sleave

According to Mads Torgersen, the C# team refer to this trick as "cast by example". See his comment (the first) on this article: tomasp.net/blog/cannot-return-anonymous-type-from-method.aspx – Lucas

I've seen it referred to as "EvilCast" as well :) Just goes to show, although something is possible, doesn't mean we should do it. – Sleave

That's a very clever trick, but as with almost all clever code, it's code that shouldn't be used. – Bedwell

Totally agree, here I would at the very least use a Tuple or similar predefined type in a framework, but I would probably create a new type for this scenario. – Sleave

Everyone keeps saying "ooh, that's evil", but why? It is only runtime-checkable, but lots of languages work exclusively that way, like Python. That can be an acceptable design decision. Anyway, if you're casting from an object back into anything, it's only runtime-checkable anyway. So whats the difference if it's one string or two strings that you are casting back into? – Enosis

I agree with the 'shouln't be used', and now there is Tuple<,...> if you're really too lazy to write a tiny class. – Misfortune

I am forced to use the anonymous method instead of strongly typed class for the following reason. I have to group a set of items based on month and year so I am grouping as new { x.date.Month, x.date.Year } which will group as expected. However, if I create a concrete class called MonthAndYear which has two ints Month and Year, and trying to group it as new MonthAndYear { Month = x.date.Month, Year = x.date.Year }, it groups each item into a separate bucket instead of putting items that belong to the same month & year into the same group. Unable to figure out how to get this working. – Evite

Didn't work for me. I got this error System.InvalidCastException: [A]<>f__AnonymousType02[System.String,System.String] cannot be cast to [B]<>f__AnonymousType02[System.String,System.String]. – Foreside

Answer 2

Instead of casting to your custom type try using dynamic type.

Your event handler would look something like this:

private void cmdOK_Click(object sender, EventArgs e)
{
    dynamic option = bsOptions.Current;
    if (option.Id == 1) { doSomething(); }
      else { doSomethingElse(); }
}

Eastnortheast

+1 - This is a good option in C# 4.0. option.Id will be evaluated at run-time in this case. – Agminate

Answer 3

To quote MSDN:

An anonymous type cannot be cast to any interface or type except for object.

Archduke

Answer 4

In C# 3.0, this is not possible. You'll have to wait for C# 4.0, which allows accessing properties at runtime using "dynamic" variables.

Basanite

Answer 5

public class MyExtensMethods{

    public static T GetPropertyValue<T>(this Object obj, string property)
    {
        return (T)obj.GetType().GetProperty(property).GetValue(obj, null);
    }
}

class SomeClass
{
    public int ID{get;set;}
    public int FullName{get;set;}
}


// casts obj to type SomeClass
public SomeClass CastToSomeClass(object obj)
{
     return new SomeClass()
     {
         ID = obj.GetPropertyValue<int>("Id"),
         FullName = obj.GetPropertyValue<string>("LastName") + ", " + obj.GetPropertyValue<string>("FirstName")
     };
}

.... then to cast you will do:

var a = new { Id = 1, FirstName = "Bob", LastName="Nam" };
SomeClass myNewVar = CastToSomeClass(a);

Ballast

@gsharp. My use case is for Unit testing a Jsonresult, which is sending an anonymous type of multiple realized classes. So I already have SomeClasses but wanted an anonymous type for passing json. This works perfect for me thanks. – Zingaro

Answer 6

you can try this:

private void cmdOK_Click(object sender, EventArgs e)
{
    var option = Cast(bsOptions.Current, new { Id = 0, Option = "", Description = "" });
}

see: Can't return anonymous type from method? Really?

Enamel