容器事件

一个实例的创建，首先是创建一个实例对象，然后对这个实例对象的属性、变量、方法进行依赖注入，最后对此实例进行动态代理
容器有一些事件，可以允许用户在容器不同阶段执行一些自己的逻辑，或修改注入的内容。这些事件包括：

OnBeforeCreateInstance 创建实例前
OnAfterCreateInstance 创建实例后
OnBeforeInject 依赖注入前
OnAfterInject 依赖注入后
OnBeforeProxy 创建代理前
OnAfterProxy 创建代理后

[Include]
public class Program
{

    /// <summary>
    /// 默认注入最高版本
    /// </summary>
    [AutoAssemble]
    private static UserController controller;

    static void Main(string[] args)
    {
        AsDIContext.Container.OnBeforeCreateInstance += Container_OnBeforeCreateInstance;
        AsDIContext.Container.OnAfterCreateInstance += Container_OnAfterCreateInstance;
        AsDIContext.Container.OnBeforeInject += Container_OnBeforeInject;
        AsDIContext.Container.OnAfterInject += Container_OnAfterInject;
        AsDIContext.Container.OnBeforeProxy += Container_OnBeforeProxy;
        AsDIContext.Container.OnAfterProxy += Container_OnAfterProxy;

        AsDIContext.Start();
        controller.Print();

    }

    private static object Container_OnBeforeCreateInstance(TypeObject arg)
    {
        Console.WriteLine("开始创建实例，类型为【" + arg.BaseType.Name + "】");
        return null;
    }
    private static object Container_OnAfterCreateInstance(TypeObject arg, object arg2)
    {
        Console.WriteLine("完成创建实例，类型为【" + arg.BaseType.Name + "】，实例类型为：" + arg2?.GetType().Name);
        return null;
    }

    private static void Container_OnBeforeInject(TypeObject arg1, object arg2)
    {
        Console.WriteLine("开始依赖注入，类型为【" + arg1.BaseType.Name + "】");
    }
    private static void Container_OnAfterInject(TypeObject arg1, object arg2)
    {
        Console.WriteLine("结束依赖注入，类型为【" + arg1.BaseType.Name + "】");
    }

    private static void Container_OnBeforeProxy(TypeObject arg1, object arg2)
    {
        Console.WriteLine("开始动态代理，类型为【" + arg1.BaseType.Name + "】");
    }

    private static void Container_OnAfterProxy(TypeObject arg1, object arg2)
    {
        Console.WriteLine("结束动态代理，类型为【" + arg1.BaseType.Name + "】");
    }

}

[Service]
public class UserController
{
    [AutoAssemble]
    private IUserService user;

    public void Print()
    {
        Console.WriteLine("Hello " +user.GetUserName());
    }
}

public interface IUserService
{
    string GetUserName();
}

[Service(1)]
public class UserService1 : IUserService
{
    public string GetUserName() => "Jack";
}

[Service(2)]
public class UserService2 : IUserService
{
    public string GetUserName() => "Lily";

}

以上代码执行后，输出：

> 开始创建实例，类型为【UserController】
> 开始依赖注入，类型为【UserController】
> 开始创建实例，类型为【IUserService】
> 开始创建实例，类型为【UserService2】
> 开始依赖注入，类型为【UserService2】
> 结束依赖注入，类型为【UserService2】
> 完成创建实例，类型为【UserService2】，实例类型为：UserService2
> 开始依赖注入，类型为【IUserService】
> 结束依赖注入，类型为【IUserService】
> 开始动态代理，类型为【IUserService】
> 结束动态代理，类型为【IUserService】
> 完成创建实例，类型为【IUserService】，实例类型为：UserService2
> 结束依赖注入，类型为【UserController】
> 完成创建实例，类型为【UserController】，实例类型为：UserController
> Lily

注意

这些事件对所有容器管理的类都有效，一旦需要特殊处理，请务必对类型就行判断，防止影响其它类型
BeforeCreateInstance 可以返回一个实例，一旦返回实例，则无论定义了什么实例化方式，一律不再执行，以此返回的实例为准。不过只是不再实例化，依赖注入和动态代理依然会执行
AfterCreateInstance 也可以返回一个实例，即可判断和修改容器实例化的对象，比如容器实例化后是null，则可以自己实例化或从其它方式获取
BeforeProxy 和 AfterProxy 仅对接口和抽象类有效，其它类型由于无法代理，将不会触发这两个事件

容器事件 ​

容器事件