सी #

Question

में अपरिवर्तनीय संरचना लिखने का सबसे छोटा तरीका अक्सर मुझे छोटे अपरिवर्तनीय डेटा संरचनाओं की आवश्यकता होती है। अन्य लोग शायद इन मामलों में टुपल्स का उपयोग करेंगे, लेकिन मैं वास्तव में नापसंद करता हूं कि टुपल्स अच्छी तरह से नहीं पढ़ते हैं और इतना अर्थ व्यक्त नहीं करते हैं। Value2int मुझे कुछ भी नहीं बताता है।

एक उदाहरण दो गुणों के संयोजन के लिए एक लुकअप टेबल (शब्दकोश) बना रहा होगा, यानी Name और Rating।

public struct Key 
{ 
    public string Name { get; private set; } 
    public int  Rating { get; private set; } 

    public LolCat(string name, int rating) : this() 
    { 
     Name = name; 
     Rating = rating; 
    } 
} 

// useage 
var key = new Key("MonorailCat", 5); 

मेरी राय में वहाँ अभी भी यहाँ में'वाक्यात्मक वसा' का एक बहुत है कि मैं चाहते हैं:

इन मामलों है कि मैं के बारे में पता करने के लिए एक अपरिवर्तनीय struct बनाने के लिए सबसे छोटा रास्ता यह है छुटकारा पाना। जब मैं सिर्फ फ़ील्ड का खुलासा करता हूं तो मैं इसे और अधिक पठनीय बना सकता हूं।

public struct Key 
{ 
    public string Name; 
    public int  Rating; 
} 

// useage 
var key = new Key { Name = "MonorailCat", Rating = 5 }; 

मुझे वास्तव में इसका वाक्यविन्यास पसंद है, क्योंकि वहां कोई भी वाक्य रचनात्मक वसा नहीं है। बड़ा नुकसान यह है कि यह अपरिवर्तनीय नहीं है, इसके सभी खतरों के साथ।

आदर्श मामले में मैं सिर्फ इस बात के लिए एक विशेष प्रकार की तरह, परिभाषा के वास्तविक न्यूनतम के साथ, करना चाहते हैं:

public immutable struct Key 
{ 
    string Name; 
    int  Rating; 
} 

// useage (needs compiler magic) 
var key = new Key(Name: "MonorailCat", Rating: 5); 

प्रश्न

वहाँ एक वास्तविक दुनिया समाधान है एक बहुत ही सरल अपरिवर्तनीय संरचना के लिए सिंटैक्टिक वसा की मात्रा को कम करने के लिए नीचे के उदाहरण के करीब कुछ?

Answer 1

सी # 6 के रूप में, आप काफी कॉम्पैक्ट struct initializers लिख सकते हैं:

public struct Key 
{ 
    public string Name { get; } 
    public int Rating { get; } 

    public Key(string name, int rating) 
    { 
     this.Name = name; 
     this.Rating = rating; 
    } 
} 

... जो कम से कम काफी कम है। मैं दृढ़ता से IEquatable<Key> को लागू करने की सलाह देता हूं, आपको दिमाग में।

ध्यान दें कि आप एक struct साथ काम कर रहे हैं, तो आप अभी भी लिखने के लिए सक्षम हो जाएगा:

Key key = new Key(); 
Console.WriteLine(key.Rating); // 0 

... जो एक समस्या नहीं हो सकता है, लेकिन आम तौर पर जरूरत कम से कम पर विचार।

से पहले सी # 6, मैं वास्तव में भी लंबे समय तक अपने वर्तमान कोड से जाना चाहते हैं, ताकि केवल पढ़ने के लिए गुण के रूप में गुण लिखने के लिए:

public struct Key 
{ 
    private readonly string name; 
    private readonly int rating; 

    public string Name { get { return name; } } 
    public int Rating { get { return rating; } } 

    public Key(string name, int rating) 
    { 
     this.name = name; 
     this.rating = rating; 
    } 
} 

मुझे लगता है इस बनाता है यह और अधिक स्पष्ट रूप "होने का मतलब अपरिवर्तनीय "- यदि आपके पास एक लिखने योग्य संपत्ति है, भले ही सेटटर केवल निजी है, जो सही इंप्रेशन आईएमओ को व्यक्त नहीं करता है। (हालांकि यह ध्यान देने योग्य है कि structs में अपरिवर्तनीयता हमेशा कम बिट का एक झगड़ा है, बशर्ते आप सदस्यों में this असाइन कर सकें ...)

Answer 2

AFAIK, कम से कम आप लिखते हैं केवल पढ़ने के लिए उपयोग कर रहा है, जो आपके struct गुण का उपयोग करने से शायद ही कम है कर सकते हैं:

public struct Key 
{ 
    public readonly string Name; 
    public readonly int  Rating; 

    public Key(string name, int rating){ 
     Name = name; 
     Rating = rating; 
    } 
} 

var key = new Key("MonorailCat", 5); 

Answer 3

सी # 7.2 में एक केवल पढ़ने के लिए struct है।

readonly public struct ReadonlyPoint3D 
{ 
    public ReadonlyPoint3D(double x, double y, double z) 
    { 
     this.X = x; 
     this.Y = y; 
     this.Z = z; 
    } 
    //setters would not compile 
    public double X { get; } 
    public double Y { get; } 
    public double Z { get; } 

    private static ReadonlyPoint3D origin = new ReadonlyPoint3D(); 
    public static ref readonly ReadonlyPoint3D Origin => ref origin; 
    public ReadonlyPoint3D Scale(double factor) 
    { 
     /* all fail compilation 
     X *= factor; 
     Y *= factor; 
     Z *= factor; 
     */ 
     return new ReadonlyPoint3D(X * factor, Y * factor, Z * factor); 
    } 
} 

कंपाइलर लागू करता है कि सभी सदस्य केवल पढ़े जाते हैं। यह रिसीवर की प्रतिलिपि के बजाय संदर्भ में 'इन' संदर्भ के रूप में पारित होता है जो आमतौर पर अधिक कुशल होता है।

Reference