Anonymous type optimization

[DotNetNext]

Anonymous classes have no way to reuse the effect is very discounted

//Want to support this
(name) x1 = new (name)
{
        id=1,
        name="a"
};

(name) x2=new (name);
x2.id=1;
x2.name="b";

The name simply identifies them as the same type, so that it can be repeated

[stephentoub]

I'm not clear on what you're proposing. The title of the issue includes "optimization"... what is that referring to? Are you instead suggesting a new syntax to create named types without declaring them?

[huoyaoyuan]

Anonymous types are artifacts of compilers. The runtime has no concept of it. This should be a discussion to csharplang repo.

[DotNetNext]

I'm not clear on what you're proposing. The title of the issue includes "optimization"... what is that referring to? Are you instead suggesting a new syntax to create named types without declaring them?

I wish there were new syntax to make anonymous types easier to use

[DotNetNext]

This is the simplest application scenario, and there are many, many more

var list = db.Orders
    .Select(it => new    { Id = 1,Name=o.Name, CustomName = cus.Name })
    .ToList();
//error
list.Add(new  { Id = 1,Name=”a“, CustomName = "aa" })

If supported, it can be compiled by pointing to the same type

var list = db.Orders
    .Select(it => new  (name)   { Id = 1,Name=o.Name, CustomName = cus.Name })
    .ToList();
list.Add(new (name)  { Id = 1,Name=”a“, CustomName = "aa" })

Console.WriteLine( new { name = 1 }.GetType().FullName);
The anonymous type essentially has a name, I'm not changing his name, I just want to add a sign that he points to the same name, so that the anonymous object can use more space

 Console.WriteLine( new (name){ name = 1 }.GetType().FullName);
 //<>f__AnonymousType61`1[[System.Int32, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]]
 Console.WriteLine(new(name) { name = 1 }.GetType().FullName);
 //<>f__AnonymousType61`1[[System.Int32, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]]

Point to the same name without changing the original name

[DotNetNext]

I have refined this reply so that maybe you can understand what I want

[HaloFour]

The C# compiler already reuses the emitted type if the anonymous type schema matches.

        var a = new { Id = 123, Name = "Foo" };
        var b = new { Id = 123, Name = "Foo" };
        
        Debug.Assert(a.GetType() == b.GetType());

[DotNetNext]

I'm talking about future features, not existing ones

[HaloFour]

The feature already behaves this way. The compiler reuses the emitted class for the anonymous type. That's why it's legal to add another value to that list after populating it.

[DotNetNext]

It's what I need. It's just weird

var x2 = new[] { "1"}.Select(it =>  new { id = 2 }  ).ToList();
x2.Add(new { id = 2 });
x2.Add((dynamic)(object)new { id = 2 });

[DotNetNext]

Anonymous types are artifacts of compilers. The runtime has no concept of it. This should be a discussion to csharplang repo.

Maybe I sent it to the wrong place, but I just wanted to pass on the idea

[HaloFour]

If you want a name, declare a type. Once it has a name it's no longer anonymous. Also, anonymous types are readonly, so creating one to mutate later is not something that would work anyway. Anonymous types are not intended to replace declaring proper types, they're intentionally opinionated because they're intended for projections.

[HaloFour]

And your use case remains incorrect, the anonymous type is reusable in that the compiler will reuse the existing emitted type based on the schema. That's why your code already compiles today just fine:

int[] numbers = [1, 2, 3];
var list = numbers.Select(i => new { Value = i, Name = i.ToString() })
    .ToList();

// not an error
list.Add(new { Value = 0, Name = "Zero!" });

[DotNetNext]

I didn't give him a name? I'm just saying that they can reference the same type

[HaloFour]

They already reference the same type.

[DotNetNext]

It seems to have been optimized so that the same type points to the same one.
It should be that the parameterless constructor is not open

[DotNetNext]

If you do what I did, you can implement open parameterless constructors

[TahirAhmadov]

The only thing I can think of that can be improved here is declaring method-scoped record types, especially record structs. I'm not sure if there is an existing thread for it. Even that idea is likely to meet objections like "is it really needed" and the new complexity.

[TahirAhmadov]

Maybe in a parallel world without tuples, especially without language supported tuples, method-scoped records would gain more traction.

Scratch that, method scoped record types just don't make any sense in any world.

[GabeSchaffer]

I think method-scoped record types actually do make sense. Say you have a LINQ query that returns an anonymous type, then you decide to refactor that query into a local function. Since you have to name the return type of that local function, you have to create a class-scoped type just to move stuff around within a method.

Support for var local functions and named tuples in LINQ expressions would make this less valuable.

[DotNetNext]

The only thing I can think of that can be improved here is declaring method-scoped record types, especially record structs. I'm not sure if there is an existing thread for it. Even that idea is likely to meet objections like "is it really needed" and the new complexity.

Really need this feature, a lot of application scenarios. The cost of creating a class is too high, the tuple is not too easy to maintain, and the anonymity only needs to be identified as the same anonymous type, so that it can be reused

[DotNetNext]

The C# compiler already reuses the emitted type if the anonymous type schema matches.

It has a generated one, one that you intentionally cannot reference or reuse.

If you want to give it a name, then declare a type. Anonymous types are not intended to be a full-fledged replacement for normal types. They are opinionated to be readonly data carriers with value identity so that they can be used specifically with projections.

If you want to give it a name, then declare a type. Anonymous types are not intended to be a full-fledged replacement for normal types. They are opinionated to be readonly data carriers with value identity so that they can be used specifically with projections.

That's fine, but if your aim is to give them a name for the purposes of reuse, you are suggesting to make them no longer anonymous. Thus, anonymous classes are not the right tool for the job.

They already reference the same type.

They already reference the same type.

They already reference the same type.

The feature already behaves this way. The compiler reuses the emitted class for the anonymous type. That's why it's legal to add another value to that list after populating it.