सी # में `नई वस्तु()` और `नया {}` के बीच अंतर क्या है?

Question

सब मैं इस पर खोज की सबसे पहले और मैं स्टैक ओवरफ़्लो पर निम्न लिंक पाया:

• Is there any difference between `new object()` and `new {}` in c#?
• Difference between object a = new Dog() vs Dog a = new Dog()

लेकिन मैं संतुष्ट इस जवाब के साथ नहीं कर रहा हूँ, यह नहीं है अच्छी तरह से समझाया (मुझे यह अच्छी तरह से नहीं मिला)। असल में, मैं new object() और new {} के बीच का अंतर जानना चाहता हूं। कैसे, उनका संकलन समय और रनटाइम पर व्यवहार किया जाता है?

Secondaly, मैं निम्नलिखित कोड है जो मैं अपने asp.net सरल आवेदन में WebMethods के लिए इस्तेमाल किया है

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

तो, (आप कोड में टिप्पणियां में देख सकते हैं), कैसे new object(){} और new {} मतभेद हैं ?

क्या यह सही तरीका है कि मैंने कोड लिखा है? क्या आप इस कोड के लिए सबसे अच्छा तरीका सुझा सकते हैं?

मुझे पता है, मैं इसे अच्छी तरह से समझा नहीं सकता और मैं बहुत कुछ पूछ रहा हूं, लेकिन यह अभी मेरे पास सबसे अच्छा है।

Answer 1

new {...} हमेशा एक गुमनाम वस्तु बनाता है, उदाहरण के लिए:

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

जबकि new Object()Object वर्ग

का एक उदाहरण बनाता है

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

सभी ऑब्जेक्ट्स (एनीनी समेत समझौता ज्ञापनों वाले) Object से प्राप्त कर रहे आप हमेशा टाइप कर सकते हैं

Object sample = new {}; 

Answer 2

new{ } किसी भी सदस्य के साथ अज्ञात प्रकार का उदाहरण बनाता है। यह object का उदाहरण बनाने से अलग है। लेकिन लगभग सभी प्रकार की तरह, अज्ञात प्रकार ऑब्जेक्ट को असाइन किए जा सकते हैं।

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

स्पष्ट रूप से एक ऑटो-जनरेटेड नाम दिखाता है, Object नहीं।

Answer 3

new Object() और new {} और new Object(){} के बीच अंतर देखने के लिए ... हम क्यों नहीं पता?

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

पहले दो एक वस्तु और प्रिंट System.Object बनाने का सिर्फ विभिन्न तरीके हैं। तीसरा वास्तव में एक अनाम प्रकार है और <>f__AnonymousType0 प्रिंट करता है।

मुझे लगता है कि आप '{}' के विभिन्न उपयोगों से भ्रमित हो रहे हैं। मेरे सिर के ऊपर से इसका उपयोग किया जा सकता है:

1. स्टेटमेंट ब्लॉक।
2. ऑब्जेक्ट/संग्रह/ऐरे प्रारंभिक।
3. बेनामी प्रकार

तो, कम object data = new { }; में एक नई वस्तु बनाने नहीं करता है। यह एक नया अनामित प्रकार बनाता है, जैसे all classes, structures, enumerations, and delegates ऑब्जेक्ट विरासत में है और इसके लिए इसे असाइन किया जा सकता है।

---

जैसा कि टिप्पणियों में उल्लिखित है, अनाम प्रकारों को लौटने पर आपने अभी भी ऑब्जेक्ट को घोषित और घटा दिया है।हालांकि, वे अभी भी अलग बातें हैं और उदाहरण के लिए कुछ कार्यान्वयन अंतर हैं:

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