Is it possible to create an anonymous generic object?

Question

Imagine that you want to declare an object with an anonymous type, but you need it to be generic (I can't think of an actual reason why, this is theoretical). How would you create such an object?

For example:

var anonymousGeneric = new <T>{ }; // <- doesn't work

var anonymousGeneric = Activator.CreateInstance((new { }).GetType()); // Not generic 

edit:

// because:
(new { }).GetType().IsGenericType == false
// Of course, any useful anonymous object _will_ be generic:
(new { a="b" }).GetType().IsGenericType == true
// But in the process of testing various aspects of this question 
// it had never occurred to me that I needed to supply any property 
// (this was all theoretical, remember)

end edit

But neither of those works. Of course, the real-world solution to this imagined problem is to define an actual class definition:

public GenericThing<T> { }

But that isn't anonymous like above.

Once the object is created, imagine using it later on with something like:

var anonymousGenericType = anonymousGeneric.GetType();

// These throw exception
// <>f__AnonymousType0#1 is not a GenericTypeDefinition. MakeGenericType may only be called on a type for which  Type.IsGenericTypeDefinition is true.
//   + System.RuntimeType.MakeGenericType(System.Type[])
var intThing = anonymousGenericType.MakeGenericType(typeof(int));
var stringThing = anonymousGenericType.MakeGenericType(typeof(string));  

In summary, is it possible to create an anonymous generic object?

Answer 1

(I can't think of an actual reason why, this is theoretical)

In that case, let's stick with the simple and obvious, since it's easier to find a reason: simply create a regular anonymous object from a generic method.

public object Foo<T>(T t) { return new { t }; }

Here, Foo(0) and Foo("") will necessarily return different types, but they'll still share a type definition.

Pretty much any use of anonymous types can make equal sense inside a generic method.

Answer 2

anonymousGeneric.GetType() is returning the wrong type of generic type: Closed (with type parameter(s)) vs open (without)¹. If you want to change a type parameter, you need to get the generic type definition from it.

The following actually works, though I can't imagine what good it does anybody ²:

var anonymousGeneric = new {a = "b"};

var anonymousGenericType = anonymousGeneric.GetType().GetGenericTypeDefinition();

var intThingType = anonymousGenericType.MakeGenericType(typeof(int));

var intThingInstance = Activator.CreateInstance(intThingType, 9);

Now we have a thing just like anonymousGeneric, but its type parameter is int instead of string, and its a property is 9. But what's it good for? How do you declare a reference to it? You could bind to its properties in XAML, if you had some time on your hands.

---

¹ Thanks to Amy and Servy for pitching in to clear up my confusion with terminology.

² Note that there are more things in heaven and earth than are dreamt of in my philosophy.