C# Language
अनाम प्रकार

एक अनाम प्रकार बनाना

चूंकि अनाम प्रकारों का नाम नहीं दिया गया है, इसलिए उन प्रकारों के वेरिएबल्स को अंतर्निहित रूप से टाइप किया जाना चाहिए ( var )।

var anon = new { Foo = 1, Bar = 2 };
// anon.Foo == 1
// anon.Bar == 2

यदि सदस्य के नाम निर्दिष्ट नहीं किए जाते हैं, तो वे ऑब्जेक्ट को प्रारंभ करने के लिए उपयोग की गई संपत्ति / चर के नाम पर सेट होते हैं।

int foo = 1;
int bar = 2;
var anon2 = new { foo, bar };
// anon2.foo == 1
// anon2.bar == 2

ध्यान दें कि नाम केवल तब छोड़ा जा सकता है जब अनाम प्रकार की घोषणा में अभिव्यक्ति एक साधारण संपत्ति का उपयोग हो; विधि कॉल या अधिक जटिल अभिव्यक्तियों के लिए, एक संपत्ति नाम निर्दिष्ट किया जाना चाहिए।

string foo = "some string";
var anon3 = new { foo.Length };
// anon3.Length == 11
var anon4 = new { foo.Length <= 10 ? "short string" : "long string" };
// compiler error - Invalid anonymous type member declarator.
var anon5 = new { Description = foo.Length <= 10 ? "short string" : "long string" };
// OK

अनाम बनाम गतिशील

बेनामी प्रकार, स्थिर प्रकार की जाँच को बनाए रखते हुए, समय से पहले अपने प्रकारों को स्पष्ट रूप से परिभाषित किए बिना वस्तुओं के निर्माण की अनुमति देते हैं।

var anon = new { Value = 1 };
Console.WriteLine(anon.Id); // compile time error

इसके विपरीत, dynamic में गतिशील प्रकार की जाँच होती है, संकलन-समय त्रुटियों के बजाय, रनटाइम त्रुटियों का विकल्प।

dynamic val = "foo";
Console.WriteLine(val.Id); // compiles, but throws runtime error

अनाम प्रकार के साथ सामान्य तरीके

जेनेरिक विधियाँ प्रकार के अंतर्ज्ञान के माध्यम से अनाम प्रकारों के उपयोग की अनुमति देती हैं।

void Log<T>(T obj) {
    // ...
}
Log(new { Value = 10 });

इसका मतलब यह है कि LINQ अभिव्यक्तियों का उपयोग अनाम प्रकारों के साथ किया जा सकता है:

var products = new[] {
    new { Amount = 10, Id = 0 },
    new { Amount = 20, Id = 1 },
    new { Amount = 15, Id = 2 }
};
var idsByAmount = products.OrderBy(x => x.Amount).Select(x => x.Id);
// idsByAmount: 0, 2, 1

अनाम प्रकारों के साथ सामान्य प्रकार को त्वरित करना

जेनेरिक कंस्ट्रक्टरों का उपयोग करने के लिए गुमनाम प्रकारों का नाम देना होगा, जो संभव नहीं है। वैकल्पिक रूप से, जेनेरिक विधियों का उपयोग प्रकार के अनुमान लगाने के लिए किया जा सकता है।

var anon = new { Foo = 1, Bar = 2 };
var anon2 = new { Foo = 5, Bar = 10 };
List<T> CreateList<T>(params T[] items) {
    return new List<T>(items);
}

var list1 = CreateList(anon, anon2);

List<T> के मामले में, ToList टाइप किए गए सरणियों को List<T> ToList विधि के माध्यम से परिवर्तित किया जा सकता है:

var list2 = new[] {anon, anon2}.ToList();

अनाम प्रकार की समानता

बेनामी प्रकार की समानता, Equals उदाहरण विधि द्वारा दी गई है। दो वस्तुएँ समान हैं यदि उनके पास प्रत्येक संपत्ति के लिए समान प्रकार और समान मान हैं ( a.Prop.Equals(b.Prop) माध्यम से)।

var anon = new { Foo = 1, Bar = 2 };
var anon2 = new { Foo = 1, Bar = 2 };
var anon3 = new { Foo = 5, Bar = 10 };
var anon3 = new { Foo = 5, Bar = 10 };
var anon4 = new { Bar = 2, Foo = 1 };
// anon.Equals(anon2) == true
// anon.Equals(anon3) == false
// anon.Equals(anon4) == false (anon and anon4 have different types, see below)

दो अनाम प्रकारों को एक ही माना जाता है यदि और केवल यदि उनके गुणों का एक ही नाम और प्रकार है और एक ही क्रम में दिखाई देते हैं।

var anon = new { Foo = 1, Bar = 2 };
var anon2 = new { Foo = 7, Bar = 1 };
var anon3 = new { Bar = 1, Foo = 3 };
var anon4 = new { Fa = 1, Bar = 2 };
// anon and anon2 have the same type
// anon and anon3 have diferent types (Bar and Foo appear in different orders)
// anon and anon4 have different types (property names are different)

अवैध रूप से टाइप किए गए सरणियाँ

अनाम प्रकारों की सारणियां अंतर्निहित टाइपिंग के साथ बनाई जा सकती हैं।

var arr = new[] {
    new { Id = 0 },
    new { Id = 1 }
};