novedades - ¿Cuál es la diferencia entre `new object()` y `new{}` en C#?

new features c#

Question

Primero busqué en esto y encontré los siguientes enlaces en Stack Overflow:

• ¿Hay alguna diferencia entre `new object ()` y `new {}` en c #?
• Diferencia entre el objeto a = perro nuevo () vs perro a = perro nuevo ()

Pero no estoy satisfecho con esta respuesta, no se explica bien (no lo entendí bien). Básicamente, quiero saber la diferencia entre new object() y new {} . ¿Cómo se tratan en tiempo de compilación y tiempo de ejecución?

En segundo lugar, tengo el siguiente código que he utilizado para WebMethods en mi aplicación simple asp.net

[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;
}

Entonces, (como se puede ver en los comentarios en el código), ¿cómo new object(){} diferencias new object(){} y new {} ?

¿Es esta la forma correcta de escribir el código? ¿Puedes sugerir la mejor forma para este código?

Lo sé, no puedo explicarlo bien y estoy pidiendo mucho, pero eso es lo mejor que tengo ahora.

Answer 1

Para ver la diferencia entre el new Object() y el new {} y el new Object(){} ... ¿por qué no nos damos cuenta?

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

Los dos primeros son solo formas diferentes de crear un Objeto e imprimen System.Object . El tercero es en realidad un tipo anónimo e imprime <>f__AnonymousType0 .

Creo que te puedes confundir por los diferentes usos de ''{}''. De la parte superior de mi cabeza, puede usarse para:

1. Bloques de declaración
2. Object / Collection / Array initialisers.
3. Tipos anónimos

Entonces, en short object data = new { }; no crea un nuevo objeto Crea un nuevo tipo anónimo que, como todas las clases, estructuras, enumeraciones y delegados, hereda el objeto y, por lo tanto, puede asignársele.

Como se menciona en los comentarios, cuando devuelve tipos anónimos, todavía tiene que declararlos y enviarlos a Object. Sin embargo, todavía son cosas diferentes y tienen algunas diferencias de implementación, por ejemplo:

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();
}

Answer 2

new {...} siempre crea un objeto anónimo , por ejemplo:

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

mientras que el new Object() crea una instancia de la clase Object

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

dado que todos los objetos (incluidos los anónimos) se derivan de Object , siempre puede escribir

  Object sample = new {};

Answer 3

new{ } crea una instancia de un tipo anónimo sin miembros. Esto es diferente de crear una instancia de object . Pero como casi todos los tipos, los tipos anónimos se pueden asignar al objeto.

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

Muestra claramente un nombre generado automáticamente, no Object .