Wie kann verhindert werden, dass ein Aktionsparameter ein asynchrones Lambda ist?

Question

Ich schreibe einen kleinen Wrapper (MyWrapper) für den Einsatz in Komponententests. Sein Zweck besteht darin, Testcode mit einem try-catch zu umhüllen, um eine bestimmte Ausnahme zu erfassen (MySpecialException) und dann den Test zu ignorieren.

Warum sollte ich das für diese Frage nicht relevant sein.

den Code unten gegeben, wie kann ich andere aus Leiten eines Action und mit Asynchron wie dies zu verhindern? Oder mit anderen Worten: Wie zwinge ich sie stattdessen, MyWrapper.ExecuteAsync(Func<Task>) zu verwenden?

---

using System; 
using System.Threading.Tasks; 
using NUnit.Framework; 

namespace PreventAsyncActionLambdaExample 
{ 
    [TestFixture] 
    public class Example 
    { 
     [Test] 
     public async Task ExampleTest() 
     { 
      // How do I prevent others from passing an action and using async like this? 
      // Or in other words: How do I force them to use MyWrapper.ExecuteAsync(Func<Task>) instead? 
      MyWrapper.Execute(async() => 
      { 
       var cut = new ClassUnderTest(); 

       await cut.DoSomethingAsync(); 

       Assert.Fail("Problem: This line will never be reached"); 
      }); 
     } 
    } 

    public static class MyWrapper 
    { 
     // This method SHOULD NOT, BUT WILL be used in this example 
     public static void Execute(Action action) 
     { 
      try 
      { 
       action(); 
      } 
      catch (MySpecialException) 
      { 
      Assert.Ignore("Ignored due to MySpecialException"); 
      } 
     } 

     // This method SHOULD BE USED in this example, BUT WILL NOT be used. 
     public static async Task ExecuteAsync(Func<Task> func) 
     { 
      try 
      { 
       await func(); 
      } 
      catch (MySpecialException) 
      { 
       Assert.Ignore("Ignored due to MySpecialException"); 
      } 
     } 
    } 

    public class MySpecialException : Exception 
    { 
     // This is another exception in reality which is not relevant for this example 
    } 

    public class ClassUnderTest 
    { 
     public Task DoSomethingAsync() 
     { 
      return Task.Delay(20); // Simulate some work 
     } 
    } 
} 

Answer 1

Ich habe Angst, dass Sie nicht wirklich diese zum Zeitpunkt der Kompilierung verhindern können, aber man könnte eine weitere Überlastung schreiben, die in diesem Fall abgeholt werden ihnen sagen, dass sie ExecuteAsync verwenden sollen statt:

public static Task Execute(Func<Task> action) 
{ 
    throw new Exception("Please use the ExecuteAsync(Func<Task> func) method instead if you will be passing async lambdas"); 
} 

Answer 2

Wie in anderen Antworten erwähnt, ich glaube nicht, dass Sie es in der Kompilierung verhindern können. Sie können jedoch eine hacky Abhilfe schaffen und eine Ausnahme auslösen. Inspiriert von this answer. Es ist vielleicht keine gute Lösung, aber es könnte zumindest den Test fehlschlagen lassen.

public static bool IsThisAsync(Action action) 
{ 
    return action.Method.IsDefined(typeof(AsyncStateMachineAttribute), 
     false); 
} 

// This method SHOULD NOT, BUT WILL be used in this example 
public static void Execute(Action action) 
{ 
    try 
    { 
     if (IsThisAsync(action)) 
     { 
      Console.WriteLine("Is async"); 
      throw new ArgumentException("Action cannot be async.", nameof(action)); 
     } 
     else 
     { 
      Console.WriteLine("Is not async"); 
     } 

     action(); 
    } 
    catch (MySpecialException) 
    { 

    } 
} 

und Prüfungen:

[TestClass] 
public class MyWrapperTests 
{ 
    // Will not pass 
    [TestMethod] 
    public void ShouldAllowAsyncAction() 
    { 
     // This will throw an exception 
     MyWrapper.Execute(async() => 
     { 
      Assert.IsTrue(true); 
      await Task.Run(() => 
      { 
       Console.WriteLine("Kind of async"); 
      }); 
     }); 
    } 

    // Will pass, since ArgumentException is expected. 
    [TestMethod] 
    [ExpectedException(typeof(ArgumentException))] 
    public void ShouldThrowArgumentExceptionWhenAsync() 
    { 
     // This will throw an exception. But that's expected. 
     MyWrapper.Execute(async() => 
     { 
      Assert.IsTrue(true); 
      await Task.Run(() => 
      { 
       Console.WriteLine("Kind of async"); 
      }); 
     }); 
    } 

    // Passes 
    [TestMethod] 
    public void ShouldAllowSyncAction() 
    { 
     MyWrapper.Execute(() => 
     { 
      Assert.IsTrue(true); 
     }); 
    } 
}