दिलचस्प "रेफरी के पैरा" सुविधा, कोई कामकाज?

Question

मुझे आश्चर्य है अगर वहाँ इस तरह किसी भी तरह से कुछ मूल्य प्रकार के लिए संभव हो जाएगा ...

public static class ExtensionMethods { 
    public static void SetTo(this Boolean source, params Boolean[] bools) { 
     for (int i = 0; i < bools.Length; i++) { 
      bools[i] = source; 
     } 
    } 
} 

तो यह संभव होगा:

Boolean a = true, b, c = true, d = true, e; 
b.SetTo(a, c, d, e); 

बेशक

, इस वजह bools काम नहीं करता है एक मान प्रकार हैं ताकि वे फ़ंक्शन में एक मान के रूप में पारित हो जाएं, संदर्भ के रूप में नहीं।

मूल्य प्रकारों को संदर्भ प्रकारों (दूसरे वर्ग बनाकर) में लपेटने के अलावा, पैराम संशोधक का उपयोग करते समय संदर्भ (रेफरी) द्वारा फ़ंक्शन में चर को पार करने का कोई तरीका है?

Answer 1

यह संभव नहीं है। क्यों की व्याख्या करने के लिए, पहले क्यों यह है कि हम उन्हें ढेर पर रख कर मान प्रकार की स्थानीय चर का आवंटन रद्द करने का अनुकूलन पर अपने निबंध पढ़ें:

http://blogs.msdn.com/ericlippert/archive/2009/05/04/the-stack-is-an-implementation-detail-part-two.aspx

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

लेकिन चलो इस बारे में थोड़ा गहरा सोचें। यदि आप चाहते हैं कि "चीज जो मुझे एक चर सेट करने की अनुमति देती है" पास हो, तो हमारे पास है जो है। यह सिर्फ एक प्रतिनिधि है:

static void DoStuff<T>(this T thing, params Action<T>[] actions) 
{ 
    foreach(var action in actions) action(thing); 
} 
... 
bool b = whatever; 
b.DoStuff(x=>{q = x;}, x=>{r = x;}); 

समझ में आता है?

Answer 2

यह संभव नहीं होगा यदि bool एस संदर्भ प्रकार थे। जबकि एक class एक संदर्भ प्रकार है, Boolean[] में चर अभी भी एक मूल्य है यह है कि अभी मूल्य एक संदर्भ है। संदर्भ के मान को असाइन करना केवल उस विशेष चर के मान को बदलता है। ref चर की एक सरणी की अवधारणा समझ में नहीं आती है (जैसे कि सरणी, उनकी प्रकृति से, मूल्यों की एक श्रृंखला है)।

Answer 3

वास्तव में कोई रास्ता नहीं है। कैसे है किसी भी सिर्फ ऐसा करने से बेहतर है कि

public static void Main(string[] args) 
{ 
    BooleanWrapper a = true, b = true, c = true, d = true, e = new BooleanWrapper(); 
    b.SetTo(a, c, d, e); 
} 

public static void SetTo(this BooleanWrapper sourceWrapper, params BooleanWrapper[] wrappers) 
{ 
    foreach (var w in wrappers) 
     w.Value = sourceWrapper.Value; 
} 

public class BooleanWrapper 
{ 
    public BooleanWrapper() { } 

    public BooleanWrapper(Boolean value) 
    { 
     Value = value; 
    } 

    public Boolean Value { get; set; } 

    public static implicit operator BooleanWrapper(Boolean value) 
    { 
     return new BooleanWrapper(value); 
    } 
} 

लेकिन तब फिर से:

public static void Main(string[] args) 
{ 
    Boolean[] bools = new Boolean[5]; 
    bools.SetTo(bools[1]); // Note I changed the order of arguments. I think this makes more sense. 
} 

public static void SetTo(this Boolean[] bools, Boolean value) 
{ 
    for(int i = 0; i < bools.Length; i++) 
     bools[i] = value; 
} 

सब के बाद, एक सरणी चर का एक क्रम है आप कुछ इस तरह कर सकता है। यदि आपको चर की अनुक्रम की तरह व्यवहार करने की आवश्यकता है, तो एक सरणी का उपयोग करें।

Answer 4

दुर्भाग्य से जावा का समुदाय, और अब .NET, डेवलपर्स ने फैसला किया कि "सुरक्षा" के नाम पर कम लचीलापन पसंदीदा समाधान है, और उसी परिणाम को प्राप्त करने के लिए आपको असाधारण जटिलता का चयन करना होगा (उन सभी वर्ग संरचनाओं, प्रतिनिधियों, आदि)।

डेल्फी में मैं बस कुछ इस तरह कर सकता है:

var 
    a: integer; f: double; n: integer; 
sscanf(fmtstr, valuestr, [@a, @f, @n]); 

// < - "sscanf" एक समारोह मैं अपने आप को लिखा है कि संकेत का एक खुला सरणी लेता है।

सी # में आप क्या करना है जाएगा:

int a; double f; int n; 
object [] o = new object[]; 
sscanf(fmtstr, valuestr, ref o); 
a = o[0]; 
f = o[1]; 
n = o[2]; 

क्या मैं डेल्फी कोड की 1 लाइन में कर सकता है ऐसा करने के लिए कोड के 5 लाइनों है कि। मुझे लगता है कि वहां कोई फॉर्मूला है कि कोड में बग की संभावना कोड की रेखाओं की संख्या के साथ ज्यामितीय रूप से बढ़ जाती है; इसलिए यदि आपके पास कोड की 20 लाइनें हैं तो आपके पास कोड होने की तुलना में 4 गुना अधिक बग होने की संभावना है।

बेशक, आप उन सभी अजीब कोण के साथ प्रतिनिधि का उपयोग कर कोड की अपनी # पंक्तियां घटा सकते हैं ब्रैकेट और अजीब वाक्यविन्यास, लेकिन मुझे लगता है कि यह भी बग के लिए एक स्वर्ग है।

सादगी के साथ क्या हुआ?