add double click to datagrid row

Author: pwelter34

samples/Sample.Core/Pages/DataGrid/Examples/Basic.razor

@@ -8,7 +8,14 @@
 <button class="btn btn-secondary" @onclick="ApplyFilter">Filter High Score</button>
 
 
-<DataGrid Data="People" class="table table-hover" Filterable="true" Selectable="true" @bind-SelectedItems="Selected" @ref="DataGrid">
+<DataGrid Data="People"
+          TItem="Person"
+          Filterable="true"
+          Selectable="true"
+          RowDoubleClick="HandleRowClick"
+          @bind-SelectedItems="Selected"
+          @ref="DataGrid"
+          class="table table-hover">
     <DataColumns>
         <DataColumn TItem="Person" Property="p => p.Id" Width="90px">
             <Template Context="item">
@@ -72,4 +79,8 @@
         await DataGrid.ApplyFilters(filters, true);
     }
 
+    private void HandleRowClick(Person person)
+    {
+        Console.WriteLine("Row Click: {0}", person.FullName);
+    }
 }

src/LoreSoft.Blazor.Controls/Data/DataGrid.razor

@@ -264,6 +264,7 @@
     {
         <tr @key="new {item, i = 0}"
             @attributes="RowAttributes?.Invoke(item)"
+            @ondblclick="() => RowDoubleClick.InvokeAsync(item)"
             class="@RowClass"
             style="@(RowStyle?.Invoke(item))">
             @if (DetailTemplate != null)

src/LoreSoft.Blazor.Controls/Data/DataGrid.razor.cs

@@ -50,6 +50,8 @@ public partial class DataGrid<TItem> : DataComponentBase<TItem>
     [Parameter]
     public EventCallback<IEnumerable<TItem>> SelectedItemsChanged { get; set; }
 
+    [Parameter]
+    public EventCallback<TItem> RowDoubleClick { get; set; }
 
     [Parameter]
     public QueryGroup Query { get; set; }

src/LoreSoft.Blazor.Controls/Utilities/ConstrainedAction.cs

@@ -2,11 +2,12 @@ namespace LoreSoft.Blazor.Controls.Utilities;
 
 public static class ConstrainedAction
 {
-    public static Action<T> Debounce<T>(Action<T> action, TimeSpan interval)
+    public static Action<T> Debounce<T>(Action<T> action, TimeSpan? delay = null)
     {
         if (action == null)
             throw new ArgumentNullException(nameof(action));
 
+        var interval = delay ?? TimeSpan.FromMilliseconds(800);
         var last = 0;
 
         return (T arguments) =>
@@ -20,11 +21,68 @@ public static Action<T> Debounce<T>(Action<T> action, TimeSpan interval)
         };
     }
 
-    public static Action<T> Throttle<T>(Action<T> action, TimeSpan interval)
+    public static Action Debounce(Action action, TimeSpan? delay = null)
     {
         if (action == null)
             throw new ArgumentNullException(nameof(action));
 
+        var interval = delay ?? TimeSpan.FromMilliseconds(800);
+        var last = 0;
+
+        return () =>
+        {
+            var current = Interlocked.Increment(ref last);
+            Task.Delay(interval).ContinueWith(task =>
+            {
+                if (current == last)
+                    action();
+            });
+        };
+    }
+
+
+    public static Func<T, Task> Debounce<T>(Func<T, Task> action, TimeSpan? delay = null)
+    {
+        if (action == null)
+            throw new ArgumentNullException(nameof(action));
+
+        var interval = delay ?? TimeSpan.FromMilliseconds(800);
+        var last = 0;
+
+        return async (T arguments) =>
+        {
+            var current = Interlocked.Increment(ref last);
+            await Task.Delay(interval);
+            if (current == last)
+                await action(arguments);
+        };
+    }
+
+    public static Func<Task> Debounce(Func<Task> action, TimeSpan? delay = null)
+    {
+        if (action == null)
+            throw new ArgumentNullException(nameof(action));
+
+        var interval = delay ?? TimeSpan.FromMilliseconds(800);
+        var last = 0;
+
+        return async () =>
+        {
+            var current = Interlocked.Increment(ref last);
+            await Task.Delay(interval);
+            if (current == last)
+                await action();
+        };
+    }
+
+
+    public static Action<T> Throttle<T>(Action<T> action, TimeSpan? delay = null)
+    {
+        if (action == null)
+            throw new ArgumentNullException(nameof(action));
+
+        var interval = delay ?? TimeSpan.FromMilliseconds(800);
+
         Task task = null;
         var locker = new object();
         T arguments = default;
@@ -48,4 +106,34 @@ public static Action<T> Throttle<T>(Action<T> action, TimeSpan interval)
             }
         };
     }
+
+    public static Action Throttle(Action action, TimeSpan? delay = null)
+    {
+        if (action == null)
+            throw new ArgumentNullException(nameof(action));
+
+        var interval = delay ?? TimeSpan.FromMilliseconds(800);
+
+        Task task = null;
+        var locker = new object();
+
+        return () =>
+        {
+            if (task != null)
+                return;
+
+            lock (locker)
+            {
+                if (task != null)
+                    return;
+
+                task = Task.Delay(interval).ContinueWith(t =>
+                {
+                    action();
+                    task = null;
+                });
+            }
+        };
+    }
+
 }