Using recommended threading rules. (ZeraGmbH#32)

JMS-1 · Sep 2, 2024 · cc67eef · cc67eef
1 parent 8ba22a1
commit cc67eef
Show file tree

Hide file tree

Showing 110 changed files with 538 additions and 472 deletions.
diff --git a/Library/BlocklyNet.csproj b/Library/BlocklyNet.csproj
@@ -14,6 +14,7 @@
     <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="8.0.0" />
     <PackageReference Include="Microsoft.Extensions.Http" Version="8.0.0" />
     <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
+    <PackageReference Include="Microsoft.VisualStudio.Threading.Analyzers" Version="17.11.20" PrivateAssets="all" />
   </ItemGroup>
 
   <PropertyGroup>

diff --git a/Library/BlocklyUtils.cs b/Library/BlocklyUtils.cs
@@ -0,0 +1,11 @@
+/// <summary>
+/// Some implementation helpers.
+/// </summary>
+public static class BlockyUtils
+{
+    /// <summary>
+    /// Simulate task access to avoid warnings.
+    /// </summary>
+    /// <param name="task">Some task.</param>
+    public static void Touch(this Task task) { }
+}
diff --git a/Library/Core/Blocks/Colour/ColourBlend.cs b/Library/Core/Blocks/Colour/ColourBlend.cs
@@ -10,12 +10,12 @@ namespace BlocklyNet.Core.Blocks.Text;
 public class ColourBlend : Block
 {
   /// <inheritdoc/>
-  public override async Task<object?> Evaluate(Context context)
+  public override async Task<object?> EvaluateAsync(Context context)
   {
-    var colour1 = (await Values.Evaluate("COLOUR1", context) ?? "").ToString();
-    var colour2 = (await Values.Evaluate("COLOUR2", context) ?? "").ToString();
+    var colour1 = (await Values.EvaluateAsync("COLOUR1", context) ?? "").ToString();
+    var colour2 = (await Values.EvaluateAsync("COLOUR2", context) ?? "").ToString();
 
-    var ratio = System.Math.Min(System.Math.Max(await Values.Evaluate<double>("RATIO", context), 0), 1);
+    var ratio = System.Math.Min(System.Math.Max(await Values.EvaluateAsync<double>("RATIO", context), 0), 1);
 
     if (string.IsNullOrWhiteSpace(colour1) || colour1.Length != 7)
       return null!;

diff --git a/Library/Core/Blocks/Colour/ColourPicker.cs b/Library/Core/Blocks/Colour/ColourPicker.cs
@@ -10,7 +10,7 @@ namespace BlocklyNet.Core.Blocks.Text;
 public class ColourPicker : Block
 {
   /// <inheritdoc/>
-  public override Task<object?> Evaluate(Context context)
+  public override Task<object?> EvaluateAsync(Context context)
   {
     return Task.FromResult((object?)(Fields["COLOUR"] ?? "#000000"));
   }

diff --git a/Library/Core/Blocks/Colour/ColourRandom.cs b/Library/Core/Blocks/Colour/ColourRandom.cs
@@ -12,7 +12,7 @@ public class ColourRandom : Block
   private readonly Random random = new Random();
 
   /// <inheritdoc/>
-  public override Task<object?> Evaluate(Context context)
+  public override Task<object?> EvaluateAsync(Context context)
   {
     var bytes = new byte[3];
 

diff --git a/Library/Core/Blocks/Colour/ColourRgb.cs b/Library/Core/Blocks/Colour/ColourRgb.cs
@@ -10,11 +10,11 @@ namespace BlocklyNet.Core.Blocks.Text;
 public class ColourRgb : Block
 {
   /// <inheritdoc/>
-  public override async Task<object?> Evaluate(Context context)
+  public override async Task<object?> EvaluateAsync(Context context)
   {
-    var red = Convert.ToByte(await Values.Evaluate("RED", context));
-    var green = Convert.ToByte(await Values.Evaluate("GREEN", context));
-    var blue = Convert.ToByte(await Values.Evaluate("BLUE", context));
+    var red = Convert.ToByte(await Values.EvaluateAsync("RED", context));
+    var green = Convert.ToByte(await Values.EvaluateAsync("GREEN", context));
+    var blue = Convert.ToByte(await Values.EvaluateAsync("BLUE", context));
 
     return $"#{red:x2}{green:x2}{blue:x2}";
   }

diff --git a/Library/Core/Blocks/Controls/ControlsFlowStatement.cs b/Library/Core/Blocks/Controls/ControlsFlowStatement.cs
@@ -10,7 +10,7 @@ namespace BlocklyNet.Core.Blocks.Controls;
 public class ControlsFlowStatement : Block
 {
   /// <inheritdoc/>
-  public override Task<object?> Evaluate(Context context)
+  public override Task<object?> EvaluateAsync(Context context)
   {
     var flow = Fields["FLOW"];
 

diff --git a/Library/Core/Blocks/Controls/ControlsFor.cs b/Library/Core/Blocks/Controls/ControlsFor.cs
@@ -10,13 +10,13 @@ namespace BlocklyNet.Core.Blocks.Controls;
 public class ControlsFor : Block
 {
   /// <inheritdoc/>
-  public override async Task<object?> Evaluate(Context context)
+  public override async Task<object?> EvaluateAsync(Context context)
   {
     var variableName = Fields["VAR"];
 
-    var fromValue = await Values.Evaluate<double>("FROM", context);
-    var toValue = await Values.Evaluate<double>("TO", context);
-    var byValue = await Values.Evaluate<double>("BY", context);
+    var fromValue = await Values.EvaluateAsync<double>("FROM", context);
+    var toValue = await Values.EvaluateAsync<double>("TO", context);
+    var byValue = await Values.EvaluateAsync<double>("BY", context);
 
     var statement = Statements.TryGet("DO");
 
@@ -26,11 +26,11 @@ public class ControlsFor : Block
     {
       context.Cancellation.ThrowIfCancellationRequested();
 
-      await statement!.Evaluate(context);
+      await statement!.EvaluateAsync(context);
 
       context.Variables[variableName] = (double)context.Variables[variableName]! + byValue;
     }
 
-    return await base.Evaluate(context);
+    return await base.EvaluateAsync(context);
   }
 }
diff --git a/Library/Core/Blocks/Controls/ControlsForEach.cs b/Library/Core/Blocks/Controls/ControlsForEach.cs
@@ -10,15 +10,15 @@ namespace BlocklyNet.Core.Blocks.Controls;
 public class ControlsForEach : Block
 {
   /// <inheritdoc/>
-  public override async Task<object?> Evaluate(Context context)
+  public override async Task<object?> EvaluateAsync(Context context)
   {
     var variableName = Fields["VAR"];
-    var list = await Values.Evaluate<IEnumerable<object>>("LIST", context);
+    var list = await Values.EvaluateAsync<IEnumerable<object>>("LIST", context);
 
     var statement = Statements.TryGet("DO");
 
     if (null == statement)
-      return await base.Evaluate(context);
+      return await base.EvaluateAsync(context);
 
     foreach (var item in list)
     {
@@ -29,9 +29,9 @@ public class ControlsForEach : Block
       else
         context.Variables.Add(variableName, item);
 
-      await statement.Evaluate(context);
+      await statement.EvaluateAsync(context);
     }
 
-    return await base.Evaluate(context);
+    return await base.EvaluateAsync(context);
   }
 }
diff --git a/Library/Core/Blocks/Controls/ControlsIf.cs b/Library/Core/Blocks/Controls/ControlsIf.cs
@@ -10,7 +10,7 @@ namespace BlocklyNet.Core.Blocks.Controls;
 public class ControlsIf : Block
 {
   /// <inheritdoc/>
-  public override async Task<object?> Evaluate(Context context)
+  public override async Task<object?> EvaluateAsync(Context context)
   {
     var ifCount = 1;
     if (null != Mutations.GetValue("elseif"))
@@ -22,11 +22,11 @@ public class ControlsIf : Block
     var done = false;
     for (var i = 0; i < ifCount; i++)
     {
-      if (await Values.Evaluate<bool>($"IF{i}", context))
+      if (await Values.EvaluateAsync<bool>($"IF{i}", context))
       {
         context.Cancellation.ThrowIfCancellationRequested();
 
-        await Statements[$"DO{i}"].Evaluate(context);
+        await Statements[$"DO{i}"].EvaluateAsync(context);
 
         done = true;
         break;
@@ -43,11 +43,11 @@ public class ControlsIf : Block
         {
           context.Cancellation.ThrowIfCancellationRequested();
 
-          await Statements["ELSE"].Evaluate(context);
+          await Statements["ELSE"].EvaluateAsync(context);
         }
       }
     }
 
-    return await base.Evaluate(context);
+    return await base.EvaluateAsync(context);
   }
 }
diff --git a/Library/Core/Blocks/Controls/ControlsRepeatExt.cs b/Library/Core/Blocks/Controls/ControlsRepeatExt.cs
@@ -8,21 +8,21 @@ namespace BlocklyNet.Core.Blocks.Controls;
 public class ControlsRepeatExt : Block
 {
   /// <inheritdoc/>
-  public override async Task<object?> Evaluate(Context context)
+  public override async Task<object?> EvaluateAsync(Context context)
   {
     /* See if there is a inner block we can execute. */
     var statement = Statements.TryGet("DO");
 
     if (statement == null)
-      return await base.Evaluate(context);
+      return await base.EvaluateAsync(context);
 
     /* Number of times to execute the inner block. */
-    for (var i = await Values.Evaluate<double>("TIMES", context); i-- > 0;)
+    for (var i = await Values.EvaluateAsync<double>("TIMES", context); i-- > 0;)
     {
       /* Execute the inner block. */
       context.Cancellation.ThrowIfCancellationRequested();
 
-      await statement.Evaluate(context);
+      await statement.EvaluateAsync(context);
 
       try
       {
@@ -40,6 +40,6 @@ public class ControlsRepeatExt : Block
     context.EscapeMode = EscapeMode.None;
 
     /* Continue with the next block. */
-    return await base.Evaluate(context);
+    return await base.EvaluateAsync(context);
   }
 }
diff --git a/Library/Core/Blocks/Controls/ControlsWhileUntil.cs b/Library/Core/Blocks/Controls/ControlsWhileUntil.cs
@@ -10,19 +10,19 @@ namespace BlocklyNet.Core.Blocks.Controls;
 public class ControlsWhileUntil : Block
 {
   /// <inheritdoc/>
-  public override async Task<object?> Evaluate(Context context)
+  public override async Task<object?> EvaluateAsync(Context context)
   {
     var mode = Fields["MODE"];
     var value = Values.TryGet("BOOL");
 
     if (!Statements.Has("DO") || null == value)
-      return await base.Evaluate(context);
+      return await base.EvaluateAsync(context);
 
     var statement = Statements["DO"];
 
     if (mode == "WHILE")
     {
-      while ((bool)(await value.Evaluate(context))!)
+      while ((bool)(await value.EvaluateAsync(context))!)
       {
         context.Cancellation.ThrowIfCancellationRequested();
 
@@ -32,17 +32,17 @@ public class ControlsWhileUntil : Block
           break;
         }
 
-        await statement.Evaluate(context);
+        await statement.EvaluateAsync(context);
       }
     }
     else
-      while (!(bool)(await value.Evaluate(context))!)
+      while (!(bool)(await value.EvaluateAsync(context))!)
       {
         context.Cancellation.ThrowIfCancellationRequested();
 
-        await statement.Evaluate(context);
+        await statement.EvaluateAsync(context);
       }
 
-    return await base.Evaluate(context);
+    return await base.EvaluateAsync(context);
   }
 }
diff --git a/Library/Core/Blocks/Lists/ListsCreateWith.cs b/Library/Core/Blocks/Lists/ListsCreateWith.cs
@@ -10,15 +10,15 @@ namespace BlocklyNet.Core.Blocks.Lists;
 public class ListsCreateWith : Block
 {
   /// <inheritdoc/>
-  public override async Task<object?> Evaluate(Context context)
+  public override async Task<object?> EvaluateAsync(Context context)
   {
     var list = new List<object>();
 
     foreach (var value in Values)
     {
       context.Cancellation.ThrowIfCancellationRequested();
 
-      list.Add((await value.Evaluate(context))!);
+      list.Add((await value.EvaluateAsync(context))!);
     }
 
     return list;

diff --git a/Library/Core/Blocks/Lists/ListsGetIndex.cs b/Library/Core/Blocks/Lists/ListsGetIndex.cs
@@ -12,18 +12,18 @@ public class ListsGetIndex : Block
   private static readonly Random rnd = new Random();
 
   /// <inheritdoc/>
-  public override async Task<object?> Evaluate(Context context)
+  public override async Task<object?> EvaluateAsync(Context context)
   {
-    var values = new ListWrapper(await Values.Evaluate("VALUE", context));
+    var values = new ListWrapper(await Values.EvaluateAsync("VALUE", context));
 
     var mode = Fields["MODE"];
     var where = Fields["WHERE"];
 
     var index = where switch
     {
       "FIRST" => 0,
-      "FROM_END" => values.Count - Convert.ToInt32(await Values.Evaluate("AT", context)),
-      "FROM_START" => Convert.ToInt32(await Values.Evaluate("AT", context)) - 1,
+      "FROM_END" => values.Count - Convert.ToInt32(await Values.EvaluateAsync("AT", context)),
+      "FROM_START" => Convert.ToInt32(await Values.EvaluateAsync("AT", context)) - 1,
       "LAST" => values.Count - 1,
       "RANDOM" => rnd.Next(values.Count),
       _ => throw new NotSupportedException($"unsupported where ({where})"),

diff --git a/Library/Core/Blocks/Lists/ListsIndexOf.cs b/Library/Core/Blocks/Lists/ListsIndexOf.cs
@@ -10,11 +10,11 @@ namespace BlocklyNet.Core.Blocks.Lists;
 public class ListsIndexOf : Block
 {
   /// <inheritdoc/>
-  public override async Task<object?> Evaluate(Context context)
+  public override async Task<object?> EvaluateAsync(Context context)
   {
     var direction = Fields["END"];
-    var value = await Values.Evaluate<IEnumerable<object>>("VALUE", context);
-    var find = await Values.Evaluate("FIND", context);
+    var value = await Values.EvaluateAsync<IEnumerable<object>>("VALUE", context);
+    var find = await Values.EvaluateAsync("FIND", context);
 
     switch (direction)
     {

diff --git a/Library/Core/Blocks/Lists/ListsIsEmpty.cs b/Library/Core/Blocks/Lists/ListsIsEmpty.cs
@@ -10,9 +10,9 @@ namespace BlocklyNet.Core.Blocks.Lists;
 public class ListsIsEmpty : Block
 {
   /// <inheritdoc/>
-  public override async Task<object?> Evaluate(Context context)
+  public override async Task<object?> EvaluateAsync(Context context)
   {
-    if (await Values.Evaluate("VALUE", context) is not IEnumerable<object> value)
+    if (await Values.EvaluateAsync("VALUE", context) is not IEnumerable<object> value)
       return true;
 
     return !value.Any();

diff --git a/Library/Core/Blocks/Lists/ListsLength.cs b/Library/Core/Blocks/Lists/ListsLength.cs
@@ -10,9 +10,9 @@ namespace BlocklyNet.Core.Blocks.Lists;
 public class ListsLength : Block
 {
   /// <inheritdoc/>
-  public override async Task<object?> Evaluate(Context context)
+  public override async Task<object?> EvaluateAsync(Context context)
   {
-    if (await Values.Evaluate("VALUE", context) is not IEnumerable<object> value)
+    if (await Values.EvaluateAsync("VALUE", context) is not IEnumerable<object> value)
       return 0.0;
 
     return (double)value.Count();

diff --git a/Library/Core/Blocks/Lists/ListsRepeat.cs b/Library/Core/Blocks/Lists/ListsRepeat.cs
@@ -10,10 +10,10 @@ namespace BlocklyNet.Core.Blocks.Lists;
 public class ListsRepeat : Block
 {
   /// <inheritdoc/>
-  public override async Task<object?> Evaluate(Context context)
+  public override async Task<object?> EvaluateAsync(Context context)
   {
-    var item = await Values.Evaluate<object>("ITEM", context);
-    var num = await Values.Evaluate<double>("NUM", context);
+    var item = await Values.EvaluateAsync<object>("ITEM", context);
+    var num = await Values.EvaluateAsync<double>("NUM", context);
 
     var list = new List<object>();
 

diff --git a/Library/Core/Blocks/Lists/ListsSetIndex.cs b/Library/Core/Blocks/Lists/ListsSetIndex.cs
@@ -10,23 +10,23 @@ public class ListsSetIndex : Block
     private static readonly Random rnd = new();
 
     /// <inheritdoc/>
-    public override async Task<object?> Evaluate(Context context)
+    public override async Task<object?> EvaluateAsync(Context context)
     {
-        var list = new ListWrapper(await Values.Evaluate("LIST", context));
+        var list = new ListWrapper(await Values.EvaluateAsync("LIST", context));
 
         var where = Fields["WHERE"];
 
         var index = where switch
         {
             "FIRST" => 0,
-            "FROM_END" => list.Count - Convert.ToInt32(await Values.Evaluate("AT", context)),
-            "FROM_START" => Convert.ToInt32(await Values.Evaluate("AT", context)) - 1,
+            "FROM_END" => list.Count - Convert.ToInt32(await Values.EvaluateAsync("AT", context)),
+            "FROM_START" => Convert.ToInt32(await Values.EvaluateAsync("AT", context)) - 1,
             "LAST" => list.Count - 1,
             "RANDOM" => rnd.Next(list.Count),
             _ => throw new NotSupportedException($"unsupported where ({where})"),
         };
 
-        var value = await Values.Evaluate("TO", context);
+        var value = await Values.EvaluateAsync("TO", context);
 
         var mode = Fields["MODE"];
         switch (mode)
@@ -43,6 +43,6 @@ public class ListsSetIndex : Block
                 throw new NotSupportedException($"unsupported mode ({mode})");
         }
 
-        return await base.Evaluate(context);
+        return await base.EvaluateAsync(context);
     }
 }