new - what is the difference between c++ and c#




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

Tout d’abord, j’ai cherché à ce sujet et j’ai trouvé les liens suivants sur Stack Overflow:

Mais je ne suis pas satisfait de cette réponse, elle n’est pas bien expliquée (je ne l’ai pas bien comprise). En gros, je veux connaître la différence entre new object() et new {} . Comment, ils sont traités à la compilation et à 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;
}

Donc, (comme vous pouvez le voir dans les commentaires dans le code), Comment les new object(){} et new {} ?

Est-ce même la bonne façon pour moi d'écrire le code? Pouvez-vous suggérer un meilleur moyen pour ce code?

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


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

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

Les deux premiers ne sont que des façons différentes de créer un objet et d’imprimer System.Object . Le troisième est en fait un type anonyme et imprime <>f__AnonymousType0 .

Je pense que vous pourriez être dérouté par les différentes utilisations de '{}'. De mémoire, il peut être utilisé pour:

  1. Blocs de déclaration.
  2. Initialiseurs Objet / Collection / Tableau.
  3. Types anonymes

Donc, en bref, object data = new { }; ne crée pas un nouvel objet. Il crée un nouveau AnonymousType qui, comme toutes les classes, structures, énumérations et délégués, hérite de Object et peut donc être affecté à celui-ci.

Comme mentionné dans les commentaires, lorsque vous retournez des types anonymes, vous devez toujours les déclarer et les transférer en bas à Object. Cependant, ce sont toujours des choses différentes et ont 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();
}

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 la classe Object

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

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

  Object sample = new {};




.net