diff --git a/src/csharp/Grpc.Core.Tests/ClientServerTest.cs b/src/csharp/Grpc.Core.Tests/ClientServerTest.cs
index 643af4daf9a..e286ea519f9 100644
--- a/src/csharp/Grpc.Core.Tests/ClientServerTest.cs
+++ b/src/csharp/Grpc.Core.Tests/ClientServerTest.cs
@@ -158,59 +158,50 @@ namespace Grpc.Core.Tests
         }
 
         [Test]
-        public void AsyncUnaryCall_ServerHandlerThrows()
+        public async Task AsyncUnaryCall_ServerHandlerThrows()
         {
-            Task.Run(async () =>
+            var internalCall = new Call<string, string>(ServiceName, EchoMethod, channel, Metadata.Empty);
+            try
             {
-                var internalCall = new Call<string, string>(ServiceName, EchoMethod, channel, Metadata.Empty);
-                try
-                {
-                    await Calls.AsyncUnaryCall(internalCall, "THROW", CancellationToken.None);
-                    Assert.Fail();
-                }
-                catch (RpcException e)
-                {
-                    Assert.AreEqual(StatusCode.Unknown, e.Status.StatusCode);
-                }
-            }).Wait();
+                await Calls.AsyncUnaryCall(internalCall, "THROW", CancellationToken.None);
+                Assert.Fail();
+            }
+            catch (RpcException e)
+            {
+                Assert.AreEqual(StatusCode.Unknown, e.Status.StatusCode);
+            }
         }
 
         [Test]
-        public void ClientStreamingCall()
+        public async Task ClientStreamingCall()
         {
-            Task.Run(async () => 
-            {
-                var internalCall = new Call<string, string>(ServiceName, ConcatAndEchoMethod, channel, Metadata.Empty);
-                var call = Calls.AsyncClientStreamingCall(internalCall, CancellationToken.None);
+            var internalCall = new Call<string, string>(ServiceName, ConcatAndEchoMethod, channel, Metadata.Empty);
+            var call = Calls.AsyncClientStreamingCall(internalCall, CancellationToken.None);
 
-                await call.RequestStream.WriteAll(new string[] { "A", "B", "C" });
-                Assert.AreEqual("ABC", await call.ResponseAsync);
-            }).Wait();
+            await call.RequestStream.WriteAll(new string[] { "A", "B", "C" });
+            Assert.AreEqual("ABC", await call.ResponseAsync);
         }
 
         [Test]
-        public void ClientStreamingCall_CancelAfterBegin()
+        public async Task ClientStreamingCall_CancelAfterBegin()
         {
-            Task.Run(async () => 
-            {
-                var internalCall = new Call<string, string>(ServiceName, ConcatAndEchoMethod, channel, Metadata.Empty);
+            var internalCall = new Call<string, string>(ServiceName, ConcatAndEchoMethod, channel, Metadata.Empty);
 
-                var cts = new CancellationTokenSource();
-                var call = Calls.AsyncClientStreamingCall(internalCall, cts.Token);
+            var cts = new CancellationTokenSource();
+            var call = Calls.AsyncClientStreamingCall(internalCall, cts.Token);
 
-                // TODO(jtattermusch): we need this to ensure call has been initiated once we cancel it.
-                await Task.Delay(1000);
-                cts.Cancel();
+            // TODO(jtattermusch): we need this to ensure call has been initiated once we cancel it.
+            await Task.Delay(1000);
+            cts.Cancel();
 
-                try
-                {
-                    await call.ResponseAsync;
-                }
-                catch (RpcException e)
-                {
-                    Assert.AreEqual(StatusCode.Cancelled, e.Status.StatusCode); 
-                }
-            }).Wait();
+            try
+            {
+                await call.ResponseAsync;
+            }
+            catch (RpcException e)
+            {
+                Assert.AreEqual(StatusCode.Cancelled, e.Status.StatusCode);
+            }
         }
 
         [Test]
diff --git a/src/csharp/Grpc.Core.Tests/Grpc.Core.Tests.csproj b/src/csharp/Grpc.Core.Tests/Grpc.Core.Tests.csproj
index 7582d1359f4..618951cb8ae 100644
--- a/src/csharp/Grpc.Core.Tests/Grpc.Core.Tests.csproj
+++ b/src/csharp/Grpc.Core.Tests/Grpc.Core.Tests.csproj
@@ -77,7 +77,9 @@
     </ProjectReference>
   </ItemGroup>
   <ItemGroup>
-    <None Include="packages.config" />
+    <None Include="packages.config">
+      <SubType>Designer</SubType>
+    </None>
   </ItemGroup>
   <ItemGroup>
     <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
diff --git a/src/csharp/Grpc.Examples.Tests/MathClientServerTests.cs b/src/csharp/Grpc.Examples.Tests/MathClientServerTests.cs
index ecd9d514fd9..26f332c1cf7 100644
--- a/src/csharp/Grpc.Examples.Tests/MathClientServerTests.cs
+++ b/src/csharp/Grpc.Examples.Tests/MathClientServerTests.cs
@@ -108,123 +108,105 @@ namespace math.Tests
         }
 
         [Test]
-        public void DivAsync()
+        public async Task DivAsync()
         {
-            Task.Run(async () =>
-            {
-                DivReply response = await client.DivAsync(new DivArgs.Builder { Dividend = 10, Divisor = 3 }.Build());
-                Assert.AreEqual(3, response.Quotient);
-                Assert.AreEqual(1, response.Remainder);
-            }).Wait();
+            DivReply response = await client.DivAsync(new DivArgs.Builder { Dividend = 10, Divisor = 3 }.Build());
+            Assert.AreEqual(3, response.Quotient);
+            Assert.AreEqual(1, response.Remainder);
         }
 
         [Test]
-        public void Fib()
+        public async Task Fib()
         {
-            Task.Run(async () =>
+            using (var call = client.Fib(new FibArgs.Builder { Limit = 6 }.Build()))
             {
-                using (var call = client.Fib(new FibArgs.Builder { Limit = 6 }.Build()))
-                {
-                    var responses = await call.ResponseStream.ToList();
-                    CollectionAssert.AreEqual(new List<long> { 1, 1, 2, 3, 5, 8 },
-                        responses.ConvertAll((n) => n.Num_));
-                }
-            }).Wait();
+                var responses = await call.ResponseStream.ToList();
+                CollectionAssert.AreEqual(new List<long> { 1, 1, 2, 3, 5, 8 },
+                    responses.ConvertAll((n) => n.Num_));
+            }
         }
 
         [Test]
-        public void FibWithCancel()
+        public async Task FibWithCancel()
         {
-            Task.Run(async () =>
+            var cts = new CancellationTokenSource();
+
+            using (var call = client.Fib(new FibArgs.Builder { Limit = 0 }.Build(), 
+                cancellationToken: cts.Token))
             {
-                var cts = new CancellationTokenSource();
+                List<long> responses = new List<long>();
 
-                using (var call = client.Fib(new FibArgs.Builder { Limit = 0 }.Build(), 
-                    cancellationToken: cts.Token))
+                try
                 {
-                    List<long> responses = new List<long>();
-
-                    try
+                    while (await call.ResponseStream.MoveNext())
                     {
-                        while (await call.ResponseStream.MoveNext())
+                        if (responses.Count == 0)
                         {
-                            if (responses.Count == 0)
-                            {
-                                cts.CancelAfter(500);  // make sure we cancel soon
-                            }
-                            responses.Add(call.ResponseStream.Current.Num_);
+                            cts.CancelAfter(500);  // make sure we cancel soon
                         }
-                        Assert.Fail();
-                    }
-                    catch (RpcException e)
-                    {
-                        Assert.IsTrue(responses.Count > 0);
-                        Assert.AreEqual(StatusCode.Cancelled, e.Status.StatusCode);
+                        responses.Add(call.ResponseStream.Current.Num_);
                     }
+                    Assert.Fail();
+                }
+                catch (RpcException e)
+                {
+                    Assert.IsTrue(responses.Count > 0);
+                    Assert.AreEqual(StatusCode.Cancelled, e.Status.StatusCode);
                 }
-            }).Wait();
+            }
         }
 
         [Test]
-        public void FibWithDeadline()
+        public async Task FibWithDeadline()
         {
-            Task.Run(async () =>
+            using (var call = client.Fib(new FibArgs.Builder { Limit = 0 }.Build(), 
+                deadline: DateTime.UtcNow.AddMilliseconds(500)))
             {
-                using (var call = client.Fib(new FibArgs.Builder { Limit = 0 }.Build(), 
-                    deadline: DateTime.UtcNow.AddMilliseconds(500)))
+                try
                 {
-                    try
-                    {
-                        await call.ResponseStream.ToList();
-                        Assert.Fail();
-                    }
-                    catch (RpcException e)
-                    {
-                        Assert.AreEqual(StatusCode.DeadlineExceeded, e.Status.StatusCode);
-                    }
+                    await call.ResponseStream.ToList();
+                    Assert.Fail();
+                }
+                catch (RpcException e)
+                {
+                    Assert.AreEqual(StatusCode.DeadlineExceeded, e.Status.StatusCode);
                 }
-            }).Wait();
+            }
         }
 
         // TODO: test Fib with limit=0 and cancellation
         [Test]
-        public void Sum()
+        public async Task Sum()
         {
-            Task.Run(async () =>
+            using (var call = client.Sum())
             {
-                using (var call = client.Sum())
-                {
-                    var numbers = new List<long> { 10, 20, 30 }.ConvertAll(
-                             n => Num.CreateBuilder().SetNum_(n).Build());
+                var numbers = new List<long> { 10, 20, 30 }.ConvertAll(
+                            n => Num.CreateBuilder().SetNum_(n).Build());
 
-                    await call.RequestStream.WriteAll(numbers);
-                    var result = await call.ResponseAsync;
-                    Assert.AreEqual(60, result.Num_);
-                }
-            }).Wait();
+                await call.RequestStream.WriteAll(numbers);
+                var result = await call.ResponseAsync;
+                Assert.AreEqual(60, result.Num_);
+            }
         }
 
         [Test]
-        public void DivMany()
+        public async Task DivMany()
         {
-            Task.Run(async () =>
+            var divArgsList = new List<DivArgs>
             {
-                var divArgsList = new List<DivArgs>
-                {
-                    new DivArgs.Builder { Dividend = 10, Divisor = 3 }.Build(),
-                    new DivArgs.Builder { Dividend = 100, Divisor = 21 }.Build(),
-                    new DivArgs.Builder { Dividend = 7, Divisor = 2 }.Build()
-                };
+                new DivArgs.Builder { Dividend = 10, Divisor = 3 }.Build(),
+                new DivArgs.Builder { Dividend = 100, Divisor = 21 }.Build(),
+                new DivArgs.Builder { Dividend = 7, Divisor = 2 }.Build()
+            };
 
-                using (var call = client.DivMany())
-                {
-                    await call.RequestStream.WriteAll(divArgsList);
-                    var result = await call.ResponseStream.ToList();
+            using (var call = client.DivMany())
+            {
+                await call.RequestStream.WriteAll(divArgsList);
+                var result = await call.ResponseStream.ToList();
 
-                    CollectionAssert.AreEqual(new long[] { 3, 4, 3 }, result.ConvertAll((divReply) => divReply.Quotient));
-                    CollectionAssert.AreEqual(new long[] { 1, 16, 1 }, result.ConvertAll((divReply) => divReply.Remainder));
-                }
-            }).Wait();
+                CollectionAssert.AreEqual(new long[] { 3, 4, 3 }, result.ConvertAll((divReply) => divReply.Quotient));
+                CollectionAssert.AreEqual(new long[] { 1, 16, 1 }, result.ConvertAll((divReply) => divReply.Remainder));
+            }
         }
     }
 }