सी #: रीडोनली structs पर उत्परिवर्तन क्यों नहीं टूटते हैं?

Question

सी # में, अगर आपके पास एक struct तो जैसे:

struct Counter 
{ 
    private int _count; 

    public int Value 
    { 
     get { return _count; } 
    } 

    public int Increment() 
    { 
     return ++_count; 
    } 
} 

और आप तो जैसे किसी प्रोग्राम:

static readonly Counter counter = new Counter(); 

static void Main() 
{ 
    // print the new value from the increment function 
    Console.WriteLine(counter.Increment()); 
    // print off the value stored in the item 
    Console.WriteLine(counter.Value); 
} 

कार्यक्रम का उत्पादन होगा:

1 
0 

यह पूरी तरह गलत लगता है। मैं या तो आउटपुट को दो 1s होने की उम्मीद करता हूं (जैसा कि Counterclass है या struct Counter : ICounter और counterICounter है) या संकलन त्रुटि हो। मुझे एहसास है कि संकलन समय पर इसका पता लगाना एक कठिन मामला है, लेकिन यह व्यवहार तर्क का उल्लंघन करता प्रतीत होता है।

क्या इस व्यवहार के कार्यान्वयन में कठिनाई से परे कोई कारण है?

Answer 1

structs मूल्य प्रकार हैं और इसलिए एक मूल्य प्रकार sematics है। इसका मतलब यह है कि हर बार जब आप उस संरचना तक पहुंचते हैं जो आप मूल रूप से संरचना के मूल्य की एक प्रति के साथ काम करते हैं।

अपने नमूने में आप मूल struct नहीं बदलते हैं लेकिन इसकी एक अस्थायी प्रतिलिपि भी बदलते हैं।

आगे स्पष्टीकरण के लिए यहाँ देखें:

Why are mutable structs evil

Answer 2

.net में, एक struct उदाहरण विधि शब्दार्थ struct के एक अतिरिक्त ref पैरामीटर के साथ एक स्थिर struct विधि के बराबर है प्रकार।

struct Blah { 
    public int value; 
    public void Add(int Amount) { value += Amount; } 
    public static void Add(ref Blah it; int Amount; it.value += Amount;} 
} 

प्रणाली को बुलाती है:

someBlah.Add(5); 
Blah.Add(ref someBlah, 5); 

, शब्दार्थ बराबर हैं एक भिन्नता होती है: इस प्रकार, घोषणाओं को देखते हुए बाद कॉल केवल तभी someBlah एक परिवर्तनशील भंडारण स्थान है की अनुमति दी जाएगी (चर, क्षेत्र, इत्यादि) और नहीं, अगर यह केवल पढ़ने के लिए भंडारण स्थान है, या अस्थायी मूल्य (संपत्ति पढ़ने का परिणाम इत्यादि)।

इस समस्या के साथ .NET भाषाओं के डिजाइनरों का सामना करना पड़ा: केवल-पढ़ने वाले structs पर किसी भी सदस्य फ़ंक्शन के उपयोग को अस्वीकार करना परेशान होगा, लेकिन वे सदस्य फ़ंक्शंस को केवल पढ़ने योग्य चरों को लिखने की अनुमति नहीं देना चाहते थे। उन्होंने "पंट" करने का फैसला किया, और इसे बनाने के लिए ताकि एक पठनीय संरचना पर एक इंस्टेंस विधि को बुलाया जा सके, संरचना की एक प्रति बनायेगा, उस पर फ़ंक्शन का आह्वान करेगा, और फिर इसे छोड़ दें। इसका उदाहरण उदाहरण विधियों को कॉल धीमा करने का प्रभाव है जो अंतर्निहित संरचना नहीं लिखते हैं, और इसे बनाने के लिए एक विधि का उपयोग करने का प्रयास जो केवल पढ़ने के लिए संरचना पर अंतर्निहित संरचना को अद्यतन करता है विभिन्न टूटा अर्थशास्त्र क्या होगा अगर यह सीधे संरचना पारित किया गया तो हासिल किया जाएगा। ध्यान दें कि प्रतिलिपि द्वारा लिया गया अतिरिक्त समय लगभग उन मामलों में सही अर्थशास्त्र नहीं देगा जो प्रतिलिपि के बिना सही नहीं होते।

.NET में मेरे प्रमुख peeves में से एक यह है कि अभी भी (कम से कम 4.0, और शायद 4.5 के रूप में) अभी भी कोई विशेषता नहीं है जिसके माध्यम से एक स्ट्रक्चर सदस्य फ़ंक्शन इंगित कर सकता है कि यह this संशोधित करता है या नहीं।लोग रेलवे को अस्थायी रूप से उत्परिवर्तनीय तरीकों की पेशकश करने की अनुमति देने के लिए टूल प्रदान करने के बजाय, कैसे प्रदान किए जाने के बजाय structs अपरिवर्तनीय होना चाहिए। यह, इस तथ्य के बावजूद कि तथाकथित "अपरिवर्तनीय" structs एक झूठ हैं। म्यूटेबल स्टोरेज स्थानों में सभी गैर-तुच्छ मान प्रकार म्यूटेबल हैं, जैसा कि सभी बॉक्स किए गए मान प्रकार हैं। एक संरचना "अपरिवर्तनीय" बनाना एक संपूर्ण संरचना को फिर से लिखने के लिए मजबूर कर सकता है जब कोई केवल एक फ़ील्ड बदलना चाहता है, लेकिन struct1 = struct2 स्ट्रक्चर 2 से सभी सार्वजनिक और निजी फ़ील्ड की प्रतिलिपि बनाकर संरचना 1 को परिवर्तित करता है, और संरचना के लिए प्रकार की परिभाषा कुछ भी नहीं है इसे रोकने के लिए कर सकते हैं (किसी भी फ़ील्ड को छोड़कर) यह संरचना सदस्यों के अप्रत्याशित उत्परिवर्तन को रोकने के लिए कुछ भी नहीं करता है। इसके अलावा, थ्रेडिंग मुद्दों के कारण, structs उनके क्षेत्रों के बीच किसी प्रकार के invariant संबंध को लागू करने की उनकी क्षमता में बहुत सीमित हैं। आईएमएचओ, यह आम तौर पर मनमाने ढंग से क्षेत्र की पहुंच की अनुमति देने के लिए एक संरचना के लिए बेहतर होगा, यह स्पष्ट कर देगा कि किसी भी कोड को एक स्ट्रक्चर प्राप्त करने के लिए यह जांच करनी चाहिए कि क्या उसके क्षेत्र सभी आवश्यक स्थितियों को पूरा करते हैं, जो कि उन शर्तों के निर्माण को रोकने की कोशिश करते हैं, जो शर्तों को पूरा नहीं करते हैं।