Improve anonymous-type ToString

[weitzhandler]

Hi,

When calling ToString of C#'s anonymous types, a dictionary-like string is produced, for example:

new { str = "sdf", char = 'a', i = 45, b = false }.ToString()

Will output a string containing:
{ str = "sdf", char = 'a', i = 45, b = False }.

My request is that it should output more precise results, for instance, string and char values should be wrapped in quotes, and booleans should be lowercase.

[YairHalberstadt]

This would be a breaking change I'm afraid.

[weitzhandler]

So I thought, but is there any possible use with the current version at all other then debug info?

[YairHalberstadt]

It is possible that people parse them, and create objects that way.

[weitzhandler]

Any room to consider improving it although it being a breaking change?

[YairHalberstadt]

It's not me you would have to convince - it's the LDC.

IMO, something like this is the sort of thing that would be ultra low priority even if it wasn't a breaking change. They already have a near infinite backlog. However if a community member were to implement it, they would consider it.

Given that it is a breaking change, that means that whatever happens, they have to be investigate how many people this would break, which means they're just going to ignore it, and do other things instead.

[ufcpp]

This request is inconsistent with the fact that 'a'.ToString() is "a" and true.ToString() is "True".

[svick]

@YairHalberstadt

It's not me you would have to convince - it's the LDC.

I don't think this would actually be a language change, since the spec does not prescribe the implementation of ToString() on an anonymous type. I believe this means it would be just a compiler change and that the LDC would not have to be involved.

But if this was considered to be an unacceptable behavioral breaking change, that would still be a problem.

[john-h-k]

Not a language feature, but you could ask for a change to ToString with a new formatter, e.g anonType.ToString("L") (literal? I do not know the formatters)

[alexk8]

why not use extension like

public static string ToJson(this object o) =>  JsonConvert.SerializeObject(o)

if anybody wants his own specific format then he should use his own formatter
no perceptible reason has been denoted, imho
why is that better?

[MgSam]

Getting a useful format for ToString that everyone agrees on is impossible, there are just too many possibilities; not to mention decades too late for it not to be a huge breaking change. There are places all over .NET where you could imagine more useful ToStrings. Unfortunately, the best we can do is make a similarly-named extension method.

[canton7]

I think adding a ToString overload to anonymous types which takes an IFormatProvider (and passes it to the generated call to string.Format) could be acceptable?

(You could also implement IFormattable, but I suppose you'd have to throw away the format parameter, which could be confusing. string does this however.)

That means you can write your own type which implements IFormatProvider and ICustomFormatter, and which contains whatever logic you want to format different types in different ways. This same custom type could be used with those different types directly, meaning that we don't have something with is specific to anonymous types.

It also means that people can pass in things like CultureInfo.InvariantCulture, which I can imagine maybe being useful? (Although nobody's asked for it).