#12 Add examples to README

README.md

@@ -115,8 +115,47 @@ Shim structShim = Shim.Replace(() => Is.A<MyStruct>().DoSomething()).With(
 
 _Note: You cannot shim methods on specific instances of Value Types_
 
+### Shim static async method
+```csharp
+using Pose;
+
+Shim staticTaskShim = Shim.Replace(() => DoWorkAsync()).With(
+    delegate
+    {
+        Console.Write("refusing to do work");
+        return Task.CompletedTask;
+    });
+```
+### Shim async instance method of a Reference Type
+```csharp
+using Pose;
+
+Shim instanceTaskShim = Shim.Replace(() => Is.A<MyClass>().DoSomethingAsync()).With(
+    delegate(MyClass @this)
+    {
+        Console.WriteLine("doing something else async");
+        return Task.CompletedTask;
+    });
+```
+
+### Shim method of specific instance of a Reference Type
+_Not supported for now. When supported, however, it will look like the following._
+
+```csharp
+using Pose;
+
+MyClass myClass = new MyClass();
+Shim myClassTaskShim = Shim.Replace(() => myClass.DoSomethingAsync()).With(
+    delegate(MyClass @this)
+    {
+        Console.WriteLine("doing something else with myClass async");
+        return Task.CompletedTask;
+    });
+```
+
 ### Isolating your code
 
+#### Non-async
 ```csharp
 // This block executes immediately
 PoseContext.Isolate(() =>
@@ -139,6 +178,25 @@ PoseContext.Isolate(() =>
 }, consoleShim, dateTimeShim, classPropShim, classShim, myClassShim, structShim);
 ```
 
+#### Async
+```csharp
+// This block executes immediately
+await PoseContext.Isolate(async () =>
+{
+    // All code that executes within this block
+    // is isolated and shimmed methods are replaced
+
+    // Outputs "refusing to do work"
+    await DoWorkAsync();
+
+    // Outputs "doing something else async"
+    new MyClass().DoSomethingAsync();
+
+    // Outputs "doing something else with myClass async"
+    await myClass.DoSomethingAsync();
+
+}, staticTaskShim, instanceTaskShim, myClassTaskShim);
+```
 ## Caveats & Limitations
 
 * **Breakpoints** - At this time any breakpoints set anywhere in the isolated code and its execution path will not be hit. However, breakpoints set within a shim replacement delegate are hit.

src/Sandbox/Program.cs

@@ -7,71 +7,110 @@ namespace Pose.Sandbox
 {
     public class Program
     {
+        internal class MyClass
+        {
+            public async Task DoSomethingAsync() => await Task.CompletedTask;
+        }
+
         public static async Task<int> GetIntAsync()
         {
             Console.WriteLine("Here");
             return await Task.FromResult(1);
         }
+
+        public static async Task DoWorkAsync()
+        {
+            Console.WriteLine("Here");
+            await Task.Delay(1000);
+        }
 
-        public static void Main(string[] args)
+        public static async Task Main(string[] args)
         {
-#if NET48
-            Console.WriteLine("4.8");
-            var dateTimeShim = Shim.Replace(() => DateTime.Now).With(() => new DateTime(2004, 1, 1));
-            PoseContext.Isolate(
-                () =>
+            var staticAsyncShim = Shim.Replace(() => DoWorkAsync()).With(
+                delegate
                 {
-                    Console.WriteLine(DateTime.Now);
-                }, dateTimeShim);
-#elif NETCOREAPP2_0
-            Console.WriteLine("2.0");
-            //var dateTimeShim = Shim.Replace(() => DateTime.Now).With(() => new DateTime(2004, 1, 1));
-            var asyncShim = Shim.Replace(() => GetIntAsync()).With(() =>
-            {
-                Console.WriteLine("This actually works!!!");
-                return Task.FromResult(15);
-            });
-            PoseContext.Isolate(
+                    Console.Write("Don't do work!");
+                    return Task.CompletedTask;
+                });
+            var taskShim = Shim.Replace(() => Is.A<MyClass>().DoSomethingAsync())
+                .With(delegate(MyClass @this)
+                    {
+                        Console.WriteLine("Shimming async Task");
+                        return Task.CompletedTask;
+                    }
+                );
+            await PoseContext.Isolate(
                 async () =>
                 {
-                    var result = await GetIntAsync();
-                    Console.WriteLine($"Result: {result}");
-                    //Console.WriteLine(DateTime.Now);
-                }, asyncShim);
-#elif NET6_0
-            Console.WriteLine("6.0");
-            var dateTimeShim = Shim.Replace(() => DateTime.Now).With(() => new DateTime(2004, 1, 1));
-            PoseContext.Isolate(
-                () =>
-                {
-                    Console.WriteLine(DateTime.Now);
-                }, dateTimeShim);
-#elif NET7_0
-            Console.WriteLine("7.0");
+                    await DoWorkAsync();
+                }, staticAsyncShim
+            );
 
-            var dateTimeShim = Shim.Replace(() => DateTime.Now).With(() => new DateTime(2004, 1, 1));
-            PoseContext.Isolate(
-                () =>
-                {
-                    Console.WriteLine(DateTime.Now);
-                }, dateTimeShim);
-#elif NETCOREAPP3_0
-            Console.WriteLine("3.0");
-            var dateTimeShim = Shim.Replace(() => DateTime.Now).With(() => new DateTime(2004, 1, 1));
-            PoseContext.Isolate(
-                () =>
-                {
-                    Console.WriteLine(DateTime.Now);
-                }, dateTimeShim);
-#else
-            Console.WriteLine("Other");
-            var dateTimeShim = Shim.Replace(() => DateTime.Now).With(() => new DateTime(2004, 1, 1));
-            PoseContext.Isolate(
-                () =>
-                {
-                    Console.WriteLine(DateTime.Now);
-                }, dateTimeShim);
-#endif
+            // #if NET48
+//             Console.WriteLine("4.8");
+//             var dateTimeShim = Shim.Replace(() => DateTime.Now).With(() => new DateTime(2004, 1, 1));
+//             PoseContext.Isolate(
+//                 () =>
+//                 {
+//                     Console.WriteLine(DateTime.Now);
+//                 }, dateTimeShim);
+// #elif NETCOREAPP2_0
+//             Console.WriteLine("2.0");
+//             var asyncVoidShim = Shim.Replace(() => DoWorkAsync())
+//                 .With(
+//                     () =>
+//                     {
+//                         Console.WriteLine("Shimming async Task");
+//                         return Task.CompletedTask;
+//                     }
+//                 );
+//             //var dateTimeShim = Shim.Replace(() => DateTime.Now).With(() => new DateTime(2004, 1, 1));
+//             var asyncShim = Shim.Replace(() => GetIntAsync()).With(() =>
+//             {
+//                 Console.WriteLine("This actually works!!!");
+//                 return Task.FromResult(15);
+//             });
+//             PoseContext.Isolate(
+//                 async () =>
+//                 {
+//                     var result = await GetIntAsync();
+//                     Console.WriteLine($"Result: {result}");
+//                     //Console.WriteLine(DateTime.Now);
+//                 }, asyncShim);
+// #elif NET6_0
+//             Console.WriteLine("6.0");
+//             var dateTimeShim = Shim.Replace(() => DateTime.Now).With(() => new DateTime(2004, 1, 1));
+//             PoseContext.Isolate(
+//                 () =>
+//                 {
+//                     Console.WriteLine(DateTime.Now);
+//                 }, dateTimeShim);
+// #elif NET7_0
+//             Console.WriteLine("7.0");
+//
+//             var dateTimeShim = Shim.Replace(() => DateTime.Now).With(() => new DateTime(2004, 1, 1));
+//             PoseContext.Isolate(
+//                 () =>
+//                 {
+//                     Console.WriteLine(DateTime.Now);
+//                 }, dateTimeShim);
+// #elif NETCOREAPP3_0
+//             Console.WriteLine("3.0");
+//             var dateTimeShim = Shim.Replace(() => DateTime.Now).With(() => new DateTime(2004, 1, 1));
+//             PoseContext.Isolate(
+//                 () =>
+//                 {
+//                     Console.WriteLine(DateTime.Now);
+//                 }, dateTimeShim);
+// #else
+//             Console.WriteLine("Other");
+//             var dateTimeShim = Shim.Replace(() => DateTime.Now).With(() => new DateTime(2004, 1, 1));
+//             PoseContext.Isolate(
+//                 () =>
+//                 {
+//                     Console.WriteLine(DateTime.Now);
+//                 }, dateTimeShim);
+// #endif
 
             // var dateTimeShim = Shim.Replace(() => T.I).With(() => "L");
             // var dateTimeShim1 = Shim.Replace(() => T.Get()).With(() => "Word");