Anonymous Type In C#

Definition

Anonymous type, as the name suggests is a type that doesn't have any name.Anonymous types are the new concept in C#3.0 that allow us to create new type without defining them. This is a way to define read only properties into a single object without having to define type explicitly. The type name is generated by the compiler and is not available at the source code level. We can create an object with the new keyword without defining its class.

Example

var Anonymous_Type = new
{
    firstName = "Pankaj",

        middleName = "Kumar",

        lastName = "Choudhary",

        age = 21,

        City = "Alwar"
};

Above Anonymous type contain 5 fields. We can see that we don’t require to maintain the data type for any field on anonymous object. We can see that City is a string type and age is integer type property. So compiler applies the appropriate type to each property based on the value expression.

An anonymous type is a temporary data type that is inferred based on the data that we include in an object initializer. Properties of anonymous types are read-only in nature so cannot change their values. Let us try to change the value of Age.

Above error confirm that we can’t change property of any Anonymous type object.

Nested Anonymous Type

var Anonymous_Type = new
{
    Name = new
        {
            firstName = "Pankaj",

                middleName = "Kumar",

                lastName = "Choudhary"
        },

        age = 21,

        City = "Alwar"
};

We can define an anonymous type that contain another anonymous type as a property. In above example we defined an anonymous type that is “Anonymous_Type” and this anonymous type contain a nested anonymous type “Name”.

Scope of Anonymous Type

Anonymous types are locally scoped. We can’t use a anonymous typed variable as a parameter for a method. But we can pass anonymous type for a method that accept dynamic type.

Example

class Program

{

    static void Main(string[] args)

    {

        var Anonymous_Type = new {
            firstName = "Pankaj",

                middleName = " Kumar",

                lastName = " Choudhary",

                age = 21,

                City = "Alwar"
        };

        Call(Anonymous_Type);

        Console.ReadKey();

    }

    static void Call(dynamic Data)

    {

        Console.WriteLine("My Name is: " + Data.firstName + Data.middleName + Data.lastName);

        Console.WriteLine("My Age is: " + Data.age);

        Console.WriteLine("I live in: " + Data.City);

    }

}

Output

Why we need of Anonymous Type

Anonymous types have been introduced to support one of the most useful feature called LINQ. It's most useful when we are querying collection of object using LINQ query and we want to return only a few of its properties. Anonymous types contain one or more public read-only properties. No other kinds of class members, such as methods or events, are valid. The expression that is used to initialize a property cannot be null

Example:

public class Employee

{

    public string Name
    {
        get;
        set;
    }

    public string City
    {
        get;
        set;
    }

    public int Age
    {
        get;
        set;
    }

    public string Post
    {
        get;
        set;
    }

}

class Program

{

    static void Main(string[] args)

    {

        List < Employee > Employee_obj = newList < Employee >
          {

            newEmployee()
           {
                Name = "Pankaj", City = "Alwar", Age = 21, Post = "Developer"
            },

            newEmployee()
          {
                Name = "Rahul", City = "Jaipur", Age = 22, Post = "Designer"
            },

            newEmployee()
          {
                Name = "Sandeep", City = "Delhi", Age = 20, Post = "Developer"
            },

            newEmployee()
          {
                Name = "Neeraj", City = "Alwar", Age = 23, Post = "Designer"
            }

        };

        varEmp =

            fromEmp_ inEmployee_obj

        selectnew

        {

            Emp_Name = Emp_.Name,

                Emp_Age = Emp_.Age

        };

        foreach(varObjinEmp)

        {

            Console.WriteLine("Employee Name is: " + Obj.Emp_Name + "Employee Age is: " + Obj.Emp_Age);

        }

        Console.ReadLine();

    }

}

Output

Point To Consider

• Anonymous types are class type, directly derived from “System.Object”, so they are reference type.
• Anonymous type can be defined using the new keyword and object initializer syntax.
• Anonymous type is a reference type.
• Properties of the Anonymous type are read only.
• The compiler provides a name for each anonymous type, although your application cannot access it.
• Anonymous type has method scope. If we want to return Anonymous type from the method, then you have to convert it in object type or we want to pass Anonymous type as parameter for a function then we should use the Dynamic Type.
• If two Anonymous types have the same properties and same order, then the compiler treats it as the same type, but both Anonymous must be in same assembly.
• We cannot declare a field, a property, an event, or the return type of a method as having an anonymous type.
• The implicitly typed variable “var”, is used to hold an anonymous type.