docs: add English: add English documentation for AspectCore Framework

- Translate all Chinese documentation to English
- Add AOP introduction (0.AOP-Introduction.md)
- Add Getting Started guide (1.Getting-Started.md)
- Add IoC and dependency injection documentation (injector.md)
- Add reflection extensions documentation (reflection-extensions.md)
- Add reflection overview (reflection.md)

This addresses the community request for English documentation.

Author: liuhaoyang

docs/en/0.AOP-Introduction.md

@@ -0,0 +1,99 @@
+# 0. AOP Introduction
+
+## AOP Concepts
+
+Aspect-Oriented Programming (AOP is the abbreviation of Aspect Oriented Program). We know that the characteristics of object-oriented programming are inheritance, polymorphism, and encapsulation. Encapsulation requires distributing functionality to different objects, which is often referred to as responsibility allocation in software design. In practice, this means designing different methods for different classes. This way, code is distributed into individual classes. The benefit of this approach is that it reduces code complexity and makes classes reusable.
+
+However, people have also discovered that while dispersing code, it also increases code duplication. What does this mean? For example, in two classes, we might need to add logging to every method. According to object-oriented design methods, we would have to add logging content to the methods in both classes. Perhaps they are exactly the same, but because object-oriented design prevents direct connections between classes, we cannot unify these repetitive codes.
+
+Some might say, that's easy, we can write this code in an independent class and method, and then call it from both classes. However, this creates coupling between the two classes and our independent class. Changes to it would affect both classes. So, is there a way to allow us to add code freely when needed? The programming idea of dynamically injecting code into specified methods and positions of specified classes at runtime is called aspect-oriented programming.
+
+Generally speaking, the code fragment injected into specified classes and methods is called an aspect, while the specification of which classes and methods to inject into is called a pointcut. With AOP, we can extract code common to several classes into an aspect, and inject it into objects when needed, thereby changing their original behavior. From this perspective, AOP is actually just a supplement to OOP. OOP distinguishes individual classes horizontally, while AOP adds specific code to objects vertically. With AOP, OOP becomes three-dimensional. If we add the time dimension, AOP transforms OOP from two-dimensional to three-dimensional, from flat to立体. Technically speaking, AOP is basically implemented through proxy mechanisms.
+
+AOP can be said to be a milestone in programming history and is a very beneficial supplement to OOP programming.
+
+This section is excerpted from Zhihu - Discussion on AOP concepts: https://www.zhihu.com/question/24863332
+
+For those who want to understand AOP in detail, you can read the above [Zhihu link](https://www.zhihu.com/question/24863332)
+
+Or https://www.ibm.com/developerworks/cn/java/j-lo-springaopcglib/
+
+Or https://www.cnblogs.com/DjlNet/p/7603654.html
+
+I'll skip a detailed overview here for brevity.
+
+## AOP Implementation Methods
+
+AOP implementations often use common methods:
+
+* Using preprocessors (like preprocessors in C++) to add source code.
+* Using post-processors to add instructions on compiled binary code.
+* Using special compilers to add code at compile time.
+* Using code interceptors at runtime to intercept execution and add required code.
+
+However, the most common approaches are post-processing and code interception:
+
+* Post-processing, also called static weaving
+
+  This refers to using commands provided by the AOP framework to compile, thereby generating AOP proxy classes during the compilation phase, hence also called compile-time enhancement or static weaving.
+
+  In .NET, this is typically done at compile time by intercepting the compilation process through custom Build Tasks in MSBuild and inserting your own IL into the generated assembly.
+
+  .NET framework representative: [PostSharp](https://www.postsharp.net/aop.net)
+
+* Code interception, also called dynamic proxy, dynamic weaving, or code hijacking
+
+  This generates AOP dynamic proxy classes "temporarily" in memory at runtime, hence also called runtime enhancement or dynamic proxy.
+
+  In .NET, this is typically done at runtime using Emit technology to generate dynamic assemblies and dynamic proxy types to intercept target methods.
+
+  .NET framework representatives: [Castle DynamicProxy](https://github.com/castleproject/Core/blob/master/docs/dynamicproxy-introduction.md) and [AspectCore](https://github.com/dotnetcore/AspectCore-Framework)
+
+## Brief Overview of AspectCore's Dynamic Weaving
+
+Simply put, dynamic weaving is the creation of `proxy classes` for our actual business implementation classes at runtime.
+
+Through `proxy classes`, interceptor classes invisible to business logic code are called at runtime.
+
+Using an example from Castle DynamicProxy to illustrate:
+
+```csharp
+public class Interceptor : IInterceptor
+{
+    public void Intercept(IInvocation invocation)
+    {
+        Console.WriteLine("Before target call");
+        try
+        {
+           invocation.Proceed();
+        }
+        catch(Exception)
+        {
+           Console.WriteLine("Target threw an exception!");
+           throw;
+        }
+        finally
+        {
+           Console.WriteLine("After target call");
+        }
+    }
+}
+```
+
+This is an interceptor class.
+
+The purpose of dynamic weaving is to call `Interceptor` to "intercept" `IInvocation` through the `proxy class` without `IInvocation` knowing about this interceptor class.
+
+The following diagram shows the call example:
+
+![](https://github.com/castleproject/Core/raw/master/docs/images/proxy-pipeline.png)
+
+The blue area is the proxy class area. To the outside world, it looks like a proxed object.
+
+But in actual calls, as shown by the yellow arrow, it goes through layer after layer of interceptor classes before finally calling the proxed object.
+
+The return path is similar to the green arrow, going through layer after layer of interceptor classes.
+
+Ultimately achieving the purpose of dynamic proxy.
+
+Currently, AspectCore uses dynamic proxy as its AOP implementation rather than the theoretically more performant static weaving implementation. This is because I personally believe the dynamic proxy approach can achieve better IoC integration and can access more runtime metadata information in aspects. Moreover, after continuous optimization, AspectCore's dynamic proxy performance is not inferior to static weaving implementations.

docs/en/1.Getting-Started.md

@@ -0,0 +1,243 @@
+# 1. Getting Started
+
+Version 2.0.0 :arrow_up: (Simple code examples: https://github.com/cdcd72/NetCore.AspectCore.AOP.Demo)
+Version 2.0.0 :arrow_down: (Simple code examples: https://github.com/fs7744/AspectCoreDemo)
+
+## Start Using AspectCore
+
+* Launch Visual Studio. From the File menu, select New > Project. Select the ASP.NET Core Web Application project template to create a new ASP.NET Core Web Application project.
+
+* Install `AspectCore.Extensions.DependencyInjection` package from Nuget:
+    ```
+    PM>   Install-Package AspectCore.Extensions.DependencyInjection
+    ```
+* In general cases, you can use the abstract `AbstractInterceptorAttribute` to customize your attribute class, which implements the `IInterceptor` interface. AspectCore provides default interceptor configuration based on `Attribute`. Our custom interceptor looks like this:
+    ```csharp
+    public class CustomInterceptorAttribute : AbstractInterceptorAttribute
+    {
+        public async override Task Invoke(AspectContext context, AspectDelegate next)
+        {
+            try
+            {
+                Console.WriteLine("Before service call");
+                await next(context);
+            }
+            catch (Exception)
+            {
+                Console.WriteLine("Service threw an exception!");
+                throw;
+            }
+            finally
+            {
+                Console.WriteLine("After service call");
+            }
+        }
+    }
+    ```
+* Define the `ICustomService` interface and its implementation class `CustomService`:
+    ```csharp
+    public interface ICustomService
+    {
+        [CustomInterceptor]
+        void Call();
+    }
+
+    public class CustomService : ICustomService
+    {
+        public void Call()
+        {
+            Console.WriteLine("service calling...");
+        }
+    }
+    ```
+* Inject `ICustomService` in `HomeController`:
+    ```csharp
+    public class HomeController : Controller
+    {
+        private readonly ICustomService _service;
+        public HomeController(ICustomService service)
+        {
+            _service = service;
+        }
+
+        public IActionResult Index()
+        {
+            _service.Call();
+            return View();
+        }
+    }
+    ```
+* Register `ICustomService`, then configure the container to create proxy types in `ConfigureServices`:
+    ```csharp
+    public void ConfigureServices(IServiceCollection services)
+    {
+        services.AddTransient<ICustomService, CustomService>();
+        services.AddMvc();
+        services.ConfigureDynamicProxy();
+    }
+    ```
+* Finally, add `UseServiceProviderFactory(new DynamicProxyServiceProviderFactory())` to `Program`'s `CreateHostBuilder`:
+    ```csharp
+    public static IHostBuilder CreateHostBuilder(string[] args) =>
+            Host.CreateDefaultBuilder(args)
+                .ConfigureWebHostDefaultsDefaults(webBuilder =>
+                {
+                    webBuilder.UseStartup<Startup>();
+                })
+                // ...
+                .UseServiceProviderFactory(new DynamicProxyServiceProviderFactory());
+    ```
+
+---
+## Interceptor Configuration
+
+* Global interceptors. Use the `ConfigureDynamicProxy(Action<IAspectConfiguration>)` overload method, where `IAspectConfiguration` provides `Interceptors` to register global interceptors:
+    ```csharp
+    services.ConfigureDynamicProxy(config =>
+    {
+        config.Interceptors.AddTyped<CustomInterceptorAttribute>();
+    });
+    ```
+    Global interceptor with constructor parameters. Add a parameterized constructor in `CustomInterceptorAttribute`:
+    ```csharp
+    public class CustomInterceptorAttribute : AbstractInterceptorAttribute
+    {
+        private readonly string _name;
+        public CustomInterceptorAttribute(string name)
+        {
+            _name = name;
+        }
+        public async override Task Invoke(AspectContext context, AspectDelegate next)
+        {
+            try
+            {
+                Console.WriteLine("Before service call");
+                await next(context);
+            }
+            catch (Exception)
+            {
+                Console.WriteLine("Service threw an exception!");
+                throw;
+            }
+            finally
+            {
+                Console.WriteLine("After service call");
+            }
+        }
+    }
+    ```
+    Modify global interceptor registration:
+    ```csharp
+    services.ConfigureDynamicProxy(config =>
+    {
+        config.Interceptors.AddTyped<CustomInterceptorAttribute>(args: new object[] { "custom" });
+    });
+    ```
+    Global interceptor as a service. Add in `ConfigureServices`:
+    ```csharp
+    services.AddTransient<CustomInterceptorAttribute>(provider => new CustomInterceptorAttribute("custom"));
+    ```
+    Modify global interceptor registration:
+    ```csharp
+    services.ConfigureDynamicProxy(config =>
+    {
+        // Add registered service
+        config.Interceptors.AddServiced<CustomInterceptorAttribute>();
+    });
+    ```
+    Global interceptor targeting specific `Service` or `Method`. The following code demonstrates a global interceptor acting on classes ending with `Service`:
+    ```csharp
+    services.ConfigureDynamicProxy(config =>
+    {
+        config.Interceptors.AddTyped<CustomInterceptorAttribute>(method => method.Name.EndsWith("MethodName"));
+    });
+    ```
+    Specific global interceptor using wildcards:
+    ```csharp
+    services.ConfigureDynamicProxy(config =>
+    {
+        config.Interceptors.AddTyped<CustomInterceptorAttribute>(Predicates.ForService("*Service"));
+    });
+    ```
+
+* AspectCore provides `NonAspectAttribute` to make `Service` or `Method` not proxied:
+    ```csharp
+    [NonAspect]
+    public interface ICustomService
+    {
+        void Call();
+    }
+    ```
+    Also supports global ignore configuration and wildcards:
+    ```csharp
+    services.ConfigureDynamicProxy(config =>
+    {
+        // Services under App1 namespace won't be proxied
+        config.NonAspectPredicates.AddNamespace("App1");
+
+        // Services under namespaces where the last level is App1 won't be proxied
+        config.NonAspectPredicates.AddNamespace("*.App1");
+
+        // ICustomService interface won't be proxied
+        config.NonAspectPredicates.AddService("ICustomService");
+
+        // Interfaces and classes ending with Service won't be proxied
+        config.NonAspectPredicates.AddService("*Service");
+
+        // Methods named Query won't be proxied
+        config.NonAspectPredicates.AddMethod("Query");
+
+        // Methods ending with Query won't be proxied
+        config.NonAspectPredicates.AddMethod("*Query");
+    });
+    ```
+
+* Dependency injection in interceptors. Supports property injection, constructor injection, and service locator pattern in interceptors.
+
+    Property injection. In interceptors, mark properties with `public get and set` permissions with the `[AspectCore.DependencyInjection.FromServiceContextAttribute]` attribute to automatically inject the property:
+    ```csharp
+    public class CustomInterceptorAttribute : AbstractInterceptorAttribute
+    {
+        // ps: Property injection only works when using config.Interceptors.AddTyped<CustomInterceptorAttribute>();
+        //     It does not work with services.AddSingleton<CustomInterceptorAttribute>(); + services.ConfigureDynamicProxy(config => { config.Interceptors.AddServiced<CustomInterceptorAttribute>(); });
+        [FromServiceContext]
+        public ILogger<CustomInterceptorAttribute> Logger { get; set; }
+
+        public override Task Invoke(AspectContext context, AspectDelegate next)
+        {
+            Logger.LogInformation("call interceptor");
+            return next(context);
+        }
+    }
+    ```
+    Constructor injection requires the interceptor to be a `Service`. Besides global interceptors, you can still use `ServiceInterceptor` to make interceptors activated from DI:
+
+    ```csharp
+    public class CustomInterceptorAttribute : AbstractInterceptorAttribute
+    {
+        private readonly ILogger<CustomInterceptor> ctorlogger;
+
+        // ps: When globally configured with config.Interceptors.AddTyped<CustomInterceptorAttribute>(), constructor injection cannot be automatically injected, needs manual handling
+        //      Only works with services.AddSingleton<CustomInterceptorAttribute>(); + services.ConfigureDynamicProxy(config => { config.Interceptors.AddServiced<CustomInterceptorAttribute>(); });
+        public CustomInterceptor(ILogger<CustomInterceptor> ctorlogger)
+        {
+            this.ctorlogger = ctorlogger;
+        }
+    }
+    ```
+
+    Service locator pattern. The interceptor context `AspectContext` can get the current scoped `ServiceProvider`:
+    ```csharp
+    public class CustomInterceptorAttribute : AbstractInterceptorAttribute
+    {
+        public override Task Invoke(AspectContext context, AspectDelegate next)
+        {
+            var logger = context.ServiceProvider.GetService<ILogger<CustomInterceptorAttribute>>();
+            logger.LogInformation("call interceptor");
+            return next(context);
+        }
+    }
+    ```
+
+Version 2.0.0 :arrow_up: ps: Original text (https://www.thinkinmd.com/post/2020/03/20/use-aspectcore-to-implement-aop-mechanism/)
+Version 2.0.0 :arrow_down: ps: Original text (http://www.cnblogs.com/liuhaoyang/p/aspectcore-introduction-1.html)