Merge pull request #11 from servicetitan/readme-improvements

Readme improvements

Author: hypercodeplace

LazyProxy.Sample/Program.cs

@@ -6,14 +6,14 @@ internal class Program
     {
         public static void Main(string[] args)
         {
-            var proxy = LazyProxyBuilder.CreateInstance<IMyService>(() =>
+            var lazyProxy = LazyProxyBuilder.CreateInstance<IMyService>(() =>
             {
-                Console.WriteLine("The real instance creation...");
+                Console.WriteLine("Creating an instance of the real service...");
                 return new MyService();
             });
 
-            Console.WriteLine("Foo execution...");
-            proxy.Foo();
+            Console.WriteLine("Executing the 'Foo' method...");
+            lazyProxy.Foo();
         }
     }
-}
+}

LazyProxy.Sample/Services.cs

@@ -9,7 +9,7 @@ public interface IMyService
 
     public class MyService : IMyService
     {
-        public MyService() => Console.WriteLine("Hello from ctor");
-        public void Foo() => Console.WriteLine("Hello from Foo");
+        public MyService() => Console.WriteLine("Ctor");
+        public void Foo() => Console.WriteLine("Foo");
     }
-}
+}

README.md

@@ -1,37 +1,84 @@
-# Dynamic Lazy Proxy
+# LazyProxy
 
-A dynamic lazy proxy is a class built in real time, that implemenets some interface `T`, takes to the constructor an argument `Lazy<T>` and routes all invocations to the corresponding method or property of this argument.
+`LazyProxy` is a lightweight library allowing to build a lazy proxy type for some interface `T` at runtime. The proxy type implements this interface and is initialized by the `Lazy<T>` argument. All method and property invocations route to the corresponding members of the lazy's `Value`.
 
-The real instance wrapped by `Lazy<T>` is created only after the first invocation of method or property. It allows to distribute the loading from the class creation to the method or property invocation.
+For illustration, assume there is the following interface:
 
-```C#
+```CSharp
 public interface IMyService
 {
-	void Foo();
+    void Foo();
+}
+```
+
+Then the generated lazy proxy type looks like this:
+
+```CSharp
+// In reality, the implementation is a little more complicated,
+// but the details are omitted for ease of understanding.
+public class LazyProxyImpl_IMyService : IMyService
+{
+    private Lazy<IMyService> _service;
+
+    public LazyProxyImpl_IMyService(Lazy<IMyService> service)
+    {
+        _service = service;
+    }
+
+    public void Foo() => _service.Value.Foo();
+}
+```
+
+## Get Packages
+
+The library provides in NuGet.
+
+```
+Install-Package LazyProxy
+```
+
+## Get Started
+
+Consider the following service:
+
+```CSharp
+public interface IMyService
+{
+    void Foo();
 }
 
 public class MyService : IMyService
 {
-	public MyService() => Console.WriteLine("Hello from ctor");
-	public void Foo() => Console.WriteLine("Hello from Foo");
+    public MyService() => Console.WriteLine("Ctor");
+    public void Foo() => Console.WriteLine("Foo");
 }
+```
 
-var proxy = LazyProxyBuilder.CreateLazyProxyInstance<IMyService>(() =>
+A lazy proxy instance for this service can be created like this:
+
+```CSharp
+var lazyProxy = LazyProxyBuilder.CreateInstance<IMyService>(() =>
 {
-	Console.WriteLine("The real instance creation...");
-	return new MyService();
+    Console.WriteLine("Creating an instance of the real service...");
+    return new MyService();
 });
 
-Console.WriteLine("Foo execution...");
-proxy.Foo();
+Console.WriteLine("Executing the 'Foo' method...");
+lazyProxy.Foo();
+```
+
+The output for this example:
 
-// Foo execution...
-// The real instance creation...
-// Hello from ctor
-// Hello from Foo
 ```
+Executing the 'Foo' method...
+Creating an instance of the real service...
+Ctor
+Foo
+```
+
+## Features
 
-The following is supported:
+Currently, `LazyProxy` supports the following:
 - Void/Result methods;
 - Async methods;
 - Generic methods;
@@ -46,13 +93,11 @@ The following is supported:
 **Not supported yet:**
 - Events
 
-## Lazy injection for IoC containers
-
-A dynamic lazy proxy can be used for IoC containers to change the resolving behaviour.
+## Lazy Dependency Injection
 
-Dependencies registered as lazy are created as dynamic proxy objects built in real time, but the real classes are resolved only after the first execution of proxy method or property.
+Lazy proxies can be used for IoC containers to improve performance by changing resolution behavior.
 
-Also dynamic lazy proxy allows injection of circular dependencies.
+More info can be found in the article about [Lazy Dependency Injection for .NET](https://dev.to/hypercodeplace/lazy-dependency-injection-37en).
 
 [Lazy injection for Unity container](https://github.com/servicetitan/lazy-proxy-unity)