मैं अक्सर खुद को ऐसी संपत्ति लिखता हूं जिसका मूल्यांकन आलसी ढंग से किया जाता है। कुछ की तरह:"LazyProperty" वर्ग को कार्यान्वित करना - क्या यह एक अच्छा विचार है?
if (backingField == null)
backingField = SomeOperation();
return backingField;
यह बहुत कोड नहीं है, लेकिन यह एक बहुत दोहराया पड़ता कि आप संपत्तियों की एक बहुत कुछ है।
मैं एक वर्ग LazyProperty बुलाया परिभाषित करने के बारे में सोच रहा हूँ: इस तरह एक क्षेत्र प्रारंभ करने में
public class LazyProperty<T>
{
private readonly Func<T> getter;
public LazyProperty(Func<T> getter)
{
this.getter = getter;
}
private bool loaded = false;
private T propertyValue;
public T Value
{
get
{
if (!loaded)
{
propertyValue = getter();
loaded = true;
}
return propertyValue;
}
}
public static implicit operator T(LazyProperty<T> rhs)
{
return rhs.Value;
}
}
यह मैं सक्षम होगा:
first = new LazyProperty<HeavyObject>(() => new HeavyObject { MyProperty = Value });
और फिर संपत्ति के शरीर के लिए कम किया जा सकता :
public HeavyObject First { get { return first; } }
इसका उपयोग अधिकांश कंपनी द्वारा किया जाएगा, क्योंकि यह एक में जाएगा हमारे अधिकांश उत्पादों द्वारा साझा की जाने वाली सामान्य श्रेणी पुस्तकालय।
मैं यह तय नहीं कर सकता कि यह एक अच्छा विचार है या नहीं। मुझे लगता है कि समाधान कुछ पेशेवरों हैं, जैसे:
- कम कोड
- सुंदर कोड
नकारात्मक पक्ष पर, यह कोड को देखो और निर्धारित वास्तव में क्या होता है करने के लिए कठिन हो सकता है - खासकर अगर एक डेवलपर LazyProperty कक्षा से परिचित नहीं है।
आपको क्या लगता है? क्या यह एक अच्छा विचार है या मुझे इसे छोड़ देना चाहिए? इसके अलावा, निहित ऑपरेटर एक अच्छा विचार है, या आप इस वर्ग का उपयोग करने के लिए स्पष्ट रूप से मूल्य संपत्ति का उपयोग करना पसंद करेंगे?
राय और सुझावों :-)
आपका बिंदु निहित ऑपरेटर के बारे में नोट किया गया है। यह उन चीजों में से एक है जिनके बारे में मुझे राय चाहिए। – driis
पेडेंटिक होना अच्छा है। +1। – dalle