Anonymous types are used to define strong types without defining the type. Anonymous types are strongly typed and checked at compile time. It provides a convenient way to encapsulate a set of read-only properties into a single object without having to first explicitly define a type. Anonymous types are reference types that derive directly from object. The compiler gives them a name although your application cannot access it. From the perspective of the common language runtime, an anonymous type is no different from any other reference type, except that it cannot be cast to any type except for object. This type is widely used by LINQ, because LINQ returns dynamically-shaped data, whose type is determined by the LINQ query
To understand better look at the following code
static void Main (string[] args)
{
string[] names = { "Abhi1", "abhi", "abhi11",
"george", "bush", "britney",
"gandhi", "David" };
IEnumerable<string> varAnnoyType = from str in names
orderby str
select str;
//following code also valid
//var varAnnoyType = from str in names
// orderby str
// select str;
foreach (string strname in varAnnoyType)
Console.WriteLine(strname);
Console.ReadLine();
}
anonymous type is an object which supports IEnumerable interface.
In the above example an array of names is created (took the array collection from msdn) , an IEnumerable<string> type is created, see the keyword like from used to iterate eact item in collection, orderby clause orders (without LINQ imagine the dictionaries , temp variables and other techniqies used to sort items now this is really cool). You can add a Where clause also before the select keyword. If any conditions are specified then select will retrieve only those items which satisfies the where clause.
var varAnnoyType = from str in names
where str.StartsWith("abhi")
orderby str
select str;
The for each iteration can be written like the following also.
foreach (var strname in varAnnoyType)
Console.WriteLine(strname);
If two or more anonymous types have the same number and type of properties in the same order, the compiler treats them as the same type and they share the same compiler-generated type information.
An anonymous type has method scope. To pass an anonymous type, or a collection that contains anonymous types, outside a method boundary, you must first cast the type to object. However, this defeats the strong typing of the anonymous type. If you must store your query results or pass them outside the method boundary, consider using an ordinary named struct or class instead of an anonymous type.
Anonymous types cannot contain unsafe types as properties.
Because the Equals and GetHashCode methods on anonymous types are defined in terms of the Equals and GetHashcode of the properties, two instances of the same anonymous type are equal only if all their properties are equal.
Comments