"William Stacey [C# MVP]" <william.sta***@gmail.com> wrote in message
news:Oew180FEIHA.4684@TK2MSFTNGP06.phx.gbl...
> Maybe an Oxymoron, but this would be very useful.  Anonomous types are
> great
> for doing projections (especially in Linq), but not being able to pass or
> return them is a bummer. Why couldn't they add something like an "AS"
> modifier like:
>
> var v = new {Name="", Age=0} as MyType;
> var v2 = Change(v);
>
> void MyType Change(MyType mt)
> {
>      return new {mt.Name + "2", mt.Age += 1} as MyType;
> }
>
> In this case, MyType can only be "declared" the same way over the whole
> assembly. So you can use "as MyType" in multiple projections with
> compile-time checking. However, the compiler flags an error if MyType is
> not
> declared the same way each time, so the first declaration "sets" the type
> by
> name. In this case, it is not really anonymous anymore, however it adds
> ability to strongly type projections and ref them from across functions
> and
> assemblies.
>
> --
> William Stacey [C# MVP]
>
>
>
>

"Nicholas Paldino [.NET/C# MVP]" <mvp@spam.guard.caspershouse.com> wrote in
message news:83D51B75-A60E-4C97-AF64-AEC037AE06E2@microsoft.com...
|    This makes sense, to a degree, but I think it would be easier to just
| have a refactoring option in the IDE which would take an anonymous type
and
| create a known type, and then replace the anonymous type in the code with
| the new known type.
|
|
| --
|          - Nicholas Paldino [.NET/C# MVP]
|          - mvp@spam.guard.caspershouse.com
|
| "William Stacey [C# MVP]" <william.sta***@gmail.com> wrote in message
| news:Oew180FEIHA.4684@TK2MSFTNGP06.phx.gbl...
| > Maybe an Oxymoron, but this would be very useful.  Anonomous types are
| > great
| > for doing projections (especially in Linq), but not being able to pass
or
| > return them is a bummer. Why couldn't they add something like an "AS"
| > modifier like:
| >
| > var v = new {Name="", Age=0} as MyType;
| > var v2 = Change(v);
| >
| > void MyType Change(MyType mt)
| > {
| >      return new {mt.Name + "2", mt.Age += 1} as MyType;
| > }
| >
| > In this case, MyType can only be "declared" the same way over the whole
| > assembly. So you can use "as MyType" in multiple projections with
| > compile-time checking. However, the compiler flags an error if MyType is
| > not
| > declared the same way each time, so the first declaration "sets" the
type
| > by
| > name. In this case, it is not really anonymous anymore, however it adds
| > ability to strongly type projections and ref them from across functions
| > and
| > assemblies.
| >
| > --
| > William Stacey [C# MVP]
| >
| >
| >
| >
|

> Maybe an Oxymoron, but this would be very useful.  Anonomous types are great
> for doing projections (especially in Linq), but not being able to pass or
> return them is a bummer. Why couldn't they add something like an "AS"
> modifier like:
>
> var v = new {Name="", Age=0} as MyType;
> var v2 = Change(v);
>
> void MyType Change(MyType mt)
> {
>       return new {mt.Name + "2", mt.Age += 1} as MyType;
> }
>
> In this case, MyType can only be "declared" the same way over the whole
> assembly. So you can use "as MyType" in multiple projections with
> compile-time checking. However, the compiler flags an error if MyType is not
> declared the same way each time, so the first declaration "sets" the type by
> name. In this case, it is not really anonymous anymore, however it adds
> ability to strongly type projections and ref them from across functions and
> assemblies.