Question

In C#, I would like to figure out if it’s possible to declare an anonymous type where the fields are not known until run-time.

For example, if I have a List of key/value pairs, can I declare an anonymous type based on the contents of that list? The specific case I’m working with is passing parameters to Dapper, where I don’t know ahead of time how many parameters I will have.

List<Tuple<string, string>> paramList = new List<Tuple<string, string>>() {
    new Tuple<string, string>("key1", "value1"),
    new Tuple<string, string>("key2", "value2")
    ...
};

I’d like to convert this List (or an equivalent Map) into an anonymous type that I can pass to Dapper as query parameters. So ideally, the above list would wind up looking like this, if defined as an anonymous type:

new { key1=value1, key2=value2, ... }

I’ve seen several questions on StackOverflow asking about extending anonymous types after they are declared (“extendo objects”), or declaring arbitrary fields on an object after it’s created, but I don’t need to do that… I just need to declare the types dynamically up-front once. My suspicion is that it will require some fancy reflection, if it’s possible at all.

My understanding is that the compiler defines a type for anonymous classes under the hood at compile-time, so if the fields of that class are not available until run-time, I might be out of luck. My use case may in fact be no different in actuality than using an “extendo object” to define arbitrary fields, whenever.

Alternatively, if anyone knows of a better way to pass query parameters to Dapper (rather than declaring an anonymous class), I would love to hear about that as well.

Thanks!

UPDATE

Sorry for the delay in getting back to this one! These answers were all great, I wish I could give points to everyone. I ended up using jbtule’s solution (with edit by Sam Saffron), passing IDynamicParameters to Dapper, so I felt I had to give the answer to him. The other answers were also good, and answered specific questions that I had asked. I really appreciate everyone’s time on this!

Answer 1

Dapper’s creators were very aware of this problem. This kind of functionality is really needed for INSERT and UPDATE helpers.

The Query, Execute and QueryMultiple methods take in a dynamic parameter. This can either be an anonymous type, a concrete type or an object that implements IDynamicParameters.

public interface IDynamicParameters
{
    void AddParameters(IDbCommand command, Identity identity);
}

This interface is very handy, AddParameters is called just before running any SQL. Not only does this give you rich control over the parameters sent to SQL. It allows you to hook up DB specific DbParameters, since you have access to the command (you can cast it to the db specific one). This allows for support of Table Values Parameters and so on.

Dapper contains an implementation of this interface that can be used for your purposes called DynamicParameters. This allows you to both concatenated anonymous parameter bags and add specific values.

You can use the method AddDynamicParams to append an anonymous type.

var p = new DynamicParameters();
p.AddDynamicParams(new{a = "1"});
p.AddDynamicParams(new{b = "2", c = "3"});
p.Add("d", "4")
var r = cnn.Query("select @a a, @b b, @c c, @d d", p);
// r.a == 1, r.b == 2, r.c == 3, r.d == 4