C # आलसी लोड स्वचालित गुण

Question 1

C # में,

क्या एक निर्धारित डिफ़ॉल्ट मान के साथ एक आलसी भरी हुई स्वचालित संपत्ति में एक स्वचालित संपत्ति को चालू करने का एक तरीका है?

अनिवार्य रूप से, मैं इसे चालू करने की कोशिश कर रहा हूं ...

private string _SomeVariable

public string SomeVariable
{
     get
     {
          if(_SomeVariable == null)
          {
             _SomeVariable = SomeClass.IOnlyWantToCallYouOnce();
          }

          return _SomeVariable;
     }
}

कुछ अलग में, जहां मैं डिफ़ॉल्ट को निर्दिष्ट कर सकता हूं और यह बाकी को स्वचालित रूप से संभालता है ...

[SetUsing(SomeClass.IOnlyWantToCallYouOnce())]
public string SomeVariable {get; private set;}

Question 2

नहीं वहाँ नहीं है। ऑटो-कार्यान्वित गुण केवल सबसे बुनियादी गुणों को लागू करने के लिए कार्य करते हैं: गेट्टर और सेटर के साथ बैकिंग फ़ील्ड। यह इस प्रकार के अनुकूलन का समर्थन नहीं करता है।

हालाँकि आप Lazy<T>इस पैटर्न को बनाने के लिए 4.0 प्रकार का उपयोग कर सकते हैं

private Lazy<string> _someVariable =new Lazy<string>(SomeClass.IOnlyWantToCallYouOnce);
public string SomeVariable => _someVariable.Value;

यह कोड _someVariableपहली बार Valueअभिव्यक्ति को कहा जाता है के मूल्य की गणना करेगा । यह केवल एक बार गणना की जाएगी और Valueसंपत्ति के भविष्य के उपयोग के लिए मूल्य को कैश करेगा

Question 3

संभवत: सबसे संक्षिप्त रूप से आप अशक्त-संचालक ऑपरेटर का उपयोग कर सकते हैं:

get { return _SomeVariable ?? (_SomeVariable = SomeClass.IOnlyWantToCallYouOnce()); }

Question 4

C # 6 में एक नई सुविधा है जिसे एक्सप्रेशन बोडीड ऑटो-प्रॉपर्टीज कहा जाता है , जो आपको इसे थोड़ा क्लीनर लिखने की अनुमति देता है:

public class SomeClass
{ 
   private Lazy<string> _someVariable = new Lazy<string>(SomeClass.IOnlyWantToCallYouOnce);

   public string SomeVariable 
   {
      get { return _someVariable.Value; }
   }
}

अब इस प्रकार लिखा जा सकता है:

public class SomeClass
{
   private Lazy<string> _someVariable = new Lazy<string>(SomeClass.IOnlyWantToCallYouOnce);

   public string SomeVariable => _someVariable.Value;
}

Question 5

ऐसा नहीं है, विशेषताओं के लिए पैरामीटर मूल्य में स्थिर होना चाहिए, आप कोड (यहां तक कि स्थिर कोड) को कॉल नहीं कर सकते।

हालाँकि आप PostSharp के पहलुओं के साथ कुछ लागू करने में सक्षम हो सकते हैं।

उनकी जाँच करो:

PostSharp

Question 6

यहाँ आपकी समस्या के समाधान का मेरा कार्यान्वयन है। मूल रूप से यह विचार एक संपत्ति है जिसे पहली बार में एक फ़ंक्शन द्वारा सेट किया जाएगा और बाद की एक्सेस पहले की तरह ही रिटर्न वैल्यू देगी।

public class LazyProperty<T>
{
    bool _initialized = false;
    T _result;

    public T Value(Func<T> fn)
    {
        if (!_initialized)
        {
            _result = fn();
            _initialized = true;
        }
        return _result;
    }
 }

फिर उपयोग करने के लिए:

LazyProperty<Color> _eyeColor = new LazyProperty<Color>();
public Color EyeColor
{ 
    get 
    {
        return _eyeColor.Value(() => SomeCPUHungryMethod());
    } 
}

बेशक फ़ंक्शन पॉइंटर को चारों ओर से गुजरने का ओवरहेड है, लेकिन यह मेरे लिए काम करता है और मैं बार-बार विधि को चलाने की तुलना में बहुत अधिक ओवरहेड को नोटिस नहीं करता हूं।

Question 7

मैं इस विचार का बहुत बड़ा प्रशंसक हूं, और मैं निम्नलिखित C # स्निपेट की पेशकश करना चाहूंगा जिसे मैंने proplazy.nippet कहा है (आप इसे आयात कर सकते हैं या इसे मानक फ़ोल्डर में पेस्ट कर सकते हैं जिसे आप स्निपेट प्रबंधक से प्राप्त कर सकते हैं)

यहाँ इसके उत्पादन का एक नमूना है:

private Lazy<int> myProperty = new Lazy<int>(()=>1);
public int MyProperty { get { return myProperty.Value; } }

यहाँ स्निपेट फ़ाइल सामग्री है: (proplazy.snippet के रूप में सहेजें)

<?xml version="1.0" encoding="utf-8" ?>
<CodeSnippets  xmlns="http://schemas.microsoft.com/VisualStudio/2005/CodeSnippet">
    <CodeSnippet Format="1.0.0">
        <Header>
            <Title>proplazy</Title>
            <Shortcut>proplazy</Shortcut>
            <Description>Code snippet for property and backing field</Description>
            <Author>Microsoft Corporation</Author>
            <SnippetTypes>
                <SnippetType>Expansion</SnippetType>
            </SnippetTypes>
        </Header>
        <Snippet>
            <Declarations>
                <Literal>
                    <ID>type</ID>
                    <ToolTip>Property type</ToolTip>
                    <Default>int</Default>
                </Literal>
                <Literal>
                    <ID>field</ID>
                    <ToolTip>The variable backing this property</ToolTip>
                    <Default>myVar</Default>
                </Literal>
                <Literal>
                    <ID>func</ID>
                    <ToolTip>The function providing the lazy value</ToolTip>
                </Literal>
                <Literal>
                    <ID>property</ID>
                    <ToolTip>Property name</ToolTip>
                    <Default>MyProperty</Default>
                </Literal>

            </Declarations>
            <Code Language="csharp"><![CDATA[private Lazy<$type$> $field$ = new Lazy<$type$>($func$);
            public $type$ $property$ { get{ return $field$.Value; } }
            $end$]]>
            </Code>
        </Snippet>
    </CodeSnippet>
</CodeSnippets>

Question 8

मुझे नहीं लगता कि यह शुद्ध C # के साथ संभव है। लेकिन आप इसे PostSharp जैसे IL rewriter का उपयोग करके कर सकते हैं । उदाहरण के लिए यह आपको विशेषताओं के आधार पर कार्यों से पहले और बाद में हैंडलर जोड़ने की अनुमति देता है।

Question 9

ऑपरेटर ?? = C # 8.0 और बाद का उपयोग करके उपलब्ध है, इसलिए अब आप इसे और भी संक्षिप्त कर सकते हैं:

private string _someVariable;

public string SomeVariable => _someVariable ??= SomeClass.IOnlyWantToCallYouOnce();

Question 10

मैंने इसे इस तरह किया:

public static class LazyCachableGetter
{
    private static ConditionalWeakTable<object, IDictionary<string, object>> Instances = new ConditionalWeakTable<object, IDictionary<string, object>>();
    public static R LazyValue<T, R>(this T obj, Func<R> factory, [CallerMemberName] string prop = "")
    {
        R result = default(R);
        if (!ReferenceEquals(obj, null))
        {
            if (!Instances.TryGetValue(obj, out var cache))
            {
                cache = new ConcurrentDictionary<string, object>();
                Instances.Add(obj, cache);

            }


            if (!cache.TryGetValue(prop, out var cached))
            {
                cache[prop] = (result = factory());
            }
            else
            {
                result = (R)cached;
            }

        }
        return result;
    }
}

और बाद में आप इसका उपयोग कर सकते हैं

       public virtual bool SomeProperty => this.LazyValue(() =>
    {
        return true; 
    });

Question 11

https://github.com/bcuff/AutoLazy आपको कुछ इस तरह से देने के लिए Fody का उपयोग करता है

public class MyClass
{
    // This would work as a method, e.g. GetSettings(), as well.
    [Lazy]
    public static Settings Settings
    {
        get
        {
            using (var fs = File.Open("settings.xml", FileMode.Open))
            {
                var serializer = new XmlSerializer(typeof(Settings));
                return (Settings)serializer.Deserialize(fs);
            }
        }
    }

    [Lazy]
    public static Settings GetSettingsFile(string fileName)
    {
        using (var fs = File.Open(fileName, FileMode.Open))
        {
            var serializer = new XmlSerializer(typeof(Settings));
            return (Settings)serializer.Deserialize(fs);
        }
    }
}

Question 12

[Serializable]
public class RaporImza
{
    private readonly Func<ReportConfig> _getReportLayout;
    public RaporImza(Func<ReportConfig> getReportLayout)
    {
        _getReportLayout = getReportLayout;
    }

    private ReportConfig _getReportLayoutResult;
    public ReportConfig GetReportLayoutResult => _getReportLayoutResult ?? (_getReportLayoutResult = _getReportLayout());

    public string ImzaAtanKisiAdi => GetReportLayoutResult.ReportSignatureName;

    public string ImzaAtanKisiUnvani => GetReportLayoutResult.ReportSignatureTitle;
    public byte[] Imza => GetReportLayoutResult.ReportSignature;
}

और मैं बंदे की तरह कहता हूं

result.RaporBilgisi = new ExchangeProgramPersonAllDataModel.RaporImza(() => _reportConfigService.GetReportLayout(documentTypeId));

Question 13

यदि आप आलसी आरंभीकरण के दौरान एक कंस्ट्रक्टर का उपयोग करते हैं, तो निम्नलिखित एक्सटेंशन भी सहायक हो सकते हैं

public static partial class New
{
    public static T Lazy<T>(ref T o) where T : class, new() => o ?? (o = new T());
    public static T Lazy<T>(ref T o, params object[] args) where T : class, new() =>
            o ?? (o = (T) Activator.CreateInstance(typeof(T), args));
}

प्रयोग

    private Dictionary<string, object> _cache;

    public Dictionary<string, object> Cache => New.Lazy(ref _cache);

                    /* _cache ?? (_cache = new Dictionary<string, object>()); */