C # Властиві автоматичні властивості

У 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;}

Ні, немає. Автоматично реалізовані властивості функціонують лише для реалізації основних основних властивостей: поле резервного копіювання за допомогою getter та setter. Він не підтримує цей тип налаштування.

Однак ви можете використовувати Lazy<T>тип 4.0 для створення цього шаблону

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

Цей код ліниво обчислить значення _someVariableпершого разу, коли Valueвикликається вираз. Він буде обчислений лише один раз і буде кешувати значення для майбутнього використання Valueресурсу

Напевно, найбільш стислим, що ви можете отримати, є використання оператора зведення нуля:

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

В C # 6 з'явилася нова функція під назвою Auto-властивості Expression Bodied , яка дозволяє написати її трохи чистіше:

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;
}

Не так, параметри атрибутів повинні бути постійними у значенні, ви не можете викликати код (Навіть статичний код).

Однак ви, можливо, зможете щось реалізувати з аспектами PostSharp.

Перевірте їх:

PostSharp

Ось моя реалізація рішення вашої проблеми. В основному ідея - це властивість, яка буде задана функцією при першому доступі, і наступні звернення дадуть те саме повернене значення, що і перше.

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());
    } 
}

Звичайно, є накладні витрати на передачу функціонального вказівника навколо, але це робить для мене роботу, і я не помічаю занадто багато накладних витрат порівняно із запуском методу знову і знову.

Я великий прихильник цієї ідеї, і я хотів би запропонувати наступний фрагмент C #, який я назвав proplazy.snippet. (Ви можете імпортувати це або вставити його в стандартну папку, яку ви можете отримати у диспетчера Snippet)

Ось зразок її результату:

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>

Я не думаю, що це можливо для чистого C #. Але ви могли це зробити, використовуючи переписувач IL, як PostSharp . Наприклад, це дозволяє додавати обробники до і після функцій залежно від атрибутів.

Я зробив це так:

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; 
    });

Оператор ?? = доступний за допомогою C # 8.0 та новіших версій, тому тепер ви можете зробити це ще більш стисло:

private string _someVariable;

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

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);
        }
    }
}

[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));

Якщо ви використовуєте конструктор під час ледачої ініціалізації, наступні розширення також можуть бути корисними

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>()); */