Improve README.

Author: hypercodeplace

LazyProxy.Unity.Sample/Program.cs

@@ -19,10 +19,10 @@ private static void UnityExtensionExample1()
             var container = new UnityContainer()
                 .RegisterLazy<IMyService, MyService>();
 
-            Console.WriteLine("Resolving service...");
+            Console.WriteLine("Resolving the service...");
             var service = container.Resolve<IMyService>();
 
-            Console.WriteLine("Foo execution...");
+            Console.WriteLine("Executing the 'Foo' method...");
             service.Foo();
         }
 
@@ -56,4 +56,4 @@ private static void UnityExtensionExample2()
             }
         }
     }
-}
+}

LazyProxy.Unity.Sample/Services.cs

@@ -10,8 +10,8 @@ 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");
     }
 
     public abstract class Warrior
@@ -111,4 +111,4 @@ public Weapon CreateShuriken()
             return new Weapon(damage);
         }
     }
-}
+}

README.md

@@ -1,36 +1,63 @@
-# Lazy injection for Unity container
+# Lazy Dependency Injection for Unity Container
 
-A [LazyProxy](https://github.com/servicetitan/lazy-proxy) can be used for IoC containers to change the resolving behaviour.
+A [LazyProxy](https://github.com/servicetitan/lazy-proxy) can be used for IoC containers to improve performance by changing the resolve behavior.
 
-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.
+More info can be found in the article about [Lazy Dependency Injection for .NET](https://dev.to/hypercodeplace/lazy-dependency-injection-37en).
 
-Also dynamic lazy proxy allows injection of circular dependencies.
+## Get Packages
 
-```C#
+The library provides in NuGet.
+
+```
+Install-Package LazyProxy.Unity
+```
+
+## Get Started
+
+Consider the following service:
+
+```CSharp
+public interface IMyService
+{
+    void Foo();
+}
+
+public class MyService : IMyService
+{
+    public MyService() => Console.WriteLine("Ctor");
+    public void Foo() => Console.WriteLine("Foo");
+}
+```
+
+A lazy registration for this service can be added like this:
+
+```CSharp
 var container = new UnityContainer().RegisterLazy<IMyService, MyService>();
 
-Console.WriteLine("Resolving service...");
+Console.WriteLine("Resolving the service...");
 var service = container.Resolve<IMyService>();
 
-Console.WriteLine("Foo execution...");
+Console.WriteLine("Executing the 'Foo' method...");
 service.Foo();
+```
 
-// Resolving service...
-// Foo execution...
-// Hello from ctor
-// Hello from Foo
+The output for this example:
 
 ```
+Resolving the service...
+Executing the 'Foo' method...
+Ctor
+Foo
+```
+
+## Features
 
-The following is supported:
+Currently, `LazyProxy.Unity` supports the following:
 - Registration of types by interfaces;
 - Passing lifetime managers;
 - Passing injection members;
 - Resolving by child containers.
 
-**Not supported yet:**
-- Registration of instances.
-
 ## Performance
 
 Here is a result of the [Benchmark test](https://github.com/servicetitan/lazy-proxy-unity/blob/master/LazyProxy.Unity.Benchmarks/UnityExtensionBenchmark.cs)