using System;

using System.Collections.Generic;

using System.Linq;

using Unity;

using Unity.Injection;

using Unity.Interception;

using Unity.Interception.ContainerIntegration;

using Unity.Interception.InterceptionBehaviors;

using Unity.Interception.Interceptors.InstanceInterceptors.InterfaceInterception;

using Unity.Interception.PolicyInjection.Pipeline;

​

​

​

public class Program

{

    public static void Main()

    {

        var container = new UnityContainer();

        container.AddExtension(new Interception());

        var interceptors = new InjectionMember[]

        {

            new Interceptor<InterfaceInterceptor>(),

            new InterceptionBehavior<MethodInterceptor>()

        };

        container.RegisterType<IParent, Parent>();

        container.RegisterType<IChild, Child>(interceptors);

        container.RegisterType<IGrandChild, GrandChild>(interceptors);

​

​

        var parent = container.Resolve<IParent>();

        parent.AddChild();

        parent.AddChild();

        parent.AddChild();

        parent.AddChild();

        parent.Run();

        Console.WriteLine("Hello World");

    }

}

​

​

​

public interface IParent

{

    void AddChild();

    void Run();

}

​

public class Parent : IParent

{

    public Func<IChild> CreateChild { get; }

​

    public Parent(Func<IChild> createChild)

    {

        CreateChild = createChild;

    }

    private IList<IChild> Items = new List<IChild>();

​

    public void AddChild()

    {

        Items.Add(CreateChild());

    }

​

    public void Run()

    {

        foreach (var child in Items)

        {

            child.Run();

        }

    }

}

​

public interface IChild

{

    void Run();

}

​

public class Child : IChild

{

    public IGrandChild Grandchild { get; }

​

    public Child(IGrandChild grandchild)

    {

        Grandchild = grandchild;

    }

    public void Run()

    {

        Console.WriteLine("Child ran!");

        Grandchild.Run();

    }

}

​

public interface IGrandChild

{

    void Run();

}

​

public class GrandChild : IGrandChild

{

    public void Run()

    {

        throw new Exception("Wohoo!!!");

        Console.WriteLine("Grandchild ran!");

    }

}

​

​

public class MethodInterceptor : IInterceptionBehavior

{

    public IMethodReturn Invoke(IMethodInvocation input, GetNextInterceptionBehaviorDelegate getNext)

    {

        var target = input.Target.GetType().Name;

        var method = input.MethodBase.Name;

​

        // Printing before method run

        var old = Console.ForegroundColor;

        Console.ForegroundColor = ConsoleColor.Green;

        Console.WriteLine($"{target}.{method}");

        Console.ForegroundColor = old;

​

        // Run the actual method

        var result = getNext()(input, getNext);

        if (result.Exception != null)

        {

            Console.ForegroundColor = ConsoleColor.Red;

            Console.WriteLine($"{target}.{method} threw an exception: {result.Exception.Message}");

            Console.WriteLine(result.Exception.StackTrace);

            Console.ForegroundColor = old;

​

            // Change the result 

            // 1. Raise an exception

            //input.CreateExceptionMethodReturn();

​

            // 2. Swallow an exception:

            result = input.CreateMethodReturn(null);

        }

​

        // After method run

        return result;

    }

​

    public IEnumerable<Type> GetRequiredInterfaces()

    {

        return Type.EmptyTypes;

    }

​

    public bool WillExecute

    {

        get { return true; }

    }

}

​