What is the Difference Between `new object()` and `new {}` in C#?

First of all i searched on this and i found the following links on Stack Overflow:

• https://stackoverflow.com/questions/1027997/is-there-any-difference-between-new-object-and-new-in-c
• https://stackoverflow.com/questions/8556651/difference-between-object-a-new-dog-vs-dog-a-new-dog

But i'm not satisfied with this answer, it's not explained well (i didn't get it well). Basically, i want to know the difference between new object() and new {}. How, they are treated at compile time and runtime?

Secondaly, i have the following code which i have used for WebMethods in my asp.net simple application

[WebMethod]
[ScriptMethod(UseHttpGet = false)]
public static object SaveMenus(MenuManager proParams)
{
    object data = new { }; // here im creating an instance of an 'object' and i have typed it `new {}` but not `new object(){}`.
    try
    {
        MenuManager menu = new MenuManager();    
        menu.Name = proParams.Name;
        menu.Icon = proParams.Icon;
        bool status = menu.MenuSave(menu);
        if (status)
        {
            // however, here i'm returning an anonymous type
            data = new
            {
                status = true,
                message = "Successfully Done!"
            };
        }
    }
    catch (Exception ex)
    {
        data = new { status = false, message = ex.Message.ToString() };
    }
    return data;
}

So, (as you can see in comments in code), How new object(){} and new {} differences?

Is this even the right way that i have write the code? Can you suggest a best way for this code?

I know, i can't explain it well and i'm asking alot, but that's the best i have right now.

new {...} always creates an anonymous object, for instance:

  Object sample = new {};
  String sampleName = sample.GetType().Name; // <- something like "<>f__AnonymousType0" 
                                             //                    not "Object"

while new Object() creates an instance of Object class

  Object sample = new Object() {};
  String sampleName = sample.GetType().Name; // <- "Object"

since all objects (including anonymous ones) are derived from Object you can always type

  Object sample = new {};

To see the difference between new Object() and new {} and new Object(){}... why don't we just find out?

Console.WriteLine(new Object().GetType().ToString());
Console.WriteLine(new Object() { }.GetType().ToString());
Console.WriteLine(new { }.GetType().ToString());

The first two are just different ways of creating an Object and prints System.Object. The third is actually an anonymous type and prints <>f__AnonymousType0.

I think you might be getting confused by the different uses of '{}'. Off the top of my head it can be used for:

1. Statement blocks.
2. Object/Collection/Array initialisers.
3. Anonymous Types

So, in short object data = new { }; does not create a new object. It creates a new AnonymousType which, like all classes, structures, enumerations, and delegates inherits Object and therefor can be assigned to it.

---

As mentioned in comments, when returning anonymous types you still have declare and downcast them to Object. However, they are still different things and have some implementation differences for example:

static void Main(string[] args)
{
    Console.WriteLine(ReturnO(true).ToString());  //"{ }"
    Console.WriteLine(ReturnO(false).ToString());  // "System.Object"

    Console.WriteLine(ReturnO(true).Equals(ReturnO(true)));  //True
    Console.WriteLine(ReturnO(false).Equals(ReturnO(false)));  //False
    Console.WriteLine(ReturnO(false).Equals(ReturnO(true)));  //False

    Console.WriteLine(ReturnO(true).GetHashCode());  //0
    Console.WriteLine(ReturnO(false).GetHashCode());  //37121646

    Console.ReadLine();
}

static object ReturnO(bool anonymous)
{
    if (anonymous) return new { };
    return new object();
}

new{ } creates an instance of an anonymous type with no members. This is different from creating an instance of object. But like almost all types, anonymous types can be assigned to object.

 object data = new { };
 Console.WriteLine(data.GetType().Name)

Clearly shows an auto-generated name, not Object.