Thuộc tính tự động được tải C # Lazy

Trong C #,

Có cách nào để biến thuộc tính tự động thành thuộc tính tự động được tải chậm với giá trị mặc định được chỉ định không?

Về cơ bản, tôi đang cố gắng biến điều này ...

private string _SomeVariable

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

          return _SomeVariable;
     }
}

thành một cái gì đó khác, nơi tôi có thể chỉ định mặc định và nó tự động xử lý phần còn lại ...

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

Không có. Các thuộc tính được triển khai tự động chỉ có chức năng triển khai các thuộc tính cơ bản nhất: trường sao lưu với getter và setter. Nó không hỗ trợ loại tùy chỉnh này.

Tuy nhiên, bạn có thể sử dụng Lazy<T>kiểu 4.0 để tạo mẫu này

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

Đoạn mã này sẽ lười biếng tính toán giá trị của _someVariablelần đầu tiên Valuebiểu thức được gọi. Nó sẽ chỉ được tính một lần và sẽ lưu vào bộ nhớ cache giá trị cho các lần sử dụng thuộc Valuetính trong tương lai

Có lẽ cách ngắn gọn nhất mà bạn có thể nhận được là sử dụng toán tử null-thanescing:

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

Có một tính năng mới trong C # 6 được gọi là Expression Bodied Auto-Properties , cho phép bạn viết nó gọn gàng hơn một chút:

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

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

Bây giờ có thể được viết là:

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

   public string SomeVariable => _someVariable.Value;
}

Không phải như vậy, tham số cho các thuộc tính phải có giá trị không đổi, bạn không thể gọi mã (Ngay cả mã tĩnh).

Tuy nhiên, bạn có thể triển khai một cái gì đó với Các khía cạnh của PostSharp.

Kiểm tra chúng:

PostSharp

Đây là cách tôi triển khai giải pháp cho vấn đề của bạn. Về cơ bản, ý tưởng là một thuộc tính sẽ được đặt bởi một hàm ở lần truy cập đầu tiên và các lần truy cập tiếp theo sẽ mang lại giá trị trả về giống như lần đầu tiên.

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

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

Sau đó để sử dụng:

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

Tất nhiên là có chi phí để truyền con trỏ hàm xung quanh, nhưng nó thực hiện công việc đối với tôi và tôi không nhận thấy quá nhiều chi phí so với việc chạy đi chạy lại phương thức.

Tôi rất thích ý tưởng này và muốn cung cấp đoạn mã C # sau đây mà tôi gọi là proplazy.snippet. (Bạn có thể nhập đoạn mã này hoặc dán vào thư mục chuẩn mà bạn có thể lấy từ Trình quản lý đoạn mã)

Đây là một mẫu đầu ra của nó:

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

Đây là nội dung tệp đoạn mã: (lưu dưới dạng 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>

Tôi không nghĩ rằng điều này là khả thi với C # thuần túy. Nhưng bạn có thể làm điều đó bằng cách sử dụng một trình viết lại IL như PostSharp . Ví dụ, nó cho phép bạn thêm các trình xử lý trước và sau các hàm tùy thuộc vào thuộc tính.

Tôi đã làm nó như thế này:

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

và sau này bạn có thể sử dụng nó như

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

https://github.com/bcuff/AutoLazy sử dụng Fody để cung cấp cho bạn một cái gì đó như thế này

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

và tôi gọi như dưới đây

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

Nếu bạn sử dụng một hàm tạo trong quá trình khởi tạo lười biếng, các phần mở rộng sau cũng có thể hữu ích

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

Sử dụng

    private Dictionary<string, object> _cache;

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

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

Toán tử ?? = khả dụng bằng C # 8.0 trở lên, vì vậy bây giờ bạn có thể làm điều đó ngắn gọn hơn:

private string _someVariable;

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