क्या पैरामीटर स्थिर हो सकते हैं?

Question 1

मैं जावा के C # समतुल्य की तलाश कर रहा हूं final। क्या यह मौजूद है?

क्या C # में निम्नलिखित की तरह कुछ भी है:

public Foo(final int bar);

उपरोक्त उदाहरण में, barकेवल पढ़ने योग्य चर है और इसके द्वारा परिवर्तित नहीं किया जा सकता है Foo()। क्या C # में ऐसा करने का कोई तरीका है?

उदाहरण के लिए, हो सकता है मैं एक लंबे विधि के साथ काम किया जाएगा x, yऔर zकिसी वस्तु (ints) के निर्देशांक। मैं पूरी तरह से निश्चित होना चाहता हूं कि फ़ंक्शन इन मानों को किसी भी तरह से नहीं बदलता है, जिससे डेटा दूषित हो जाता है। इस प्रकार, मैं उन्हें आसानी से घोषित करना चाहूंगा।

public Foo(int x, int y, int z) {
     // do stuff
     x++; // oops. This corrupts the data. Can this be caught at compile time?
     // do more stuff, assuming x is still the original value.
}

Question 2

दुर्भाग्य से आप C # में ऐसा नहीं कर सकते।

constकीवर्ड केवल स्थानीय चर और क्षेत्रों के लिए इस्तेमाल किया जा सकता।

readonlyकीवर्ड केवल खेतों पर इस्तेमाल किया जा सकता।

नोट: जावा भाषा भी एक विधि के लिए अंतिम मापदंडों का समर्थन करती है। यह कार्यक्षमता C # में मौजूद नहीं है।

से http://www.25hoursaday.com/CsharpVsJava.html

EDIT (2019/08/13): मैं इसे दृश्यता के लिए फेंक रहा हूं क्योंकि यह स्वीकार किया जाता है और सूची में उच्चतम है। यह अब inमापदंडों के साथ संभव है । देखें जवाब जानकारी के लिए इस एक नीचे।

Question 3

यह अब C # संस्करण 7.2 में संभव है:

आप inविधि हस्ताक्षर में कीवर्ड का उपयोग कर सकते हैं । MSDN प्रलेखन ।

inएक प्रणाली के तर्क को निर्दिष्ट से पहले जोड़ा जाना चाहिए।

उदाहरण, C # 7.2 में एक मान्य विधि:

public long Add(in long x, in long y)
{
    return x + y;
}

जबकि निम्नलिखित की अनुमति नहीं है:

public long Add(in long x, in long y)
{
    x = 10; // It is not allowed to modify an in-argument.
    return x + y;
}

निम्नलिखित त्रुटि को तब दिखाया जाएगा जब या तो संशोधित करने का प्रयास किया जाएगा xy वे या कर रहे हैं या जब से वे चिह्नित हैं in:

'लॉन्ग' में वेरिएबल को असाइन नहीं किया जा सकता क्योंकि यह एक आसानी से वेरिएबल है

के साथ एक तर्क चिह्नित करना inसाधनों के :

यह विधि इस पैरामीटर के रूप में उपयोग किए गए तर्क के मूल्य को संशोधित नहीं करती है।

Question 4

यहाँ एक छोटा और मीठा जवाब है जो शायद बहुत सारे वोटों को प्राप्त करेगा। मैंने सभी पोस्ट और टिप्पणियों को नहीं पढ़ा है, इसलिए कृपया मुझे क्षमा करें यदि यह पहले सुझाया गया है।

अपने मापदंडों को क्यों न लें और उन्हें एक ऐसी वस्तु के रूप में पारित करें जो उन्हें अपरिवर्तनीय के रूप में उजागर करता है और फिर उस वस्तु का अपने तरीके से उपयोग करता है?

मुझे लगता है कि यह संभवतः एक बहुत ही स्पष्ट कार्य है जिसके बारे में पहले ही विचार किया जा चुका है और ओपी इस सवाल को पूछकर ऐसा करने से बचने की कोशिश कर रहा है, लेकिन मुझे लगा कि यह यहाँ होना चाहिए और कम नहीं ...

सौभाग्य :-)

Question 5

उत्तर: C # में C ++ जैसी कास्ट फंक्शनलिटी नहीं है।

मैं बेनेट डिल से सहमत हूं।

Const कीवर्ड बहुत उपयोगी है। उदाहरण में, आपने एक int का उपयोग किया है और लोगों को आपकी बात समझ में नहीं आती है। लेकिन, क्यों अगर आप पैरामीटर उपयोगकर्ता की विशाल और जटिल वस्तु है जिसे उस फ़ंक्शन के अंदर नहीं बदला जा सकता है? यह कॉन्स्टेबल कीवर्ड का उपयोग है: पैरामीटर उस पद्धति के अंदर नहीं बदल सकता है क्योंकि [यहाँ जो भी कारण है] जो उस पद्धति के लिए मायने नहीं रखता है। कॉन्स्ट कीवर्ड बहुत शक्तिशाली है और मैं वास्तव में इसे सी # में याद करता हूं।

Question 6

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

चलो संदर्भ प्रकारों पर चलते हैं। अब यह थोड़ा भ्रमित हो जाता है। क्या आपका मतलब एक निरंतर संदर्भ है, जहां संदर्भ को स्वयं बदला नहीं जा सकता है, या पूरी तरह से बंद, अपरिवर्तनीय वस्तु? यदि पूर्व, डिफ़ॉल्ट रूप से .Net में संदर्भ मूल्य द्वारा पारित किए जाते हैं। यही है, आपको संदर्भ की एक प्रति मिलती है। इसलिए हमारे पास अनिवार्य रूप से वैसी ही स्थिति है जैसे मूल्य प्रकारों के लिए। यदि कार्यान्वयनकर्ता को मूल संदर्भ की आवश्यकता होगी तो वे इसे स्वयं रख सकते हैं।

बस हमें निरंतर (लॉक / अपरिवर्तनीय) वस्तु के साथ छोड़ देता है। यह एक रनटाइम परिप्रेक्ष्य से ठीक लग सकता है, लेकिन संकलक इसे लागू करने के लिए कैसे है? चूंकि गुण और विधियां सभी दुष्प्रभाव हो सकती हैं, आप अनिवार्य रूप से केवल-पढ़ने के लिए क्षेत्र तक ही सीमित रहेंगे। इस तरह की वस्तु बहुत दिलचस्प होने की संभावना नहीं है।

Question 7

अपनी कक्षा के लिए एक इंटरफ़ेस बनाएँ जिसमें केवल आसानी से संपत्ति एक्सेसर्स हों। तब आपका पैरामीटर क्लास के बजाय उस इंटरफ़ेस का होगा। उदाहरण:

public interface IExample
{
    int ReadonlyValue { get; }
}

public class Example : IExample
{
    public int Value { get; set; }
    public int ReadonlyValue { get { return this.Value; } }
}


public void Foo(IExample example)
{
    // Now only has access to the get accessors for the properties
}

स्ट्रक्चर्स के लिए, एक जेनेरिक कास्ट रैपर बनाएं।

public struct Const<T>
{
    public T Value { get; private set; }

    public Const(T value)
    {
        this.Value = value;
    }
}

public Foo(Const<float> X, Const<float> Y, Const<float> Z)
{
// Can only read these values
}

हालांकि यह ध्यान देने योग्य है कि यह अजीब है कि आप वह करना चाहते हैं जो आप स्ट्रक्चर्स के संबंध में करने के लिए कह रहे हैं, क्योंकि विधि के लेखक से आपको यह जानने की उम्मीद करनी चाहिए कि उस पद्धति में क्या चल रहा है। यह विधि के भीतर उन्हें संशोधित करने के लिए पास किए गए मानों को प्रभावित नहीं करेगा, इसलिए आपकी एकमात्र चिंता यह सुनिश्चित कर रही है कि आप अपने द्वारा लिखी गई विधि में स्वयं व्यवहार करें। एक बिंदु आता है जहां सतर्कता और साफ कोड कुंजी और ऐसे अन्य नियमों को लागू करने के लिए महत्वपूर्ण है।

Question 8

यदि आप अक्सर इस तरह की परेशानी में रहते हैं, तो आपको "एप्स" पर विचार करना चाहिए। अच्छी किस्म, बुरे किस्म के विपरीत । हालांकि यह आम तौर पर एक विधि पैरामीटर के निरंतर-नेस को व्यक्त करने की कोशिश नहीं करता है (जो कि बहुत ही असामान्य है), निश्चित रूप से ऐसा कुछ भी नहीं है जो आपको पहचानकर्ता नाम से पहले एक अतिरिक्त "सी" से निपटने से रोकता है।

अब डाउनवोट बटन को स्लैम करने के लिए उन सभी के लिए, कृपया इस विषय पर इन प्रकाशकों की राय पढ़ें:

Question 9

मुझे पता है कि इसमें थोड़ी देर हो सकती है। लेकिन जो लोग अभी भी इसके लिए अन्य तरीके खोज रहे हैं, उनके लिए C # मानक की इस सीमा के आसपास एक और तरीका हो सकता है। हम रैपर क्लास ReadOnly <T> लिख सकते हैं जहां T: संरचना है। बेस प्रकार टी के निहितार्थ रूपांतरण के साथ लेकिन रैपर <T> वर्ग के लिए केवल स्पष्ट रूपांतरण। यदि कंपाइलर त्रुटियों को लागू करेगा, यदि डेवलपर ReadOnly <T> प्रकार के मान को सेट करने का प्रयास करता है। जैसा कि मैं नीचे दो संभावित उपयोग प्रदर्शित करूंगा।

परिवर्तन के लिए 1 आवश्यक कॉलर परिभाषा का उपयोग करें। यह उपयोग केवल आपके "TestCalled" फ़ंक्शन कोड की शुद्धता के लिए परीक्षण में उपयोग होगा। रिलीज के स्तर पर / निर्माण करते समय आपको इसका उपयोग नहीं करना चाहिए। चूंकि बड़े पैमाने पर गणितीय कार्य रूपांतरणों में हावी हो सकते हैं, और आपके कोड को धीमा कर सकते हैं। मैं इसका उपयोग नहीं करूंगा, लेकिन प्रदर्शन के उद्देश्य से ही मैंने इसे पोस्ट किया है।

उपयोग 2 जो मैं सुझाऊंगा, उसमें टेस्टकॉलड 2 फ़ंक्शन में प्रदर्शित डिबग बनाम रिलीज़ उपयोग है। इस दृष्टिकोण का उपयोग करते समय TestCaller फ़ंक्शन में कोई रूपांतरण नहीं होगा, लेकिन इसके लिए संकलक कंडीशनिंग का उपयोग करके TestCaller2 परिभाषाओं के कोडिंग की थोड़ी अधिक आवश्यकता होती है। आप डिबग कॉन्फ़िगरेशन में कंपाइलर त्रुटियों को नोटिस कर सकते हैं, जबकि रिलीज़ कॉन्फ़िगरेशन पर TestCalled2 फ़ंक्शन में सभी कोड सफलतापूर्वक संकलित करेंगे।

using System;
using System.Collections.Generic;

public class ReadOnly<VT>
  where VT : struct
{
  private VT value;
  public ReadOnly(VT value)
  {
    this.value = value;
  }
  public static implicit operator VT(ReadOnly<VT> rvalue)
  {
    return rvalue.value;
  }
  public static explicit operator ReadOnly<VT>(VT rvalue)
  {
    return new ReadOnly<VT>(rvalue);
  }
}

public static class TestFunctionArguments
{
  static void TestCall()
  {
    long a = 0;

    // CALL USAGE 1.
    // explicite cast must exist in call to this function
    // and clearly states it will be readonly inside TestCalled function.
    TestCalled(a);                  // invalid call, we must explicit cast to ReadOnly<T>
    TestCalled((ReadOnly<long>)a);  // explicit cast to ReadOnly<T>

    // CALL USAGE 2.
    // Debug vs Release call has no difference - no compiler errors
    TestCalled2(a);

  }

  // ARG USAGE 1.
  static void TestCalled(ReadOnly<long> a)
  {
    // invalid operations, compiler errors
    a = 10L;
    a += 2L;
    a -= 2L;
    a *= 2L;
    a /= 2L;
    a++;
    a--;
    // valid operations
    long l;
    l = a + 2;
    l = a - 2;
    l = a * 2;
    l = a / 2;
    l = a ^ 2;
    l = a | 2;
    l = a & 2;
    l = a << 2;
    l = a >> 2;
    l = ~a;
  }


  // ARG USAGE 2.
#if DEBUG
  static void TestCalled2(long a2_writable)
  {
    ReadOnly<long> a = new ReadOnly<long>(a2_writable);
#else
  static void TestCalled2(long a)
  {
#endif
    // invalid operations
    // compiler will have errors in debug configuration
    // compiler will compile in release
    a = 10L;
    a += 2L;
    a -= 2L;
    a *= 2L;
    a /= 2L;
    a++;
    a--;
    // valid operations
    // compiler will compile in both, debug and release configurations
    long l;
    l = a + 2;
    l = a - 2;
    l = a * 2;
    l = a / 2;
    l = a ^ 2;
    l = a | 2;
    l = a & 2;
    l = a << 2;
    l = a >> 2;
    l = ~a;
  }

}

Question 10

यदि संरचना को एक विधि में पारित किया जाता है, जब तक कि इसे रेफ द्वारा पारित नहीं किया जाता है, तो इसे उस विधि द्वारा परिवर्तित नहीं किया जाएगा जिसे इसे पारित किया गया है। तो इस मायने में, हाँ।

क्या आप ऐसा पैरामीटर बना सकते हैं जिसका मान विधि के भीतर नहीं रखा जा सकता है या जिनके गुण विधि के भीतर सेट नहीं किए जा सकते हैं? नहीं। आप मूल्य को विधि के भीतर नियत होने से नहीं रोक सकते, लेकिन आप इसे अपरिवर्तनीय प्रकार का निर्माण करने से रोक सकते हैं।

सवाल यह नहीं है कि क्या पैरामीटर या इसके गुण विधि के भीतर सौंपे जा सकते हैं। सवाल यह है कि विधि से बाहर निकलने पर यह क्या होगा।

यदि आप किसी कक्षा को पास करते हैं और उसमें से किसी एक गुण को बदलते हैं, या यदि आप रेफ कीवर्ड का उपयोग करके कोई मान पास करते हैं, तो केवल एक बार ही बाहर का डेटा बदल दिया जाएगा। आपके द्वारा उल्लिखित स्थिति न तो है।