Add TaskFactoryExtensions

Author: jerviscui

src/.editorconfig

@@ -843,6 +843,10 @@ dotnet_diagnostic.CRR0030.severity = error
 # CRR0033: The void async method should be in a try/catch block
 dotnet_diagnostic.CRR0033.severity = error
 
+# CRR0034 - The asynchronous method should contain the "Async" suffix
+# duplicate with S4261
+dotnet_diagnostic.CRR0034.severity = none
+
 # CRR0035 - No CancellationToken parameter in the asynchronous method
 dotnet_diagnostic.CRR0035.severity = suggestion
 

src/Tests/ThreadingTest/Program.cs

@@ -1,4 +1,3 @@
-using System;
 using System.Threading.Tasks;
 
 namespace ThreadingTest;
@@ -65,9 +64,12 @@ private static async Task Main(string[] args)
         //    Console.WriteLine($"ThreadCount: {ThreadPool.ThreadCount}");
         //}
 
-        await new AsyncLocalTest().AsyncLocal_TestAsync(default);
-        Console.WriteLine();
-        await new AsyncLocalTest().Wrapper_TestAsync(default);
+        //await new AsyncLocalTest().AsyncLocal_TestAsync(default);
+        //Console.WriteLine();
+        //await new AsyncLocalTest().Wrapper_TestAsync(default);
+
+        await TaskFactoryTest.StartNewUnwrappedTest1();
+        await TaskFactoryTest.StartNewUnwrappedTest2();
     }
 
     #endregion

src/Tests/ThreadingTest/TaskFactoryExtensions.cs

@@ -0,0 +1,113 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace ThreadingTest;
+
+[SuppressMessage("Async/await", "CRR0038:CancellationToken parameter is never used.", Justification = "<Pending>")]
+[SuppressMessage(
+    "Minor Code Smell",
+    "S4261:Methods should be named according to their synchronicities",
+    Justification = "<Pending>")]
+public static class TaskFactoryExtensions
+{
+
+    #region Constants & Statics
+
+    public static Task<TResult> StartNewUnwrapped<TResult>(this TaskFactory factory, Func<Task<TResult>> function)
+    {
+        var task = factory.StartNew(function);
+
+        return task.Unwrap();
+    }
+
+    public static Task<TResult> StartNewUnwrapped<TResult>(
+        this TaskFactory factory,
+        Func<Task<TResult>> function,
+        CancellationToken cancellationToken)
+    {
+        var task = factory.StartNew(function, cancellationToken);
+
+        return task.Unwrap();
+    }
+
+    public static Task<TResult> StartNewUnwrapped<TResult>(
+        this TaskFactory factory,
+        Func<Task<TResult>> function,
+        TaskCreationOptions creationOptions)
+    {
+        var task = factory.StartNew(function, creationOptions);
+
+        return task.Unwrap();
+    }
+
+    public static Task<TResult> StartNewUnwrapped<TResult>(
+        this TaskFactory factory,
+        Func<object?, Task<TResult>> function,
+        object? state)
+    {
+        var task = factory.StartNew(function, state);
+
+        return task.Unwrap();
+    }
+
+    public static Task<TResult> StartNewUnwrapped<TResult>(
+        this TaskFactory factory,
+        Func<object?, Task<TResult>> function,
+        object? state,
+        CancellationToken cancellationToken)
+    {
+        var task = factory.StartNew(function, state, cancellationToken);
+
+        return task.Unwrap();
+    }
+
+    public static Task<TResult> StartNewUnwrapped<TResult>(
+        this TaskFactory factory,
+        Func<object?, Task<TResult>> function,
+        object? state,
+        TaskCreationOptions creationOptions)
+    {
+        var task = factory.StartNew(function, state, creationOptions);
+
+        return task.Unwrap();
+    }
+
+    public static Task<TResult> StartNewUnwrapped<TResult>(
+        this TaskFactory factory,
+        Func<Task<TResult>> function,
+        TaskScheduler scheduler,
+        CancellationToken? cancellationToken = null,
+        TaskCreationOptions? creationOptions = null)
+    {
+        var task = factory.StartNew(
+            function,
+            cancellationToken ?? factory.CancellationToken,
+            creationOptions ?? factory.CreationOptions,
+            scheduler);
+
+        return task.Unwrap();
+    }
+
+    public static Task<TResult> StartNewUnwrapped<TResult>(
+        this TaskFactory factory,
+        Func<object?, Task<TResult>> function,
+        object? state,
+        TaskScheduler scheduler,
+        CancellationToken? cancellationToken = null,
+        TaskCreationOptions? creationOptions = null)
+    {
+        var task = factory.StartNew(
+            function,
+            state,
+            cancellationToken ?? factory.CancellationToken,
+            creationOptions ?? factory.CreationOptions,
+            scheduler);
+
+        return task.Unwrap();
+    }
+
+    #endregion
+
+}

src/Tests/ThreadingTest/TaskFactoryTest.cs

@@ -0,0 +1,37 @@
+using System;
+using System.Threading.Tasks;
+
+namespace ThreadingTest;
+
+public static class TaskFactoryTest
+{
+
+    #region Constants & Statics
+
+    public static async Task StartNewUnwrappedTest1()
+    {
+        static Task<int> ReturnIntFunction()
+        {
+            return Task.FromResult(42);
+        }
+
+        var result = await Task.Factory.StartNewUnwrapped(ReturnIntFunction);
+
+        Console.WriteLine(result);
+    }
+
+    public static async Task StartNewUnwrappedTest2()
+    {
+        static async Task<int> TaskFunction(object? i)
+        {
+            await Task.Yield();
+            return 32;
+        }
+
+        var result = await Task.Factory.StartNewUnwrapped(TaskFunction, "32");
+        Console.WriteLine(result);
+    }
+
+    #endregion
+
+}

template/src/.editorconfig

@@ -843,6 +843,10 @@ dotnet_diagnostic.CRR0030.severity = error
 # CRR0033: The void async method should be in a try/catch block
 dotnet_diagnostic.CRR0033.severity = error
 
+# CRR0034 - The asynchronous method should contain the "Async" suffix
+# duplicate with S4261
+dotnet_diagnostic.CRR0034.severity = none
+
 # CRR0035 - No CancellationToken parameter in the asynchronous method
 dotnet_diagnostic.CRR0035.severity = suggestion