Effect private field renamed

Author: stidsborg

Core/Cleipnir.ResilientFunctions/Domain/Effect.cs

@@ -12,37 +12,37 @@ public enum ResiliencyLevel
     AtMostOnce
 }
 
-public class Effect(EffectResults _effectResults)
+public class Effect(EffectResults effectResults)
 {
     public async Task<bool> Contains(string id) => await Contains(CreateEffectId(id, EffectType.Effect));
-    internal Task<bool> Contains(EffectId effectId) => _effectResults.Contains(effectId);
+    internal Task<bool> Contains(EffectId effectId) => effectResults.Contains(effectId);
 
     public async Task<WorkStatus?> GetStatus(string id)
     {
         var effectId = CreateEffectId(id);
-        var storedEffect = await _effectResults.GetOrValueDefault(effectId);
+        var storedEffect = await effectResults.GetOrValueDefault(effectId);
         return storedEffect?.WorkStatus;
     }
 
     public async Task<bool> Mark(string id)
     {
         var effectId = CreateEffectId(id);
-        if (await _effectResults.Contains(effectId))
+        if (await effectResults.Contains(effectId))
             return false;
 
         var storedEffect = StoredEffect.CreateCompleted(effectId);
-        await _effectResults.Set(storedEffect);
+        await effectResults.Set(storedEffect);
         return true;
     }
 
     public Task<T> CreateOrGet<T>(string id, T value) => CreateOrGet(CreateEffectId(id), value);
-    internal Task<T> CreateOrGet<T>(EffectId effectId, T value) => _effectResults.CreateOrGet(effectId, value);
+    internal Task<T> CreateOrGet<T>(EffectId effectId, T value) => effectResults.CreateOrGet(effectId, value);
 
     public async Task Upsert<T>(string id, T value) => await Upsert(CreateEffectId(id, EffectType.Effect), value);
-    internal Task Upsert<T>(EffectId effectId, T value) => _effectResults.Upsert(effectId, value);
+    internal Task Upsert<T>(EffectId effectId, T value) => effectResults.Upsert(effectId, value);
 
     public async Task<Option<T>> TryGet<T>(string id) => await TryGet<T>(CreateEffectId(id, EffectType.Effect));
-    private Task<Option<T>> TryGet<T>(EffectId effectId) => _effectResults.TryGet<T>(effectId);
+    private Task<Option<T>> TryGet<T>(EffectId effectId) => effectResults.TryGet<T>(effectId);
     public async Task<T> Get<T>(string id) => await Get<T>(CreateEffectId(id, EffectType.Effect));
     internal async Task<T> Get<T>(EffectId effectId)
     {
@@ -77,11 +77,11 @@ public async Task<T> Capture<T>(string id, Func<Task<T>> work, ResiliencyLevel r
         => await InnerCapture(id, EffectType.Effect, work, resiliency, EffectContext.CurrentContext);
 
     private Task InnerCapture(string id, EffectType effectType, Func<Task> work, ResiliencyLevel resiliency, EffectContext effectContext)
-        => _effectResults.InnerCapture(id, effectType, work, resiliency, effectContext);
+        => effectResults.InnerCapture(id, effectType, work, resiliency, effectContext);
     private Task<T> InnerCapture<T>(string id, EffectType effectType, Func<Task<T>> work, ResiliencyLevel resiliency, EffectContext effectContext)
-        => _effectResults.InnerCapture(id, effectType, work, resiliency, effectContext);
+        => effectResults.InnerCapture(id, effectType, work, resiliency, effectContext);
 
-    public Task Clear(string id) => _effectResults.Clear(CreateEffectId(id));
+    public Task Clear(string id) => effectResults.Clear(CreateEffectId(id));
 
     public Task<T> WhenAny<T>(string id, params Task<T>[] tasks)
         => Capture(id, work: async () => await await Task.WhenAny(tasks));