Improved proxies

Author: usercode

src/DragonFly.AspNetCore/BackgroundTasks/BackgroundTaskContextExtensions.cs

@@ -26,7 +26,7 @@ public static async Task ProcessQueryAsync<T, TQuery>(this BackgroundTaskContext
                 break;
             }
 
-            QueryResult<T> result = await queryAction(ctx.Input);
+            QueryResult<T> result = await queryAction(ctx.Input).ConfigureAwait(false);
 
             if (result.Items.Count == 0)
             {
@@ -40,7 +40,7 @@ public static async Task ProcessQueryAsync<T, TQuery>(this BackgroundTaskContext
                     break;
                 }
 
-                await ctx.UpdateStatusAsync(item.ToString(), counter, result.TotalCount);
+                await ctx.UpdateStatusAsync(item.ToString(), counter, result.TotalCount).ConfigureAwait(false);
 
                 try
                 {
@@ -61,6 +61,6 @@ public static async Task ProcessQueryAsync<T, TQuery>(this BackgroundTaskContext
             ctx.Input.Skip += ctx.Input.Take;
         }
 
-        await ctx.UpdateStatusAsync($"Succeed: {counterSucceed} / Failed: {counterFailed}", progressValue: counter);
+        await ctx.UpdateStatusAsync($"Succeed: {counterSucceed} / Failed: {counterFailed}", progressValue: counter).ConfigureAwait(false);
     }
 }

src/DragonFly.Client/_Imports.razor

@@ -30,6 +30,7 @@
 @using BlazorStrap
 @using BlazorStrap.V5
 @using DragonFly.Client.Base
+@using DragonFly.Proxies
 @using static Microsoft.AspNetCore.Components.Web.RenderMode
 @attribute [Authorize]
 @inject IDragonFlyApi DragonFly

src/DragonFly.Core/Api/Init/DragonFlyApiExtensions.cs

@@ -2,7 +2,6 @@
 // https://github.com/usercode/DragonFly
 // MIT License
 
-using System.Security.Claims;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 
@@ -37,7 +36,7 @@ public static async Task InitAsync(this IDragonFlyApi api)
             logger.LogInformation("Initializing {type}", GetName(item));
 
             await item.ExecuteAsync(api);
-        }        
+        }
     }
 
     private static string? GetName(object initializer)

src/DragonFly.Core/AsyncLazy.cs

@@ -0,0 +1,75 @@
+// Copyright (c) usercode
+// https://github.com/usercode/DragonFly
+// MIT License
+
+using System.Runtime.CompilerServices;
+
+namespace DragonFly;
+
+/// <summary>
+/// AsyncLazy
+/// </summary>
+/// <typeparam name="T"></typeparam>
+public class AsyncLazy<T>
+{
+    public AsyncLazy(ContentReference reference, Func<Task<T?>> taskFactory)
+    {
+        ContentReference = reference;
+        _lazy = new Lazy<Task<T?>>(taskFactory);
+    }
+
+    public AsyncLazy(T? value)
+    {
+        SetDirectValue(value);
+    }
+
+    private Lazy<Task<T?>> _lazy;
+    public ContentReference? ContentReference { get; private set; }
+    private T? _directValue;
+    private bool _directValueChanged;
+
+    public TaskAwaiter<T?> GetAwaiter()
+    {
+        return _lazy.Value.GetAwaiter();
+    }
+
+    public void SetDirectValue(T? value)
+    {
+        if (value is ContentItem content)
+        {
+            ContentReference = content.ToReference();
+        }
+        else if (value is Asset asset)
+        {
+            ContentReference = asset.ToReference();
+        }
+        else
+        {
+            ContentReference = null;
+        }
+
+        _directValue = value;
+        _directValueChanged = true;
+
+        _lazy = new Lazy<Task<T?>>(() => Task.FromResult(value));
+    }
+
+    public bool TryGetDirectValue(out T? value)
+    {
+        if (_directValueChanged)
+        {
+            value = _directValue;
+
+            return true;
+        }
+
+        value = default;
+
+        return false;
+    }
+
+    public static implicit operator AsyncLazy<T>(T? value)
+    {
+        return new AsyncLazy<T>(value);
+    }
+}

src/DragonFly.Core/Modules/ContentItems/Models/Fields/AssetField.cs

@@ -2,6 +2,8 @@
 // https://github.com/usercode/DragonFly
 // MIT License
 
+using DragonFly.Core;
+
 namespace DragonFly;
 
 /// <summary>

src/DragonFly.Core/Modules/Proxies/IProxyObject.cs

@@ -6,4 +6,5 @@ namespace DragonFly.Generator;
 
 public interface IProxyObject
 {
+    Task LoadAsync();
 }

src/DragonFly.Core/Modules/Proxies/Proxy.cs

@@ -0,0 +1,22 @@
+// Copyright (c) usercode
+// https://github.com/usercode/DragonFly
+// MIT License
+
+using DragonFly.Generator;
+
+namespace DragonFly.Proxies;
+
+public static class Proxy
+{
+    public static async Task<bool> LoadAsync(object? obj)
+    {
+        if (obj is IProxyObject proxyObject)
+        {
+            await proxyObject.LoadAsync();
+
+            return true;
+        }
+
+        return false;
+    }
+}

src/DragonFly.Generator.Tests/DragonFly.Generator.Tests.csproj

@@ -7,7 +7,6 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.CodeAnalysis.Analyzer.Testing" Version="1.1.2" />
     <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.13.0" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.13.0" />
     <PackageReference Include="System.Formats.Asn1" Version="9.0.3" />