Can you consider adding some metaprogramming factors to C #

[nczsl]

Because C # is not like JavaScript, as it is strongly typed, performance is prioritized and dynamic features are not easily added. Referring to TS's metaprogramming, its role is only limited to providing a friendly prompt to developers when editing. Originally, C # could also have these features because they are erased after compilation, such as in code like this: dynamic x where IA|IB|IC = somePerameter; This kind of thing allows x to enjoy the intelligent perception provided by where constraints, making the code easier to read and write; At the same time, it is completely erased after being compiled into plain C # code; Because it does not affect the original usage rules at all.

[colejohnson66]

#7967 and others

[sharpchen]

I think he meant compile-time shape checking, not specific to unions

[colejohnson66]

One of the union proposal ideas includes type erasure, where the compiler-alone knows what the real options are. Which is exactly what is proposed above.

[CyrusNajmabadi]

@huoyaoyuan can you please keep things civil. No need for that sort of description. Thanks :-)

[nczsl]

Proposal: Enhancing Anonymous Types and Dynamic Objects with Metaprogramming in C#
Background
In C#, handling complex query results often involves the use of anonymous types and dynamic objects. While these features provide flexibility, they also introduce challenges:

Loss of Type Information: Once an anonymous type or dynamic object leaves its defining scope, it loses its type information. This makes it difficult to pass these objects between methods and maintain type safety.
Limited IDE Support: Without type information, IDEs cannot provide intelligent code suggestions, leading to potential runtime errors and decreased developer productivity.
Inflexible Type Definitions: Defining interfaces or classes for every possible query result is cumbersome and inflexible.
Proposal
To address these issues, I propose enhancing C# with metaprogramming capabilities that allow for more flexible and type-safe handling of anonymous types and dynamic objects. Specifically, suggest the following features:

Metaprogramming Constraints:
Allow developers to define constraints on dynamic objects and anonymous types using metaprogramming syntax. These constraints will provide type information during development but will not affect the compiled code.
Example:

//example 1
class Class1{
  public dynamic field1 where IEnumerable<{Prop1:int,Prop2:string /*...*/}> ;
  //... some one method:
  void M1(){
          //...
          this.field1  = from i in EntitySet1 join j in EntitySet2 on  ...  select new {...}  ; 
         //...
  }
 //...
}
//example 2
dynamic x where {Prop1:int,Prop2:string,Method1->void}  = somePerameter;
  //or
dynamic x where {Prop1:int,Prop2:string,Method1->void}  = default;
//example 3
void M(dynamic p1) where p1:{Prop1:int,Method1->string} { /*... */}
//example 4
dynamic interface IInterface1{
  int Property1;
  string Property2;
  ref Entity1.Property1;
  ref Entity2.Property1;
  ref Entity3.Method1;
  void M();
  string M2(int id);
  //...
}

would constrain the dynamic object to have properties matching Entity1, Entity2, or a specific structure.
Enhanced IDE Support:
Ensure that IDEs can provide intelligent code suggestions based on the metaprogramming constraints. This will help developers understand and use complex query results more effectively, reducing runtime errors and improving code quality.
Simplified Type Definitions:
Reduce the need to define separate interfaces or classes for each query result by allowing inline type definitions using metaprogramming. This will make it easier to handle temporary result sets without sacrificing type safety.
Benefits
Flexibility: Developers can handle complex query results more flexibly without losing type information.
Type Safety: Metaprogramming constraints ensure that dynamic objects and anonymous types are used correctly, reducing runtime errors.
Developer Productivity: Enhanced IDE support and simplified type definitions improve developer productivity and code maintainability.
Key Points
Editor-Time Support: The metaprogramming annotations will provide type information and intelligent code suggestions during development.
Compile-Time Cleanliness: The annotations will be removed during compilation, ensuring that the final compiled code remains clean and efficient, without any additional overhead.

[HaloFour]

There's no desire to make C# into a dynamic language, even with loose structural typing. If that's the paradigm you're looking for, why are you using C# instead of, say, Typescript?

[colejohnson66]

If you want an anonymous type's information to persist, just declare a proper struct/class.