Quelle est la différence entre `new object()` et `new {}` en C# ?

Question

Tout d'abord, j'ai fait une recherche sur ce sujet et j'ai trouvé les liens suivants sur Stack Overflow :

• Y a-t-il une différence entre `new object()` et `new {}` en c# ?
• Différence entre l'objet a = new Dog() et Dog a = new Dog()

Mais je ne le suis pas. satisfaite avec cette réponse, ce n'est pas bien expliqué (je ne l'ai pas bien compris). En gros, je veux savoir la différence entre new object() et new {} . Comment sont-elles traitées au moment de la compilation et de l'exécution ?

Deuxièmement, j'ai le code suivant que j'ai utilisé pour WebMethods dans mon application 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;
}

Ainsi, (comme vous pouvez le voir dans les commentaires du code), comment new object(){} et new {} des différences ?

Est-ce bien la bonne façon d'écrire le code ? Pouvez-vous suggérer une meilleure méthode pour ce code ?

Je sais, je ne peux pas bien l'expliquer et je demande beaucoup, mais c'est le mieux que j'ai pour le moment.

Answer 1

new {...} crée toujours un objet anonyme par exemple :

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

tandis que new Object() crée une instance de Object classe

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

puisque tous les objets (y compris les objets anonymes) sont dérivés de Object vous pouvez toujours taper

  Object sample = new {};

Answer 2

Pour voir la différence entre new Object() et new {} et new Object(){} ... pourquoi ne pas simplement le découvrir ?

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

Les deux premières sont simplement des façons différentes de créer un objet et des impressions. System.Object . Le troisième est en fait un type anonyme et imprime <>f__AnonymousType0 .

Je pense que vous êtes confus par les différentes utilisations de "{}". Pour ma part, je pense qu'il peut être utilisé pour.. :

1. Blocs de déclaration.
2. Initialisateurs d'objets/collections/rayons.
3. Types d'anonymes

Donc, en bref object data = new { }; ne crée pas de nouvel objet. Il crée un nouveau type d'anonyme qui, à l'instar de l'objet toutes les classes, structures, énumérations et délégués hérite d'Object et peut donc lui être assigné.

---

Comme indiqué dans les commentaires, lorsque vous renvoyez des types anonymes, vous devez toujours les déclarer et les convertir en objets. Cependant, il s'agit toujours de choses différentes et il y a quelques différences d'implémentation, par exemple :

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 3

new{ } crée une instance d'un type anonyme sans membres. Ceci est différent de la création d'une instance de object . Mais comme presque tous les types, les types anonymes peuvent être affectés à un objet.

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

Il s'agit clairement d'un nom généré automatiquement, et non d'un nom d'utilisateur. Object .