{"id":1070,"date":"2023-04-01T09:09:39","date_gmt":"2023-04-01T02:09:39","guid":{"rendered":"https:\/\/csharptutorial.net\/?page_id=1070"},"modified":"2023-06-17T22:00:26","modified_gmt":"2023-06-17T15:00:26","slug":"csharp-anonymous-type","status":"publish","type":"page","link":"https:\/\/www.csharptutorial.net\/csharp-tutorial\/csharp-anonymous-type\/","title":{"rendered":"C# Anonymous Types"},"content":{"rendered":"\n

Summary<\/strong>: in this tutorial, you’ll learn about C# anonymous types to create a single object that consists of read-only properties without having to define a class first.<\/p>\n\n\n\n

Introduction to C# anonymous types<\/h2>\n\n\n\n

Typically, you define a class<\/a> that has a set of properties and use the class to create objects.<\/p>\n\n\n\n

But sometimes you need to create an object that has a set of read-only properties without having to define a class. To do it, you use anonymous types.<\/p>\n\n\n\n

By definition, anonymous types allow you to encapsulate a set of read-only properties into a single object without having to define a class first.<\/p>\n\n\n\n

Behind the scenes, the compiler will generate the type name for the anonymous type. Therefore, the type name is not accessible at the source code level. The compiler also infers the type of each property of the anonymous type.<\/p>\n\n\n\n

To create anonymous types, you use the new<\/code> operator with an object initializer<\/a>. For example, the following demonstrates how to create an anonymous type with two properties named Name<\/code> and Price<\/code>:<\/p>\n\n\n

using<\/span> static<\/span> System.Console;\n\nvar<\/span> product = new<\/span>\n{\n    Name = \"Phone X\"<\/span>,\n    Price = 999.99<\/span>\n};\n\nWriteLine($\"{product.Name}<\/span> : {product.Price:C}<\/span>\"<\/span>);<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
Output:<\/p>\n\n\n
Phone X : $999.99<\/span><\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
If you hover the mouse over the Name<\/code> or Price<\/code> properties, you’ll see that the compiler infers the type of the Name<\/code> property to string and the type of the Price<\/code> property to double<\/code>:<\/p>\n\n\n\n
\"c#<\/figure>\n\n\n\n
Because the Name<\/code> and Price<\/code> properties are read-only, if you attempt to assign a new value to it, you’ll get a compiled error. For example:<\/p>\n\n\n
product.Price = 2000<\/span>; \/\/ error<\/span><\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
To form a new anonymous object with the same name and different price, you can use the with<\/code> expression.<\/p>\n\n\n\n
The with<\/code> expression creates an anonymous type object where one or more properties have new values. For example:<\/p>\n\n\n
using<\/span> static<\/span> System.Console;\n\nvar<\/span> product = new<\/span>\n{\n    Name = \"Phone X\"<\/span>,\n    Price = 999.99<\/span>\n};\nWriteLine($\"{product.Name}<\/span> : {product.Price:C}<\/span>\"<\/span>);\n\n\nvar<\/span> productX = product with\n{\n    Price = 1099.99<\/span>\n};\nWriteLine($\"{productX.Name}<\/span> : {productX.Price:C}<\/span>\"<\/span>);\n<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
Output:<\/p>\n\n\n
Phone X : $999.99<\/span>\nPhone X : $1<\/span>,099.99<\/span><\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
In this example, we use the with<\/code> expression to create a new instance of the same anonymous type with the product<\/code> object, but with the new Price<\/code> value.<\/p>\n\n\n\n
var<\/span> products = new<\/span>[]\n{\n    new<\/span> { Name = \"Phone X\"<\/span>, Price = 999.99<\/span> },\n    new<\/span> { Name = \"Computer Y\"<\/span>, Price = 1999.99<\/span> },\n    new<\/span> { Name = \"Tablet Z\"<\/span>, Price = 2999.99<\/span> }\n};<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
And an anonymous type can have properties that are instances of explicit types. For example:<\/p>\n\n\n
using<\/span> static<\/span> System.Console;\n\n\nvar<\/span> product = new<\/span>\n{\n    Name = \"Phone X\"<\/span>,\n    Price = 999.99<\/span>,\n    attribute = new<\/span> ProductAttribute() { Color = \"Black\"<\/span>, Weight = 100<\/span> }\n};\n\nWriteLine($\"{product.Name}<\/span>: {product.attribute.Color}<\/span>\"<\/span>);\n\n\n\nclass<\/span> ProductAttribute<\/span>\n{\n    public<\/span> string<\/span>? Color\n    {\n        get<\/span>; init;\n    }\n    public<\/span> decimal<\/span>? Weight\n    {\n        get<\/span>; init;\n    }\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
In this example, we define an anonymous object with a property that is an instance of the ProductAttribute<\/code> class.<\/p>\n\n\n\n
The supertype of anonymous types <\/h2>\n\n\n\n
Anonymous types inherit directly from the object<\/a><\/code> type. And you cannot cast anonymous types to any type except object<\/code>.<\/p>\n\n\n\n
If you have two or more anonymous objects that have the same set of properties in the same order and types, the compiler will treat these objects with the same type. In other words, they share the same generated type. For example:<\/p>\n\n\n
using<\/span> static<\/span> System.Console;\n\nvar<\/span> productX = new<\/span> { Name = \"Phone X\"<\/span>, Price = 999.99<\/span> };\nvar<\/span> productY = new<\/span> { Name = \"Phone Y\"<\/span>, Price = 555.99<\/span> };\n\nWriteLine(productX.GetType() == productY.GetType()); \/\/ true<\/span><\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
Output:<\/p>\n\n\n
<>f__AnonymousType0`2<\/span>[System.String,System.Double]\nTrue<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
In this example, productX<\/code> and productY<\/code> will share the same anonymous type’s name. Note that you may get a different generated type name.<\/p>\n\n\n\n
Two anonymous objects of the same type are equal if all their properties are equal. For example:<\/p>\n\n\n
using<\/span> static<\/span> System.Console;\n\nvar<\/span> productX = new<\/span> { Name = \"Phone X\"<\/span>, Price = 99<\/span> };\nvar<\/span> productY = new<\/span> { Name = \"Phone X\"<\/span>, Price = 99<\/span> };\n\nWriteLine(productX.Equals(productY));<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
Output:<\/p>\n\n\n
True<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
The reason is that anonymous types override the Equals<\/code> and GetHashCode<\/code> methods in terms of Equals<\/code> and GetHashCode<\/code> methods of its properties.<\/p>\n\n\n\n
Anonymous types override the ToString<\/code> method by concatenating the results of ToString<\/code> method of all properties and wrapping it in curly braces:<\/p>\n\n\n
using<\/span> static<\/span> System.Console;\n\nvar<\/span> productX = new<\/span> { Name = \"Phone X\"<\/span>, Price = 99<\/span> };\n\nWriteLine(productX.ToString());<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
Output:<\/p>\n\n\n
using<\/span> static<\/span> System.Console;\n\nvar<\/span> productX = new<\/span> { Name = \"Phone X\"<\/span>, Price = 99<\/span> };\n\nWriteLine(productX.ToString());<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
Output:<\/p>\n\n\n
{ Name = Phone X, Price = 99<\/span> }<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
Summary<\/h2>\n\n\n\n
It’s possible to define an array<\/a> of anonymous types like this:<\/p>\n\n\n