Proposal: Local Type Alias for anonymous types

[pmunin]

Local Type Alias for anonymous types would be nice solution for dealing with Generics:

//ways to define alias:
<TPerson> myPerson = new {FirstName:"John", LastName:"Smith"};
//or: 
var myPerson = new {FirstName:"John", LastName:"Smith"} as <TPerson>;
//or: 
var lazyNewAlias = new Lazy< <TPerson> >(()=> new {FirstName:"John", LastName:"Smith"} );


//reusing alias
var myQueue  = new Queue<TPerson>(); myQueue.Enqueue(myPerson);

var myDictionaryReuseAlias = new Dictionary<string,TPerson>(){
   {"person1" , new TPerson {FirstName:"John", LastName:"Smith"} }
};

This issue came from #427. This current proposal could be alternative solution for #427

[Mafii]

Are there any really useful use cases? I could see some, but not large benefits in most queries, etc.

[svick]

What is the advantage over tuples? E.g.:

var myPerson = (FirstName:"John", LastName:"Smith");

var lazy = new Lazy<(string FirstName, string LastName)>(() => ("John", "Smith"));

var myQueue  = new Queue<(string FirstName, string LastName)>(); myQueue.Enqueue(myPerson);

var myDictionary = new Dictionary<string, (string FirstName, string LastName)> {
   { "person1", ("John", "Smith") }
};

[pmunin]

Well, the main advantage the alias - you don't have to specify the structure of the ValueTuple with all types and property names every single time:

//just do it once
var myPerson = (FirstName:"John", LastName:"Smith") as <TPerson>; 

//and then reuse it:
var lazy = new Lazy<TPerson>(() => ("John", "Smith"));

var myQueue  = new Queue<TPerson>(); myQueue.Enqueue(myPerson);

var myDictionary = new Dictionary<string, TPerson> {
   { "person1", ("John", "Smith") }
};

Also I don't think people will stop using anonymous types after ValueTuples showed up, especially when you need to add dependency to additional package in order to get it available. Type aliasing can be compatible not only with Anonymous type but with any other type besides and including value tuples.

[DavidArno]

@pmunin

The "we might get it one day" feature of records would cover that:

class TPerson(string FirstName, string LastName);
...

[andrey-messi]

@pmunin

This current proposal could be alternative solution for #427

Do I understand correctly that you implied to do this:

<AnonymousClassName> myObjectsArray = new[]{ new{ FirstName: "John", LastName:"Smith"} };
var myObjsQueue = new Queue<AnonymousClassName>(myObjectsArray);

?
Also, there are my examples of using aliases for anomymous types within methods (I just used another syntax - var{MyClass} instead of < MyClass>):

void Func1()
{
	// Here an anomymous type with an alias MyClass is defined and that type represents an object with properties string Name and int Age
	var{MyClass} cat1 = context.Cats.Select(cat => new {cat.Name, cat.Age}).First();
	// I can use a type var{MyClass} here because I select properties of same types with same names for cat2 as for cat1 (I do not know should an order of properties also be the same or not)
	var{MyClass} cat2 = context.Cats.Skip(1).Select(cat => new {cat.Name, cat.Age}).First();
	// I can omit {MyClass} and use just var but cat3 is of type MyClass because of same properties as for cat1 and cat2
	var cat3 = context.Cats.Skip(2).Select(cat => new {cat.Name, cat.Age}).First();
	// here I can use type directly as MyClass (not var{MyClass}) like if it is not an alias but a real type because it is already defined above
	MyClass cat4 = context.Cats.Skip(3).Select(cat => new {cat.Name, cat.Age}).First();
	// compile error because of MyClass type doesn't contain a property Breed
	MyClass catsCompileError = context.Cats.Select(cat => new {cat.Name, cat.Age, cat.Breed}).First();
	// here I can create a Lamba that can receive an object of a type MyClass that is not just anonymous type, but anonymous with alias MyClass
	Func<MyClass, bool> IsOldAndFemale = cat => cat.Age > 10 && femaleCatsNames.Contains(cat.Name);
	//Now I can invoke IsOldAndFemale for all objects (cat1, cat2, cat3, cat4)
	var res1 = IsOldAndFemale(cat1);
	var res2 = IsOldAndFemale(cat2);
	var res3 = IsOldAndFemale(cat3);
	var res4 = IsOldAndFemale(cat4);
	//For example if we use ToList() instead of First() then an anomymous type with an alias MyClass1 represents a collection of objects with properties string Name and int Age, i.e in this case var{MyClass1} internally is List<{string Name, int Age}>
	var{MyClass1} cats = context.Cats.Select(cat => new {cat.Name, cat.Age}).ToList();
	var count = cats.Count();
}

[andrey-messi]

Another lightweight variant of syntax using * for local named (they already can't be called 'anonymous') classes:

void Func1()
{
	// var here is a classic anomymous type
	var cat0 = context.Cats.Select(cat => new {cat.Name, cat.Age, cat.Breed}).First();	
	// *Cat - new syntax for defining a named local type with an alias 'Cat' and that type represents an object with properties string Name and int Age.
	// The type 'Cat' is accessable only from inside the method 'Func1'
	*Cat cat1 = context.Cats.Skip(1).Select(cat => new {cat.Name, cat.Age}).First();
	// another object of type 'Cat'
	Cat cat2 = context.Cats.Skip(2).Select(cat => new {cat.Name, cat.Age}).First();
	// Now I can reuse a type 'Cat' with Func or local functions:
	Func<Cat, bool> IsOldAndFemale = cat => cat.Age > 10 && femaleCatsNames.Contains(cat.Name);
	var res1 = IsOldAndFemale(cat1);
	var res2 = IsOldAndFemale(cat2);
	// It is also should be valid to call IsOldAndFemale with cat0 because a compiler should know that cat0 is of a type that derived from a type 'Cat' (cat0 has the same properties that defined in the type 'Cat'):
	var res3 = IsOldAndFemale(cat0);
}

And one more possible syntax:
class Cat cat1 = context.Cats.Skip(1).Select(cat => new {cat.Name, cat.Age}).First();

[svick]

@andrey-messi Cat* already has a meaning. I think adding a completely unrelated *Cat would be very confusing.

[Pzixel]

I'd like just generics to accept Type as valid argument, because it's paint to call generic method while we know type at runtime only. Then it could be just:

var myPerson = new {FirstName:"John", LastName:"Smith"};
var lazyNewAlias = new Lazy<myPerson.GetType()>(()=> new {FirstName:"John", LastName:"Smith"} );

and finally inference for constructors:

var lazyNewAlias = new Lazy(()=> new {FirstName:"John", LastName:"Smith"} );